sequel 4.22.0 → 4.23.0

data/spec/extensions/round_timestamps_spec.rb

@@ -6,36 +6,36 @@ describe "Sequel::Dataset::RoundTimestamps" do
     @dataset = Sequel.mock.dataset.extension(:round_timestamps)
   end
 
-  specify "should round times properly for databases supporting microsecond precision" do
-    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999.5)).should == "'01:02:03.500000'"
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999995)).should == "'2010-01-02 03:04:05.500000'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999995, 10000000))).should == "'2010-01-02 03:04:05.500000'"
+  it "should round times properly for databases supporting microsecond precision" do
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999.5)).must_equal "'01:02:03.500000'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999995)).must_equal "'2010-01-02 03:04:05.500000'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999995, 10000000))).must_equal "'2010-01-02 03:04:05.500000'"
 
-    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999.4)).should == "'01:02:03.499999'"
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999994)).should == "'2010-01-02 03:04:05.499999'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999994, 10000000))).should == "'2010-01-02 03:04:05.499999'"
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999.4)).must_equal "'01:02:03.499999'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999994)).must_equal "'2010-01-02 03:04:05.499999'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999994, 10000000))).must_equal "'2010-01-02 03:04:05.499999'"
   end
   
-  specify "should round times properly for databases supporting millisecond precision" do
+  it "should round times properly for databases supporting millisecond precision" do
     def @dataset.timestamp_precision() 3 end
-    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499500)).should == "'01:02:03.500'"
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4995)).should == "'2010-01-02 03:04:05.500'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54995, 10000))).should == "'2010-01-02 03:04:05.500'"
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499500)).must_equal "'01:02:03.500'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4995)).must_equal "'2010-01-02 03:04:05.500'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54995, 10000))).must_equal "'2010-01-02 03:04:05.500'"
 
-    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499499)).should == "'01:02:03.499'"
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4994)).should == "'2010-01-02 03:04:05.499'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54994, 10000))).should == "'2010-01-02 03:04:05.499'"
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499499)).must_equal "'01:02:03.499'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4994)).must_equal "'2010-01-02 03:04:05.499'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54994, 10000))).must_equal "'2010-01-02 03:04:05.499'"
   end
   
-  specify "should round times properly for databases supporting second precision" do
+  it "should round times properly for databases supporting second precision" do
     def @dataset.supports_timestamp_usecs?() false end
-    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).should == "'01:02:04'"
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.5)).should == "'2010-01-02 03:04:06'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).should == "'2010-01-02 03:04:06'"
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).must_equal "'01:02:04'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.5)).must_equal "'2010-01-02 03:04:06'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).must_equal "'2010-01-02 03:04:06'"
 
-    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999)).should == "'01:02:03'"
-    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999999)).should == "'2010-01-02 03:04:05'"
-    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999999, 10000000))).should == "'2010-01-02 03:04:05'"
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 499999)).must_equal "'01:02:03'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5.4999999)).must_equal "'2010-01-02 03:04:05'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(54999999, 10000000))).must_equal "'2010-01-02 03:04:05'"
   end
 end
 else

data/spec/extensions/schema_caching_spec.rb

@@ -12,30 +12,30 @@ describe "schema_caching extension" do
   end
 
   it "Database#dump_schema_cache should dump cached schema to the given file" do
-    File.exist?(@filename).should == false
+    File.exist?(@filename).must_equal false
     @db.dump_schema_cache(@filename)
-    File.exist?(@filename).should == true
-    File.size(@filename).should > 0
+    File.exist?(@filename).must_equal true
+    File.size(@filename).must_be :>,  0
   end
 
   it "Database#load_schema_cache should load cached schema from the given file dumped by #dump_schema_cache" do
     @db.dump_schema_cache(@filename)
     db = Sequel::Database.new.extension(:schema_caching)
     db.load_schema_cache(@filename)
-    @db.instance_variable_get(:@schemas).should == @schemas
+    @db.instance_variable_get(:@schemas).must_equal @schemas
   end
 
   it "Database#dump_schema_cache? should dump cached schema to the given file unless the file exists" do
     File.open(@filename, 'wb'){|f|}
-    File.size(@filename).should == 0
+    File.size(@filename).must_equal 0
     @db.dump_schema_cache?(@filename)
-    File.size(@filename).should == 0
+    File.size(@filename).must_equal 0
   end
 
   it "Database#load_schema_cache? should load cached schema from the given file if it exists" do
     db = Sequel::Database.new.extension(:schema_caching)
-    File.exist?(@filename).should == false
+    File.exist?(@filename).must_equal false
     db.load_schema_cache?(@filename)
-    db.instance_variable_get(:@schemas).should == {}
+    db.instance_variable_get(:@schemas).must_equal({})
   end
 end

data/spec/extensions/schema_dumper_spec.rb

@@ -31,9 +31,9 @@ describe "Sequel::Schema::Generator dump methods" do
       instance_eval(g.dump_constraints, __FILE__, __LINE__)
       instance_eval(g.dump_indexes, __FILE__, __LINE__)
     end
-    g.columns.should == g2.columns
-    g.constraints.should == g2.constraints
-    g.indexes.should == g2.indexes
+    g.columns.must_equal g2.columns
+    g.constraints.must_equal g2.constraints
+    g.indexes.must_equal g2.indexes
   end
 
   it "should allow dumping indexes as separate add_index and drop_index methods" do
@@ -43,13 +43,13 @@ describe "Sequel::Schema::Generator dump methods" do
       index [:b, :c], :unique=>true
     end
 
-    g.dump_indexes(:add_index=>:t).should == (<<END_CODE).strip
+    g.dump_indexes(:add_index=>:t).must_equal((<<END_CODE).strip)
 add_index :t, [:a]
 add_index :t, [:c, :e], :name=>:blah
 add_index :t, [:b, :c], :unique=>true
 END_CODE
 
-    g.dump_indexes(:drop_index=>:t).should == (<<END_CODE).strip
+    g.dump_indexes(:drop_index=>:t).must_equal((<<END_CODE).strip)
 drop_index :t, [:b, :c], :unique=>true
 drop_index :t, [:c, :e], :name=>:blah
 drop_index :t, [:a]
@@ -57,7 +57,7 @@ END_CODE
   end
 
   it "should raise an error if you try to dump a Generator that uses a constraint with a proc" do
-    proc{@g.new(@d){check{a>1}}.dump_constraints}.should raise_error(Sequel::Error)
+    proc{@g.new(@d){check{a>1}}.dump_constraints}.must_raise(Sequel::Error)
   end
 end
 
@@ -80,27 +80,27 @@ describe "Sequel::Database dump methods" do
   end
 
   it "should support dumping table schemas as create_table method calls" do
-    @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_table_schema(:t1).must_equal "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
   it "should support dumping table schemas when given a string" do
-    @d.dump_table_schema('t__t1').should == "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_table_schema('t__t1').must_equal "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
   it "should support dumping table schemas when given an identifier" do
-    @d.dump_table_schema(Sequel.identifier(:t__t1)).should == "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_table_schema(Sequel.identifier(:t__t1)).must_equal "create_table(\"t__t1\") do\n  primary_key :c1\n  String :c2, :size=>20\nend"
   end
 
   it "should dump non-Integer primary key columns with explicit :type" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'bigint', :primary_key=>true, :allow_null=>true, :auto_increment=>true}]]}
-    @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
+    @d.dump_table_schema(:t6).must_equal "create_table(:t6) do\n  primary_key :c1, :type=>Bignum\nend"
   end
 
   it "should handle foreign keys" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer', :allow_null=>true}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
-    @d.dump_table_schema(:t6).should == "create_table(:t6) do\n  foreign_key :c1, :t2, :key=>[:c2]\nend"
+    @d.dump_table_schema(:t6).must_equal "create_table(:t6) do\n  foreign_key :c1, :t2, :key=>[:c2]\nend"
   end
 
   it "should handle primary keys that are also foreign keys" do
@@ -108,9 +108,9 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2]}]}
     s = @d.dump_table_schema(:t6)
-    s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
-    s.should =~ /:table=>:t2/
-    s.should =~ /:key=>\[:c2\]/
+    s.must_match(/create_table\(:t6\) do\n  primary_key :c1, /)
+    s.must_match(/:table=>:t2/)
+    s.must_match(/:key=>\[:c2\]/)
   end
 
   it "should handle foreign key options" do
@@ -118,11 +118,11 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
     s = @d.dump_table_schema(:t6)
-    s.should =~ /create_table\(:t6\) do\n  foreign_key :c1, :t2, /
-    s.should =~ /:key=>\[:c2\]/
-    s.should =~ /:on_delete=>:restrict/
-    s.should =~ /:on_update=>:set_null/
-    s.should =~ /:deferrable=>true/
+    s.must_match(/create_table\(:t6\) do\n  foreign_key :c1, :t2, /)
+    s.must_match(/:key=>\[:c2\]/)
+    s.must_match(/:on_delete=>:restrict/)
+    s.must_match(/:on_update=>:set_null/)
+    s.must_match(/:deferrable=>true/)
   end
 
   it "should handle foreign key options in the primary key" do
@@ -130,12 +130,12 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:restrict, :on_update=>:set_null, :deferrable=>true}]}
     s = @d.dump_table_schema(:t6)
-    s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
-    s.should =~ /:table=>:t2/
-    s.should =~ /:key=>\[:c2\]/
-    s.should =~ /:on_delete=>:restrict/
-    s.should =~ /:on_update=>:set_null/
-    s.should =~ /:deferrable=>true/
+    s.must_match(/create_table\(:t6\) do\n  primary_key :c1, /)
+    s.must_match(/:table=>:t2/)
+    s.must_match(/:key=>\[:c2\]/)
+    s.must_match(/:on_delete=>:restrict/)
+    s.must_match(/:on_update=>:set_null/)
+    s.must_match(/:deferrable=>true/)
   end
 
   it "should omit foreign key options that are the same as defaults" do
@@ -143,11 +143,11 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
     s = @d.dump_table_schema(:t6)
-    s.should =~ /create_table\(:t6\) do\n  foreign_key :c1, :t2, /
-    s.should =~ /:key=>\[:c2\]/
-    s.should_not =~ /:on_delete/
-    s.should_not =~ /:on_update/
-    s.should_not =~ /:deferrable/
+    s.must_match(/create_table\(:t6\) do\n  foreign_key :c1, :t2, /)
+    s.must_match(/:key=>\[:c2\]/)
+    s.wont_match(/:on_delete/)
+    s.wont_match(/:on_update/)
+    s.wont_match(/:deferrable/)
   end
 
   it "should omit foreign key options that are the same as defaults in the primary key" do
@@ -155,28 +155,28 @@ describe "Sequel::Database dump methods" do
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1], :table=>:t2, :key=>[:c2], :on_delete=>:no_action, :on_update=>:no_action, :deferrable=>false}]}
     s = @d.dump_table_schema(:t6)
-    s.should =~ /create_table\(:t6\) do\n  primary_key :c1, /
-    s.should =~ /:table=>:t2/
-    s.should =~ /:key=>\[:c2\]/
-    s.should_not =~ /:on_delete/
-    s.should_not =~ /:on_update/
-    s.should_not =~ /:deferrable/
+    s.must_match(/create_table\(:t6\) do\n  primary_key :c1, /)
+    s.must_match(/:table=>:t2/)
+    s.must_match(/:key=>\[:c2\]/)
+    s.wont_match(/:on_delete/)
+    s.wont_match(/:on_update/)
+    s.wont_match(/:deferrable/)
   end
 
   it "should dump primary key columns with explicit type equal to the database type when :same_db option is passed" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'somedbspecifictype', :primary_key=>true, :allow_null=>false}]]}
-    @d.dump_table_schema(:t7, :same_db => true).should == "create_table(:t7) do\n  column :c1, \"somedbspecifictype\", :null=>false\n  \n  primary_key [:c1]\nend"
+    @d.dump_table_schema(:t7, :same_db => true).must_equal "create_table(:t7) do\n  column :c1, \"somedbspecifictype\", :null=>false\n  \n  primary_key [:c1]\nend"
   end
 
   it "should use a composite primary_key calls if there is a composite primary key" do
-    @d.dump_table_schema(:t2).should == "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
+    @d.dump_table_schema(:t2).must_equal "create_table(:t2) do\n  Integer :c1, :null=>false\n  BigDecimal :c2, :null=>false\n  \n  primary_key [:c1, :c2]\nend"
   end
 
   it "should use a composite foreign_key calls if there is a composite foreign key" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'integer'}], [:c2, {:db_type=>'integer'}]]}
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|*s| [{:columns=>[:c1, :c2], :table=>:t2, :key=>[:c3, :c4]}]}
-    @d.dump_table_schema(:t1).should == "create_table(:t1) do\n  Integer :c1\n  Integer :c2\n  \n  foreign_key [:c1, :c2], :t2, :key=>[:c3, :c4]\nend"
+    @d.dump_table_schema(:t1).must_equal "create_table(:t1) do\n  Integer :c1\n  Integer :c2\n  \n  foreign_key [:c1, :c2], :t2, :key=>[:c3, :c4]\nend"
   end
 
   it "should include index information if available" do
@@ -185,11 +185,11 @@ describe "Sequel::Database dump methods" do
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
-    @d.dump_table_schema(:t1).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1], :unique=>true\nend"
+    @d.dump_table_schema(:t1).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1], :unique=>true\nend"
   end
 
   it "should support dumping the whole database as a migration" do
-    @d.dump_schema_migration.should == <<-END_MIG
+    @d.dump_schema_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1) do
@@ -210,7 +210,7 @@ END_MIG
 
   it "should sort table names when dumping a migration" do
     @d.meta_def(:tables){|o| [:t2, :t1]}
-    @d.dump_schema_migration.should == <<-END_MIG
+    @d.dump_schema_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1) do
@@ -238,7 +238,7 @@ END_MIG
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
-    @d.dump_schema_migration.should == <<-END_MIG
+    @d.dump_schema_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t2) do
@@ -262,7 +262,7 @@ END_MIG
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : [{:columns=>[:c1], :table=>:t1, :key=>[:c2]}]
     end
-    @d.dump_schema_migration.should == <<-END_MIG
+    @d.dump_schema_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1) do
@@ -291,7 +291,7 @@ END_MIG
       raise Sequel::DatabaseError unless [:t1, :t2].include?(t)
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
-    @d.dump_schema_migration.should == <<-END_MIG
+    @d.dump_schema_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t2) do
@@ -307,8 +307,8 @@ END_MIG
   end
 
   it "should honor the :same_db option to not convert types" do
-    @d.dump_table_schema(:t1, :same_db=>true).should == "create_table(:t1) do\n  primary_key :c1\n  column :c2, \"varchar(20)\"\nend"
-    @d.dump_schema_migration(:same_db=>true).should == <<-END_MIG
+    @d.dump_table_schema(:t1, :same_db=>true).must_equal "create_table(:t1) do\n  primary_key :c1\n  column :c2, \"varchar(20)\"\nend"
+    @d.dump_schema_migration(:same_db=>true).must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1) do
@@ -333,8 +333,8 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
-    @d.dump_table_schema(:t1, :index_names=>false).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1]\n  index [:c2, :c1], :unique=>true\nend"
-    @d.dump_schema_migration(:index_names=>false).should == <<-END_MIG
+    @d.dump_table_schema(:t1, :index_names=>false).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1]\n  index [:c2, :c1], :unique=>true\nend"
+    @d.dump_schema_migration(:index_names=>false).must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1, :ignore_index_errors=>true) do
@@ -365,8 +365,8 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
-    @d.dump_table_schema(:t1, :index_names=>:namespace).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1]\nend"
-    @d.dump_schema_migration(:index_names=>:namespace).should == <<-END_MIG
+    @d.dump_table_schema(:t1, :index_names=>:namespace).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1, :ignore_index_errors=>true) do
@@ -398,8 +398,8 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
-    @d.dump_table_schema(:t1, :index_names=>:namespace).should == "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:t1_i1\n  index [:c2, :c1]\nend"
-    @d.dump_schema_migration(:index_names=>:namespace).should == <<-END_MIG
+    @d.dump_table_schema(:t1, :index_names=>:namespace).must_equal "create_table(:t1, :ignore_index_errors=>true) do\n  primary_key :c1\n  String :c2, :size=>20\n  \n  index [:c1], :name=>:t1_i1\n  index [:c2, :c1]\nend"
+    @d.dump_schema_migration(:index_names=>:namespace).must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1, :ignore_index_errors=>true) do
@@ -430,8 +430,8 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
-    @d.dump_table_schema(:t1, :indexes=>false).should == "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
-    @d.dump_schema_migration(:indexes=>false).should == <<-END_MIG
+    @d.dump_table_schema(:t1, :indexes=>false).must_equal "create_table(:t1) do\n  primary_key :c1\n  String :c2, :size=>20\nend"
+    @d.dump_schema_migration(:indexes=>false).must_equal <<-END_MIG
 Sequel.migration do
   change do
     create_table(:t1) do
@@ -454,7 +454,7 @@ END_MIG
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
-    @d.dump_schema_migration(:indexes=>false).should_not =~ /foreign_key/
+    @d.dump_schema_migration(:indexes=>false).wont_match(/foreign_key/)
   end
 
   it "should have :foreign_keys option override :indexes => false disabling of foreign keys" do
@@ -462,7 +462,7 @@ END_MIG
     @d.meta_def(:foreign_key_list) do |t|
       t == :t1 ? [{:columns=>[:c2], :table=>:t2, :key=>[:c1]}] : []
     end
-    @d.dump_schema_migration(:indexes=>false, :foreign_keys=>true).should =~ /foreign_key/
+    @d.dump_schema_migration(:indexes=>false, :foreign_keys=>true).must_match(/foreign_key/)
   end
 
   it "should support dumping just indexes as a migration" do
@@ -472,7 +472,7 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
-    @d.dump_indexes_migration.should == <<-END_MIG
+    @d.dump_indexes_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
@@ -489,7 +489,7 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>true}}
     end
-    @d.dump_indexes_migration(:index_names=>false).should == <<-END_MIG
+    @d.dump_indexes_migration(:index_names=>false).must_equal <<-END_MIG
 Sequel.migration do
   change do
     add_index :t1, [:c1], :ignore_errors=>true
@@ -506,7 +506,7 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
-    @d.dump_indexes_migration(:index_names=>:namespace).should == <<-END_MIG
+    @d.dump_indexes_migration(:index_names=>:namespace).must_equal <<-END_MIG
 Sequel.migration do
   change do
     add_index :t1, [:c1], :ignore_errors=>true, :name=>:i1
@@ -527,7 +527,7 @@ END_MIG
       {:i1=>{:columns=>[:c1], :unique=>false},
        :t1_c2_c1_index=>{:columns=>[:c2, :c1], :unique=>false}}
     end
-    @d.dump_indexes_migration(:index_names=>:namespace).should == <<-END_MIG
+    @d.dump_indexes_migration(:index_names=>:namespace).must_equal <<-END_MIG
 Sequel.migration do
   change do
     add_index :t1, [:c1], :ignore_errors=>true, :name=>:t1_i1
@@ -542,7 +542,7 @@ END_MIG
 
   it "should handle missing index parsing support when dumping index migration" do
     @d.meta_def(:tables){|o| [:t1]}
-    @d.dump_indexes_migration.should == <<-END_MIG
+    @d.dump_indexes_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     
@@ -553,7 +553,7 @@ END_MIG
 
   it "should handle missing foreign key parsing support when dumping foreign key migration" do
     @d.meta_def(:tables){|o| [:t1]}
-    @d.dump_foreign_key_migration.should == <<-END_MIG
+    @d.dump_foreign_key_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     
@@ -578,7 +578,7 @@ END_MIG
         []
       end
     end
-    @d.dump_foreign_key_migration.should == <<-END_MIG
+    @d.dump_foreign_key_migration.must_equal <<-END_MIG
 Sequel.migration do
   change do
     alter_table(:t1) do
@@ -595,7 +595,7 @@ END_MIG
 
   it "should handle not null values and defaults" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'date', :default=>"'now()'", :allow_null=>true}], [:c2, {:db_type=>'datetime', :allow_null=>false}]]}
-    @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
+    @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
   end
   
   it "should handle converting common defaults" do
@@ -615,8 +615,8 @@ END_MIG
       s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
       s
     end
-    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
-    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.new(2008, 10, 29)\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  Time :c9, :default=>Sequel::SQLTime.parse(\"10:20:30.0\"), :only_time=>true\n  String :c10\n  Date :c11, :default=>Sequel::CURRENT_DATE\n  DateTime :c12, :default=>Sequel::CURRENT_TIMESTAMP\nend"
+    @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d\d\d"\)/, '")').gsub(/\.0+/, '.0').must_equal "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.new(2008, 10, 29)\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30.0\")\n  column :c9, \"time\", :default=>Sequel::SQLTime.parse(\"10:20:30.0\")\n  column :c10, \"foo\", :default=>Sequel::LiteralString.new(\"'6 weeks'\")\n  column :c11, \"date\", :default=>Sequel::CURRENT_DATE\n  column :c12, \"timestamp\", :default=>Sequel::CURRENT_TIMESTAMP\nend"
   end
   
   it "should not use a literal string as a fallback if using MySQL with the :same_db option" do
@@ -628,11 +628,11 @@ END_MIG
       s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
       s
     end
-    @d.dump_table_schema(:t5, :same_db=>true).should == "create_table(:t5) do\n  column :c10, \"foo\"\nend"
+    @d.dump_table_schema(:t5, :same_db=>true).must_equal "create_table(:t5) do\n  column :c10, \"foo\"\nend"
   end
 
   it "should convert unknown database types to strings" do
-    @d.dump_table_schema(:t5).should == "create_table(:t5) do\n  String :c1\nend"
+    @d.dump_table_schema(:t5).must_equal "create_table(:t5) do\n  String :c1\nend"
   end
 
   it "should convert many database types to ruby types" do
@@ -652,7 +652,7 @@ END_MIG
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
-    @d.dump_table_schema(:x).should == (<<END_MIG).chomp
+    @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
 create_table(:x) do
   Integer :c1
   Integer :c2
@@ -744,7 +744,7 @@ END_MIG
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
-    @d.dump_table_schema(:x).should == (<<END_MIG).chomp
+    @d.dump_table_schema(:x).must_equal((<<END_MIG).chomp)
 create_table(:x) do
   Float :c1
   Float :c2
@@ -757,16 +757,16 @@ END_MIG
   it "should force specify :null option for MySQL timestamp columns when using :same_db" do
     @d.meta_def(:database_type){:mysql}
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>true}]]}
-    @d.dump_table_schema(:t3, :same_db=>true).should == "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>true\n  \n  primary_key [:c1]\nend"
+    @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>true\n  \n  primary_key [:c1]\nend"
 
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'timestamp', :primary_key=>true, :allow_null=>false}]]}
-    @d.dump_table_schema(:t3, :same_db=>true).should == "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>false\n  \n  primary_key [:c1]\nend"
+    @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"timestamp\", :null=>false\n  \n  primary_key [:c1]\nend"
   end
 
   it "should use separate primary_key call with non autoincrementable types" do
     @d.meta_def(:schema){|*s| [[:c1, {:db_type=>'varchar(8)', :primary_key=>true, :auto_increment=>false}]]}
-    @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"
-    @d.dump_table_schema(:t3, :same_db=>true).should == "create_table(:t3) do\n  column :c1, \"varchar(8)\"\n  \n  primary_key [:c1]\nend"
+    @d.dump_table_schema(:t3).must_equal "create_table(:t3) do\n  String :c1, :size=>8\n  \n  primary_key [:c1]\nend"
+    @d.dump_table_schema(:t3, :same_db=>true).must_equal "create_table(:t3) do\n  column :c1, \"varchar(8)\"\n  \n  primary_key [:c1]\nend"
   end
 
   it "should use explicit type for non integer foreign_key types" do
@@ -774,9 +774,9 @@ END_MIG
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
     ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>Date, :key=>[:c1]\n  \n  primary_key [:c1]\nend",
-     "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>Date\n  \n  primary_key [:c1]\nend"].should include(@d.dump_table_schema(:t4))
+     "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>Date\n  \n  primary_key [:c1]\nend"].must_include(@d.dump_table_schema(:t4))
     ["create_table(:t4) do\n  foreign_key :c1, :t3, :type=>\"date\", :key=>[:c1]\n  \n  primary_key [:c1]\nend",
-     "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>\"date\"\n  \n  primary_key [:c1]\nend"].should include(@d.dump_table_schema(:t4, :same_db=>true))
+     "create_table(:t4) do\n  foreign_key :c1, :t3, :key=>[:c1], :type=>\"date\"\n  \n  primary_key [:c1]\nend"].must_include(@d.dump_table_schema(:t4, :same_db=>true))
   end
 
   it "should correctly handing autoincrementing primary keys that are also foreign keys" do
@@ -784,6 +784,6 @@ END_MIG
     @d.meta_def(:supports_foreign_key_parsing?){true}
     @d.meta_def(:foreign_key_list){|t, *a| [{:columns=>[:c1], :table=>:t3, :key=>[:c1]}] if t == :t4}
     ["create_table(:t4) do\n  primary_key :c1, :table=>:t3, :key=>[:c1]\nend",
-     "create_table(:t4) do\n  primary_key :c1, :key=>[:c1], :table=>:t3\nend"].should include(@d.dump_table_schema(:t4))
+     "create_table(:t4) do\n  primary_key :c1, :key=>[:c1], :table=>:t3\nend"].must_include(@d.dump_table_schema(:t4))
   end
 end