sequel 4.22.0 → 4.23.0

data/spec/model/hooks_spec.rb

@@ -14,38 +14,38 @@ describe "Model#before_create && Model#after_create" do
     DB.reset
   end
   
-  specify "should be called around new record creation" do
+  it "should be called around new record creation" do
     @c.send(:define_method, :before_create){DB << "BLAH before"}
     @c.create(:x => 2)
-    DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
+    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
   end
 
-  specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
+  it ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_create){false}
-    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
-    proc{@c.load(:id => 2233).save}.should_not raise_error
+    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
+    @c.load(:id => 2233).save
   end
 
-  specify ".create should cancel the save and raise an error if before_create calls cancel_action and raise_on_save_failure is true" do
+  it ".create should cancel the save and raise an error if before_create calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_create){cancel_action 'not good'}
-    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed, 'not good')
-    DB.sqls.should == []
-    proc{@c.load(:id => 2233).save}.should_not raise_error
+    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed, 'not good')
+    DB.sqls.must_equal []
+    @c.load(:id => 2233).save
   end
 
-  specify ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
+  it ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_create){false}
     @c.raise_on_save_failure = false
-    @c.create(:x => 2).should == nil
-    DB.sqls.should == []
+    @c.create(:x => 2).must_equal nil
+    DB.sqls.must_equal []
   end
 
-  specify ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
+  it ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_create){cancel_action}
     @c.raise_on_save_failure = false
-    @c.create(:x => 2).should == nil
-    DB.sqls.should == []
+    @c.create(:x => 2).must_equal nil
+    DB.sqls.must_equal []
   end
 end
 
@@ -60,44 +60,44 @@ describe "Model#before_update && Model#after_update" do
     DB.reset
   end
   
-  specify "should be called around record update" do
+  it "should be called around record update" do
     @c.send(:define_method, :before_update){DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
+    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
-  specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
+  it "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_update){false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and raise an error if before_update calls cancel_action and raise_on_save_failure is true" do
+  it "#save should cancel the save and raise an error if before_update calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_update){cancel_action}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and raise an error if before_update returns false and raise_on_failure option is true" do
+  it "#save should cancel the save and raise an error if before_update returns false and raise_on_failure option is true" do
     @c.send(:define_method, :before_update){false}
     @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
+  it "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_update){false}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).save.must_equal nil
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and return nil if before_update calls cancel_action and raise_on_save_failure is false" do
+  it "#save should cancel the save and return nil if before_update calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_update){cancel_action}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).save.must_equal nil
+    DB.sqls.must_equal []
   end
 end
 
@@ -112,59 +112,59 @@ describe "Model#before_save && Model#after_save" do
     DB.reset
   end
   
-  specify "should be called around record update" do
+  it "should be called around record update" do
     @c.send(:define_method, :before_save){DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
+    DB.sqls.must_equal ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
   
-  specify "should be called around record creation" do
+  it "should be called around record creation" do
     @c.send(:define_method, :before_save){DB << "BLAH before"}
     @c.set_primary_key :x
     @c.unrestrict_primary_key
     @c.create(:x => 2)
-    DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
+    DB.sqls.must_equal ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
   end
 
-  specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
+  it "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_save){false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and raise an error if before_save returns false and raise_on_failure option is true" do
+  it "#save should cancel the save and raise an error if before_save returns false and raise_on_failure option is true" do
     @c.send(:define_method, :before_save){false}
     @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and raise an error if before_save calls cancel_action and raise_on_failure option is true" do
+  it "#save should cancel the save and raise an error if before_save calls cancel_action and raise_on_failure option is true" do
     @c.send(:define_method, :before_save){cancel_action}
     @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
+  it "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_save){false}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).save.must_equal nil
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and return nil if before_save calls cancel_action and raise_on_save_failure is false" do
+  it "#save should cancel the save and return nil if before_save calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_save){cancel_action}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).save.must_equal nil
+    DB.sqls.must_equal []
   end
 
-  specify "#save should have a raised exception reference the model instance" do
+  it "#save should have a raised exception reference the model instance" do
     @c.send(:define_method, :before_save){false}
-    proc{@c.create(:x => 2233)}.should raise_error(Sequel::HookFailed){|e| e.model.should == @c.load(:x=>2233)}
-    DB.sqls.should == []
+    proc{@c.create(:x => 2233)}.must_raise(Sequel::HookFailed){|e| e.model.must_equal @c.load(:x=>2233)}
+    DB.sqls.must_equal []
   end
 end
 
@@ -178,44 +178,44 @@ describe "Model#before_destroy && Model#after_destroy" do
     DB.reset
   end
   
-  specify "should be called around record destruction" do
+  it "should be called around record destruction" do
     @c.send(:define_method, :before_destroy){DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.destroy
-    DB.sqls.should == ['BLAH before', 'DELETE FROM items WHERE id = 2233', 'BLAH after']
+    DB.sqls.must_equal ['BLAH before', 'DELETE FROM items WHERE id = 2233', 'BLAH after']
   end
 
-  specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
+  it "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_destroy){false}
-    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#destroy should cancel the destroy and raise an error if before_destroy calls cancel_action and raise_on_save_failure is true" do
+  it "#destroy should cancel the destroy and raise an error if before_destroy calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_destroy){cancel_action; true}
-    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).destroy}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_failure option is true" do
+  it "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_failure option is true" do
     @c.send(:define_method, :before_destroy){false}
     @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).destroy(:raise_on_failure => true)}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).destroy(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
+  it "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_destroy){false}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).destroy.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).destroy.must_equal nil
+    DB.sqls.must_equal []
   end
 
-  specify "#destroy should cancel the destroy and return nil if before_destroy calls cancel_action and raise_on_save_failure is false" do
+  it "#destroy should cancel the destroy and return nil if before_destroy calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_destroy){cancel_action; true}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).destroy.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).destroy.must_equal nil
+    DB.sqls.must_equal []
   end
 end
 
@@ -231,67 +231,68 @@ describe "Model#before_validation && Model#after_validation" do
         errors.add(:id, 'not valid') unless id == 2233
       end
     end
+    DB.reset
   end
   
-  specify "should be called around validation" do
+  it "should be called around validation" do
     @c.send(:define_method, :before_validation){DB << "BLAH before"}
     m = @c.load(:id => 2233)
-    m.should be_valid
-    DB.sqls.should == ['BLAH before', 'BLAH after']
+    m.must_be :valid?
+    DB.sqls.must_equal ['BLAH before', 'BLAH after']
 
     m = @c.load(:id => 22)
-    m.should_not be_valid
-    DB.sqls.should == ['BLAH before', 'BLAH after']
+    m.wont_be :valid?
+    DB.sqls.must_equal ['BLAH before', 'BLAH after']
   end
 
-  specify "should be called when calling save" do
+  it "should be called when calling save" do
     @c.send(:define_method, :before_validation){DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
-    m.save.should == m
-    DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
+    m.save.must_equal m
+    DB.sqls.must_equal ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
 
     m = @c.load(:id => 22)
     m.raise_on_save_failure = false
-    m.save.should == nil
-    DB.sqls.should == ['BLAH before', 'BLAH after']
+    m.save.must_equal nil
+    DB.sqls.must_equal ['BLAH before', 'BLAH after']
   end
 
-  specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
+  it "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_validation){false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_failure option is true" do
+  it "#save should cancel the save and raise an error if before_validation returns false and raise_on_failure option is true" do
     @c.send(:define_method, :before_validation){false}
     @c.raise_on_save_failure = false
-    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
   
-  specify "#save should cancel the save and raise an error if before_validation calls cancel_action and raise_on_save_failure is true" do
+  it "#save should cancel the save and raise an error if before_validation calls cancel_action and raise_on_save_failure is true" do
     @c.send(:define_method, :before_validation){cancel_action}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
-    DB.sqls.should == []
+    proc{@c.load(:id => 2233).save}.must_raise(Sequel::HookFailed)
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
+  it "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_validation){false}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).save.must_equal nil
+    DB.sqls.must_equal []
   end
 
-  specify "#save should cancel the save and return nil if before_validation calls cancel_action and raise_on_save_failure is false" do
+  it "#save should cancel the save and return nil if before_validation calls cancel_action and raise_on_save_failure is false" do
     @c.send(:define_method, :before_validation){cancel_action}
     @c.raise_on_save_failure = false
-    @c.load(:id => 2233).save.should == nil
-    DB.sqls.should == []
+    @c.load(:id => 2233).save.must_equal nil
+    DB.sqls.must_equal []
   end
   
-  specify "#valid? should return false if before_validation returns false" do
+  it "#valid? should return false if before_validation returns false" do
     @c.send(:define_method, :before_validation){false}
-    @c.load(:id => 2233).valid?.should == false
+    @c.load(:id => 2233).valid?.must_equal false
   end
 end
 
@@ -303,7 +304,7 @@ describe "Model around filters" do
     DB.reset
   end
   
-  specify "around_create should be called around new record creation" do
+  it "around_create should be called around new record creation" do
     @c.class_eval do
       def around_create
         DB << 'ac_before'
@@ -312,10 +313,10 @@ describe "Model around filters" do
       end
     end
     @c.create(:x => 2)
-    DB.sqls.should == ['ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ['ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
-  specify "around_delete should be called around record destruction" do
+  it "around_delete should be called around record destruction" do
     @c.class_eval do
       def around_destroy
         DB << 'ad_before'
@@ -324,10 +325,10 @@ describe "Model around filters" do
       end
     end
     @c.load(:id=>1, :x => 2).destroy
-    DB.sqls.should == ['ad_before', 'DELETE FROM items WHERE id = 1', 'ad_after']
+    DB.sqls.must_equal ['ad_before', 'DELETE FROM items WHERE id = 1', 'ad_after']
   end
   
-  specify "around_update should be called around updating existing records" do
+  it "around_update should be called around updating existing records" do
     @c.class_eval do
       def around_update
         DB << 'au_before'
@@ -336,10 +337,10 @@ describe "Model around filters" do
       end
     end
     @c.load(:id=>1, :x => 2).save
-    DB.sqls.should == ['au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after']
+    DB.sqls.must_equal ['au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after']
   end
 
-  specify "around_save should be called around saving both new and existing records, around either after_create and after_update" do
+  it "around_save should be called around saving both new and existing records, around either after_create and after_update" do
     @c.class_eval do
       def around_update
         DB << 'au_before'
@@ -358,12 +359,12 @@ describe "Model around filters" do
       end
     end
     @c.create(:x => 2)
-    DB.sqls.should == ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.load(:id=>1, :x => 2).save
-    DB.sqls.should == ['as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after']
+    DB.sqls.must_equal ['as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after']
   end
 
-  specify "around_validation should be called around validating records" do
+  it "around_validation should be called around validating records" do
     @c.class_eval do
       def around_validation
         DB << 'av_before'
@@ -374,75 +375,75 @@ describe "Model around filters" do
         DB << 'validate'
       end
     end
-    @c.new(:x => 2).valid?.should == true
-    DB.sqls.should == [ 'av_before', 'validate', 'av_after' ]
+    @c.new(:x => 2).valid?.must_equal true
+    DB.sqls.must_equal [ 'av_before', 'validate', 'av_after' ]
   end
 
-  specify "around_validation should be able to catch validation errors and modify them" do
+  it "around_validation should be able to catch validation errors and modify them" do
     @c.class_eval do
       def validate
         errors.add(:x, 'foo')
       end
     end
-    @c.new(:x => 2).valid?.should == false
+    @c.new(:x => 2).valid?.must_equal false
     @c.class_eval do
       def around_validation
         super
         errors.clear
       end
     end
-    @c.new(:x => 2).valid?.should == true
+    @c.new(:x => 2).valid?.must_equal true
   end
 
-  specify "around_create that doesn't call super should raise a HookFailed" do
+  it "around_create that doesn't call super should raise a HookFailed" do
     @c.send(:define_method, :around_create){}
-    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
+    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
   end
   
-  specify "around_update that doesn't call super should raise a HookFailed" do
+  it "around_update that doesn't call super should raise a HookFailed" do
     @c.send(:define_method, :around_update){}
-    proc{@c.load(:x => 2).save}.should raise_error(Sequel::HookFailed)
+    proc{@c.load(:x => 2).save}.must_raise(Sequel::HookFailed)
   end
   
-  specify "around_save that doesn't call super should raise a HookFailed" do
+  it "around_save that doesn't call super should raise a HookFailed" do
     @c.send(:define_method, :around_save){}
-    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
-    proc{@c.load(:x => 2).save}.should raise_error(Sequel::HookFailed)
+    proc{@c.create(:x => 2)}.must_raise(Sequel::HookFailed)
+    proc{@c.load(:x => 2).save}.must_raise(Sequel::HookFailed)
   end
   
-  specify "around_destroy that doesn't call super should raise a HookFailed" do
+  it "around_destroy that doesn't call super should raise a HookFailed" do
     @c.send(:define_method, :around_destroy){}
-    proc{@c.load(:x => 2).destroy}.should raise_error(Sequel::HookFailed)
+    proc{@c.load(:x => 2).destroy}.must_raise(Sequel::HookFailed)
   end
   
-  specify "around_validation that doesn't call super should raise a HookFailed" do
+  it "around_validation that doesn't call super should raise a HookFailed" do
     @c.send(:define_method, :around_validation){}
-    proc{@c.new.save}.should raise_error(Sequel::HookFailed)
+    proc{@c.new.save}.must_raise(Sequel::HookFailed)
   end
 
-  specify "around_validation that doesn't call super should have valid? return false" do
+  it "around_validation that doesn't call super should have valid? return false" do
     @c.send(:define_method, :around_validation){}
-    @c.new.valid?.should == false
+    @c.new.valid?.must_equal false
   end
 
-  specify "around_* that doesn't call super should return nil if raise_on_save_failure is false" do
+  it "around_* that doesn't call super should return nil if raise_on_save_failure is false" do
     @c.raise_on_save_failure = false
 
     o = @c.load(:id => 1)
     def o.around_save() end
-    o.save.should == nil
+    o.save.must_equal nil
 
     o = @c.load(:id => 1)
     def o.around_update() end
-    o.save.should == nil
+    o.save.must_equal nil
 
     o = @c.new
     def o.around_create() end
-    o.save.should == nil
+    o.save.must_equal nil
 
     o = @c.new
     def o.around_validation() end
-    o.save.should == nil
+    o.save.must_equal nil
   end
 end
 
@@ -479,125 +480,125 @@ describe "Model#after_commit and #after_rollback" do
     @db.sqls
   end
 
-  specify "should call after_commit for save after the transaction commits if it commits" do
+  it "should call after_commit for save after the transaction commits if it commits" do
     @o.save
-    @db.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac']
+    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT', 'ac']
   end
 
-  specify "should call after_rollback for save after the transaction rolls back if it rolls back" do
+  it "should call after_rollback for save after the transaction rolls back if it rolls back" do
     @o.rb = true
     @o.save
-    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar']
+    @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK', 'ar']
   end
 
-  specify "should have after_commit respect any surrounding transactions" do
+  it "should have after_commit respect any surrounding transactions" do
     @db.transaction do
       @o.save
     end
-    @db.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac']
+    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT', 'ac']
   end
 
-  specify "should have after_rollback respect any surrounding transactions" do
+  it "should have after_rollback respect any surrounding transactions" do
     @db.transaction do
       @o.rb = true
       @o.save
     end
-    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar']
+    @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK', 'ar']
   end
 
-  specify "should have after_commit work with surrounding transactions and sharding" do
+  it "should have after_commit work with surrounding transactions and sharding" do
     @db.transaction(:server=>:test) do
       @o.save
     end
-    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'as', 'COMMIT', 'ac', 'COMMIT -- test']
+    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'as', 'COMMIT', 'ac', 'COMMIT -- test']
   end
 
-  specify "should have after_rollback work with surrounding transactions and sharding" do
+  it "should have after_rollback work with surrounding transactions and sharding" do
     @db.transaction(:server=>:test) do
       @o.rb = true
       @o.save
     end
-    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'as', 'ROLLBACK', 'ar', 'COMMIT -- test']
+    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'as', 'ROLLBACK', 'ar', 'COMMIT -- test']
   end
 
-  specify "should call after_destroy_commit for destroy after the transaction commits if it commits" do
+  it "should call after_destroy_commit for destroy after the transaction commits if it commits" do
     @o.destroy
-    @db.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc']
+    @db.sqls.must_equal ['BEGIN', 'ad', 'COMMIT', 'adc']
   end
 
-  specify "should call after_destroy_rollback for destroy after the transaction rolls back if it rolls back" do
+  it "should call after_destroy_rollback for destroy after the transaction rolls back if it rolls back" do
     @o.rb = true
     @o.destroy
-    @db.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr']
+    @db.sqls.must_equal ['BEGIN', 'ad', 'ROLLBACK', 'adr']
   end
 
-  specify "should have after_destroy_commit respect any surrounding transactions" do
+  it "should have after_destroy_commit respect any surrounding transactions" do
     @db.transaction do
       @o.destroy
     end
-    @db.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc']
+    @db.sqls.must_equal ['BEGIN', 'ad', 'COMMIT', 'adc']
   end
 
-  specify "should have after_destroy_rollback respect any surrounding transactions" do
+  it "should have after_destroy_rollback respect any surrounding transactions" do
     @db.transaction do
       @o.rb = true
       @o.destroy
     end
-    @db.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr']
+    @db.sqls.must_equal ['BEGIN', 'ad', 'ROLLBACK', 'adr']
   end
 
-  specify "should have after_destroy commit work with surrounding transactions and sharding" do
+  it "should have after_destroy commit work with surrounding transactions and sharding" do
     @db.transaction(:server=>:test) do
       @o.destroy
     end
-    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'ad', 'COMMIT', 'adc', 'COMMIT -- test']
+    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'ad', 'COMMIT', 'adc', 'COMMIT -- test']
   end
 
-  specify "should have after_destroy_rollback work with surrounding transactions and sharding" do
+  it "should have after_destroy_rollback work with surrounding transactions and sharding" do
     @db.transaction(:server=>:test) do
       @o.rb = true
       @o.destroy
     end
-    @db.sqls.should == ['BEGIN -- test', 'BEGIN', 'ad', 'ROLLBACK', 'adr', 'COMMIT -- test']
+    @db.sqls.must_equal ['BEGIN -- test', 'BEGIN', 'ad', 'ROLLBACK', 'adr', 'COMMIT -- test']
   end
 
-  specify "should not call after_commit if use_after_commit_rollback is false" do
+  it "should not call after_commit if use_after_commit_rollback is false" do
     @o.use_after_commit_rollback = false
     @o.save
-    @db.sqls.should == ['BEGIN', 'as', 'COMMIT']
+    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
   end
 
-  specify "should not call after_rollback if use_after_commit_rollback is false" do
+  it "should not call after_rollback if use_after_commit_rollback is false" do
     @o.use_after_commit_rollback = false
     @o.rb = true
     @o.save
-    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK']
+    @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK']
   end
 
-  specify "should not call after_destroy_commit if use_after_commit_rollback is false" do
+  it "should not call after_destroy_commit if use_after_commit_rollback is false" do
     @o.use_after_commit_rollback = false
     @o.destroy
-    @db.sqls.should == ['BEGIN', 'ad', 'COMMIT']
+    @db.sqls.must_equal ['BEGIN', 'ad', 'COMMIT']
   end
 
-  specify "should not call after_destroy_rollback for save if use_after_commit_rollback is false" do
+  it "should not call after_destroy_rollback for save if use_after_commit_rollback is false" do
     @o.use_after_commit_rollback = false
     @o.rb = true
     @o.destroy
-    @db.sqls.should == ['BEGIN', 'ad', 'ROLLBACK']
+    @db.sqls.must_equal ['BEGIN', 'ad', 'ROLLBACK']
   end
 
-  specify "should handle use_after_commit_rollback at the class level" do
+  it "should handle use_after_commit_rollback at the class level" do
     @m.use_after_commit_rollback = false
     @o.save
-    @db.sqls.should == ['BEGIN', 'as', 'COMMIT']
+    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
   end
 
-  specify "should handle use_after_commit_rollback when subclassing" do
+  it "should handle use_after_commit_rollback when subclassing" do
     @m.use_after_commit_rollback = false
     o = Class.new(@m).load({})
     @db.sqls
     o.save
-    @db.sqls.should == ['BEGIN', 'as', 'COMMIT']
+    @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
   end
 end