api_resource 0.6.18 → 0.6.19

data/spec/lib/attributes_spec.rb

@@ -7,30 +7,25 @@ describe "Attributes" do
   before(:all) do
     TestResource.reload_class_attributes
   end
-  
+
   after(:all) do
     TestResource.reload_class_attributes
   end
 
   context "setters" do
 
-    it "should allow setting of protected attributes individually" do
-      test_resource = TestResource.new
-      test_resource.protected_attr = 100
-      test_resource.protected_attr.should eql(100)
-    end
-
-    it "should not allow mass assignment of protected attributes" do
+    it "should not allow setting of protected attributes individually" do
       test_resource = TestResource.new
       lambda{
-        test_resource.attributes = {:protected_attr => 100}  
-      }.should raise_error
-    end
+        test_resource.protected_attr = 100
+      }.should raise_error NoMethodError
 
-    it "should not allow mass assignment in the constructor" do
-      lambda{
-        TestResource.new({:protected_attr => 100})
-      }.should raise_error
+      lambda {
+        test_resource.attributes = { protected_attr: 100 }
+      }.should_not raise_error ApiResource::AttributeAccessError
+
+      test_resource = TestResource.new(protected_attr: 100)
+      test_resource.protected_attr.should eql(100)
     end
 
   end
@@ -42,7 +37,7 @@ describe "Attributes" do
       TestResource.attribute?(:attr1).should be_true
       TestResource.attribute?(:attr2).should be_true
     end
-    
+
 
     describe "Determining Attributes, Scopes, and Associations from the server" do
 
@@ -51,12 +46,12 @@ describe "Attributes" do
         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
@@ -72,7 +67,7 @@ describe "Attributes" do
         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
@@ -92,9 +87,9 @@ describe "Attributes" do
     context "Attributes" do
       before(:all) do
         TestResource.define_attributes :attr1, :attr2
-        TestResource.define_protected_attributes :attr3
+        TestResource.define_attributes :attr3, access_level: :protected
       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
@@ -102,14 +97,12 @@ describe "Attributes" do
         tst.attr1 = "test"
         tst.attr1.should eql("test")
       end
-    
-      it "should create protected attributes for unknown attributes trying to be loaded" do
-        
-        TestResource.connection.stubs(:get => {:attr1 => "attr1", :attr3 => "attr3"})
+
+      it "should allow access to an unknown attribute through method missing" do
+        TestResource.connection.stubs(:get => {:attr1 => "attr1", :attr5 => "attr5"})
         tst = TestResource.find(1)
 
-        tst.attr3?.should be_true
-        tst.attr3.should eql("attr3")
+        tst.attr5.should eql("attr5")
       end
     end
 
@@ -120,7 +113,7 @@ describe "Attributes" do
       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
@@ -130,20 +123,20 @@ describe "Attributes" do
       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
+      TestResource.define_attributes :attr1, :attr2, :attr4
       tst = TestResource.new
-      tst.attr3 = "123"
-      
+      tst.attr4 = "123"
+
       tst.attributes = {:attr1 => "abc", :attr2 => "test"}
       tst.attr1.should eql "abc"
       tst.attr2.should eql "test"
-      tst.attr3.should eql "123"
+      tst.attr4.should eql "123"
     end
-    
+
   end
-  
+
   context "Dirty tracking" do
     context "Changes to attributes" do
       it "should implement dirty tracking for attributes" do
@@ -153,57 +146,48 @@ describe "Attributes" do
         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.clear_changes
         tst.changed.should be_blank
       end
-      
-      it "should be able to reset any list of attributes" do
+
+      it "should be able to reset any attribute" do
         tst = TestResource.new
         tst.attr1 = "attr1"
-        tst.reset_attribute_changes :attr1
+        tst.reset_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.reset_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

@@ -4,7 +4,7 @@ require 'json'
 include ApiResource
 
 describe "Base" do
-  
+
   before(:each) do
     TestResource.reload_resource_definition
     HasOneObject.reload_resource_definition
@@ -14,15 +14,15 @@ describe "Base" do
 
   context ".instantiate_record" do
 
-    context "should handle blank associations and not load them 
+    context "should handle blank associations and not load them
       afterwards" do
 
       it "belongs_to_remote" do
         tr = TestResource.instantiate_record(
-          :name => "X",
-          :belongs_to_object => nil
+          name: "X",
+          belongs_to_object: nil
         )
-        # load our resource definition so we can say we never expect a 
+        # load our resource definition so we can say we never expect a
         # get
         BelongsToObject.reload_resource_definition
         BelongsToObject.connection.expects(:get).never
@@ -32,10 +32,10 @@ describe "Base" do
 
       it "has_one_remote" do
         tr = TestResource.instantiate_record(
-          :name => "X",
-          :has_one_object => nil
+          name: "X",
+          has_one_object: nil
         )
-        # load our resource definition so we can say we never expect a 
+        # load our resource definition so we can say we never expect a
         # get
         HasOneObject.reload_resource_definition
         HasOneObject.connection.expects(:get).never
@@ -45,10 +45,10 @@ describe "Base" do
 
       it "has_many_remote" do
         tr = TestResource.instantiate_record(
-          :name => "X",
-          :has_many_objects => []
+          name: "X",
+          has_many_objects: []
         )
-        # load our resource definition so we can say we never expect a 
+        # load our resource definition so we can say we never expect a
         # get
         HasManyObject.reload_resource_definition
         HasManyObject.connection.expects(:get).never
@@ -67,7 +67,7 @@ describe "Base" do
       ErrorResource.new
       orig_public_attr_names = ErrorResource.public_attribute_names
       orig_protected_attr_names = ErrorResource.protected_attribute_names
-      
+
       TestResource.new
 
       ErrorResource.public_attribute_names.should eql(
@@ -110,30 +110,6 @@ describe "Base" do
 
   end
 
-  context "#method_missing" do
-
-    after(:all) do
-      TestResource.reload_resource_definition
-    end
-
-    it "should attempt to reload the resource definition if a method
-      is not found" do
-
-      TestResource.class_eval do
-        remove_method :bday
-      end
-
-      tr = TestResource.new
-      
-      lambda{
-        tr.bday
-      }.should_not raise_error
-
-    end
-
-  end
-
-
   context "Prefixes" do
 
     before(:all) do
@@ -146,19 +122,20 @@ describe "Base" do
 
     context "#create" do
 
-      it "should place prefix data in the URL and remove it from 
+      it "should place prefix data in the URL and remove it from
         the parameters" do
 
         TestResource.connection.expects(:post).with(
-          "/belongs_to_objects/22/test_resources.json", JSON.unparse(
-            :test_resource => {
-              :name => "Dan"
+          "/belongs_to_objects/22/test_resources.json",
+          {
+            test_resource: {
+              'name' => 'Dan'
             }
-          ),
+          },
           TestResource.headers
         )
 
-        TestResource.create(:belongs_to_object_id => 22, :name => "Dan")
+        TestResource.create(belongs_to_object_id: 22, name: "Dan")
 
       end
 
@@ -174,10 +151,10 @@ describe "Base" do
       it "should allow grouping by resources with the same id" do
 
         test_resource_1 = TestResource.new
-        test_resource_1.stubs(:id => 1)
+        test_resource_1.stubs(id: 1)
 
         test_resource_2 = TestResource.new
-        test_resource_2.stubs(:id => 1)
+        test_resource_2.stubs(id: 1)
 
 
         ParentResource = Struct.new(:resource, :name)
@@ -195,22 +172,22 @@ describe "Base" do
 
   end
 
-  
+
   describe "Loading data from a hash" do
-    
+
 
     context ".instantiate_record" do
 
       it "should set boolean values" do
 
-        tr = TestResource.instantiate_record(:is_active => true)
+        tr = TestResource.instantiate_record(is_active: true)
         tr.is_active.should eql(true)
 
       end
 
       it "should set boolean values" do
 
-        tr = TestResource.instantiate_record(:is_active => false)
+        tr = TestResource.instantiate_record(is_active: false)
         tr.is_active.should eql(false)
 
       end
@@ -242,105 +219,105 @@ describe "Base" do
         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 = 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})
+          TestResource.new({has_many_objects: nil})
           lambda {
-            TestResource.new({:has_many_objects => "invalid"})
+            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'}]
+            has_many_objects: [{service_uri: '/path'}]
           })
           tst.has_many_objects.remote_path.should eql('/path')
 
           tst = TestResource.new({
-            :has_many_objects => {:service_uri => '/path'}
+            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 = 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 
+
+        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 => [])
+            TestResource.new(belongs_to_object: [])
           }.should raise_error
           lambda {
-            TestResource.new(:has_one_object => [])
+            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"
+            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")
+      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
@@ -350,18 +327,18 @@ describe "Base" do
 
     it "should only allow proper formats to be set" do
       expect {TestResource.format = :blah}.to raise_error(::ApiResource::Formats::BadFormat)
-    end 
-    
+    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
-    
+
+  context 'Serialization' do
+
     before(:each) do
       TestResource.reload_resource_definition
       TestResource.has_many :has_many_objects
@@ -372,277 +349,206 @@ describe "Base" do
     after(:all) do
       TestResource.include_root_in_json = true
     end
-      
-    
-    context "JSON" do
-      
+
+    context "#to_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"})
+
+        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"})
+        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
-
-        TestResource.class_eval do
-          define_protected_attributes(:attr3)
-        end
 
-        tst = TestResource.instantiate_record({
-          :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.instantiate_record({
-          :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_resource_definition
-        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"}
-            ]
-          })
-          tst.has_many_objects.first.id
-          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
-      
+
+    context "#to_xml" do
       it "should only be able to serialize itself with the root" do
-        tst = TestResource.new({:attr1 => "attr1", :attr2 => "attr2"})
+        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({
-          :has_many_objects => []
+          has_many_objects: []
         })
-        hash = Hash.from_xml(tst.to_xml(:include_associations => [: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_resource_definition
     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_resource_definition
     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 save method" do
-        tr = TestResource.build({:name => "Ethan", :age => 20})
+        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}}", 
+            "/test_resources.json",
+            {
+              test_resource: {
+                'name' => 'Ethan',
+                'age' => 20
+              }
+            },
             TestResource.headers
           )
 
-          tr = TestResource.build(:name => "Ethan", :age => 20)
+          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\"}}", 
+            "/test_resources.json",
+            {
+              test_resource: {
+                'name' => 'Ethan'
+              }
+            },
             TestResource.headers
           )
 
-          tr = TestResource.build(:name => "Ethan")
+          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}}", 
+            "/test_resources.json",
+            {
+              test_resource: {
+                'name' => 'Ethan',
+                'is_active' => false
+              }
+            },
             TestResource.headers
           )
 
-          tr = TestResource.build(:name => "Ethan", :is_active => false)
+          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\"}}}", 
+            "/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])
+          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}}", 
+            "/test_resources.json",
+            {
+              test_resource: {
+                'name' => 'Ethan',
+                'age' => nil
+              }
+            },
             TestResource.headers
           )
 
-          tr = TestResource.build(:name => "Ethan")
-          tr.save(:include_extras => [:age])
+          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", JSON.unparse(
-              :test_resource => {
-                :name => "Ethan",
-                :age => nil,
-                :is_active => nil,
-                :belongs_to_object_id => nil,
-                :custom_name_id => nil,
-                :bday => nil,
-                :roles => []
+            "/test_resources.json", {
+              test_resource: {
+                'name' => "Ethan",
+                'age' => nil,
+                'is_active' => nil,
+                'belongs_to_object_id' => nil,
+                'custom_name_id' => nil,
+                'bday' => nil,
+                'roles' => []
               }
-            ),
+            },
             TestResource.headers
           )
 
           TestResource.include_nil_attributes_on_create = true
-          tr = TestResource.build(:name => "Ethan")
+          tr = TestResource.build(name: "Ethan")
           tr.save
 
           #hash['test_resource'].key?('age').should be_true
@@ -650,13 +556,12 @@ describe "Base" do
         end
       end
     end
-    
+
     context "Updating old records" do
       before(:all) do
         TestResource.reload_resource_definition
         HasOneObject.reload_resource_definition
         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
@@ -666,67 +571,67 @@ describe "Base" do
         # put request, but name is not present since it has not changed.
 
         ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          JSON.unparse({
-            :test_resource => {
-              :name => "Ethan", 
-              :age => 6
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'name' => "Ethan",
+              'age' => 6
             }
-          }), 
+          },
           TestResource.headers
         )
 
-        tr = TestResource.new(:name => "Ethan")
-        tr.stubs(:id => 1)
+        tr = TestResource.new(name: "Ethan")
+        tr.stubs(id: 1)
         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", 
-          JSON.unparse({
-            :test_resource => {
-              :name => "Ethan", 
-              :has_many_objects => [{:name => "Test"}]
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'name' => "Ethan",
+              'has_many_objects' => [{'name' => "Test"}]
             }
-          }),  
+          },
           TestResource.headers
         )
 
         tr = TestResource.new(
-          :name => "Ethan", 
-          :has_many_objects => [{:id => 12, :name => "Dan"}]
+          name: "Ethan",
+          has_many_objects: [{id: 12, name: "Dan"}]
         )
-        tr.stubs(:id => 1)
+        tr.stubs(id: 1)
 
-        tr.has_many_objects = [HasManyObject.new(:name => "Test")]
+        tr.has_many_objects = [HasManyObject.new(name: "Test")]
         tr.save
       end
-      
+
 
       it "should include unchanged associations if they are specified" do
         ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          JSON.unparse({
-            :test_resource => {
-              :name => "Ethan", 
-              :has_many_objects => []
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'name' => "Ethan",
+              'has_many_objects' => []
             }
-          }), 
+          },
           TestResource.headers
         )
 
-        tr = TestResource.new(:name => "Ethan", :has_many_objects => [])
-        tr.stubs(:id => 1)
+        tr = TestResource.new(name: "Ethan", has_many_objects: [])
+        tr.stubs(id: 1)
 
-        tr.save(:include_associations => [:has_many_objects])
+        tr.save(include_associations: [:has_many_objects])
       end
-      
+
 
       it "should not include nil attributes of associated objects when updating,
         unless the attributes have changed to nil" do
@@ -734,104 +639,108 @@ describe "Base" do
         correct_order = sequence("ordering")
 
         ApiResource::Connection.any_instance.expects(:put).with(
-          "/test_resources/1.json", 
-          JSON.unparse({
-            :test_resource => {
-              :name => "Ethan", 
-              :has_one_object => {
-                :size => "large"
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'name' => "Ethan",
+              'has_one_object' => {
+                'size' => "large"
               }
             }
-          }),
+          },
           TestResource.headers
         ).in_sequence(correct_order)
 
-        tr = TestResource.new(:name => "Ethan")
-        tr.stubs(:id => 1)
-        tr.has_one_object = HasOneObject.new(:size => "large", :color => nil)
-        tr.save(:include_associations => [:has_one_object])
+        tr = TestResource.new(name: "Ethan")
+        tr.stubs(id: 1)
+        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", 
-          JSON.unparse({
-            :test_resource => {
-              :has_one_object => {
-                :size => nil
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'has_one_object' => {
+                'size' => nil
               }
             }
-          }), 
+          },
           TestResource.headers
         ).in_sequence(correct_order)
 
         tr.has_one_object.size = nil
-        tr.save(:include_associations => [:has_one_object])
+        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
+      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", 
-          JSON.unparse({
-            :test_resource => {
-              :name => "Ethan", 
-              :has_one_object => {
-                :size => "large"
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'name' => "Ethan",
+              'has_one_object' => {
+                'size' => "large"
               }
             }
-          }),
+          },
           TestResource.headers
         ).in_sequence(correct_order)
 
-        tr = TestResource.new(:name => "Ethan")
-        tr.stubs(:id => 1)
-        tr.has_one_object = HasOneObject.new(:size => "large", :color => nil)
-        tr.save(:include_associations => [:has_one_object])
+        tr = TestResource.new(name: "Ethan")
+        tr.stubs(id: 1)
+        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}}", 
+          "/test_resources/1.json",
+          {
+            test_resource: {
+              'has_one_object' => nil
+            }
+          },
           TestResource.headers
         ).in_sequence(correct_order)
 
         tr.has_one_object = nil
-        tr.save(:include_associations => [:has_one_object])
+        tr.save(include_associations: [:has_one_object])
       end
 
 
-      it "should include all attributes if include_all_attributes_on_update is true" do  
-        
+      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", JSON.unparse(
-            :test_resource => {
-              :name => "Ethan",
-              :age => nil,
-              :is_active => nil,
-              :belongs_to_object_id => nil,
-              :custom_name_id => nil,
-              :bday => nil,
-              :roles => []
+          "/test_resources/1.json",{
+            test_resource: {
+              'name' => "Ethan",
+              'age' => nil,
+              'is_active' => nil,
+              'belongs_to_object_id' => nil,
+              'custom_name_id' => nil,
+              'bday' => nil,
+              'roles' => []
             }
-          ),
+          },
           TestResource.headers
         )
         begin
           TestResource.include_all_attributes_on_update = true
-          tr = TestResource.new(:name => "Ethan")
-          tr.stubs(:id => 1)
+          tr = TestResource.new(name: "Ethan")
+          tr.stubs(id: 1)
           tr.save
-        ensure 
+        ensure
           TestResource.include_all_attributes_on_update = false
         end
       end
-    
+
       it "should provide an update_attributes method to set attrs and save" do
-        
+
         correct_order = sequence("ordering")
 
         # initial save
@@ -840,22 +749,22 @@ describe "Base" do
 
         ApiResource::Connection.any_instance.expects(:put)
           .with(
-            "/test_resources/1.json", 
-             {:test_resource => {:name => "Dan"}}.to_json, 
+            "/test_resources/1.json",
+             {test_resource: {'name' => "Dan"}},
             TestResource.headers
           ).in_sequence(correct_order)
 
-        tr = TestResource.new(:name => "Ethan")
-        tr.stubs(:id => 1)
+        tr = TestResource.new(name: "Ethan")
+        tr.stubs(id: 1)
         tr.save
 
-        tr.update_attributes(:name => "Dan")
+        tr.update_attributes(name: "Dan")
       end
-      
 
-      it "should include nil attributes when updating if they have 
+
+      it "should include nil attributes when updating if they have
         changed by default" do
-        
+
         correct_order = sequence("ordering")
 
         # initial save
@@ -864,19 +773,19 @@ describe "Base" do
 
         ApiResource::Connection.any_instance.expects(:put)
           .with(
-            "/test_resources/1.json", 
-            {:test_resource => {:is_active => nil}}.to_json,
+            "/test_resources/1.json",
+            {test_resource: {"is_active" => nil}},
             TestResource.headers
           )
           .in_sequence(correct_order)
 
         tr = TestResource.new(
-          :name => "Ethan", :is_active => false
+          name: "Ethan", is_active: false
         )
-        tr.stubs(:id => 1)
+        tr.stubs(id: 1)
         tr.save
 
-        tr.update_attributes(:is_active => nil)
+        tr.update_attributes(is_active: nil)
       end
 
       it "should include attributes that have changed to false by default" do
@@ -889,58 +798,58 @@ describe "Base" do
         # update
         ApiResource::Connection.any_instance.expects(:put)
           .with(
-            "/test_resources/1.json", 
-            {:test_resource => {:is_active => false}}.to_json,
+            "/test_resources/1.json",
+            {test_resource: {"is_active" => false}},
             TestResource.headers
           ).in_sequence(correct_order)
 
         tr = TestResource.new(
-          :name => "Ethan", :is_active => true
+          name: "Ethan", is_active: true
         )
-        tr.stubs(:id => 1)
+        tr.stubs(id: 1)
         tr.save
 
-        tr.update_attributes(:is_active => false)
+        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(:name => "Ethan")
-      tr.stubs(:id => 1)
+      tr = TestResource.new(name: "Ethan")
+      tr.stubs(id: 1)
 
       tr.destroy.should be_true
     end
   end
-  
+
   describe "Random methods" do
 
-    before(:all) do
+    before(:each) {
+      TestResource.reload_resource_definition
       HasOneObject.reload_resource_definition
-      HasManyObject.load_resource_definition
-    end
-    
+      HasManyObject.reload_resource_definition
+    }
+
     it "should know if it is persisted" do
-      tr = TestResource.new(:name => "Ethan")
-      tr.stubs(:id => 1)
+      tr = TestResource.new(name: "Ethan")
+      tr.stubs(id: 1)
 
       tr.persisted?.should be_true
 
-      tr = TestResource.new(:name => "Ethan")
+      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"
 
@@ -952,7 +861,6 @@ describe "Base" do
 
     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"
 
@@ -964,29 +872,29 @@ describe "Base" do
       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
@@ -1001,25 +909,25 @@ describe "Base" do
             Object.send(:remove_const, :Rails)
           end
           example.run
-        ensure 
+        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)
+        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)
-        
+          .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
@@ -1046,5 +954,5 @@ describe "Base" do
   end
 
 
-  
+
 end