sequel 4.22.0 → 4.23.0

data/spec/extensions/connection_validator_spec.rb

@@ -1,105 +1,107 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-shared_examples_for "Sequel::ConnectionValidator" do  
-  before do
-    @db.extend(Module.new do
-      def disconnect_connection(conn)
-        @sqls << 'disconnect'
-      end
-      def valid_connection?(conn)
-        super
-        conn.valid
-      end
-      def connect(server)
-        conn = super
-        conn.extend(Module.new do
-          attr_accessor :valid
-        end)
-        conn.valid = true
-        conn
-      end
-    end)
-    @db.extension(:connection_validator)
-  end
+connection_validator_specs = shared_description do
+  describe "connection validator" do
+    before do
+      @db.extend(Module.new do
+        def disconnect_connection(conn)
+          @sqls << 'disconnect'
+        end
+        def valid_connection?(conn)
+          super
+          conn.valid
+        end
+        def connect(server)
+          conn = super
+          conn.extend(Module.new do
+            attr_accessor :valid
+          end)
+          conn.valid = true
+          conn
+        end
+      end)
+      @db.extension(:connection_validator)
+    end
 
-  it "should still allow new connections" do
-    @db.synchronize{|c| c}.should be_a_kind_of(Sequel::Mock::Connection)
-  end
+    it "should still allow new connections" do
+      @db.synchronize{|c| c}.must_be_kind_of(Sequel::Mock::Connection)
+    end
 
-  it "should only validate if connection idle longer than timeout" do
-    c1 = @db.synchronize{|c| c}
-    @db.sqls.should == []
-    @db.synchronize{|c| c}.should equal(c1)
-    @db.sqls.should == []
-    @db.pool.connection_validation_timeout = -1
-    @db.synchronize{|c| c}.should equal(c1)
-    @db.sqls.should == ['SELECT NULL']
-    @db.pool.connection_validation_timeout = 1
-    @db.synchronize{|c| c}.should equal(c1)
-    @db.sqls.should == []
-    @db.synchronize{|c| c}.should equal(c1)
-    @db.sqls.should == []
-  end
+    it "should only validate if connection idle longer than timeout" do
+      c1 = @db.synchronize{|c| c}
+      @db.sqls.must_equal []
+      @db.synchronize{|c| c}.must_be_same_as(c1)
+      @db.sqls.must_equal []
+      @db.pool.connection_validation_timeout = -1
+      @db.synchronize{|c| c}.must_be_same_as(c1)
+      @db.sqls.must_equal ['SELECT NULL']
+      @db.pool.connection_validation_timeout = 1
+      @db.synchronize{|c| c}.must_be_same_as(c1)
+      @db.sqls.must_equal []
+      @db.synchronize{|c| c}.must_be_same_as(c1)
+      @db.sqls.must_equal []
+    end
 
-  it "should disconnect connection if not valid" do
-    c1 = @db.synchronize{|c| c}
-    @db.sqls.should == []
-    c1.valid = false
-    @db.pool.connection_validation_timeout = -1
-    c2 = @db.synchronize{|c| c}
-    @db.sqls.should == ['SELECT NULL', 'disconnect']
-    c2.should_not equal(c1)
-  end
+    it "should disconnect connection if not valid" do
+      c1 = @db.synchronize{|c| c}
+      @db.sqls.must_equal []
+      c1.valid = false
+      @db.pool.connection_validation_timeout = -1
+      c2 = @db.synchronize{|c| c}
+      @db.sqls.must_equal ['SELECT NULL', 'disconnect']
+      c2.wont_be_same_as(c1)
+    end
 
-  it "should disconnect multiple connections repeatedly if they are not valid" do
-    q, q1 = Queue.new, Queue.new
-    c1 = nil
-    c2 = nil
-    @db.pool.connection_validation_timeout = -1
-    @db.synchronize do |c|
-      Thread.new do
-        @db.synchronize do |cc|
-          c2 = cc
+    it "should disconnect multiple connections repeatedly if they are not valid" do
+      q, q1 = Queue.new, Queue.new
+      c1 = nil
+      c2 = nil
+      @db.pool.connection_validation_timeout = -1
+      @db.synchronize do |c|
+        Thread.new do
+          @db.synchronize do |cc|
+            c2 = cc
+          end
+          q1.pop
+          q.push nil
         end
-        q1.pop
-        q.push nil
+        q1.push nil
+        q.pop
+        c1 = c
       end
-      q1.push nil
-      q.pop
-      c1 = c
+      c1.valid = false
+      c2.valid = false
+
+      c3 = @db.synchronize{|c| c}
+      @db.sqls.must_equal ['SELECT NULL', 'disconnect', 'SELECT NULL', 'disconnect']
+      c3.wont_be_same_as(c1)
+      c3.wont_be_same_as(c2)
     end
-    c1.valid = false
-    c2.valid = false
 
-    c3 = @db.synchronize{|c| c}
-    @db.sqls.should == ['SELECT NULL', 'disconnect', 'SELECT NULL', 'disconnect']
-    c3.should_not equal(c1)
-    c3.should_not equal(c2)
-  end
+    it "should not leak connection references" do
+      c1 = @db.synchronize do |c|
+        @db.pool.instance_variable_get(:@connection_timestamps).must_equal({})
+        c
+      end
+      @db.pool.instance_variable_get(:@connection_timestamps).must_include(c1)
 
-  it "should not leak connection references" do
-    c1 = @db.synchronize do |c|
-      @db.pool.instance_variable_get(:@connection_timestamps).should == {}
-      c
+      c1.valid = false
+      @db.pool.connection_validation_timeout = -1
+      c2 = @db.synchronize do |c|
+        @db.pool.instance_variable_get(:@connection_timestamps).must_equal({})
+        c
+      end
+      c2.wont_be_same_as(c1)
+      @db.pool.instance_variable_get(:@connection_timestamps).wont_include(c1)
+      @db.pool.instance_variable_get(:@connection_timestamps).must_include(c2)
     end
-    @db.pool.instance_variable_get(:@connection_timestamps).should have_key(c1)
 
-    c1.valid = false
-    @db.pool.connection_validation_timeout = -1
-    c2 = @db.synchronize do |c|
-      @db.pool.instance_variable_get(:@connection_timestamps).should == {}
-      c
+    it "should handle case where determining validity requires a connection" do
+      @db.meta_def(:valid_connection?){|c| synchronize{}; true}
+      @db.pool.connection_validation_timeout = -1
+      c1 = @db.synchronize{|c| c}
+      @db.synchronize{|c| c}.must_be_same_as(c1)
     end
-    c2.should_not equal(c1)
-    @db.pool.instance_variable_get(:@connection_timestamps).should_not have_key(c1)
-    @db.pool.instance_variable_get(:@connection_timestamps).should have_key(c2)
-  end
-
-  it "should handle case where determining validity requires a connection" do
-    @db.meta_def(:valid_connection?){|c| synchronize{}; true}
-    @db.pool.connection_validation_timeout = -1
-    c1 = @db.synchronize{|c| c}
-    @db.synchronize{|c| c}.should equal(c1)
   end
 end
 
@@ -107,12 +109,12 @@ describe "Sequel::ConnectionValidator with threaded pool" do
   before do
     @db = Sequel.mock
   end
-  it_should_behave_like "Sequel::ConnectionValidator"
+  include connection_validator_specs
 end
 describe "Sequel::ConnectionValidator with sharded threaded pool" do
   before do
     @db = Sequel.mock(:servers=>{})
   end
-  it_should_behave_like "Sequel::ConnectionValidator"
+  include connection_validator_specs
 end
 

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -25,49 +25,49 @@ describe "Sequel::Plugins::ConstraintValidations" do
   end
 
   it "should load the validation_helpers plugin into the class" do
-    model_class.new.should respond_to(:validates_presence)
+    model_class.new.must_respond_to(:validates_presence)
   end
 
   it "should parse constraint validations when loading plugin" do
     @c = model_class
-    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
-    @db.constraint_validations.should == {"items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}]}
-    @c.constraint_validations.should == [[:validates_presence, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
+    @db.constraint_validations.must_equal("items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}])
+    @c.constraint_validations.must_equal [[:validates_presence, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should parse constraint validations with a custom constraint validations table" do
     c = Class.new(Sequel::Model(@db[:items]))
     @db.sqls
     c.plugin :constraint_validations, :constraint_validations_table=>:foo
-    @db.sqls.should == ["SELECT * FROM foo"]
-    @db.constraint_validations.should == {"items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}]}
-    c.constraint_validations.should == [[:validates_presence, :name]]
-    c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal ["SELECT * FROM foo"]
+    @db.constraint_validations.must_equal("items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}])
+    c.constraint_validations.must_equal [[:validates_presence, :name]]
+    c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should populate constraint_validations when subclassing" do
     c = Class.new(Sequel::Model(@db))
     c.plugin :constraint_validations
-    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
     sc = Class.new(c)
     sc.set_dataset @ds
-    @db.sqls.should == []
-    sc.constraint_validations.should == [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal []
+    sc.constraint_validations.must_equal [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should handle plugin being loaded in subclass when superclass uses a custom constraint validations table" do
     c = Class.new(Sequel::Model(@db))
     c.plugin :constraint_validations, :constraint_validations_table=>:foo
-    @db.sqls.should == ["SELECT * FROM foo"]
+    @db.sqls.must_equal ["SELECT * FROM foo"]
     sc = Class.new(c)
     sc.plugin :constraint_validations
-    sc.constraint_validations_table.should == :foo
+    sc.constraint_validations_table.must_equal :foo
     sc.set_dataset @ds
-    @db.sqls.should == []
-    sc.constraint_validations.should == [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal []
+    sc.constraint_validations.must_equal [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should populate constraint_validations when changing the model's dataset" do
@@ -75,166 +75,166 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c.columns :name
     @db.sqls
     c.plugin :constraint_validations
-    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
     sc = Class.new(c)
     sc.set_dataset @ds
-    @db.sqls.should == []
-    sc.constraint_validations.should == [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal []
+    sc.constraint_validations.must_equal [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should reparse constraint validations when changing the model's database" do
     c = Class.new(Sequel::Model(@ds2))
     c.plugin :constraint_validations
-    @ds2.db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    @ds2.db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
     sc = Class.new(c)
     sc.set_dataset @ds
-    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
-    sc.constraint_validations.should == [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
+    sc.constraint_validations.must_equal [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should reparse constraint validations when changing the model's database with a custom constraint validations table" do
     c = Class.new(Sequel::Model(@ds2))
     c.plugin :constraint_validations, :constraint_validations_table=>:foo
-    @ds2.db.sqls.should == ["SELECT * FROM foo"]
+    @ds2.db.sqls.must_equal ["SELECT * FROM foo"]
     sc = Class.new(c)
     sc.set_dataset @ds
-    @db.sqls.should == ["SELECT * FROM foo"]
-    sc.constraint_validations.should == [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    @db.sqls.must_equal ["SELECT * FROM foo"]
+    sc.constraint_validations.must_equal [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should correctly retrieve :message option from constraint validations table" do
-    model_class(:message=>'foo').constraint_validations.should == [[:validates_presence, :name, {:message=>'foo'}]]
-    @c.constraint_validation_reflections.should == {:name=>[[:presence, {:message=>'foo'}]]}
+    model_class(:message=>'foo').constraint_validations.must_equal [[:validates_presence, :name, {:message=>'foo'}]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {:message=>'foo'}]])
   end
 
   it "should correctly retrieve :allow_nil option from constraint validations table" do
-    model_class(:allow_nil=>true).constraint_validations.should == [[:validates_presence, :name, {:allow_nil=>true}]]
-    @c.constraint_validation_reflections.should == {:name=>[[:presence, {:allow_nil=>true}]]}
+    model_class(:allow_nil=>true).constraint_validations.must_equal [[:validates_presence, :name, {:allow_nil=>true}]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {:allow_nil=>true}]])
   end
 
   it "should handle presence validation" do
-    model_class(:validation_type=>'presence').constraint_validations.should == [[:validates_presence, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    model_class(:validation_type=>'presence').constraint_validations.must_equal [[:validates_presence, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should handle exact_length validation" do
-    model_class(:validation_type=>'exact_length', :argument=>'5').constraint_validations.should == [[:validates_exact_length, 5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:exact_length, {:argument=>5}]]}
+    model_class(:validation_type=>'exact_length', :argument=>'5').constraint_validations.must_equal [[:validates_exact_length, 5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:exact_length, {:argument=>5}]])
   end
 
   it "should handle min_length validation" do
-    model_class(:validation_type=>'min_length', :argument=>'5').constraint_validations.should == [[:validates_min_length, 5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:min_length, {:argument=>5}]]}
+    model_class(:validation_type=>'min_length', :argument=>'5').constraint_validations.must_equal [[:validates_min_length, 5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:min_length, {:argument=>5}]])
   end
 
   it "should handle max_length validation" do
-    model_class(:validation_type=>'max_length', :argument=>'5').constraint_validations.should == [[:validates_max_length, 5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:max_length, {:argument=>5}]]}
+    model_class(:validation_type=>'max_length', :argument=>'5').constraint_validations.must_equal [[:validates_max_length, 5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:max_length, {:argument=>5}]])
   end
 
   it "should handle length_range validation" do
-    model_class(:validation_type=>'length_range', :argument=>'3..5').constraint_validations.should == [[:validates_length_range, 3..5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:length_range, {:argument=>3..5}]]}
+    model_class(:validation_type=>'length_range', :argument=>'3..5').constraint_validations.must_equal [[:validates_length_range, 3..5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:length_range, {:argument=>3..5}]])
   end
 
   it "should handle length_range validation with an exclusive end" do
-    model_class(:validation_type=>'length_range', :argument=>'3...5').constraint_validations.should == [[:validates_length_range, 3...5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:length_range, {:argument=>3...5}]]}
+    model_class(:validation_type=>'length_range', :argument=>'3...5').constraint_validations.must_equal [[:validates_length_range, 3...5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:length_range, {:argument=>3...5}]])
   end
 
   it "should handle format validation" do
-    model_class(:validation_type=>'format', :argument=>'^foo.*').constraint_validations.should == [[:validates_format, /^foo.*/, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/^foo.*/}]]}
+    model_class(:validation_type=>'format', :argument=>'^foo.*').constraint_validations.must_equal [[:validates_format, /^foo.*/, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/^foo.*/}]])
   end
 
   it "should handle format validation with case insensitive format" do
-    model_class(:validation_type=>'iformat', :argument=>'^foo.*').constraint_validations.should == [[:validates_format, /^foo.*/i, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/^foo.*/i}]]}
+    model_class(:validation_type=>'iformat', :argument=>'^foo.*').constraint_validations.must_equal [[:validates_format, /^foo.*/i, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/^foo.*/i}]])
   end
 
   it "should handle includes validation with array of strings" do
-    model_class(:validation_type=>'includes_str_array', :argument=>'a,b,c').constraint_validations.should == [[:validates_includes, %w'a b c', :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:includes, {:argument=>%w'a b c'}]]}
+    model_class(:validation_type=>'includes_str_array', :argument=>'a,b,c').constraint_validations.must_equal [[:validates_includes, %w'a b c', :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>%w'a b c'}]])
   end
 
   it "should handle includes validation with array of integers" do
-    model_class(:validation_type=>'includes_int_array', :argument=>'1,2,3').constraint_validations.should == [[:validates_includes, [1, 2, 3], :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:includes, {:argument=>[1, 2, 3]}]]}
+    model_class(:validation_type=>'includes_int_array', :argument=>'1,2,3').constraint_validations.must_equal [[:validates_includes, [1, 2, 3], :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>[1, 2, 3]}]])
   end
 
   it "should handle includes validation with inclusive range of integers" do
-    model_class(:validation_type=>'includes_int_range', :argument=>'3..5').constraint_validations.should == [[:validates_includes, 3..5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:includes, {:argument=>3..5}]]}
+    model_class(:validation_type=>'includes_int_range', :argument=>'3..5').constraint_validations.must_equal [[:validates_includes, 3..5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>3..5}]])
   end
 
   it "should handle includes validation with exclusive range of integers" do
-    model_class(:validation_type=>'includes_int_range', :argument=>'3...5').constraint_validations.should == [[:validates_includes, 3...5, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:includes, {:argument=>3...5}]]}
+    model_class(:validation_type=>'includes_int_range', :argument=>'3...5').constraint_validations.must_equal [[:validates_includes, 3...5, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>3...5}]])
   end
 
   it "should handle like validation" do
-    model_class(:validation_type=>'like', :argument=>'foo').constraint_validations.should == [[:validates_format, /\Afoo\z/, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\Afoo\z/}]]}
+    model_class(:validation_type=>'like', :argument=>'foo').constraint_validations.must_equal [[:validates_format, /\Afoo\z/, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Afoo\z/}]])
   end
 
   it "should handle ilike validation" do
-    model_class(:validation_type=>'ilike', :argument=>'foo').constraint_validations.should == [[:validates_format, /\Afoo\z/i, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\Afoo\z/i}]]}
+    model_class(:validation_type=>'ilike', :argument=>'foo').constraint_validations.must_equal [[:validates_format, /\Afoo\z/i, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Afoo\z/i}]])
   end
 
   it "should handle like validation with % metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'%foo%').constraint_validations.should == [[:validates_format, /\A.*foo.*\z/, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\A.*foo.*\z/}]]}
+    model_class(:validation_type=>'like', :argument=>'%foo%').constraint_validations.must_equal [[:validates_format, /\A.*foo.*\z/, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A.*foo.*\z/}]])
   end
 
   it "should handle like validation with %% metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'%%foo%%').constraint_validations.should == [[:validates_format, /\A%foo%\z/, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\A%foo%\z/}]]}
+    model_class(:validation_type=>'like', :argument=>'%%foo%%').constraint_validations.must_equal [[:validates_format, /\A%foo%\z/, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A%foo%\z/}]])
   end
 
   it "should handle like validation with _ metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'f_o').constraint_validations.should == [[:validates_format, /\Af.o\z/, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\Af.o\z/}]]}
+    model_class(:validation_type=>'like', :argument=>'f_o').constraint_validations.must_equal [[:validates_format, /\Af.o\z/, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Af.o\z/}]])
   end
 
   it "should handle like validation with Regexp metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'\wfoo\d').constraint_validations.should == [[:validates_format, /\A\\wfoo\\d\z/, :name]]
-    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\A\\wfoo\\d\z/}]]}
+    model_class(:validation_type=>'like', :argument=>'\wfoo\d').constraint_validations.must_equal [[:validates_format, /\A\\wfoo\\d\z/, :name]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A\\wfoo\\d\z/}]])
   end
 
   it "should handle unique validation" do
-    model_class(:validation_type=>'unique').constraint_validations.should == [[:validates_unique, [:name]]]
-    @c.constraint_validation_reflections.should == {:name=>[[:unique, {}]]}
+    model_class(:validation_type=>'unique').constraint_validations.must_equal [[:validates_unique, [:name]]]
+    @c.constraint_validation_reflections.must_equal(:name=>[[:unique, {}]])
   end
 
   it "should handle unique validation with multiple columns" do
-    model_class(:validation_type=>'unique', :column=>'name,id').constraint_validations.should == [[:validates_unique, [:name, :id]]]
-    @c.constraint_validation_reflections.should == {[:name, :id]=>[[:unique, {}]]}
+    model_class(:validation_type=>'unique', :column=>'name,id').constraint_validations.must_equal [[:validates_unique, [:name, :id]]]
+    @c.constraint_validation_reflections.must_equal([:name, :id]=>[[:unique, {}]])
   end
 
   it "should handle :validation_options" do
     c = model_class(:validation_type=>'unique', :column=>'name')
     c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad'}}
-    c.constraint_validations.should == [[:validates_unique, [:name], {:message=>'is bad'}]]
-    c.constraint_validation_reflections.should == {:name=>[[:unique, {:message=>'is bad'}]]}
+    c.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad'}]]
+    c.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad'}]])
     c.dataset._fetch = {:count=>1}
     o = c.new(:name=>'a')
-    o.valid?.should == false
-    o.errors.full_messages.should == ['name is bad']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['name is bad']
   end
 
   it "should handle :validation_options merging with constraint validation options" do
     c = model_class(:validation_type=>'unique', :column=>'name', :allow_nil=>true)
     c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad'}}
-    c.constraint_validations.should == [[:validates_unique, [:name], {:message=>'is bad', :allow_nil=>true}]]
-    c.constraint_validation_reflections.should == {:name=>[[:unique, {:message=>'is bad', :allow_nil=>true}]]}
+    c.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad', :allow_nil=>true}]]
+    c.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad', :allow_nil=>true}]])
     c.dataset._fetch = {:count=>1}
     o = c.new(:name=>'a')
-    o.valid?.should == false
-    o.errors.full_messages.should == ['name is bad']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['name is bad']
   end
 
   it "should handle :validation_options merging with subclasses" do
@@ -242,33 +242,33 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad', :allow_nil=>true}}
     sc = Class.new(c)
     sc.plugin :constraint_validations, :validation_options=>{:unique=>{:allow_missing=>true, :allow_nil=>false}}
-    sc.constraint_validations.should == [[:validates_unique, [:name], {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]
-    sc.constraint_validation_reflections.should == {:name=>[[:unique, {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]}
+    sc.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]
+    sc.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]])
     sc.dataset._fetch = {:count=>1}
     o = sc.new(:name=>'a')
-    o.valid?.should == false
-    o.errors.full_messages.should == ['name is bad']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['name is bad']
   end
 
   it "should used parsed constraint validations when validating" do
     o = model_class.new
-    o.valid?.should == false
-    o.errors.full_messages.should == ['name is not present']
+    o.valid?.must_equal false
+    o.errors.full_messages.must_equal ['name is not present']
   end
 
   it "should handle a table name specified as SQL::Identifier" do
     set_fetch(:table=>'sch__items')
     c = Class.new(Sequel::Model(@db[Sequel.identifier(:sch__items)]))
     c.plugin :constraint_validations
-    c.constraint_validations.should == [[:validates_presence, :name]]
-    c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    c.constraint_validations.must_equal [[:validates_presence, :name]]
+    c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 
   it "should handle a table name specified as SQL::QualifiedIdentifier" do
     set_fetch(:table=>'sch.items')
     c = Class.new(Sequel::Model(@db[Sequel.qualify(:sch, :items)]))
     c.plugin :constraint_validations
-    c.constraint_validations.should == [[:validates_presence, :name]]
-    c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
+    c.constraint_validations.must_equal [[:validates_presence, :name]]
+    c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
   end
 end