sequel 4.22.0 → 4.23.0

data/spec/extensions/schema_spec.rb

@@ -6,20 +6,20 @@ describe Sequel::Model, "set_schema" do
     @model.plugin :schema
   end 
 
-  specify "sets schema with implicit table name" do
+  it "sets schema with implicit table name" do
     @model.set_schema do
       primary_key :ssn, :type=>:string
     end
-    @model.primary_key.should == :ssn
-    @model.table_name.should == :items
+    @model.primary_key.must_equal :ssn
+    @model.table_name.must_equal :items
   end
 
-  specify "sets schema with explicit table name" do
+  it "sets schema with explicit table name" do
     @model.set_schema :foo do
       primary_key :id
     end
-    @model.primary_key.should == :id
-    @model.table_name.should == :foo
+    @model.primary_key.must_equal :id
+    @model.table_name.must_equal :foo
   end
 end
 
@@ -38,37 +38,38 @@ describe Sequel::Model, "create_table and schema" do
 
   it "should get the create table SQL list from the db and execute it line by line" do
     @model.create_table
-    DB.sqls.should == ['CREATE TABLE items (name text, price float NOT NULL)']
+    DB.sqls.must_equal ['CREATE TABLE items (name text, price float NOT NULL)']
   end
 
   it "should allow setting schema and creating the table in one call" do
     @model.create_table { text :name }
-    DB.sqls.should == ['CREATE TABLE items (name text)']
+    DB.sqls.must_equal ['CREATE TABLE items (name text)']
   end
 
   it "should reload the schema from the database" do
     schem = {:name=>{:type=>:string}, :price=>{:type=>:float}}
-    @model.db.should_receive(:schema).with(@model.dataset, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
-    @model.create_table
-    @model.db_schema.should == schem
-    @model.instance_variable_get(:@columns).should == [:name, :price]
+    @model.db.stub(:schema, schem.to_a.sort_by{|x| x[0].to_s}) do
+      @model.create_table
+      @model.db_schema.must_equal schem
+    end
+    @model.instance_variable_get(:@columns).must_equal [:name, :price]
   end
 
   it "should return the schema generator via schema" do
-    @model.schema.should be_a_kind_of(Sequel::Schema::Generator)
+    @model.schema.must_be_kind_of(Sequel::Schema::Generator)
   end
 
   it "should use the superclasses schema if it exists" do
     @submodel = Class.new(@model)
-    @submodel.schema.should be_a_kind_of(Sequel::Schema::Generator)
+    @submodel.schema.must_be_kind_of(Sequel::Schema::Generator)
   end
 
   it "should return nil if no schema is present" do
     @model = Class.new(Sequel::Model)
     @model.plugin :schema
-    @model.schema.should == nil
+    @model.schema.must_equal nil
     @submodel = Class.new(@model)
-    @submodel.schema.should == nil
+    @submodel.schema.must_equal nil
   end
 end
 
@@ -80,34 +81,37 @@ describe Sequel::Model, "schema methods" do
   end
 
   it "table_exists? should get the table name and question the model's db if table_exists?" do
-    @model.db.should_receive(:table_exists?).and_return(false)
-    @model.table_exists?.should == false
+    DB.stub(:table_exists?, false) do
+      @model.table_exists?.must_equal false
+    end
   end
 
   it "drop_table should drop the related table" do
     @model.drop_table
-    DB.sqls.should == ['DROP TABLE items']
+    DB.sqls.must_equal ['DROP TABLE items']
   end
 
   it "drop_table? should drop the table if it exists" do
     @model.drop_table?
-    DB.sqls.should == ["SELECT NULL AS nil FROM items LIMIT 1", 'DROP TABLE items']
+    DB.sqls.must_equal ["SELECT NULL AS nil FROM items LIMIT 1", 'DROP TABLE items']
   end
   
   it "create_table! should drop table if it exists and then create the table" do
     @model.create_table!
-    DB.sqls.should == ["SELECT NULL AS nil FROM items LIMIT 1", 'DROP TABLE items', 'CREATE TABLE items ()']
+    DB.sqls.must_equal ["SELECT NULL AS nil FROM items LIMIT 1", 'DROP TABLE items', 'CREATE TABLE items ()']
   end
   
   it "create_table? should not create the table if it already exists" do
-    @model.should_receive(:table_exists?).and_return(true)
-    @model.create_table?
-    DB.sqls.should == []
+    DB.stub(:table_exists?, true) do
+      @model.create_table?
+    end
+    DB.sqls.must_equal []
   end
 
   it "create_table? should create the table if it doesn't exist" do
-    @model.should_receive(:table_exists?).and_return(false)
-    @model.create_table?
-    DB.sqls.should == ['CREATE TABLE items ()']
+    DB.stub(:table_exists?, false) do
+      @model.create_table?
+    end
+    DB.sqls.must_equal ['CREATE TABLE items ()']
   end
 end

data/spec/extensions/scissors_spec.rb

@@ -10,17 +10,17 @@ describe "scissors plugin" do
 
   it "Model.delete should delete from the dataset" do
     @m.delete
-    @m.db.sqls.should == ['DELETE FROM items']
+    @m.db.sqls.must_equal ['DELETE FROM items']
   end
 
   it "Model.update should update the dataset" do
     @m.update(:a=>1)
-    @m.db.sqls.should == ['UPDATE items SET a = 1']
+    @m.db.sqls.must_equal ['UPDATE items SET a = 1']
   end
 
   it "Model.destory each instance in the dataset" do
     @m.dataset._fetch = {:id=>1}
     @m.destroy
-    @m.db.sqls.should == ['BEGIN', 'SELECT * FROM items', 'DELETE FROM items WHERE id = 1', 'COMMIT']
+    @m.db.sqls.must_equal ['BEGIN', 'SELECT * FROM items', 'DELETE FROM items WHERE id = 1', 'COMMIT']
   end
 end

data/spec/extensions/select_remove_spec.rb

@@ -6,33 +6,33 @@ describe "Dataset#select_remove" do
     @d.columns :a, :b, :c
   end
   
-  specify "should remove columns from the selected columns" do
-    @d.sql.should == 'SELECT * FROM test'
-    @d.select_remove(:a).sql.should == 'SELECT b, c FROM test'
-    @d.select_remove(:b).sql.should == 'SELECT a, c FROM test'
-    @d.select_remove(:c).sql.should == 'SELECT a, b FROM test'
+  it "should remove columns from the selected columns" do
+    @d.sql.must_equal 'SELECT * FROM test'
+    @d.select_remove(:a).sql.must_equal 'SELECT b, c FROM test'
+    @d.select_remove(:b).sql.must_equal 'SELECT a, c FROM test'
+    @d.select_remove(:c).sql.must_equal 'SELECT a, b FROM test'
   end
 
-  specify "should work correctly if there are already columns selected" do
+  it "should work correctly if there are already columns selected" do
     d = @d.select(:a, :b, :c)
     d.columns :a, :b, :c
-    d.select_remove(:c).sql.should == 'SELECT a, b FROM test'
+    d.select_remove(:c).sql.must_equal 'SELECT a, b FROM test'
   end
 
-  specify "should have no effect if the columns given are not currently selected" do
-    @d.select_remove(:d).sql.should == 'SELECT a, b, c FROM test'
+  it "should have no effect if the columns given are not currently selected" do
+    @d.select_remove(:d).sql.must_equal 'SELECT a, b, c FROM test'
   end
 
-  specify "should handle expressions where Sequel can't determine the alias by itself" do
+  it "should handle expressions where Sequel can't determine the alias by itself" do
     d = @d.select(:a, Sequel.function(:b), Sequel.as(:c, :b))
     d.columns :a, :"b()", :b
-    d.select_remove(:"b()").sql.should == 'SELECT a, c AS b FROM test'
+    d.select_remove(:"b()").sql.must_equal 'SELECT a, c AS b FROM test'
   end
 
-  specify "should remove expressions if given exact expressions" do
+  it "should remove expressions if given exact expressions" do
     d = @d.select(:a, Sequel.function(:b), Sequel.as(:c, :b))
     d.columns :a, :"b()", :b
-    d.select_remove(Sequel.function(:b)).sql.should == 'SELECT a, c AS b FROM test'
-    d.select_remove(Sequel.as(:c, :b)).sql.should == 'SELECT a, b() FROM test'
+    d.select_remove(Sequel.function(:b)).sql.must_equal 'SELECT a, c AS b FROM test'
+    d.select_remove(Sequel.as(:c, :b)).sql.must_equal 'SELECT a, b() FROM test'
   end
 end

data/spec/extensions/sequel_3_dataset_methods_spec.rb

@@ -5,21 +5,21 @@ describe "Dataset#to_csv" do
     @ds = Sequel.mock(:fetch=>[{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}, {:a=>7, :b=>8, :c=>9}])[:items].columns(:a, :b, :c).extension(:sequel_3_dataset_methods)
   end
   
-  specify "should format a CSV representation of the records" do
-    @ds.to_csv.should == "a, b, c\r\n1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+  it "should format a CSV representation of the records" do
+    @ds.to_csv.must_equal "a, b, c\r\n1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
   end
 
-  specify "should exclude column titles if so specified" do
-    @ds.to_csv(false).should == "1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
+  it "should exclude column titles if so specified" do
+    @ds.to_csv(false).must_equal "1, 2, 3\r\n4, 5, 6\r\n7, 8, 9\r\n"
   end
 end
 
 describe "Dataset#[]=" do
-  specify "should perform an update on the specified filter" do
+  it "should perform an update on the specified filter" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
     ds[:a => 1] = {:x => 3}
-    db.sqls.should == ['UPDATE items SET x = 3 WHERE (a = 1)']
+    db.sqls.must_equal ['UPDATE items SET x = 3 WHERE (a = 1)']
   end
 end
 
@@ -29,73 +29,73 @@ describe "Dataset#insert_multiple" do
     @ds = @db[:items].extension(:sequel_3_dataset_methods)
   end
   
-  specify "should insert all items in the supplied array" do
+  it "should insert all items in the supplied array" do
     @ds.insert_multiple(['aa', 5, 3, {:a => 2}])
-    @db.sqls.should == ["INSERT INTO items VALUES ('aa')",
+    @db.sqls.must_equal ["INSERT INTO items VALUES ('aa')",
       "INSERT INTO items VALUES (5)",
       "INSERT INTO items VALUES (3)",
       "INSERT INTO items (a) VALUES (2)"]
   end
   
-  specify "should pass array items through the supplied block if given" do
+  it "should pass array items through the supplied block if given" do
     @ds.insert_multiple(["inevitable", "hello", "the ticking clock"]){|i| i.gsub('l', 'r')}
-    @db.sqls.should == ["INSERT INTO items VALUES ('inevitabre')",
+    @db.sqls.must_equal ["INSERT INTO items VALUES ('inevitabre')",
       "INSERT INTO items VALUES ('herro')",
       "INSERT INTO items VALUES ('the ticking crock')"]
   end
 
-  specify "should return array of inserted ids" do
-    @ds.insert_multiple(['aa', 5, 3, {:a => 2}]).should == [2, 3, 4, 5]
+  it "should return array of inserted ids" do
+    @ds.insert_multiple(['aa', 5, 3, {:a => 2}]).must_equal [2, 3, 4, 5]
   end
 
-  specify "should work exactly like in metioned in the example" do
+  it "should work exactly like in metioned in the example" do
     @ds.insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2 ; row }
     sqls = @db.sqls
-    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls[0])
-    ["INSERT INTO items (x, y) VALUES (2, 4)", "INSERT INTO items (y, x) VALUES (4, 2)"].should include(sqls[1])
+    ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].must_include(sqls[0])
+    ["INSERT INTO items (x, y) VALUES (2, 4)", "INSERT INTO items (y, x) VALUES (4, 2)"].must_include(sqls[1])
   end
 end
 
 describe "Dataset#db=" do
-  specify "should change the dataset's database" do
+  it "should change the dataset's database" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
     db2 = Sequel.mock
     ds.db = db2
-    ds.db.should == db2
-    ds.db.should_not == db
+    ds.db.must_equal db2
+    ds.db.wont_equal db
   end
 end
 
 describe "Dataset#opts=" do
-  specify "should change the dataset's opts" do
+  it "should change the dataset's opts" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
-    ds.sql.should == 'SELECT * FROM items'
+    ds.sql.must_equal 'SELECT * FROM items'
     ds.opts = {}
-    ds.sql.should == 'SELECT *'
-    ds.opts.should == {}
+    ds.sql.must_equal 'SELECT *'
+    ds.opts.must_equal({})
   end
 end
 
 describe "Dataset#set" do
-  specify "should act as alias to #update" do
+  it "should act as alias to #update" do
     db = Sequel.mock
     ds = db[:items].extension(:sequel_3_dataset_methods)
     ds.set({:x => 3})
-    db.sqls.should == ['UPDATE items SET x = 3']
+    db.sqls.must_equal ['UPDATE items SET x = 3']
   end
 end
 
 describe "Sequel::Dataset#qualify_to_first_source" do
-  specify "should qualify to the first source" do
-    Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to_first_source.sql.should == 'SELECT t.* FROM t WHERE (t.a < t.b)'
+  it "should qualify to the first source" do
+    Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to_first_source.sql.must_equal 'SELECT t.* FROM t WHERE (t.a < t.b)'
   end
 end
 
 describe "Sequel::Dataset#qualify_to" do
-  specify "should qualify to the given table" do
-    Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to(:e).sql.should == 'SELECT e.* FROM t WHERE (e.a < e.b)'
+  it "should qualify to the given table" do
+    Sequel.mock.dataset.extension(:sequel_3_dataset_methods).from(:t).filter{a<b}.qualify_to(:e).sql.must_equal 'SELECT e.* FROM t WHERE (e.a < e.b)'
   end
 end
 

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -17,82 +17,82 @@ describe "serialization_modification_detection plugin" do
   end
   
   it "should not detect columns that haven't been changed" do
-    @o1.changed_columns.should == []
-    @o1.h.should == {}
+    @o1.changed_columns.must_equal []
+    @o1.h.must_equal({})
     @o1.h[1] = 2
     @o1.h.clear
-    @o1.changed_columns.should == []
+    @o1.changed_columns.must_equal []
 
-    @o2.changed_columns.should == []
-    @o2.h.should == {}
+    @o2.changed_columns.must_equal []
+    @o2.h.must_equal({})
     @o2.h[1] = 2
     @o2.h.clear
-    @o2.changed_columns.should == []
+    @o2.changed_columns.must_equal []
   end
   
   it "should detect columns that have been changed" do
-    @o1.changed_columns.should == []
-    @o1.h.should == {}
+    @o1.changed_columns.must_equal []
+    @o1.h.must_equal({})
     @o1.h[1] = 2
-    @o1.changed_columns.should == [:h]
+    @o1.changed_columns.must_equal [:h]
 
-    @o2.changed_columns.should == []
-    @o2.h.should == {}
+    @o2.changed_columns.must_equal []
+    @o2.h.must_equal({})
     @o2.h[1] = 2
-    @o2.changed_columns.should == [:h]
+    @o2.changed_columns.must_equal [:h]
 
-    @o3.changed_columns.should == []
-    @o3.h.should == nil
+    @o3.changed_columns.must_equal []
+    @o3.h.must_equal nil
     @o3.h = {}
-    @o3.changed_columns.should == [:h]
+    @o3.changed_columns.must_equal [:h]
 
-    @o4.changed_columns.should == []
-    @o4.h.should == nil
+    @o4.changed_columns.must_equal []
+    @o4.h.must_equal nil
     @o4.h = {}
-    @o4.changed_columns.should == [:h]
+    @o4.changed_columns.must_equal [:h]
   end
   
   it "should report correct changed_columns after saving" do
     @o1.h[1] = 2
     @o1.save
-    @o1.changed_columns.should == []
+    @o1.changed_columns.must_equal []
 
     @o2.h[1] = 2
     @o2.save_changes
-    @o2.changed_columns.should == []
+    @o2.changed_columns.must_equal []
 
     @o3.h = {1=>2}
     @o3.save
-    @o3.changed_columns.should == []
+    @o3.changed_columns.must_equal []
 
     @o4.h = {1=>2}
     @o4.save
-    @o4.changed_columns.should == []
+    @o4.changed_columns.must_equal []
   end
 
   it "should work with frozen objects" do
-    @o1.changed_columns.should == []
-    @o1.h.should == {}
+    @o1.changed_columns.must_equal []
+    @o1.h.must_equal({})
     @o1.freeze
     @o1.h[1] = 2
-    @o1.changed_columns.should == [:h]
+    @o1.changed_columns.must_equal [:h]
   end
 
   it "should work with duplicating objects" do
-    @o2.changed_columns.should == []
+    @o2.changed_columns.must_equal []
     o = @o2.dup
-    @o2.h.should == {}
+    @o2.h.must_equal({})
     @o2.h[1] = 2
-    @o2.changed_columns.should == [:h]
-    o.changed_columns.should == []
+    @o2.changed_columns.must_equal [:h]
+    o.changed_columns.must_equal []
   end
 
   it "should work with duplicating objects after modifying them" do
-    @o2.changed_columns.should == []
-    @o2.h.should == {}
+    @o2.changed_columns.must_equal []
+    @o2.h.must_equal({})
     @o2.h[1] = 2
-    @o2.changed_columns.should == [:h]
+    @o2.changed_columns.must_equal [:h]
     o = @o2.dup
-    o.changed_columns.should == [:h]
+    o.changed_columns.must_equal [:h]
   end
 end

data/spec/extensions/serialization_spec.rb

@@ -15,15 +15,15 @@ describe "Serialization plugin" do
   it "should allow setting additional serializable attributes via plugin :serialization call" do
     @c.plugin :serialization, :yaml, :abc
     @c.create(:abc => 1, :def=> 2)
-    DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 2|2, '--- 1\n(\.\.\.\n)?')\)/
+    DB.sqls.last.must_match(/INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 2|2, '--- 1\n(\.\.\.\n)?')\)/)
 
     @c.plugin :serialization, :marshal, :def
     @c.create(:abc => 1, :def=> 1)
-    DB.sqls.last.should =~ /INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n(\.\.\.\n)?')\)/
+    DB.sqls.last.must_match(/INSERT INTO items \((abc, def|def, abc)\) VALUES \(('--- 1\n(\.\.\.\n)?', 'BAhpBg==\n'|'BAhpBg==\n', '--- 1\n(\.\.\.\n)?')\)/)
     
     @c.plugin :serialization, :json, :ghi
     @c.create(:ghi => [123])
-    DB.sqls.last.should =~ /INSERT INTO items \((ghi)\) VALUES \('\[123\]'\)/
+    DB.sqls.last.must_match(/INSERT INTO items \((ghi)\) VALUES \('\[123\]'\)/)
   end
 
   it "should handle validations of underlying column" do
@@ -32,16 +32,16 @@ describe "Serialization plugin" do
     def o.validate
       errors.add(:abc, "not present") unless self[:abc]
     end
-    o.valid?.should == false
+    o.valid?.must_equal false
     o.abc = {}
-    o.valid?.should == true
+    o.valid?.must_equal true
   end
 
   it "should set column values even when not validating" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc
     @c.load({:id=>1}).set(:abc=>{}).save(:validate=>false)
-    DB.sqls.last.gsub("\n", '').should == "UPDATE items SET abc = '--- {}' WHERE (id = 1)"
+    DB.sqls.last.gsub("\n", '').must_equal "UPDATE items SET abc = '--- {}' WHERE (id = 1)"
   end
 
   it "should allow serializing attributes to yaml" do
@@ -49,12 +49,12 @@ describe "Serialization plugin" do
     @c.create(:abc => 1)
     @c.create(:abc => "hello")
 
-    DB.sqls.map{|s| s.sub("...\n", '')}.should == ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
+    DB.sqls.map{|s| s.sub("...\n", '')}.must_equal ["INSERT INTO items (abc) VALUES ('--- 1\n')", "INSERT INTO items (abc) VALUES ('--- hello\n')"]
   end
 
   it "serialized_columns should be the columns serialized" do
     @c.plugin :serialization, :yaml, :abc
-    @c.serialized_columns.should == [:abc]
+    @c.serialized_columns.must_equal [:abc]
   end
 
   it "should allow serializing attributes to marshal" do
@@ -63,7 +63,7 @@ describe "Serialization plugin" do
     @c.create(:abc => "hello")
     x = [Marshal.dump("hello")].pack('m')
 
-    DB.sqls.should == [ \
+    DB.sqls.must_equal [ \
       "INSERT INTO items (abc) VALUES ('BAhpBg==\n')", \
       "INSERT INTO items (abc) VALUES ('#{x}')", \
     ]
@@ -75,7 +75,7 @@ describe "Serialization plugin" do
     @c.create(:ghi => ["hello"])
     
     x = ["hello"].to_json
-    DB.sqls.should == [ \
+    DB.sqls.must_equal [ \
       "INSERT INTO items (ghi) VALUES ('[1]')", \
       "INSERT INTO items (ghi) VALUES ('#{x}')", \
     ]
@@ -84,11 +84,11 @@ describe "Serialization plugin" do
   it "should allow serializing attributes using arbitrary callable" do
     @c.plugin :serialization, [proc{|s| s.reverse}, proc{}], :abc
     @c.create(:abc => "hello")
-    DB.sqls.should == ["INSERT INTO items (abc) VALUES ('olleh')"]
+    DB.sqls.must_equal ["INSERT INTO items (abc) VALUES ('olleh')"]
   end
   
   it "should raise an error if specificing serializer as an unregistered symbol" do
-    proc{@c.plugin :serialization, :foo, :abc}.should raise_error(Sequel::Error)
+    proc{@c.plugin :serialization, :foo, :abc}.must_raise(Sequel::Error)
   end
   
   it "should translate values to and from yaml serialization format using accessor methods" do
@@ -97,15 +97,15 @@ describe "Serialization plugin" do
     @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
 
     o = @c.first
-    o.id.should == 1
-    o.abc.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-    o.def.should == "hello"
+    o.id.must_equal 1
+    o.abc.must_equal 1
+    o.abc.must_equal 1
+    o.def.must_equal "hello"
+    o.def.must_equal "hello"
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
@@ -117,15 +117,15 @@ describe "Serialization plugin" do
     @c.dataset._fetch = [:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m')]
 
     o = @c.first
-    o.id.should == 1
-    o.abc.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-    o.def.should == "hello"
+    o.id.must_equal 1
+    o.abc.must_equal 1
+    o.abc.must_equal 1
+    o.def.must_equal "hello"
+    o.def.must_equal "hello"
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')",
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
@@ -137,8 +137,8 @@ describe "Serialization plugin" do
     @c.dataset._fetch = [:id => 1, :abc =>Marshal.dump(1), :def =>Marshal.dump('hello')]
 
     o = @c.first
-    o.abc.should == 1
-    o.def.should == "hello"
+    o.abc.must_equal 1
+    o.def.must_equal "hello"
   end
 
   it "should raise exception for bad marshal data" do
@@ -147,8 +147,8 @@ describe "Serialization plugin" do
     @c.dataset._fetch = [:id => 1, :abc =>'foo', :def =>'bar']
 
     o = @c.first
-    proc{o.abc}.should raise_error
-    proc{o.def}.should raise_error
+    proc{o.abc}.must_raise TypeError, ArgumentError
+    proc{o.def}.must_raise TypeError, ArgumentError
   end
   
   it "should translate values to and from json serialization format using accessor methods" do
@@ -157,16 +157,16 @@ describe "Serialization plugin" do
     @c.dataset._fetch = {:id => 1, :abc => [1].to_json, :def => ["hello"].to_json}
     
     o = @c.first
-    o.id.should == 1
-    o.abc.should == [1]
-    o.abc.should == [1]
-    o.def.should == ["hello"]
-    o.def.should == ["hello"]
+    o.id.must_equal 1
+    o.abc.must_equal [1]
+    o.abc.must_equal [1]
+    o.def.must_equal ["hello"]
+    o.def.must_equal ["hello"]
     
     o.update(:abc => [23])
     @c.create(:abc => [1,2,3])
     
-    DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')",
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
@@ -178,16 +178,16 @@ describe "Serialization plugin" do
     @c.dataset._fetch = {:id => 1, :abc => 'cba', :def => 'olleh'}
     
     o = @c.first
-    o.id.should == 1
-    o.abc.should == 'abc'
-    o.abc.should == 'abc'
-    o.def.should == "hello"
-    o.def.should == "hello"
+    o.id.must_equal 1
+    o.abc.must_equal 'abc'
+    o.abc.must_equal 'abc'
+    o.def.must_equal "hello"
+    o.def.must_equal "hello"
     
     o.update(:abc => 'foo')
     @c.create(:abc => 'bar')
     
-    DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = 'oof' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('rab')",
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
@@ -195,21 +195,22 @@ describe "Serialization plugin" do
 
   it "should handle registration of custom serializer/deserializer pairs" do
     @c.set_primary_key :id
+    require 'sequel/plugins/serialization'
     Sequel::Plugins::Serialization.register_format(:reverse, proc{|s| s.reverse}, proc{|s| s.reverse})
     @c.plugin :serialization, :reverse, :abc, :def
     @c.dataset._fetch = {:id => 1, :abc => 'cba', :def => 'olleh'}
     
     o = @c.first
-    o.id.should == 1
-    o.abc.should == 'abc'
-    o.abc.should == 'abc'
-    o.def.should == "hello"
-    o.def.should == "hello"
+    o.id.must_equal 1
+    o.abc.must_equal 'abc'
+    o.abc.must_equal 'abc'
+    o.def.must_equal "hello"
+    o.def.must_equal "hello"
     
     o.update(:abc => 'foo')
     @c.create(:abc => 'bar')
     
-    DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = 'oof' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('rab')",
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
@@ -221,15 +222,15 @@ describe "Serialization plugin" do
     @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
 
     o = Class.new(@c).first
-    o.id.should == 1
-    o.abc.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-    o.def.should == "hello"
+    o.id.must_equal 1
+    o.abc.must_equal 1
+    o.abc.must_equal 1
+    o.def.must_equal "hello"
+    o.def.must_equal "hello"
 
     o.update(:abc => 23)
     Class.new(@c).create(:abc => [1, 2, 3])
-    DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+    DB.sqls.must_equal ["SELECT * FROM items LIMIT 1",
       "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
       "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
       "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
@@ -240,19 +241,19 @@ describe "Serialization plugin" do
     @c.plugin :serialization, :yaml, :abc, :def
     o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
     o.abc = 23
-    o.deserialized_values.length.should == 1
-    o.abc.should == 23
+    o.deserialized_values.length.must_equal 1
+    o.abc.must_equal 23
     o.refresh
-    o.deserialized_values.length.should == 0
+    o.deserialized_values.length.must_equal 0
   end
   
   it "should not clear the deserialized columns when refreshing after saving a new object" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def
     o = @c.new(:abc => "--- 1\n", :def => "--- hello\n")
-    o.deserialized_values.length.should == 2
+    o.deserialized_values.length.must_equal 2
     o.save
-    o.deserialized_values.length.should == 2
+    o.deserialized_values.length.must_equal 2
   end
   
   it "should not clear the deserialized columns when refreshing after saving a new object with insert_select" do
@@ -261,17 +262,17 @@ describe "Serialization plugin" do
     def (@c.instance_dataset).supports_insert_select?() true end
     def (@c.instance_dataset).insert_select(*) {:id=>1} end
     o = @c.new(:abc => "--- 1\n", :def => "--- hello\n")
-    o.deserialized_values.length.should == 2
+    o.deserialized_values.length.must_equal 2
     o.save
-    o.deserialized_values.length.should == 2
+    o.deserialized_values.length.must_equal 2
   end
   
   it "should raise an error if calling internal serialization methods with bad columns" do
     @c.set_primary_key :id
     @c.plugin :serialization
     o = @c.load(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    lambda{o.send(:serialize_value, :abc, 1)}.should raise_error(Sequel::Error)
-    lambda{o.send(:deserialize_value, :abc, "--- hello\n")}.should raise_error(Sequel::Error)
+    lambda{o.send(:serialize_value, :abc, 1)}.must_raise(Sequel::Error)
+    lambda{o.send(:deserialize_value, :abc, "--- hello\n")}.must_raise(Sequel::Error)
   end
 
   it "should add the accessors to a module included in the class, so they can be easily overridden" do
@@ -282,7 +283,7 @@ describe "Serialization plugin" do
     end
     @c.plugin :serialization, :yaml, :abc
     o = @c.load(:abc => "--- 1\n")
-    o.abc.should == "1-blah"
+    o.abc.must_equal "1-blah"
   end
 
   it "should call super to get the deserialized value from a previous accessor" do
@@ -294,7 +295,7 @@ describe "Serialization plugin" do
     @c.send(:include, m)
     @c.plugin :serialization, :yaml, :abc
     o = @c.load(:abc => 3)
-    o.abc.should == 9
+    o.abc.must_equal 9
   end
 
   it "should work correctly with frozen instances" do
@@ -304,37 +305,37 @@ describe "Serialization plugin" do
 
     o = @c.first
     o.freeze
-    o.abc.should == 1
-    o.abc.should == 1
-    o.def.should == "hello"
-    o.def.should == "hello"
-    proc{o.abc = 2}.should raise_error
-    proc{o.def = 'h'}.should raise_error
+    o.abc.must_equal 1
+    o.abc.must_equal 1
+    o.def.must_equal "hello"
+    o.def.must_equal "hello"
+    proc{o.abc = 2}.must_raise
+    proc{o.def = 'h'}.must_raise
   end
 
   it "should have dup duplicate internal structures" do
     @c.plugin :serialization, :yaml, :abc, :def
     o = @c.new
-    o.dup.deserialized_values.should == o.deserialized_values
-    o.dup.deserialized_values.should_not equal(o.deserialized_values)
+    o.dup.deserialized_values.must_equal o.deserialized_values
+    o.dup.deserialized_values.wont_be_same_as(o.deserialized_values)
   end
 
   it "should have changed_columns include serialized columns if those columns have changed" do
     @c.plugin :serialization, :yaml, :abc, :def
     @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
     o = @c.first
-    o.changed_columns.should == []
+    o.changed_columns.must_equal []
     o.abc = 1
-    o.changed_columns.should == []
+    o.changed_columns.must_equal []
     o.abc = 1
-    o.changed_columns.should == []
+    o.changed_columns.must_equal []
     o.abc = 2
-    o.changed_columns.should == [:abc]
+    o.changed_columns.must_equal [:abc]
     o.def = 'hello'
-    o.changed_columns.should == [:abc]
+    o.changed_columns.must_equal [:abc]
     o.def = 'hello'
-    o.changed_columns.should == [:abc]
+    o.changed_columns.must_equal [:abc]
     o.def = 'hello2'
-    o.changed_columns.should == [:abc, :def]
+    o.changed_columns.must_equal [:abc, :def]
   end
 end