sequel 4.22.0 → 4.23.0

data/spec/extensions/modification_detection_spec.rb

@@ -12,50 +12,50 @@ describe "serialization_modification_detection plugin" do
   end
   
   it "should only detect columns that have been changed" do
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
     @o.a << 'b'
-    @o.changed_columns.should == [:a]
+    @o.changed_columns.must_equal [:a]
     @o.a.replace('a') 
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
     @o.values[:b] = 2
-    @o.changed_columns.should == [:b]
+    @o.changed_columns.must_equal [:b]
     @o.values[:b] = 1
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
     @o.c[0] << 'b'
     @o.d['b'] << 'b'
-    @o.changed_columns.sort_by{|c| c.to_s}.should == [:c, :d]
+    @o.changed_columns.sort_by{|c| c.to_s}.must_equal [:c, :d]
     @o.c[0] = 'a'
-    @o.changed_columns.should == [:d]
+    @o.changed_columns.must_equal [:d]
     @o.d['b'] = 'c'
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
   end
   
   it "should not list a column twice" do
     @o.a = 'b'
     @o.a << 'a'
-    @o.changed_columns.should == [:a]
+    @o.changed_columns.must_equal [:a]
   end
   
   it "should report correct changed_columns after updating" do
     @o.a << 'a'
     @o.save_changes
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
     @o.values[:b] = 2
     @o.save_changes
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
     @o.c[0] << 'b'
     @o.save_changes
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
     @o.d['b'] << 'a'
     @o.save_changes
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
-    @ds.db.sqls.should == ["UPDATE items SET a = 'aa' WHERE (id = 1)",
+    @ds.db.sqls.must_equal ["UPDATE items SET a = 'aa' WHERE (id = 1)",
                        "UPDATE items SET b = 2 WHERE (id = 1)",
                        "UPDATE items SET c = ('ab') WHERE (id = 1)",
                        "UPDATE items SET d = ('b' = 'ca') WHERE (id = 1)"]
@@ -63,18 +63,18 @@ describe "serialization_modification_detection plugin" do
 
   it "should report correct changed_columns after creating new object" do
     o = @c.create
-    o.changed_columns.should == []
+    o.changed_columns.must_equal []
     o.a << 'a'
-    o.changed_columns.should == [:a]
-    @ds.db.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    o.changed_columns.must_equal [:a]
+    @ds.db.sqls.must_equal ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
 
   it "should report correct changed_columns after refreshing existing object" do
     @o.a << 'a'
-    @o.changed_columns.should == [:a]
+    @o.changed_columns.must_equal [:a]
     @o.refresh
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
     @o.a << 'a'
-    @o.changed_columns.should == [:a]
+    @o.changed_columns.must_equal [:a]
   end
 end

data/spec/extensions/mssql_optimistic_locking_spec.rb

@@ -13,42 +13,42 @@ describe "MSSSQL optimistic locking plugin" do
   it "should not include the lock column when updating" do
     @db.fetch = [[{:timestamp=>'2345'}]]
     @o.save
-    @db.sqls.should == ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x31323334))"]
+    @db.sqls.must_equal ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x31323334))"]
   end
 
   it "should automatically update lock column using new value from database" do
     @db.fetch = [[{:timestamp=>'2345'}]]
     @o.save
-    @o.timestamp.should == '2345'
+    @o.timestamp.must_equal '2345'
   end
 
   it "should raise error when updating stale object" do
     @db.fetch = []
     @o.timestamp = '2345'
-    proc{@o.save}.should raise_error(Sequel::NoExistingObject)
-    @o.timestamp.should == '2345'
-    @db.sqls.should == ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x32333435))"]
+    proc{@o.save}.must_raise(Sequel::NoExistingObject)
+    @o.timestamp.must_equal '2345'
+    @db.sqls.must_equal ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x32333435))"]
   end
 
   it "should raise error when destroying stale object" do
     @db.numrows = 0
     @o.timestamp = '2345'
-    proc{@o.destroy}.should raise_error(Sequel::NoExistingObject)
-    @db.sqls.should == ["DELETE FROM items WHERE ((id = 1) AND (timestamp = 0x32333435))"]
+    proc{@o.destroy}.must_raise(Sequel::NoExistingObject)
+    @db.sqls.must_equal ["DELETE FROM items WHERE ((id = 1) AND (timestamp = 0x32333435))"]
   end
 
   it "should allow refresh after failed save" do
     @db.fetch = []
     @o.timestamp = '2345'
-    proc{@o.save}.should raise_error(Sequel::NoExistingObject)
+    proc{@o.save}.must_raise(Sequel::NoExistingObject)
     @db.fetch = {:id=>1, :name=>'a', :timestamp=>'2345'}
     @o.refresh
     @db.sqls
     @o.save
-    @db.sqls.should == ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x32333435))"]
+    @db.sqls.must_equal ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x32333435))"]
   end
 
-  specify "should allow changing the lock column via model.lock_column=" do
+  it "should allow changing the lock column via model.lock_column=" do
     @c = Class.new(Sequel::Model(@db[:items]))
     @c.columns :id, :name, :lv
     @c.plugin :mssql_optimistic_locking
@@ -56,36 +56,36 @@ describe "MSSSQL optimistic locking plugin" do
     @o = @c.load(:id=>1, :name=>'a', :lv=>'1234')
     @db.sqls
     @db.fetch = []
-    proc{@o.save}.should raise_error(Sequel::NoExistingObject)
-    @o.lv.should == '1234'
-    @db.sqls.should == ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.lv WHERE ((id = 1) AND (lv = 0x31323334))"]
+    proc{@o.save}.must_raise(Sequel::NoExistingObject)
+    @o.lv.must_equal '1234'
+    @db.sqls.must_equal ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.lv WHERE ((id = 1) AND (lv = 0x31323334))"]
     @o = @c.load(:id=>1, :name=>'a', :lv=>'1234')
     @db.fetch = {:lv=>'2345'}
     @o.save
-    @o.lv.should == '2345'
+    @o.lv.must_equal '2345'
   end
 
-  specify "should allow changing the lock column via plugin option" do
+  it "should allow changing the lock column via plugin option" do
     @c = Class.new(Sequel::Model(@db[:items]))
     @c.columns :id, :name, :lv
     @c.plugin :mssql_optimistic_locking, :lock_column=>:lv
     @o = @c.load(:id=>1, :name=>'a', :lv=>'1234')
     @db.sqls
     @db.fetch = []
-    proc{@o.save}.should raise_error(Sequel::NoExistingObject)
-    @o.lv.should == '1234'
-    @db.sqls.should == ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.lv WHERE ((id = 1) AND (lv = 0x31323334))"]
+    proc{@o.save}.must_raise(Sequel::NoExistingObject)
+    @o.lv.must_equal '1234'
+    @db.sqls.must_equal ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.lv WHERE ((id = 1) AND (lv = 0x31323334))"]
     @o = @c.load(:id=>1, :name=>'a', :lv=>'1234')
     @db.fetch = {:lv=>'2345'}
     @o.save
-    @o.lv.should == '2345'
+    @o.lv.must_equal '2345'
   end
 
-  specify "should work when subclassing" do
+  it "should work when subclassing" do
     c = Class.new(@c)
     o = c.load(:id=>1, :name=>'a', :timestamp=>'1234')
     @db.fetch = [[{:timestamp=>'2345'}]]
     o.save
-    @db.sqls.should == ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x31323334))"]
+    @db.sqls.must_equal ["UPDATE TOP (1) items SET name = 'a' OUTPUT inserted.timestamp WHERE ((id = 1) AND (timestamp = 0x31323334))"]
   end
 end

data/spec/extensions/named_timezones_spec.rb

@@ -26,21 +26,21 @@ describe "Sequel named_timezones extension" do
   end
   
   it "should convert string arguments to *_timezone= to TZInfo::Timezone instances" do
-    Sequel.application_timezone.should == @tz_in
-    Sequel.database_timezone.should == @tz_out
+    Sequel.application_timezone.must_equal @tz_in
+    Sequel.database_timezone.must_equal @tz_out
   end
     
   it "should convert string arguments for Database#timezone= to TZInfo::Timezone instances for database-specific timezones" do
     @db.extension :named_timezones
     @db.timezone = 'America/Los_Angeles'
-    @db.timezone.should == @tz_in
+    @db.timezone.must_equal @tz_in
   end
     
   it "should accept TZInfo::Timezone instances in *_timezone=" do
     Sequel.application_timezone = @tz_in
     Sequel.database_timezone = @tz_out
-    Sequel.application_timezone.should == @tz_in
-    Sequel.database_timezone.should == @tz_out
+    Sequel.application_timezone.must_equal @tz_in
+    Sequel.database_timezone.must_equal @tz_out
   end
     
   it "should convert datetimes going into the database to named database_timezone" do
@@ -48,36 +48,36 @@ describe "Sequel named_timezones extension" do
     def ds.supports_timestamp_timezones?; true; end
     def ds.supports_timestamp_usecs?; false; end
     ds.insert([@dt, DateTime.civil(2009,6,1,3,20,30,-7/24.0), DateTime.civil(2009,6,1,6,20,30,-1/6.0)])
-    @db.sqls.should == ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
+    @db.sqls.must_equal ["INSERT INTO a VALUES ('2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400', '2009-06-01 06:20:30-0400')"]
   end
   
   it "should convert datetimes coming out of the database from database_timezone to application_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30-0400')
-    dt.should == @dt
-    dt.offset.should == -7/24.0
+    dt.must_equal @dt
+    dt.offset.must_equal(-7/24.0)
     
     dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30+0000')
-    dt.should == @dt
-    dt.offset.should == -7/24.0
+    dt.must_equal @dt
+    dt.offset.must_equal(-7/24.0)
   end
     
   it "should raise an error for ambiguous timezones by default" do
-    proc{Sequel.database_to_application_timestamp('2004-10-31T01:30:00')}.should raise_error(Sequel::InvalidValue)
+    proc{Sequel.database_to_application_timestamp('2004-10-31T01:30:00')}.must_raise(Sequel::InvalidValue)
   end
 
   it "should support tzinfo_disambiguator= to handle ambiguous timezones automatically" do
     Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
-    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').should == DateTime.parse('2004-10-30T22:30:00-07:00')
+    Sequel.database_to_application_timestamp('2004-10-31T01:30:00').must_equal DateTime.parse('2004-10-30T22:30:00-07:00')
   end
 
   it "should assume datetimes coming out of the database that don't have an offset as coming from database_timezone" do
     dt = Sequel.database_to_application_timestamp('2009-06-01 06:20:30')
-    dt.should == @dt
-    dt.offset.should == -7/24.0
+    dt.must_equal @dt
+    dt.offset.must_equal(-7/24.0)
     
     dt = Sequel.database_to_application_timestamp('2009-06-01 10:20:30')
-    dt.should == @dt + 1/6.0
-    dt.offset.should == -7/24.0
+    dt.must_equal @dt + 1/6.0
+    dt.offset.must_equal(-7/24.0)
   end
   
   it "should work with the thread_local_timezones extension" do
@@ -101,8 +101,8 @@ describe "Sequel named_timezones extension" do
     q1.push nil
     t1.join
     t2.join
-    tz1.should == @tz_out
-    tz2.should == @tz_in
+    tz1.must_equal @tz_out
+    tz2.must_equal @tz_in
   end
 end
 end

data/spec/extensions/nested_attributes_spec.rb

@@ -3,15 +3,15 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "NestedAttributes plugin" do
   def check_sqls(should, is)
     if should.is_a?(Array)
-      should.should include(is)
+      should.must_include(is)
     else
-      is.should == should
+      is.must_equal should
     end
   end
 
   def check_sql_array(*shoulds)
     sqls = @db.sqls
-    sqls.length.should == shoulds.length
+    sqls.length.must_equal shoulds.length
     shoulds.zip(sqls){|s, i| check_sqls(s, i)}
   end
 
@@ -51,7 +51,7 @@ describe "NestedAttributes plugin" do
   
   it "should support creating new many_to_one objects" do
     a = @Album.new({:name=>'Al', :artist_attributes=>{:name=>'Ar'}})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
       ["INSERT INTO albums (name, artist_id) VALUES ('Al', 1)", "INSERT INTO albums (artist_id, name) VALUES (1, 'Al')"])
@@ -61,7 +61,7 @@ describe "NestedAttributes plugin" do
     a = @Artist.new(:name=>'Ar')
     a.id = 1
     a.first_album_attributes = {:name=>'Al'}
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array(["INSERT INTO artists (name, id) VALUES ('Ar', 1)", "INSERT INTO artists (id, name) VALUES (1, 'Ar')"],
       "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)",
@@ -70,7 +70,7 @@ describe "NestedAttributes plugin" do
   
   it "should support creating new one_to_many objects" do
     a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
@@ -85,7 +85,7 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:name=>'Al'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
@@ -93,7 +93,7 @@ describe "NestedAttributes plugin" do
     a = @Artist.new(:name=>'Ar')
     a.id = 1
     a.first_album_attributes = {:name=>'Al'}
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array(["INSERT INTO artists (name, id) VALUES ('Ar', 1)", "INSERT INTO artists (id, name) VALUES (1, 'Ar')"],
       "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)",
@@ -125,10 +125,10 @@ describe "NestedAttributes plugin" do
     end
 
     c = @Concert.new(:playlist=>'Pl')
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     c.albums_attributes = [{:name=>'Al'}]
     c.save
-    insert.should == {:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl'}
+    insert.must_equal(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
     check_sql_array(["INSERT INTO albums (name, artist_id) VALUES ('Al', 3)", "INSERT INTO albums (artist_id, name) VALUES (3, 'Al')"])
 
     @Concert.class_eval do
@@ -142,11 +142,11 @@ describe "NestedAttributes plugin" do
     a = @Artist.new(:name=>'Ar')
     a.id = 1
     a.first_concert_attributes = {:playlist=>'Pl'}
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array(["INSERT INTO artists (name, id) VALUES ('Ar', 1)", "INSERT INTO artists (id, name) VALUES (1, 'Ar')"],
                    "UPDATE concerts SET artist_id = NULL WHERE (artist_id = 1)")
-    insert.should == {:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl'}
+    insert.must_equal(:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl')
   end
 
   it "should should not remove existing values from object when validating" do
@@ -155,15 +155,15 @@ describe "NestedAttributes plugin" do
     @db.fetch = {:id=>1}
     a = @Artist.load(:id=>1)
     a.set(:first_album_attributes=>{:id=>1, :name=>'Ar'})
-    a.first_album.values.should == {:id=>1, :name=>'Ar'}
-    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.id = 1) LIMIT 1"]
+    a.first_album.values.must_equal(:id=>1, :name=>'Ar')
+    @db.sqls.must_equal ["SELECT * FROM albums WHERE (albums.id = 1) LIMIT 1"]
     a.save_changes
     check_sql_array("UPDATE albums SET name = 'Ar' WHERE (id = 1)")
   end
 
   it "should support creating new many_to_many objects" do
     a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
       "INSERT INTO tags (name) VALUES ('T')",
@@ -172,11 +172,11 @@ describe "NestedAttributes plugin" do
   
   it "should add new objects to the cached association array as soon as the *_attributes= method is called" do
     a = @Artist.new({:name=>'Ar', :first_album_attributes=>{:name=>'B'}, :albums_attributes=>[{:name=>'Al', :tags_attributes=>[{:name=>'T'}]}]})
-    a.albums.should == [@Album.new(:name=>'Al')]
-    a.albums.first.artist.should == a
-    a.albums.first.tags.should == [@Tag.new(:name=>'T')]
-    a.first_album.should == @Album.new(:name=>'B')
-    a.first_album.artist.should == a
+    a.albums.must_equal [@Album.new(:name=>'Al')]
+    a.albums.first.artist.must_equal a
+    a.albums.first.tags.must_equal [@Tag.new(:name=>'T')]
+    a.first_album.must_equal @Album.new(:name=>'B')
+    a.first_album.artist.must_equal a
   end
   
   it "should support creating new objects with composite primary keys" do
@@ -192,10 +192,10 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Artist.new({:name=>'Ar', :concerts_attributes=>[{:playlist=>'Pl'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["INSERT INTO artists (name) VALUES ('Ar')"]
-    insert.should == {:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl'}
+    @db.sqls.must_equal ["INSERT INTO artists (name) VALUES ('Ar')"]
+    insert.must_equal(:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl')
   end
 
   it "should support creating new objects with specific primary keys if :unmatched_pk => :create is set" do
@@ -208,10 +208,10 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Artist.new({:name=>'Ar', :albums_attributes=>[{:id=>7, :name=>'Al'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["INSERT INTO artists (name) VALUES ('Ar')"]
-    insert.should == {:artist_id=>1, :name=>'Al', :id=>7}
+    @db.sqls.must_equal ["INSERT INTO artists (name) VALUES ('Ar')"]
+    insert.must_equal(:artist_id=>1, :name=>'Al', :id=>7)
   end
 
   it "should support creating new objects with specific composite primary keys if :unmatched_pk => :create is set" do
@@ -223,10 +223,10 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Artist.new({:name=>'Ar', :concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["INSERT INTO artists (name) VALUES ('Ar')"]
-    insert.should == {:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl'}
+    @db.sqls.must_equal ["INSERT INTO artists (name) VALUES ('Ar')"]
+    insert.must_equal(:tour=>'To', :date=>'2004-04-05', :artist_id=>1, :playlist=>'Pl')
   end
 
   it "should support updating many_to_one objects" do
@@ -234,9 +234,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
     al.set(:artist_attributes=>{:id=>'20', :name=>'Ar2'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.save
-    @db.sqls.should == ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE artists SET name = 'Ar2' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE artists SET name = 'Ar2' WHERE (id = 20)"]
   end
   
   it "should support updating one_to_one objects" do
@@ -244,9 +244,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:first_album] = al
     ar.set(:first_album_attributes=>{:id=>10, :name=>'Al2'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
   end
   
   it "should support updating one_to_many objects" do
@@ -254,9 +254,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
   end
   
   it "should support updating one_to_many objects with _delete/_remove flags set to false" do
@@ -264,9 +264,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2', :_delete => 'f', :_remove => '0'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "UPDATE albums SET name = 'Al2' WHERE (id = 10)"]
   end
   
   it "should support updating many_to_many objects" do
@@ -274,9 +274,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :name=>'T2'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE tags SET name = 'T2' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE tags SET name = 'T2' WHERE (id = 20)"]
   end
   
   it "should support updating many_to_many objects with _delete/_remove flags set to false" do
@@ -284,9 +284,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :name=>'T2', '_delete' => false, '_remove' => 'F'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE tags SET name = 'T2' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE albums SET name = 'Al' WHERE (id = 10)", "UPDATE tags SET name = 'T2' WHERE (id = 20)"]
   end
   
   it "should support updating objects with composite primary keys" do
@@ -294,7 +294,7 @@ describe "NestedAttributes plugin" do
     co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
     ar.associations[:concerts] = [co]
     ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl2'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
     check_sql_array("UPDATE artists SET name = 'Ar' WHERE (id = 10)", ["UPDATE concerts SET playlist = 'Pl2' WHERE ((tour = 'To') AND (date = '2004-04-05'))", "UPDATE concerts SET playlist = 'Pl2' WHERE ((date = '2004-04-05') AND (tour = 'To'))"])
   end
@@ -304,7 +304,7 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
     al.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.save
     check_sql_array(["UPDATE albums SET artist_id = NULL, name = 'Al' WHERE (id = 10)", "UPDATE albums SET name = 'Al', artist_id = NULL WHERE (id = 10)"])
   end
@@ -314,9 +314,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:first_album] = al
     ar.set(:first_album_attributes=>{:id=>10, :_remove=>'t'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 20)", "UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 20)", "UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
   end
   
   it "should support removing one_to_many objects" do
@@ -324,8 +324,8 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :_remove=>'t'}])
-    ar.associations[:albums].should == []
-    @db.sqls.should == []
+    ar.associations[:albums].must_equal []
+    @db.sqls.must_equal []
     @Album.dataset._fetch = {:id=>1}
     ar.save
     check_sql_array("SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 20) AND (id = 10)) LIMIT 1",
@@ -338,10 +338,10 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :_remove=>true}])
-    a.associations[:tags].should == []
-    @db.sqls.should == []
+    a.associations[:tags].must_equal []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)"]
+    @db.sqls.must_equal ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)"]
   end
   
   it "should support removing objects with composite primary keys" do
@@ -349,7 +349,7 @@ describe "NestedAttributes plugin" do
     co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
     ar.associations[:concerts] = [co]
     ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_remove=>'t'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     @Concert.dataset._fetch = {:id=>1}
     ar.save
     check_sql_array(["SELECT 1 AS one FROM concerts WHERE ((concerts.artist_id = 10) AND (tour = 'To') AND (date = '2004-04-05')) LIMIT 1", "SELECT 1 AS one FROM concerts WHERE ((concerts.artist_id = 10) AND (date = '2004-04-05') AND (tour = 'To')) LIMIT 1"],
@@ -362,7 +362,7 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
     al.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.save
     check_sql_array(["UPDATE albums SET artist_id = NULL, name = 'Al' WHERE (id = 10)", "UPDATE albums SET name = 'Al', artist_id = NULL WHERE (id = 10)"],
       "DELETE FROM artists WHERE (id = 20)")
@@ -373,9 +373,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:first_album] = al
     ar.set(:first_album_attributes=>{:id=>10, :_delete=>'t'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
   end
   
   it "should support destroying one_to_many objects" do
@@ -383,9 +383,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)", "DELETE FROM albums WHERE (id = 10)"]
   end
   
   it "should support destroying many_to_many objects" do
@@ -393,9 +393,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set(:tags_attributes=>[{:id=>20, :_delete=>true}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
+    @db.sqls.must_equal ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
   it "should support destroying objects with composite primary keys" do
@@ -403,7 +403,7 @@ describe "NestedAttributes plugin" do
     co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
     ar.associations[:concerts] = [co]
     ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_delete=>'t'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
     check_sql_array("UPDATE artists SET name = 'Ar' WHERE (id = 10)", ["DELETE FROM concerts WHERE ((tour = 'To') AND (date = '2004-04-05'))", "DELETE FROM concerts WHERE ((date = '2004-04-05') AND (tour = 'To'))"])
   end
@@ -413,9 +413,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set('tags_attributes'=>[{'id'=>20, '_delete'=>true}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
+    @db.sqls.must_equal ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
   it "should support using a hash instead of an array for to_many nested attributes" do
@@ -423,9 +423,9 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>20, :name=>'T')
     a.associations[:tags] = [t]
     a.set('tags_attributes'=>{'1'=>{'id'=>20, '_delete'=>true}})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
-    @db.sqls.should == ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
+    @db.sqls.must_equal ["DELETE FROM at WHERE ((album_id = 10) AND (tag_id = 20))", "UPDATE albums SET name = 'Al' WHERE (id = 10)", "DELETE FROM tags WHERE (id = 20)"]
   end
   
   it "should only allow destroying associated objects if :destroy option is used in the nested_attributes call" do
@@ -433,9 +433,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     a.associations[:artist] = ar
     @Album.nested_attributes :artist
-    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.must_raise(Sequel::MassAssignmentRestriction)
     @Album.nested_attributes :artist, :destroy=>true
-    proc{a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})}.should_not raise_error
+    a.set(:artist_attributes=>{:id=>'20', :_delete=>'1'})
   end
   
   it "should only allow removing associated objects if :remove option is used in the nested_attributes call" do
@@ -443,17 +443,17 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     a.associations[:artist] = ar
     @Album.nested_attributes :artist
-    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.must_raise(Sequel::MassAssignmentRestriction)
     @Album.nested_attributes :artist, :remove=>true
-    proc{a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})}.should_not raise_error
+    a.set(:artist_attributes=>{:id=>'20', :_remove=>'1'})
   end
   
   it "should raise an Error if a primary key is given in a nested attribute hash, but no matching associated object exists" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
-    proc{ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])}.should raise_error(Sequel::Error)
-    proc{ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])}.should_not raise_error
+    proc{ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])}.must_raise(Sequel::Error)
+    ar.set(:albums_attributes=>[{:id=>10, :_delete=>'t'}])
   end
   
   it "should not raise an Error if an unmatched primary key is given, if the :strict=>false option is used" do
@@ -462,9 +462,9 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
   end
   
   it "should not raise an Error if an unmatched primary key is given, if the :unmatched_pk=>:ignore option is used" do
@@ -473,17 +473,17 @@ describe "NestedAttributes plugin" do
     ar = @Artist.load(:id=>20, :name=>'Ar')
     ar.associations[:albums] = [al]
     ar.set(:albums_attributes=>[{:id=>30, :_delete=>'t'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 20)"]
   end
 
   it "should raise an Error if a composite primary key is given in a nested attribute hash, but no matching associated object exists" do
     ar = @Artist.load(:id=>10, :name=>'Ar')
     co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
     ar.associations[:concerts] = [co]
-    proc{ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-04', :_delete=>'t'}])}.should raise_error(Sequel::Error)
-    proc{ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_delete=>'t'}])}.should_not raise_error
+    proc{ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-04', :_delete=>'t'}])}.must_raise(Sequel::Error)
+    ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-05', :_delete=>'t'}])
   end
 
   it "should not raise an Error if an unmatched composite primary key is given, if the :strict=>false option is used" do
@@ -492,9 +492,9 @@ describe "NestedAttributes plugin" do
     co = @Concert.load(:tour=>'To', :date=>'2004-04-05', :playlist=>'Pl')
     ar.associations[:concerts] = [co]
     ar.set(:concerts_attributes=>[{:tour=>'To', :date=>'2004-04-06', :_delete=>'t'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     ar.save
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar' WHERE (id = 10)"]
   end
 
   it "should not save if nested attribute is not valid and should include nested attribute validation errors in the main object's validation errors" do
@@ -505,12 +505,12 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
-    @db.sqls.should == []
-    proc{a.save}.should raise_error(Sequel::ValidationFailed)
-    a.errors.full_messages.should == ['artist name cannot be Ar']
-    @db.sqls.should == []
+    @db.sqls.must_equal []
+    proc{a.save}.must_raise(Sequel::ValidationFailed)
+    a.errors.full_messages.must_equal ['artist name cannot be Ar']
+    @db.sqls.must_equal []
     # Should preserve attributes
-    a.artist.name.should == 'Ar'
+    a.artist.name.must_equal 'Ar'
   end
   
   it "should not attempt to validate nested attributes if the :validate=>false association option is used" do
@@ -523,7 +523,7 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
@@ -537,7 +537,7 @@ describe "NestedAttributes plugin" do
       end
     end
     a = @Album.new(:name=>'Al', :artist_attributes=>{:name=>'Ar'})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save(:validate=>false)
     check_sql_array("INSERT INTO artists (name) VALUES ('Ar')",
       ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
@@ -545,25 +545,25 @@ describe "NestedAttributes plugin" do
   
   it "should not accept nested attributes unless explicitly specified" do
     @Artist.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:at
-    proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.should raise_error(Sequel::MassAssignmentRestriction)
-    @db.sqls.should == []
+    proc{@Artist.create({:name=>'Ar', :tags_attributes=>[{:name=>'T'}]})}.must_raise(Sequel::MassAssignmentRestriction)
+    @db.sqls.must_equal []
   end
   
   it "should save when save_changes or update is called if nested attribute associated objects changed but there are no changes to the main object" do
     al = @Album.load(:id=>10, :name=>'Al')
     ar = @Artist.load(:id=>20, :name=>'Ar')
     al.associations[:artist] = ar
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.update(:artist_attributes=>{:id=>'20', :name=>'Ar2'})
-    @db.sqls.should == ["UPDATE artists SET name = 'Ar2' WHERE (id = 20)"]
+    @db.sqls.must_equal ["UPDATE artists SET name = 'Ar2' WHERE (id = 20)"]
   end
   
   it "should have a :limit option limiting the amount of entries" do
     @Album.nested_attributes :tags, :limit=>2
     arr = [{:name=>'T'}]
-    proc{@Album.new({:name=>'Al', :tags_attributes=>arr*3})}.should raise_error(Sequel::Error)
+    proc{@Album.new({:name=>'Al', :tags_attributes=>arr*3})}.must_raise(Sequel::Error)
     a = @Album.new({:name=>'Al', :tags_attributes=>arr*2})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
       "INSERT INTO tags (name) VALUES ('T')",
@@ -575,7 +575,7 @@ describe "NestedAttributes plugin" do
   it "should accept a block that each hash gets passed to determine if it should be processed" do
     @Album.nested_attributes(:tags){|h| h[:name].empty?}
     a = @Album.new({:name=>'Al', :tags_attributes=>[{:name=>'T'}, {:name=>''}, {:name=>'T2'}]})
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
       "INSERT INTO tags (name) VALUES ('T')",
@@ -588,7 +588,7 @@ describe "NestedAttributes plugin" do
     @Album.nested_attributes :tags, :transform=>proc{|parent, hash| hash[:name] << parent.name; hash }
     a = @Album.new(:name => 'Al')
     a.set(:tags_attributes=>[{:name=>'T'}, {:name=>'T2'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     a.save
     check_sql_array("INSERT INTO albums (name) VALUES ('Al')",
       "INSERT INTO tags (name) VALUES ('TAl')",
@@ -608,7 +608,7 @@ describe "NestedAttributes plugin" do
     a = @Album.new(:name=>'Al')
     a.associations[:tags] = [@Tag.load(:id=>6, :name=>'A'), @Tag.load(:id=>7, :name=>'A2')] 
     a.tags_attributes = [{:id=>6, :name=>'T'}, {:id=>7, :name=>'T2', :_remove=>true}, {:name=>'T3'}, {:id=>8, :name=>'T4'}, {:id=>9, :name=>'T5', :_remove=>true}]
-    objs.should == [[@Tag.load(:id=>6, :name=>'T'), :update], [@Tag.load(:id=>7, :name=>'A2'), :remove], [@Tag.new(:name=>'T3'), :create]]
+    objs.must_equal [[@Tag.load(:id=>6, :name=>'T'), :update], [@Tag.load(:id=>7, :name=>'A2'), :remove], [@Tag.new(:name=>'T3'), :create]]
   end
 
   it "should raise an error if updating modifies the associated objects keys" do
@@ -627,9 +627,9 @@ describe "NestedAttributes plugin" do
     al.associations[:artist] = ar
     al.associations[:tags] = [t]
     ar.associations[:albums] = [al]
-    proc{ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2', :artist_id=>'3'}])}.should raise_error(Sequel::Error)
-    proc{al.set(:artist_attributes=>{:id=>20, :name=>'Ar2', :artist_id=>'3'})}.should raise_error(Sequel::Error)
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :tag_id=>'3'}])}.should raise_error(Sequel::Error)
+    proc{ar.set(:albums_attributes=>[{:id=>10, :name=>'Al2', :artist_id=>'3'}])}.must_raise(Sequel::Error)
+    proc{al.set(:artist_attributes=>{:id=>20, :name=>'Ar2', :artist_id=>'3'})}.must_raise(Sequel::Error)
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :tag_id=>'3'}])}.must_raise(Sequel::Error)
   end
 
   it "should accept a :fields option and only allow modification of those fields" do
@@ -640,14 +640,14 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>30, :name=>'T', :number=>10)
     al.associations[:tags] = [t]
     al.set(:tags_attributes=>[{:id=>30, :name=>'T2'}, {:name=>'T3'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.save
     check_sql_array("UPDATE albums SET name = 'Al' WHERE (id = 10)",
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should accept a proc for the :fields option that accepts the associated object and returns an array of fields" do
@@ -658,14 +658,14 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>30, :name=>'T', :number=>10)
     al.associations[:tags] = [t]
     al.set(:tags_attributes=>[{:id=>30, :name=>'T2'}, {:name=>'T3'}])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.save
     check_sql_array("UPDATE albums SET name = 'Al' WHERE (id = 10)",
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should allow per-call options via the set_nested_attributes method" do
@@ -676,22 +676,22 @@ describe "NestedAttributes plugin" do
     t = @Tag.load(:id=>30, :name=>'T', :number=>10)
     al.associations[:tags] = [t]
     al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2'}, {:name=>'T3'}], :fields=>[:name])
-    @db.sqls.should == []
+    @db.sqls.must_equal []
     al.save
     check_sql_array("UPDATE albums SET name = 'Al' WHERE (id = 10)",
       "UPDATE tags SET name = 'T2' WHERE (id = 30)",
       "INSERT INTO tags (name) VALUES ('T3')",
       ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
-    proc{al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{al.set_nested_attributes(:tags, [{:name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{al.set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{al.set_nested_attributes(:tags, [{:name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should have set_nested_attributes method raise error if called with a bad association" do
-    proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags2, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+    proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags2, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::Error)
   end
 
   it "should have set_nested_attributes method raise error if called with an association that doesn't support nested attributes" do
     @Tag.columns :id, :name, :number
-    proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.should raise_error(Sequel::Error)
+    proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::Error)
   end
 end