couchrest_model 2.1.0.rc1 → 2.2.0.beta1

data/lib/couchrest/model/proxyable.rb

@@ -4,9 +4,12 @@ module CouchRest
     module Proxyable
       extend ActiveSupport::Concern
 
-      def proxy_database
+      def proxy_database(assoc_name)
         raise StandardError, "Please set the #proxy_database_method" if self.class.proxy_database_method.nil?
-        @proxy_database ||= self.class.prepare_database(self.send(self.class.proxy_database_method))
+        db_name = self.send(self.class.proxy_database_method)
+        db_suffix = self.class.proxy_database_suffixes[assoc_name.to_sym]
+        @proxy_databases ||= {}
+        @proxy_databases[assoc_name.to_sym] ||= self.class.prepare_database([db_name, db_suffix].compact.reject(&:blank?).join(self.class.connection[:join]))
       end
 
       module ClassMethods
@@ -15,13 +18,16 @@ module CouchRest
         # Define a collection that will use the base model for the database connection
         # details.
         def proxy_for(assoc_name, options = {})
-          db_method = options[:database_method] || "proxy_database"
+          db_method = (options[:database_method] || "proxy_database").to_sym
+          db_suffix = options[:database_suffix] || (options[:use_suffix] ? assoc_name.to_s : nil)
           options[:class_name] ||= assoc_name.to_s.singularize.camelize
           proxy_method_names   << assoc_name.to_sym    unless proxy_method_names.include?(assoc_name.to_sym)
           proxied_model_names  << options[:class_name] unless proxied_model_names.include?(options[:class_name])
+          proxy_database_suffixes[assoc_name.to_sym] = db_suffix
+          db_method_call = "#{db_method}(:#{assoc_name.to_s})"
           class_eval <<-EOS, __FILE__, __LINE__ + 1
             def #{assoc_name}
-              @#{assoc_name} ||= CouchRest::Model::Proxyable::ModelProxy.new(::#{options[:class_name]}, self, self.class.to_s.underscore, #{db_method})
+              @#{assoc_name} ||= CouchRest::Model::Proxyable::ModelProxy.new(::#{options[:class_name]}, self, self.class.to_s.underscore, #{db_method_call})
             end
           EOS
         end
@@ -57,6 +63,10 @@ module CouchRest
           @proxied_model_names ||= []
         end
 
+        def proxy_database_suffixes
+          @proxy_database_suffixes ||= {}
+        end
+
         private
 
         # Ensure that no attempt is made to autoload a database connection
@@ -156,6 +166,12 @@ module CouchRest
           end
         end
 
+        private
+
+        def method_missing(m, *args, &block)
+          model.respond_to?(m) ? model.send(m, self, *args, &block) : super
+        end
+        
       end
     end
   end

data/lib/couchrest/model/validations/uniqueness.rb

@@ -1,4 +1,7 @@
-# encoding: utf-8
+
+I18n.load_path << File.join(
+  File.dirname(__FILE__), "locale", "en.yml"
+)
 
 module CouchRest
   module Model

data/lib/couchrest_model.rb

@@ -17,6 +17,7 @@ require "enumerator"
 require "time"
 require "digest/md5"
 require "yaml"
+require "hashdiff"
 
 require "bigdecimal" # used in typecast
 require "bigdecimal/util" # used in typecast
@@ -25,6 +26,7 @@ require "couchrest"
 
 require "couchrest/model"
 require "couchrest/model/errors"
+require "couchrest/model/configuration"
 require "couchrest/model/translation"
 require "couchrest/model/persistence"
 require "couchrest/model/typecast"
@@ -34,14 +36,12 @@ require "couchrest/model/property"
 require "couchrest/model/property_protection"
 require "couchrest/model/properties"
 require "couchrest/model/casted_array"
-require "couchrest/model/casted_hash"
 require "couchrest/model/validations"
 require "couchrest/model/callbacks"
 require "couchrest/model/document_queries"
 require "couchrest/model/extended_attachments"
 require "couchrest/model/proxyable"
 require "couchrest/model/associations"
-require "couchrest/model/configuration"
 require "couchrest/model/connection"
 require "couchrest/model/designs/migrations"
 require "couchrest/model/designs/design_mapper"

data/spec/fixtures/models/article.rb

@@ -33,6 +33,6 @@ class Article < CouchRest::Model::Base
   before_save :generate_slug_from_title
 
   def generate_slug_from_title
-    self['slug'] = title.downcase.gsub(/[^a-z0-9]/,'-').squeeze('-').gsub(/^\-|\-$/,'') if new?
+    self['slug'] = title.to_s.downcase.gsub(/[^a-z0-9]/,'-').squeeze('-').gsub(/^\-|\-$/,'') if new?
   end
 end

data/spec/fixtures/models/card.rb

@@ -9,7 +9,8 @@ class Card < CouchRest::Model::Base
   property :last_name,        :alias     => :family_name
   property :read_only_value,  :read_only => true
   property :cast_alias,       Person,  :alias  => :calias
-  property :fg_color,         :default   => '#000'
+  property :fg_color,         String, :default   => '#000'
+  property :bg_color,         String, :protected => true
 
   timestamps!
 

data/spec/fixtures/models/person.rb

@@ -2,6 +2,7 @@ require 'cat'
 
 class Person
   include ::CouchRest::Model::Embeddable
+
   property :pet, Cat
   property :name, [String]
   

data/spec/fixtures/models/project.rb

@@ -1,5 +1,8 @@
 class Project < CouchRest::Model::Base
   use_database DB
+
+  disable_dirty_tracking true
+
   property :name,   String
   timestamps!
 

data/spec/unit/assocations_spec.rb

@@ -12,22 +12,22 @@ describe "Assocations" do
 
     it "should return a default set of options" do
       o = SaleInvoice.merge_assoc_opts(:cat)
-      o[:foreign_key].should eql('cat_id')
-      o[:class_name].should eql('Cat')
-      o[:proxy_name].should eql('cats')
-      o[:proxy].should eql('Cat') # same as class name
+      expect(o[:foreign_key]).to eql('cat_id')
+      expect(o[:class_name]).to eql('Cat')
+      expect(o[:proxy_name]).to eql('cats')
+      expect(o[:proxy]).to eql('Cat') # same as class name
     end
 
     it "should merge with provided options" do
       o = SaleInvoice.merge_assoc_opts(:cat, :foreign_key => 'somecat_id', :proxy => 'some_cats')
-      o[:foreign_key].should eql('somecat_id')
-      o[:proxy].should eql('some_cats')
+      expect(o[:foreign_key]).to eql('somecat_id')
+      expect(o[:proxy]).to eql('some_cats')
     end
 
     it "should generate a proxy string if proxied" do
-      SaleInvoice.stub(:proxy_owner_method).twice.and_return('company')
+      allow(SaleInvoice).to receive(:proxy_owner_method).twice.and_return('company')
       o = SaleInvoice.merge_assoc_opts(:cat)
-      o[:proxy].should eql('self.company.cats')
+      expect(o[:proxy]).to eql('self.company.cats')
     end
     
   end
@@ -40,59 +40,59 @@ describe "Assocations" do
     end
 
     it "should create a foreign key property with setter and getter" do
-      @invoice.properties.find{|p| p.name == 'client_id'}.should_not be_nil
-      @invoice.respond_to?(:client_id).should be_true
-      @invoice.respond_to?("client_id=").should be_true
+      expect(@invoice.properties.find{|p| p.name == 'client_id'}).not_to be_nil
+      expect(@invoice.respond_to?(:client_id)).to be_truthy
+      expect(@invoice.respond_to?("client_id=")).to be_truthy
     end
 
     it "should set the property and provide object when set" do
       @invoice.client = @client
-      @invoice.client_id.should eql(@client.id)
-      @invoice.client.should eql(@client)
+      expect(@invoice.client_id).to eql(@client.id)
+      expect(@invoice.client).to eql(@client)
     end
 
     it "should set the attribute, save and return" do
       @invoice.client = @client
       @invoice.save
       @invoice = SaleInvoice.get(@invoice.id)
-      @invoice.client.id.should eql(@client.id)
+      expect(@invoice.client.id).to eql(@client.id)
     end
 
     it "should remove the association if nil is provided" do
       @invoice.client = @client
       @invoice.client = nil
-      @invoice.client_id.should be_nil
+      expect(@invoice.client_id).to be_nil
     end
 
     it "should not try to search for association if foreign_key is nil" do
       @invoice.client_id = nil
-      Client.should_not_receive(:get)
+      expect(Client).not_to receive(:get)
       @invoice.client
     end
 
     it "should ignore blank ids" do
       @invoice.client_id = ""
-      @invoice.client_id.should be_nil
+      expect(@invoice.client_id).to be_nil
     end
 
     it "should allow replacement of object after updating key" do
       @invoice.client = @client
-      @invoice.client.should eql(@client)
+      expect(@invoice.client).to eql(@client)
       @invoice.client_id = nil
-      @invoice.client.should be_nil
+      expect(@invoice.client).to be_nil
     end
 
     it "should allow override of foreign key" do
-      @invoice.respond_to?(:alternate_client).should be_true
-      @invoice.respond_to?("alternate_client=").should be_true
-      @invoice.properties.find{|p| p.name == 'alt_client_id'}.should_not be_nil
+      expect(@invoice.respond_to?(:alternate_client)).to be_truthy
+      expect(@invoice.respond_to?("alternate_client=")).to be_truthy
+      expect(@invoice.properties.find{|p| p.name == 'alt_client_id'}).not_to be_nil
     end
 
     it "should allow override of foreign key and save" do
       @invoice.alternate_client = @client
       @invoice.save
       @invoice = SaleInvoice.get(@invoice.id)
-      @invoice.alternate_client.id.should eql(@client.id)
+      expect(@invoice.alternate_client.id).to eql(@client.id)
     end
 
   end
@@ -109,95 +109,95 @@ describe "Assocations" do
     end
 
     it "should create an associated property and collection proxy" do
-      @invoice.respond_to?('entry_ids').should be_true
-      @invoice.respond_to?('entry_ids=').should be_true
-      @invoice.entries.class.should eql(::CouchRest::Model::CollectionOfProxy)
+      expect(@invoice.respond_to?('entry_ids')).to be_truthy
+      expect(@invoice.respond_to?('entry_ids=')).to be_truthy
+      expect(@invoice.entries.class).to eql(::CouchRest::Model::CollectionOfProxy)
     end
 
     it "should allow replacement of objects" do
       @invoice.entries = @entries
-      @invoice.entries.length.should eql(3)
-      @invoice.entry_ids.length.should eql(3)
-      @invoice.entries.first.should eql(@entries.first)
-      @invoice.entry_ids.first.should eql(@entries.first.id)
+      expect(@invoice.entries.length).to eql(3)
+      expect(@invoice.entry_ids.length).to eql(3)
+      expect(@invoice.entries.first).to eql(@entries.first)
+      expect(@invoice.entry_ids.first).to eql(@entries.first.id)
     end
 
     it "should allow ids to be set directly and load entries" do
       @invoice.entry_ids = @entries.collect{|i| i.id}
-      @invoice.entries.length.should eql(3)
-      @invoice.entries.first.should eql(@entries.first)
-      @invoice.changed?.should be_true
+      expect(@invoice.entries.length).to eql(3)
+      expect(@invoice.entries.first).to eql(@entries.first)
+      expect(@invoice.changed?).to be_truthy
     end
 
     it "should ignore blank ids when set directly" do
       @invoice.entry_ids = ["", @entries.first.id]
-      @invoice.entry_ids.length.should be(1)
+      expect(@invoice.entry_ids.length).to be(1)
     end
 
     it "should replace collection if ids replaced" do
       @invoice.entry_ids = @entries.collect{|i| i.id}
-      @invoice.entries.length.should eql(3) # load once
+      expect(@invoice.entries.length).to eql(3) # load once
       @invoice.entry_ids = @entries[0..1].collect{|i| i.id}
-      @invoice.entries.length.should eql(2)
+      expect(@invoice.entries.length).to eql(2)
     end
 
     it "should allow forced collection update if ids changed" do
       @invoice.entry_ids = @entries[0..1].collect{|i| i.id}
-      @invoice.entries.length.should eql(2) # load once
+      expect(@invoice.entries.length).to eql(2) # load once
       @invoice.entry_ids << @entries[2].id
-      @invoice.entry_ids.length.should eql(3)
-      @invoice.entries.length.should eql(2) # cached!
-      @invoice.entries(true).length.should eql(3)
+      expect(@invoice.entry_ids.length).to eql(3)
+      expect(@invoice.entries.length).to eql(2) # cached!
+      expect(@invoice.entries(true).length).to eql(3)
     end
 
     it "should empty arrays when nil collection provided" do
       @invoice.entries = @entries
       @invoice.entries = nil
-      @invoice.entry_ids.should be_empty
-      @invoice.entries.should be_empty
+      expect(@invoice.entry_ids).to be_empty
+      expect(@invoice.entries).to be_empty
     end
 
     it "should empty arrays when nil ids array provided" do
       @invoice.entries = @entries
       @invoice.entry_ids = nil
-      @invoice.entry_ids.should be_empty
-      @invoice.entries.should be_empty
+      expect(@invoice.entry_ids).to be_empty
+      expect(@invoice.entries).to be_empty
     end
 
     it "should ignore nil entries" do
       @invoice.entries = [ nil ]
-      @invoice.entry_ids.should be_empty
-      @invoice.entries.should be_empty
+      expect(@invoice.entry_ids).to be_empty
+      expect(@invoice.entries).to be_empty
     end
 
     # Account for dirty tracking
     describe "dirty tracking" do
       it "should register changes on replacement" do
         @invoice.entries = @entries
-        @invoice.changed?.should be_true
+        expect(@invoice.changed?).to be_truthy
       end
       it "should register changes on push" do
-        @invoice.changed?.should be_false
+        expect(@invoice.changed?).to be_falsey
         @invoice.entries << @entries[0]
-        @invoice.changed?.should be_true
+        expect(@invoice.changed?).to be_truthy
       end
       it "should register changes on pop" do
         @invoice.entries << @entries[0]
         @invoice.save
-        @invoice.changed?.should be_false
+        expect(@invoice.changed?).to be_falsey
         @invoice.entries.pop
-        @invoice.changed?.should be_true
+        expect(@invoice.changed?).to be_truthy
       end
       it "should register id changes on push" do
         @invoice.entry_ids << @entries[0].id
-        @invoice.changed?.should be_true
+        expect(@invoice.changed?).to be_truthy
       end
       it "should register id changes on pop" do
         @invoice.entry_ids << @entries[0].id
         @invoice.save
-        @invoice.changed?.should be_false
+        expect(@invoice.changed?).to be_falsey
         @invoice.entry_ids.pop
-        @invoice.changed?.should be_true
+        expect(@invoice.changed?).to be_truthy
       end
     end
 
@@ -205,53 +205,53 @@ describe "Assocations" do
 
       it "should ensure new entries to proxy are matched" do
         @invoice.entries << @entries.first
-        @invoice.entry_ids.first.should eql(@entries.first.id)
-        @invoice.entries.first.should eql(@entries.first)
+        expect(@invoice.entry_ids.first).to eql(@entries.first.id)
+        expect(@invoice.entries.first).to eql(@entries.first)
         @invoice.entries << @entries[1]
-        @invoice.entries.count.should eql(2)
-        @invoice.entry_ids.count.should eql(2)
-        @invoice.entry_ids.last.should eql(@entries[1].id)
-        @invoice.entries.last.should eql(@entries[1])
+        expect(@invoice.entries.count).to eql(2)
+        expect(@invoice.entry_ids.count).to eql(2)
+        expect(@invoice.entry_ids.last).to eql(@entries[1].id)
+        expect(@invoice.entries.last).to eql(@entries[1])
       end
 
       it "should support push method" do
         @invoice.entries.push(@entries.first)
-        @invoice.entry_ids.first.should eql(@entries.first.id)
+        expect(@invoice.entry_ids.first).to eql(@entries.first.id)
       end
 
       it "should support []= method" do
         @invoice.entries[0] = @entries.first
-        @invoice.entry_ids.first.should eql(@entries.first.id)
+        expect(@invoice.entry_ids.first).to eql(@entries.first.id)
       end
 
       it "should support unshift method" do
         @invoice.entries.unshift(@entries.first)
-        @invoice.entry_ids.first.should eql(@entries.first.id)
+        expect(@invoice.entry_ids.first).to eql(@entries.first.id)
         @invoice.entries.unshift(@entries[1])
-        @invoice.entry_ids.first.should eql(@entries[1].id)
+        expect(@invoice.entry_ids.first).to eql(@entries[1].id)
       end
 
       it "should support pop method" do
         @invoice.entries.push(@entries.first)
-        @invoice.entries.pop.should eql(@entries.first)
-        @invoice.entries.empty?.should be_true
-        @invoice.entry_ids.empty?.should be_true
+        expect(@invoice.entries.pop).to eql(@entries.first)
+        expect(@invoice.entries.empty?).to be_truthy
+        expect(@invoice.entry_ids.empty?).to be_truthy
       end
 
       it "should support shift method" do
         @invoice.entries.push(@entries[0])
         @invoice.entries.push(@entries[1])
-        @invoice.entries.shift.should eql(@entries[0])
-        @invoice.entries.first.should eql(@entries[1])
-        @invoice.entry_ids.first.should eql(@entries[1].id)
+        expect(@invoice.entries.shift).to eql(@entries[0])
+        expect(@invoice.entries.first).to eql(@entries[1])
+        expect(@invoice.entry_ids.first).to eql(@entries[1].id)
       end
 
       it "should raise error when adding un-persisted entries" do
-        SaleEntry.find_by_description('test entry').should be_nil
+        expect(SaleEntry.find_by_description('test entry')).to be_nil
         entry = SaleEntry.new(:description => 'test entry', :price => 500)
-        lambda {
+        expect {
           @invoice.entries << entry
-        }.should raise_error
+        }.to raise_error(/Object cannot be added/)
         # In the future maybe?
         # @invoice.save.should be_true
         # SaleEntry.find_by_description('test entry').should_not be_nil

data/spec/unit/attachment_spec.rb

@@ -6,35 +6,35 @@ describe "Model attachments" do
     before(:each) do
       reset_test_db!
       @obj = Basic.new
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
       @file = File.open(FIXTURE_PATH + '/attachments/test.html')
       @attachment_name = 'my_attachment'
       @obj.create_attachment(:file => @file, :name => @attachment_name)
     end
   
     it 'should return false if there is no attachment' do
-      @obj.has_attachment?('bogus').should be_false
+      expect(@obj.has_attachment?('bogus')).to be_falsey
     end
   
     it 'should return true if there is an attachment' do
-      @obj.has_attachment?(@attachment_name).should be_true
+      expect(@obj.has_attachment?(@attachment_name)).to be_truthy
     end
   
     it 'should return true if an object with an attachment is reloaded' do
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
       reloaded_obj = Basic.get(@obj.id)
-      reloaded_obj.has_attachment?(@attachment_name).should be_true
+      expect(reloaded_obj.has_attachment?(@attachment_name)).to be_truthy
     end
   
     it 'should return false if an attachment has been removed' do
       @obj.delete_attachment(@attachment_name)
-      @obj.has_attachment?(@attachment_name).should be_false
+      expect(@obj.has_attachment?(@attachment_name)).to be_falsey
     end
     
     it 'should return false if an attachment has been removed and reloaded' do
       @obj.delete_attachment(@attachment_name)
       reloaded_obj = Basic.get(@obj.id)
-      reloaded_obj.has_attachment?(@attachment_name).should be_false
+      expect(reloaded_obj.has_attachment?(@attachment_name)).to be_falsey
     end
     
   end
@@ -42,7 +42,7 @@ describe "Model attachments" do
   describe "creating an attachment" do
     before(:each) do
       @obj = Basic.new
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
       @file_ext = File.open(FIXTURE_PATH + '/attachments/test.html')
       @file_no_ext = File.open(FIXTURE_PATH + '/attachments/README')
       @attachment_name = 'my_attachment'
@@ -51,41 +51,41 @@ describe "Model attachments" do
   
     it "should create an attachment from file with an extension" do
       @obj.create_attachment(:file => @file_ext, :name => @attachment_name)
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
       reloaded_obj = Basic.get(@obj.id)
-      reloaded_obj.attachments[@attachment_name].should_not be_nil
+      expect(reloaded_obj.attachments[@attachment_name]).not_to be_nil
     end
   
     it "should create an attachment from file without an extension" do
       @obj.create_attachment(:file => @file_no_ext, :name => @attachment_name)
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
       reloaded_obj = Basic.get(@obj.id)
-      reloaded_obj.attachments[@attachment_name].should_not be_nil
+      expect(reloaded_obj.attachments[@attachment_name]).not_to be_nil
     end
   
     it 'should raise ArgumentError if :file is missing' do
-      lambda{ @obj.create_attachment(:name => @attachment_name) }.should raise_error
+      expect{ @obj.create_attachment(:name => @attachment_name) }.to raise_error(ArgumentError, /:file/)
     end
   
     it 'should raise ArgumentError if :name is missing' do
-      lambda{ @obj.create_attachment(:file => @file_ext) }.should raise_error
+      expect{ @obj.create_attachment(:file => @file_ext) }.to raise_error(ArgumentError, /:name/)
     end
   
     it 'should set the content-type if passed' do
       @obj.create_attachment(:file => @file_ext, :name => @attachment_name, :content_type => @content_type)
-      @obj.attachments[@attachment_name]['content_type'].should == @content_type
+      expect(@obj.attachments[@attachment_name]['content_type']).to eq(@content_type)
     end
 
     it "should detect the content-type automatically" do
       @obj.create_attachment(:file => File.open(FIXTURE_PATH + '/attachments/couchdb.png'), :name => "couchdb.png")
-      @obj.attachments['couchdb.png']['content_type'].should == "image/png" 
+      expect(@obj.attachments['couchdb.png']['content_type']).to eq("image/png") 
     end
 
     it "should use name to detect the content-type automatically if no file" do
       file = File.open(FIXTURE_PATH + '/attachments/couchdb.png')
-      file.stub(:path).and_return("badfilname")
+      allow(file).to receive(:path).and_return("badfilname")
       @obj.create_attachment(:file => File.open(FIXTURE_PATH + '/attachments/couchdb.png'), :name => "couchdb.png")
-      @obj.attachments['couchdb.png']['content_type'].should == "image/png" 
+      expect(@obj.attachments['couchdb.png']['content_type']).to eq("image/png") 
     end
 
   end
@@ -96,37 +96,37 @@ describe "Model attachments" do
       @file = File.open(FIXTURE_PATH + '/attachments/test.html')
       @attachment_name = 'my_attachment'
       @obj.create_attachment(:file => @file, :name => @attachment_name)
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
       @file.rewind
       @content_type = 'media/mp3'
     end
   
     it 'should read an attachment that exists' do
-      @obj.read_attachment(@attachment_name).should == @file.read
+      expect(@obj.read_attachment(@attachment_name)).to eq(@file.read)
     end
   
     it 'should update an attachment that exists' do
       file = File.open(FIXTURE_PATH + '/attachments/README')
-      @file.should_not == file
+      expect(@file).not_to eq(file)
       @obj.update_attachment(:file => file, :name => @attachment_name)
       @obj.save
       reloaded_obj = Basic.get(@obj.id)
       file.rewind
-      reloaded_obj.read_attachment(@attachment_name).should_not == @file.read
-      reloaded_obj.read_attachment(@attachment_name).should == file.read
+      expect(reloaded_obj.read_attachment(@attachment_name)).not_to eq(@file.read)
+      expect(reloaded_obj.read_attachment(@attachment_name)).to eq(file.read)
     end
   
     it 'should set the content-type if passed' do
       file = File.open(FIXTURE_PATH + '/attachments/README')
-      @file.should_not == file
+      expect(@file).not_to eq(file)
       @obj.update_attachment(:file => file, :name => @attachment_name, :content_type => @content_type)
-      @obj.attachments[@attachment_name]['content_type'].should == @content_type
+      expect(@obj.attachments[@attachment_name]['content_type']).to eq(@content_type)
     end
   
     it 'should delete an attachment that exists' do
       @obj.delete_attachment(@attachment_name)
       @obj.save
-      lambda{Basic.get(@obj.id).read_attachment(@attachment_name)}.should raise_error
+      expect{Basic.get(@obj.id).read_attachment(@attachment_name)}.to raise_error(/404 Not Found/)
     end
   end
 
@@ -136,19 +136,19 @@ describe "Model attachments" do
       @file = File.open(FIXTURE_PATH + '/attachments/test.html')
       @attachment_name = 'my_attachment'
       @obj.create_attachment(:file => @file, :name => @attachment_name)
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
     end
   
     it 'should return nil if attachment does not exist' do
-      @obj.attachment_url('bogus').should be_nil
+      expect(@obj.attachment_url('bogus')).to be_nil
     end
   
     it 'should return the attachment URL as specified by CouchDB HttpDocumentApi' do
-      @obj.attachment_url(@attachment_name).should == "#{Basic.database}/#{@obj.id}/#{@attachment_name}"
+      expect(@obj.attachment_url(@attachment_name)).to eq("#{Basic.database}/#{@obj.id}/#{@attachment_name}")
     end
     
     it 'should return the attachment URI' do
-      @obj.attachment_uri(@attachment_name).should == "#{Basic.database.uri}/#{@obj.id}/#{@attachment_name}"
+      expect(@obj.attachment_uri(@attachment_name)).to eq("#{Basic.database.uri}/#{@obj.id}/#{@attachment_name}")
     end
   end
 
@@ -158,18 +158,18 @@ describe "Model attachments" do
       @file = File.open(FIXTURE_PATH + '/attachments/test.html')
       @attachment_name = 'my_attachment'
       @obj.create_attachment(:file => @file, :name => @attachment_name)
-      @obj.save.should be_true
+      expect(@obj.save).to be_truthy
     end
   
     it 'should return an empty Hash when document does not have any attachment' do
       new_obj = Basic.new
-      new_obj.save.should be_true
-      new_obj.attachments.should == {}
+      expect(new_obj.save).to be_truthy
+      expect(new_obj.attachments).to eq({})
     end
   
     it 'should return a Hash with all attachments' do
       @file.rewind
-      @obj.attachments.should == { @attachment_name =>{ "data" => "PCFET0NUWVBFIGh0bWw+CjxodG1sPgogIDxoZWFkPgogICAgPHRpdGxlPlRlc3Q8L3RpdGxlPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxwPgogICAgICBUZXN0CiAgICA8L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==", "content_type" => "text/html"}}
+      expect(@obj.attachments).to eq({ @attachment_name =>{ "data" => "PCFET0NUWVBFIGh0bWw+CjxodG1sPgogIDxoZWFkPgogICAgPHRpdGxlPlRlc3Q8L3RpdGxlPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxwPgogICAgICBUZXN0CiAgICA8L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==", "content_type" => "text/html"}})
     end
   
   end