sequel 4.22.0 → 4.23.0

data/spec/integration/type_test.rb

@@ -10,75 +10,75 @@ describe "Supported types" do
     DB.drop_table?(:items)
   end
 
-  specify "should support casting correctly" do
+  it "should support casting correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 1)
-    ds.select(Sequel.cast(:number, String).as(:n)).map(:n).should == %w'1'
+    ds.select(Sequel.cast(:number, String).as(:n)).map(:n).must_equal %w'1'
     ds = create_items_table_with_column(:name, String)
     ds.insert(:name=> '1')
-    ds.select(Sequel.cast(:name, Integer).as(:n)).map(:n).should == [1]
+    ds.select(Sequel.cast(:name, Integer).as(:n)).map(:n).must_equal [1]
   end
 
-  specify "should support NULL correctly" do
+  it "should support NULL correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => nil)
-    ds.all.should == [{:number=>nil}]
+    ds.all.must_equal [{:number=>nil}]
   end
 
-  specify "should support generic integer type" do
+  it "should support generic integer type" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 2)
-    ds.all.should == [{:number=>2}]
+    ds.all.must_equal [{:number=>2}]
   end
   
-  specify "should support generic fixnum type" do
+  it "should support generic fixnum type" do
     ds = create_items_table_with_column(:number, Fixnum)
     ds.insert(:number => 2)
-    ds.all.should == [{:number=>2}]
+    ds.all.must_equal [{:number=>2}]
   end
   
-  specify "should support generic bignum type" do
+  it "should support generic bignum type" do
     ds = create_items_table_with_column(:number, Bignum)
     ds.insert(:number => 2**34)
-    ds.all.should == [{:number=>2**34}]
+    ds.all.must_equal [{:number=>2**34}]
   end
   
   cspecify "should support generic float type", [:swift, :sqlite] do
     ds = create_items_table_with_column(:number, Float)
     ds.insert(:number => 2.1)
-    ds.all.should == [{:number=>2.1}]
+    ds.all.must_equal [{:number=>2.1}]
   end
   
   cspecify "should support generic numeric type", [:odbc, :mssql], [:swift, :sqlite] do
     ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
     ds.insert(:number => BigDecimal.new('2.123456789'))
-    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+    ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
     ds = create_items_table_with_column(:number, BigDecimal, :size=>[15, 10])
     ds.insert(:number => BigDecimal.new('2.123456789'))
-    ds.all.should == [{:number=>BigDecimal.new('2.123456789')}]
+    ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
   end
 
-  specify "should support generic string type" do
+  it "should support generic string type" do
     ds = create_items_table_with_column(:name, String)
     ds.insert(:name => 'Test User')
-    ds.all.should == [{:name=>'Test User'}]
+    ds.all.must_equal [{:name=>'Test User'}]
   end
   
-  specify "should support generic text type" do
+  it "should support generic text type" do
     ds = create_items_table_with_column(:name, String, :text=>true)
     ds.insert(:name => 'Test User'*100)
-    ds.all.should == [{:name=>'Test User'*100}]
+    ds.all.must_equal [{:name=>'Test User'*100}]
 
     ds.update(:name=>ds.get(:name))
-    ds.all.should == [{:name=>'Test User'*100}]
+    ds.all.must_equal [{:name=>'Test User'*100}]
   end
   
   cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], [:tinytds], [:jdbc, :mssql], :oracle do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
-    ds.first[:dat].should be_a_kind_of(Date)
-    ds.first[:dat].to_s.should == d.to_s
+    ds.first[:dat].must_be_kind_of(Date)
+    ds.first[:dat].to_s.must_equal d.to_s
   end
   
   cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle do
@@ -86,48 +86,48 @@ describe "Supported types" do
     t = Sequel::SQLTime.now
     ds.insert(:tim => t)
     v = ds.first[:tim]
-    ds.literal(v).should == ds.literal(t)
-    v.should be_a_kind_of(Sequel::SQLTime)
+    ds.literal(v).must_equal ds.literal(t)
+    v.must_be_kind_of(Sequel::SQLTime)
     ds.delete
     ds.insert(:tim => v)
     v2 = ds.first[:tim]
-    ds.literal(v2).should == ds.literal(t)
-    v2.should be_a_kind_of(Sequel::SQLTime)
+    ds.literal(v2).must_equal ds.literal(t)
+    v2.must_be_kind_of(Sequel::SQLTime)
   end
   
   cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
     ds = create_items_table_with_column(:tim, DateTime)
     t = DateTime.now
     ds.insert(:tim => t)
-    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').must_equal t.strftime('%Y%m%d%H%M%S')
     ds = create_items_table_with_column(:tim, Time)
     t = Time.now
     ds.insert(:tim => t)
-    ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
+    ds.first[:tim].strftime('%Y%m%d%H%M%S').must_equal t.strftime('%Y%m%d%H%M%S')
   end
   
   cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:tinytds] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name =>Sequel.blob("a\0"*300))
-    ds.all.should == [{:name=>Sequel.blob("a\0"*300)}]
-    ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
+    ds.all.must_equal [{:name=>Sequel.blob("a\0"*300)}]
+    ds.first[:name].must_be_kind_of(::Sequel::SQL::Blob)
   end
   
   cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
-    ds.all.should == [{:number=>true}]
+    ds.all.must_equal [{:number=>true}]
     ds = create_items_table_with_column(:number, FalseClass)
     ds.insert(:number => true)
-    ds.all.should == [{:number=>true}]
+    ds.all.must_equal [{:number=>true}]
   end
   
   cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass, :default=>true)
     ds.insert
-    ds.all.should == [{:number=>true}]
+    ds.all.must_equal [{:number=>true}]
     ds = create_items_table_with_column(:number, FalseClass, :default=>false)
     ds.insert
-    ds.all.should == [{:number=>false}]
+    ds.all.must_equal [{:number=>false}]
   end
 end

data/spec/model/association_reflection_spec.rb

@@ -11,14 +11,14 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
 
   it "should use the :class value if present" do
     @c.many_to_one :c, :class=>ParParent
-    @c.association_reflection(:c).keys.should include(:class)
-    @c.association_reflection(:c).associated_class.should == ParParent
+    @c.association_reflection(:c).keys.must_include(:class)
+    @c.association_reflection(:c).associated_class.must_equal ParParent
   end
 
   it "should figure out the class if the :class value is not present" do
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).keys.should_not include(:class)
-    @c.association_reflection(:c).associated_class.should == ParParent
+    @c.association_reflection(:c).keys.wont_include(:class)
+    @c.association_reflection(:c).associated_class.must_equal ParParent
   end
 end
 
@@ -33,14 +33,23 @@ describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
 
   it "should use the :primary_key value if present" do
     @c.many_to_one :c, :class=>ParParent, :primary_key=>:blah__blah
-    @c.association_reflection(:c).keys.should include(:primary_key)
-    @c.association_reflection(:c).primary_key.should == :blah__blah
+    @c.association_reflection(:c).keys.must_include(:primary_key)
+    @c.association_reflection(:c).primary_key.must_equal :blah__blah
   end
 
   it "should use the associated table's primary key if :primary_key is not present" do
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).keys.should_not include(:primary_key)
-    @c.association_reflection(:c).primary_key.should == :id
+    @c.association_reflection(:c).keys.wont_include(:primary_key)
+    @c.association_reflection(:c).primary_key.must_equal :id
+  end
+end
+
+describe Sequel::Model::Associations::AssociationReflection, "#reciprocal_type" do
+  it "should include a specific type if only one matches" do
+    c = Class.new(Sequel::Model(:a))
+    c.one_to_many :cs, :class=>c, :key=>:c_id
+    c.many_to_one :c, :class=>c, :key=>:c_id
+    c.association_reflection(:c).send(:reciprocal_type).must_equal :one_to_many
   end
 end
 
@@ -60,15 +69,15 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     @c = Class.new(Sequel::Model(:foo))
     @d = Class.new(Sequel::Model(:foo))
     @c.many_to_one :c, :class=>@d, :reciprocal=>:xx
-    @c.association_reflection(:c).keys.should include(:reciprocal)
-    @c.association_reflection(:c).reciprocal.should == :xx
+    @c.association_reflection(:c).keys.must_include(:reciprocal)
+    @c.association_reflection(:c).reciprocal.must_equal :xx
   end
 
   it "should not raise an error if some reciprocal associations have invalid associated classes" do
     @c = Class.new(Sequel::Model(:foo))
     @c.one_to_many :sadfakloasdfioas
     @c.many_to_one :c, :class=>@c
-    proc{@c.association_reflection(:c).reciprocal}.should_not raise_error
+    @c.association_reflection(:c).reciprocal
   end
 
   it "should require the associated class is the current class to be a reciprocal" do
@@ -77,16 +86,16 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParentTwo.one_to_many :par_parents, :key=>:blah
     ParParentThree.one_to_many :par_parents, :key=>:blah
 
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_three
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_three
 
     ParParent.many_to_many :par_parent_twos, :left_key=>:l, :right_key=>:r, :join_table=>:jt
     ParParent.many_to_many :par_parent_threes, :left_key=>:l, :right_key=>:r, :join_table=>:jt
     ParParentTwo.many_to_many :par_parents, :right_key=>:l, :left_key=>:r, :join_table=>:jt
     ParParentThree.many_to_many :par_parents, :right_key=>:l, :left_key=>:r, :join_table=>:jt
 
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_twos
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_threes
   end
   
   it "should handle composite keys" do
@@ -95,16 +104,16 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParentTwo.one_to_many :par_parents, :primary_key=>[:c, :b], :key=>[:a, :b]
     ParParentThree.one_to_many :par_parents, :primary_key=>[:c, :b], :key=>[:d, :e]
 
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_three
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_three
 
     ParParent.many_to_many :par_parent_twos, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:pl1, :pl2], :right_primary_key=>[:pr1, :pr2], :join_table=>:jt
     ParParent.many_to_many :par_parent_threes, :right_key=>[:l1, :l2], :left_key=>[:r1, :r2], :left_primary_key=>[:pl1, :pl2], :right_primary_key=>[:pr1, :pr2], :join_table=>:jt
     ParParentTwo.many_to_many :par_parents, :right_key=>[:l1, :l2], :left_key=>[:r1, :r2], :right_primary_key=>[:pl1, :pl2], :left_primary_key=>[:pr1, :pr2], :join_table=>:jt
     ParParentThree.many_to_many :par_parents, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :right_primary_key=>[:pl1, :pl2], :left_primary_key=>[:pr1, :pr2], :join_table=>:jt
 
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_twos
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_threes
   end
 
   it "should figure out the reciprocal if the :reciprocal value is not present" do
@@ -113,14 +122,14 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParent.many_to_many :par_parent_threes
     ParParentThree.many_to_many :par_parents
 
-    ParParent.association_reflection(:par_parent_two).keys.should_not include(:reciprocal)
-    ParParent.association_reflection(:par_parent_two).reciprocal.should == :par_parents
-    ParParentTwo.association_reflection(:par_parents).keys.should_not include(:reciprocal)
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
-    ParParent.association_reflection(:par_parent_threes).keys.should_not include(:reciprocal)
-    ParParent.association_reflection(:par_parent_threes).reciprocal.should == :par_parents
-    ParParentThree.association_reflection(:par_parents).keys.should_not include(:reciprocal)
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+    ParParent.association_reflection(:par_parent_two).keys.wont_include(:reciprocal)
+    ParParent.association_reflection(:par_parent_two).reciprocal.must_equal :par_parents
+    ParParentTwo.association_reflection(:par_parents).keys.wont_include(:reciprocal)
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_two
+    ParParent.association_reflection(:par_parent_threes).keys.wont_include(:reciprocal)
+    ParParent.association_reflection(:par_parent_threes).reciprocal.must_equal :par_parents
+    ParParentThree.association_reflection(:par_parents).keys.wont_include(:reciprocal)
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_threes
   end
 
   it "should handle ambiguous reciprocals where only one doesn't have conditions/blocks" do
@@ -133,8 +142,8 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     end
     ParParentThree.many_to_many :par_parents
 
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_threes
   end
 
   it "should handle ambiguous reciprocals where only one has matching primary keys" do
@@ -147,14 +156,14 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParent.many_to_many :par_parent_threes3, :clone=>:par_parent_threes, :left_primary_key=>:foo
     ParParentThree.many_to_many :par_parents
 
-    ParParent.association_reflection(:par_parent_two).reciprocal.should == :par_parents
-    ParParent.association_reflection(:par_parent_two2).reciprocal.should == :par_parents2
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
-    ParParentTwo.association_reflection(:par_parents2).reciprocal.should == :par_parent_two2
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+    ParParent.association_reflection(:par_parent_two).reciprocal.must_equal :par_parents
+    ParParent.association_reflection(:par_parent_two2).reciprocal.must_equal :par_parents2
+    ParParentTwo.association_reflection(:par_parents).reciprocal.must_equal :par_parent_two
+    ParParentTwo.association_reflection(:par_parents2).reciprocal.must_equal :par_parent_two2
+    ParParentThree.association_reflection(:par_parents).reciprocal.must_equal :par_parent_threes
   end
 
-  specify "should handle reciprocals where current association has conditions/block" do
+  it "should handle reciprocals where current association has conditions/block" do
     ParParent.many_to_one :par_parent_two, :conditions=>{:id=>:id}
     ParParentTwo.one_to_many :par_parents
     ParParent.many_to_many :par_parent_threes do |ds|
@@ -162,8 +171,8 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     end
     ParParentThree.many_to_many :par_parents
 
-    ParParent.association_reflection(:par_parent_two).reciprocal.should == :par_parents
-    ParParent.association_reflection(:par_parent_threes).reciprocal.should == :par_parents
+    ParParent.association_reflection(:par_parent_two).reciprocal.must_equal :par_parents
+    ParParent.association_reflection(:par_parent_threes).reciprocal.must_equal :par_parents
   end
 end
 
@@ -178,27 +187,27 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
 
   it "should use the :select value if present" do
     @c.many_to_one :c, :class=>ParParent, :select=>[:par_parents__id]
-    @c.association_reflection(:c).keys.should include(:select)
-    @c.association_reflection(:c).select.should == [:par_parents__id]
+    @c.association_reflection(:c).keys.must_include(:select)
+    @c.association_reflection(:c).select.must_equal [:par_parents__id]
   end
   it "should be the associated_table.* if :select is not present for a many_to_many associaiton" do
     @c.many_to_many :cs, :class=>'ParParent'
-    @c.association_reflection(:cs).keys.should_not include(:select)
-    @c.association_reflection(:cs).select.should == Sequel::SQL::ColumnAll.new(:par_parents)
+    @c.association_reflection(:cs).keys.wont_include(:select)
+    @c.association_reflection(:cs).select.must_equal Sequel::SQL::ColumnAll.new(:par_parents)
   end
   it "should be blank if :select is not present for a many_to_one and one_to_many associaiton" do
     @c.one_to_many :cs, :class=>'ParParent'
-    @c.association_reflection(:cs).keys.should_not include(:select)
-    @c.association_reflection(:cs).select.should == nil
+    @c.association_reflection(:cs).keys.wont_include(:select)
+    @c.association_reflection(:cs).select.must_equal nil
     @c.many_to_one :c, :class=>'ParParent'
-    @c.association_reflection(:c).keys.should_not include(:select)
-    @c.association_reflection(:c).select.should == nil
+    @c.association_reflection(:c).keys.wont_include(:select)
+    @c.association_reflection(:c).select.must_equal nil
   end
 end
 
 describe Sequel::Model::Associations::AssociationReflection, "#can_have_associated_objects?" do
   it "should be true for any given object (for backward compatibility)" do
-    Sequel::Model::Associations::AssociationReflection.new.can_have_associated_objects?(Object.new).should == true
+    Sequel::Model::Associations::AssociationReflection.new.can_have_associated_objects?(Object.new).must_equal true
   end
 end
 
@@ -213,27 +222,27 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_object
 
   it "should use the primary keys for a many_to_one association" do
     @c.many_to_one :c, :class=>ParParent
-    @c.association_reflection(:c).associated_object_keys.should == [:id]
+    @c.association_reflection(:c).associated_object_keys.must_equal [:id]
     @c.many_to_one :c, :class=>ParParent, :primary_key=>:d_id
-    @c.association_reflection(:c).associated_object_keys.should == [:d_id]
+    @c.association_reflection(:c).associated_object_keys.must_equal [:d_id]
     @c.many_to_one :c, :class=>ParParent, :key=>[:c_id1, :c_id2], :primary_key=>[:id1, :id2]
-    @c.association_reflection(:c).associated_object_keys.should == [:id1, :id2]
+    @c.association_reflection(:c).associated_object_keys.must_equal [:id1, :id2]
   end
   it "should use the keys for a one_to_many association" do
     ParParent.one_to_many :cs, :class=>ParParent
-    ParParent.association_reflection(:cs).associated_object_keys.should == [:par_parent_id]
+    ParParent.association_reflection(:cs).associated_object_keys.must_equal [:par_parent_id]
     @c.one_to_many :cs, :class=>ParParent, :key=>:d_id
-    @c.association_reflection(:cs).associated_object_keys.should == [:d_id]
+    @c.association_reflection(:cs).associated_object_keys.must_equal [:d_id]
     @c.one_to_many :cs, :class=>ParParent, :key=>[:c_id1, :c_id2], :primary_key=>[:id1, :id2]
-    @c.association_reflection(:cs).associated_object_keys.should == [:c_id1, :c_id2]
+    @c.association_reflection(:cs).associated_object_keys.must_equal [:c_id1, :c_id2]
   end
   it "should use the right primary keys for a many_to_many association" do
     @c.many_to_many :cs, :class=>ParParent
-    @c.association_reflection(:cs).associated_object_keys.should == [:id]
+    @c.association_reflection(:cs).associated_object_keys.must_equal [:id]
     @c.many_to_many :cs, :class=>ParParent, :right_primary_key=>:d_id
-    @c.association_reflection(:cs).associated_object_keys.should == [:d_id]
+    @c.association_reflection(:cs).associated_object_keys.must_equal [:d_id]
     @c.many_to_many :cs, :class=>ParParent, :right_key=>[:c_id1, :c_id2], :right_primary_key=>[:id1, :id2]
-    @c.association_reflection(:cs).associated_object_keys.should == [:id1, :id2]
+    @c.association_reflection(:cs).associated_object_keys.must_equal [:id1, :id2]
   end
 end
 
@@ -245,27 +254,27 @@ describe Sequel::Model::Associations::AssociationReflection do
 
   it "#eager_loading_predicate_key should be an alias of predicate_key for backwards compatibility" do
     @c.one_to_many :cs, :class=>@c
-    @c.dataset.literal(@c.association_reflection(:cs).eager_loading_predicate_key).should == 'foo.c_id'
+    @c.dataset.literal(@c.association_reflection(:cs).eager_loading_predicate_key).must_equal 'foo.c_id'
   end
 
   it "one_to_many #qualified_primary_key should be a qualified version of the primary key" do
     @c.one_to_many :cs, :class=>@c
-    @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).should == 'foo.id'
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).must_equal 'foo.id'
   end
 
   it "many_to_many #associated_key_column should be the left key" do
     @c.many_to_many :cs, :class=>@c
-    @c.association_reflection(:cs).associated_key_column.should == :c_id
+    @c.association_reflection(:cs).associated_key_column.must_equal :c_id
   end
 
   it "many_to_many #qualified_right_key should be a qualified version of the primary key" do
     @c.many_to_many :cs, :class=>@c, :right_key=>:c2_id
-    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_key).should == 'cs_cs.c2_id'
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_key).must_equal 'cs_cs.c2_id'
   end
 
   it "many_to_many #qualified_right_primary_key should be a qualified version of the primary key" do
     @c.many_to_many :cs, :class=>@c
-    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_primary_key).should == 'foo.id'
+    @c.dataset.literal(@c.association_reflection(:cs).qualified_right_primary_key).must_equal 'foo.id'
   end
 end
 
@@ -276,16 +285,16 @@ describe Sequel::Model::Associations::AssociationReflection, "#remove_before_des
 
   it "should be true for many_to_one and many_to_many associations" do
     @c.many_to_one :c, :class=>@c
-    @c.association_reflection(:c).remove_before_destroy?.should == true
+    @c.association_reflection(:c).remove_before_destroy?.must_equal true
     @c.many_to_many :cs, :class=>@c
-    @c.association_reflection(:cs).remove_before_destroy?.should == true
+    @c.association_reflection(:cs).remove_before_destroy?.must_equal true
   end
 
   it "should be false for one_to_one and one_to_many associations" do
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).remove_before_destroy?.should == false
+    @c.association_reflection(:c).remove_before_destroy?.must_equal false
     @c.one_to_many :cs, :class=>@c
-    @c.association_reflection(:cs).remove_before_destroy?.should == false
+    @c.association_reflection(:cs).remove_before_destroy?.must_equal false
   end
 end
 
@@ -300,110 +309,110 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
 
   it "should be nil by default for *_one associations" do
     @c.many_to_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
     @c.one_through_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
   end
 
   it "should be :correlated_subquery by default for one_to_many and one_to_one with :order associations" do
     @c.one_to_one :c, :class=>@c, :order=>:a
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :correlated_subquery
     @c.one_to_many :cs, :class=>@c, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :correlated_subquery
   end
 
   it "should be :ruby by default for many_to_many and one_through_one with :order associations" do
     @c.one_through_one :c, :class=>@c, :order=>:a
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :ruby
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :ruby
     @c.many_to_many :cs, :class=>@c, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
   it "should be nil for many_to_one associations even if :eager_limit_strategy or :filter_limit_strategy is used" do
     @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
     @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
     @c.many_to_one :c, :class=>@c, :filter_limit_strategy=>true
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
   end
 
   it "should be a symbol for other associations if given a symbol" do
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :distinct_on
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :distinct_on
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>:window_function, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
   end
 
   it "should use :distinct_on for one_to_one associations if picking and the association dataset supports ordered distinct on" do
     def (@c.dataset).supports_ordered_distinct_on?() true end
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :distinct_on
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :distinct_on
   end
 
   it "should use :window_function for associations if picking and the association dataset supports window functions" do
     def (@c.dataset).supports_window_functions?() true end
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should == :window_function
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :window_function
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
     @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
   end
 
   it "should use :ruby for one_to_many associations if the database doesn't support limits in subqueries" do
     def (@c.dataset).supports_limits_in_correlated_subqueries?; false; end
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
   it "should use :ruby for one_to_many associations if offset doesn't work in correlated subqueries and an offset is used" do
     def (@c.dataset).supports_offsets_in_correlated_subqueries?; false; end
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :correlated_subquery
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>[1, 1]
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
   it "should use :ruby for one_to_many associations if composite primary key is used and database does not multiple columns in IN" do
     def (@c.dataset).supports_multiple_column_in?; false; end
     @c.set_primary_key [:id, :id2]
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1, :key=>[:id, :id2]
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
   it "should use :ruby for many_to_many associations if picking and the association dataset doesn't window functions" do
     @c.many_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
-    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :ruby
+    @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
   it "should respect Model.default_eager_limit_strategy to *_many associations" do
     Sequel::Model.default_eager_limit_strategy = :window_function
-    Sequel::Model.default_eager_limit_strategy.should == :window_function
+    Sequel::Model.default_eager_limit_strategy.must_equal :window_function
     c = Class.new(Sequel::Model)
     c.dataset = :a
-    c.default_eager_limit_strategy.should == :window_function
+    c.default_eager_limit_strategy.must_equal :window_function
     c.one_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
     c.many_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
 
     Sequel::Model.default_eager_limit_strategy = true
     c = Class.new(Sequel::Model)
     c.dataset = :a
     c.one_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :correlated_subquery
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :correlated_subquery
     def (c.dataset).supports_window_functions?() true end
     c.many_to_many :cs, :class=>c, :limit=>1
-    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).should == :window_function
+    c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
   end
 
   it "should ignore Model.default_eager_limit_strategy for one_to_one associations" do
     @c.default_eager_limit_strategy = :window_function
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).should be_nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
   end
 end
 
@@ -411,7 +420,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#apply_eager_datas
   it "should apply the eager block as well as the association options to the dataset" do
     @c = Class.new(Sequel::Model(:foo))
     @c.one_to_many :cs, :class=>@c, :select=>:a, :order=>:b do |ds| ds.where(:c) end
-    @c.association_reflection(:cs).apply_eager_dataset_changes(@c.dataset).sql.should == 'SELECT a FROM foo WHERE c ORDER BY b'
+    @c.association_reflection(:cs).apply_eager_dataset_changes(@c.dataset).sql.must_equal 'SELECT a FROM foo WHERE c ORDER BY b'
   end
 end
 
@@ -425,55 +434,55 @@ describe Sequel::Model, " association reflection methods" do
   end
   
   it "#all_association_reflections should include all association reflection hashes" do
-    @c1.all_association_reflections.should == []
+    @c1.all_association_reflections.must_equal []
 
     @c1.associate :many_to_one, :parent, :class => @c1
-    @c1.all_association_reflections.collect{|v| v[:name]}.should == [:parent]
-    @c1.all_association_reflections.collect{|v| v[:type]}.should == [:many_to_one]
-    @c1.all_association_reflections.collect{|v| v[:class]}.should == [@c1]
+    @c1.all_association_reflections.collect{|v| v[:name]}.must_equal [:parent]
+    @c1.all_association_reflections.collect{|v| v[:type]}.must_equal [:many_to_one]
+    @c1.all_association_reflections.collect{|v| v[:class]}.must_equal [@c1]
 
     @c1.associate :one_to_many, :children, :class => @c1
     @c1.all_association_reflections.sort_by{|x|x[:name].to_s}
-    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:name]}.should == [:children, :parent]
-    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:type]}.should == [:one_to_many, :many_to_one]
-    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:class]}.should == [@c1, @c1]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:name]}.must_equal [:children, :parent]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:type]}.must_equal [:one_to_many, :many_to_one]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:class]}.must_equal [@c1, @c1]
   end
 
   it "#association_reflection should return nil for nonexistent association" do
-    @c1.association_reflection(:blah).should == nil
+    @c1.association_reflection(:blah).must_equal nil
   end
 
   it "#association_reflection should return association reflection hash if association exists" do
     @c1.associate :many_to_one, :parent, :class => @c1
-    @c1.association_reflection(:parent).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
-    @c1.association_reflection(:parent)[:name].should == :parent
-    @c1.association_reflection(:parent)[:type].should == :many_to_one
-    @c1.association_reflection(:parent)[:class].should == @c1
+    @c1.association_reflection(:parent).must_be_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:parent)[:name].must_equal :parent
+    @c1.association_reflection(:parent)[:type].must_equal :many_to_one
+    @c1.association_reflection(:parent)[:class].must_equal @c1
 
     @c1.associate :one_to_many, :children, :class => @c1
-    @c1.association_reflection(:children).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
-    @c1.association_reflection(:children)[:name].should == :children
-    @c1.association_reflection(:children)[:type].should == :one_to_many
-    @c1.association_reflection(:children)[:class].should == @c1
+    @c1.association_reflection(:children).must_be_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:children)[:name].must_equal :children
+    @c1.association_reflection(:children)[:type].must_equal :one_to_many
+    @c1.association_reflection(:children)[:class].must_equal @c1
   end
 
   it "#associations should include all association names" do
-    @c1.associations.should == []
+    @c1.associations.must_equal []
     @c1.associate :many_to_one, :parent, :class => @c1
-    @c1.associations.should == [:parent]
+    @c1.associations.must_equal [:parent]
     @c1.associate :one_to_many, :children, :class => @c1
-    @c1.associations.sort_by{|x|x.to_s}.should == [:children, :parent]
+    @c1.associations.sort_by{|x|x.to_s}.must_equal [:children, :parent]
   end
 
   it "association reflections should be copied upon subclasing" do
     @c1.associate :many_to_one, :parent, :class => @c1
     c = Class.new(@c1)
-    @c1.associations.should == [:parent]
-    c.associations.should == [:parent]
+    @c1.associations.must_equal [:parent]
+    c.associations.must_equal [:parent]
     c.associate :many_to_one, :parent2, :class => @c1
-    @c1.associations.should == [:parent]
-    c.associations.sort_by{|x| x.to_s}.should == [:parent, :parent2]
-    c.instance_methods.map{|x| x.to_s}.should include('parent')
+    @c1.associations.must_equal [:parent]
+    c.associations.sort_by{|x| x.to_s}.must_equal [:parent, :parent2]
+    c.instance_methods.map{|x| x.to_s}.must_include('parent')
   end
 end
 
@@ -490,11 +499,11 @@ describe Sequel::Model::Associations::AssociationReflection, "with caching disab
       class ::ParParent < Sequel::Model; end
       c = ParParent
       @c.many_to_one :c, :class=>:ParParent
-      @c.association_reflection(:c).associated_class.should == c
+      @c.association_reflection(:c).associated_class.must_equal c
       Object.send(:remove_const, :ParParent)
       class ::ParParent < Sequel::Model; end
       c = ParParent
-      @c.association_reflection(:c).associated_class.should == c
+      @c.association_reflection(:c).associated_class.must_equal c
     ensure
       Object.send(:remove_const, :ParParent)
     end
@@ -506,11 +515,11 @@ describe Sequel::Model::Associations::AssociationReflection, "with caching disab
       [[opts[:reload] ? :reload : :id, {}]]
     end
     @c.dataset = @db[:items]
-    @c.columns.should == [:reload]
+    @c.columns.must_equal [:reload]
 
     @c.cache_associations = true
     @c.dataset = @db[:items]
-    @c.columns.should == [:id]
+    @c.columns.must_equal [:id]
   end
 end