rod-rest 0.0.1

data/test/spec/collection_proxy.rb

@@ -0,0 +1,109 @@
+require 'bundler/setup'
+require_relative 'test_helper'
+require 'rod/rest/collection_proxy'
+
+module Rod
+  module Rest
+    describe CollectionProxy do
+      let(:collection)        { CollectionProxy.new(mercedes_proxy,association_name,size,client) }
+      let(:mercedes_proxy)    { Object.new }
+      let(:association_name)  { "drivers" }
+      let(:size)              { 0 }
+      let(:client)            { Object.new }
+
+      describe "#empty?" do
+        describe "with 0 elements" do
+          it "is empty" do
+            collection.empty?.should == true
+          end
+        end
+
+        describe "with 1 element" do
+          let(:size)          { 1 }
+
+          it "is not empty" do
+            collection.empty?.should == false
+          end
+        end
+      end
+
+      describe "#size" do
+        describe "with 5 elements" do
+          let(:size)      { 5 }
+
+          it "has size of 5" do
+            collection.size.should == size
+          end
+        end
+      end
+
+      describe "with car proxy" do
+        let(:car_type)          { "Car" }
+        let(:mercedes_300_id)   { 1 }
+
+        describe "with 3 drivers" do
+          let(:size)        { 3 }
+          let(:schumaher)   { Object.new }
+          let(:kubica)      { Object.new }
+          let(:alonzo)      { Object.new }
+
+          describe "#[index]" do
+            before do
+              stub(client).fetch_related_object(mercedes_proxy,association_name,1) { kubica }
+              stub(client).fetch_related_object(mercedes_proxy,association_name,5) { raise MissingResource.new("/cars/#{mercedes_300_id}/drivers/5") }
+            end
+
+            it "returns drivers by index" do
+              collection[1].should == kubica
+            end
+
+            it "returns nil in case of out of bounds driver" do
+              collection[5].should == nil
+            end
+          end
+
+          describe "#first" do
+            before do
+              stub(client).fetch_related_object(mercedes_proxy,association_name,0) { schumaher }
+            end
+
+            it "returns the first driver" do
+              collection.first.should == schumaher
+            end
+          end
+
+          describe "#last" do
+            before do
+              stub(client).fetch_related_object(mercedes_proxy,association_name,2) { alonzo }
+            end
+
+            it "returns the last driver" do
+              collection.last.should == alonzo
+            end
+          end
+
+          describe "#each" do
+            before do
+              stub(client).fetch_related_object(mercedes_proxy,association_name,0) { schumaher }
+              stub(client).fetch_related_object(mercedes_proxy,association_name,1) { kubica }
+              stub(client).fetch_related_object(mercedes_proxy,association_name,2) { alonzo }
+            end
+
+            it "iterates over the drivers" do
+              drivers = [schumaher,kubica,alonzo]
+              collection.each do |driver|
+                driver.should == drivers.shift
+              end
+              drivers.size.should == 0
+            end
+
+            it "allows to chain the calls" do
+              drivers = [schumaher,kubica,alonzo]
+              collection.each.map{|e| e }.should == drivers
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/spec/json_serializer.rb

@@ -0,0 +1,108 @@
+require 'bundler/setup'
+require_relative 'test_helper'
+require 'rod/rest/json_serializer'
+
+stub_class 'Rod::Model'
+
+module Rod
+  module Rest
+    describe JsonSerializer do
+      let(:serializer)            { JsonSerializer.new }
+      let(:object)                { object = stub!.class { resource }.subject
+                                    stub(object).rod_id { rod_id }
+                                    stub(object).is_a?(Rod::Model) { true }
+                                    object
+      }
+      let(:rod_id)                { 1 }
+      let(:type)                  { "Car" }
+      let(:resource)              { resource = stub!.fields { fields }.subject
+                                    stub(resource).singular_associations { singular_associations }
+                                    stub(resource).plural_associations { plural_associations }
+                                    stub(resource).to_s { type }
+                                    resource
+      }
+      let(:fields)                { [] }
+      let(:singular_associations) { [] }
+      let(:plural_associations)   { [] }
+      let(:result)                { JSON.parse(serializer.serialize(object),symbolize_names: true) }
+
+
+      describe "resource without properties" do
+        it "serializes its rod_id" do
+          result[:rod_id].should == rod_id
+        end
+
+        it "serializes its type" do
+          result[:type].should == type
+        end
+      end
+
+      describe "resource with name field" do
+        let(:fields)        { [name_field] }
+        let(:name_field)    { stub!.name { field_name }.subject }
+        let(:field_name)    { "brand" }
+        let(:brand)         { "Mercedes" }
+
+        before do
+          stub(object).brand { brand }
+        end
+
+        it "serializes its name field" do
+          result[:brand].should == brand
+        end
+      end
+
+      describe "resource with 'owner' singular association" do
+        let(:singular_associations) { [owner_association] }
+        let(:owner_association)     { stub!.name { owner_association_name }.subject }
+        let(:owner_association_name){ "owner" }
+        let(:owner)                 { owner = stub!.rod_id { owner_rod_id }.subject
+                                      stub(owner).class { owner_type }.subject
+                                      owner
+        }
+        let(:owner_rod_id)          { 10 }
+        let(:owner_type)            { "Person" }
+
+        describe "with existing owner" do
+          before do
+            stub(object).owner { owner }
+          end
+
+          it "serializes rod_id of the owner" do
+            result[:owner][:rod_id] == owner_rod_id
+          end
+
+          it "serializes type of the owner" do
+            result[:owner][:type] == owner_type
+          end
+        end
+
+        describe "without owner" do
+          before do
+            stub(object).owner { nil }
+          end
+
+          it "serializes the owner as nil" do
+            result[:owner].should == nil
+          end
+        end
+      end
+
+      describe "resource with 'drivers' plural association" do
+        let(:plural_associations)       { [drivers_association] }
+        let(:drivers_association)       { stub!.name { driver_association_name }.subject }
+        let(:driver_association_name)   { "drivers" }
+        let(:drivers)                   { stub!.size { drivers_count }.subject }
+        let(:drivers_count)             { 1 }
+
+        before do
+          stub(object).drivers { drivers }
+        end
+
+        it "serializes the number of associated objects" do
+          result[:drivers][:count].should == drivers_count
+        end
+      end
+    end
+  end
+end

data/test/spec/metadata.rb

@@ -0,0 +1,37 @@
+require 'bundler/setup'
+require_relative 'test_helper'
+require 'rod/rest/metadata'
+
+module Rod
+  module Rest
+    describe Metadata do
+      let(:metadata)                  { Metadata.new(description: description, parser: parser, resource_metadata_factory: resource_metadata_factory) }
+      let(:parser)                    { stub!.parse(description,is_a(Hash)) { hash_description }.subject }
+      let(:description)               { Object.new }
+      let(:hash_description)          { { resource_name => resource_description, "Rod" => rod_description } }
+      let(:resource_description)      { Object.new }
+      let(:rod_description)           { Object.new }
+      let(:resource_metadata_factory) { stub!.new(resource_name,resource_description) { resource_metadata }.subject }
+      let(:resource_metadata)         { Object.new }
+      let(:resource_name)             { "Resource" }
+
+      it "creates the metadata from the description" do
+        metadata.resources
+        expect(parser).to have_received.parse(description,is_a(Hash))
+      end
+
+      it "returns collection of resource descriptions" do
+        metadata.resources.should respond_to(:each)
+      end
+
+      it "skips Rod pseudo-resource description" do
+        metadata.resources.size.should == hash_description.size - 1
+      end
+
+      it "creates the metadata description using the metadata factory" do
+        metadata.resources.first
+        expect(resource_metadata_factory).to have_received.new(resource_name,resource_description)
+      end
+    end
+  end
+end

data/test/spec/property_metadata.rb

@@ -0,0 +1,63 @@
+require 'bundler/setup'
+require_relative 'test_helper'
+require 'rod/rest/property_metadata'
+
+module Rod
+  module Rest
+    describe PropertyMetadata do
+      let(:property_metadata) { PropertyMetadata.new(name,options) }
+
+      describe "constructor" do
+        it "forbids to create property without name" do
+          lambda { PropertyMetadata.new(nil,{}) }.should raise_error(ArgumentError)
+        end
+      end
+
+      describe "#name" do
+        let(:options)       { { type: :integer } }
+        let(:name)          { :age }
+
+        it "converts its name to string" do
+          property_metadata.name.should be_a(String)
+        end
+
+        it "returns the name of the poperty" do
+          property_metadata.name.should == name.to_s
+        end
+      end
+
+      describe "#symbolic_name" do
+        let(:options)       { { type: :string } }
+        let(:name)          { :name }
+
+        it "converts its symbolic name to string" do
+          property_metadata.symbolic_name.should be_a(Symbol)
+        end
+
+        it "returns the symbolic name of the poperty" do
+          property_metadata.symbolic_name.should == name.to_sym
+        end
+      end
+
+      describe "#indexed?" do
+        let(:options)       { { type: :string, index: index } }
+        let(:name)          { :brand }
+
+        describe "with index" do
+          let(:index) { :hash }
+
+          it "returns true" do
+            property_metadata.should be_indexed
+          end
+        end
+
+        describe "without index" do
+          let(:index) { nil }
+          it "returns false" do
+            property_metadata.should_not be_indexed
+          end
+        end
+      end
+    end
+  end
+end

data/test/spec/proxy.rb

@@ -0,0 +1,87 @@
+require 'bundler/setup'
+require_relative 'test_helper'
+require 'rod/rest/proxy'
+
+module Rod
+  module Rest
+    describe Proxy do
+      let(:proxy)               { Proxy.new(metadata,client,collection_proxy_factory: collection_proxy_factory) }
+      let(:metadata)            { metadata = stub!.fields { [id_field,name_field] }.subject
+                                  stub(metadata).singular_associations { [owner_association] }
+                                  stub(metadata).plural_associations { [drivers_association] }
+                                  stub(metadata).name { car_type }
+                                  metadata
+      }
+      let(:client)              { client = stub!.fetch_object(schumaher_hash) { schumaher_object }.subject }
+      let(:collection_proxy_factory) { stub!.new(anything,drivers_association_name,drivers_count,client) { collection_proxy }.subject }
+      let(:collection_proxy)    { Object.new }
+      let(:id_field)            { property = stub!.symbolic_name { :rod_id }.subject
+                                  stub(property).name { "rod_id" }
+                                  property
+      }
+      let(:name_field)          { property = stub!.symbolic_name { :name }.subject
+                                  stub(property).name { "name" }
+                                  property
+      }
+      let(:owner_association)   { property = stub!.symbolic_name { :owner }.subject
+                                  stub(property).name { "owner" }
+                                  property
+      }
+      let(:drivers_association) { property = stub!.symbolic_name { drivers_association_name.to_sym }.subject
+                                  stub(property).name { drivers_association_name }
+                                  property
+      }
+      let(:drivers_association_name)  { "drivers"}
+
+      let(:car_type)            { "Test::Car" }
+      let(:mercedes_300_hash)   { { rod_id: mercedes_300_id, name: mercedes_300_name, type: car_type,
+                                    owner: { rod_id: schumaher_id, type: person_type}, drivers: { count: drivers_count } } }
+      let(:mercedes_300_id)     { 1 }
+      let(:mercedes_300_name)   { "Mercedes 300" }
+
+      let(:person_type)         { "Test::Person" }
+      let(:drivers_count)       { 1 }
+      let(:schumaher_hash)      { { rod_id: schumaher_id, type: person_type } }
+      let(:schumaher_id)        { 2 }
+      let(:schumaher_object)    { Object.new }
+      let(:owner_object)        { schumaher_object }
+      let(:first_driver_object) { schumaher_object }
+
+      it "creates new instances" do
+        proxy.new(mercedes_300_hash).should_not == nil
+      end
+
+      it "refuses to create instances with missing rod_id" do
+        lambda { proxy.new({}) }.should raise_error(InvalidData)
+      end
+
+      it "refuses to create instances with missing type" do
+        lambda { proxy.new({rod_id: mercedes_300_id}) }.should raise_error(InvalidData)
+      end
+
+      describe "created instance" do
+        let(:mercedes_300)      { proxy.new(mercedes_300_hash) }
+
+        it "has a type" do
+          mercedes_300.type.should == car_type
+        end
+
+        it "has an id" do
+          mercedes_300.rod_id.should == mercedes_300_id
+        end
+
+        it "has a valid 'name' field" do
+          mercedes_300.name.should == mercedes_300_name
+        end
+
+        it "has an valid 'owner' singular association" do
+          mercedes_300.owner.should == owner_object
+        end
+
+        it "has a valid 'drivers' plural association" do
+          mercedes_300.drivers.should == collection_proxy
+        end
+      end
+    end
+  end
+end

data/test/spec/proxy_factory.rb

@@ -0,0 +1,44 @@
+require 'bundler/setup'
+require_relative 'test_helper'
+require 'rod/rest/proxy_factory'
+
+module Rod
+  module Rest
+    describe ProxyFactory do
+      let(:factory)           { ProxyFactory.new(metadata,client,proxy_class: proxy_class) }
+      let(:metadata)          { [car_metadata,person_metadata] }
+      let(:car_metadata)      { stub!.name { car_type }.subject }
+      let(:person_metadata)   { stub!.name { person_type }.subject }
+      let(:client)            { Object.new }
+      let(:car_type)          { "Car" }
+      let(:person_type)       { "Person" }
+      let(:unknown_type)      { "Unknown" }
+      let(:proxy_class)       { klass = stub!.new(car_metadata,client) { car_proxy_factory }.subject
+                                stub(klass).new(person_metadata,client) { person_proxy_factory }
+                                klass
+      }
+      let(:car_proxy_factory)     { stub!.new(mercedes_300_hash) { mercedes_300 }.subject }
+      let(:person_proxy_factory)  { stub!.new(schumaher_hash) { schumaher }.subject }
+      let(:mercedes_300_hash)     { { rod_id: mercedes_300_id, type: car_type } }
+      let(:schumaher_hash)        { { rod_id: schumaher_id, type: person_type } }
+      let(:unknown_hash)          { { rod_id: unknown_id, type: unknown_type } }
+      let(:mercedes_300_id)       { 1 }
+      let(:schumaher_id)          { 2 }
+      let(:unknown_id)            { 3 }
+      let(:mercedes_300)          { Object.new }
+      let(:schumaher)             { Object.new }
+
+      it "builds new car from hash" do
+        factory.build(mercedes_300_hash).should == mercedes_300
+      end
+
+      it "builds new person proxy from hash" do
+        factory.build(schumaher_hash).should == schumaher
+      end
+
+      it "raises UnknownResource for unknown resource type" do
+        lambda { factory.build(unknown_hash) }.should raise_error(UnknownResource)
+      end
+    end
+  end
+end