sequel 4.22.0 → 4.23.0

data/spec/extensions/column_conflicts_spec.rb

@@ -11,37 +11,42 @@ describe "column_conflicts plugin" do
 
   it "should have mass assignment work correctly" do
     @o.set_fields({:use_transactions=>3}, [:use_transactions])
-    @o.get_column_value(:use_transactions).should == 3
+    @o.get_column_value(:use_transactions).must_equal 3
   end
 
   it "should handle both symbols and strings" do
-    @o.get_column_value(:model).should == 1
-    @o.get_column_value("model").should == 1
+    @o.get_column_value(:model).must_equal 1
+    @o.get_column_value("model").must_equal 1
     @o.set_column_value(:use_transactions=, 3)
-    @o.get_column_value(:use_transactions).should == 3
+    @o.get_column_value(:use_transactions).must_equal 3
     @o.set_column_value(:use_transactions=, 4)
-    @o.get_column_value(:use_transactions).should == 4
+    @o.get_column_value(:use_transactions).must_equal 4
+  end
+
+  it "should work correctly if there are no conflicts" do
+    @o.get_column_value(:foo).must_equal 4
+    @o.set_column_value(:model=, 2).must_equal 2
   end
 
   it "should allow manual setting of conflicted columns" do
     @c.send(:define_method, :foo){raise}
     @c.get_column_conflict!(:foo)
-    @o.get_column_value(:foo).should == 4
+    @o.get_column_value(:foo).must_equal 4
 
     @c.send(:define_method, :model=){raise}
     @c.set_column_conflict!(:model)
-    @o.set_column_value(:model=, 2).should == 2
-    @o.get_column_value(:model).should == 2
+    @o.set_column_value(:model=, 2).must_equal 2
+    @o.get_column_value(:model).must_equal 2
   end
 
   it "should work correctly in subclasses" do
     @o = Class.new(@c).load(:model=>1, :use_transactions=>2)
-    @o.get_column_value(:model).should == 1
-    @o.get_column_value("model").should == 1
+    @o.get_column_value(:model).must_equal 1
+    @o.get_column_value("model").must_equal 1
     @o.set_column_value(:use_transactions=, 3)
-    @o.get_column_value(:use_transactions).should == 3
+    @o.get_column_value(:use_transactions).must_equal 3
     @o.set_column_value(:use_transactions=, 4)
-    @o.get_column_value(:use_transactions).should == 4
+    @o.get_column_value(:use_transactions).must_equal 4
   end
 
   it "should work correctly for dataset changes" do
@@ -49,7 +54,7 @@ describe "column_conflicts plugin" do
     def ds.columns; [:object_id] end
     @c.dataset = ds
     o = @c.load(:object_id=>3)
-    o.get_column_value(:object_id).should == 3
-    o.object_id.should_not == 3
+    o.get_column_value(:object_id).must_equal 3
+    o.object_id.wont_equal 3
   end
 end

data/spec/extensions/column_select_spec.rb

@@ -15,71 +15,71 @@ describe "Sequel::Plugins::ColumnSelect" do
 
   it "should add a explicit column selections to existing dataset without explicit selection" do
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
+    @Album.dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
 
     @Album.dataset = :albs
-    @Album.dataset.sql.should == 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
+    @Album.dataset.sql.must_equal 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
 
     @Album.dataset = Sequel.identifier(:albs)
-    @Album.dataset.sql.should == 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
+    @Album.dataset.sql.must_equal 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
   end
 
   it "should handle qualified tables" do
     @Album.dataset = :s__albums
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT s.albums.id, s.albums.a, s.albums.b, s.albums.c FROM s.albums'
+    @Album.dataset.sql.must_equal 'SELECT s.albums.id, s.albums.a, s.albums.b, s.albums.c FROM s.albums'
 
     @Album.dataset = Sequel.qualify(:s2, :albums)
-    @Album.dataset.sql.should == 'SELECT s2.albums.id, s2.albums.a, s2.albums.b, s2.albums.c FROM s2.albums'
+    @Album.dataset.sql.must_equal 'SELECT s2.albums.id, s2.albums.a, s2.albums.b, s2.albums.c FROM s2.albums'
   end
 
   it "should handle aliases" do
     @Album.dataset = :albums___a
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT a.id, a.a, a.b, a.c FROM albums AS a'
+    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM albums AS a'
 
     @Album.dataset = Sequel.as(:albums, :b)
-    @Album.dataset.sql.should == 'SELECT b.id, b.a, b.b, b.c FROM albums AS b'
+    @Album.dataset.sql.must_equal 'SELECT b.id, b.a, b.b, b.c FROM albums AS b'
 
     @Album.dataset = :s__albums___a
-    @Album.dataset.sql.should == 'SELECT a.id, a.a, a.b, a.c FROM s.albums AS a'
+    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM s.albums AS a'
 
     @Album.dataset = @Album.db[:albums].from_self
-    @Album.dataset.sql.should == 'SELECT t1.id, t1.a, t1.b, t1.c FROM (SELECT * FROM albums) AS t1'
+    @Album.dataset.sql.must_equal 'SELECT t1.id, t1.a, t1.b, t1.c FROM (SELECT * FROM albums) AS t1'
 
     @Album.dataset = Sequel.as(@Album.db[:albums], :b)
-    @Album.dataset.sql.should == 'SELECT b.id, b.a, b.b, b.c FROM (SELECT * FROM albums) AS b'
+    @Album.dataset.sql.must_equal 'SELECT b.id, b.a, b.b, b.c FROM (SELECT * FROM albums) AS b'
   end
 
   it "should not add a explicit column selection selection on existing dataset with explicit selection" do
     @Album.dataset = @Album.dataset.select(:name)
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT name FROM albums'
+    @Album.dataset.sql.must_equal 'SELECT name FROM albums'
 
     @Album.dataset = @Album.dataset.select(:name, :artist)
-    @Album.dataset.sql.should == 'SELECT name, artist FROM albums'
+    @Album.dataset.sql.must_equal 'SELECT name, artist FROM albums'
   end
 
   it "should not add a explicit column selection on existing dataset with multiple tables" do
     @Album.dataset = @Album.db.from(:a1, :a2)
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT * FROM a1, a2'
+    @Album.dataset.sql.must_equal 'SELECT * FROM a1, a2'
 
     @Album.dataset = @Album.db.from(:a1).cross_join(:a2)
-    @Album.dataset.sql.should == 'SELECT * FROM a1 CROSS JOIN a2'
+    @Album.dataset.sql.must_equal 'SELECT * FROM a1 CROSS JOIN a2'
   end
 
   it "should use explicit column selection for many_to_many associations" do
     @Album.plugin :column_select
     @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j
-    @Album.load(:id=>1).albums_dataset.sql.should == 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
+    @Album.load(:id=>1).albums_dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
   end
 
   it "should set not explicit column selection for many_to_many associations when overriding select" do
     @Album.plugin :column_select
     @Album.dataset = @Album.dataset.select(:a)
     @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j
-    @Album.load(:id=>1).albums_dataset.sql.should == 'SELECT albums.* FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
+    @Album.load(:id=>1).albums_dataset.sql.must_equal 'SELECT albums.* FROM albums INNER JOIN j ON (j.r = albums.id) WHERE (j.l = 1)'
   end
 
   it "should use the schema to get columns if available" do
@@ -88,14 +88,14 @@ describe "Sequel::Plugins::ColumnSelect" do
       [[:t, {}], [:d, {}]]
     end
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT albums.t, albums.d FROM albums'
+    @Album.dataset.sql.must_equal 'SELECT albums.t, albums.d FROM albums'
   end
 
   it "should handle case where schema parsing does not produce results" do
     def @db.supports_schema_parsing?() true end
     def @db.schema_parse_table(t, *) [] end
     @Album.plugin :column_select
-    @Album.dataset.sql.should == 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
+    @Album.dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
   end
 
   it "works correctly when loaded on model without a dataset" do
@@ -103,6 +103,6 @@ describe "Sequel::Plugins::ColumnSelect" do
     c.plugin :column_select
     sc = Class.new(c)
     sc.dataset = @db[:a]
-    sc.dataset.sql.should == "SELECT a.id, a.a, a.b, a.c FROM a"
+    sc.dataset.sql.must_equal "SELECT a.id, a.a, a.b, a.c FROM a"
   end
 end

data/spec/extensions/columns_introspection_spec.rb

@@ -9,83 +9,83 @@ describe "columns_introspection extension" do
     @db.sqls
   end
 
-  specify "should not issue a database query if the columns are already loaded" do
+  it "should not issue a database query if the columns are already loaded" do
     @ds.instance_variable_set(:@columns, [:x])
-    @ds.columns.should == [:x]
-    @db.sqls.length.should == 0
+    @ds.columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
   
-  specify "should handle plain symbols without a database query" do
-    @ds.select(:x).columns.should == [:x]
-    @db.sqls.length.should == 0
+  it "should handle plain symbols without a database query" do
+    @ds.select(:x).columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle qualified symbols without a database query" do
-    @ds.select(:t__x).columns.should == [:x]
-    @db.sqls.length.should == 0
+  it "should handle qualified symbols without a database query" do
+    @ds.select(:t__x).columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle aliased symbols without a database query" do
-    @ds.select(:x___a).columns.should == [:a]
-    @db.sqls.length.should == 0
+  it "should handle aliased symbols without a database query" do
+    @ds.select(:x___a).columns.must_equal [:a]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle qualified and aliased symbols without a database query" do
-    @ds.select(:t__x___a).columns.should == [:a]
-    @db.sqls.length.should == 0
+  it "should handle qualified and aliased symbols without a database query" do
+    @ds.select(:t__x___a).columns.must_equal [:a]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle SQL::Identifiers " do
-    @ds.select(Sequel.identifier(:x)).columns.should == [:x]
-    @db.sqls.length.should == 0
+  it "should handle SQL::Identifiers " do
+    @ds.select(Sequel.identifier(:x)).columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle SQL::QualifiedIdentifiers" do
-    @ds.select(Sequel.qualify(:t, :x)).columns.should == [:x]
-    @ds.select(Sequel.identifier(:x).qualify(:t)).columns.should == [:x]
-    @db.sqls.length.should == 0
+  it "should handle SQL::QualifiedIdentifiers" do
+    @ds.select(Sequel.qualify(:t, :x)).columns.must_equal [:x]
+    @ds.select(Sequel.identifier(:x).qualify(:t)).columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle SQL::AliasedExpressions" do
-    @ds.select(Sequel.as(:x, :a)).columns.should == [:a]
-    @ds.select(Sequel.as(:x, Sequel.identifier(:a))).columns.should == [:a]
-    @db.sqls.length.should == 0
+  it "should handle SQL::AliasedExpressions" do
+    @ds.select(Sequel.as(:x, :a)).columns.must_equal [:a]
+    @ds.select(Sequel.as(:x, Sequel.identifier(:a))).columns.must_equal [:a]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle selecting * from a single subselect with no joins without a database query if the subselect's columns can be handled" do
-    @ds.select(:x).from_self.columns.should == [:x]
-    @db.sqls.length.should == 0
-    @ds.select(:x).from_self.from_self.columns.should == [:x]
-    @db.sqls.length.should == 0
+  it "should handle selecting * from a single subselect with no joins without a database query if the subselect's columns can be handled" do
+    @ds.select(:x).from_self.columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
+    @ds.select(:x).from_self.from_self.columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should handle selecting * from a single table with no joins without a database query if the database has cached schema columns for the table" do
+  it "should handle selecting * from a single table with no joins without a database query if the database has cached schema columns for the table" do
     @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
-    @ds.columns.should == [:x]
-    @db.sqls.length.should == 0
+    @ds.columns.must_equal [:x]
+    @db.sqls.length.must_equal 0
   end
 
-  specify "should issue a database query for multiple subselects or joins" do
+  it "should issue a database query for multiple subselects or joins" do
     @ds.from(@ds.select(:x), @ds.select(:y)).columns
-    @db.sqls.length.should == 1
+    @db.sqls.length.must_equal 1
     @ds.select(:x).from_self.natural_join(:a).columns
-    @db.sqls.length.should == 1
+    @db.sqls.length.must_equal 1
   end
 
-  specify "should issue a database query when common table expressions are used" do
+  it "should issue a database query when common table expressions are used" do
     @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
     def @ds.supports_cte?(*) true end
     @ds.with(:a, @ds).columns
-    @db.sqls.length.should == 1
+    @db.sqls.length.must_equal 1
   end
 
-  specify "should issue a database query if the wildcard is selected" do
+  it "should issue a database query if the wildcard is selected" do
     @ds.columns
-    @db.sqls.length.should == 1
+    @db.sqls.length.must_equal 1
   end
 
-  specify "should issue a database query if an unsupported type is used" do
+  it "should issue a database query if an unsupported type is used" do
     @ds.select(1).columns
-    @db.sqls.length.should == 1
+    @db.sqls.length.must_equal 1
   end
 end

data/spec/extensions/composition_spec.rb

@@ -10,21 +10,21 @@ describe "Composition plugin" do
   end
   
   it ".composition should add compositions" do
-    @o.should_not respond_to(:date)
+    @o.wont_respond_to(:date)
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date.should == Date.new(1, 2, 3)
+    @o.date.must_equal Date.new(1, 2, 3)
   end
 
   it "loading the plugin twice should not remove existing compositions" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @c.plugin :composition
-    @c.compositions.keys.should == [:date]
+    @c.compositions.keys.must_equal [:date]
   end
 
   it ".composition should raise an error if :composer and :decomposer options are not present and :mapping option is not provided" do
-    proc{@c.composition :date}.should raise_error(Sequel::Error)
-    proc{@c.composition :date, :composer=>proc{}, :decomposer=>proc{}}.should_not raise_error
-    proc{@c.composition :date, :mapping=>[]}.should_not raise_error
+    proc{@c.composition :date}.must_raise(Sequel::Error)
+    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
+    @c.composition :date, :mapping=>[]
   end
 
   it "should handle validations of underlying columns" do
@@ -33,45 +33,45 @@ describe "Composition plugin" do
     def o.validate
       [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
     end
-    o.valid?.should == false
+    o.valid?.must_equal false
     o.date = Date.new(1, 2, 3)
-    o.valid?.should == true
+    o.valid?.must_equal true
   end
 
   it "should set column values even when not validating" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @c.load({}).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)
     sql = DB.sqls.last
-    sql.should include("year = 4")
-    sql.should include("month = 8")
-    sql.should include("day = 12")
+    sql.must_include("year = 4")
+    sql.must_include("month = 8")
+    sql.must_include("day = 12")
   end
 
   it ".compositions should return the reflection hash of compositions" do
-    @c.compositions.should == {}
+    @c.compositions.must_equal({})
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.compositions.keys.should == [:date]
+    @c.compositions.keys.must_equal [:date]
     r = @c.compositions.values.first
-    r[:mapping].should == [:year, :month, :day]
-    r[:composer].should be_a_kind_of(Proc)
-    r[:decomposer].should be_a_kind_of(Proc)
+    r[:mapping].must_equal [:year, :month, :day]
+    r[:composer].must_be_kind_of Proc
+    r[:decomposer].must_be_kind_of Proc
   end
 
   it "#compositions should be a hash of cached values of compositions" do
-    @o.compositions.should == {}
+    @o.compositions.must_equal({})
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.date
-    @o.compositions.should == {:date=>Date.new(1, 2, 3)}
+    @o.compositions.must_equal(:date=>Date.new(1, 2, 3))
   end
 
   it "should work with custom :composer and :decomposer options" do
     @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
-    @o.date.should == Date.new(2, 4, 6)
+    @o.date.must_equal Date.new(2, 4, 6)
     @o.save
     sql = DB.sqls.last
-    sql.should include("year = 4")
-    sql.should include("month = 8")
-    sql.should include("day = 12")
+    sql.must_include("year = 4")
+    sql.must_include("month = 8")
+    sql.must_include("day = 12")
   end
 
   it "should allow call super in composition getter and setter method definition in class" do
@@ -84,75 +84,75 @@ describe "Composition plugin" do
         super(v - 3)
       end
     end
-    @o.date.should == Date.new(1, 2, 4)
-    @o.compositions[:date].should == Date.new(1, 2, 3)
+    @o.date.must_equal Date.new(1, 2, 4)
+    @o.compositions[:date].must_equal Date.new(1, 2, 3)
     @o.date = Date.new(1, 3, 5)
-    @o.compositions[:date].should == Date.new(1, 3, 2)
-    @o.date.should == Date.new(1, 3, 3)
+    @o.compositions[:date].must_equal Date.new(1, 3, 2)
+    @o.date.must_equal Date.new(1, 3, 3)
   end
 
   it "should mark the object as modified whenever the composition is set" do
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.modified?.should == false
+    @o.modified?.must_equal false
     @o.date = Date.new(3, 4, 5)
-    @o.modified?.should == true
+    @o.modified?.must_equal true
   end
 
   it "should only decompose existing compositions" do
     called = false
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
-    called.should == false
+    called.must_equal false
     @o.save
-    called.should == false
+    called.must_equal false
     @o.date = Date.new(1,2,3)
-    called.should == false
+    called.must_equal false
     @o.save_changes
-    called.should == true
+    called.must_equal true
   end
 
   it "should clear compositions cache when refreshing" do
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @o.date = Date.new(3, 4, 5)
     @o.refresh
-    @o.compositions.should == {}
+    @o.compositions.must_equal({})
   end
 
   it "should not clear compositions cache when refreshing after save" do
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {:date=>Date.new(3, 4, 5)}
+    @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
   end
 
   it "should not clear compositions cache when saving with insert_select" do
     def (@c.instance_dataset).supports_insert_select?() true end
     def (@c.instance_dataset).insert_select(*) {:id=>1} end
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {:date=>Date.new(3, 4, 5)}
+    @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
   end
 
   it "should instantiate compositions lazily" do
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.compositions.should == {}
+    @o.compositions.must_equal({})
     @o.date
-    @o.compositions.should == {:date=>Date.new(1,2,3)}
+    @o.compositions.must_equal(:date=>Date.new(1,2,3))
   end
 
   it "should cache value of composition" do
     times = 0
     @c.composition :date, :composer=>proc{times+=1}, :decomposer=>proc{}
-    times.should == 0
+    times.must_equal 0
     @o.date
-    times.should == 1
+    times.must_equal 1
     @o.date
-    times.should == 1
+    times.must_equal 1
   end
 
   it ":class option should take an string, symbol, or class" do
     @c.composition :date1, :class=>'Date', :mapping=>[:year, :month, :day]
     @c.composition :date2, :class=>:Date, :mapping=>[:year, :month, :day]
     @c.composition :date3, :class=>Date, :mapping=>[:year, :month, :day]
-    @o.date1.should == Date.new(1, 2, 3)
-    @o.date2.should == Date.new(1, 2, 3)
-    @o.date3.should == Date.new(1, 2, 3)
+    @o.date1.must_equal Date.new(1, 2, 3)
+    @o.date2.must_equal Date.new(1, 2, 3)
+    @o.date3.must_equal Date.new(1, 2, 3)
   end
 
   it ":mapping option should work with a single array of symbols" do
@@ -168,13 +168,13 @@ describe "Composition plugin" do
       end
     end
     @c.composition :date, :class=>c, :mapping=>[:year, :month]
-    @o.date.year.should == 2
-    @o.date.month.should == 6
+    @o.date.year.must_equal 2
+    @o.date.month.must_equal 6
     @o.date = c.new(3, 4)
     @o.save
     sql = DB.sqls.last
-    sql.should include("year = 6")
-    sql.should include("month = 12")
+    sql.must_include("year = 6")
+    sql.must_include("month = 12")
   end
 
   it ":mapping option should work with an array of two pairs of symbols" do
@@ -190,18 +190,18 @@ describe "Composition plugin" do
       end
     end
     @c.composition :date, :class=>c, :mapping=>[[:year, :y], [:month, :m]]
-    @o.date.y.should == 2
-    @o.date.m.should == 6
+    @o.date.y.must_equal 2
+    @o.date.m.must_equal 6
     @o.date = c.new(3, 4)
     @o.save
     sql = DB.sqls.last
-    sql.should include("year = 6")
-    sql.should include("month = 12")
+    sql.must_include("year = 6")
+    sql.must_include("month = 12")
   end
 
   it ":mapping option :composer should return nil if all values are nil" do
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.new.date.should == nil
+    @c.new.date.must_equal nil
   end
 
   it ":mapping option :decomposer should set all related fields to nil if nil" do
@@ -209,34 +209,34 @@ describe "Composition plugin" do
     @o.date = nil
     @o.save
     sql = DB.sqls.last
-    sql.should include("year = NULL")
-    sql.should include("month = NULL")
-    sql.should include("day = NULL")
+    sql.must_include("year = NULL")
+    sql.must_include("month = NULL")
+    sql.must_include("day = NULL")
   end
 
   it "should work with frozen instances" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.freeze
-    @o.date.should == Date.new(1, 2, 3)
-    proc{@o.date = Date.today}.should raise_error
+    @o.date.must_equal Date.new(1, 2, 3)
+    proc{@o.date = Date.today}.must_raise
   end
 
   it "should have #dup duplicate compositions" do
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date.should == Date.new(1, 2, 3)
-    @o.dup.compositions.should == @o.compositions
-    @o.dup.compositions.should_not equal(@o.compositions)
+    @o.date.must_equal Date.new(1, 2, 3)
+    @o.dup.compositions.must_equal @o.compositions
+    @o.dup.compositions.wont_be_same_as(@o.compositions)
   end
 
   it "should work correctly with subclasses" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     c = Class.new(@c)
     o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
-    o.date.should == Date.new(1, 2, 3)
+    o.date.must_equal Date.new(1, 2, 3)
     o.save
     sql = DB.sqls.last
-    sql.should include("year = 1")
-    sql.should include("month = 2")
-    sql.should include("day = 3")
+    sql.must_include("year = 1")
+    sql.must_include("month = 2")
+    sql.must_include("day = 3")
   end
 end