rod-rest 0.0.1.1 → 0.5.0

data/test/spec/client.rb

@@ -9,7 +9,7 @@ stub_class 'Rod::Rest::ProxyFactory'
 module Rod
   module Rest
     describe Client do
-      let(:factory_class) { stub!.new([resource1],is_a(Client)) { factory }.subject }
+      let(:factory_class) { stub!.new([resource1],is_a(Client),is_a(Hash)) { factory }.subject }
       let(:factory)       { Object.new }
       let(:metadata)      { stub!.resources { [resource1] }.subject }
       let(:resource1)     { resource = stub!.name { resource_name }.subject
@@ -23,9 +23,11 @@ module Rod
       let(:car_type)      { resource_name }
       let(:response)      { stub!.status{ 200 }.subject }
       let(:web_client)    { Object.new }
+      let(:proxy_cache)   { nil }
 
       describe "without metadata provided to the client" do
-        let(:client)                { Client.new(http_client: web_client,metadata_factory: metadata_factory, factory: factory_class) }
+        let(:client)                { Client.new(http_client: web_client,metadata_factory: metadata_factory, factory: factory_class,
+                                      proxy_cache: proxy_cache) }
         let(:metadata_factory)      { stub!.new(description: metadata_description) { metadata }.subject }
         let(:metadata_description)  { "{}" }
 
@@ -39,9 +41,9 @@ module Rod
         end
 
         describe "when fetching the data via the API" do
-          let(:json_cars_count)   { { count: 3 }.to_json }
+          let(:cars_count_json)   { { count: 3 }.to_json }
           let(:cars_response)     { response = stub!.status { 200 }.subject
-                                    stub(response).body { json_cars_count }
+                                    stub(response).body { cars_count_json }
                                     response
           }
 
@@ -56,18 +58,18 @@ module Rod
       end
 
       describe "with metadata provided to the client" do
-        let(:client)        { Client.new(http_client: web_client,metadata: metadata, factory: factory_class) }
+        let(:client)        { Client.new(http_client: web_client,metadata: metadata, factory: factory_class, proxy_cache: proxy_cache) }
 
         let(:invalid_id)    { 1000 }
         let(:invalid_index) { 2000 }
         let(:invalid_response) { stub!.status{ 404 }.subject }
 
         describe "#cars_count" do
-          let(:json_cars_count)   { { count: 3 }.to_json }
+          let(:cars_count_json)   { { count: 3 }.to_json }
 
           before do
             stub(web_client).get("/cars") { response }
-            stub(response).body { json_cars_count }
+            stub(response).body { cars_count_json }
           end
 
           it "returns the number of cars" do
@@ -75,51 +77,86 @@ module Rod
           end
         end
 
-        describe "with two cars defined" do
+        describe "with three cars defined" do
           let(:mercedes_300_id)   { 1 }
+          let(:mercedes_180_id)   { 2 }
+          let(:audi_a4_id)        { 3 }
           let(:mercedes_300_hash) { {rod_id: mercedes_300_id, type: car_type } }
-          let(:mercedes_180_hash) { {rod_id: 2, type: car_type } }
-          let(:mercedes_300_proxy){ Object.new }
-          let(:mercedes_180_proxy){ Object.new }
-          let(:factory)           { factory = stub!.build(mercedes_300_hash) { mercedes_300_proxy }.subject
-                                    stub(factory).build(mercedes_180_hash) { mercedes_180_proxy }
+          let(:mercedes_180_hash) { {rod_id: mercedes_180_id, type: car_type } }
+          let(:audi_a4_hash)      { {rod_id: audi_a4_id, type: car_type } }
+          let(:mercedes_300)      { mercedes = stub!.rod_id { mercedes_300_id }.subject
+                                    stub(mercedes).type { car_type }
+                                    mercedes
+          }
+          let(:mercedes_180)      { Object.new }
+          let(:audi_a4)           { Object.new }
+          let(:factory)           { factory = stub!.build(mercedes_300_hash) { mercedes_300 }.subject
+                                    stub(factory).build(mercedes_180_hash) { mercedes_180 }
+                                    stub(factory).build(audi_a4_hash) { audi_a4 }
                                     factory
           }
 
           describe "#find_cars_by_name(name)" do
             let(:car_name)          { "Mercedes" }
             let(:property_name)     { "name" }
-            let(:json_cars)         { [mercedes_300_hash,mercedes_180_hash].to_json }
+            let(:cars_json)         { [mercedes_300_hash,mercedes_180_hash].to_json }
             let(:indexed_properties){ [indexed_property] }
             let(:indexed_property)  { stub!.name { property_name }.subject }
 
             before do
               stub(web_client).get("/cars?#{property_name}=#{car_name}") { response }
-              stub(response).body { json_cars }
+              stub(response).body { cars_json }
             end
 
             it "finds the cars by their name" do
               cars = client.find_cars_by_name(car_name)
-              expected_cars = [mercedes_300_proxy,mercedes_180_proxy]
-              cars.size.should == expected_cars.size
-              cars.zip(expected_cars).each do |result,expected|
-                result.should == expected
-              end
+              expected_cars = [mercedes_300,mercedes_180]
+              cars.should == expected_cars
+            end
+          end
+
+          describe "#find_cars(1..3)" do
+            let(:cars_json)         { [mercedes_300_hash,mercedes_180_hash,audi_a4_hash].to_json }
+
+            before do
+              stub(web_client).get("/cars/#{mercedes_300_id}..#{audi_a4_id}") { response }
+              stub(response).body { cars_json }
+            end
+
+            it "returns range of cars" do
+              cars = client.find_cars(mercedes_300_id..audi_a4_id)
+              expected_cars = [mercedes_300,mercedes_180,audi_a4]
+              cars.should == expected_cars
+            end
+          end
+
+          describe "#find_cars(1,3)" do
+            let(:cars_json)         { [mercedes_300_hash,audi_a4_hash].to_json }
+
+            before do
+              stub(web_client).get("/cars/#{mercedes_300_id},#{audi_a4_id}") { response }
+              stub(response).body { cars_json }
+            end
+
+            it "returns collection of cars" do
+              cars = client.find_cars(mercedes_300_id,audi_a4_id)
+              expected_cars = [mercedes_300,audi_a4]
+              cars.should == expected_cars
             end
           end
 
           describe "with car response defined" do
-            let(:json_mercedes_300) { mercedes_300_hash.to_json }
+            let(:mercedes_300_json) { mercedes_300_hash.to_json }
 
             before do
               stub(web_client).get("/cars/#{mercedes_300_id}") { response }
               stub(web_client).get("/cars/#{invalid_id}") { invalid_response }
-              stub(response).body { json_mercedes_300 }
+              stub(response).body { mercedes_300_json }
             end
 
             describe "#find_car(rod_id)" do
               it "finds the car by its rod_id" do
-                client.find_car(mercedes_300_id).should == mercedes_300_proxy
+                client.find_car(mercedes_300_id).should == mercedes_300
               end
 
               it "raises MissingResource exception for invalid car rod_id" do
@@ -134,7 +171,7 @@ module Rod
               let(:invalid_type)    { "InvalidType" }
 
               it "finds the car by its stub" do
-                client.fetch_object(car_stub).should == mercedes_300_proxy
+                client.fetch_object(car_stub).should == mercedes_300
               end
 
               it "raises MissingResource execption for invalid car rod_id" do
@@ -154,13 +191,13 @@ module Rod
 
             describe "#car_drivers_count(rod_id)" do
               let(:drivers_count)     { 3 }
-              let(:json_driver_count) { { count: drivers_count }.to_json }
+              let(:driver_count_json) { { count: drivers_count }.to_json }
 
 
               before do
                 stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}") { response }
                 stub(web_client).get("/cars/#{invalid_id}/#{association_name}") { invalid_response }
-                stub(response).body { json_driver_count }
+                stub(response).body { driver_count_json }
               end
 
               it "returns the number of car drivers" do
@@ -172,24 +209,33 @@ module Rod
               end
             end
 
-            describe "with reponse defined" do
+            describe "with drivers" do
               let(:schumaher_index)   { 0 }
+              let(:alonzo_index)      { 2 }
               let(:schumaher_hash)    { { rod_id: schumaher_id, name: "Schumaher", type: "Driver" } }
+              let(:kubica_hash)       { { rod_id: 3, name: "Kubica", type: "Driver" } }
+              let(:alonzo_hash)       { { rod_id: 4, name: "Alonzo", type: "Driver" } }
               let(:schumaher_json)    { schumaher_hash.to_json }
-              let(:schumaher_proxy)   { Object.new }
+              let(:kubica_json)       { kubica_hash.to_json }
+              let(:alonzo_json)       { schumaher_hash.to_json }
+              let(:schumaher)         { Object.new }
+              let(:kubica)            { Object.new }
+              let(:alonzo)            { Object.new }
               let(:schumaher_id)      { 1 }
 
               before do
+                stub(factory).build(schumaher_hash) { schumaher }
+                stub(factory).build(kubica_hash) { kubica }
+                stub(factory).build(alonzo_hash) { alonzo }
                 stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}/#{schumaher_index}") { response }
                 stub(web_client).get("/cars/#{invalid_id}/#{association_name}/#{schumaher_index}") { invalid_response }
                 stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}/#{invalid_index}") { invalid_response }
                 stub(response).body { schumaher_json }
-                stub(factory).build(schumaher_hash) { schumaher_proxy }
               end
 
               describe "#car_driver(rod_id,index)" do
                 it "returns the driver" do
-                  client.car_driver(mercedes_300_id,schumaher_index).should == schumaher_proxy
+                  client.car_driver(mercedes_300_id,schumaher_index).should == schumaher
                 end
 
                 it "raises MissingResource exception for invalid car rod_id" do
@@ -201,6 +247,34 @@ module Rod
                 end
               end
 
+              describe "#car_drivers(subject,relation,0..2)" do
+                let(:drivers)         { [schumaher,kubica,alonzo] }
+                let(:collection_json) { [schumaher_hash,kubica_hash,alonzo_hash].to_json }
+
+                before do
+                  stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}/#{schumaher_index}..#{alonzo_index}") { response }
+                  stub(response).body { collection_json }
+                end
+
+                it "returns the collection of drivers" do
+                  client.car_drivers(mercedes_300_id,schumaher_index..alonzo_index).should == drivers
+                end
+              end
+
+              describe "#car_drivers(subject,relation,0,2)" do
+                let(:drivers) { [schumaher,alonzo] }
+                let(:collection_json) { [schumaher_hash,alonzo_hash].to_json }
+
+                before do
+                  stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}/#{schumaher_index},#{alonzo_index}") { response }
+                  stub(response).body { collection_json }
+                end
+
+                it "returns the collection of drivers" do
+                  client.car_drivers(mercedes_300_id,schumaher_index,alonzo_index).should == drivers
+                end
+              end
+
               describe "#fetch_related_object(subject,relation,index)" do
                 let(:association_name)        { "drivers" }
                 let(:invalid_association_name){ "owners" }
@@ -214,13 +288,8 @@ module Rod
                                                 proxy
                 }
 
-                before do
-                  stub(mercedes_300_proxy).rod_id { mercedes_300_id }
-                  stub(mercedes_300_proxy).type { car_type }
-                end
-
                 it "returns the driver" do
-                  client.fetch_related_object(mercedes_300_proxy,association_name,schumaher_index).should == schumaher_proxy
+                  client.fetch_related_object(mercedes_300,association_name,schumaher_index).should == schumaher
                 end
 
                 it "raises MissingResource exception for invalid car proxy id" do
@@ -228,7 +297,7 @@ module Rod
                 end
 
                 it "raises MissingResource exception for invalid index" do
-                  lambda { client.fetch_related_object(mercedes_300_proxy,association_name,invalid_index)}.should raise_exception(MissingResource)
+                  lambda { client.fetch_related_object(mercedes_300,association_name,invalid_index)}.should raise_exception(MissingResource)
                 end
 
                 it "raises APIError exception for invalid resource type" do
@@ -236,7 +305,37 @@ module Rod
                 end
 
                 it "raises APIError exception for invalid association name" do
-                  lambda { client.fetch_related_object(mercedes_300_proxy,invalid_association_name,schumaher_index)}.should raise_exception(APIError)
+                  lambda { client.fetch_related_object(mercedes_300,invalid_association_name,schumaher_index)}.should raise_exception(APIError)
+                end
+              end
+
+              describe "#fetch_related_objects(subject,relation,0..2)" do
+                let(:association_name)        { "drivers" }
+                let(:drivers)                 { [schumaher,kubica,alonzo] }
+                let(:collection_json)         { [schumaher_hash,kubica_hash,alonzo_hash].to_json }
+
+                before do
+                  stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}/#{schumaher_index}..#{alonzo_index}") { response }
+                  stub(response).body { collection_json }
+                end
+
+                it "returns drivers collection" do
+                  client.fetch_related_objects(mercedes_300,association_name,schumaher_index..alonzo_index).should == drivers
+                end
+              end
+
+              describe "#fetch_related_objects(subject,relation,0,2)" do
+                let(:association_name)        { "drivers" }
+                let(:drivers)                 { [schumaher,alonzo] }
+                let(:collection_json)         { [schumaher_hash,alonzo_hash].to_json }
+
+                before do
+                  stub(web_client).get("/cars/#{mercedes_300_id}/#{association_name}/#{schumaher_index},#{alonzo_index}") { response }
+                  stub(response).body { collection_json }
+                end
+
+                it "returns drivers collection" do
+                  client.fetch_related_objects(mercedes_300,association_name,schumaher_index,alonzo_index).should == drivers
                 end
               end
             end

data/test/spec/collection_proxy.rb

@@ -11,6 +11,34 @@ module Rod
       let(:size)              { 0 }
       let(:client)            { Object.new }
 
+      describe "#inspect" do
+        let(:car_type)        { "Car" }
+        before do
+          stub(mercedes_proxy).type { car_type }
+        end
+
+        it "reports the type of the proxy object" do
+          collection.inspect.should match(/#{car_type}/)
+        end
+
+        it "reports the name of the association" do
+          collection.inspect.should match(/#{association_name}/)
+        end
+
+        it "reports size of the collection" do
+          collection.inspect.should match(/#{size}/)
+        end
+      end
+
+      describe "#to_s" do
+        it "reports the size of the collection" do
+          collection.to_s.should match(/#{size}/)
+        end
+      end
+
+      describe "#to_s" do
+      end
+
       describe "#empty?" do
         describe "with 0 elements" do
           it "is empty" do
@@ -60,6 +88,29 @@ module Rod
             it "returns nil in case of out of bounds driver" do
               collection[5].should == nil
             end
+
+            it "caches retrieved objects" do
+              collection[1]
+              collection[1]
+              expect(client).to have_received.fetch_related_object(mercedes_proxy,association_name,1) { kubica }.once
+            end
+          end
+
+          describe "#[lower..upper]" do
+            before do
+              stub(client).fetch_related_objects(mercedes_proxy,association_name,0..2) { [schumaher,kubica,alonzo] }
+            end
+
+            it "returns drivers by index range" do
+              collection[0..2].should == [schumaher,kubica,alonzo]
+            end
+
+            it "caches retrieved objects" do
+              collection[0..2]
+              collection[1]
+              collection[1]
+              expect(client).to have_received.fetch_related_objects(mercedes_proxy,association_name,0..2).once
+            end
           end
 
           describe "#first" do
@@ -84,9 +135,7 @@ module Rod
 
           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 }
+              stub(client).fetch_related_objects(mercedes_proxy,association_name,0..2) { [schumaher,kubica,alonzo] }
             end
 
             it "iterates over the drivers" do

data/test/spec/metadata.rb

@@ -32,6 +32,30 @@ module Rod
         metadata.resources.first
         expect(resource_metadata_factory).to have_received.new(resource_name,resource_description)
       end
+
+      describe "#inspect" do
+        let(:data_description)  { "data description" }
+
+        before do
+          stub(description).inspect { data_description }
+        end
+
+        it "returns the description of the data" do
+          metadata.inspect.should match(/#{data_description}/)
+        end
+      end
+
+      describe "#to_s" do
+        let(:data_description)  { "data description" }
+
+        before do
+          stub(description).to_s { data_description }
+        end
+
+        it "returns the description of the data" do
+          metadata.to_s.should match(/#{data_description}/)
+        end
+      end
     end
   end
 end

data/test/spec/property_metadata.rb

@@ -6,6 +6,8 @@ module Rod
   module Rest
     describe PropertyMetadata do
       let(:property_metadata) { PropertyMetadata.new(name,options) }
+      let(:name)              { :age }
+      let(:options)           { { type: :integer } }
 
       describe "constructor" do
         it "forbids to create property without name" do
@@ -14,9 +16,6 @@ module Rod
       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
@@ -27,9 +26,6 @@ module Rod
       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
@@ -58,6 +54,35 @@ module Rod
           end
         end
       end
+
+      describe "#inspect" do
+        let(:options)       { { type: :string, index: index } }
+        let(:index)         { nil }
+
+        it "reports the name of the property" do
+          property_metadata.inspect.should match(/#{name}/)
+        end
+
+        context "without index" do
+          it "doesn't report that it is indexed" do
+            property_metadata.inspect.should_not match(/indexed/)
+          end
+        end
+
+        context "with index" do
+          let(:index)     { :hash }
+
+          it "reports that it is indexed" do
+            property_metadata.inspect.should match(/indexed/)
+          end
+        end
+      end
+
+      describe "#to_s" do
+        it "reports the name of the property" do
+          property_metadata.to_s.should match(/#{name}/)
+        end
+      end
     end
   end
 end