sequel 4.22.0 → 4.23.0

data/spec/extensions/string_date_time_spec.rb

@@ -3,13 +3,13 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 Sequel.extension :string_date_time
 
 describe "String#to_time" do
-  specify "should convert the string into a Time object" do
-    "2007-07-11".to_time.should == Time.parse("2007-07-11")
-    "06:30".to_time.should == Time.parse("06:30")
+  it "should convert the string into a Time object" do
+    "2007-07-11".to_time.must_equal Time.parse("2007-07-11")
+    "06:30".to_time.must_equal Time.parse("06:30")
   end
   
-  specify "should raise InvalidValue for an invalid time" do
-    proc {'0000-00-00'.to_time}.should raise_error(Sequel::InvalidValue)
+  it "should raise InvalidValue for an invalid time" do
+    proc {'0000-00-00'.to_time}.must_raise(Sequel::InvalidValue)
   end
 end
 
@@ -18,21 +18,21 @@ describe "String#to_date" do
     Sequel.convert_two_digit_years = true
   end
 
-  specify "should convert the string into a Date object" do
-    "2007-07-11".to_date.should == Date.parse("2007-07-11")
+  it "should convert the string into a Date object" do
+    "2007-07-11".to_date.must_equal Date.parse("2007-07-11")
   end
   
-  specify "should convert 2 digit years by default" do
-    "July 11, 07".to_date.should == Date.parse("2007-07-11")
+  it "should convert 2 digit years by default" do
+    "July 11, 07".to_date.must_equal Date.parse("2007-07-11")
   end
 
-  specify "should not convert 2 digit years if set not to" do
+  it "should not convert 2 digit years if set not to" do
     Sequel.convert_two_digit_years = false
-    "July 11, 07".to_date.should == Date.parse("0007-07-11")
+    "July 11, 07".to_date.must_equal Date.parse("0007-07-11")
   end
 
-  specify "should raise InvalidValue for an invalid date" do
-    proc {'0000-00-00'.to_date}.should raise_error(Sequel::InvalidValue)
+  it "should raise InvalidValue for an invalid date" do
+    proc {'0000-00-00'.to_date}.must_raise(Sequel::InvalidValue)
   end
 end
 
@@ -41,21 +41,21 @@ describe "String#to_datetime" do
     Sequel.convert_two_digit_years = true
   end
 
-  specify "should convert the string into a DateTime object" do
-    "2007-07-11 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a")
+  it "should convert the string into a DateTime object" do
+    "2007-07-11 10:11:12a".to_datetime.must_equal DateTime.parse("2007-07-11 10:11:12a")
   end
   
-  specify "should convert 2 digit years by default" do
-    "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("2007-07-11 10:11:12a")
+  it "should convert 2 digit years by default" do
+    "July 11, 07 10:11:12a".to_datetime.must_equal DateTime.parse("2007-07-11 10:11:12a")
   end
 
-  specify "should not convert 2 digit years if set not to" do
+  it "should not convert 2 digit years if set not to" do
     Sequel.convert_two_digit_years = false
-    "July 11, 07 10:11:12a".to_datetime.should == DateTime.parse("0007-07-11 10:11:12a")
+    "July 11, 07 10:11:12a".to_datetime.must_equal DateTime.parse("0007-07-11 10:11:12a")
   end
 
-  specify "should raise InvalidValue for an invalid date" do
-    proc {'0000-00-00'.to_datetime}.should raise_error(Sequel::InvalidValue)
+  it "should raise InvalidValue for an invalid date" do
+    proc {'0000-00-00'.to_datetime}.must_raise(Sequel::InvalidValue)
   end
 end
 
@@ -65,31 +65,31 @@ describe "String#to_sequel_time" do
     Sequel.convert_two_digit_years = true
   end
 
-  specify "should convert the string into a Time object by default" do
-    "2007-07-11 10:11:12a".to_sequel_time.class.should == Time
-    "2007-07-11 10:11:12a".to_sequel_time.should == Time.parse("2007-07-11 10:11:12a")
+  it "should convert the string into a Time object by default" do
+    "2007-07-11 10:11:12a".to_sequel_time.class.must_equal Time
+    "2007-07-11 10:11:12a".to_sequel_time.must_equal Time.parse("2007-07-11 10:11:12a")
   end
   
-  specify "should convert the string into a DateTime object if that is set" do
+  it "should convert the string into a DateTime object if that is set" do
     Sequel.datetime_class = DateTime
-    "2007-07-11 10:11:12a".to_sequel_time.class.should == DateTime
-    "2007-07-11 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
+    "2007-07-11 10:11:12a".to_sequel_time.class.must_equal DateTime
+    "2007-07-11 10:11:12a".to_sequel_time.must_equal DateTime.parse("2007-07-11 10:11:12a")
   end
   
-  specify "should convert 2 digit years by default if using DateTime class" do
+  it "should convert 2 digit years by default if using DateTime class" do
     Sequel.datetime_class = DateTime
-    "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("2007-07-11 10:11:12a")
+    "July 11, 07 10:11:12a".to_sequel_time.must_equal DateTime.parse("2007-07-11 10:11:12a")
   end
 
-  specify "should not convert 2 digit years if set not to when using DateTime class" do
+  it "should not convert 2 digit years if set not to when using DateTime class" do
     Sequel.datetime_class = DateTime
     Sequel.convert_two_digit_years = false
-    "July 11, 07 10:11:12a".to_sequel_time.should == DateTime.parse("0007-07-11 10:11:12a")
+    "July 11, 07 10:11:12a".to_sequel_time.must_equal DateTime.parse("0007-07-11 10:11:12a")
   end
 
-  specify "should raise InvalidValue for an invalid time" do
-    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue)
+  it "should raise InvalidValue for an invalid time" do
+    proc {'0000-00-00'.to_sequel_time}.must_raise(Sequel::InvalidValue)
     Sequel.datetime_class = DateTime
-    proc {'0000-00-00'.to_sequel_time}.should raise_error(Sequel::InvalidValue)
+    proc {'0000-00-00'.to_sequel_time}.must_raise(Sequel::InvalidValue)
   end
 end

data/spec/extensions/string_stripper_spec.rb

@@ -12,44 +12,44 @@ describe "Sequel::Plugins::StringStripper" do
 
   it "should strip all input strings" do
     @o.name = ' name '
-    @o.name.should == 'name'
+    @o.name.must_equal 'name'
   end
 
   it "should not affect other types" do
     @o.name = 1
-    @o.name.should == 1
+    @o.name.must_equal 1
     @o.name = Date.today
-    @o.name.should == Date.today
+    @o.name.must_equal Date.today
   end
 
   it "should not strip strings for blob arguments" do
     v = Sequel.blob(' name ')
     @o.name = v
-    @o.name.should equal(v)
+    @o.name.must_be_same_as(v)
   end
 
   it "should not strip strings for blob columns" do
     @o.b = ' name '
-    @o.b.should be_a_kind_of(Sequel::SQL::Blob)
-    @o.b.should == Sequel.blob(' name ')
+    @o.b.must_be_kind_of(Sequel::SQL::Blob)
+    @o.b.must_equal Sequel.blob(' name ')
   end
 
   it "should allow skipping of columns using Model.skip_string_stripping" do
-    @c.skip_string_stripping?(:name).should == false
+    @c.skip_string_stripping?(:name).must_equal false
     @c.skip_string_stripping :name
-    @c.skip_string_stripping?(:name).should == true
+    @c.skip_string_stripping?(:name).must_equal true
     v = ' name '
     @o.name = v
-    @o.name.should equal(v)
+    @o.name.must_be_same_as(v)
   end
 
   it "should work correctly in subclasses" do
     o = Class.new(@c).new
     o.name = ' name '
-    o.name.should == 'name'
+    o.name.must_equal 'name'
     o.b = ' name '
-    o.b.should be_a_kind_of(Sequel::SQL::Blob)
-    o.b.should == Sequel.blob(' name ')
+    o.b.must_be_kind_of(Sequel::SQL::Blob)
+    o.b.must_equal Sequel.blob(' name ')
   end
 
   it "should work correctly for dataset changes" do
@@ -60,9 +60,9 @@ describe "Sequel::Plugins::StringStripper" do
     c.set_dataset(@db[:test2])
     o = c.new
     o.name = ' name '
-    o.name.should == 'name'
+    o.name.must_equal 'name'
     o.b = ' name '
-    o.b.should be_a_kind_of(Sequel::SQL::Blob)
-    o.b.should == Sequel.blob(' name ')
+    o.b.must_be_kind_of(Sequel::SQL::Blob)
+    o.b.must_equal Sequel.blob(' name ')
   end
 end

data/spec/extensions/subclasses_spec.rb

@@ -6,61 +6,61 @@ describe Sequel::Model, "Subclasses plugin" do
     @c.plugin :subclasses
   end
 
-  specify "#subclasses should record direct subclasses of the given model" do
-    @c.subclasses.should == []
+  it "#subclasses should record direct subclasses of the given model" do
+    @c.subclasses.must_equal []
 
     sc1 = Class.new(@c)
-    @c.subclasses.should == [sc1]
-    sc1.subclasses.should == []
+    @c.subclasses.must_equal [sc1]
+    sc1.subclasses.must_equal []
 
     sc2 = Class.new(@c)
-    @c.subclasses.should == [sc1, sc2]
-    sc1.subclasses.should == []
-    sc2.subclasses.should == []
+    @c.subclasses.must_equal [sc1, sc2]
+    sc1.subclasses.must_equal []
+    sc2.subclasses.must_equal []
 
     ssc1 = Class.new(sc1)
-    @c.subclasses.should == [sc1, sc2]
-    sc1.subclasses.should == [ssc1]
-    sc2.subclasses.should == []
+    @c.subclasses.must_equal [sc1, sc2]
+    sc1.subclasses.must_equal [ssc1]
+    sc2.subclasses.must_equal []
   end
 
-  specify "#descendents should record all descendent subclasses of the given model" do
-    @c.descendents.should == []
+  it "#descendents should record all descendent subclasses of the given model" do
+    @c.descendents.must_equal []
 
     sc1 = Class.new(@c)
-    @c.descendents.should == [sc1]
-    sc1.descendents.should == []
+    @c.descendents.must_equal [sc1]
+    sc1.descendents.must_equal []
 
     sc2 = Class.new(@c)
-    @c.descendents.should == [sc1, sc2]
-    sc1.descendents.should == []
-    sc2.descendents.should == []
+    @c.descendents.must_equal [sc1, sc2]
+    sc1.descendents.must_equal []
+    sc2.descendents.must_equal []
 
     ssc1 = Class.new(sc1)
-    @c.descendents.should == [sc1, ssc1, sc2]
-    sc1.descendents.should == [ssc1]
-    sc2.descendents.should == []
-    ssc1.descendents.should == []
+    @c.descendents.must_equal [sc1, ssc1, sc2]
+    sc1.descendents.must_equal [ssc1]
+    sc2.descendents.must_equal []
+    ssc1.descendents.must_equal []
 
     sssc1 = Class.new(ssc1)
-    @c.descendents.should == [sc1, ssc1, sssc1, sc2]
-    sc1.descendents.should == [ssc1, sssc1]
-    sc2.descendents.should == []
-    ssc1.descendents.should == [sssc1]
-    sssc1.descendents.should == []
+    @c.descendents.must_equal [sc1, ssc1, sssc1, sc2]
+    sc1.descendents.must_equal [ssc1, sssc1]
+    sc2.descendents.must_equal []
+    ssc1.descendents.must_equal [sssc1]
+    sssc1.descendents.must_equal []
   end
 
-  specify "plugin block should be called with each subclass created" do
+  it "plugin block should be called with each subclass created" do
     c = Class.new(Sequel::Model)
     a = []
     c.plugin(:subclasses){|sc| a << sc}
     sc1 = Class.new(c)
-    a.should == [sc1]
+    a.must_equal [sc1]
     sc2 = Class.new(c)
-    a.should == [sc1, sc2]
+    a.must_equal [sc1, sc2]
     sc3 = Class.new(sc1)
-    a.should == [sc1, sc2, sc3]
+    a.must_equal [sc1, sc2, sc3]
     sc4 = Class.new(sc3)
-    a.should == [sc1, sc2, sc3, sc4]
+    a.must_equal [sc1, sc2, sc3, sc4]
   end
 end

data/spec/extensions/table_select_spec.rb

@@ -7,58 +7,58 @@ describe "Sequel::Plugins::TableSelect" do
 
   it "should add a table.* selection to existing dataset without explicit selection" do
     @Album.plugin :table_select
-    @Album.dataset.sql.should == 'SELECT albums.* FROM albums'
+    @Album.dataset.sql.must_equal 'SELECT albums.* FROM albums'
 
     @Album.dataset = :albs
-    @Album.dataset.sql.should == 'SELECT albs.* FROM albs'
+    @Album.dataset.sql.must_equal 'SELECT albs.* FROM albs'
 
     @Album.dataset = Sequel.identifier(:albs)
-    @Album.dataset.sql.should == 'SELECT albs.* FROM albs'
+    @Album.dataset.sql.must_equal 'SELECT albs.* FROM albs'
   end
 
   it "should handle qualified tables" do
     @Album.dataset = :s__albums
     @Album.plugin :table_select
-    @Album.dataset.sql.should == 'SELECT s.albums.* FROM s.albums'
+    @Album.dataset.sql.must_equal 'SELECT s.albums.* FROM s.albums'
 
     @Album.dataset = Sequel.qualify(:s2, :albums)
-    @Album.dataset.sql.should == 'SELECT s2.albums.* FROM s2.albums'
+    @Album.dataset.sql.must_equal 'SELECT s2.albums.* FROM s2.albums'
   end
 
   it "should handle aliases" do
     @Album.dataset = :albums___a
     @Album.plugin :table_select
-    @Album.dataset.sql.should == 'SELECT a.* FROM albums AS a'
+    @Album.dataset.sql.must_equal 'SELECT a.* FROM albums AS a'
 
     @Album.dataset = Sequel.as(:albums, :b)
-    @Album.dataset.sql.should == 'SELECT b.* FROM albums AS b'
+    @Album.dataset.sql.must_equal 'SELECT b.* FROM albums AS b'
 
     @Album.dataset = :s__albums___a
-    @Album.dataset.sql.should == 'SELECT a.* FROM s.albums AS a'
+    @Album.dataset.sql.must_equal 'SELECT a.* FROM s.albums AS a'
 
     @Album.dataset = @Album.db[:albums].from_self
-    @Album.dataset.sql.should == 'SELECT t1.* FROM (SELECT * FROM albums) AS t1'
+    @Album.dataset.sql.must_equal 'SELECT t1.* FROM (SELECT * FROM albums) AS t1'
 
     @Album.dataset = Sequel.as(@Album.db[:albums], :b)
-    @Album.dataset.sql.should == 'SELECT b.* FROM (SELECT * FROM albums) AS b'
+    @Album.dataset.sql.must_equal 'SELECT b.* FROM (SELECT * FROM albums) AS b'
   end
 
   it "should not add a table.* selection on existing dataset with explicit selection" do
     @Album.dataset = @Album.dataset.select(:name)
     @Album.plugin :table_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 table.* selection on existing dataset with multiple tables" do
     @Album.dataset = @Album.db.from(:a1, :a2)
     @Album.plugin :table_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 "works correctly when loaded on model without a dataset" do
@@ -66,6 +66,6 @@ describe "Sequel::Plugins::TableSelect" do
     c.plugin :table_select
     sc = Class.new(c)
     sc.dataset = :a
-    sc.dataset.sql.should == "SELECT a.* FROM a"
+    sc.dataset.sql.must_equal "SELECT a.* FROM a"
   end
 end

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -29,30 +29,30 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
 
   it "Dataset#all should set the retrieved_by and retrieved_with attributes" do
     ts = @c.all
-    ts.map{|x| [x.retrieved_by, x.retrieved_with]}.should == [[@ds,ts], [@ds,ts], [@ds,ts], [@ds,ts]]
+    ts.map{|x| [x.retrieved_by, x.retrieved_with]}.must_equal [[@ds,ts], [@ds,ts], [@ds,ts], [@ds,ts]]
   end
 
   it "Dataset#all shouldn't raise an error if a Sequel::Model instance is not returned" do
-    proc{@c.naked.all}.should_not raise_error
+    @c.naked.all
   end
 
   it "association getter methods should eagerly load the association if the association isn't cached" do
-    DB.sqls.length.should == 0
+    DB.sqls.length.must_equal 0
     ts = @c.all
-    DB.sqls.length.should == 1
-    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
-    DB.sqls.length.should == 1
-    ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
-    DB.sqls.length.should == 1
+    DB.sqls.length.must_equal 1
+    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
+    DB.sqls.length.must_equal 1
+    ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
+    DB.sqls.length.must_equal 1
   end
 
   it "association getter methods should not eagerly load the association if the association is cached" do
-    DB.sqls.length.should == 0
+    DB.sqls.length.must_equal 0
     ts = @c.all
-    DB.sqls.length.should == 1
-    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
-    @ds.should_not_receive(:eager_load)
-    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
+    DB.sqls.length.must_equal 1
+    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
+    def @ds.eager_load(*) raise end
+    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
   end
 
   it "should handle case where an association is valid on an instance, but not on all instances" do
@@ -65,18 +65,18 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
   it "association getter methods should not eagerly load the association if an instance is frozen" do
     ts = @c.all
     ts.first.freeze
-    DB.sqls.length.should == 1
-    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
-    DB.sqls.length.should == 2
-    ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
-    DB.sqls.length.should == 2
-    ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
-    DB.sqls.length.should == 1
-    ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
-    DB.sqls.length.should == 1
+    DB.sqls.length.must_equal 1
+    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
+    DB.sqls.length.must_equal 2
+    ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
+    DB.sqls.length.must_equal 2
+    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
+    DB.sqls.length.must_equal 1
+    ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
+    DB.sqls.length.must_equal 1
   end
 
   it "#marshallable should make marshalling not fail" do
-    proc{Marshal.dump(@c.all.map{|x| x.marshallable!})}.should_not raise_error
+    Marshal.dump(@c.all.map{|x| x.marshallable!})
   end
 end

data/spec/extensions/thread_local_timezones_spec.rb

@@ -11,33 +11,33 @@ describe "Sequel thread_local_timezones extension" do
   end
   
   it "should allow specifying thread local timezones via thread_*_timezone=" do
-    proc{Sequel.thread_application_timezone = :local}.should_not raise_error
-    proc{Sequel.thread_database_timezone = :utc}.should_not raise_error
-    proc{Sequel.thread_typecast_timezone = nil}.should_not raise_error
+    Sequel.thread_application_timezone = :local
+    Sequel.thread_database_timezone = :utc
+    Sequel.thread_typecast_timezone = nil
   end
     
   it "should use thread local timezone if available" do
     Sequel.thread_application_timezone = :local
-    Sequel.application_timezone.should == :local
+    Sequel.application_timezone.must_equal :local
     Sequel.thread_database_timezone = :utc
-    Sequel.database_timezone.should == :utc
+    Sequel.database_timezone.must_equal :utc
     Sequel.thread_typecast_timezone = nil
-    Sequel.typecast_timezone.should == nil
+    Sequel.typecast_timezone.must_equal nil
   end
   
   it "should fallback to default timezone if no thread_local timezone" do
     Sequel.default_timezone = :utc
-    Sequel.application_timezone.should == :utc
-    Sequel.database_timezone.should == :utc
-    Sequel.typecast_timezone.should == :utc
+    Sequel.application_timezone.must_equal :utc
+    Sequel.database_timezone.must_equal :utc
+    Sequel.typecast_timezone.must_equal :utc
   end
   
   it "should use a nil thread_local_timezone if set instead of falling back to the default timezone if thread_local_timezone is set to :nil" do
     Sequel.typecast_timezone = :utc
     Sequel.thread_typecast_timezone = nil
-    Sequel.typecast_timezone.should == :utc
+    Sequel.typecast_timezone.must_equal :utc
     Sequel.thread_typecast_timezone = :nil
-    Sequel.typecast_timezone.should == nil
+    Sequel.typecast_timezone.must_equal nil
   end
     
   it "should be thread safe" do
@@ -61,7 +61,7 @@ describe "Sequel thread_local_timezones extension" do
     q1.push nil
     t1.join
     t2.join
-    tz1.should == :utc
-    tz2.should == :local
+    tz1.must_equal :utc
+    tz2.must_equal :local
   end
 end