api_resource 0.6.18 → 0.6.19

data/spec/lib/callbacks_spec.rb

@@ -15,7 +15,7 @@ describe "Should put callbacks around save, create, update, and destroy by defau
       before_create :bc_cb; after_create :ac_cb
       before_update :bu_cb; after_update :au_cb
       before_destroy :bd_cb; after_destroy :ad_cb
-      
+
       def bs_cb
         @s_val = 1
       end
@@ -42,7 +42,7 @@ describe "Should put callbacks around save, create, update, and destroy by defau
       end
     EOE
   end
-  
+
   it "should fire save and create callbacks when saving a new record" do
     tr = TestResource.new(:name => "Ethan", :age => 20)
     tr.save.should be_true
@@ -50,7 +50,7 @@ describe "Should put callbacks around save, create, update, and destroy by defau
     tr.c_val.should eql(2)
     tr.u_val.should be_nil
   end
-  
+
   it "should fire save and update callbacks when updating a record" do
     tr = TestResource.new(:name => "Ethan", :age => 20)
     tr.stubs(:id => 1)
@@ -61,13 +61,13 @@ describe "Should put callbacks around save, create, update, and destroy by defau
     tr.c_val.should be_nil
     tr.u_val.should eql(2)
   end
-  
+
   it "should only fire destroy callbacks when destroying a record" do
     tr = TestResource.new(:name => "Ethan", :age => 20)
     tr.stubs(:id => 1)
     tr.destroy.should be_true
     tr.d_val.should eql(2)
-    tr.s_val.should be_nil   
+    tr.s_val.should be_nil
   end
-  
+
 end

data/spec/lib/connection_spec.rb

@@ -3,21 +3,21 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 include ApiResource
 
 describe Connection do
-  
+
   it "should be able to set the token directly on ApiResource" do
     ApiResource.token = "123"
     ApiResource::Base.token.should eql "123"
   end
-  
+
   it "should be able to set a default token value, which is passed through each request" do
-    ApiResource::Mocks::Connection.expects(:get).with("/test_resources/1.json", {"Accept"=>"application/json", "Lifebooker-Token" => "abc"}).returns(ApiResource::Mocks::MockResponse.new({}))
+    ApiResource::Mocks::Connection.expects(:get).with("/test_resources/1.json", {}, {"Accept"=>"application/json", "Lifebooker-Token" => "abc"}).returns(ApiResource::Mocks::MockResponse.new({}))
     ApiResource::Base.token = "abc"
     TestResource.find(1)
   end
 
   it "should set the Lifebooker-Token if one is present for GET requests" do
     token = Kernel.rand(100000).to_s
-    ApiResource::Mocks::Connection.expects(:get).with("/test_resources/1.json", {"Accept"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+    ApiResource::Mocks::Connection.expects(:get).with("/test_resources/1.json", {}, {"Accept"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
 
     ApiResource::Base.token = token
 
@@ -44,7 +44,7 @@ describe Connection do
 
   it "should set the Lifebooker-Token if one is present for POST requests" do
     token = Kernel.rand(100000).to_s
-    ApiResource::Mocks::Connection.expects(:post).with("/test_resources/1.json", {}, {"Content-Type"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+    ApiResource::Mocks::Connection.expects(:post).with("/test_resources/1.json", '{}', {"Content-Type"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
 
     ApiResource::Base.token = token
 
@@ -53,7 +53,7 @@ describe Connection do
 
   it "should set the Lifebooker-Token if one is present for PUT requests" do
     token = Kernel.rand(100000).to_s
-    ApiResource::Mocks::Connection.expects(:put).with("/test_resources/1.json", {}, {"Content-Type"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
+    ApiResource::Mocks::Connection.expects(:put).with("/test_resources/1.json", '{}', {"Content-Type"=>"application/json", 'Lifebooker-Token' => "#{token}"}).returns(ApiResource::Mocks::MockResponse.new({}))
 
     ApiResource::Base.token = token
 
@@ -75,7 +75,7 @@ describe Connection do
     TestResource.connection.headers.include?("Lifebooker-Token").should eql true
     TestResource.connection.headers["Lifebooker-Token"] = token
   end
-  
+
   it "should be able to set a token for a given block" do
     ApiResource::Base.token = "123456"
     begin
@@ -88,14 +88,14 @@ describe Connection do
     end
     ApiResource::Base.token.should eql "123456"
   end
-  
+
   it "should provider a method to regenerate its connection" do
     conn = ApiResource::Base.connection
     conn.should be ApiResource::Base.connection
     ApiResource.reset_connection
     conn.should_not be ApiResource::Base.connection
   end
-  
+
   context "No Mocks" do
     before(:all) do
       ApiResource::Mocks.remove
@@ -111,25 +111,25 @@ describe Connection do
       ApiResource.open_timeout = 1
       ApiResource.open_timeout.should eql 1
 
-      ApiResource::Base.connection.send(:http, "/test").options[:timeout].should eql 1
-      ApiResource::Base.connection.send(:http, "/test").options[:open_timeout].should eql 1
-      
+      ApiResource::Base.connection.send(:http).receive_timeout.should eql 1
+      ApiResource::Base.connection.send(:http).connect_timeout.should eql 1
+
       ApiResource.timeout = 100
-      ApiResource::Base.connection.send(:http, "/test").options[:timeout].should eql 100
+      ApiResource::Base.connection.send(:http).receive_timeout.should eql 100
 
     end
-    
-    it "should time out if RestClient takes too long" do
-      
+
+    it "should time out if HttpClient takes too long" do
+
       # hopefully google won't actually respond this fast :)
       ApiResource.timeout = 0.001
       ApiResource::Base.site = "http://www.google.com"
       lambda{
         ApiResource::Base.connection.get("/")
       }.should raise_error(ApiResource::RequestTimeout)
-      
+
     end
-    
+
   end
 
   context "headers" do
@@ -150,7 +150,7 @@ describe Connection do
     end
 
   end
-  
 
-  
+
+
 end

data/spec/lib/finders_spec.rb

@@ -79,6 +79,20 @@ describe ApiResource::Finders do
 		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([])
+
+		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([])
+
+		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}])

data/spec/lib/mocks_spec.rb

@@ -4,7 +4,7 @@ require 'json'
 include ApiResource
 
 describe Mocks do
-  
+
   # we set up the mocks in spec helper, so we can just assert this
   it "should hijack the connection" do
     ApiResource::Mocks::Interface.any_instance.expects(:get).once.returns(
@@ -12,29 +12,29 @@ describe Mocks do
     )
     TestResource.reload_class_attributes
   end
-  
+
   it "should allow the user to raise errors for invalid responsed" do
-    old_err_status = ApiResource.raise_missing_definition_error 
+    old_err_status = ApiResource.raise_missing_definition_error
     ApiResource::Base.raise_missing_definition_error = true
-    
+
     lambda {
       class MyNewInvalidResource < ApiResource::Base; end
-      MyNewInvalidResource.new 
+      MyNewInvalidResource.new
     }.should raise_error(ApiResource::ResourceNotFound)
-    
+
     ApiResource.raise_missing_definition_error = old_err_status
   end
 
   it "should merge params for a request" do
     resp = ApiResource::Base.connection.get(
-      "/mock_with_block/1?#{{:test => "abc"}.to_query}"
+      "/mock_with_block/1.json?#{{:test => "abc"}.to_query}"
     )
     resp["id"].should eql "1"
     resp["test"].should eql "abc"
   end
 
   context "Mock Request" do
-    context "Initialize" do 
+    context "Initialize" do
       it "should correctly assign blank params" do
         request = ApiResource::Mocks::MockRequest.new(:get, "/authenticate.json?token=")
         request.params.should eql({"token" => ""})
@@ -70,5 +70,5 @@ describe Mocks do
 
     end
   end
-  
+
 end

data/spec/lib/prefixes_spec.rb

@@ -36,8 +36,8 @@ describe "With Prefixes" do
     it "should use the prefix to create a new record" do
       prefix_model.send(:connection).expects(:post)
         .with(
-          "/foreign/123/prefix_models.json", 
-          {"prefix_model" => {"name" => "test"}}.to_json,
+          "/foreign/123/prefix_models.json",
+          has_entry(:prefix_model, has_entry('name', 'test')),
           instance_of(Hash)
         )
       prefix_model.save
@@ -90,9 +90,8 @@ describe "With Prefixes" do
       prefix_model.name = "changed name"
       prefix_model.send(:connection).expects(:put)
         .with(
-
-          "/foreign/123/prefix_models/456.json", 
-          {"prefix_model" => {"name" => "changed name"}}.to_json,
+          "/foreign/123/prefix_models/456.json",
+          has_entry(:prefix_model, has_entry('name', 'changed name')),
           instance_of(Hash)
         )
       prefix_model.save

data/spec/lib/scopes_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe ApiResource::Scopes do
+  
+  before(:all) do
+    ScopeResource.class_eval do
+      scope :no_arg, {}
+      scope :one_arg, {id: :req}
+      scope :one_array_arg, {ids: :req}
+      scope :two_args, {page: :req, per_page: :req}
+      scope :opt_args, {arg1: :opt}
+      scope :req_and_opt_args, {arg1: :req, arg2: :opt}
+      scope :var_args, {ids: :rest}
+      scope :mix_args, {id: :req, vararg: :rest}
+    end
+  end
+
+  context "Constructing arguments" do
+
+    it "should be able to query scopes on the current model" do
+      ScopeResource.no_arg.to_query.should eql(
+        "no_arg=true"
+      )
+      ScopeResource.one_arg(5).to_query.should eql(
+        "one_arg[id]=5"
+      )
+      ScopeResource.one_array_arg([3, 5]).to_query.should eql(
+        "one_array_arg[ids][]=3&one_array_arg[ids][]=5"
+      )
+      ScopeResource.two_args(1, 20).to_query.should eql(
+        "two_args[page]=1&two_args[per_page]=20"
+      )
+      $DEB = true
+      ScopeResource.opt_args.to_query.should eql(
+        "opt_args=true"
+      )
+      ScopeResource.opt_args(3).to_query.should eql(
+        "opt_args[arg1]=3"
+      )
+      ScopeResource.var_args(1, 2).to_query.should eql(
+        "var_args[ids][]=1&var_args[ids][]=2"
+      )
+      args = ["a", {opt1: 1}, {opt2: 2}]
+      ScopeResource.mix_args(*args).to_query.should eql(
+        "mix_args[id]=a&mix_args[vararg][][opt1]=1&mix_args[vararg][][opt2]=2"
+      )
+    end
+  end
+
+  context '#add_scopes' do
+
+    it 'applies static scopes' do
+      ScopeResource.expects(:no_arg).returns(ScopeResource)
+      ScopeResource.add_scopes(no_arg: 1)
+    end
+
+    it 'applies scopes with one argument' do
+      ScopeResource.expects(:one_arg).with(5).returns(ScopeResource)
+      ScopeResource.add_scopes(one_arg: {id: 5})
+    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]})
+    end
+
+    it 'applies scopes with two arguments' do
+      ScopeResource.expects(:two_args).with(7,9).returns(ScopeResource)
+      ScopeResource.add_scopes(two_args: {page: 7, per_page: 9})
+    end
+
+    it 'applies scopes with optional arguments when those arguments are supplied' do
+      ScopeResource.expects(:opt_args).with(5).returns(ScopeResource)
+      ScopeResource.add_scopes(opt_args: {arg1: 5})
+    end
+
+    it "doesn't apply scopes with only optional arguments when there are no supplied args" do
+      ScopeResource.expects(:opt_args).never
+      ScopeResource.add_scopes(opt_args: {})
+    end
+
+    it "applies scopes that have both optional and required args with only the required args if the optional args are not passed in" do
+      ScopeResource.expects(:req_and_opt_args).with(5).returns(ScopeResource)
+      ScopeResource.add_scopes(req_and_opt_args: {arg1: 5})
+    end
+
+    it "applies scopes with variable arg lists" do
+      ScopeResource.expects(:var_args).with([5,6,7]).returns(ScopeResource)
+      ScopeResource.add_scopes(var_args: {ids: [5,6,7]})
+    end
+
+    it "applies scopes with mixed arg lists" do
+      ScopeResource.expects(:mix_args).with(4,[5,6,7]).returns(ScopeResource)
+      ScopeResource.add_scopes(mix_args: {id: 4, vararg: [5,6,7]})
+    end
+  end
+
+end

data/spec/lib/serializer_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module ApiResource
+
+  describe Serializer do
+
+    before(:each) do
+      TestResource.reload_resource_definition
+      TestResource.has_many :has_many_objects
+      TestResource.define_attributes :attr1, :attr2
+      TestResource.include_root_in_json = false
+    end
+
+    after(:all) do
+      TestResource.include_root_in_json = true
+    end
+
+    subject {
+      Serializer.new(instance)
+    }
+
+    let(:instance){
+      TestResource.new({
+        attr1: "attr1",
+        attr2: "attr2",
+        has_many_objects: []
+      })
+    }
+
+    context "#to_hash" do
+
+      it 'includes attributes' do
+
+        subject.to_hash["attr1"].should_not be_nil
+
+      end
+
+      it "should not include associations by default if
+        they have not changed" do
+
+        subject.to_hash["has_many_objects"].should be_nil
+      end
+
+      it "should include associations passed given in the include_associations array" do
+
+        subject = Serializer.new(
+          instance,
+          include_associations: [:has_many_objects]
+        )
+
+        subject.to_hash["has_many_objects"].should_not be_nil
+      end
+
+      it "should include associations by default if they have changed" do
+        instance.has_many_objects = [{name: "test"}]
+        hash = subject.to_hash
+        hash["has_many_objects"].should_not be_nil
+      end
+
+      it "should not include unknown attributes unless they
+        are passed in via the include_extras array" do
+
+        TestResource.class_eval do
+          define_attributes :attr3, access_level: :protected
+        end
+
+        instance = TestResource.instantiate_record({
+          attr1: "attr1",
+          attr2: "attr2",
+          attr3: "attr3"
+        })
+
+        subject = Serializer.new(instance)
+        subject.to_hash["attr3"].should be_nil
+
+        subject = Serializer.new(instance, include_extras: [:attr3])
+        subject.to_hash["attr3"].should_not be_nil
+      end
+
+      it "should ignore fields set under the except option" do
+        tst = TestResource.new({
+          attr1: "attr1",
+          attr2: "attr2"
+        })
+        hash = JSON.parse(tst.to_json(except: [:attr1]))
+        hash["attr1"].should be_nil
+        hash["attr2"].should be_present
+      end
+
+      context "Nested Objects" do
+
+        before(:all) do
+          TestResource.has_many(:has_many_objects)
+        end
+
+        after(:all) do
+          TestResource.reload_resource_definition
+        end
+
+        it "should include the id of nested objects in the serialization" do
+          instance.has_many_objects = [
+            {name: "123", id: "1"}
+          ]
+          subject = Serializer.new(
+            instance,
+            include_associations: [:has_many_objects]
+          )
+          subject.to_hash["has_many_objects"].first["id"].should_not be_nil
+        end
+
+        it "should exclude include the id of new nested objects in the
+           serialization" do
+          instance.has_many_objects = [
+            {name: "123"}
+          ]
+          subject = Serializer.new(
+            instance,
+            include_associations: [:has_many_objects]
+          )
+          object_hash = subject.to_hash["has_many_objects"].first
+          object_hash.keys.should_not include "id"
+        end
+
+      end
+
+      context 'Foreign keys' do
+
+        context 'Prefixed' do
+
+          before(:all) do
+            TestResource.prefix =
+              "/belongs_to_objects/:belongs_to_object_id/"
+          end
+
+          after(:all) do
+            TestResource.prefix = "/"
+          end
+
+          it 'excludes the foreign key when it is nested in the prefix' do
+            instance.belongs_to_object_id = 123
+            subject.to_hash["belongs_to_object_id"].should be_blank
+          end
+
+        end
+
+        it "should include the foreign_key_id when saving" do
+          instance.stubs(:id => 123)
+          instance.has_many_object_ids = [4]
+          subject.to_hash[:has_many_object_ids].should eql([4])
+        end
+
+      end
+
+    end
+  end
+end