sequel 4.22.0 → 4.23.0

data/spec/extensions/boolean_readers_spec.rb

@@ -16,78 +16,78 @@ describe Sequel::Model, "BooleanReaders plugin" do
     @c.instance_eval(&@p)
   end 
 
-  specify "should create attribute? readers for all boolean attributes" do
+  it "should create attribute? readers for all boolean attributes" do
     @c.plugin(:boolean_readers)
     o = @c.new
-    o.b?.should == nil
+    o.b?.must_equal nil
     o.b = '1'
-    o.b?.should == true
+    o.b?.must_equal true
     o.b = '0'
-    o.b?.should == false
+    o.b?.must_equal false
     o.b = ''
-    o.b?.should == nil
+    o.b?.must_equal nil
   end
 
-  specify "should not create attribute? readers for non-boolean attributes" do
+  it "should not create attribute? readers for non-boolean attributes" do
     @c.plugin(:boolean_readers)
-    proc{@c.new.z?}.should raise_error(NoMethodError)
-    proc{@c.new.id?}.should raise_error(NoMethodError)
+    proc{@c.new.z?}.must_raise(NoMethodError)
+    proc{@c.new.id?}.must_raise(NoMethodError)
   end
 
-  specify "should accept a block to determine if an attribute is boolean" do
+  it "should accept a block to determine if an attribute is boolean" do
     @c.plugin(:boolean_readers){|c| db_schema[c][:db_type] == 'tinyint(1)'}
-    proc{@c.new.b?}.should raise_error(NoMethodError)
+    proc{@c.new.b?}.must_raise(NoMethodError)
     o = @c.new
-    o.z.should == nil
-    o.z?.should == nil
+    o.z.must_equal nil
+    o.z?.must_equal nil
     o.z = '1'
-    o.z.should == 1
-    o.z?.should == true
+    o.z.must_equal 1
+    o.z?.must_equal true
     o.z = '0'
-    o.z.should == 0
-    o.z?.should == false
+    o.z.must_equal 0
+    o.z?.must_equal false
     o.z = ''
-    o.z.should == nil
-    o.z?.should == nil
+    o.z.must_equal nil
+    o.z?.must_equal nil
   end
 
-  specify "should create boolean readers when set_dataset is defined" do
+  it "should create boolean readers when set_dataset is defined" do
     c = Class.new(Sequel::Model(@db))
     c.instance_eval(&@p)
     c.plugin(:boolean_readers)
     c.set_dataset(@db[:a])
     o = c.new
-    o.b?.should == nil
+    o.b?.must_equal nil
     o.b = '1'
-    o.b?.should == true
+    o.b?.must_equal true
     o.b = '0'
-    o.b?.should == false
+    o.b?.must_equal false
     o.b = ''
-    o.b?.should == nil
-    proc{o.i?}.should raise_error(NoMethodError)
+    o.b?.must_equal nil
+    proc{o.i?}.must_raise(NoMethodError)
 
     c = Class.new(Sequel::Model(@db))
     c.instance_eval(&@p)
     c.plugin(:boolean_readers){|x| db_schema[x][:db_type] == 'tinyint(1)'}
     c.set_dataset(@db[:a])
     o = c.new
-    o.z.should == nil
-    o.z?.should == nil
+    o.z.must_equal nil
+    o.z?.must_equal nil
     o.z = '1'
-    o.z.should == 1
-    o.z?.should == true
+    o.z.must_equal 1
+    o.z?.must_equal true
     o.z = '0'
-    o.z.should == 0
-    o.z?.should == false
+    o.z.must_equal 0
+    o.z?.must_equal false
     o.z = ''
-    o.z.should == nil
-    o.z?.should == nil
-    proc{o.b?}.should raise_error(NoMethodError)
+    o.z.must_equal nil
+    o.z?.must_equal nil
+    proc{o.b?}.must_raise(NoMethodError)
   end
 
-  specify "should handle cases where getting the columns raises an error" do
+  it "should handle cases where getting the columns raises an error" do
     @c.meta_def(:columns){raise Sequel::Error}
-    proc{@c.plugin(:boolean_readers)}.should_not raise_error
-    proc{@c.new.b?}.should raise_error(NoMethodError)
+    @c.plugin(:boolean_readers)
+    proc{@c.new.b?}.must_raise(NoMethodError)
   end
 end

data/spec/extensions/caching_spec.rb

@@ -54,52 +54,52 @@ describe Sequel::Model, "caching" do
   end
   
   it "should set the model's cache store" do
-    @c.cache_store.should be(@cache)
-    @c2.cache_store.should be(@cache)
+    @c.cache_store.wont_be_nil
+    @c2.cache_store.wont_be_nil
   end
   
   it "should have a default ttl of 3600" do
-    @c.cache_ttl.should == 3600
-    @c2.cache_ttl.should == 3600
+    @c.cache_ttl.must_equal 3600
+    @c2.cache_ttl.must_equal 3600
   end
   
   it "should take a ttl option" do
     c = Class.new(Sequel::Model(:items))
     c.plugin :caching, @cache, :ttl => 1234
-    c.cache_ttl.should == 1234
-    Class.new(c).cache_ttl.should == 1234
+    c.cache_ttl.must_equal 1234
+    Class.new(c).cache_ttl.must_equal 1234
   end
   
   it "should allow overriding the ttl option via a plugin :caching call" do
     @c.plugin :caching, @cache, :ttl => 1234
-    @c.cache_ttl.should == 1234
-    Class.new(@c).cache_ttl.should == 1234
+    @c.cache_ttl.must_equal 1234
+    Class.new(@c).cache_ttl.must_equal 1234
   end
   
   it "should offer a set_cache_ttl method for setting the ttl" do
-    @c.cache_ttl.should == 3600
+    @c.cache_ttl.must_equal 3600
     @c.set_cache_ttl 1234
-    @c.cache_ttl.should == 1234
-    Class.new(@c).cache_ttl.should == 1234
+    @c.cache_ttl.must_equal 1234
+    Class.new(@c).cache_ttl.must_equal 1234
   end
   
   it "should generate a cache key appropriate to the class via the Model#cache_key" do
     m = @c.new
     m.values[:id] = 1
-    m.cache_key.should == "#{m.class}:1"
+    m.cache_key.must_equal "#{m.class}:1"
     m = @c2.new
     m.values[:id] = 1
-    m.cache_key.should == "#{m.class}:1"
+    m.cache_key.must_equal "#{m.class}:1"
     
     # custom primary key
     @c.set_primary_key :ttt
     m = @c.new
     m.values[:ttt] = 333
-    m.cache_key.should == "#{m.class}:333"
+    m.cache_key.must_equal "#{m.class}:333"
     c = Class.new(@c)
     m = c.new
     m.values[:ttt] = 333
-    m.cache_key.should == "#{m.class}:333"
+    m.cache_key.must_equal "#{m.class}:333"
     
     # composite primary key
     @c.set_primary_key [:a, :b, :c]
@@ -107,164 +107,164 @@ describe Sequel::Model, "caching" do
     m.values[:a] = 123
     m.values[:c] = 456
     m.values[:b] = 789
-    m.cache_key.should == "#{m.class}:123,789,456"
+    m.cache_key.must_equal "#{m.class}:123,789,456"
     c = Class.new(@c)
     m = c.new
     m.values[:a] = 123
     m.values[:c] = 456
     m.values[:b] = 789
-    m.cache_key.should == "#{m.class}:123,789,456"
+    m.cache_key.must_equal "#{m.class}:123,789,456"
   end
 
   it "should generate a cache key via the Model.cache_key method" do
-    @c.cache_key(1).should == "#{@c}:1"
-    @c.cache_key([1, 2]).should == "#{@c}:1,2"
+    @c.cache_key(1).must_equal "#{@c}:1"
+    @c.cache_key([1, 2]).must_equal "#{@c}:1,2"
   end
   
   it "should raise error if attempting to generate cache_key and primary key value is null" do
     m = @c.new
-    proc {m.cache_key}.should raise_error(Sequel::Error)
+    proc {m.cache_key}.must_raise(Sequel::Error)
     m.values[:id] = 1
-    proc {m.cache_key}.should_not raise_error
+    m.cache_key
 
     m = @c2.new
-    proc {m.cache_key}.should raise_error(Sequel::Error)
+    proc {m.cache_key}.must_raise(Sequel::Error)
     m.values[:id] = 1
-    proc {m.cache_key}.should_not raise_error
+    m.cache_key
   end
   
   it "should not raise error if trying to save a new record" do
-    proc {@c.new(:name=>'blah').save}.should_not raise_error
-    proc {@c.create(:name=>'blah')}.should_not raise_error
-    proc {@c2.new(:name=>'blah').save}.should_not raise_error
-    proc {@c2.create(:name=>'blah')}.should_not raise_error
+    @c.new(:name=>'blah').save
+    @c.create(:name=>'blah')
+    @c2.new(:name=>'blah').save
+    @c2.create(:name=>'blah')
   end
   
   it "should set the cache when reading from the database" do
-    @c.db.sqls.should == []
-    @cache.should be_empty
+    @c.db.sqls.must_equal []
+    @cache.must_be :empty?
     
     m = @c[1]
-    @c.db.sqls.should == ['SELECT * FROM items WHERE id = 1']
-    m.values.should == {:name=>"sharon", :id=>1}
-    @cache[m.cache_key].should == m
+    @c.db.sqls.must_equal ['SELECT * FROM items WHERE id = 1']
+    m.values.must_equal(:name=>"sharon", :id=>1)
+    @cache[m.cache_key].must_equal m
     m2 = @c[1]
-    @c.db.sqls.should == []
-    m2.should == m
-    m2.values.should == {:name=>"sharon", :id=>1}
+    @c.db.sqls.must_equal []
+    m2.must_equal m
+    m2.values.must_equal(:name=>"sharon", :id=>1)
 
     m = @c2[1]
-    @c.db.sqls.should == ['SELECT * FROM items WHERE id = 1']
-    m.values.should == {:name=>"sharon", :id=>1}
-    @cache[m.cache_key].should == m
+    @c.db.sqls.must_equal ['SELECT * FROM items WHERE id = 1']
+    m.values.must_equal(:name=>"sharon", :id=>1)
+    @cache[m.cache_key].must_equal m
     m2 = @c2[1]
-    @c.db.sqls.should == []
-    m2.should == m
-    m2.values.should == {:name=>"sharon", :id=>1}
+    @c.db.sqls.must_equal []
+    m2.must_equal m
+    m2.values.must_equal(:name=>"sharon", :id=>1)
   end
 
   it "should handle lookups by nil primary keys" do
-    @c[nil].should == nil
-    @c.db.sqls.should == []
+    @c[nil].must_equal nil
+    @c.db.sqls.must_equal []
   end
   
   it "should delete the cache when writing to the database" do
     m = @c[1]
-    @cache[m.cache_key].should == m
+    @cache[m.cache_key].must_equal m
     m.name = 'hey'
     m.save
-    @cache.has_key?(m.cache_key).should == false
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
+    @cache.has_key?(m.cache_key).must_equal false
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
 
     m = @c2[1]
-    @cache[m.cache_key].should == m
+    @cache[m.cache_key].must_equal m
     m.name = 'hey'
     m.save
-    @cache.has_key?(m.cache_key).should == false
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
+    @cache.has_key?(m.cache_key).must_equal false
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
   end
 
   it "should delete the cache when deleting the record" do
     m = @c[1]
-    @cache[m.cache_key].should == m
+    @cache[m.cache_key].must_equal m
     m.delete
-    @cache.has_key?(m.cache_key).should == false
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
+    @cache.has_key?(m.cache_key).must_equal false
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
 
     m = @c2[1]
-    @cache[m.cache_key].should == m
+    @cache[m.cache_key].must_equal m
     m.delete
-    @cache.has_key?(m.cache_key).should == false
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
+    @cache.has_key?(m.cache_key).must_equal false
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
   end
   
   it "should support #[] as a shortcut to #find with hash" do
     m = @c[:id => 3]
-    @cache[m.cache_key].should be_nil
-    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
+    @cache[m.cache_key].must_equal nil
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c[1]
-    @cache[m.cache_key].should == m
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1"]
+    @cache[m.cache_key].must_equal m
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE id = 1"]
     @c[:id => 4]
-    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
 
     m = @c2[:id => 3]
-    @cache[m.cache_key].should be_nil
-    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
+    @cache[m.cache_key].must_equal nil
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c2[1]
-    @cache[m.cache_key].should == m
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1"]
+    @cache[m.cache_key].must_equal m
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE id = 1"]
     @c2[:id => 4]
-    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+    @c.db.sqls.must_equal ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
   end
   
   it "should support ignore_exception option" do
     c = Class.new(Sequel::Model(:items))
     c.plugin :caching, @cache, :ignore_exceptions => true
-    Class.new(c).cache_ignore_exceptions.should == true
+    Class.new(c).cache_ignore_exceptions.must_equal true
   end
   
   it "should raise an exception if cache_store is memcached and ignore_exception is not enabled" do
-    proc{@c3[1]}.should raise_error
+    proc{@c3[1]}.must_raise ArgumentError
     m = @c3.new.save
-    proc{m.update({:name=>'blah'})}.should raise_error
+    proc{m.update({:name=>'blah'})}.must_raise ArgumentError
   end
   
   it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
-    @c4[1].values.should == {:name => 'sharon', :id => 1}
+    @c4[1].values.must_equal(:name => 'sharon', :id => 1)
     m = @c4.new.save
-    proc{m.update({:name=>'blah'})}.should_not raise_error
-    m.values.should == {:name => 'blah', :id => 1, :x => 1}
+    m.update({:name=>'blah'})
+    m.values.must_equal(:name => 'blah', :id => 1, :x => 1)
   end
   
   it "should support Model.cache_get_pk for getting a value from the cache by primary key" do
-    @c.cache_get_pk(1).should == nil
+    @c.cache_get_pk(1).must_equal nil
     m = @c[1]
-    @c.cache_get_pk(1).should == m
+    @c.cache_get_pk(1).must_equal m
   end
   
   it "should support Model.cache_delete_pk for removing a value from the cache by primary key" do
     @c[1]
-    @c.cache_get_pk(1).should_not == nil
-    @c.cache_delete_pk(1).should == nil
-    @c.cache_get_pk(1).should == nil
+    @c.cache_get_pk(1).wont_equal nil
+    @c.cache_delete_pk(1).must_equal nil
+    @c.cache_get_pk(1).must_equal nil
   end
 
   it "should support overriding the cache key prefix" do
     c2 = Class.new(@c)
     def c2.cache_key_prefix; "ceetwo" end
     c3 = Class.new(c2)
-    @c.cache_key(:id).should_not == c2.cache_key(:id)
-    c2.cache_key(:id).should == c3.cache_key(:id)
+    @c.cache_key(:id).wont_equal c2.cache_key(:id)
+    c2.cache_key(:id).must_equal c3.cache_key(:id)
     
     @c[1]
-    c2.cache_get_pk(1).should == nil
+    c2.cache_get_pk(1).must_equal nil
     m = c2[1]
-    c2.cache_get_pk(1).values.should == @c[1].values
-    c3.cache_get_pk(1).values.should == m.values
+    c2.cache_get_pk(1).values.must_equal @c[1].values
+    c3.cache_get_pk(1).values.must_equal m.values
 
     m.name << m.name
     m.save
-    c2[1].values.should == c3[1].values
+    c2[1].values.must_equal c3[1].values
   end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -48,51 +48,51 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
-  specify "should have simple_table = nil for all classes" do
-    Employee.simple_table.should == nil
-    Manager.simple_table.should == nil
-    Executive.simple_table.should == nil
-    Staff.simple_table.should == nil
+  it "should have simple_table = nil for all classes" do
+    Employee.simple_table.must_equal nil
+    Manager.simple_table.must_equal nil
+    Executive.simple_table.must_equal nil
+    Staff.simple_table.must_equal nil
   end
   
-    specify "should have working row_proc if using set_dataset in subclass to remove columns" do
+    it "should have working row_proc if using set_dataset in subclass to remove columns" do
       Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
       Manager.dataset._fetch = {:id=>1, :kind=>'Executive'}
-      Manager[1].should == Executive.load(:id=>1, :kind=>'Executive')
+      Manager[1].must_equal Executive.load(:id=>1, :kind=>'Executive')
     end
 
-  specify "should use a joined dataset in subclasses" do
-    Employee.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind FROM employees'
-    Manager.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
-    Executive.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)'
-    Staff.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
+  it "should use a joined dataset in subclasses" do
+    Employee.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind FROM employees'
+    Manager.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
+    Executive.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id)'
+    Staff.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
     @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.should == [Employee, Manager, Executive, Staff]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Manager, Executive, Staff]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
     Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
-    Manager.all.collect{|x| x.class}.should == [Manager, Executive]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive]
   end
   
   it "should have refresh return all columns in subclass after loading from superclass" do
     Employee.dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Executive'}]
     Executive.instance_dataset._fetch = [{:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2}]
     a = Employee.first
-    a.class.should == Executive
-    a.values.should == {:id=>1, :name=>'A', :kind=>'Executive'}
-    a.refresh.values.should == {:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2}
-    @db.sqls.should == ["SELECT employees.id, employees.name, employees.kind FROM employees LIMIT 1",
+    a.class.must_equal Executive
+    a.values.must_equal(:id=>1, :name=>'A', :kind=>'Executive')
+    a.refresh.values.must_equal(:id=>1, :name=>'A', :kind=>'Executive', :num_staff=>3, :num_managers=>2)
+    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind FROM employees LIMIT 1",
       "SELECT employees.id, employees.name, employees.kind, managers.num_staff, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1"]
   end
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
     Employee.dataset._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.should == [Employee, Employee, Employee, Employee]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Employee, Employee]
   end
   
   it "should return rows with the current class if cti_key is nil in subclasses" do
@@ -102,7 +102,7 @@ describe "class_table_inheritance plugin" do
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
     Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
-    Manager.all.collect{|x| x.class}.should == [Manager, Manager]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Manager]
   end
   
   it "should handle a model map with integer values" do
@@ -112,41 +112,41 @@ describe "class_table_inheritance plugin" do
     class ::Manager < Employee; end 
     class ::Executive < Manager; end 
     Employee.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}]
-    Employee.all.collect{|x| x.class}.should == [Employee, Employee, Manager, Executive]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Employee, Manager, Executive]
     Manager.dataset._fetch = [{:kind=>nil},{:kind=>0},{:kind=>1}, {:kind=>2}]
-    Manager.all.collect{|x| x.class}.should == [Manager, Employee, Manager, Executive]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Employee, Manager, Executive]
   end
   
   it "should fallback to the main class if the given class does not exist" do
     @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Blah'}, {:kind=>'Staff'}]
-    Employee.all.collect{|x| x.class}.should == [Employee, Manager, Employee, Staff]
+    Employee.all.collect{|x| x.class}.must_equal [Employee, Manager, Employee, Staff]
   end
   
   it "should fallback to the main class if the given class does not exist in subclasses" do
     Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Blah'}]
-    Manager.all.collect{|x| x.class}.should == [Manager, Executive, Manager]
+    Manager.all.collect{|x| x.class}.must_equal [Manager, Executive, Manager]
   end
 
   it "should sets the model class name for the key when creating new parent class records" do
     Employee.create
-    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
   
   it "should sets the model class name for the key when creating new subclass records" do
     Executive.create
-    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Executive')",
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Executive')",
       "INSERT INTO managers (id) VALUES (1)",
       "INSERT INTO executives (id) VALUES (1)"]
   end
 
   it "should ignore existing cti_key value when creating new records" do
     Employee.create(:kind=>'Manager')
-    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
     
   it "should ignore existing cti_key value in subclasses" do
     Manager.create(:kind=>'Executive')
-    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Manager')",
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Manager')",
       "INSERT INTO managers (id) VALUES (1)"]
   end
 
@@ -155,41 +155,41 @@ describe "class_table_inheritance plugin" do
     def o.validate
       errors.add(:kind, 'not present') unless kind
     end
-    o.valid?.should == true
+    o.valid?.must_equal true
   end
 
   it "should set the type column field even when not validating" do
     Employee.new.save(:validate=>false)
-    @db.sqls.should == ["INSERT INTO employees (kind) VALUES ('Employee')"]
+    @db.sqls.must_equal ["INSERT INTO employees (kind) VALUES ('Employee')"]
   end
 
   it "should raise an error if attempting to create an anonymous subclass" do
-    proc{Class.new(Manager)}.should raise_error(Sequel::Error)
+    proc{Class.new(Manager)}.must_raise(Sequel::Error)
   end
 
   it "should allow specifying a map of names to tables to override implicit mapping" do
-    Manager.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
-    Staff.dataset.sql.should == 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
+    Manager.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id)'
+    Staff.dataset.sql.must_equal 'SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id)'
   end
 
   it "should lazily load attributes for columns in subclass tables" do
     Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
     m = Manager[1]
-    @db.sqls.should == ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1']
+    @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1']
     Executive.instance_dataset._fetch = Executive.dataset._fetch = {:num_managers=>3}
-    m.num_managers.should == 3
-    @db.sqls.should == ['SELECT executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1']
-    m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}
+    m.num_managers.must_equal 3
+    @db.sqls.must_equal ['SELECT executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id = 1) LIMIT 1']
+    m.values.must_equal(:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3)
   end
 
   it "should lazily load columns in middle classes correctly when loaded from parent class" do
     Employee.dataset._fetch = {:id=>1, :kind=>'Executive'}
     Manager.dataset._fetch = {:num_staff=>2}
     e = Employee[1]
-    e.should be_a_kind_of(Executive)
-    @db.sqls.should == ["SELECT employees.id, employees.name, employees.kind FROM employees WHERE (id = 1) LIMIT 1"]
-    e.num_staff.should == 2
-    @db.sqls.should == ["SELECT managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1"]
+    e.must_be_kind_of(Executive)
+    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind FROM employees WHERE (id = 1) LIMIT 1"]
+    e.num_staff.must_equal 2
+    @db.sqls.must_equal ["SELECT managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1"]
   end
 
   it "should eagerly load lazily columns in subclasses when loaded from parent class" do
@@ -197,51 +197,51 @@ describe "class_table_inheritance plugin" do
     Manager.dataset._fetch = {:id=>1, :num_staff=>2}
     Executive.dataset._fetch = {:id=>1, :num_managers=>3}
     e = Employee.all.first
-    e.should be_a_kind_of(Executive)
-    @db.sqls.should == ["SELECT employees.id, employees.name, employees.kind FROM employees"]
-    e.num_staff#.should == 2
-    @db.sqls.should == ["SELECT managers.id, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id IN (1))"]
-    e.num_managers#.should == 3
-    @db.sqls.should == ['SELECT executives.id, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id IN (1))']
+    e.must_be_kind_of(Executive)
+    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind FROM employees"]
+    e.num_staff#.must_equal 2
+    @db.sqls.must_equal ["SELECT managers.id, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id IN (1))"]
+    e.num_managers#.must_equal 3
+    @db.sqls.must_equal ['SELECT executives.id, executives.num_managers FROM employees INNER JOIN managers ON (managers.id = employees.id) INNER JOIN executives ON (executives.id = managers.id) WHERE (executives.id IN (1))']
   end
   
   it "should include schema for columns for tables for ancestor classes" do
-    Employee.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}}
-    Manager.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}}
-    Executive.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer}}
-    Staff.db_schema.should == {:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer}}
+    Employee.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string})
+    Manager.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer})
+    Executive.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :num_staff=>{:type=>:integer}, :num_managers=>{:type=>:integer})
+    Staff.db_schema.must_equal(:id=>{:primary_key=>true, :type=>:integer}, :name=>{:type=>:string}, :kind=>{:type=>:string}, :manager_id=>{:type=>:integer})
   end
 
   it "should use the correct primary key (which should have the same name in all subclasses)" do
-    [Employee, Manager, Executive, Staff].each{|c| c.primary_key.should == :id}
+    [Employee, Manager, Executive, Staff].each{|c| c.primary_key.must_equal :id}
   end
 
   it "should have table_name return the table name of the most specific table" do
-    Employee.table_name.should == :employees
-    Manager.table_name.should == :managers
-    Executive.table_name.should == :executives
-    Staff.table_name.should == :staff
+    Employee.table_name.must_equal :employees
+    Manager.table_name.must_equal :managers
+    Executive.table_name.must_equal :executives
+    Staff.table_name.must_equal :staff
   end
 
   it "should delete the correct rows from all tables when deleting" do
     Executive.load(:id=>1).delete
-    @db.sqls.should == ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
+    @db.sqls.must_equal ["DELETE FROM executives WHERE (id = 1)", "DELETE FROM managers WHERE (id = 1)", "DELETE FROM employees WHERE (id = 1)"]
   end
 
   it "should not allow deletion of frozen object" do
     o = Executive.load(:id=>1)
     o.freeze
-    proc{o.delete}.should raise_error(Sequel::Error)
-    @db.sqls.should == []
+    proc{o.delete}.must_raise(Sequel::Error)
+    @db.sqls.must_equal []
   end
 
   it "should insert the correct rows into all tables when inserting" do
     Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
     sqls = @db.sqls
-    sqls.length.should == 3
-    sqls[0].should =~ /INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/
-    sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/
-    sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/
+    sqls.length.must_equal 3
+    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/)
+    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/)
+    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/)
     end
     
   it "should insert the correct rows into all tables with a given primary key" do
@@ -249,26 +249,26 @@ describe "class_table_inheritance plugin" do
     e.id = 2
     e.save
     sqls = @db.sqls
-    sqls.length.should == 3
-    sqls[0].should =~ /INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/
-    sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/
-    sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/
+    sqls.length.must_equal 3
+    sqls[0].must_match(/INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/)
+    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/)
+    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/)
   end
 
   it "should update the correct rows in all tables when updating" do
     Executive.load(:id=>2).update(:num_managers=>3, :num_staff=>2, :name=>'E')
-    @db.sqls.should == ["UPDATE employees SET name = 'E' WHERE (id = 2)", "UPDATE managers SET num_staff = 2 WHERE (id = 2)", "UPDATE executives SET num_managers = 3 WHERE (id = 2)"]
+    @db.sqls.must_equal ["UPDATE employees SET name = 'E' WHERE (id = 2)", "UPDATE managers SET num_staff = 2 WHERE (id = 2)", "UPDATE executives SET num_managers = 3 WHERE (id = 2)"]
   end
 
   it "should handle many_to_one relationships correctly" do
     Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3}
-    Staff.load(:manager_id=>3).manager.should == Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
-    @db.sqls.should == ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
+    Staff.load(:manager_id=>3).manager.must_equal Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
+    @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do
     Staff.dataset._fetch = {:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3}
-    Executive.load(:id=>3).staff_members.should == [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
-    @db.sqls.should == ['SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
+    Executive.load(:id=>3).staff_members.must_equal [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
+    @db.sqls.must_equal ['SELECT employees.id, employees.name, employees.kind, staff.manager_id FROM employees INNER JOIN staff ON (staff.id = employees.id) WHERE (staff.manager_id = 3)']
   end
 end