couchrest_model 2.1.0.rc1 → 2.2.0.beta1

data/spec/unit/property_protection_spec.rb

@@ -12,16 +12,16 @@ describe "Model Attributes" do
     it "should not protect anything through new" do
       user = NoProtection.new(:name => "will", :phone => "555-5555")
 
-      user.name.should == "will"
-      user.phone.should == "555-5555"
+      expect(user.name).to eq("will")
+      expect(user.phone).to eq("555-5555")
     end
 
     it "should not protect anything through attributes=" do
       user = NoProtection.new
       user.attributes = {:name => "will", :phone => "555-5555"}
 
-      user.name.should == "will"
-      user.phone.should == "555-5555"
+      expect(user.name).to eq("will")
+      expect(user.phone).to eq("555-5555")
     end
 
     it "should recreate from the database properly" do
@@ -31,14 +31,14 @@ describe "Model Attributes" do
       user.save!
 
       user = NoProtection.get(user.id)
-      user.name.should == "will"
-      user.phone.should == "555-5555"
+      expect(user.name).to eq("will")
+      expect(user.phone).to eq("555-5555")
     end
 
     it "should provide a list of all properties as accessible" do
       user = NoProtection.new(:name => "will", :phone => "555-5555")
-      user.accessible_properties.length.should eql(2)
-      user.protected_properties.should be_empty
+      expect(user.accessible_properties.length).to eql(2)
+      expect(user.protected_properties).to be_empty
     end
   end
 
@@ -53,29 +53,29 @@ describe "Model Attributes" do
 
     it "should recognize accessible properties" do
       props = WithAccessible.accessible_properties.map { |prop| prop.name}
-      props.should include("name")
-      props.should_not include("admin")
+      expect(props).to include("name")
+      expect(props).not_to include("admin")
     end
 
     it "should protect non-accessible properties set through new" do
       user = WithAccessible.new(:name => "will", :admin => true)
 
-      user.name.should == "will"
-      user.admin.should == false
+      expect(user.name).to eq("will")
+      expect(user.admin).to eq(false)
     end
 
     it "should protect non-accessible properties set through attributes=" do
       user = WithAccessible.new
       user.attributes = {:name => "will", :admin => true}
 
-      user.name.should == "will"
-      user.admin.should == false
+      expect(user.name).to eq("will")
+      expect(user.admin).to eq(false)
     end
     
     it "should provide correct accessible and protected property lists" do
       user = WithAccessible.new(:name => 'will', :admin => true)
-      user.accessible_properties.map{|p| p.to_s}.should eql(['name'])
-      user.protected_properties.map{|p| p.to_s}.should eql(['admin'])
+      expect(user.accessible_properties.map{|p| p.to_s}).to eql(['name'])
+      expect(user.protected_properties.map{|p| p.to_s}).to eql(['admin'])
     end
   end
 
@@ -90,37 +90,37 @@ describe "Model Attributes" do
 
     it "should recognize protected properties" do
       props = WithProtected.protected_properties.map { |prop| prop.name}
-      props.should_not include("name")
-      props.should include("admin")
+      expect(props).not_to include("name")
+      expect(props).to include("admin")
     end
 
     it "should protect non-accessible properties set through new" do
       user = WithProtected.new(:name => "will", :admin => true)
 
-      user.name.should == "will"
-      user.admin.should == false
+      expect(user.name).to eq("will")
+      expect(user.admin).to eq(false)
     end
 
     it "should protect non-accessible properties set through attributes=" do
       user = WithProtected.new
       user.attributes = {:name => "will", :admin => true}
 
-      user.name.should == "will"
-      user.admin.should == false
+      expect(user.name).to eq("will")
+      expect(user.admin).to eq(false)
     end
 
     it "should not modify the provided attribute hash" do
       user = WithProtected.new
       attrs = {:name => "will", :admin => true}
       user.attributes = attrs
-      attrs[:admin].should be_true
-      attrs[:name].should eql('will')
+      expect(attrs[:admin]).to be_truthy
+      expect(attrs[:name]).to eql('will')
     end
 
     it "should provide correct accessible and protected property lists" do
       user = WithProtected.new(:name => 'will', :admin => true)
-      user.accessible_properties.map{|p| p.to_s}.should eql(['name'])
-      user.protected_properties.map{|p| p.to_s}.should eql(['admin'])
+      expect(user.accessible_properties.map{|p| p.to_s}).to eql(['name'])
+      expect(user.protected_properties.map{|p| p.to_s}).to eql(['admin'])
     end
 
   end
@@ -138,9 +138,9 @@ describe "Model Attributes" do
     it 'should assume that any unspecified property is protected by default' do
       user = WithBothAndUnspecified.new(:name => 'will', :admin => true, :phone => '555-1234')
 
-      user.name.should == 'will'
-      user.admin.should == false
-      user.phone.should == 'unset phone number'
+      expect(user.name).to eq('will')
+      expect(user.admin).to eq(false)
+      expect(user.phone).to eq('unset phone number')
     end
 
   end
@@ -163,8 +163,8 @@ describe "Model Attributes" do
     end
 
     def verify_attrs(user)
-      user.name.should  == "will"
-      user.admin.should == true
+      expect(user.name).to  eq("will")
+      expect(user.admin).to eq(true)
     end
 
     it "Base#get should not strip protected attributes" do
@@ -180,7 +180,7 @@ describe "Model Attributes" do
     it "Base#all should not strip protected attributes" do
       # all creates a CollectionProxy
       docs = WithProtected.all(:key => @user.id)
-      docs.length.should == 1
+      expect(docs.length).to eq(1)
       reloaded = docs.first
       verify_attrs reloaded
     end

data/spec/unit/property_spec.rb

@@ -3,504 +3,113 @@ require 'spec_helper'
 
 describe CouchRest::Model::Property do
 
-  before(:each) do
-    reset_test_db!
-    @card = Card.new(:first_name => "matt")
-  end
-
-  it "should be accessible from the object" do
-    @card.properties.should be_an_instance_of(Array)
-    @card.properties.map{|p| p.name}.should include("first_name")
-  end
-
-  it "should list object properties with values" do
-    @card.properties_with_values.should be_an_instance_of(Hash)
-    @card.properties_with_values["first_name"].should == "matt"
-  end
-
-  it "should let you access a property value (getter)" do
-    @card.first_name.should == "matt"
-  end
-
-  it "should let you set a property value (setter)" do
-    @card.last_name = "Aimonetti"
-    @card.last_name.should == "Aimonetti"
-  end
-
-  it "should not let you set a property value if it's read only" do
-    lambda{@card.read_only_value = "test"}.should raise_error
-  end
-
-  it "should let you use an alias for an attribute" do
-    @card.last_name = "Aimonetti"
-    @card.family_name.should == "Aimonetti"
-    @card.family_name.should == @card.last_name
-  end
-
-  it "should let you use an alias for a casted attribute" do
-    @card.cast_alias = Person.new(:name => ["Aimonetti"])
-    @card.cast_alias.name.should == ["Aimonetti"]
-    @card.calias.name.should == ["Aimonetti"]
-    card = Card.new(:first_name => "matt", :cast_alias => {:name => ["Aimonetti"]})
-    card.cast_alias.name.should == ["Aimonetti"]
-    card.calias.name.should == ["Aimonetti"]
-  end
-
-  it "should raise error if property name coincides with model type key" do
-    lambda { Cat.property(Cat.model_type_key) }.should raise_error(/already used/)
-  end
-
-  it "should not raise error if property name coincides with model type key on non-model" do
-    lambda { Person.property(Article.model_type_key) }.should_not raise_error
-  end
-
-  it "should be auto timestamped" do
-    @card.created_at.should be_nil
-    @card.updated_at.should be_nil
-    @card.save.should be_true
-    @card.created_at.should_not be_nil
-    @card.updated_at.should_not be_nil
-  end
-
-  describe "#as_couch_json" do
-
-    it "should provide a simple hash from model" do
-      @card.as_couch_json.class.should eql(Hash)
-    end
-
-    it "should remove properties from Hash if value is nil" do
-      @card.last_name = nil
-      @card.as_couch_json.keys.include?('last_name').should be_false
-    end
-
-  end
-
-  describe "#as_json" do
-
-    it "should provide a simple hash from model" do
-      @card.as_json.class.should eql(Hash)
-    end
-
-    it "should pass options to Active Support's as_json" do
-      @card.last_name = "Aimonetti"
-      @card.as_json(:only => 'last_name').should eql('last_name' => 'Aimonetti')
-    end
-
-  end
-
-  describe '#read_attribute' do
-    it "should let you use read_attribute method" do
-      @card.last_name = "Aimonetti"
-      @card.read_attribute(:last_name).should eql('Aimonetti')
-      @card.read_attribute('last_name').should eql('Aimonetti')
-      last_name_prop = @card.properties.find{|p| p.name == 'last_name'}
-      @card.read_attribute(last_name_prop).should eql('Aimonetti')
-    end
-
-    it 'should raise an error if the property does not exist' do
-      expect { @card.read_attribute(:this_property_should_not_exist) }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#write_attribute' do
-    it "should let you use write_attribute method" do
-      @card.write_attribute(:last_name, 'Aimonetti 1')
-      @card.last_name.should eql('Aimonetti 1')
-      @card.write_attribute('last_name', 'Aimonetti 2')
-      @card.last_name.should eql('Aimonetti 2')
-      last_name_prop = @card.properties.find{|p| p.name == 'last_name'}
-      @card.write_attribute(last_name_prop, 'Aimonetti 3')
-      @card.last_name.should eql('Aimonetti 3')
-    end
-
-    it 'should raise an error if the property does not exist' do
-      expect { @card.write_attribute(:this_property_should_not_exist, 823) }.to raise_error(ArgumentError)
-    end
-
-
-    it "should let you use write_attribute on readonly properties" do
-      lambda {
-        @card.read_only_value = "foo"
-      }.should raise_error
-      @card.write_attribute(:read_only_value, "foo")
-      @card.read_only_value.should == 'foo'
-    end
-
-    it "should cast via write_attribute" do
-      @card.write_attribute(:cast_alias, {:name => ["Sam", "Lown"]})
-      @card.cast_alias.class.should eql(Person)
-      @card.cast_alias.name.last.should eql("Lown")
-    end
-
-    it "should not cast via write_attribute if property not casted" do
-      @card.write_attribute(:first_name, {:name => "Sam"})
-      @card.first_name.class.should eql(Hash)
-      @card.first_name[:name].should eql("Sam")
-    end
-  end
-
-  describe "mass updating attributes without property" do
-    
-    describe "when mass_assign_any_attribute false" do
-      
-      it "should not allow them to be set" do
-        @card.attributes = {:test => 'fooobar'}
-        @card['test'].should be_nil
-      end
-
-     it 'should not allow them to be updated with update_attributes' do
-       @card.update_attributes(:test => 'fooobar')
-       @card['test'].should be_nil
-     end
-
-     it 'should not have a different revision after update_attributes' do
-       @card.save
-       rev = @card.rev
-       @card.update_attributes(:test => 'fooobar')
-       @card.rev.should eql(rev)
-     end
-
-     it 'should not have a different revision after save' do
-       @card.save
-       rev = @card.rev
-       @card.attributes = {:test => 'fooobar'}
-       @card.save
-       @card.rev.should eql(rev)
-     end
-
-    end
-
-    describe "when mass_assign_any_attribute true" do
-      before(:each) do
-        # dup Card class so that no other tests are effected
-        card_class = Card.dup
-        card_class.class_eval do
-          mass_assign_any_attribute true
-        end
-        @card = card_class.new(:first_name => 'Sam')
-      end
-
-      it 'should allow them to be updated' do
-        @card.attributes = {:testing => 'fooobar'}
-        @card['testing'].should eql('fooobar')
-      end
-
-      it 'should allow them to be updated with update_attributes' do
-        @card.update_attributes(:testing => 'fooobar')
-        @card['testing'].should eql('fooobar')
-      end
-
-      it 'should have a different revision after update_attributes' do
-        @card.save
-        rev = @card.rev
-        @card.update_attributes(:testing => 'fooobar')
-        @card.rev.should_not eql(rev)
-      end
-
-      it 'should have a different revision after save' do
-        @card.save
-        rev = @card.rev
-        @card.attributes = {:testing => 'fooobar'}
-        @card.save
-        @card.rev.should_not eql(rev)
-      end
-
-    end
-  end
-
-  describe "mass assignment protection" do
-
-    it "should not store protected attribute using mass assignment" do
-      cat_toy = CatToy.new(:name => "Zorro")
-      cat = Cat.create(:name => "Helena", :toys => [cat_toy], :favorite_toy => cat_toy, :number => 1)
-      cat.number.should be_nil
-      cat.number = 1
-      cat.save
-      cat.number.should == 1
-    end
-
-    it "should not store protected attribute when 'declare accessible poperties, assume all the rest are protected'" do
-      user = User.create(:name => "Marcos Tapajós", :admin => true)
-      user.admin.should be_nil
-    end
-
-    it "should not store protected attribute when 'declare protected properties, assume all the rest are accessible'" do
-      user = SpecialUser.create(:name => "Marcos Tapajós", :admin => true)
-      user.admin.should be_nil
-    end
-
-  end
-
-  describe "validation" do
-    before(:each) do
-      @invoice = Invoice.new(:client_name => "matt", :employee_name => "Chris", :location => "San Diego, CA")
-    end
-
-    it "should be able to be validated" do
-      @card.valid?.should == true
-    end
-
-    it "should let you validate the presence of an attribute" do
-      @card.first_name = nil
-      @card.should_not be_valid
-      @card.errors.should_not be_empty
-      @card.errors[:first_name].should == ["can't be blank"]
-    end
-
-    it "should let you look up errors for a field by a string name" do
-      @card.first_name = nil
-      @card.should_not be_valid
-      @card.errors['first_name'].should == ["can't be blank"]
-    end
-
-    it "should validate the presence of 2 attributes" do
-      @invoice.clear
-      @invoice.should_not be_valid
-      @invoice.errors.should_not be_empty
-      @invoice.errors[:client_name].should == ["can't be blank"]
-      @invoice.errors[:employee_name].should_not be_empty
-    end
-
-    it "should let you set an error message" do
-      @invoice.location = nil
-      @invoice.valid?
-      @invoice.errors[:location].should == ["Hey stupid!, you forgot the location"]
-    end
-
-    it "should validate before saving" do
-      @invoice.location = nil
-      @invoice.should_not be_valid
-      @invoice.save.should be_false
-      @invoice.should be_new
-    end
-  end
-
-end
-
-describe "properties of hash of casted models" do
-  it "should be able to assign a casted hash to a hash property" do
-    chain = KeyChain.new
-    keys = {"House" => "8==$", "Office" => "<>==U"}
-    chain.keys = keys
-    chain.keys = chain.keys
-    chain.keys.should == keys
-  end
-end
-
-describe "properties of array of casted models" do
-
-  before(:each) do
-    @course = Course.new :title => 'Test Course'
-  end
-
-  it "should allow attribute to be set from an array of objects" do
-    @course.questions = [Question.new(:q => "works?"), Question.new(:q => "Meaning of Life?")]
-    @course.questions.length.should eql(2)
-  end
-
-  it "should allow attribute to be set from an array of hashes" do
-    @course.questions = [{:q => "works?"}, {:q => "Meaning of Life?"}]
-    @course.questions.length.should eql(2)
-    @course.questions.last.q.should eql("Meaning of Life?")
-    @course.questions.last.class.should eql(Question) # typecasting
-  end
-
-  it "should allow attribute to be set from hash with ordered keys and objects" do
-    @course.questions = { '0' => Question.new(:q => "Test1"), '1' => Question.new(:q => 'Test2') }
-    @course.questions.length.should eql(2)
-    @course.questions.last.q.should eql('Test2')
-    @course.questions.last.class.should eql(Question)
-  end
-
-  it "should allow attribute to be set from hash with ordered keys and sub-hashes" do
-    @course.questions = { '10' => {:q => 'Test10'}, '0' => {:q => "Test1"}, '1' => {:q => 'Test2'} }
-    @course.questions.length.should eql(3)
-    @course.questions.last.q.should eql('Test10')
-    @course.questions.last.class.should eql(Question)
-  end
-
-  it "should allow attribute to be set from hash with ordered keys and HashWithIndifferentAccess" do
-    # This is similar to what you'd find in an HTML POST parameters
-    hash = HashWithIndifferentAccess.new({ '0' => {:q => "Test1"}, '1' => {:q => 'Test2'} })
-    @course.questions = hash
-    @course.questions.length.should eql(2)
-    @course.questions.last.q.should eql('Test2')
-    @course.questions.last.class.should eql(Question)
-  end
-
-  it "should allow attribute to be set from Hash subclass with ordered keys" do
-    ourhash = Class.new(HashWithIndifferentAccess)
-    hash = ourhash.new({ '0' => {:q => "Test1"}, '1' => {:q => 'Test2'} })
-    @course.questions = hash
-    @course.questions.length.should eql(2)
-    @course.questions.last.q.should eql('Test2')
-    @course.questions.last.class.should eql(Question)
-  end
-
-  it "should raise an error if attempting to set single value for array type" do
-    lambda {
-      @course.questions = Question.new(:q => 'test1')
-    }.should raise_error(/Expecting an array/)
-  end
-
-
-end
-
-describe "a casted model retrieved from the database" do
-  before(:each) do
-    reset_test_db!
-    @cat = Cat.new(:name => 'Stimpy')
-    @cat.favorite_toy = CatToy.new(:name => 'Stinky')
-    @cat.toys << CatToy.new(:name => 'Feather')
-    @cat.toys << CatToy.new(:name => 'Mouse')
-    @cat.save
-    @cat = Cat.get(@cat.id)
-  end
-
-  describe "as a casted property" do
-    it "should already be casted_by its parent" do
-      @cat.favorite_toy.casted_by.should === @cat
-    end
-  end
-
-  describe "from a casted collection" do
-    it "should already be casted_by its parent" do
-      @cat.toys[0].casted_by.should === @cat
-      @cat.toys[1].casted_by.should === @cat
-    end
-  end
-end
-
-describe "nested models (not casted)" do
-  before(:each) do
-    reset_test_db!
-    @cat = ChildCat.new(:name => 'Stimpy')
-    @cat.mother = {:name => 'Stinky'}
-    @cat.siblings = [{:name => 'Feather'}, {:name => 'Felix'}]
-    @cat.save
-    @cat = ChildCat.get(@cat.id)
-  end
-
-  it "should correctly save single relation" do
-    @cat.mother.name.should eql('Stinky')
-    @cat.mother.casted_by.should eql(@cat)
-  end
-
-  it "should correctly save collection" do
-    @cat.siblings.first.name.should eql("Feather")
-    @cat.siblings.last.casted_by.should eql(@cat)
-  end
-end
-
-describe "Property Class" do
-
   let :klass do
     CouchRest::Model::Property
   end
 
   it "should provide name as string" do
     property = CouchRest::Model::Property.new(:test, :type => String)
-    property.name.should eql('test')
-    property.to_s.should eql('test')
+    expect(property.name).to eql('test')
+    expect(property.to_s).to eql('test')
   end
 
   it "should provide name as a symbol" do 
     property = CouchRest::Model::Property.new(:test, :type => String)
-    property.name.to_sym.should eql(:test)
-    property.to_sym.should eql(:test)
+    expect(property.name.to_sym).to eql(:test)
+    expect(property.to_sym).to eql(:test)
   end
 
   it "should provide class from type" do
     property = CouchRest::Model::Property.new(:test, :type => String)
-    property.type.should eql(String)
-    property.array.should be_false
+    expect(property.type).to eql(String)
+    expect(property.array).to be_falsey
   end
 
   it "should provide base class from type in array" do
     property = CouchRest::Model::Property.new(:test, :type => [String])
-    property.type.should eql(String)
-    property.array.should be_true
+    expect(property.type).to eql(String)
+    expect(property.array).to be_truthy
   end
 
   it "should provide base class and set array type" do
     property = CouchRest::Model::Property.new(:test, :type => String, :array => true)
-    property.type.should eql(String)
-    property.array.should be_true
+    expect(property.type).to eql(String)
+    expect(property.array).to be_truthy
   end
 
   it "should raise error if type as string requested" do
-    lambda {
-      property = CouchRest::Model::Property.new(:test, :type => 'String')
-    }.should raise_error
+    expect {
+      CouchRest::Model::Property.new(:test, :type => 'String')
+    }.to raise_error(/Defining a property type as a String is not supported/)
   end
 
   it "should leave type nil and return class as nil also" do
     property = CouchRest::Model::Property.new(:test, :type => nil)
-    property.type.should be_nil
+    expect(property.type).to be_nil
   end
 
   it "should convert empty type array to [Object]" do
     property = CouchRest::Model::Property.new(:test, :type => [])
-    property.type.should eql(Object)
+    expect(property.type).to eql(Object)
   end
 
   it "should set init method option or leave as 'new'" do
     # (bad example! Time already typecast)
     property = CouchRest::Model::Property.new(:test, :type => Time)
-    property.init_method.should eql('new')
+    expect(property.init_method).to eql('new')
     property = CouchRest::Model::Property.new(:test, :type => Time, :init_method => 'parse')
-    property.init_method.should eql('parse')
+    expect(property.init_method).to eql('parse')
   end
 
   it "should set the allow_blank option to true by default" do
     property = CouchRest::Model::Property.new(:test, :type => String)
-    property.allow_blank.should be_true
+    expect(property.allow_blank).to be_truthy
   end
 
   it "should allow setting of the allow_blank option to false" do
     property = CouchRest::Model::Property.new(:test, :type => String, :allow_blank => false)
-    property.allow_blank.should be_false
+    expect(property.allow_blank).to be_falsey
   end
 
   it "should convert block to type" do
     prop = klass.new(:test) do
       property :testing
     end
-    prop.array.should be_false
-    prop.type.should_not be_nil
-    prop.type.class.should eql(Class)
+    expect(prop.array).to be_falsey
+    expect(prop.type).not_to be_nil
+    expect(prop.type.class).to eql(Class)
     obj = prop.type.new
-    obj.should respond_to(:testing)
+    expect(obj).to respond_to(:testing)
   end
 
   it "should convert block to type with array" do
     prop = klass.new(:test, :array => true) do
       property :testing
     end
-    prop.type.should_not be_nil
-    prop.type.class.should eql(Class)
-    prop.array.should be_true
+    expect(prop.type).not_to be_nil
+    expect(prop.type.class).to eql(Class)
+    expect(prop.array).to be_truthy
   end
 
   describe "#build" do
     it "should allow instantiation of new object" do
       property = CouchRest::Model::Property.new(:test, :type => Date)
       obj = property.build(2011, 05, 21)
-      obj.should eql(Date.new(2011, 05, 21))
+      expect(obj).to eql(Date.new(2011, 05, 21))
     end
     it "should use init_method if provided" do
       property = CouchRest::Model::Property.new(:test, :type => Date, :init_method => 'parse')
       obj = property.build("2011-05-21")
-      obj.should eql(Date.new(2011, 05, 21))
+      expect(obj).to eql(Date.new(2011, 05, 21))
     end
     it "should use init_method Proc if provided" do
       property = CouchRest::Model::Property.new(:test, :type => Date, :init_method => Proc.new{|v| Date.parse(v)})
       obj = property.build("2011-05-21")
-      obj.should eql(Date.new(2011, 05, 21))
+      expect(obj).to eql(Date.new(2011, 05, 21))
     end
     it "should raise error if no class" do
       property = CouchRest::Model::Property.new(:test)
-      lambda { property.build }.should raise_error(StandardError, /Cannot build/)
+      expect { property.build }.to raise_error(StandardError, /Cannot build/)
     end
   end
 
@@ -510,20 +119,20 @@ describe "Property Class" do
     it "should cast a value" do
       property = CouchRest::Model::Property.new(:test, :type => Date)
       parent = double("FooObject")
-      property.cast(parent, "2010-06-16").should eql(Date.new(2010, 6, 16))
-      property.cast_value(parent, "2010-06-16").should eql(Date.new(2010, 6, 16))
+      expect(property.cast(parent, "2010-06-16")).to eql(Date.new(2010, 6, 16))
+      expect(property.cast_value(parent, "2010-06-16")).to eql(Date.new(2010, 6, 16))
     end
 
     it "should cast an array of values" do
       property = CouchRest::Model::Property.new(:test, :type => [Date])
       parent = double("FooObject")
-      property.cast(parent, ["2010-06-01", "2010-06-02"]).should eql([Date.new(2010, 6, 1), Date.new(2010, 6, 2)])
+      expect(property.cast(parent, ["2010-06-01", "2010-06-02"])).to eql([Date.new(2010, 6, 1), Date.new(2010, 6, 2)])
     end
 
     it "should cast an array of values with array option" do
       property = CouchRest::Model::Property.new(:test, :type => Date, :array => true)
       parent = double("FooObject")
-      property.cast(parent, ["2010-06-01", "2010-06-02"]).should eql([Date.new(2010, 6, 1), Date.new(2010, 6, 2)])
+      expect(property.cast(parent, ["2010-06-01", "2010-06-02"])).to eql([Date.new(2010, 6, 1), Date.new(2010, 6, 2)])
     end
 
     context "when allow_blank is false" do
@@ -533,25 +142,25 @@ describe "Property Class" do
 
       it "should convert blank to nil" do
         property = CouchRest::Model::Property.new(:test, :type => String, :allow_blank => false)
-        property.cast(parent, "").should be_nil
+        expect(property.cast(parent, "")).to be_nil
       end
 
       it "should remove blank array entries" do
         property = CouchRest::Model::Property.new(:test, :type => [String], :allow_blank => false)
-        property.cast(parent, ["", "foo"]).should eql(["foo"])
+        expect(property.cast(parent, ["", "foo"])).to eql(["foo"])
       end
     end
 
     it "should set a CastedArray on array of Objects" do
       property = CouchRest::Model::Property.new(:test, :type => [Object])
       parent = double("FooObject")
-      property.cast(parent, ["2010-06-01", "2010-06-02"]).class.should eql(CouchRest::Model::CastedArray)
+      expect(property.cast(parent, ["2010-06-01", "2010-06-02"]).class).to eql(CouchRest::Model::CastedArray)
     end
 
     it "should set a CastedArray on array of Strings" do
       property = CouchRest::Model::Property.new(:test, :type => [String])
       parent = double("FooObject")
-      property.cast(parent, ["2010-06-01", "2010-06-02"]).class.should eql(CouchRest::Model::CastedArray)
+      expect(property.cast(parent, ["2010-06-01", "2010-06-02"]).class).to eql(CouchRest::Model::CastedArray)
     end
 
     it "should allow instantion of model via CastedArray#build" do
@@ -559,11 +168,11 @@ describe "Property Class" do
       parent = Article.new
       ary = property.cast(parent, [])
       obj = ary.build(2011, 05, 21)
-      ary.length.should eql(1)
-      ary.first.should eql(Date.new(2011, 05, 21))
+      expect(ary.length).to eql(1)
+      expect(ary.first).to eql(Date.new(2011, 05, 21))
       obj = ary.build(2011, 05, 22)
-      ary.length.should eql(2)
-      ary.last.should eql(Date.new(2011, 05, 22))
+      expect(ary.length).to eql(2)
+      expect(ary.last).to eql(Date.new(2011, 05, 22))
     end
 
     it "should cast an object that provides an array" do
@@ -575,20 +184,20 @@ describe "Property Class" do
       property = CouchRest::Model::Property.new(:test, :type => prop)
       parent = double("FooClass")
       cast = property.cast(parent, [1, 2])
-      cast.ary.should eql([1, 2])
+      expect(cast.ary).to eql([1, 2])
     end
 
     it "should set parent as casted_by object in CastedArray" do
       property = CouchRest::Model::Property.new(:test, :type => [Object])
       parent = double("FooObject")
-      property.cast(parent, ["2010-06-01", "2010-06-02"]).casted_by.should eql(parent)
+      expect(property.cast(parent, ["2010-06-01", "2010-06-02"]).casted_by).to eql(parent)
     end
 
     it "should set casted_by on new value" do
       property = CouchRest::Model::Property.new(:test, :type => CatToy)
       parent = double("CatObject")
       cast = property.cast(parent, {:name => 'catnip'})
-      cast.casted_by.should eql(parent)
+      expect(cast.casted_by).to eql(parent)
     end
 
   end