sequel 4.22.0 → 4.23.0

data/spec/extensions/dataset_source_alias_spec.rb

@@ -7,45 +7,45 @@ describe "dataset_source_alias extension" do
   end
 
   it "should automatically alias datasets to their first source in #from" do
-    @db[@db[:a]].sql.should == 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db[:a, @db[:b]].sql.should == 'SELECT * FROM a, (SELECT * FROM b) AS b'
+    @db[@db[:a]].sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
+    @db[:a, @db[:b]].sql.must_equal 'SELECT * FROM a, (SELECT * FROM b) AS b'
   end
 
   it "should handle virtual row blocks in #from" do
-    @db.dataset.from{|_| @db[:a]}.sql.should == 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db.dataset.from(:a){|_| @db[:b]}.sql.should == 'SELECT * FROM a, (SELECT * FROM b) AS b'
+    @db.dataset.from{|_| @db[:a]}.sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
+    @db.dataset.from(:a){|_| @db[:b]}.sql.must_equal 'SELECT * FROM a, (SELECT * FROM b) AS b'
   end
 
   it "should automatically alias datasets to their first source in #join" do
-    @db[:a].cross_join(@db[:b]).sql.should == 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS b'
+    @db[:a].cross_join(@db[:b]).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS b'
   end
 
   it "should handle :table_alias option when joining" do
-    @db[:a].cross_join(@db[:b], :table_alias=>:c).sql.should == 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS c'
+    @db[:a].cross_join(@db[:b], :table_alias=>:c).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS c'
   end
 
   it "should handle aliasing issues automatically" do
-    @db[:a, @db[:a]].sql.should == 'SELECT * FROM a, (SELECT * FROM a) AS a_0'
-    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.sql.should == 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1'
-    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.cross_join(@db[:a]).sql.should == 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1 CROSS JOIN (SELECT * FROM a) AS a_2'
+    @db[:a, @db[:a]].sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0'
+    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1'
+    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.cross_join(@db[:a]).sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1 CROSS JOIN (SELECT * FROM a) AS a_2'
   end
 
   it "should handle from_self" do
-    @db[:a].from_self.sql.should == 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db[:a].from_self.from_self.sql.should == 'SELECT * FROM (SELECT * FROM (SELECT * FROM a) AS a) AS a'
+    @db[:a].from_self.sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
+    @db[:a].from_self.from_self.sql.must_equal 'SELECT * FROM (SELECT * FROM (SELECT * FROM a) AS a) AS a'
   end
 
   it "should handle datasets without sources" do
-    @db[@db.select(1)].sql.should == 'SELECT * FROM (SELECT 1) AS t1'
-    @db[:t, @db.select(1)].sql.should == 'SELECT * FROM t, (SELECT 1) AS t1'
-    @db[:a].cross_join(@db.select(1)).sql.should == 'SELECT * FROM a CROSS JOIN (SELECT 1) AS t1'
+    @db[@db.select(1)].sql.must_equal 'SELECT * FROM (SELECT 1) AS t1'
+    @db[:t, @db.select(1)].sql.must_equal 'SELECT * FROM t, (SELECT 1) AS t1'
+    @db[:a].cross_join(@db.select(1)).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT 1) AS t1'
   end
 
   it "should handle datasets selecting from functions" do
-    @db.dataset.from{|o| @db[o.f(:a)]}.sql.should == 'SELECT * FROM (SELECT * FROM f(a)) AS t1'
+    @db.dataset.from{|o| @db[o.f(:a)]}.sql.must_equal 'SELECT * FROM (SELECT * FROM f(a)) AS t1'
   end
 
   it "should handle datasets with literal SQL" do
-    @db.from(@db['SELECT c FROM d']).sql.should == 'SELECT * FROM (SELECT c FROM d) AS t1'
+    @db.from(@db['SELECT c FROM d']).sql.must_equal 'SELECT * FROM (SELECT c FROM d) AS t1'
   end
 end

data/spec/extensions/date_arithmetic_spec.rb

@@ -25,133 +25,126 @@ describe "date_arithmetic extension" do
 
   it "should have Sequel.date_add with an interval hash return an appropriate Sequel::SQL::DateAdd expression" do
     da = Sequel.date_add(:a, :days=>1)
-    da.should be_a_kind_of(Sequel::SQL::DateAdd)
-    da.expr.should == :a
-    da.interval.should == {:days=>1}
-    Sequel.date_add(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.should == {:years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1}
+    da.must_be_kind_of(Sequel::SQL::DateAdd)
+    da.expr.must_equal :a
+    da.interval.must_equal(:days=>1)
+    Sequel.date_add(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.must_equal(:years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1)
   end
 
   it "should have Sequel.date_sub with an interval hash return an appropriate Sequel::SQL::DateAdd expression" do
     da = Sequel.date_sub(:a, :days=>1)
-    da.should be_a_kind_of(Sequel::SQL::DateAdd)
-    da.expr.should == :a
-    da.interval.should == {:days=>-1}
-    Sequel.date_sub(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.should == {:years=>-1, :months=>-2, :days=>-3, :hours=>-1, :minutes=>-1, :seconds=>-1}
+    da.must_be_kind_of(Sequel::SQL::DateAdd)
+    da.expr.must_equal :a
+    da.interval.must_equal(:days=>-1)
+    Sequel.date_sub(:a, :years=>1, :months=>2, :days=>3, :hours=>1, :minutes=>1, :seconds=>1).interval.must_equal(:years=>-1, :months=>-2, :days=>-3, :hours=>-1, :minutes=>-1, :seconds=>-1)
   end
 
   it "should have Sequel.date_* with an interval hash handle nil values" do
-    Sequel.date_sub(:a, :days=>1, :hours=>nil).interval.should == {:days=>-1}
+    Sequel.date_sub(:a, :days=>1, :hours=>nil).interval.must_equal(:days=>-1)
   end
 
   it "should raise an error if given string values in an interval hash" do
-    lambda{Sequel.date_add(:a, :days=>'1')}.should raise_error(Sequel::InvalidValue)
+    lambda{Sequel.date_add(:a, :days=>'1')}.must_raise(Sequel::InvalidValue)
   end
 
   if asd
     it "should have Sequel.date_add with an ActiveSupport::Duration return an appropriate Sequel::SQL::DateAdd expression" do
       da = Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:days, 1]]))
-      da.should be_a_kind_of(Sequel::SQL::DateAdd)
-      da.expr.should == :a
-      da.interval.should == {:days=>1}
-      Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.should == {:years=>1, :months=>1, :days=>1, :minutes=>61, :seconds=>1}
+      da.must_be_kind_of(Sequel::SQL::DateAdd)
+      da.expr.must_equal :a
+      da.interval.must_equal(:days=>1)
+      Sequel.date_add(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.must_equal(:years=>1, :months=>1, :days=>1, :minutes=>61, :seconds=>1)
     end
 
     it "should have Sequel.date_sub with an ActiveSupport::Duration return an appropriate Sequel::SQL::DateAdd expression" do
       da = Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:days, 1]]))
-      da.should be_a_kind_of(Sequel::SQL::DateAdd)
-      da.expr.should == :a
-      da.interval.should == {:days=>-1}
-      Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.should == {:years=>-1, :months=>-1, :days=>-1, :minutes=>-61, :seconds=>-1}
+      da.must_be_kind_of(Sequel::SQL::DateAdd)
+      da.expr.must_equal :a
+      da.interval.must_equal(:days=>-1)
+      Sequel.date_sub(:a, ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])).interval.must_equal(:years=>-1, :months=>-1, :days=>-1, :minutes=>-61, :seconds=>-1)
     end
   end
 
   it "should correctly literalize on Postgres" do
     db = dbf.call(:postgres)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "(CAST(a AS timestamp) + CAST('1 days ' AS interval))"
-    db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "(CAST(a AS timestamp) + CAST('1 days ' AS interval))"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "(CAST(a AS timestamp) + CAST('1 years 1 months 1 days 1 hours 1 minutes 1 seconds ' AS interval))"
   end
 
   it "should correctly literalize on SQLite" do
     db = dbf.call(:sqlite)
-    db.literal(Sequel.date_add(:a, @h0)).should == "datetime(a)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "datetime(a, '1 days')"
-    db.literal(Sequel.date_add(:a, @h2)).should == "datetime(a, '1 years', '1 months', '1 days', '1 hours', '1 minutes', '1 seconds')"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "datetime(a)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "datetime(a, '1 days')"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "datetime(a, '1 years', '1 months', '1 days', '1 hours', '1 minutes', '1 seconds')"
   end
 
   it "should correctly literalize on MySQL" do
     db = dbf.call(:mysql)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS DATETIME)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "DATE_ADD(a, INTERVAL 1 DAY)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(a, INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS DATETIME)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(a, INTERVAL 1 DAY)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(a, INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
   end
 
   it "should correctly literalize on HSQLDB" do
     db = Sequel.mock
     def db.database_type; :hsqldb end
     db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(CAST(a AS timestamp) AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "DATE_ADD(CAST(a AS timestamp), INTERVAL 1 DAY)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS timestamp), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(CAST(a AS timestamp) AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATE_ADD(CAST(a AS timestamp), INTERVAL 1 DAY)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(DATE_ADD(CAST(a AS timestamp), INTERVAL 1 YEAR), INTERVAL 1 MONTH), INTERVAL 1 DAY), INTERVAL 1 HOUR), INTERVAL 1 MINUTE), INTERVAL 1 SECOND)"
   end
 
   it "should correctly literalize on MSSQL" do
     db = dbf.call(:mssql)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS datetime)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "DATEADD(day, 1, a)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, a))))))"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS datetime)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD(day, 1, a)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD(second, 1, DATEADD(minute, 1, DATEADD(hour, 1, DATEADD(day, 1, DATEADD(month, 1, DATEADD(year, 1, a))))))"
   end
 
   it "should correctly literalize on H2" do
     db = Sequel.mock
     def db.database_type; :h2 end
     db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "DATEADD('day', 1, a)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "DATEADD('second', 1, DATEADD('minute', 1, DATEADD('hour', 1, DATEADD('day', 1, DATEADD('month', 1, DATEADD('year', 1, a))))))"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD('day', 1, a)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD('second', 1, DATEADD('minute', 1, DATEADD('hour', 1, DATEADD('day', 1, DATEADD('month', 1, DATEADD('year', 1, a))))))"
   end
 
   it "should correctly literalize on access" do
     db = dbf.call(:access)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CDate(a)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "DATEADD('d', 1, a)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "DATEADD('s', 1, DATEADD('n', 1, DATEADD('h', 1, DATEADD('d', 1, DATEADD('m', 1, DATEADD('yyyy', 1, a))))))"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CDate(a)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "DATEADD('d', 1, a)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "DATEADD('s', 1, DATEADD('n', 1, DATEADD('h', 1, DATEADD('d', 1, DATEADD('m', 1, DATEADD('yyyy', 1, a))))))"
   end
 
   it "should correctly literalize on Derby" do
     db = Sequel.mock
     def db.database_type; :derby end
     db.extension :date_arithmetic
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "{fn timestampadd(SQL_TSI_DAY, 1, timestamp(a))}"
-    db.literal(Sequel.date_add(:a, @h2)).should == "{fn timestampadd(SQL_TSI_SECOND, 1, timestamp({fn timestampadd(SQL_TSI_MINUTE, 1, timestamp({fn timestampadd(SQL_TSI_HOUR, 1, timestamp({fn timestampadd(SQL_TSI_DAY, 1, timestamp({fn timestampadd(SQL_TSI_MONTH, 1, timestamp({fn timestampadd(SQL_TSI_YEAR, 1, timestamp(a))}))}))}))}))}))}"
-    db.literal(Sequel.date_add(Date.civil(2012, 11, 12), @h1)).should == "{fn timestampadd(SQL_TSI_DAY, 1, timestamp((CAST('2012-11-12' AS varchar(255)) || ' 00:00:00')))}"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "{fn timestampadd(SQL_TSI_DAY, 1, timestamp(a))}"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "{fn timestampadd(SQL_TSI_SECOND, 1, timestamp({fn timestampadd(SQL_TSI_MINUTE, 1, timestamp({fn timestampadd(SQL_TSI_HOUR, 1, timestamp({fn timestampadd(SQL_TSI_DAY, 1, timestamp({fn timestampadd(SQL_TSI_MONTH, 1, timestamp({fn timestampadd(SQL_TSI_YEAR, 1, timestamp(a))}))}))}))}))}))}"
+    db.literal(Sequel.date_add(Date.civil(2012, 11, 12), @h1)).must_equal "{fn timestampadd(SQL_TSI_DAY, 1, timestamp((CAST('2012-11-12' AS varchar(255)) || ' 00:00:00')))}"
   end
 
   it "should correctly literalize on Oracle" do
     db = dbf.call(:oracle)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "(a + INTERVAL '1' DAY)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "(a + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "(a + INTERVAL '1' DAY)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "(a + INTERVAL '1' YEAR + INTERVAL '1' MONTH + INTERVAL '1' DAY + INTERVAL '1' HOUR + INTERVAL '1' MINUTE + INTERVAL '1' SECOND)"
   end
 
   it "should correctly literalize on DB2" do
     db = dbf.call(:db2)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "(CAST(a AS timestamp) + 1 days)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
+    db.literal(Sequel.date_add(:a, @h0)).must_equal "CAST(a AS timestamp)"
+    db.literal(Sequel.date_add(:a, @h1)).must_equal "(CAST(a AS timestamp) + 1 days)"
+    db.literal(Sequel.date_add(:a, @h2)).must_equal "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
   end
 
-  it "should correctly literalize on Fdbsql" do
-    db = dbf.call(:fdbsql)
-    db.literal(Sequel.date_add(:a, @h0)).should == "CAST(a AS timestamp)"
-    db.literal(Sequel.date_add(:a, @h1)).should == "(a + INTERVAL 1 day)"
-    db.literal(Sequel.date_add(:a, @h2)).should == "(a + INTERVAL 1 year + INTERVAL 1 month + INTERVAL 1 day + INTERVAL 1 hour + INTERVAL 1 minute + INTERVAL 1 second)"
-  end
-
-  specify "should raise error if literalizing on an unsupported database" do
+  it "should raise error if literalizing on an unsupported database" do
     db = Sequel.mock
     db.extension :date_arithmetic
-    lambda{db.literal(Sequel.date_add(:a, @h0))}.should raise_error(Sequel::Error)
+    lambda{db.literal(Sequel.date_add(:a, @h0))}.must_raise(Sequel::Error)
   end
 end

data/spec/extensions/defaults_setter_spec.rb

@@ -15,36 +15,36 @@ describe "Sequel::Plugins::DefaultsSetter" do
   end
 
   it "should set default value upon initialization" do
-    @pr.call(2).new.a.should == 2
+    @pr.call(2).new.a.must_equal 2
   end
 
   it "should not mark the column as modified" do
-    @pr.call(2).new.changed_columns.should == []
+    @pr.call(2).new.changed_columns.must_equal []
   end
 
   it "should not set a default of nil" do
-    @pr.call(nil).new.class.default_values.should == {}
+    @pr.call(nil).new.class.default_values.must_equal({})
   end
 
   it "should set a default of false" do
-    @pr.call(false).new.a.should == false
+    @pr.call(false).new.a.must_equal false
   end
 
   it "should handle Sequel::CURRENT_DATE default by using the current Date" do
-    @pr.call(Sequel::CURRENT_DATE).new.a.should == Date.today
+    @pr.call(Sequel::CURRENT_DATE).new.a.must_equal Date.today
   end
 
   it "should handle Sequel::CURRENT_TIMESTAMP default by using the current Time" do
     t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
-    t.should be_a_kind_of(Time)
-    (t - Time.now).should < 1
+    t.must_be_kind_of(Time)
+    (t - Time.now).must_be :<,  1
   end
 
   it "should handle Sequel::CURRENT_TIMESTAMP default by using the current DateTime if Sequel.datetime_class is DateTime" do
     Sequel.datetime_class = DateTime
     t = @pr.call(Sequel::CURRENT_TIMESTAMP).new.a
-    t.should be_a_kind_of(DateTime)
-    (t - DateTime.now).should < 1/86400.0
+    t.must_be_kind_of(DateTime)
+    (t - DateTime.now).must_be :<,  1/86400.0
   end
 
   it "should work correctly with the current_datetime_timestamp extension" do
@@ -56,46 +56,46 @@ describe "Sequel::Plugins::DefaultsSetter" do
     o = c.new
     o.a = o.a
     o.save
-    @db.sqls.should == ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE (id = 1) LIMIT 1"]
+    @db.sqls.must_equal ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE (id = 1) LIMIT 1"]
   end
 
   it "should not override a given value" do
     @pr.call(2)
-    @c.new('a'=>3).a.should == 3
-    @c.new('a'=>nil).a.should == nil
+    @c.new('a'=>3).a.must_equal 3
+    @c.new('a'=>nil).a.must_equal nil
   end
 
   it "should work correctly when subclassing" do
-    Class.new(@pr.call(2)).new.a.should == 2
+    Class.new(@pr.call(2)).new.a.must_equal 2
   end
 
   it "should contain the default values in default_values" do
-    @pr.call(2).default_values.should == {:a=>2}
-    @pr.call(nil).default_values.should == {}
+    @pr.call(2).default_values.must_equal(:a=>2)
+    @pr.call(nil).default_values.must_equal({})
   end
 
   it "should allow modifications of default values" do
     @pr.call(2)
     @c.default_values[:a] = 3
-    @c.new.a.should == 3
+    @c.new.a.must_equal 3
   end
 
   it "should allow proc default values" do
     @pr.call(2)
     @c.default_values[:a] = proc{3}
-    @c.new.a.should == 3
+    @c.new.a.must_equal 3
   end
 
   it "should have procs that set default values set them to nil" do
     @pr.call(2)
     @c.default_values[:a] = proc{nil}
-    @c.new.a.should == nil
+    @c.new.a.must_equal nil
   end
 
   it "should work correctly on a model without a dataset" do
     @pr.call(2)
     c = Class.new(Sequel::Model(@db[:bar]))
     c.plugin :defaults_setter
-    c.default_values.should == {:a=>2}
+    c.default_values.must_equal(:a=>2)
   end
 end

data/spec/extensions/delay_add_association_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DelayAddAssociation" do
+  before do
+    @db = Sequel.mock(:autoid=>1, :numrows=>1, :fetch=>{:id=>1, :name=>'a', :c_id=>nil})
+    @c = Class.new(Sequel::Model(@db[:cs]))
+    @c.send(:define_method, :save){|*| super(:changed=>true)}
+    @c.plugin :delay_add_association
+    @c.columns :id, :name, :c_id
+    @c.one_to_many :cs, :class=>@c, :key=>:c_id
+    @db.sqls
+  end
+
+  it "should delay adding of the association until after creation" do
+    @o = @c.new(:name=>'a')
+    @o.add_c(@c.load(:id=>2, :name=>'b'))
+    @db.sqls.must_equal []
+    @o.save
+    @db.sqls.must_equal ["INSERT INTO cs (name) VALUES ('a')", "UPDATE cs SET c_id = 1 WHERE (id = 2)", "SELECT * FROM cs WHERE (id = 1) LIMIT 1"]
+  end
+
+  it "should immediately reflect changes in cached association" do
+    @o = @c.new(:name=>'a')
+    o = @c.load(:id=>2, :name=>'b')
+    @o.add_c(o)
+    @o.cs.must_equal [o]
+    @db.sqls.must_equal []
+  end
+
+  it "should not affect adding associations to existing rows" do
+    @o = @c.load(:id=>1, :name=>'a')
+    @o.add_c(@c.load(:id=>2, :name=>'b'))
+    @db.sqls.must_equal ["UPDATE cs SET c_id = 1 WHERE (id = 2)"]
+  end
+
+  it "should raise an error when saving if the associated object is invalid" do
+    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
+    @o = @c.new(:name=>'a')
+    @o.add_c(@c.load(:id=>2, :name=>'b'))
+    proc{@o.save}.must_raise Sequel::ValidationFailed
+  end
+
+  it "should return nil when saving if the associated object is invalid when raise_on_save_failure is false" do
+    @c.raise_on_save_failure = false
+    @c.send(:define_method, :validate){|*| errors.add(:name, 'is b') if name == 'b'}
+    @o = @c.new(:name=>'a')
+    @o.add_c(@c.load(:id=>2, :name=>'b'))
+    @o.save.must_equal nil
+    @o.errors[:cs].must_equal ["name is b"]
+    @o.cs.first.errors[:name].must_equal ['is b']
+  end
+end

data/spec/extensions/dirty_spec.rb

@@ -8,104 +8,104 @@ describe "Sequel::Plugins::Dirty" do
     @c.columns :initial, :initial_changed, :missing, :missing_changed
   end
 
-  shared_examples_for "dirty plugin" do
+  dirty_plugin_specs = shared_description do
     it "initial_value should be the current value if value has not changed" do
-      @o.initial_value(:initial).should == 'i'
-      @o.initial_value(:missing).should == nil
+      @o.initial_value(:initial).must_equal 'i'
+      @o.initial_value(:missing).must_equal nil
     end
 
     it "initial_value should be the intial value if value has changed" do
-      @o.initial_value(:initial_changed).should == 'ic'
-      @o.initial_value(:missing_changed).should == nil
+      @o.initial_value(:initial_changed).must_equal 'ic'
+      @o.initial_value(:missing_changed).must_equal nil
     end
 
     it "initial_value should handle case where initial value is reassigned later" do
       @o.initial_changed = 'ic'
-      @o.initial_value(:initial_changed).should == 'ic'
+      @o.initial_value(:initial_changed).must_equal 'ic'
       @o.missing_changed = nil
-      @o.initial_value(:missing_changed).should == nil
+      @o.initial_value(:missing_changed).must_equal nil
     end
 
     it "changed_columns should handle case where initial value is reassigned later" do
-      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.changed_columns.must_equal [:initial_changed, :missing_changed]
       @o.initial_changed = 'ic'
-      @o.changed_columns.should == [:missing_changed]
+      @o.changed_columns.must_equal [:missing_changed]
       @o.missing_changed = nil
-      @o.changed_columns.should == [:missing_changed]
+      @o.changed_columns.must_equal [:missing_changed]
     end
 
     it "column_change should give initial and current values if there has been a change made" do
-      @o.column_change(:initial_changed).should == ['ic', 'ic2']
-      @o.column_change(:missing_changed).should == [nil, 'mc2']
+      @o.column_change(:initial_changed).must_equal ['ic', 'ic2']
+      @o.column_change(:missing_changed).must_equal [nil, 'mc2']
     end
 
     it "column_change should be nil if no change has been made" do
-      @o.column_change(:initial).should == nil
-      @o.column_change(:missing).should == nil
+      @o.column_change(:initial).must_equal nil
+      @o.column_change(:missing).must_equal nil
     end
 
     it "column_changed? should return whether the column has changed" do
-      @o.column_changed?(:initial).should == false
-      @o.column_changed?(:initial_changed).should == true
-      @o.column_changed?(:missing).should == false
-      @o.column_changed?(:missing_changed).should == true
+      @o.column_changed?(:initial).must_equal false
+      @o.column_changed?(:initial_changed).must_equal true
+      @o.column_changed?(:missing).must_equal false
+      @o.column_changed?(:missing_changed).must_equal true
     end
 
     it "column_changed? should handle case where initial value is reassigned later" do
       @o.initial_changed = 'ic'
-      @o.column_changed?(:initial_changed).should == false
+      @o.column_changed?(:initial_changed).must_equal false
       @o.missing_changed = nil
-      @o.column_changed?(:missing_changed).should == false
+      @o.column_changed?(:missing_changed).must_equal false
     end
 
     it "changed_columns should handle case where initial value is reassigned later" do
-      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.changed_columns.must_equal [:initial_changed, :missing_changed]
       @o.initial_changed = 'ic'
-      @o.changed_columns.should == [:missing_changed]
+      @o.changed_columns.must_equal [:missing_changed]
       @o.missing_changed = nil
-      @o.changed_columns.should == [:missing_changed]
+      @o.changed_columns.must_equal [:missing_changed]
     end
 
     it "column_changes should give initial and current values" do
-      @o.column_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+      @o.column_changes.must_equal(:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2'])
     end
 
     it "reset_column should reset the column to its initial value" do
       @o.reset_column(:initial)
-      @o.initial.should == 'i'
+      @o.initial.must_equal 'i'
       @o.reset_column(:initial_changed)
-      @o.initial_changed.should == 'ic'
+      @o.initial_changed.must_equal 'ic'
       @o.reset_column(:missing)
-      @o.missing.should == nil
+      @o.missing.must_equal nil
       @o.reset_column(:missing_changed)
-      @o.missing_changed.should == nil
+      @o.missing_changed.must_equal nil
     end
 
     it "reset_column should remove missing values from the values" do
       @o.reset_column(:missing)
-      @o.values.has_key?(:missing).should == false
+      @o.values.has_key?(:missing).must_equal false
       @o.reset_column(:missing_changed)
-      @o.values.has_key?(:missing_changed).should == false
+      @o.values.has_key?(:missing_changed).must_equal false
     end
     
     it "refresh should clear the cached initial values" do
       @o.refresh
-      @o.column_changes.should == {}
+      @o.column_changes.must_equal({})
     end
     
     it "will_change_column should be used to signal in-place modification to column" do
       @o.will_change_column(:initial)
       @o.initial << 'b'
-      @o.column_change(:initial).should == ['i', 'ib']
+      @o.column_change(:initial).must_equal ['i', 'ib']
       @o.will_change_column(:initial_changed)
       @o.initial_changed << 'b'
-      @o.column_change(:initial_changed).should == ['ic', 'ic2b']
+      @o.column_change(:initial_changed).must_equal ['ic', 'ic2b']
       @o.will_change_column(:missing)
       @o.values[:missing] = 'b'
-      @o.column_change(:missing).should == [nil, 'b']
+      @o.column_change(:missing).must_equal [nil, 'b']
       @o.will_change_column(:missing_changed)
       @o.missing_changed << 'b'
-      @o.column_change(:missing_changed).should == [nil, 'mc2b']
+      @o.column_change(:missing_changed).must_equal [nil, 'mc2b']
     end
 
     it "will_change_column should different types of existing objects" do
@@ -113,23 +113,23 @@ describe "Sequel::Plugins::Dirty" do
         o = @c.new(:initial=>v)
         o.will_change_column(:initial)
         o.initial = 'a'
-        o.column_change(:initial).should == [v, 'a']
+        o.column_change(:initial).must_equal [v, 'a']
       end
     end
 
     it "should work when freezing objects" do
       @o.freeze
-      @o.initial_value(:initial).should == 'i'
-      proc{@o.initial = 'b'}.should raise_error
+      @o.initial_value(:initial).must_equal 'i'
+      proc{@o.initial = 'b'}.must_raise
     end
 
     it "should have #dup duplicate structures" do
-      @o.dup.initial_values.should == @o.initial_values
-      @o.dup.initial_values.should_not equal(@o.initial_values)
-      @o.dup.instance_variable_get(:@missing_initial_values).should == @o.instance_variable_get(:@missing_initial_values)
-      @o.dup.instance_variable_get(:@missing_initial_values).should_not equal(@o.instance_variable_get(:@missing_initial_values))
-      @o.dup.previous_changes.should == @o.previous_changes
-      @o.dup.previous_changes.should_not equal(@o.previous_changes) if @o.previous_changes
+      @o.dup.initial_values.must_equal @o.initial_values
+      @o.dup.initial_values.wont_be_same_as(@o.initial_values)
+      @o.dup.instance_variable_get(:@missing_initial_values).must_equal @o.instance_variable_get(:@missing_initial_values)
+      @o.dup.instance_variable_get(:@missing_initial_values).wont_be_same_as(@o.instance_variable_get(:@missing_initial_values))
+      @o.dup.previous_changes.must_equal @o.previous_changes
+      @o.dup.previous_changes.wont_be_same_as(@o.previous_changes) if @o.previous_changes
     end
   end
 
@@ -140,18 +140,18 @@ describe "Sequel::Plugins::Dirty" do
       @o.missing_changed = 'mc2'
     end
 
-    it_should_behave_like "dirty plugin"
+    include dirty_plugin_specs
 
     it "save should clear the cached initial values" do
       @o.save
-      @o.column_changes.should == {}
+      @o.column_changes.must_equal({})
     end
 
     it "save_changes should clear the cached initial values" do
       def (@c.instance_dataset).supports_insert_select?() true end
       def (@c.instance_dataset).insert_select(*) {:id=>1} end
       @o.save
-      @o.column_changes.should == {}
+      @o.column_changes.must_equal({})
     end
   end
 
@@ -162,19 +162,19 @@ describe "Sequel::Plugins::Dirty" do
       @o.missing_changed = 'mc2'
     end
 
-    it_should_behave_like "dirty plugin"
+    include dirty_plugin_specs
 
     it "previous_changes should be the previous changes after saving" do
       @o.save
-      @o.previous_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+      @o.previous_changes.must_equal(:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2'])
     end
 
     it "should work when freezing objects after saving" do
       @o.initial = 'a'
       @o.save
       @o.freeze
-      @o.previous_changes[:initial].should == ['i', 'a']
-      proc{@o.initial = 'b'}.should raise_error
+      @o.previous_changes[:initial].must_equal ['i', 'a']
+      proc{@o.initial = 'b'}.must_raise
     end
   end
 end