sequel 4.22.0 → 4.23.0

data/spec/model/base_spec.rb

@@ -9,35 +9,35 @@ describe "Model attribute setters" do
     DB.reset
   end
 
-  specify "refresh should return self" do
+  it "refresh should return self" do
     @o = @c[1]
-    @o.stub(:_refresh).and_return([])
-    @o.refresh.should == @o
+    def @o._refresh(*) [] end
+    @o.refresh.must_equal @o
   end
 
   it "should mark the column value as changed" do
-    @o.changed_columns.should == []
+    @o.changed_columns.must_equal []
 
     @o.x = 2
-    @o.changed_columns.should == [:x]
+    @o.changed_columns.must_equal [:x]
 
     @o.y = 3
-    @o.changed_columns.should == [:x, :y]
+    @o.changed_columns.must_equal [:x, :y]
 
     @o.changed_columns.clear
 
     @o[:x] = 2
-    @o.changed_columns.should == [:x]
+    @o.changed_columns.must_equal [:x]
 
     @o[:y] = 3
-    @o.changed_columns.should == [:x, :y]
+    @o.changed_columns.must_equal [:x, :y]
   end
 
   it "should handle columns that can't be called like normal ruby methods" do
     @o.send(:"x y=", 3)
-    @o.changed_columns.should == [:"x y"]
-    @o.values.should == {:"x y"=>3}
-    @o.send(:"x y").should == 3
+    @o.changed_columns.must_equal [:"x y"]
+    @o.values.must_equal(:"x y"=>3)
+    @o.send(:"x y").must_equal 3
   end
 end
 
@@ -51,13 +51,13 @@ describe "Model.def_column_alias" do
   end
 
   it "should create an getter alias for the column" do
-    @o.id2.should == 1
+    @o.id2.must_equal 1
   end
 
   it "should create an setter alias for the column" do
     @o.id2 = 2
-    @o.id2.should == 2
-    @o.values.should == {:id => 2}
+    @o.id2.must_equal 2
+    @o.values.must_equal(:id => 2)
   end
 end
 
@@ -74,32 +74,32 @@ describe Sequel::Model, "dataset" do
     [:Elephant, :Maggot, :ShoeSize, :BootSize].each{|x| Object.send(:remove_const, x)}
   end
   
-  specify "should default to the plural of the class name" do
-    Maggot.dataset.sql.should == 'SELECT * FROM maggots'
-    ShoeSize.dataset.sql.should == 'SELECT * FROM shoe_sizes'
+  it "should default to the plural of the class name" do
+    Maggot.dataset.sql.must_equal 'SELECT * FROM maggots'
+    ShoeSize.dataset.sql.must_equal 'SELECT * FROM shoe_sizes'
   end
   
-  specify "should return the dataset for the superclass if available" do
-    BootSize.dataset.sql.should == 'SELECT * FROM shoe_sizes'
+  it "should return the dataset for the superclass if available" do
+    BootSize.dataset.sql.must_equal 'SELECT * FROM shoe_sizes'
   end
   
-  specify "should return the correct dataset if set explicitly" do
-    Elephant.dataset.sql.should == 'SELECT * FROM ele1'
-    @a.dataset.sql.should == 'SELECT * FROM items'
+  it "should return the correct dataset if set explicitly" do
+    Elephant.dataset.sql.must_equal 'SELECT * FROM ele1'
+    @a.dataset.sql.must_equal 'SELECT * FROM items'
   end
   
-  specify "should raise if no dataset is explicitly set and the class is anonymous" do
-    proc {@b.dataset}.should raise_error(Sequel::Error)
+  it "should raise if no dataset is explicitly set and the class is anonymous" do
+    proc {@b.dataset}.must_raise(Sequel::Error)
   end
   
-  specify "should disregard namespaces for the table name" do
+  it "should disregard namespaces for the table name" do
     begin
       module ::BlahBlah
         class MwaHaHa < Sequel::Model
         end
       end
     
-      BlahBlah::MwaHaHa.dataset.sql.should == 'SELECT * FROM mwa_ha_has'
+      BlahBlah::MwaHaHa.dataset.sql.must_equal 'SELECT * FROM mwa_ha_has'
     ensure
       Object.send(:remove_const, :BlahBlah)
     end
@@ -113,14 +113,14 @@ describe Sequel::Model, ".def_dataset_method" do
   
   it "should add a method to the dataset and model if called with a block argument" do
     @c.def_dataset_method(:return_3){3}
-    @c.return_3.should == 3
-    @c.dataset.return_3.should == 3
+    @c.return_3.must_equal 3
+    @c.dataset.return_3.must_equal 3
   end
 
   it "should handle weird method names" do
     @c.def_dataset_method(:"return 3"){3}
-    @c.send(:"return 3").should == 3
-    @c.dataset.send(:"return 3").should == 3
+    @c.send(:"return 3").must_equal 3
+    @c.dataset.send(:"return 3").must_equal 3
   end
 
   it "should not add a model method if the model already responds to the method" do
@@ -138,37 +138,37 @@ describe Sequel::Model, ".def_dataset_method" do
       def_dataset_method(:foo){3}
       def_dataset_method(:bar){4}
     end
-    @c.foo.should == 1
-    @c.dataset.foo.should == 3
-    @c.send(:bar).should == 2
-    @c.dataset.bar.should == 4
+    @c.foo.must_equal 1
+    @c.dataset.foo.must_equal 3
+    @c.send(:bar).must_equal 2
+    @c.dataset.bar.must_equal 4
   end
 
   it "should add all passed methods to the model if called without a block argument" do
     @c.def_dataset_method(:return_3, :return_4)
-    proc{@c.return_3}.should raise_error(NoMethodError)
-    proc{@c.return_4}.should raise_error(NoMethodError)
+    proc{@c.return_3}.must_raise(NoMethodError)
+    proc{@c.return_4}.must_raise(NoMethodError)
     @c.dataset.instance_eval do
       def return_3; 3; end
       def return_4; 4; end
     end
-    @c.return_3.should == 3
-    @c.return_4.should == 4
+    @c.return_3.must_equal 3
+    @c.return_4.must_equal 4
   end
 
   it "should cache calls and readd methods if set_dataset is used" do
     @c.def_dataset_method(:return_3){3}
     @c.set_dataset :items
-    @c.return_3.should == 3
-    @c.dataset.return_3.should == 3
+    @c.return_3.must_equal 3
+    @c.dataset.return_3.must_equal 3
   end
 
   it "should readd methods to subclasses, if set_dataset is used in a subclass" do
     @c.def_dataset_method(:return_3){3}
     c = Class.new(@c)
     c.set_dataset :items
-    c.return_3.should == 3
-    c.dataset.return_3.should == 3
+    c.return_3.must_equal 3
+    c.dataset.return_3.must_equal 3
   end
 end
 
@@ -179,69 +179,69 @@ describe Sequel::Model, ".dataset_module" do
   
   it "should extend the dataset with the module if the model has a dataset" do
     @c.dataset_module{def return_3() 3 end}
-    @c.dataset.return_3.should == 3
+    @c.dataset.return_3.must_equal 3
   end
 
   it "should also extend the instance_dataset with the module if the model has a dataset" do
     @c.dataset_module{def return_3() 3 end}
-    @c.instance_dataset.return_3.should == 3
+    @c.instance_dataset.return_3.must_equal 3
   end
 
   it "should add methods defined in the module to the class" do
     @c.dataset_module{def return_3() 3 end}
-    @c.return_3.should == 3
+    @c.return_3.must_equal 3
   end
 
   it "should add methods defined in the module outside the block to the class" do
     @c.dataset_module.module_eval{def return_3() 3 end}
-    @c.return_3.should == 3
+    @c.return_3.must_equal 3
   end
 
   it "should cache calls and readd methods if set_dataset is used" do
     @c.dataset_module{def return_3() 3 end}
     @c.set_dataset :items
-    @c.return_3.should == 3
-    @c.dataset.return_3.should == 3
+    @c.return_3.must_equal 3
+    @c.dataset.return_3.must_equal 3
   end
 
   it "should readd methods to subclasses, if set_dataset is used in a subclass" do
     @c.dataset_module{def return_3() 3 end}
     c = Class.new(@c)
     c.set_dataset :items
-    c.return_3.should == 3
-    c.dataset.return_3.should == 3
+    c.return_3.must_equal 3
+    c.dataset.return_3.must_equal 3
   end
 
   it "should only have a single dataset_module per class" do
     @c.dataset_module{def return_3() 3 end}
     @c.dataset_module{def return_3() 3 + (begin; super; rescue NoMethodError; 1; end) end}
-    @c.return_3.should == 4
+    @c.return_3.must_equal 4
   end
 
   it "should not have subclasses share the dataset_module" do
     @c.dataset_module{def return_3() 3 end}
     c = Class.new(@c)
     c.dataset_module{def return_3() 3 + (begin; super; rescue NoMethodError; 1; end) end}
-    c.return_3.should == 6
+    c.return_3.must_equal 6
   end
 
   it "should accept a module object and extend the dataset with it" do
     @c.dataset_module Module.new{def return_3() 3 end}
-    @c.dataset.return_3.should == 3
+    @c.dataset.return_3.must_equal 3
   end
 
   it "should be able to call dataset_module with a module multiple times" do
     @c.dataset_module Module.new{def return_3() 3 end}
     @c.dataset_module Module.new{def return_4() 4 end}
-    @c.dataset.return_3.should == 3
-    @c.dataset.return_4.should == 4
+    @c.dataset.return_3.must_equal 3
+    @c.dataset.return_4.must_equal 4
   end
 
   it "should be able mix dataset_module calls with and without arguments" do
     @c.dataset_module{def return_3() 3 end}
     @c.dataset_module Module.new{def return_4() 4 end}
-    @c.dataset.return_3.should == 3
-    @c.dataset.return_4.should == 4
+    @c.dataset.return_3.must_equal 3
+    @c.dataset.return_4.must_equal 4
   end
 
   it "should have modules provided to dataset_module extend subclass datasets" do
@@ -249,26 +249,26 @@ describe Sequel::Model, ".dataset_module" do
     @c.dataset_module Module.new{def return_4() 4 end}
     c = Class.new(@c)
     c.set_dataset :a
-    c.dataset.return_3.should == 3
-    c.dataset.return_4.should == 4
+    c.dataset.return_3.must_equal 3
+    c.dataset.return_4.must_equal 4
   end
 
   it "should return the dataset module if given a block" do
-    Object.new.extend(@c.dataset_module{def return_3() 3 end}).return_3.should == 3
+    Object.new.extend(@c.dataset_module{def return_3() 3 end}).return_3.must_equal 3
   end
 
   it "should return the argument if given one" do
-    Object.new.extend(@c.dataset_module Module.new{def return_3() 3 end}).return_3.should == 3
+    Object.new.extend(@c.dataset_module Module.new{def return_3() 3 end}).return_3.must_equal 3
   end
 
   it "should have dataset_module support a subset method" do
     @c.dataset_module{subset :released, :released}
-    @c.released.sql.should == 'SELECT * FROM items WHERE released'
-    @c.where(:foo).released.sql.should == 'SELECT * FROM items WHERE (foo AND released)'
+    @c.released.sql.must_equal 'SELECT * FROM items WHERE released'
+    @c.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
   end
 
   it "should raise error if called with both an argument and ablock" do
-    proc{@c.dataset_module(Module.new{def return_3() 3 end}){}}.should raise_error(Sequel::Error)
+    proc{@c.dataset_module(Module.new{def return_3() 3 end}){}}.must_raise(Sequel::Error)
   end
 end
 
@@ -281,8 +281,8 @@ describe "A model class with implicit table name" do
     Object.send(:remove_const, :Donkey)
   end
   
-  specify "should have a dataset associated with the model class" do
-    Donkey.dataset.model.should == Donkey
+  it "should have a dataset associated with the model class" do
+    Donkey.dataset.model.must_equal Donkey
   end
 end
 
@@ -296,9 +296,9 @@ describe "A model inheriting from a model" do
     Object.send(:remove_const, :Feline)
   end
   
-  specify "should have a dataset associated with itself" do
-    Feline.dataset.model.should == Feline
-    Leopard.dataset.model.should == Leopard
+  it "should have a dataset associated with itself" do
+    Feline.dataset.model.must_equal Feline
+    Leopard.dataset.model.must_equal Leopard
   end
 end
 
@@ -307,21 +307,21 @@ describe "Model.primary_key" do
     @c = Class.new(Sequel::Model)
   end
   
-  specify "should default to id" do
-    @c.primary_key.should == :id
+  it "should default to id" do
+    @c.primary_key.must_equal :id
   end
 
-  specify "should be overridden by set_primary_key" do
+  it "should be overridden by set_primary_key" do
     @c.set_primary_key :cid
-    @c.primary_key.should == :cid
+    @c.primary_key.must_equal :cid
 
     @c.set_primary_key([:id1, :id2])
-    @c.primary_key.should == [:id1, :id2]
+    @c.primary_key.must_equal [:id1, :id2]
   end
   
-  specify "should use nil for no primary key" do
+  it "should use nil for no primary key" do
     @c.no_primary_key
-    @c.primary_key.should == nil
+    @c.primary_key.must_equal nil
   end
 end
 
@@ -330,18 +330,18 @@ describe "Model.primary_key_hash" do
     @c = Class.new(Sequel::Model)
   end
   
-  specify "should handle a single primary key" do
-    @c.primary_key_hash(1).should == {:id=>1}
+  it "should handle a single primary key" do
+    @c.primary_key_hash(1).must_equal(:id=>1)
   end
 
-  specify "should handle a composite primary key" do
+  it "should handle a composite primary key" do
     @c.set_primary_key([:id1, :id2])
-    @c.primary_key_hash([1, 2]).should == {:id1=>1, :id2=>2}
+    @c.primary_key_hash([1, 2]).must_equal(:id1=>1, :id2=>2)
   end
 
-  specify "should raise an error for no primary key" do
+  it "should raise an error for no primary key" do
     @c.no_primary_key
-    proc{@c.primary_key_hash(1)}.should raise_error(Sequel::Error)
+    proc{@c.primary_key_hash(1)}.must_raise(Sequel::Error)
   end
 end
 
@@ -350,24 +350,24 @@ describe "Model.qualified_primary_key_hash" do
     @c = Class.new(Sequel::Model(:items))
   end
   
-  specify "should handle a single primary key" do
-    @c.qualified_primary_key_hash(1).should == {Sequel.qualify(:items, :id)=>1}
+  it "should handle a single primary key" do
+    @c.qualified_primary_key_hash(1).must_equal(Sequel.qualify(:items, :id)=>1)
   end
 
-  specify "should handle a composite primary key" do
+  it "should handle a composite primary key" do
     @c.set_primary_key([:id1, :id2])
-    @c.qualified_primary_key_hash([1, 2]).should == {Sequel.qualify(:items, :id1)=>1, Sequel.qualify(:items, :id2)=>2}
+    @c.qualified_primary_key_hash([1, 2]).must_equal(Sequel.qualify(:items, :id1)=>1, Sequel.qualify(:items, :id2)=>2)
   end
 
-  specify "should raise an error for no primary key" do
+  it "should raise an error for no primary key" do
     @c.no_primary_key
-    proc{@c.qualified_primary_key_hash(1)}.should raise_error(Sequel::Error)
+    proc{@c.qualified_primary_key_hash(1)}.must_raise(Sequel::Error)
   end
 
-  specify "should allow specifying a different qualifier" do
-    @c.qualified_primary_key_hash(1, :apple).should == {Sequel.qualify(:apple, :id)=>1}
+  it "should allow specifying a different qualifier" do
+    @c.qualified_primary_key_hash(1, :apple).must_equal(Sequel.qualify(:apple, :id)=>1)
     @c.set_primary_key([:id1, :id2])
-    @c.qualified_primary_key_hash([1, 2], :bear).should == {Sequel.qualify(:bear, :id1)=>1, Sequel.qualify(:bear, :id2)=>2}
+    @c.qualified_primary_key_hash([1, 2], :bear).must_equal(Sequel.qualify(:bear, :id1)=>1, Sequel.qualify(:bear, :id2)=>2)
   end
 end
 
@@ -380,40 +380,40 @@ describe "Model.db" do
     Sequel::DATABASES.clear
   end
   after do
-    Sequel::Model.instance_variable_get(:@db).should == nil
+    Sequel::Model.instance_variable_get(:@db).must_equal nil
     Sequel::DATABASES.replace(@databases)
     Sequel::Model.db = @model_db
   end
 
-  specify "should be required when creating named model classes" do
+  it "should be required when creating named model classes" do
     begin
-      proc{class ModelTest < Sequel::Model; end}.should raise_error(Sequel::Error)
+      proc{class ModelTest < Sequel::Model; end}.must_raise(Sequel::Error)
     ensure
       Object.send(:remove_const, :ModelTest)
     end
   end
 
-  specify "should be required when creating anonymous model classes without a database" do
-    proc{Sequel::Model(:foo)}.should raise_error(Sequel::Error)
+  it "should be required when creating anonymous model classes without a database" do
+    proc{Sequel::Model(:foo)}.must_raise(Sequel::Error)
   end
 
-  specify "should not be required when creating anonymous model classes with a database" do
-    Sequel::Model(@db).db.should == @db
-    Sequel::Model(@db[:foo]).db.should == @db
+  it "should not be required when creating anonymous model classes with a database" do
+    Sequel::Model(@db).db.must_equal @db
+    Sequel::Model(@db[:foo]).db.must_equal @db
   end
 
-  specify "should work correctly when subclassing anonymous model classes with a database" do
+  it "should work correctly when subclassing anonymous model classes with a database" do
     begin
-      Class.new(Sequel::Model(@db)).db.should == @db
-      Class.new(Sequel::Model(@db[:foo])).db.should == @db
+      Class.new(Sequel::Model(@db)).db.must_equal @db
+      Class.new(Sequel::Model(@db[:foo])).db.must_equal @db
       class ModelTest < Sequel::Model(@db)
-        db.should == @db
+        db.must_equal @db
       end
       class ModelTest2 < Sequel::Model(@db[:foo])
-        db.should == @db
+        db.must_equal @db
       end
       ModelTest.instance_variable_set(:@db, nil)
-      ModelTest.db.should == @db
+      ModelTest.db.must_equal @db
     ensure
       Object.send(:remove_const, :ModelTest)
       Object.send(:remove_const, :ModelTest2)
@@ -429,21 +429,21 @@ describe "Model.db=" do
     @m = Class.new(Sequel::Model(@db1[:blue].filter(:x=>1)))
   end
   
-  specify "should affect the underlying dataset" do
+  it "should affect the underlying dataset" do
     @m.db = @db2
     
-    @m.dataset.db.should === @db2
-    @m.dataset.db.should_not === @db1
+    @m.dataset.db.must_equal @db2
+    @m.dataset.db.wont_equal @db1
   end
 
-  specify "should keep the same dataset options" do
+  it "should keep the same dataset options" do
     @m.db = @db2
-    @m.dataset.sql.should == 'SELECT * FROM blue WHERE (x = 1)'
+    @m.dataset.sql.must_equal 'SELECT * FROM blue WHERE (x = 1)'
   end
 
-  specify "should use the database for subclasses" do
+  it "should use the database for subclasses" do
     @m.db = @db2
-    Class.new(@m).db.should === @db2
+    Class.new(@m).db.must_equal @db2
   end
 end
 
@@ -454,28 +454,29 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     end
     @c.strict_param_setting = false
     @c.instance_variable_set(:@columns, [:x, :y, :z])
+    DB.reset
   end
   
   it "should set the allowed columns correctly" do
-    @c.allowed_columns.should == nil
+    @c.allowed_columns.must_equal nil
     @c.set_allowed_columns :x
-    @c.allowed_columns.should == [:x]
+    @c.allowed_columns.must_equal [:x]
     @c.set_allowed_columns :x, :y
-    @c.allowed_columns.should == [:x, :y]
+    @c.allowed_columns.must_equal [:x, :y]
   end
 
   it "should only set allowed columns by default" do
     @c.set_allowed_columns :x, :y
     i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.should == {:x => 1, :y => 2}
+    i.values.must_equal(:x => 1, :y => 2)
     i.set(:x => 4, :y => 5, :z => 6)
-    i.values.should == {:x => 4, :y => 5}
+    i.values.must_equal(:x => 4, :y => 5)
 
     @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7}
     i = @c.new
     i.update(:x => 7, :z => 9)
-    i.values.should == {:x => 7}
-    DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    i.values.must_equal(:x => 7)
+    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 end
 
@@ -490,30 +491,30 @@ describe Sequel::Model, ".(un)?restrict_primary_key\\??" do
   
   it "should restrict updates to primary key by default" do
     i = @c.new(:x => 1, :y => 2, :id => 3)
-    i.values.should == {:x => 1, :y => 2}
+    i.values.must_equal(:x => 1, :y => 2)
     i.set(:x => 4, :y => 5, :id => 6)
-    i.values.should == {:x => 4, :y => 5}
+    i.values.must_equal(:x => 4, :y => 5)
   end
 
   it "should allow updates to primary key if unrestrict_primary_key is used" do
     @c.unrestrict_primary_key
     i = @c.new(:x => 1, :y => 2, :id => 3)
-    i.values.should == {:x => 1, :y => 2, :id=>3}
+    i.values.must_equal(:x => 1, :y => 2, :id=>3)
     i.set(:x => 4, :y => 5, :id => 6)
-    i.values.should == {:x => 4, :y => 5, :id=>6}
+    i.values.must_equal(:x => 4, :y => 5, :id=>6)
   end
 
   it "should have restrict_primary_key? return true or false depending" do
-    @c.restrict_primary_key?.should == true
+    @c.restrict_primary_key?.must_equal true
     @c.unrestrict_primary_key
-    @c.restrict_primary_key?.should == false
+    @c.restrict_primary_key?.must_equal false
     c1 = Class.new(@c)
-    c1.restrict_primary_key?.should == false
+    c1.restrict_primary_key?.must_equal false
     @c.restrict_primary_key
-    @c.restrict_primary_key?.should == true
-    c1.restrict_primary_key?.should == false
+    @c.restrict_primary_key?.must_equal true
+    c1.restrict_primary_key?.must_equal false
     c2 = Class.new(@c)
-    c2.restrict_primary_key?.should == true
+    c2.restrict_primary_key?.must_equal true
   end
 end
 
@@ -526,25 +527,25 @@ describe Sequel::Model, ".strict_param_setting" do
   end
   
   it "should be enabled by default" do
-    @c.strict_param_setting.should == true
+    @c.strict_param_setting.must_equal true
   end
 
   it "should raise an error if a missing/restricted column/method is accessed" do
-    proc{@c.new(:z=>1)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{@c.create(:z=>1)}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{@c.new(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{@c.create(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
     c = @c.new
-    proc{c.set(:z=>1)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{c.set_all(:use_after_commit_rollback => false)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{c.set_only({:x=>1}, :y)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{c.update(:z=>1)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{c.update_all(:use_after_commit_rollback=>false)}.should raise_error(Sequel::MassAssignmentRestriction)
-    proc{c.update_only({:x=>1}, :y)}.should raise_error(Sequel::MassAssignmentRestriction)
+    proc{c.set(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.set_all(:use_after_commit_rollback => false)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.set_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update(:z=>1)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update_all(:use_after_commit_rollback=>false)}.must_raise(Sequel::MassAssignmentRestriction)
+    proc{c.update_only({:x=>1}, :y)}.must_raise(Sequel::MassAssignmentRestriction)
   end
 
   it "should be disabled by strict_param_setting = false" do
     @c.strict_param_setting = false
-    @c.strict_param_setting.should == false
-    proc{@c.new(:z=>1)}.should_not raise_error
+    @c.strict_param_setting.must_equal false
+    @c.new(:z=>1)
   end
 end
 
@@ -560,18 +561,18 @@ describe Sequel::Model, ".require_modification" do
   end
 
   it "should depend on whether the dataset provides an accurate number of rows matched by default" do
-    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.should == false
-    Class.new(Sequel::Model).set_dataset(@ds2).require_modification.should == true
+    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.must_equal false
+    Class.new(Sequel::Model).set_dataset(@ds2).require_modification.must_equal true
   end
 
   it "should obey global setting regardless of dataset support if set" do
     Sequel::Model.require_modification = true
-    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.should == true
-    Class.new(Sequel::Model).set_dataset(@ds2).require_modification.should == true
+    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.must_equal true
+    Class.new(Sequel::Model).set_dataset(@ds2).require_modification.must_equal true
     
     Sequel::Model.require_modification = false
-    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.should == false
-    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.should == false
+    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.must_equal false
+    Class.new(Sequel::Model).set_dataset(@ds1).require_modification.must_equal false
   end
 end
 
@@ -586,73 +587,73 @@ describe Sequel::Model, ".[] optimization" do
 
   it "should set simple_pk to the literalized primary key column name if a single primary key" do
     @c.set_primary_key :id
-    @c.simple_pk.should == '"id"'
+    @c.simple_pk.must_equal '"id"'
     @c.set_primary_key :b
-    @c.simple_pk.should == '"b"'
+    @c.simple_pk.must_equal '"b"'
     @c.set_primary_key Sequel.identifier(:b__a)
-    @c.simple_pk.should == '"b__a"'
+    @c.simple_pk.must_equal '"b__a"'
   end
 
   it "should have simple_pk be blank if compound or no primary key" do
     @c.no_primary_key
-    @c.simple_pk.should == nil
+    @c.simple_pk.must_equal nil
     @c.set_primary_key [:b, :a]
-    @c.simple_pk.should == nil
+    @c.simple_pk.must_equal nil
   end
 
   it "should have simple table set if passed a Symbol to set_dataset" do
     @c.set_dataset :a
-    @c.simple_table.should == '"a"'
+    @c.simple_table.must_equal '"a"'
     @c.set_dataset :b
-    @c.simple_table.should == '"b"'
+    @c.simple_table.must_equal '"b"'
     @c.set_dataset :b__a
-    @c.simple_table.should == '"b"."a"'
+    @c.simple_table.must_equal '"b"."a"'
   end
 
   it "should have simple_table set if passed a simple select all dataset to set_dataset" do
     @c.set_dataset @db[:a]
-    @c.simple_table.should == '"a"'
+    @c.simple_table.must_equal '"a"'
     @c.set_dataset @db[:b]
-    @c.simple_table.should == '"b"'
+    @c.simple_table.must_equal '"b"'
     @c.set_dataset @db[:b__a]
-    @c.simple_table.should == '"b"."a"'
+    @c.simple_table.must_equal '"b"."a"'
   end
 
   it "should have simple_pk and simple_table respect dataset's identifier input methods" do
     ds = @db[:ab]
     ds.identifier_input_method = :reverse
     @c.set_dataset ds
-    @c.simple_table.should == '"ba"'
+    @c.simple_table.must_equal '"ba"'
     @c.set_primary_key :cd
-    @c.simple_pk.should == '"dc"'
+    @c.simple_pk.must_equal '"dc"'
 
     @c.set_dataset ds.from(:ef__gh)
-    @c.simple_table.should == '"fe"."hg"'
+    @c.simple_table.must_equal '"fe"."hg"'
   end
 
   it "should have simple_table = nil if passed a non-simple select all dataset to set_dataset" do
     @c.set_dataset @c.db[:a].filter(:active)
-    @c.simple_table.should == nil
+    @c.simple_table.must_equal nil
   end
 
   it "should have simple_table inherit superclass's setting" do
-    Class.new(@c).simple_table.should == nil
+    Class.new(@c).simple_table.must_equal nil
     @c.set_dataset :a
-    Class.new(@c).simple_table.should == '"a"'
+    Class.new(@c).simple_table.must_equal '"a"'
   end
 
   it "should use Dataset#with_sql if simple_table and simple_pk are true" do
     @c.set_dataset :a
     @c.instance_dataset._fetch = @c.dataset._fetch = {:id => 1}
-    @c[1].should == @c.load(:id=>1)
-    @db.sqls.should == ['SELECT * FROM "a" WHERE "id" = 1']
+    @c[1].must_equal @c.load(:id=>1)
+    @db.sqls.must_equal ['SELECT * FROM "a" WHERE "id" = 1']
   end
 
   it "should not use Dataset#with_sql if either simple_table or simple_pk is nil" do
     @c.set_dataset @db[:a].filter(:active)
     @c.dataset._fetch = {:id => 1}
-    @c[1].should == @c.load(:id=>1)
-    @db.sqls.should == ['SELECT * FROM "a" WHERE ("active" AND ("id" = 1)) LIMIT 1']
+    @c[1].must_equal @c.load(:id=>1)
+    @db.sqls.must_equal ['SELECT * FROM "a" WHERE ("active" AND ("id" = 1)) LIMIT 1']
   end
 end
 
@@ -665,31 +666,31 @@ describe "Model datasets #with_pk with #with_pk!" do
   end
 
   it "should be callable on the model class with optimized SQL" do
-    @c.with_pk(1).should == @c.load(:id=>1)
-    DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
-    @c.with_pk!(1).should == @c.load(:id=>1)
-    DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
+    @c.with_pk(1).must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE id = 1"]
+    @c.with_pk!(1).must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE id = 1"]
   end
 
   it "should return the first record where the primary key matches" do
-    @ds.with_pk(1).should == @c.load(:id=>1)
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
-    @ds.with_pk!(1).should == @c.load(:id=>1)
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    @ds.with_pk(1).must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    @ds.with_pk!(1).must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should handle existing filters" do
     @ds.filter(:a=>2).with_pk(1)
-    DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
     @ds.filter(:a=>2).with_pk!(1)
-    DB.sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
   end
 
   it "should work with string values" do
     @ds.with_pk("foo")
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
     @ds.with_pk!("foo")
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
   end
 
   it "should handle an array for composite primary keys" do
@@ -697,40 +698,40 @@ describe "Model datasets #with_pk with #with_pk!" do
     @ds.with_pk([1, 2])
     sqls = DB.sqls
     ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(sqls.pop)
-    sqls.should == []
+    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
+    sqls.must_equal []
 
     @ds.with_pk!([1, 2])
     sqls = DB.sqls
     ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
-    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(sqls.pop)
-    sqls.should == []
+    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
+    sqls.must_equal []
   end
 
   it "should have with_pk return nil and with_pk! raise if no rows match" do
     @ds._fetch = []
-    @ds.with_pk(1).should == nil
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
-    proc{@ds.with_pk!(1)}.should raise_error(Sequel::NoMatchingRow)
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    @ds.with_pk(1).must_equal nil
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    proc{@ds.with_pk!(1)}.must_raise(Sequel::NoMatchingRow)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should have with_pk return nil and with_pk! raise if no rows match when calling the class method" do
     @ds._fetch = []
-    @c.with_pk(1).should == nil
-    DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
-    proc{@c.with_pk!(1)}.should raise_error(Sequel::NoMatchingRow)
-    DB.sqls.should == ["SELECT * FROM a WHERE id = 1"]
+    @c.with_pk(1).must_equal nil
+    DB.sqls.must_equal ["SELECT * FROM a WHERE id = 1"]
+    proc{@c.with_pk!(1)}.must_raise(Sequel::NoMatchingRow)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE id = 1"]
   end
 
   it "should have #[] consider an integer as a primary key lookup" do
-    @ds[1].should == @c.load(:id=>1)
-    DB.sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    @ds[1].must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should not have #[] consider a string as a primary key lookup" do
-    @ds['foo'].should == @c.load(:id=>1)
-    DB.sqls.should == ["SELECT * FROM a WHERE (foo) LIMIT 1"]
+    @ds['foo'].must_equal @c.load(:id=>1)
+    DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
   end
 end
 
@@ -741,6 +742,6 @@ describe "Model::include" do
     including_class = Class.new(Sequel::Model(:items)) do
       include(mod1, mod2)
     end
-    including_class.included_modules.should include(mod1, mod2)
+    including_class.included_modules.must_include(mod1, mod2)
   end
 end