sequel 4.22.0 → 4.23.0

data/spec/extensions/update_primary_key_spec.rb

@@ -11,90 +11,90 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     DB.reset
   end
 
-  specify "should handle regular updates" do
+  it "should handle regular updates" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>1, :b=>4}], [{:a=>1, :b=>4}], [{:a=>1, :b=>5}], [{:a=>1, :b=>5}], [{:a=>1, :b=>6}], [{:a=>1, :b=>6}]]
     @c.first.update(:b=>4)
-    @c.all.should == [@c.load(:a=>1, :b=>4)]
-    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
+    @c.all.must_equal [@c.load(:a=>1, :b=>4)]
+    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 4 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>5).save
-    @c.all.should == [@c.load(:a=>1, :b=>5)]
-    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
+    @c.all.must_equal [@c.load(:a=>1, :b=>5)]
+    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:b=>6).save(:columns=>:b)
-    @c.all.should == [@c.load(:a=>1, :b=>6)]
-    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
+    @c.all.must_equal [@c.load(:a=>1, :b=>6)]
+    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
   end
 
-  specify "should handle updating the primary key field with another field" do
+  it "should handle updating the primary key field with another field" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.update(:a=>2, :b=>4)
-    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    @c.all.must_equal [@c.load(:a=>2, :b=>4)]
     sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
-    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
+    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
-  specify "should handle updating just the primary key field when saving changes" do
+  it "should handle updating just the primary key field when saving changes" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}], [{:a=>2, :b=>3}], [{:a=>3, :b=>3}]]
     @c.first.update(:a=>2)
-    @c.all.should == [@c.load(:a=>2, :b=>3)]
-    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
+    @c.all.must_equal [@c.load(:a=>2, :b=>3)]
+    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
     @c.first.set(:a=>3).save(:columns=>:a)
-    @c.all.should == [@c.load(:a=>3, :b=>3)]
-    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
+    @c.all.must_equal [@c.load(:a=>3, :b=>3)]
+    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
   end
 
-  specify "should handle saving after modifying the primary key field with another field" do
+  it "should handle saving after modifying the primary key field with another field" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     @c.first.set(:a=>2, :b=>4).save
-    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    @c.all.must_equal [@c.load(:a=>2, :b=>4)]
     sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
-    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
+    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
-  specify "should handle saving after modifying just the primary key field" do
+  it "should handle saving after modifying just the primary key field" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>3}]]
     @c.first.set(:a=>2).save
-    @c.all.should == [@c.load(:a=>2, :b=>3)]
+    @c.all.must_equal [@c.load(:a=>2, :b=>3)]
     sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
-    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
+    ["UPDATE a SET a = 2, b = 3 WHERE (a = 1)", "UPDATE a SET b = 3, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
+    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
   end
 
-  specify "should handle saving after updating the primary key" do
+  it "should handle saving after updating the primary key" do
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>5}]]
     @c.first.update(:a=>2).update(:b=>4).set(:b=>5).save
-    @c.all.should == [@c.load(:a=>2, :b=>5)]
-    DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "UPDATE a SET b = 4 WHERE (a = 2)", "UPDATE a SET b = 5 WHERE (a = 2)", "SELECT * FROM a"]
+    @c.all.must_equal [@c.load(:a=>2, :b=>5)]
+    DB.sqls.must_equal ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "UPDATE a SET b = 4 WHERE (a = 2)", "UPDATE a SET b = 5 WHERE (a = 2)", "SELECT * FROM a"]
   end
 
-  specify "should work correctly when using the prepared_statements plugin" do
+  it "should work correctly when using the prepared_statements plugin" do
     @c.plugin :prepared_statements
     @ds._fetch = [[{:a=>1, :b=>3}], [{:a=>2, :b=>4}]]
     o = @c.first
     o.update(:a=>2, :b=>4)
-    @c.all.should == [@c.load(:a=>2, :b=>4)]
+    @c.all.must_equal [@c.load(:a=>2, :b=>4)]
     sqls = DB.sqls
-    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].should include(sqls.slice!(1))
-    sqls.should == ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
+    ["UPDATE a SET a = 2, b = 4 WHERE (a = 1)", "UPDATE a SET b = 4, a = 2 WHERE (a = 1)"].must_include(sqls.slice!(1))
+    sqls.must_equal ["SELECT * FROM a LIMIT 1", "SELECT * FROM a"]
 
     o.delete
   end
 
-  specify "should clear the associations cache of non-many_to_one associations when changing the primary key" do
+  it "should clear the associations cache of non-many_to_one associations when changing the primary key" do
     @c.one_to_many :cs, :class=>@c
     @c.many_to_one :c, :class=>@c
     o = @c.new(:a=>1)
     o.associations[:cs] = @c.new
     o.associations[:c] = o2 = @c.new
     o.a = 2
-    o.associations.should == {:c=>o2}
+    o.associations.must_equal(:c=>o2)
   end
 
-  specify "should handle frozen instances" do
+  it "should handle frozen instances" do
     o = @c.new
     o.a = 1
     o.freeze
-    o.pk_hash.should == {:a=>1}
+    o.pk_hash.must_equal(:a=>1)
   end
 end

data/spec/extensions/update_refresh_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::UpdateRefresh" do
+  before do
+    @db = Sequel.mock(:numrows=>1, :fetch=>{:id=>1, :name=>'b'})
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @ds = @c.dataset
+    @c.columns :id, :name
+    @c.plugin :update_refresh
+    @db.sqls
+  end
+
+  it "should refresh the instance after updating" do
+    o = @c.load(:id=>1, :name=>'a')
+    o.save
+    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1)", "SELECT * FROM test WHERE (id = 1) LIMIT 1"]
+    o.name.must_equal 'b'
+  end
+
+  it "should refresh the instance after updating" do
+    @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
+    @c.dataset = @db[:test]
+    @db.sqls
+    o = @c.load(:id=>1, :name=>'a')
+    o.save
+    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) RETURNING *"]
+    o.name.must_equal 'b'
+  end
+
+  it "should refresh the instance after updating when returning specific columns" do
+    @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
+    @c.plugin :insert_returning_select
+    @c.dataset = @db[:test].select(:id, :name)
+    @db.sqls
+    o = @c.load(:id=>1, :name=>'a')
+    o.this.opts[:returning] = [:id, :name]
+    o.save
+    @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) RETURNING id, name"]
+    o.name.must_equal 'b'
+  end
+end

data/spec/extensions/validate_associated_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "ValidatesAssociated plugin" do
+  before do
+    @db = Sequel.mock(:autoid=>1, :numrows=>1, :fetch=>{:id=>1, :name=>'a', :c_id=>nil})
+    @c = Class.new(Sequel::Model(@db[:cs]))
+    @c.plugin :validate_associated
+    @c.columns :id, :name, :c_id
+    @c.one_to_many :cs, :class=>@c, :key=>:c_id
+    @o = @c.load(:id=>1, :name=>'a')
+    @db.sqls
+  end
+  
+  it "should return nil when saving if the associated object is invalid when raise_on_save_failure is false" do
+    @c.raise_on_save_failure = false
+    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
+    o = @c.load(:id=>2, :name=>'b')
+    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), o)
+    @o.save.must_equal nil
+    @o.errors[:cs].must_equal ["name is b"]
+    o.errors[:name].must_equal ['is b']
+  end
+
+  it "should support creating new one_to_many and one_to_one objects with presence validations on the foreign key" do
+    @c.class_eval do
+      plugin :validation_helpers
+      def validate
+        validates_integer :c_id
+        super
+      end
+    end
+    @o.c_id = 5
+    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), @c.load(:id=>2, :name=>'b', :c_id=>2))
+    @o.valid?.must_equal true
+  end
+
+  it "should should not remove existing values from object when validating" do
+    o = @c.load(:id=>2, :name=>'b', :c_id=>3)
+    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), o)
+    @o.valid?.must_equal true
+    o.c_id.must_equal 3
+  end
+  
+  it "should not attempt to validate associated_object if the :validate=>false option is passed to save" do
+    @c.one_to_many :cs, :class=>@c, :key=>:c_id
+    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
+    o = @c.load(:id=>2, :name=>'b', :c_id=>3)
+    @o.send(:delay_validate_associated_object, @c.association_reflection(:cs), o)
+    @o.save(:validate=>false).must_equal @o
+    @db.sqls.must_equal ["UPDATE cs SET name = 'a' WHERE (id = 1)"]
+  end
+end

data/spec/extensions/validation_class_methods_spec.rb

@@ -16,46 +16,46 @@ describe Sequel::Model do
     end
   end
   
-  specify "should respond to validations, has_validations?, and validation_reflections" do
-    @c.should respond_to(:validations)
-    @c.should respond_to(:has_validations?)
-    @c.should respond_to(:validation_reflections)
+  it "should respond to validations, has_validations?, and validation_reflections" do
+    @c.must_respond_to(:validations)
+    @c.must_respond_to(:has_validations?)
+    @c.must_respond_to(:validation_reflections)
   end
   
-  specify "should be able to reflect on validations" do
-    @c.validation_reflections.should == {}
+  it "should be able to reflect on validations" do
+    @c.validation_reflections.must_equal({})
     @c.validates_acceptance_of(:a)
-    @c.validation_reflections.should == {:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]]}
+    @c.validation_reflections.must_equal(:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]])
     @c.validates_presence_of(:a)
-    @c.validation_reflections[:a].length.should == 2
-    @c.validation_reflections[:a].last.should == [:presence, {:tag=>:presence, :message=>"is not present"}]
+    @c.validation_reflections[:a].length.must_equal 2
+    @c.validation_reflections[:a].last.must_equal [:presence, {:tag=>:presence, :message=>"is not present"}]
   end
 
-  specify "should handle validation reflections correctly when subclassing" do
+  it "should handle validation reflections correctly when subclassing" do
     @c.validates_acceptance_of(:a)
     c = Class.new(@c)
-    c.validation_reflections.map{|k,v| k}.should == [:a]
+    c.validation_reflections.map{|k,v| k}.must_equal [:a]
     c.validates_presence_of(:a)
-    @c.validation_reflections.should == {:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]]}
-    c.validation_reflections[:a].last.should == [:presence, {:tag=>:presence, :message=>"is not present"}]
+    @c.validation_reflections.must_equal(:a=>[[:acceptance, {:tag=>:acceptance, :message=>"is not accepted", :allow_nil=>true, :accept=>"1"}]])
+    c.validation_reflections[:a].last.must_equal [:presence, {:tag=>:presence, :message=>"is not present"}]
   end
 
-  specify "should acccept validation definitions using validates_each" do
+  it "should acccept validation definitions using validates_each" do
     @c.validates_each(:xx, :yy) {|o, a, v| o.errors.add(a, 'too low') if v < 50}
     o = @c.new
-    o.should_receive(:xx).once.and_return(40)
-    o.should_receive(:yy).once.and_return(60)
-    o.valid?.should == false
-    o.errors.full_messages.should == ['xx too low']
+    def o.xx; 40; end
+    def o.yy; 60; end
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['xx too low']
   end
 
-  specify "should return true/false for has_validations?" do
-    @c.has_validations?.should == false
+  it "should return true/false for has_validations?" do
+    @c.has_validations?.must_equal false
     @c.validates_each(:xx) {1}
-    @c.has_validations?.should == true
+    @c.has_validations?.must_equal true
   end
   
-  specify "should validate multiple attributes at once" do
+  it "should validate multiple attributes at once" do
     o = @c.new
     def o.xx
       1
@@ -67,11 +67,11 @@ describe Sequel::Model do
     atts = nil
     @c.validates_each([:xx, :yy]){|obj,a,v| atts=a; vals=v}
     o.valid?
-    vals.should == [1,2]
-    atts.should == [:xx, :yy]
+    vals.must_equal [1,2]
+    atts.must_equal [:xx, :yy]
   end
   
-  specify "should respect allow_missing option when using multiple attributes" do
+  it "should respect allow_missing option when using multiple attributes" do
     o = @c.new
     def o.xx
       self[:xx]
@@ -85,26 +85,26 @@ describe Sequel::Model do
 
     o.values[:xx] = 1
     o.valid?
-    vals.should == [1,nil]
-    atts.should == [:xx, :yy]
+    vals.must_equal [1,nil]
+    atts.must_equal [:xx, :yy]
 
     vals = nil
     atts = nil
     o.values.clear
     o.values[:yy] = 2
     o.valid?
-    vals.should == [nil, 2]
-    atts.should == [:xx, :yy]
+    vals.must_equal [nil, 2]
+    atts.must_equal [:xx, :yy]
 
     vals = nil
     atts = nil
     o.values.clear
-    o.valid?.should == true
-    vals.should == nil
-    atts.should == nil
+    o.valid?.must_equal true
+    vals.must_equal nil
+    atts.must_equal nil
   end
   
-  specify "should overwrite existing validation with the same tag and attribute" do
+  it "should overwrite existing validation with the same tag and attribute" do
     @c.validates_each(:xx, :xx, :tag=>:low) {|o, a, v| o.xxx; o.errors.add(a, 'too low') if v < 50}
     @c.validates_each(:yy, :yy) {|o, a, v| o.yyy; o.errors.add(a, 'too low') if v < 50}
     @c.validates_presence_of(:zz, :zz)
@@ -118,33 +118,33 @@ describe Sequel::Model do
       @b ||= 0
       @b += 1
     end
-    o.should_receive(:xx).once.and_return(40)
-    o.should_receive(:yy).once.and_return(60)
-    o.should_receive(:xxx).once
-    o.should_receive(:yyy).twice
-    o.valid?.should == false
-    o.zz.should == 2
-    o.aa.should == 2
-    o.errors.full_messages.should == ['xx too low']
+    def o.xx; 40; end
+    def o.yy; 60; end
+    def o.xxx; end
+    def o.yyy; end
+    o.valid?.must_equal false
+    o.zz.must_equal 2
+    o.aa.must_equal 2
+    o.errors.full_messages.must_equal ['xx too low']
   end
 
-  specify "should provide a validates method that takes block with validation definitions" do
+  it "should provide a validates method that takes block with validation definitions" do
     @c.validates do
       coolness_of :blah
     end
-    @c.validations[:blah].should_not be_empty
+    @c.validations[:blah].wont_be :empty?
     o = @c.new
-    o.should_receive(:blah).once.and_return(nil)
-    o.valid?.should == false
-    o.errors.full_messages.should == ['blah is not cool']
+    def o.blah; end
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['blah is not cool']
   end
 
-  specify "should have the validates block have appropriate respond_to?" do
+  it "should have the validates block have appropriate respond_to?" do
     c = nil
     @c.validates{c = respond_to?(:foo)}
-    c.should == false
+    c.must_equal false
     @c.validates{c = respond_to?(:length_of)}
-    c.should == true
+    c.must_equal true
   end if RUBY_VERSION >= '1.9'
 end
 
@@ -160,22 +160,22 @@ describe Sequel::Model do
     @o = @c.new
   end
   
-  specify "should supply a #valid? method that returns true if validations pass" do
+  it "should supply a #valid? method that returns true if validations pass" do
     @o.score = 50
-    @o.should_not be_valid
+    @o.wont_be :valid?
     @o.score = 100
-    @o.should be_valid
+    @o.must_be :valid?
   end
   
-  specify "should provide an errors object" do
+  it "should provide an errors object" do
     @o.score = 100
-    @o.should be_valid
-    @o.errors.should be_empty
+    @o.must_be :valid?
+    @o.errors.must_be :empty?
     
     @o.score = 86
-    @o.should_not be_valid
-    @o.errors[:score].should == ['too low']
-    @o.errors.on(:blah).should be_nil
+    @o.wont_be :valid?
+    @o.errors[:score].must_equal ['too low']
+    @o.errors.on(:blah).must_equal nil
   end
 end
 
@@ -190,11 +190,11 @@ describe "Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator" do
     end
   end
   
-  specify "should instance_eval the block, sending everything to its receiver" do
+  it "should instance_eval the block, sending everything to its receiver" do
     @c.validates do
       blah
     end
-    @testit.should == [1324]
+    @testit.must_equal [1324]
   end
 end
 
@@ -215,379 +215,379 @@ describe Sequel::Model do
     @m = @c.new
   end
 
-  specify "should validate acceptance_of" do
+  it "should validate acceptance_of" do
     @c.validates_acceptance_of :value
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '1'
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should validate acceptance_of with accept" do
+  it "should validate acceptance_of with accept" do
     @c.validates_acceptance_of :value, :accept => 'true'
     @m.value = '1'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 'true'
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should validate acceptance_of with allow_nil => false" do
+  it "should validate acceptance_of with allow_nil => false" do
     @c.validates_acceptance_of :value, :allow_nil => false
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate acceptance_of with allow_missing => true" do
+  it "should validate acceptance_of with allow_missing => true" do
     @c.validates_acceptance_of :value, :allow_missing => true
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate acceptance_of with allow_missing => true and allow_nil => false" do
+  it "should validate acceptance_of with allow_missing => true and allow_nil => false" do
     @c.validates_acceptance_of :value, :allow_missing => true, :allow_nil => false
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate acceptance_of with if => true" do
+  it "should validate acceptance_of with if => true" do
     @c.validates_acceptance_of :value, :if => :dont_skip
     @m.value = '0'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate acceptance_of with if => false" do
+  it "should validate acceptance_of with if => false" do
     @c.validates_acceptance_of :value, :if => :skip
     @m.value = '0'
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate acceptance_of with if proc that evaluates to true" do
+  it "should validate acceptance_of with if proc that evaluates to true" do
     @c.validates_acceptance_of :value, :if => proc{true}
     @m.value = '0'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate acceptance_of with if proc that evaluates to false" do
+  it "should validate acceptance_of with if proc that evaluates to false" do
     @c.validates_acceptance_of :value, :if => proc{false}
     @m.value = '0'
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should raise an error if :if option is not a Symbol, Proc, or nil" do
+  it "should raise an error if :if option is not a Symbol, Proc, or nil" do
     @c.validates_acceptance_of :value, :if => 1
     @m.value = '0'
-    proc{@m.valid?}.should raise_error(Sequel::Error)
+    proc{@m.valid?}.must_raise(Sequel::Error)
   end
 
-  specify "should validate confirmation_of" do
+  it "should validate confirmation_of" do
     @c.send(:attr_accessor, :value_confirmation)
     @c.validates_confirmation_of :value
     
     @m.value = 'blah'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     
     @m.value_confirmation = 'blah'
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should validate confirmation_of with if => true" do
+  it "should validate confirmation_of with if => true" do
     @c.send(:attr_accessor, :value_confirmation)
     @c.validates_confirmation_of :value, :if => :dont_skip
 
     @m.value = 'blah'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate confirmation_of with if => false" do
+  it "should validate confirmation_of with if => false" do
     @c.send(:attr_accessor, :value_confirmation)
     @c.validates_confirmation_of :value, :if => :skip
 
     @m.value = 'blah'
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate confirmation_of with allow_missing => true" do
+  it "should validate confirmation_of with allow_missing => true" do
     @c.send(:attr_accessor, :value_confirmation)
     @c.validates_acceptance_of :value, :allow_missing => true
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value_confirmation = 'blah'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate format_of" do
+  it "should validate format_of" do
     @c.validates_format_of :value, :with => /.+_.+/
     @m.value = 'abc_'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 'abc_def'
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should raise for validate_format_of without regexp" do
-    proc {@c.validates_format_of :value}.should raise_error(ArgumentError)
-    proc {@c.validates_format_of :value, :with => :blah}.should raise_error(ArgumentError)
+  it "should raise for validate_format_of without regexp" do
+    proc {@c.validates_format_of :value}.must_raise(ArgumentError)
+    proc {@c.validates_format_of :value, :with => :blah}.must_raise(ArgumentError)
   end
   
-  specify "should validate format_of with if => true" do
+  it "should validate format_of with if => true" do
     @c.validates_format_of :value, :with => /_/, :if => :dont_skip
 
     @m.value = 'a'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate format_of with if => false" do
+  it "should validate format_of with if => false" do
     @c.validates_format_of :value, :with => /_/, :if => :skip
 
     @m.value = 'a'
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should validate format_of with allow_missing => true" do
+  it "should validate format_of with allow_missing => true" do
     @c.validates_format_of :value, :allow_missing => true, :with=>/./
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate length_of with maximum" do
+  it "should validate length_of with maximum" do
     @c.validates_length_of :value, :maximum => 5
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '12345'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '123456'
-    @m.should_not be_valid
-    @m.errors[:value].should == ['is too long']
+    @m.wont_be :valid?
+    @m.errors[:value].must_equal ['is too long']
     @m.value = nil
-    @m.should_not be_valid
-    @m.errors[:value].should == ['is not present']
+    @m.wont_be :valid?
+    @m.errors[:value].must_equal ['is not present']
   end
 
-  specify "should validate length_of with maximum using customized error messages" do
+  it "should validate length_of with maximum using customized error messages" do
     @c.validates_length_of :value, :maximum => 5, :too_long=>'tl', :nil_message=>'np'
     @m.value = '123456'
-    @m.should_not be_valid
-    @m.errors[:value].should == ['tl']
+    @m.wont_be :valid?
+    @m.errors[:value].must_equal ['tl']
     @m.value = nil
-    @m.should_not be_valid
-    @m.errors[:value].should == ['np']
+    @m.wont_be :valid?
+    @m.errors[:value].must_equal ['np']
   end
 
-  specify "should validate length_of with minimum" do
+  it "should validate length_of with minimum" do
     @c.validates_length_of :value, :minimum => 5
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '12345'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '1234'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate length_of with within" do
+  it "should validate length_of with within" do
     @c.validates_length_of :value, :within => 2..5
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '12345'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '1'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '123456'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate length_of with is" do
+  it "should validate length_of with is" do
     @c.validates_length_of :value, :is => 3
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '123'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '12'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '1234'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
   
-  specify "should validate length_of with allow_nil" do
+  it "should validate length_of with allow_nil" do
     @c.validates_length_of :value, :is => 3, :allow_nil => true
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate length_of with if => true" do
+  it "should validate length_of with if => true" do
     @c.validates_length_of :value, :is => 3, :if => :dont_skip
 
     @m.value = 'a'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate length_of with if => false" do
+  it "should validate length_of with if => false" do
     @c.validates_length_of :value, :is => 3, :if => :skip
 
     @m.value = 'a'
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate length_of with allow_missing => true" do
+  it "should validate length_of with allow_missing => true" do
     @c.validates_length_of :value, :allow_missing => true, :minimum => 5
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should allow multiple calls to validates_length_of with different options without overwriting" do
+  it "should allow multiple calls to validates_length_of with different options without overwriting" do
     @c.validates_length_of :value, :maximum => 5
     @c.validates_length_of :value, :minimum => 5
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '12345'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '123456'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '12345'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '1234'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate numericality_of" do
+  it "should validate numericality_of" do
     @c.validates_numericality_of :value
     @m.value = 'blah'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '123'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '123.1231'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '+1'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '-1'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '+1.123'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '-0.123'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '-0.123E10'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '32.123e10'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '+32.123E10'
-    @m.should be_valid
-    @m.should be_valid
+    @m.must_be :valid?
+    @m.must_be :valid?
     @m.value = '.0123'
   end
 
-  specify "should validate numericality_of with only_integer" do
+  it "should validate numericality_of with only_integer" do
     @c.validates_numericality_of :value, :only_integer => true
     @m.value = 'blah'
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = '123'
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = '123.1231'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
   
-  specify "should validate numericality_of with if => true" do
+  it "should validate numericality_of with if => true" do
     @c.validates_numericality_of :value, :if => :dont_skip
 
     @m.value = 'a'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate numericality_of with if => false" do
+  it "should validate numericality_of with if => false" do
     @c.validates_numericality_of :value, :if => :skip
 
     @m.value = 'a'
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate numericality_of with allow_missing => true" do
+  it "should validate numericality_of with allow_missing => true" do
     @c.validates_numericality_of :value, :allow_missing => true
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate presence_of" do
+  it "should validate presence_of" do
     @c.validates_presence_of :value
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = ''
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 1234
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = true
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = false
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should validate inclusion_of with an array" do
+  it "should validate inclusion_of with an array" do
     @c.validates_inclusion_of :value, :in => [1,2]
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 1
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = 1.5
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 2
-    @m.should be_valid    
+    @m.must_be :valid?    
     @m.value = 3
-    @m.should_not be_valid 
+    @m.wont_be :valid? 
   end
   
-  specify "should validate inclusion_of with a range" do
+  it "should validate inclusion_of with a range" do
     @c.validates_inclusion_of :value, :in => 1..4
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 1
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = 1.5
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = 0
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.value = 5
-    @m.should_not be_valid    
+    @m.wont_be :valid?    
   end
   
-  specify "should raise an error if inclusion_of doesn't receive a valid :in option" do
-    lambda{@c.validates_inclusion_of :value}.should raise_error(ArgumentError)
-    lambda{@c.validates_inclusion_of :value, :in => 1}.should raise_error(ArgumentError)
+  it "should raise an error if inclusion_of doesn't receive a valid :in option" do
+    lambda{@c.validates_inclusion_of :value}.must_raise(ArgumentError)
+    lambda{@c.validates_inclusion_of :value, :in => 1}.must_raise(ArgumentError)
   end
   
-  specify "should raise an error if inclusion_of handles :allow_nil too" do
+  it "should raise an error if inclusion_of handles :allow_nil too" do
     @c.validates_inclusion_of :value, :in => 1..4, :allow_nil => true
     @m.value = nil
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = 0
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate presence_of with if => true" do
+  it "should validate presence_of with if => true" do
     @c.validates_presence_of :value, :if => :dont_skip
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate presence_of with if => false" do
+  it "should validate presence_of with if => false" do
     @c.validates_presence_of :value, :if => :skip
-    @m.should be_valid
+    @m.must_be :valid?
   end
 
-  specify "should validate presence_of with allow_missing => true" do
+  it "should validate presence_of with allow_missing => true" do
     @c.validates_presence_of :value, :allow_missing => true
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = nil
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate uniqueness_of with if => true" do
+  it "should validate uniqueness_of with if => true" do
     @c.validates_uniqueness_of :value, :if => :dont_skip
 
     @m.value = 'a'
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 
-  specify "should validate uniqueness_of with if => false" do
+  it "should validate uniqueness_of with if => false" do
     @c.validates_uniqueness_of :value, :if => :skip
     @m.value = 'a'
-    @m.should be_valid
+    @m.must_be :valid?
   end
   
-  specify "should validate uniqueness_of with allow_missing => true" do
+  it "should validate uniqueness_of with allow_missing => true" do
     @c.validates_uniqueness_of :value, :allow_missing => true
-    @m.should be_valid
+    @m.must_be :valid?
     @m.value = 1
-    @m.should_not be_valid
+    @m.wont_be :valid?
   end
 end
 
@@ -605,44 +605,44 @@ describe "Superclass validations" do
     end
   end
   
-  specify "should be checked when validating" do
+  it "should be checked when validating" do
     o = @c2.new
     o.value = 'ab'
-    o.valid?.should == false
-    o.errors.full_messages.should == ['value is too short']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['value is too short']
 
     o.value = '12'
-    o.valid?.should == false
-    o.errors.full_messages.should == ['value is too short', 'value is invalid']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['value is too short', 'value is invalid']
 
     o.value = 'abcde'
-    o.valid?.should == true
+    o.valid?.must_equal true
   end
   
-  specify "should have skip_superclass_validations? return whether superclass validations were skipped" do
-    @c2.skip_superclass_validations?.should == nil
+  it "should have skip_superclass_validations? return whether superclass validations were skipped" do
+    @c2.skip_superclass_validations?.must_equal nil
     @c2.skip_superclass_validations
-    @c2.skip_superclass_validations?.should == true
+    @c2.skip_superclass_validations?.must_equal true
   end
 
-  specify "should be skipped if skip_superclass_validations is called" do
+  it "should be skipped if skip_superclass_validations is called" do
     @c2.skip_superclass_validations
 
     o = @c2.new
     o.value = 'ab'
-    o.valid?.should == true
+    o.valid?.must_equal true
 
     o.value = '12'
-    o.valid?.should == false
-    o.errors.full_messages.should == ['value is invalid']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['value is invalid']
 
     o.value = 'abcde'
-    o.valid?.should == true
+    o.valid?.must_equal true
   end
 end
 
 describe ".validates with block" do
-  specify "should support calling .each" do
+  it "should support calling .each" do
     @c = model_class.call Sequel::Model do
       columns :vvv
       validates do
@@ -654,15 +654,14 @@ describe ".validates with block" do
     
     o = @c.new
     o.vvv = 1
-    o.should be_valid
+    o.must_be :valid?
     o.vvv = -1
-    o.should_not be_valid
+    o.wont_be :valid?
   end
 end
 
 describe Sequel::Model, "Validations" do
-
-  before(:all) do
+  before do
     class ::Person < Sequel::Model
       plugin :validation_class_methods
       columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms
@@ -691,7 +690,7 @@ describe Sequel::Model, "Validations" do
       columns :id, :zip_code
     end
   end
-  after(:all) do
+  after do
     [:Person, :Smurf, :Cow, :User, :Address].each{|c| Object.send(:remove_const, c)}
   end
   
@@ -702,11 +701,11 @@ describe Sequel::Model, "Validations" do
     end
     
     @cow = Cow.new
-    @cow.should_not be_valid
-    @cow.errors.full_messages.should == ["got_milk is not accepted"]
+    @cow.wont_be :valid?
+    @cow.errors.full_messages.must_equal ["got_milk is not accepted"]
     
     @cow.got_milk = "blah"
-    @cow.should be_valid
+    @cow.must_be :valid?
   end
   
   it "should validate the confirmation of a column" do
@@ -720,11 +719,11 @@ describe Sequel::Model, "Validations" do
     end
     
     @user = User.new
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ["password is not confirmed"]
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ["password is not confirmed"]
     
     @user.password = "test"
-    @user.should be_valid
+    @user.must_be :valid?
   end
   
   it "should validate format of column" do
@@ -733,9 +732,9 @@ describe Sequel::Model, "Validations" do
     end
 
     @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.should == false
+    @person.valid?.must_equal false
     @person = Person.new :first_name => "Anita"
-    @person.valid?.should == true
+    @person.valid?.must_equal true
   end
   
   it "should validate length of column" do
@@ -754,20 +753,20 @@ describe Sequel::Model, "Validations" do
       :middle_name => "danger"
     )
     
-    @person.should_not be_valid
-    @person.errors.full_messages.size.should == 4
-    @person.errors.full_messages.should include(
+    @person.wont_be :valid?
+    @person.errors.full_messages.size.must_equal 4
+    @person.errors.full_messages.sort.must_equal [
       'first_name is too long',
+      'initials is the wrong length',
       'last_name is too short',
-      'middle_name is the wrong length',
-      'initials is the wrong length'
-    )
+      'middle_name is the wrong length'
+    ]
     
     @person.first_name  = "Lancelot"
     @person.last_name   = "1234567890123456789012345678901"
     @person.initials    = "LC"
     @person.middle_name = "Will"
-    @person.should be_valid
+    @person.must_be :valid?
   end
   
   it "should validate that a column has the correct type for the schema column" do
@@ -780,19 +779,19 @@ describe Sequel::Model, "Validations" do
     end
     
     @person = p.new
-    @person.should be_valid
+    @person.must_be :valid?
 
     @person.age = 'a'
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['age is not a valid integer']
+    @person.wont_be :valid?
+    @person.errors.full_messages.must_equal ['age is not a valid integer']
     @person.age = 1
-    @person.should be_valid
+    @person.must_be :valid?
 
     @person.d = 'a'
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['d is a bad choice']
+    @person.wont_be :valid?
+    @person.errors.full_messages.must_equal ['d is a bad choice']
     @person.d = Date.today
-    @person.should be_valid
+    @person.must_be :valid?
   end
 
   it "should validate numericality of column" do
@@ -802,11 +801,11 @@ describe Sequel::Model, "Validations" do
     end
     
     @person = Person.new :age => "Twenty"
-    @person.should_not be_valid
-    @person.errors.full_messages.should == ['age is not a number']
+    @person.wont_be :valid?
+    @person.errors.full_messages.must_equal ['age is not a number']
     
     @person.age = 20
-    @person.should be_valid
+    @person.must_be :valid?
   end
   
   it "should validate the presence of a column" do
@@ -816,11 +815,11 @@ describe Sequel::Model, "Validations" do
     end
     
     @cow = Cow.new
-    @cow.should_not be_valid
-    @cow.errors.full_messages.should == ['name is not present']
+    @cow.wont_be :valid?
+    @cow.errors.full_messages.must_equal ['name is not present']
     
     @cow.name = "Betsy"
-    @cow.should be_valid
+    @cow.must_be :valid?
   end
  
   it "should validate the uniqueness of a column" do
@@ -844,30 +843,30 @@ describe Sequel::Model, "Validations" do
     end
     
     @user = User.new(:username => "2records", :password => "anothertest")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username is already taken']
 
     @user = User.new(:username => "1record", :password => "anothertest")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username is already taken']
 
     @user = User.load(:id=>4, :username => "1record", :password => "anothertest")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username is already taken']
 
     @user = User.load(:id=>3, :username => "1record", :password => "anothertest")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
 
     @user = User.new(:username => "0records", :password => "anothertest")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
 
     User.db.sqls
     @user = User.new(:password => "anothertest")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
-    User.db.sqls.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
+    User.db.sqls.must_equal []
   end
   
   it "should validate the uniqueness of multiple columns" do
@@ -895,40 +894,40 @@ describe Sequel::Model, "Validations" do
     end
     
     @user = User.new(:username => "2records", :password => "anothertest")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username and password is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username and password is already taken']
 
     @user = User.new(:username => "1record", :password => "anothertest")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username and password is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username and password is already taken']
 
     @user = User.load(:id=>4, :username => "1record", :password => "anothertest")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username and password is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username and password is already taken']
 
     @user = User.load(:id=>3, :username => "1record", :password => "test")
-    @user.should_not be_valid
-    @user.errors.full_messages.should == ['username and password is already taken']
+    @user.wont_be :valid?
+    @user.errors.full_messages.must_equal ['username and password is already taken']
 
     @user = User.load(:id=>3, :username => "1record", :password => "anothertest")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
 
     @user = User.new(:username => "0records", :password => "anothertest")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
 
     User.db.sqls
     @user = User.new(:password => "anothertest")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
     @user = User.new(:username => "0records")
-    @user.should be_valid
-    @user.errors.full_messages.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
     @user = User.new
-    @user.should be_valid
-    @user.errors.full_messages.should == []
-    User.db.sqls.should == []
+    @user.must_be :valid?
+    @user.errors.full_messages.must_equal []
+    User.db.sqls.must_equal []
   end
   
   it "should have a validates block that contains multiple validations" do
@@ -940,23 +939,21 @@ describe Sequel::Model, "Validations" do
       end
     end
 
-    Person.validations[:first_name].size.should == 2
+    Person.validations[:first_name].size.must_equal 2
     
     @person = Person.new :first_name => "Lancelot99"
-    @person.valid?.should == false
+    @person.valid?.must_equal false
     
     @person2 = Person.new :first_name => "Wayne"
-    @person2.valid?.should == true
+    @person2.valid?.must_equal true
   end
 
   it "should allow 'longhand' validations direcly within the model." do
-    lambda {
-      class ::Person < Sequel::Model
-        validations.clear
-        validates_length_of :first_name, :maximum => 30
-      end
-    }.should_not raise_error
-    Person.validations.length.should eql(1)
+    class ::Person < Sequel::Model
+      validations.clear
+      validates_length_of :first_name, :maximum => 30
+    end
+    Person.validations.length.must_equal(1)
   end
 
   it "should define a has_validations? method which returns true if the model has validations, false otherwise" do
@@ -972,8 +969,8 @@ describe Sequel::Model, "Validations" do
       validations.clear
     end
 
-    Person.should have_validations
-    Smurf.should_not have_validations
+    Person.validations.wont_be :empty?
+    Smurf.validations.must_be :empty?
   end
 
   it "should validate correctly instances initialized with string keys" do
@@ -981,8 +978,8 @@ describe Sequel::Model, "Validations" do
       validates_length_of :name, :minimum => 4
     end
     
-    Can.new('name' => 'ab').should_not be_valid
-    Can.new('name' => 'abcd').should be_valid
+    Can.new('name' => 'ab').wont_be :valid?
+    Can.new('name' => 'abcd').must_be :valid?
   end
   
 end
@@ -1000,31 +997,31 @@ describe "Model#save" do
     DB.reset
   end
 
-  specify "should save only if validations pass" do
+  it "should save only if validations pass" do
     @m.raise_on_save_failure = false
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.save
-    DB.sqls.should be_empty
+    DB.sqls.must_be :empty?
     
     @m.x = 7
-    @m.should be_valid
-    @m.save.should_not == false
-    DB.sqls.should == ['UPDATE people SET x = 7 WHERE (id = 4)']
+    @m.must_be :valid?
+    @m.save.wont_equal false
+    DB.sqls.must_equal ['UPDATE people SET x = 7 WHERE (id = 4)']
   end
   
-  specify "should skip validations if the :validate=>false option is used" do
+  it "should skip validations if the :validate=>false option is used" do
     @m.raise_on_save_failure = false
-    @m.should_not be_valid
+    @m.wont_be :valid?
     @m.save(:validate=>false)
-    DB.sqls.should == ['UPDATE people SET x = 6 WHERE (id = 4)']
+    DB.sqls.must_equal ['UPDATE people SET x = 6 WHERE (id = 4)']
   end
     
-  specify "should raise error if validations fail and raise_on_save_faiure is true" do
-    proc{@m.save}.should raise_error(Sequel::ValidationFailed)
+  it "should raise error if validations fail and raise_on_save_faiure is true" do
+    proc{@m.save}.must_raise(Sequel::ValidationFailed)
   end
   
-  specify "should return nil if validations fail and raise_on_save_faiure is false" do
+  it "should return nil if validations fail and raise_on_save_faiure is false" do
     @m.raise_on_save_failure = false
-    @m.save.should == nil
+    @m.save.must_equal nil
   end
 end