api_resource 0.4.0 → 0.4.1

data/spec/lib/attributes_spec.rb

@@ -1,191 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-include ApiResource
-
-describe "Attributes" do
-  
-  after(:all) do
-    TestResource.reload_class_attributes
-  end
-  
-  context "Defining, getting, and setting attributes" do
-    it "should be able to define known attributes" do
-      TestResource.define_attributes :attr1, :attr2
-      TestResource.attribute?(:attr1).should be_true
-      TestResource.attribute?(:attr2).should be_true
-    end
-    
-
-    describe "Determining Attributes, Scopes, and Associations from the server" do
-
-      it "should determine it's attributes when the class loads" do
-        tst = TestResource.new
-        tst.attribute?(:name).should be_true
-        tst.attribute?(:age).should be_true
-      end
-      
-      it "should typecast data if a format is specified" do
-        tst = TestResource.new(:bday => Date.today.to_s)
-        tst.bday.should be_a Date
-      end
-      
-      it "should typecast data if a format is specified" do
-        tst = TestResource.new(:roles => [:role1, :role2])
-        tst.roles.should be_a Array
-      end
-
-      it "should default array fields to a blank array" do
-        tst = TestResource.new
-        tst.roles.should be_a Array
-      end
-
-      it "should determine it's associations when the class loads" do
-        tst = TestResource.new
-        tst.association?(:has_many_objects).should be_true
-        tst.association?(:belongs_to_object).should be_true
-      end
-      
-      it "should be able to determine scopes when the class loads" do
-        tst = TestResource.new
-        tst.scope?(:paginate).should be_true
-        tst.scope?(:active).should be_true
-      end
-
-      it "should provide attributes without proxies if attributes_without_proxies is called" do
-        tst = TestResource.new({:has_many_objects => []})
-        tst.attributes_without_proxies.each do |k,v|
-          [ApiResource::Associations::SingleObjectProxy, ApiResource::Associations::MultiObjectProxy]
-            .include?(v.class).should be_false
-        end
-      end
-
-    end
-
-    context "Attributes" do
-      before(:all) do
-        TestResource.define_attributes :attr1, :attr2
-        TestResource.define_protected_attributes :attr3
-      end
-    
-      it "should set attributes for the data loaded from a hash" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2"})
-        tst.attr1?.should be_true
-        tst.attr1.should eql("attr1")
-        tst.attr1 = "test"
-        tst.attr1.should eql("test")
-      end
-    
-      it "should create protected attributes for unknown attributes trying to be loaded" do
-        tst = TestResource.new({:attr1 => "attr1", :attr3 => "attr3"})
-        tst.attr3?.should be_true
-        tst.attr3.should eql("attr3")
-        lambda {
-          tst.attr3 = "test"
-        }.should raise_error
-      end
-    end
-
-    it "should define methods for testing for reading and writing known attributes" do
-      TestResource.define_attributes :attr1, :attr2
-      tst = TestResource.new
-      tst.respond_to?(:attr1).should be_true
-      tst.respond_to?(:attr1=).should be_true
-      tst.respond_to?(:attr1?).should be_true
-    end
-    
-    it "should be able to set and change attributes" do
-      TestResource.define_attributes :attr1, :attr2
-      tst = TestResource.new
-      tst.attr1.should be_nil
-      tst.attr1?.should be_false
-      tst.attr1 = "test"
-      tst.attr1.should eql("test")
-      tst.attr1?.should be_true
-    end
-    
-    it "should be able to set multiple attributes at once" do
-      TestResource.define_attributes :attr1, :attr2, :attr3
-      tst = TestResource.new
-      tst.attr3 = "123"
-      
-      tst.attributes = {:attr1 => "abc", :attr2 => "test"}
-      tst.attr1.should eql "abc"
-      tst.attr2.should eql "test"
-      tst.attr3.should eql "123"
-    end
-    
-  end
-  
-  context "Protected attributes" do
-    it "should allow protected attributes that cannot be changed" do
-      TestResource.define_protected_attributes :pattr3
-      lambda {
-        tst = TestResource.new
-        tst.pattr3 = "test"
-      }.should raise_error
-    end
-  end
-  
-  context "Dirty tracking" do
-    context "Changes to attributes" do
-      it "should implement dirty tracking for attributes" do
-        TestResource.define_attributes :attr1, :attr2
-        tst = TestResource.new
-        tst.changed.should be_blank
-        tst.attr1 = "Hello"
-        tst.changed.include?("attr1").should be_true
-        tst.changes.should_not be_blank
-        
-        # Set an attribute equal to itself
-        tst.attr2 = tst.attr2
-        tst.changes.include?("attr2").should be_false
-      end
-
-    end
-    
-    context "Resetting and marking attributes current" do
-      
-      before(:each) do
-        TestResource.define_attributes :attr1, :attr2
-      end
-      
-      it "should be able to mark any list of attributes as current (unchanged)" do
-        tst = TestResource.new
-        tst.attr1 = "Hello"
-        tst.changed.should_not be_blank
-        tst.set_attributes_as_current :attr1, :attr2
-        tst.changed.should be_blank
-      end
-      
-      it "should be able to mark all the attributes as current if none are given" do
-        tst = TestResource.new
-        tst.attr1 = "attr1"
-        tst.attr2 = "attr2"
-        tst.changed.should_not be_blank
-        tst.set_attributes_as_current
-        tst.changed.should be_blank
-      end
-      
-      it "should be able to reset any list of attributes" do
-        tst = TestResource.new
-        tst.attr1 = "attr1"
-        tst.reset_attribute_changes :attr1
-        tst.attr1.should be_nil
-        tst.changed.should be_blank
-      end
-      
-      it "should be able to reset all the attributes if none are given" do
-        tst = TestResource.new
-        tst.attr1 = "attr1"
-        tst.attr2 = "attr2"
-
-        tst.reset_attribute_changes
-        tst.attr1.should be_nil
-        tst.attr2.should be_nil
-        tst.changed.should be_blank
-      end
-    end
-    
-  end
-  
-end

data/spec/lib/base_spec.rb

@@ -1,655 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'json'
-
-include ApiResource
-
-describe "Base" do
-  
-  after(:all) do
-    TestResource.reload_class_attributes
-  end
-  
-  describe "Loading data from a hash" do
-    
-    context "Associations" do
-      before(:all) do
-        TestResource.has_many :has_many_objects
-        TestResource.has_one :has_one_object
-        TestResource.belongs_to :belongs_to_object
-      end
-      
-      after(:all) do
-        TestResource.related_objects.each do |key,val|
-          val.clear
-        end
-      end
-      
-      context "MultiObjectProxy" do
-      
-        it "should create a MultiObjectProxy for has_many associations" do
-          tst = TestResource.new({:has_many_objects => []})
-          tst.has_many_objects.should be_a(Associations::MultiObjectProxy)
-        end
-        
-        it "should throw an error if a has many association is not nil or an array or a hash" do
-          TestResource.new({:has_many_objects => nil})
-          lambda {
-            TestResource.new({:has_many_objects => "invalid"})
-          }.should raise_error
-        end
-        
-        it "should properly load the data from the provided array or hash" do
-          tst = TestResource.new({:has_many_objects => [{:service_uri => '/path'}]})
-          tst.has_many_objects.remote_path.should eql('/path')
-          tst = TestResource.new({:has_many_objects => {:service_uri => '/path'}})
-          tst.has_many_objects.remote_path.should eql('/path')
-        end
-        
-      end
-      
-      context "SingleObjectProxy" do
-        
-        it "should create a SingleObjectProxy for belongs to and has_one associations" do
-          tst = TestResource.new(:belongs_to_object => {}, :has_one_object => {})
-          tst.belongs_to_object.should be_a(Associations::SingleObjectProxy)
-          tst.has_one_object.should be_a(Associations::SingleObjectProxy)
-        end
-        
-        it "should throw an error if a belongs_to or has_many association is not a hash or nil" do
-          lambda {
-            TestResource.new(:belongs_to_object => [])
-          }.should raise_error
-          lambda {
-            TestResource.new(:has_one_object => [])
-          }.should raise_error
-        end
-        
-        it "should properly load data from the provided hash" do
-          tst = TestResource.new(:has_one_object => {:service_uri => "/path"})
-          tst.has_one_object.remote_path.should eql('/path')
-        end
-        
-      end
-    end
-  end
-    
-  describe "Request parameters and paths" do
-    
-    after(:each) do
-      TestResource.element_name = TestResource.model_name.element
-      TestResource.collection_name = TestResource.element_name.to_s.pluralize
-    end
-    
-    it "should set the element name and collection name by default" do
-      TestResource.element_name.should eql("test_resource")
-      TestResource.collection_name.should eql("test_resources")
-    end
-    
-    it "should inherit element name and collection name from its parent class if using SCI" do
-      ChildTestResource.ancestors.should include TestResource
-      ChildTestResource.collection_name.should eql "test_resources"
-    end
-    
-    it "should be able to set the element and collection names to anything" do
-      TestResource.element_name = "element"
-      TestResource.collection_name = "elements"
-      TestResource.element_name.should eql("element")
-      TestResource.collection_name.should eql("elements")
-    end
-    
-    it "should propery generate collection paths and element paths with the new names and the default format json" do
-      TestResource.element_name = "element"
-      TestResource.collection_name = "elements"
-      TestResource.new_element_path.should eql("/elements/new.json")
-      TestResource.collection_path.should eql("/elements.json")
-      TestResource.element_path(1).should eql("/elements/1.json")
-      TestResource.element_path(1, :active => true).should eql("/elements/1.json?active=true")
-    end
-    
-    it "should be able to set the format" do
-      TestResource.format.extension.to_sym.should eql(:json)
-      TestResource.format = :xml
-      TestResource.format.extension.to_sym.should eql(:xml)
-      TestResource.format = :json
-    end
-
-    it "should only allow proper formats to be set" do
-      expect {TestResource.format = :blah}.should raise_error(::ApiResource::Formats::BadFormat)
-    end 
-    
-    it "should be able to set an http timeout" do
-      TestResource.timeout = 5
-      TestResource.timeout.should eql(5)
-      TestResource.connection.timeout.should eql(5)
-    end
-       
-  end
-  
-  describe "Serialization" do
-    
-    before(:all) do
-      TestResource.reload_class_attributes
-      TestResource.has_many :has_many_objects
-      TestResource.define_attributes :attr1, :attr2
-      TestResource.include_root_in_json = true
-    end
-    
-    before(:each) do
-      TestResource.include_root_in_json = false
-    end
-    
-    context "JSON" do
-      
-      it "should be able to serialize itself without the root" do
-        TestResource.include_root_in_json = false
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2"})
-        hash = JSON.parse(tst.to_json)
-        hash["attr1"].should eql("attr1")
-        hash["attr2"].should eql("attr2")
-      end
-      
-      it "should be able to serialize itself with the root" do
-        TestResource.include_root_in_json = true
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2"})
-        hash = JSON.parse(tst.to_json)
-        hash["test_resource"].should_not be_nil
-      end
-      
-      it "should not include associations by default if they have not changed" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :has_many_objects => []})
-        hash = JSON.parse(tst.to_json)
-        hash["has_many_objects"].should be_nil
-      end
-      
-      it "should include associations passed given in the include_associations array" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :has_many_objects => []})
-        hash = JSON.parse(tst.to_json(:include_associations => [:has_many_objects]))
-        hash["has_many_objects"].should_not be_nil
-      end
-      
-      it "should include associations by default if they have changed" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :has_many_objects => []})
-        tst.has_many_objects = [{:name => "test"}]
-        hash = JSON.parse(tst.to_json)
-        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
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :attr3 => "attr3"})
-        hash = JSON.parse(tst.to_json)
-        hash["attr3"].should be_nil
-        hash = JSON.parse(tst.to_json(:include_extras => [:attr3]))
-        hash["attr3"].should_not be_nil
-      end
-      
-      it "should ignore fields set under the except option" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :attr3 => "attr3"})
-        hash = JSON.parse(tst.to_json(:except => [:attr1]))
-        hash["attr1"].should be_nil
-      end
-      
-      context "Nested Objects" do
-        before(:all) do
-          TestResource.has_many(:has_many_objects)
-        end
-        after(:all) do
-          TestResource.reload_class_attributes
-        end
-        
-        it "should include the id of nested objects in the serialization" do
-          tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :has_many_objects => [{:name => "123", :id => "1"}]})
-          hash = JSON.parse(tst.to_json(:include_associations => [:has_many_objects]))
-          hash["has_many_objects"].first["id"].should_not be nil
-        end
-        it "should include the id of nested objects in the serialization" do
-          tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :has_many_objects => [{:name => "123"}]})
-          hash = JSON.parse(tst.to_json(:include_associations => [:has_many_objects]))
-          hash["has_many_objects"].first.keys.should_not include "id"
-        end
-      end
-    end
-    
-    context "XML" do
-      
-      it "should only be able to serialize itself with the root" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2"})
-        hash = Hash.from_xml(tst.to_xml)
-        hash["test_resource"].should_not be_nil
-      end
-      
-      it "should properly serialize associations if they are included" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2", :has_many_objects => []})
-        hash = Hash.from_xml(tst.to_xml(:include_associations => [:has_many_objects]))
-        hash["test_resource"]["has_many_objects"].should eql([])
-      end
-    end
-    
-  end
-  
-  describe "Finding Data" do
-    
-    before(:all) do
-      TestResource.reload_class_attributes
-    end
-    
-    it "should be able to find all" do
-      resources = TestResource.find(:all)
-      resources.size.should eql(5)
-      resources.each{|r| r.should be_a TestResource}
-    end
-    
-    it "should be able to find first or last" do
-      res = TestResource.first
-      res.should be_a TestResource
-      res.name.should_not be_blank
-      res.age.should_not be_blank
-      
-      res = TestResource.last
-      res.should be_a TestResource
-      res.name.should_not be_blank
-      res.age.should_not be_blank
-    end
-    
-    it "should be able to find by id" do
-      res = TestResource.find(2)
-      res.should be_a TestResource
-      res.id.to_i.should eql(2)
-    end
-    
-  end
-  
-  describe "Saving Data" do
-    
-    before(:all) do
-      TestResource.include_root_in_json = true
-      TestResource.reload_class_attributes
-    end
-    
-    context "Creating new records" do
-      
-      before(:all) do
-        TestResource.has_many :has_many_objects
-      end
-    
-      it "should be able to post new data via the create method" do
-        tr = TestResource.create({:name => "Ethan", :age => 20})
-        tr.id.should_not be_blank
-      end
-    
-      it "should be able to post new data via the save method" do
-        tr = TestResource.build({:name => "Ethan", :age => 20})
-        tr.save.should be_true
-        tr.id.should_not be_blank
-      end
-      
-      context("Override create to return the json") do
-        
-        before(:all) do
-          RestClient::Payload.stubs(:has_file? => false)
-        end
-
-        it "should be able to include associations when saving if they are specified" do
-          ApiResource::Connection.any_instance.expects(:post).with(
-            "/test_resources.json", 
-            "{\"test_resource\":{\"name\":\"Ethan\",\"age\":20}}", 
-            TestResource.headers
-          )
-
-          tr = TestResource.build(:name => "Ethan", :age => 20)
-          tr.save
-        end
-      
-
-        it "should not include nil attributes when creating by default" do
-          ApiResource::Connection.any_instance.expects(:post).with(
-            "/test_resources.json", 
-            "{\"test_resource\":{\"name\":\"Ethan\"}}", 
-            TestResource.headers
-          )
-
-          tr = TestResource.build(:name => "Ethan")
-          tr.save
-        end
-
-        it "should include false attributes when creating by default" do
-          ApiResource::Connection.any_instance.expects(:post).with(
-            "/test_resources.json", 
-            "{\"test_resource\":{\"name\":\"Ethan\",\"is_active\":false}}", 
-            TestResource.headers
-          )
-
-          tr = TestResource.build(:name => "Ethan", :is_active => false)
-          tr.save
-        end
-
-
-        it "should not include nil attributes for associated objects when creating by default" do
-          ApiResource::Connection.any_instance.expects(:post).with(
-            "/test_resources.json", 
-            "{\"test_resource\":{\"name\":\"Ethan\",\"has_one_object\":{\"size\":\"large\"}}}", 
-            TestResource.headers
-          )
-
-          tr = TestResource.build(:name => "Ethan")
-          tr.has_one_object = HasOneObject.new(:size => "large", :color => nil)
-          tr.save(:include_associations => [:has_one_object])
-        end
-      
-
-        it "should include nil attributes if they are passed in through the include_extras" do
-          ApiResource::Connection.any_instance.expects(:post).with(
-            "/test_resources.json", 
-            "{\"test_resource\":{\"name\":\"Ethan\",\"age\":null}}", 
-            TestResource.headers
-          )
-
-          tr = TestResource.build(:name => "Ethan")
-          tr.save(:include_extras => [:age])
-        end
-      
-
-        it "should include nil attributes when creating if include_nil_attributes_on_create is true" do
-          ApiResource::Connection.any_instance.expects(:post).with(
-            "/test_resources.json", 
-            "{\"test_resource\":{\"name\":\"Ethan\",\"age\":null,\"is_active\":null,\"bday\":null,\"roles\":[]}}", 
-            TestResource.headers
-          )
-
-          TestResource.include_nil_attributes_on_create = true
-          tr = TestResource.build(:name => "Ethan")
-          tr.save
-
-          #hash['test_resource'].key?('age').should be_true
-          TestResource.include_nil_attributes_on_create = false
-        end
-      end
-    end
-    
-    context "Updating old records" do
-      before(:all) do
-        TestResource.reload_class_attributes
-        TestResource.has_many :has_many_objects
-        RestClient::Payload.stubs(:has_file? => false)
-      end
-
-      it "should be able to put updated data via the update method and
-        should only include changed attributes when updating" do
-
-        # Note that age is a non-nil attribute and is present in the
-        # put request, but name is not present since it has not changed.
-
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"age\":6}}", 
-          TestResource.headers
-        )
-
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.should_not be_new
-        
-        # Thus we know we are calling update
-        tr.age = 6
-        tr.save
-      end
-      
-
-      it "should include changed associations without specification" do
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"has_many_objects\":[{}]}}", 
-          TestResource.headers
-        )
-
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.has_many_objects = [HasManyObject.new]
-        tr.save
-      end
-      
-
-      it "should include unchanged associations if they are specified" do
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"has_many_objects\":[]}}", 
-          TestResource.headers
-        )
-
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.save(:has_many_objects)
-      end
-      
-
-      it "should not include nil attributes of associated objects when updating,
-        unless the attributes have changed to nil" do
-
-        correct_order = sequence("ordering")
-
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"has_one_object\":{\"size\":\"large\"}}}", 
-          TestResource.headers
-        ).in_sequence(correct_order)
-
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.has_one_object = HasOneObject.new(:size => "large", :color => nil)
-        tr.save(:include_associations => [:has_one_object])
-
-
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"has_one_object\":{\"size\":null}}}", 
-          TestResource.headers
-        ).in_sequence(correct_order)
-
-        tr.has_one_object.size = nil
-        tr.save(:include_associations => [:has_one_object])
-      end
-
-
-      it "should not include nil values for association objects when updating,
-        unless the association has changed to nil" do
-
-        correct_order = sequence("ordering")
-
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"has_one_object\":{\"size\":\"large\"}}}", 
-          TestResource.headers
-        ).in_sequence(correct_order)
-
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.has_one_object = HasOneObject.new(:size => "large", :color => nil)
-        tr.save(:include_associations => [:has_one_object])
-
-
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"has_one_object\":null}}", 
-          TestResource.headers
-        ).in_sequence(correct_order)
-
-        tr.has_one_object = nil
-        tr.save(:include_associations => [:has_one_object])
-      end
-
-
-      it "should include all attributes if include_all_attributes_on_update is true" do  
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"name\":\"Ethan\",\"age\":null,\"is_active\":null,\"bday\":null,\"roles\":[]}}", 
-          TestResource.headers
-        )
-
-        TestResource.include_all_attributes_on_update = true
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.save
-        TestResource.include_all_attributes_on_update = false
-      end
-    
-      it "should provide an update_attributes method to set attrs and save" do
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"name\":\"Dan\"}}", 
-          TestResource.headers
-        )
-
-        tr = TestResource.new(:id => 1, :name => "Ethan")
-        tr.update_attributes(:name => "Dan")
-      end
-      
-
-      it "should include nil attributes when updating if they have 
-        changed by default" do
-        
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"is_active\":null}}", 
-          TestResource.headers
-        )
-
-        tr = TestResource.new(
-          :id => "1", :name => "Ethan", :is_active => false
-        )
-        tr.update_attributes(:is_active => nil)
-      end
-
-      it "should include attributes that have changed to false by default" do
-        ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          "{\"test_resource\":{\"is_active\":false}}", 
-          TestResource.headers
-        )
-
-        tr = TestResource.new(
-          :id => "1", :name => "Ethan", :is_active => true
-        )
-        tr.update_attributes(:is_active => false)
-
-      end
-      
-    end
-  
-  end
-  
-  describe "Deleting data" do
-    it "should be able to delete an id from the class method" do
-      TestResource.delete(1).should be_true
-    end
-    
-    it "should be able to destroy itself as an instance" do
-      tr = TestResource.new(:id => 1, :name => "Ethan")
-      tr.destroy.should be_true
-    end
-  end
-  
-  describe "Random methods" do
-    
-    it "should know if it is persisted" do
-      tr = TestResource.new(:id => 1, :name => "Ethan")
-      tr.persisted?.should be_true
-      tr = TestResource.new(:name => "Ethan")
-      tr.persisted?.should be_false
-    end
-
-    it "should know how to reload attributes" do
-      tr = TestResource.find(1)
-
-      tr.age = 47
-      tr.name = "Ethan"
-
-      tr.reload
-
-      tr.age.should eql "age"
-      tr.name.should eql "name"
-    end
-
-    it "should know how to reload associations" do
-      tr = TestResource.find(1)
-
-      tr.has_one_object.size = "small"
-      tr.has_many_objects.first.name = "Ethan"
-
-      tr.has_one_object.size.should eql "small"
-      tr.has_many_objects.first.name.should eql "Ethan"
-
-      tr.reload
-
-      tr.has_one_object.size.should eql "large"
-      tr.has_many_objects.first.name.should eql "name"
-    end
-    
-  end
-  
-  describe "Inheritable Accessors" do
-    
-    it "should copy the default values down to any level of subclass" do
-      
-      class Child < TestResource
-      end
-      
-      Child.site.should eql(TestResource.site)
-      Child.site.should_not be_blank
-    end
-    
-  end
-  
-  describe "Inflections" do
-    
-    it "should be able to singularize and pluralize words ending in ess" do
-      "address".singularize.should eql("address")
-      "address".pluralize.should eql("addresses")
-    end
-    
-  end
-
-  context ".get" do
-
-    context "with ttl" do
-      around(:each) do |example|
-
-        begin
-          initial = ApiResource::Base.ttl
-          ApiResource::Base.ttl = 1
-          example.run
-        ensure 
-          ApiResource::Base.ttl = initial
-        end
-
-      end
-
-      it "should implement caching using the ttl setting" do
-        cache = mock(:fetch => {:id => 123, :name => "Dan"})
-        ApiResource.stubs(:cache => cache)
-        TestResource.find(123)
-      end
-      
-      it "should find with expires_in and cache" do
-        ApiResource.cache.expects(:fetch).with(anything, :expires_in => 10.0).returns({:id => 2, :name => "d"})
-        res = TestResource.find("adfa", :expires_in => 10)
-        
-        ApiResource::Base.ttl.should eql(1)
-        res.id.to_i.should eql(2)
-      end
-    end
-
-  end
-
-  context ".respond_to?" do
-
-    it "should load the resouce definition when respond_to? is called" do
-      # remove our attribute that denotes that the definition was loaded
-      TestResource.send(:remove_instance_variable, :@class_data)
-      TestResource.expects(:set_class_attributes_upon_load)
-      TestResource.respond_to?(:test)
-    end
-
-    it "should not load the resource definition when respond_to? is called
-      if the definition has already been loaded" do
-      TestResource.expects(:set_class_attributes_upon_load).never
-      TestResource.send(:respond_to?, :some_method)
-    end
-
-  end
-
-
-  
-end