api_resource 0.6.21 → 0.6.22

data/spec/lib/conditions/pagination_condition_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+module ApiResource
+
+  module Conditions
+
+    describe PaginationCondition do
+
+      context '.paginate' do
+
+        it 'returns an object that knows it is paginated from the base
+          class' do
+          paginated = TestResource.paginate(page: 1, per_page: 10).active
+          expect(paginated).to be_paginated
+        end
+
+        it 'returns an object that knows it is paginated from a scope' do
+          paginated = TestResource.active.paginate(
+            page: 1,
+            per_page: 10
+          )
+          expect(paginated).to be_paginated
+        end
+
+      end
+
+      context '#current_page' do
+
+        it 'knows its page number' do
+          paginated = TestResource.paginate(page: 1, per_page: 10).active
+          expect(paginated.current_page).to be 1
+        end
+
+      end
+
+      context '#offset' do
+
+        it 'passes along the headers for the total number of entries' do
+          paginated = TestResource.paginate(
+            page: 2,
+            per_page: 10
+          )
+          expect(paginated.offset).to be 10
+        end
+
+      end
+
+      context '#per_page' do
+
+        it 'knows its number per page' do
+          paginated = TestResource.paginate(
+            page: 2,
+            per_page: 100
+          )
+          expect(paginated.per_page).to be 100
+        end
+
+      end
+
+      context '#total_entries' do
+
+        it 'passes along the headers for the total number of entries' do
+          paginated = TestResource.paginate(
+            page: 1,
+            per_page: 10
+          )
+          expect(paginated.total_entries).to be 100
+        end
+
+      end
+
+      context '#total_pages' do
+
+        it 'calculates the number of pages' do
+          paginated = TestResource.paginate(
+            page: 1,
+            per_page: 12
+          )
+          expect(paginated.total_pages).to be 9
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/finders/multi_object_association_finder_spec.rb

@@ -5,39 +5,67 @@ describe "MultiObjectAssociationFinder" do
 	before(:each) do
 		TestResource.reload_resource_definition
 	end
-	
-	it "should build a proper load path and call into the connection" do
-		TestResource.connection.expects(:get).with("test_resources.json?id[]=1&id[]=2").returns([])
-
-		ApiResource::Finders::MultiObjectAssociationFinder.new(
-			TestResource,
-			stub(:remote_path => "test_resources", :to_query => "id[]=1&id[]=2", :blank_conditions? => false)
-		).load
+
+	context "#load" do
+
+		it "should build a proper load path and call into the connection" do
+			TestResource.connection.expects(:get).with("test_resources.json?id[]=1&id[]=2").returns([])
+
+			ApiResource::Finders::MultiObjectAssociationFinder.new(
+				TestResource,
+				stub(remote_path: "test_resources", to_query: "id[]=1&id[]=2", :blank_conditions? => false)
+			).load
+		end
+
+		it "should load a has many association properly" do
+			# much of this test already lies in resource_finder_spec.rb
+			# this just verifies that the data is passed in correctly
+			finder = ApiResource::Finders::MultiObjectAssociationFinder.new(
+				TestResource,
+				stub(
+					remote_path: "test_resources",
+					blank_conditions?: true,
+					eager_load?: true,
+					included_objects: [:has_many_objects]
+				)
+			)
+
+			tr = TestResource.new
+			tr.stubs(:id).returns(1)
+			tr.stubs(:has_many_object_ids).returns([1,2])
+			TestResource.connection.expects(:get).with("test_resources.json").returns([4])
+			TestResource.expects(:instantiate_collection).with([4]).returns([tr])
+
+			finder.expects(:load_includes).with(has_many_objects: [1,2]).returns(5)
+			finder.expects(:apply_includes).with([tr], 5).returns(6)
+
+			finder.load.should eql([tr])
+		end
 	end
 
-	it "should load a has many association properly" do
-		# much of this test already lies in resource_finder_spec.rb
-		# this just verifies that the data is passed in correctly
-		finder = ApiResource::Finders::MultiObjectAssociationFinder.new(
-			TestResource,
-			stub(
-				:remote_path => "test_resources", 
-				:blank_conditions? => true,
-				:eager_load? => true, 
-				:included_objects => [:has_many_objects]
+	context "#select" do
+
+		it "properly sends #select to its internal object" do
+
+			TestResource.connection.stubs(:get)
+				.with("test_resources.json?id[]=1&id[]=2")
+				.returns([{"name" => "Dan"}])
+
+			finder = ApiResource::Finders::MultiObjectAssociationFinder.new(
+				TestResource,
+				stub(
+					remote_path: "test_resources",
+					to_query: "id[]=1&id[]=2",
+					blank_conditions?: false,
+					included_objects: [],
+					eager_load?: true
+				)
 			)
-		)
 
-		tr = TestResource.new
-		tr.stubs(:id).returns(1)
-		tr.stubs(:has_many_object_ids).returns([1,2])
-		TestResource.connection.expects(:get).with("test_resources.json").returns([4])
-		TestResource.expects(:instantiate_collection).with([4]).returns([tr])
+			expect(finder.select{|r| r.name == 'Dan'}.length).to eql(1)
 
-		finder.expects(:load_includes).with(:has_many_objects => [1,2]).returns(5)
-		finder.expects(:apply_includes).with([tr], 5).returns(6)
+		end
 
-		finder.load.should eql([tr])
 	end
 
 end

data/spec/lib/finders/resource_finder_spec.rb

@@ -4,7 +4,6 @@ describe "ResourceFinder" do
 
 	before(:each) do
 		TestResource.reload_resource_definition
-
 	end
 
 	it "should load normally without includes using connection.get" do
@@ -20,7 +19,7 @@ describe "ResourceFinder" do
 		TestResource.connection.expects(:get).with("/test_resources.json?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3")
 
 		ApiResource::Finders::ResourceFinder.new(
-			TestResource, 
+			TestResource,
 			mock(:to_hash => {:ids => [1,2,3]})
 		).load
 	end
@@ -75,4 +74,29 @@ describe "ResourceFinder" do
 		obj.second.has_many_objects.collect(&:id).should eql([2])
 	end
 
+	context 'Headers returned from the server' do
+
+		context '#total_entries' do
+
+			it 'stores the ApiResource-Total-Entries as total_entries' do
+
+				finder = ApiResource::Finders::ResourceFinder.new(
+					TestResource,
+					ApiResource::Conditions::PaginationCondition.new(
+						TestResource,
+						{ page: 2, per_page: 10 }
+					)
+				)
+
+				finder.load
+
+				expect(finder.total_entries).to be 100
+
+
+			end
+
+		end
+
+	end
+
 end

data/spec/lib/finders/single_object_association_finder_spec.rb

@@ -7,12 +7,20 @@ describe "SingleObjectAssociationFinder" do
 	end
 
 	it "should build a proper load path and call into the connection" do
-		TestResource.connection.expects(:get).with("test_resources.json?id[]=1&id[]=2").returns(nil)
+		TestResource.connection
+			.expects(:get)
+			.with("test_resources.json?id[]=1&id[]=2")
+			.returns(nil)
 
-		ApiResource::Finders::SingleObjectAssociationFinder.new(
+		finder = ApiResource::Finders::SingleObjectAssociationFinder.new(
 			TestResource,
-			stub(:remote_path => "test_resources", :to_query => "id[]=1&id[]=2", :blank_conditions? => false)
-		).load
+			stub(
+				:remote_path => "test_resources",
+				:to_query => "id[]=1&id[]=2",
+				:blank_conditions? => false
+			)
+		)
+		finder.load
 	end
 
 	it "should load a has many association properly" do
@@ -21,9 +29,9 @@ describe "SingleObjectAssociationFinder" do
 		finder = ApiResource::Finders::SingleObjectAssociationFinder.new(
 			TestResource,
 			stub(
-				:remote_path => "test_resources", 
+				:remote_path => "test_resources",
 				:blank_conditions? => true,
-				:eager_load? => true, 
+				:eager_load? => true,
 				:included_objects => [:has_many_objects]
 			)
 		)

data/spec/lib/finders_spec.rb

@@ -2,114 +2,114 @@ require 'spec_helper'
 
 describe ApiResource::Finders do
 
-	before(:each) do
-		TestResource.reload_resource_definition
-	end
+  before(:each) do
+    TestResource.reload_resource_definition
+  end
 
-	it "should be able to find a single object" do
-		TestResource.connection.expects(:get).with("/test_resources/1.json")
+  it "should be able to find a single object" do
+    TestResource.connection.expects(:get).with("/test_resources/1.json")
 
-		TestResource.find(1)
-	end
+    TestResource.find(1)
+  end
 
-	it "should be able to find with parameters, params syntax" do
-		TestResource.connection.expects(:get).with("/test_resources.json?active=true")
-		TestResource.all(:params => {:active => true})
-	end
+  it "should be able to find with parameters, params syntax" do
+    TestResource.connection.expects(:get).with("/test_resources.json?active=true")
+    TestResource.all(:params => {:active => true})
+  end
 
-	it "should be able to find with parameters without the params syntax" do
-		TestResource.connection.expects(:get).with("/test_resources.json?active=true&passive=false")
+  it "should be able to find with parameters without the params syntax" do
+    TestResource.connection.expects(:get).with("/test_resources.json?active=true&passive=false")
 
-		TestResource.all(:active => true, :passive => false)
-	end
+    TestResource.all(:active => true, :passive => false)
+  end
 
-	it "should be able to chain find on top of a scope" do
-		TestResource.connection.expects(:get).with("/test_resources.json?active=true&passive=true")
-		TestResource.active.all(:passive => true)
-	end
+  it "should be able to chain find on top of a scope" do
+    TestResource.connection.expects(:get).with("/test_resources.json?active=true&passive=true")
+    TestResource.active.all(:passive => true)
+  end
 
-	it "should be able to find a single object after a scope" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns([{"id" => 10}])
+  it "should be able to find a single object as an enumerable after a scope" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns([{"id" => 10}])
 
-		val = TestResource.birthday(5).find(1)
-		val.should be_a(TestResource)
-	end
+    val = TestResource.birthday(5).find(1)
+    val.first.should be_a(TestResource)
+  end
 
-	it "should be able to find multiple objects after a scope" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns([{"id" => 10}, {"id" => 8}])
+  it "should be able to find multiple objects after a scope" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns([{"id" => 10}, {"id" => 8}])
 
-		val = TestResource.birthday(5).find(1)
-		val.should be_a(Array)
-		val.first.should be_a(TestResource)
-	end
+    val = TestResource.birthday(5).find(1)
+    val.should be_a(Array)
+    val.first.should be_a(TestResource)
+  end
 
-	it "should be able to find the first/last object" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?first=true").returns([{"id" => 10}])
+  it "should be able to find the first/last object" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?first=true").returns([{"id" => 10}])
 
-		val = TestResource.first
-		val.should be_a(TestResource)
-	end
+    val = TestResource.first
+    val.should be_a(TestResource)
+  end
 
-	it "should pass first and last as params" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?first=true")
+  it "should pass first and last as params" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?first=true")
 
-		val = TestResource.first
+    val = TestResource.first
 
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?last=true")
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?last=true")
 
-		val = TestResource.last
-	end
+    val = TestResource.last
+  end
 
-	it "should not pass all as a param, even when all records are requested" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json")
+  it "should not pass all as a param, even when all records are requested" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json")
 
-		val = TestResource.all
-	end
+    val = TestResource.all
+  end
 
-	it "should be able to chain find on top of an includes call" do
-		TestResource.connection.expects(:get).with("/test_resources/1.json").returns({"id" => 1, "has_many_object_ids" => [1,2]})
-		HasManyObject.connection.expects(:get).with("/has_many_objects.json?ids%5B%5D=1&ids%5B%5D=2").returns([])
+  it "should be able to chain find on top of an includes call" do
+    TestResource.connection.expects(:get).with("/test_resources/1.json").returns({"id" => 1, "has_many_object_ids" => [1,2]})
+    HasManyObject.connection.expects(:get).with("/has_many_objects.json?ids%5B%5D=1&ids%5B%5D=2").returns([])
 
-		TestResource.includes(:has_many_objects).find(1)
-	end
+    TestResource.includes(:has_many_objects).find(1)
+  end
 
-	it "should be able to chain find on top of an includes call and a scope" do
-		TestResource.connection.expects(:get).with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns({"id" => 1, "has_many_object_ids" => [1,2]})
-		HasManyObject.connection.expects(:get).with("/has_many_objects.json?ids%5B%5D=1&ids%5B%5D=2").returns([])
+  it "should be able to chain find on top of an includes call and a scope" do
+    TestResource.connection.expects(:get).with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns({"id" => 1, "has_many_object_ids" => [1,2]})
+    HasManyObject.connection.expects(:get).with("/has_many_objects.json?ids%5B%5D=1&ids%5B%5D=2").returns([])
 
-		TestResource.includes(:has_many_objects).birthday(5).find(1)
-	end
+    TestResource.includes(:has_many_objects).birthday(5).find(1)
+  end
 
-	it "should disregard condition order" do
-		TestResource.connection.expects(:get).with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns({"id" => 1, "has_many_object_ids" => [1,2]})
-		HasManyObject.connection.expects(:get).with("/has_many_objects.json?ids%5B%5D=1&ids%5B%5D=2").returns([])
+  it "should disregard condition order" do
+    TestResource.connection.expects(:get).with("/test_resources.json?birthday%5Bdate%5D=5&find%5Bids%5D=1").returns({"id" => 1, "has_many_object_ids" => [1,2]})
+    HasManyObject.connection.expects(:get).with("/has_many_objects.json?ids%5B%5D=1&ids%5B%5D=2").returns([])
 
-		TestResource.birthday(5).includes(:has_many_objects).find(1)
-	end
+    TestResource.birthday(5).includes(:has_many_objects).find(1)
+  end
 
-	it "should be able to use a scope with arguments" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?active=true&birthday%5Bdate%5D=5").returns([{"id" => 10}])
+  it "should be able to use a scope with arguments" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?active=true&birthday%5Bdate%5D=5").returns([{"id" => 10}])
 
-		res = TestResource.active.birthday(5).all
-		res.should be_a(Array)
-		res.first.id.should eql(10)
-	end
+    res = TestResource.active.birthday(5).all
+    res.should be_a(Array)
+    res.first.id.should eql(10)
+  end
 
-	it "should be able to use a scope with multiple arguments" do
-		TestResource.connection.expects(:get)
-			.with("/test_resources.json?paginate%5Bcurrent_page%5D=10&paginate%5Bper_page%5D=5")
-			.returns([{:id => 20}])
+  it "should be able to use a scope with multiple arguments" do
+    TestResource.connection.expects(:get)
+      .with("/test_resources.json?boolean%5Ba%5D=5&boolean%5Bb%5D=10")
+      .returns([{:id => 20}])
 
-		res = TestResource.paginate(5, 10).all
-		res.should be_a(Array)
-		res.first.id.should eql(20)
-	end
+    res = TestResource.boolean(5, 10).all
+    res.should be_a(Array)
+    res.first.id.should eql(20)
+  end
 
 end

data/spec/lib/observing_spec.rb

@@ -77,16 +77,15 @@ describe "Observing" do
   end
 
   it "should run callbacks before observers" do
-    klass = Class.new(TestResource)
-    klass.class_eval <<-EOE, __FILE__, __LINE__ + 1
+    class ChildObserverResource < TestResource
       before_save :abort_save
 
       def abort_save
         return false
       end
-    EOE
+    end
 
-    tr = klass.new
+    tr = ChildObserverResource.new
     tr.expects(:abort_save).returns(false)
     tr.expects(:notify_observers).never
     tr.expects(:save_without_callbacks).never

data/spec/lib/response_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module ApiResource
+
+  describe Response do
+
+    context '#initialize' do
+
+      it 'handles a blank body' do
+        raw_response = stub(headers: {}, body: nil)
+        expect(Response.new(raw_response)).to be_blank
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/scopes_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ApiResource::Scopes do
-  
+
   before(:all) do
     ScopeResource.class_eval do
       scope :no_arg, {}
@@ -12,6 +12,7 @@ describe ApiResource::Scopes do
       scope :req_and_opt_args, {arg1: :req, arg2: :opt}
       scope :var_args, {ids: :rest}
       scope :mix_args, {id: :req, vararg: :rest}
+      scope :date_scope, {start_date: :req, end_date: :req}
     end
   end
 
@@ -59,6 +60,18 @@ describe ApiResource::Scopes do
       ScopeResource.add_scopes(one_arg: {id: 5})
     end
 
+    it 'does not apply scopes with a blank argument' do
+      ScopeResource.expects(:one_arg).never
+      ScopeResource.add_scopes(one_arg: {id: ""})
+      ScopeResource.add_scopes(one_arg: {id: nil})
+    end
+
+    it 'does not apply scopes when a parameter is missing' do
+      ScopeResource.expects(:two_args).never
+      ScopeResource.add_scopes(two_args: { page: 1 })
+      ScopeResource.add_scopes(two_args: { per_page: 1 })
+    end
+
     it 'applies scopes with an array argument' do
       ScopeResource.expects(:one_array_arg).with([5]).returns(ScopeResource)
       ScopeResource.add_scopes(one_array_arg: {ids: [5]})
@@ -93,6 +106,17 @@ describe ApiResource::Scopes do
       ScopeResource.expects(:mix_args).with(4,[5,6,7]).returns(ScopeResource)
       ScopeResource.add_scopes(mix_args: {id: 4, vararg: [5,6,7]})
     end
+
+    it 'parses dates if the parameters are correctly named' do
+      ScopeResource.expects(:date_scope)
+        .with(instance_of(Date), instance_of(Date))
+        .returns(ScopeResource)
+
+      ScopeResource.add_scopes({
+        date_scope: { start_date: 'May 6, 2013', end_date: 'June 8, 2014' }
+      })
+    end
+
   end
 
 end

data/spec/lib/typecasters/boolean_typecaster_spec.rb

@@ -13,7 +13,7 @@ describe ApiResource::Typecast::BooleanTypecaster do
     end
 
     it "should return false for any other conceivable input" do
-      [Date.new, Time.new, Date.today, Time.now, nil, false, Float, 2.0, 2, "", "bad value"].each do |val|
+      [Date.new, Time.new, Date.today, Time.now, false, Float, 2.0, 2, "", "bad value"].each do |val|
         klass.from_api(val).should be_instance_of(FalseClass)
       end
     end

data/spec/lib/typecasters/integer_typecaster_spec.rb

@@ -22,7 +22,7 @@ describe ApiResource::Typecast::IntegerTypecaster do
     end
 
     it "should be able to typecast any value you can think of" do
-      klass.from_api(nil).should eql(0)
+      klass.from_api(nil).should eql(nil)
       klass.from_api("").should eql(nil)
       klass.from_api(BasicObject).should eql(0)
       klass.from_api("abc").should eql(0)

data/spec/lib/typecasters/time_typecaster_spec.rb

@@ -29,6 +29,12 @@ describe ApiResource::Typecast::TimeTypecaster do
       val.day.should eql(28)
     end
 
+    it "should parse a date not in ISO format with a time zone" do
+      val = klass.from_api("2012-12-21T19:29:20-04:00")
+      val.hour.should eql(23)
+      val.zone.to_s.should eql("UTC")
+    end
+
     it "should parse a date not in ISO format" do
       val = klass.from_api("2012/08/09")
       val.year.should eql(2012)

data/spec/support/mocks/test_resource_mocks.rb

@@ -1,47 +1,57 @@
 include ApiResource
 
 Mocks.define do
-  
+
   endpoint("/test_resources/new") do
     get(HashDealer.roll(:new_test_object))
+    get(HashDealer.roll(:new_test_object), params: {type: 'X'}.matcher)
   end
-  
+
   endpoint("/test_resources") do
-    post(HashDealer.roll(:test_resource).merge(:id => 1), :params => {:test_resource => HashDealer.roll(:test_resource).matcher})
-    post(HashDealer.roll(:test_resource).merge(:id => 1), :params => {:test_resource => HashDealer.roll(:test_resource_with_roles).matcher})
+    post(HashDealer.roll(:test_resource).merge(id: 1), params: {test_resource: HashDealer.roll(:test_resource).matcher})
+    post(HashDealer.roll(:test_resource).merge(id: 1), params: {test_resource: HashDealer.roll(:test_resource_with_roles).matcher})
     get((0..4).to_a.collect{HashDealer.roll(:test_resource)})
-    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, :params => {:active => true})
-    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, :params => {:all => true})
-    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, :params => {:first => true})
-    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, :params => {:last => true})
+    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, params: {active: true})
+    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, params: {all: true})
+    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, params: {first: true})
+    get((0..4).to_a.collect{HashDealer.roll(:test_resource)}, params: {last: true})
+
+    get(
+      (0..4).to_a.collect{HashDealer.roll(:test_resource)},
+      params: { page: 1, per_page: 10 }.matcher,
+      response_headers: {
+        "ApiResource-Total-Entries" => 100
+      }
+    )
+
   end
-  
+
   endpoint("/test_resources/:id") do
     get(HashDealer.roll(:test_resource_with_proxies)) do |params|
       self.merge(params)
     end
     delete({})
-    put({}, :params => {:test_resource => HashDealer.roll(:test_resource).matcher})
+    put({}, params: {test_resource: HashDealer.roll(:test_resource).matcher})
   end
-  
+
   endpoint("/child_test_resources/new") do
     get({})
   end
-  
+
   endpoint("/child_test_resource2s/new") do
     get({})
   end
-  
+
   endpoint("/another_test_resources/new") do
     get({})
   end
-  
+
   endpoint("/test_classes/new") do
     get({})
   end
-  
+
   endpoint("/children/new") do
     get({})
   end
-  
+
 end