sequel 4.22.0 → 4.23.0

data/spec/extensions/accessed_columns_spec.rb

@@ -10,42 +10,42 @@ describe "accessed_columns plugin" do
   end
 
   it "should record columns accessed" do
-    @o.accessed_columns.should == []
+    @o.accessed_columns.must_equal []
     @o.name
-    @o.accessed_columns.should == [:name]
+    @o.accessed_columns.must_equal [:name]
     @o.name
-    @o.accessed_columns.should == [:name]
+    @o.accessed_columns.must_equal [:name]
     @o.b
-    @o.accessed_columns.sort_by{|s| s.to_s}.should == [:b, :name]
+    @o.accessed_columns.sort_by{|s| s.to_s}.must_equal [:b, :name]
   end
 
   it "should clear accessed columns when refreshing" do
     @o.name
     @o.refresh
-    @o.accessed_columns.should == []
+    @o.accessed_columns.must_equal []
   end
 
   it "should clear accessed columns when saving" do
     @o.name
     @o.save
-    @o.accessed_columns.should == []
+    @o.accessed_columns.must_equal []
   end
 
   it "should work when duping and cloning instances" do
     @o.name
     o = @o.dup
-    @o.accessed_columns.should == [:name]
+    @o.accessed_columns.must_equal [:name]
     @o.b
-    @o.accessed_columns.sort_by{|s| s.to_s}.should == [:b, :name]
-    o.accessed_columns.should == [:name]
+    @o.accessed_columns.sort_by{|s| s.to_s}.must_equal [:b, :name]
+    o.accessed_columns.must_equal [:name]
     o2 = o.clone
     o2.refresh
-    o.accessed_columns.should == [:name]
-    o2.accessed_columns.should == []
+    o.accessed_columns.must_equal [:name]
+    o2.accessed_columns.must_equal []
   end
 
   it "should not raise exceptions when object is frozen" do
     @o.freeze
-    proc{@o.name}.should_not raise_error
+    @o.name
   end
 end

data/spec/extensions/active_model_spec.rb

@@ -24,7 +24,7 @@ rescue LoadError => e
   skip_warn "active_model plugin: can't load active_model (#{e.class}: #{e})"
 else
 describe "ActiveModel plugin" do
-  specify "should be compliant to the ActiveModel spec" do
+  it "should be compliant to the ActiveModel spec" do
     tc = Class.new(test_class)
     tc.class_eval do
       define_method(:setup) do
@@ -53,7 +53,7 @@ describe "ActiveModel plugin" do
 
       # Should return self, not a proxy object
       def test__to_model
-        assert_equal @m.to_model.object_id.should, @m.object_id
+        assert_equal @m.to_model.object_id, @m.object_id
       end
       
       def test__to_key
@@ -116,7 +116,7 @@ describe "ActiveModel plugin" do
       if res.failure_count > 0
         puts res.instance_variable_get(:@failures)
       end
-      res.failure_count.should == 0
+      res.failure_count.must_equal 0
     end
   end
 end 

data/spec/extensions/after_initialize_spec.rb

@@ -15,10 +15,10 @@ describe "Sequel::Plugins::AfterInitialize" do
   end
 
   it "should have after_initialize hook be called for new objects" do
-    @c.new(:name=>'foo').values.should == {:name=>'foofoo'}
+    @c.new(:name=>'foo').values.must_equal(:name=>'foofoo')
   end
 
   it "should have after_initialize hook be called for objects loaded from the database" do
-    @c.call(:id=>1, :name=>'foo').values.should == {:id=>3, :name=>'foofoo'}
+    @c.call(:id=>1, :name=>'foo').values.must_equal(:id=>3, :name=>'foofoo')
   end
 end

data/spec/extensions/arbitrary_servers_spec.rb

@@ -6,78 +6,78 @@ describe "arbtirary servers" do
     @db.extension :arbitrary_servers
   end
 
-  specify "should allow arbitrary server options using a hash" do
+  it "should allow arbitrary server options using a hash" do
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      c.opts[:host].should == 'host1'
-      c.opts[:database].should == 'db1'
+      c.opts[:host].must_equal 'host1'
+      c.opts[:database].must_equal 'db1'
     end
   end
 
-  specify "should not cache connections to arbitrary servers" do
+  it "should not cache connections to arbitrary servers" do
     x = nil
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
       x = c
     end
     @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-      c2.should_not equal(x)
+      c2.wont_be_same_as(x)
     end
   end
 
-  specify "should yield same connection correctly when nesting" do
+  it "should yield same connection correctly when nesting" do
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
       @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-        c2.should equal(c)
+        c2.must_be_same_as(c)
       end
     end
   end
 
-  specify "should disconnect when connection is finished" do
+  it "should disconnect when connection is finished" do
     x, x1 = nil, nil
     @db.meta_def(:disconnect_connection){|c| x = c}
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
       x1 = c
       @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-        c2.should equal(c)
+        c2.must_be_same_as(c)
       end
-      x.should equal(nil)
+      x.must_be_same_as(nil)
     end
-    x.should equal(x1)
+    x.must_be_same_as(x1)
   end
 
-  specify "should yield different connection correctly when nesting" do
+  it "should yield different connection correctly when nesting" do
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
-      c.opts[:host].should == 'host1'
+      c.opts[:host].must_equal 'host1'
       @db.synchronize(:host=>'host2', :database=>'db1') do |c2|
-        c2.opts[:host].should == 'host2'
-        c2.should_not equal(c)
+        c2.opts[:host].must_equal 'host2'
+        c2.wont_be_same_as(c)
       end
     end
   end
 
-  specify "should respect multithreaded access" do
+  it "should respect multithreaded access" do
     @db.synchronize(:host=>'host1', :database=>'db1') do |c|
       Thread.new do
         @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
-          c2.should_not equal(c)
+          _(c2).wont_be_same_as(c)
         end
       end.join
     end
   end
 
-  specify "should work correctly with server_block plugin" do
+  it "should work correctly with server_block plugin" do
     @db.extension :server_block
     @db.with_server(:host=>'host1', :database=>'db1') do
       @db.synchronize do |c|
-        c.opts[:host].should == 'host1'
-        c.opts[:database].should == 'db1'
+        c.opts[:host].must_equal 'host1'
+        c.opts[:database].must_equal 'db1'
         @db.synchronize do |c2|
-          c2.should equal(c)
+          c2.must_be_same_as(c)
         end
       end
     end
   end
 
-  specify "should respect multithreaded access with server block plugin" do
+  it "should respect multithreaded access with server block plugin" do
     @db.extension :server_block
     q, q1 = Queue.new, Queue.new
     
@@ -103,7 +103,7 @@ describe "arbtirary servers" do
     @db[:t].all
     q1.push nil
     t.join
-    @db.sqls.should == ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
+    @db.sqls.must_equal ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
       'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
   end
 end

data/spec/extensions/association_dependencies_spec.rb

@@ -18,100 +18,100 @@ describe "AssociationDependencies plugin" do
     DB.reset
   end
 
-  specify "should allow destroying associated many_to_one associated object" do
+  it "should allow destroying associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should allow deleting associated many_to_one associated object" do
+  it "should allow deleting associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:delete
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
   end
   
-  specify "should allow destroying associated one_to_one associated object" do
+  it "should allow destroying associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should allow deleting associated one_to_one associated object" do
+  it "should allow deleting associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should allow destroying associated one_to_many objects" do
+  it "should allow destroying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should allow deleting associated one_to_many objects" do
+  it "should allow deleting associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
   
-  specify "should allow nullifying associated one_to_one objects" do
+  it "should allow nullifying associated one_to_one objects" do
     @Artist.add_association_dependencies :first_album=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should allow nullifying associated one_to_many objects" do
+  it "should allow nullifying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should allow nullifying associated many_to_many associations" do
+  it "should allow nullifying associated many_to_many associations" do
     @Artist.add_association_dependencies :other_artists=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should raise an error if attempting to nullify a many_to_one association" do
-    proc{@Album.add_association_dependencies :artist=>:nullify}.should raise_error(Sequel::Error)
+  it "should raise an error if attempting to nullify a many_to_one association" do
+    proc{@Album.add_association_dependencies :artist=>:nullify}.must_raise(Sequel::Error)
   end
 
-  specify "should raise an error if using an unrecognized dependence action" do
-    proc{@Album.add_association_dependencies :artist=>:blah}.should raise_error(Sequel::Error)
+  it "should raise an error if using an unrecognized dependence action" do
+    proc{@Album.add_association_dependencies :artist=>:blah}.must_raise(Sequel::Error)
   end
 
-  specify "should raise an error if a nonexistent association is used" do
-    proc{@Album.add_association_dependencies :blah=>:delete}.should raise_error(Sequel::Error)
+  it "should raise an error if a nonexistent association is used" do
+    proc{@Album.add_association_dependencies :blah=>:delete}.must_raise(Sequel::Error)
   end
 
-  specify "should raise an error if a invalid association type is used" do
+  it "should raise an error if a invalid association type is used" do
     @Artist.plugin :many_through_many
     @Artist.many_through_many :other_albums, [[:id, :id, :id]]
-    proc{@Artist.add_association_dependencies :other_albums=>:nullify}.should raise_error(Sequel::Error)
+    proc{@Artist.add_association_dependencies :other_albums=>:nullify}.must_raise(Sequel::Error)
   end
 
-  specify "should raise an error if using a many_to_many association type without nullify" do
-    proc{@Artist.add_association_dependencies :other_artists=>:delete}.should raise_error(Sequel::Error)
+  it "should raise an error if using a many_to_many association type without nullify" do
+    proc{@Artist.add_association_dependencies :other_artists=>:delete}.must_raise(Sequel::Error)
   end
 
-  specify "should allow specifying association dependencies in the plugin call" do
+  it "should allow specifying association dependencies in the plugin call" do
     @Album.plugin :association_dependencies, :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
-  specify "should work with subclasses" do
+  it "should work with subclasses" do
     c = Class.new(@Album)
     c.add_association_dependencies :artist=>:destroy
     c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE id = 1']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1']
 
     @Album.add_association_dependencies :artist=>:destroy
     c2 = Class.new(@Album)
     c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.must_equal ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 end

data/spec/extensions/association_pks_spec.rb

@@ -60,143 +60,143 @@ describe "Sequel::Plugins::AssociationPks" do
     @db.sqls
   end
 
-  specify "should return correct associated pks for one_to_many associations" do
-    @Artist.load(:id=>1).album_pks.should == [1,2,3]
-    @Artist.load(:id=>2).album_pks.should == []
+  it "should return correct associated pks for one_to_many associations" do
+    @Artist.load(:id=>1).album_pks.must_equal [1,2,3]
+    @Artist.load(:id=>2).album_pks.must_equal []
   end
 
-  specify "should return correct associated pks for many_to_many associations" do
-    @Album.load(:id=>1).tag_pks.should == [1, 2]
-    @Album.load(:id=>2).tag_pks.should == [2, 3]
-    @Album.load(:id=>3).tag_pks.should == []
+  it "should return correct associated pks for many_to_many associations" do
+    @Album.load(:id=>1).tag_pks.must_equal [1, 2]
+    @Album.load(:id=>2).tag_pks.must_equal [2, 3]
+    @Album.load(:id=>3).tag_pks.must_equal []
   end
 
-  specify "should set associated pks correctly for a one_to_many association" do
+  it "should set associated pks correctly for a one_to_many association" do
     @Artist.load(:id=>1).album_pks = [1, 2]
-    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
   end
 
-  specify "should use associated class's primary key for a one_to_many association" do
+  it "should use associated class's primary key for a one_to_many association" do
     @Album.set_primary_key :foo
     @Artist.load(:id=>1).album_pks = [1, 2]
-    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (foo IN (1, 2))",
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (foo IN (1, 2))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (foo NOT IN (1, 2)))"]
   end
 
-  specify "should set associated pks correctly for a many_to_many association" do
+  it "should set associated pks correctly for a many_to_many association" do
     @Album.load(:id=>2).tag_pks = [1, 3]
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[2].should == 'BEGIN'
-    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
-    sqls[4].should == 'COMMIT'
-    sqls.length.should == 5
+    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].must_equal 'BEGIN'
+    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
+    sqls[4].must_equal 'COMMIT'
+    sqls.length.must_equal 5
   end
 
-  specify "should return correct right-side associated cpks for one_to_many associations" do
+  it "should return correct right-side associated cpks for one_to_many associations" do
     @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
-    @Album.load(:id=>1).vocalist_pks.should == [["F1", "L1"], ["F2", "L2"]]
-    @Album.load(:id=>2).vocalist_pks.should == []
+    @Album.load(:id=>1).vocalist_pks.must_equal [["F1", "L1"], ["F2", "L2"]]
+    @Album.load(:id=>2).vocalist_pks.must_equal []
   end
 
-  specify "should return correct right-side associated cpks for many_to_many associations" do
+  it "should return correct right-side associated cpks for many_to_many associations" do
     @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
-    @Album.load(:id=>1).vocalist_pks.should == [["F1", "L1"], ["F2", "L2"]]
-    @Album.load(:id=>2).vocalist_pks.should == [["F2", "L2"], ["F3", "L3"]]
-    @Album.load(:id=>3).vocalist_pks.should == []
+    @Album.load(:id=>1).vocalist_pks.must_equal [["F1", "L1"], ["F2", "L2"]]
+    @Album.load(:id=>2).vocalist_pks.must_equal [["F2", "L2"], ["F3", "L3"]]
+    @Album.load(:id=>3).vocalist_pks.must_equal []
   end
 
-  specify "should set associated right-side cpks correctly for a one_to_many association" do
+  it "should set associated right-side cpks correctly for a one_to_many association" do
     @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
     @Album.load(:id=>1).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
-    @db.sqls.should == ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN (('F1', 'L1'), ('F2', 'L2')))",
+    @db.sqls.must_equal ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN (('F1', 'L1'), ('F2', 'L2')))",
       "UPDATE vocalists SET album_id = NULL WHERE ((vocalists.album_id = 1) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"]
   end
 
-  specify "should set associated right-side cpks correctly for a many_to_many association" do
+  it "should set associated right-side cpks correctly for a many_to_many association" do
     @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
     @Album.load(:id=>2).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"
-    sqls[1].should == 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
+    sqls[0].must_equal "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"
+    sqls[1].must_equal 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
     match = sqls[3].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F1'", "last"=>"'L1'", "album_id"=>"2"}
-    sqls.length.should == 5
+    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F1'", "last"=>"'L1'", "album_id"=>"2")
+    sqls.length.must_equal 5
   end
 
-  specify "should return correct associated pks for left-side cpks for one_to_many associations" do
+  it "should return correct associated pks for left-side cpks for one_to_many associations" do
     @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.should == [1, 2]
-    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.should == []
+    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.must_equal [1, 2]
+    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.must_equal []
   end
 
-  specify "should return correct associated pks for left-side cpks for many_to_many associations" do
+  it "should return correct associated pks for left-side cpks for many_to_many associations" do
     @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.should == [1, 2]
-    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.should == [2, 3]
-    @Vocalist.load(:first=>'F3', :last=>'L3').instrument_pks.should == []
+    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.must_equal [1, 2]
+    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.must_equal [2, 3]
+    @Vocalist.load(:first=>'F3', :last=>'L3').instrument_pks.must_equal []
   end
 
-  specify "should set associated pks correctly for left-side cpks for a one_to_many association" do
+  it "should set associated pks correctly for left-side cpks for a one_to_many association" do
     @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last]
     @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks = [1, 2]
     sqls = @db.sqls
-    sqls[0].should =~ /UPDATE instruments SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(id IN \(1, 2\)\)/
-    sqls[1].should =~ /UPDATE instruments SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(instruments.first = 'F1'\) AND \(instruments.last = 'L1'\) AND \(id NOT IN \(1, 2\)\)\)/
-    sqls.length.should == 2
+    sqls[0].must_match(/UPDATE instruments SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(id IN \(1, 2\)\)/)
+    sqls[1].must_match(/UPDATE instruments SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(instruments.first = 'F1'\) AND \(instruments.last = 'L1'\) AND \(id NOT IN \(1, 2\)\)\)/)
+    sqls.length.must_equal 2
   end
 
-  specify "should set associated pks correctly for left-side cpks for a many_to_many association" do
+  it "should set associated pks correctly for left-side cpks for a many_to_many association" do
     @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last]
     @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks = [1, 2]
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2') AND (instrument_id NOT IN (1, 2)))"
-    sqls[1].should == "SELECT instrument_id FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2'))"
+    sqls[0].must_equal "DELETE FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2') AND (instrument_id NOT IN (1, 2)))"
+    sqls[1].must_equal "SELECT instrument_id FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2'))"
     match = sqls[3].match(/INSERT INTO vocalists_instruments \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F2'", "last"=>"'L2'", "instrument_id"=>"1"}
-    sqls.length.should == 5
+    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F2'", "last"=>"'L2'", "instrument_id"=>"1")
+    sqls.length.must_equal 5
   end
 
-  specify "should return correct right-side associated cpks for left-side cpks for one_to_many associations" do
+  it "should return correct right-side associated cpks for left-side cpks for one_to_many associations" do
     @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last]
-    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.should == [[1997, 1], [1997, 2]]
-    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.should == []
+    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal []
   end
 
-  specify "should return correct right-side associated cpks for left-side cpks for many_to_many associations" do
+  it "should return correct right-side associated cpks for left-side cpks for many_to_many associations" do
     @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
-    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.should == [[1997, 1], [1997, 2]]
-    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.should == [[1997, 2], [1997, 3]]
-    @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.should == []
+    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.must_equal [[1997, 1], [1997, 2]]
+    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.must_equal [[1997, 2], [1997, 3]]
+    @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.must_equal []
   end
 
-  specify "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do
+  it "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do
     @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last], :order=>:week
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks = [[1997, 1], [1997, 2]]
     sqls = @db.sqls
-    sqls[0].should =~ /UPDATE hits SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(\(year, week\) IN \(\(1997, 1\), \(1997, 2\)\)\)/
-    sqls[1].should =~ /UPDATE hits SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(hits.first = 'F1'\) AND \(hits.last = 'L1'\) AND \(\(year, week\) NOT IN \(\(1997, 1\), \(1997, 2\)\)\)\)/
-    sqls.length.should == 2
+    sqls[0].must_match(/UPDATE hits SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(\(year, week\) IN \(\(1997, 1\), \(1997, 2\)\)\)/)
+    sqls[1].must_match(/UPDATE hits SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(hits.first = 'F1'\) AND \(hits.last = 'L1'\) AND \(\(year, week\) NOT IN \(\(1997, 1\), \(1997, 2\)\)\)\)/)
+    sqls.length.must_equal 2
   end
 
-  specify "should set associated right-side cpks correctly for left-side cpks for a many_to_many association" do
+  it "should set associated right-side cpks correctly for left-side cpks for a many_to_many association" do
     @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks = [[1997, 1], [1997, 2]]
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
-    sqls[1].should == "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
+    sqls[0].must_equal "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
+    sqls[1].must_equal "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
     match = sqls[3].match(/INSERT INTO vocalists_hits \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1"}
-    sqls.length.should == 5
+    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1")
+    sqls.length.must_equal 5
   end
 
-  specify "should use transactions if the object is configured to use transactions" do
+  it "should use transactions if the object is configured to use transactions" do
     artist = @Artist.load(:id=>1)
     artist.use_transactions = true
     artist.album_pks = [1, 2]
-    @db.sqls.should == ["BEGIN",
+    @db.sqls.must_equal ["BEGIN",
       "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))",
       "COMMIT"]
@@ -205,77 +205,77 @@ describe "Sequel::Plugins::AssociationPks" do
     album.use_transactions = true
     album.tag_pks = [1, 3]
     sqls = @db.sqls
-    sqls[0].should == "BEGIN"
-    sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[2].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
-    sqls[4].should == "COMMIT"
-    sqls.length.should == 5
+    sqls[0].must_equal "BEGIN"
+    sqls[1].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[2].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
+    sqls[4].must_equal "COMMIT"
+    sqls.length.must_equal 5
   end
 
-  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+  it "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
     @Album.db_schema[:id][:type] = :integer
     @Artist.load(:id=>1).album_pks = %w'1 2'
-    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
   end
 
-  specify "should not automatically convert keys if the primary key is not an integer for one_to_many associations" do
+  it "should not automatically convert keys if the primary key is not an integer for one_to_many associations" do
     @Album.db_schema[:id][:type] = :string
     @Artist.load(:id=>1).album_pks = %w'1 2'
-    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN ('1', '2'))",
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN ('1', '2'))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN ('1', '2')))"]
   end
 
-  specify "should automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+  it "should automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
     @Tag.db_schema[:id][:type] = :integer
     @Album.load(:id=>2).tag_pks = %w'1 3'
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
-    sqls.length.should == 5
+    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
+    sqls.length.must_equal 5
   end
 
-  specify "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+  it "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
     @Tag.db_schema[:id][:type] = :string
     @Album.load(:id=>2).tag_pks = %w'1 3'
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
-    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/
-    sqls[4].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/
-    sqls.length.should == 6
+    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
+    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/)
+    sqls[4].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/)
+    sqls.length.must_equal 6
   end
 
-  specify "should automatically convert keys to numbers for appropriate integer primary key for composite key associations" do
+  it "should automatically convert keys to numbers for appropriate integer primary key for composite key associations" do
     @Hit.db_schema[:year][:type] = :integer
     @Hit.db_schema[:week][:type] = :integer
     @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks = [['1997', '1'], ['1997', '2']]
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
-    sqls[1].should == "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
+    sqls[0].must_equal "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
+    sqls[1].must_equal "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
     match = sqls[3].match(/INSERT INTO vocalists_hits \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1"}
-    sqls.length.should == 5
+    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1")
+    sqls.length.must_equal 5
 
     @Vocalist.db_schema[:first][:type] = :integer
     @Vocalist.db_schema[:last][:type] = :integer
     @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
     @Album.load(:id=>1).vocalist_pks = [["11", "11"], ["12", "12"]]
-    @db.sqls.should == ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN ((11, 11), (12, 12)))",
+    @db.sqls.must_equal ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN ((11, 11), (12, 12)))",
       "UPDATE vocalists SET album_id = NULL WHERE ((vocalists.album_id = 1) AND ((first, last) NOT IN ((11, 11), (12, 12))))"]
 
     @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
     @Album.load(:id=>2).vocalist_pks = [["11", "11"], ["12", "12"]]
     sqls = @db.sqls
-    sqls[0].should == "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN ((11, 11), (12, 12))))"
-    sqls[1].should == 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
+    sqls[0].must_equal "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN ((11, 11), (12, 12))))"
+    sqls[1].must_equal 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
     match = sqls[3].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"11", "last"=>"11", "album_id"=>"2"}
+    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"11", "last"=>"11", "album_id"=>"2")
     match = sqls[4].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
-    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"12", "last"=>"12", "album_id"=>"2"}
-    sqls.length.should == 6
+    Hash[match[1].split(', ').zip(match[2].split(', '))].must_equal("first"=>"12", "last"=>"12", "album_id"=>"2")
+    sqls.length.must_equal 6
   end
 end