api_resource 0.5.1 → 0.6.0

data/spec/lib/connection_spec.rb

@@ -131,6 +131,25 @@ describe Connection do
     end
     
   end
+
+  context "headers" do
+
+    it "should include the Lifebooker-Token in its headers" do
+
+      old_token = ApiResource.token
+
+      ApiResource.with_token("a") do
+        TestResource.connection.headers["Lifebooker-Token"].should eql("a")
+        ApiResource.with_token("b") do
+          TestResource.connection.headers["Lifebooker-Token"].should eql("b")
+        end
+      end
+
+      TestResource.connection.headers["Lifebooker-Token"].should eql(old_token)
+
+    end
+
+  end
   
 
   

data/spec/lib/finders/multi_object_association_finder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+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)
+		).find
+	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.find.should eql([tr])
+	end
+
+end

data/spec/lib/finders/resource_finder_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe "ResourceFinder" do
+
+	before(:each) do
+		TestResource.reload_resource_definition
+	end
+
+	it "should call find on the class normally without includes" do
+		TestResource.expects(:find).with(:all, {})
+
+		ApiResource::Finders::ResourceFinder.new(
+			TestResource,
+			mock(:to_hash => {})
+		).find
+	end
+
+	it "should pass conditions into the finder method" do
+		TestResource.expects(:find).with(:all, {:id => [1,2,3]})
+
+		ApiResource::Finders::ResourceFinder.new(
+			TestResource, 
+			mock(:to_hash => {:id => [1,2,3]})
+		).find
+	end
+
+	it "should try to load includes if it finds an object" do
+		obj_mock = mock(:id => 1)
+
+		TestResource.expects(:find).with(:all, {}).returns([obj_mock])
+
+		obj = ApiResource::Finders::ResourceFinder.new(
+			TestResource,
+			stub(:to_hash => {}, :eager_load? => false, :included_objects => [])
+		).find
+
+		obj.first.id.should eql(1)
+	end
+
+	it "should load and distribute includes among the returned objects" do
+		inc_mock = stub(:id => 1)
+		inc_mock2 = stub(:id => 2)
+
+		tr = TestResource.new
+		tr.stubs(:id).returns(1)
+		tr.stubs(:has_many_object_ids).returns([1,2])
+		tr.expects(:has_many_objects=).with([inc_mock, inc_mock2])
+		tr.expects(:has_many_objects).returns([inc_mock, inc_mock2])
+
+		TestResource.expects(:find).with(:all, {}).returns([tr])
+
+		HasManyObject.expects(:find).with(:all, :id => [1,2]).returns([inc_mock, inc_mock2])
+
+		obj = ApiResource::Finders::ResourceFinder.new(
+			TestResource,
+			stub(:to_hash => {}, :eager_load? => true, :included_objects => [:has_many_objects])
+		).find
+		obj.first.has_many_objects.collect(&:id).should eql([1,2])
+	end
+
+	it "should work with loading for multiple objects" do
+		inc_mock = stub(:id => 1)
+		inc_mock2 = stub(:id => 2)
+
+		tr = TestResource.new
+		tr.stubs(:id).returns(1)
+		tr.stubs(:has_many_object_ids).returns([1])
+		tr.expects(:has_many_objects=).with([inc_mock]).returns([inc_mock])
+		tr.expects(:has_many_objects).returns([inc_mock])
+
+		tr2 = TestResource.new
+		tr2.stubs(:id).returns(2)
+		tr2.stubs(:has_many_object_ids).returns([2])
+		tr2.expects(:has_many_objects=).with([inc_mock2]).returns([inc_mock2])
+		tr2.expects(:has_many_objects).returns([inc_mock2])
+
+		TestResource.expects(:find).with(:all, {}).returns([tr, tr2])
+		HasManyObject.expects(:find).with(:all, :id => [1,2]).returns([inc_mock2, inc_mock])
+
+		obj = ApiResource::Finders::ResourceFinder.new(
+			TestResource,
+			stub(:to_hash => {}, :eager_load? => true, :included_objects => [:has_many_objects])
+		).find
+
+		obj.first.has_many_objects.collect(&:id).should eql([1])
+		obj.second.has_many_objects.collect(&:id).should eql([2])
+	end
+
+end

data/spec/lib/finders/single_object_association_finder_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe "SingleObjectAssociationFinder" 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(nil)
+
+		ApiResource::Finders::SingleObjectAssociationFinder.new(
+			TestResource,
+			stub(:remote_path => "test_resources", :to_query => "id[]=1&id[]=2", :blank_conditions? => false)
+		).find
+	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::SingleObjectAssociationFinder.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_record).returns(tr)
+
+		finder.expects(:load_includes).with(:has_many_objects => [1,2]).returns(5)
+		finder.expects(:apply_includes).with(tr, 5).returns(6)
+
+		finder.find.should eql(tr)
+	end
+
+end

data/spec/lib/observing_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+include ApiResource
+
+describe "Observing" do
+
+  before(:all) do
+    TestResource.reload_class_attributes
+  end
+
+  after(:all) do
+    TestResource.observers = []
+    TestResource.observer_instances.clear
+    TestResource.reload_class_attributes
+  end
+
+  it "should notify observers on create" do
+    tr = TestResource.new
+    tr.expects(:notify_observers).with(:before_save).returns(true)
+    tr.expects(:notify_observers).with(:before_create).returns(true)
+    tr.expects(:create_without_observers).returns(true)
+    tr.expects(:notify_observers).with(:after_create).returns(true)
+    tr.expects(:notify_observers).with(:after_save).returns(true)
+    tr.save
+  end
+
+  it "should notify observers on update" do
+    tr = TestResource.new
+    tr.stubs(:new?).returns(false)
+    tr.expects(:notify_observers).with(:before_save).returns(true)
+    tr.expects(:notify_observers).with(:before_update).returns(true)
+    tr.expects(:update_without_observers).returns(true)
+    tr.expects(:notify_observers).with(:after_update).returns(true)
+    tr.expects(:notify_observers).with(:after_save).returns(true)
+    tr.save
+  end
+
+  it "should notify observers on destroy" do
+    tr = TestResource.new
+    tr.stubs(:id).returns(1)
+    tr.expects(:notify_observers).with(:before_destroy).returns(true)
+    tr.expects(:destroy_without_observers).returns(true)
+    tr.expects(:notify_observers).with(:after_destroy).returns(true)
+    tr.destroy
+  end
+
+  it "should notify an observer for a given event" do
+    class TestResourceObserver < ApiResource::Observer
+      def before_save(elm)
+        return true
+      end
+    end
+
+    TestResourceObserver.any_instance.expects(:before_save).returns(true)
+    # A bit of a pain to set these up ex post facto
+    TestResource.observers = :test_resource_observer
+    TestResource.instantiate_observers
+    tr = TestResource.new
+    tr.expects(:save_without_observers).returns(true)
+    tr.save
+  end
+
+  it "should cancel the save if the observer returns false" do
+    class TestResourceObserver < ApiResource::Observer
+      def before_save(elm)
+        return true
+      end
+    end
+
+    TestResourceObserver.any_instance.expects(:before_save).returns(false)
+    # A bit of a pain to set these up ex post facto
+    TestResource.observers = :test_resource_observer
+    TestResource.instantiate_observers
+    tr = TestResource.new
+    tr.expects(:save_without_observers).never
+    tr.save
+  end
+
+  it "should run callbacks before observers" do
+    klass = Class.new(TestResource)
+    klass.class_eval <<-EOE, __FILE__, __LINE__ + 1
+      before_save :abort_save
+
+      def abort_save
+        return false
+      end
+    EOE
+
+    tr = klass.new
+    tr.expects(:abort_save).returns(false)
+    tr.expects(:notify_observers).never
+    tr.expects(:save_without_callbacks).never
+    tr.save
+  end
+
+end

data/spec/lib/typecast_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe ApiResource::Typecast do
+
+  let(:klass) { ApiResource::Base }
+
+  context ".register_typecaster" do
+
+    it "should be able to define a typecaster given a name and a module/class" do
+      caster = Module.new do
+        def self.from_api(value)
+          return "hello"
+        end
+        def self.to_api(value)
+        end
+      end
+      klass.register_typecaster(:String1, caster)
+      klass.typecasters[:string1].from_api(1).should eql("hello")
+    end
+
+    it "should be able to define a typecaster given a block" do
+      klass.register_typecaster(:String2) do
+        def self.from_api(value)
+          return "hello"
+        end
+        def self.to_api(value)
+        end
+      end
+
+      klass.typecasters[:string2].from_api(1).should eql("hello")
+    end
+
+    it "should raise an error if given both a class and a block" do
+      caster = Module.new do
+        def self.from_api(value)
+          return "hello"
+        end
+        def self.to_api(value)
+        end
+      end
+
+      lambda {
+        klass.register_typecaster(:String3, caster) do
+          def self.from_api(value)
+            return "hello"
+          end
+          def self.to_api(value)
+          end
+        end
+        }.should raise_error ArgumentError, "Cannot declare a typecaster with a class and a block"
+    end
+
+    it "should raise an error if given neither a class nor a block" do
+      lambda {
+        klass.register_typecaster(:String4)
+      }.should raise_error ArgumentError, "Must specify a typecaster with either a class or a block"
+    end
+
+    it "should raise an error if the typecaster already exists" do
+      klass.register_typecaster(:String5) do
+        def self.from_api(value)
+          return "hello"
+        end
+        def self.to_api(value)
+        end
+      end
+      lambda {
+        klass.register_typecaster(:String5) do
+          def self.from_api(value)
+            return "goodbye"
+          end
+          def self.to_api(value)
+          end
+        end
+      }.should raise_error ArgumentError, "Typecaster String5 already exists"
+    end
+
+    it "should raise an error if the klass does not respond_to? from_api" do
+      lambda {
+        klass.register_typecaster(:String6) do
+
+        end
+      }.should raise_error ArgumentError, "Typecaster must respond to from_api and to_api"
+    end
+  end
+
+  context "redefine_typecaster!" do
+    it "should be able to reregister a typecaster" do
+      klass.register_typecaster(:String7) do
+        def self.from_api(value)
+          return "hello"
+        end
+        def self.to_api(value)
+        end
+      end
+      klass.typecasters[:string7].from_api(1).should eql("hello")
+      klass.redefine_typecaster!(:String7) do
+        def self.from_api(value)
+          return "goodbye"
+        end
+        def self.to_api(value)
+        end
+      end
+
+      klass.typecasters[:string7].from_api(1).should eql("goodbye")
+    end
+
+    it "should redefine a typecaster only for subclasses of the class called on" do
+      sib1 = Class.new(ApiResource::Base)
+      sib2 = Class.new(ApiResource::Base)
+      child = Class.new(sib2)
+      # overriding a typecaster in sib2 should affect sib2 and child but not sib1
+      sib2.redefine_typecaster!(:string) do
+        def self.from_api(value)
+          return "hello"
+        end
+
+        def self.to_api(value)
+          return value
+        end
+      end
+
+      sib1.typecasters[:string].from_api(1).should eql("1")
+      ApiResource::Base.typecasters[:string].from_api(2).should eql("2")
+      sib2.typecasters[:string].from_api(1).should eql("hello")
+      child.typecasters[:string].from_api(1).should eql("hello")
+    end
+
+    it "should redefine a typecaster for all subclasses when called on ApiResource::Base" do
+      grandparent = Class.new(ApiResource::Base)
+      parent = Class.new(grandparent)
+      child = Class.new(parent)
+
+      grandparent.redefine_typecaster!(:string) do
+        def self.from_api(value)
+          return "goodbye"
+        end
+
+        def self.to_api(value)
+          return value
+        end
+      end
+
+      grandparent.typecasters[:string].from_api(2).should eql("goodbye")
+      parent.typecasters[:string].from_api(2).should eql("goodbye")
+      child.typecasters[:string].from_api(2).should eql("goodbye")
+    end
+
+    it "should be able to restore default typecasters" do
+      ApiResource::Base.redefine_typecaster!(:string) do
+        def self.from_api(value)
+          return "goodbye"
+        end
+
+        def self.to_api(value)
+          return value
+        end
+      end
+      ApiResource::Base.typecasters[:string].from_api(2).should eql("goodbye")
+      ApiResource::Base.redefine_typecaster!(:string, ApiResource::Base.default_typecasters[:string])
+      ApiResource::Base.typecasters[:string].from_api(2).should eql("2")
+    end
+  end
+
+  context ".typecasters" do
+    it "should have default typecasters" do
+      vals = [:boolean, :bool, :date, :decimal, :float, :integer,
+       :int, :string, :time, :datetime, :array]
+      vals.each do |val|
+        klass.typecasters.keys.should include val
+      end
+    end
+  end
+end