sequel 4.36.0 → 5.61.0

data/spec/extensions/string_date_time_spec.rb

@@ -1,95 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-Sequel.extension :string_date_time
-
-describe "String#to_time" do
-  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
-  
-  it "should raise InvalidValue for an invalid time" do
-    proc {'0000-00-00'.to_time}.must_raise(Sequel::InvalidValue)
-  end
-end
-
-describe "String#to_date" do
-  after do
-    Sequel.convert_two_digit_years = true
-  end
-
-  it "should convert the string into a Date object" do
-    "2007-07-11".to_date.must_equal Date.parse("2007-07-11")
-  end
-  
-  it "should convert 2 digit years by default" do
-    "July 11, 07".to_date.must_equal Date.parse("2007-07-11")
-  end
-
-  it "should not convert 2 digit years if set not to" do
-    Sequel.convert_two_digit_years = false
-    "July 11, 07".to_date.must_equal Date.parse("0007-07-11")
-  end
-
-  it "should raise InvalidValue for an invalid date" do
-    proc {'0000-00-00'.to_date}.must_raise(Sequel::InvalidValue)
-  end
-end
-
-describe "String#to_datetime" do
-  after do
-    Sequel.convert_two_digit_years = true
-  end
-
-  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
-  
-  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
-
-  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.must_equal DateTime.parse("0007-07-11 10:11:12a")
-  end
-
-  it "should raise InvalidValue for an invalid date" do
-    proc {'0000-00-00'.to_datetime}.must_raise(Sequel::InvalidValue)
-  end
-end
-
-describe "String#to_sequel_time" do
-  after do
-    Sequel.datetime_class = Time
-    Sequel.convert_two_digit_years = true
-  end
-
-  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
-  
-  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.must_equal DateTime
-    "2007-07-11 10:11:12a".to_sequel_time.must_equal DateTime.parse("2007-07-11 10:11:12a")
-  end
-  
-  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.must_equal DateTime.parse("2007-07-11 10:11:12a")
-  end
-
-  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.must_equal DateTime.parse("0007-07-11 10:11:12a")
-  end
-
-  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}.must_raise(Sequel::InvalidValue)
-  end
-end

data/spec/extensions/string_stripper_spec.rb

@@ -1,68 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::StringStripper" do
-  before do
-    @db = Sequel.mock
-    @c = Class.new(Sequel::Model(@db[:test]))
-    @c.columns :name, :b
-    @c.db_schema[:b][:type] = :blob
-    @c.plugin :string_stripper
-    @o = @c.new
-  end
-
-  it "should strip all input strings" do
-    @o.name = ' name '
-    @o.name.must_equal 'name'
-  end
-
-  it "should not affect other types" do
-    @o.name = 1
-    @o.name.must_equal 1
-    @o.name = 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.must_be_same_as(v)
-  end
-
-  it "should not strip strings for blob columns" do
-    @o.b = ' 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).must_equal false
-    @c.skip_string_stripping :name
-    @c.skip_string_stripping?(:name).must_equal true
-    v = ' name '
-    @o.name = 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.must_equal 'name'
-    o.b = ' 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
-    c = Class.new(Sequel::Model(@db[:test]))
-    c.plugin :string_stripper
-    def @db.supports_schema_parsing?() true end
-    def @db.schema(*) [[:name, {}], [:b, {:type=>:blob}]] end
-    c.set_dataset(@db[:test2])
-    o = c.new
-    o.name = ' name '
-    o.name.must_equal 'name'
-    o.b = ' 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

@@ -1,66 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe Sequel::Model, "Subclasses plugin" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.plugin :subclasses
-  end
-
-  it "#subclasses should record direct subclasses of the given model" do
-    @c.subclasses.must_equal []
-
-    sc1 = Class.new(@c)
-    @c.subclasses.must_equal [sc1]
-    sc1.subclasses.must_equal []
-
-    sc2 = Class.new(@c)
-    @c.subclasses.must_equal [sc1, sc2]
-    sc1.subclasses.must_equal []
-    sc2.subclasses.must_equal []
-
-    ssc1 = Class.new(sc1)
-    @c.subclasses.must_equal [sc1, sc2]
-    sc1.subclasses.must_equal [ssc1]
-    sc2.subclasses.must_equal []
-  end
-
-  it "#descendents should record all descendent subclasses of the given model" do
-    @c.descendents.must_equal []
-
-    sc1 = Class.new(@c)
-    @c.descendents.must_equal [sc1]
-    sc1.descendents.must_equal []
-
-    sc2 = Class.new(@c)
-    @c.descendents.must_equal [sc1, sc2]
-    sc1.descendents.must_equal []
-    sc2.descendents.must_equal []
-
-    ssc1 = Class.new(sc1)
-    @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.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
-
-  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.must_equal [sc1]
-    sc2 = Class.new(c)
-    a.must_equal [sc1, sc2]
-    sc3 = Class.new(sc1)
-    a.must_equal [sc1, sc2, sc3]
-    sc4 = Class.new(sc3)
-    a.must_equal [sc1, sc2, sc3, sc4]
-  end
-end

data/spec/extensions/subset_conditions_spec.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-describe "subset_conditions plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:a))
-    @c.plugin :subset_conditions
-  end
-
-  it "should provide *_conditions method return the arguments passed" do
-    @c.subset(:published, :published => true)
-    @c.where(@c.published_conditions).sql.must_equal @c.published.sql
-
-    @c.subset(:active, :active)
-    @c.where(@c.active_conditions).sql.must_equal @c.active.sql
-
-    @c.subset(:active_published, :active, :published => true)
-    @c.where(@c.active_published_conditions).sql.must_equal @c.active_published.sql
-    @c.where(Sequel.&(@c.active_conditions, @c.published_conditions)).sql.must_equal @c.active_published.sql
-    @c.where(Sequel.|(@c.active_conditions, @c.published_conditions)).sql.must_equal "SELECT * FROM a WHERE (active OR (published IS TRUE))"
-    @c.where(Sequel.|(@c.active_published_conditions, :foo)).sql.must_equal "SELECT * FROM a WHERE ((active AND (published IS TRUE)) OR foo)"
-  end
-
-  it "should work with blocks" do
-    p1 = proc{{:published=>true}}
-    @c.subset(:published, &p1)
-    @c.where(@c.published_conditions).sql.must_equal @c.published.sql
-
-    p2 = proc{:active}
-    @c.subset(:active, &p2)
-    @c.where(@c.active_conditions).sql.must_equal @c.active.sql
-
-    @c.subset(:active_published, p2, &p1)
-    @c.where(@c.active_published_conditions).sql.must_equal @c.active_published.sql
-    @c.where(Sequel.&(@c.active_conditions, @c.published_conditions)).sql.must_equal @c.active_published.sql
-    @c.where(Sequel.|(@c.active_conditions, @c.published_conditions)).sql.must_equal "SELECT * FROM a WHERE (active OR (published IS TRUE))"
-    @c.where(Sequel.|(@c.active_published_conditions, :foo)).sql.must_equal "SELECT * FROM a WHERE ((active AND (published IS TRUE)) OR foo)"
-  end
-end

data/spec/extensions/table_select_spec.rb

@@ -1,71 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::TableSelect" do
-  before do
-    @Album = Class.new(Sequel::Model(Sequel.mock[:albums]))
-  end
-
-  it "should add a table.* selection to existing dataset without explicit selection" do
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT albums.* FROM albums'
-
-    @Album.dataset = :albs
-    @Album.dataset.sql.must_equal 'SELECT albs.* FROM albs'
-
-    @Album.dataset = Sequel.identifier(: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.must_equal 'SELECT s.albums.* FROM s.albums'
-
-    @Album.dataset = Sequel.qualify(: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.must_equal 'SELECT a.* FROM albums AS a'
-
-    @Album.dataset = Sequel.as(:albums, :b)
-    @Album.dataset.sql.must_equal 'SELECT b.* FROM albums AS b'
-
-    @Album.dataset = :s__albums___a
-    @Album.dataset.sql.must_equal 'SELECT a.* FROM s.albums AS a'
-
-    @Album.dataset = @Album.db[:albums].from_self
-    @Album.dataset.sql.must_equal 'SELECT t1.* FROM (SELECT * FROM albums) AS t1'
-
-    @Album.dataset = Sequel.as(@Album.db[:albums], :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.must_equal 'SELECT name FROM albums'
-
-    @Album.dataset = @Album.dataset.select(:name, :artist)
-    @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.must_equal 'SELECT * FROM a1, a2'
-
-    @Album.dataset = @Album.db.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
-    c = Class.new(Sequel::Model)
-    c.plugin :table_select
-    sc = Class.new(c)
-    sc.dataset = :a
-    sc.dataset.sql.must_equal "SELECT a.* FROM a"
-  end
-end

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -1,136 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::TacticalEagerLoading" do
-  def sql_match(*args)
-    sqls = DB.sqls
-    sqls.length.must_equal args.length
-    sqls.zip(args).each do |is, should|
-      if should.is_a?(Regexp)
-        is.must_match should
-      else
-        is.must_equal should
-      end
-    end
-  end
-  
-  attr_reader :ts
-
-  before do
-    class ::TacticalEagerLoadingModel < Sequel::Model(:t)
-      plugin :tactical_eager_loading
-      columns :id, :parent_id
-      many_to_one :parent, :class=>self
-      one_to_many :children, :class=>self, :key=>:parent_id
-      dataset._fetch = proc do |sql|
-        if sql !~ /WHERE/
-          [{:id=>1, :parent_id=>101}, {:id=>2, :parent_id=>102}, {:id=>101, :parent_id=>nil}, {:id=>102, :parent_id=>nil}]
-        elsif sql =~ /WHERE.*\bid = (\d+)/
-          [{:id=>$1.to_i, :parent_id=>nil}]
-        elsif sql =~ /WHERE.*\bid IN \(([\d, ]*)\)/
-          $1.split(', ').map{|x| {:id=>x.to_i, :parent_id=>nil}}
-        elsif sql =~ /WHERE.*\bparent_id IN \(([\d, ]*)\)/
-          $1.split(', ').map{|x| {:id=>x.to_i - 100, :parent_id=>x.to_i} if x.to_i > 100}.compact
-        end
-      end
-    end
-    @c = ::TacticalEagerLoadingModel
-    @ds = TacticalEagerLoadingModel.dataset
-    DB.reset
-    @ts = @c.all
-    sql_match('SELECT * FROM t')
-  end
-  after do
-    Object.send(:remove_const, :TacticalEagerLoadingModel)
-    sql_match
-  end
-
-  it "Dataset#all should set the retrieved_by and retrieved_with attributes" do
-    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
-    @c.naked.all
-    sql_match('SELECT * FROM t')
-  end
-
-  it "association getter methods should eagerly load the association if the association isn't cached" do
-    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/)
-    ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
-    sql_match(/\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
-  end
-
-  it "association getter methods should not eagerly load the association if the association is cached" do
-    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/)
-    def @ds.eager_load(*) raise end
-    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-  end
-
-  it "association getter methods should not eagerly load the association if a block is given" do
-    ts.map{|x| x.parent{|ds| ds}}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match('SELECT * FROM t WHERE (t.id = 101) LIMIT 1', 'SELECT * FROM t WHERE (t.id = 102) LIMIT 1')
-  end
-
-  it "association getter methods should not eagerly load the association if a callback proc is given" do
-    ts.map{|x| x.parent(:callback=>proc{|ds| ds})}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match('SELECT * FROM t WHERE (t.id = 101) LIMIT 1', 'SELECT * FROM t WHERE (t.id = 102) LIMIT 1')
-  end
-
-  it "association getter methods should not eagerly load the association if true is passed" do
-    ts.map{|x| x.parent(true)}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match('SELECT * FROM t WHERE id = 101', 'SELECT * FROM t WHERE id = 102')
-  end
-
-  it "association getter methods should not eagerly load the association if :reload=>true is passed" do
-    ts.map{|x| x.parent(:reload=>true)}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match('SELECT * FROM t WHERE id = 101', 'SELECT * FROM t WHERE id = 102')
-  end
-
-  it "association getter methods should eagerly reload the association if :eager_reload=>true is passed" do
-    ts.first.parent(:reload=>true)
-    sql_match('SELECT * FROM t WHERE id = 101')
-    ts.map{|x| x.associations.fetch(:parent, 1)}.must_equal [ts[2], 1, 1, 1]
-    ts.first.parent(:eager_reload=>true)
-    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/)
-    ts.map{|x| x.associations.fetch(:parent, 1)}.must_equal [ts[2], ts[3], nil, nil]
-  end
-
-  it "association getter methods should support eagerly loading dependent associations via :eager" do
-    parents = ts.map{|x| x.parent(:eager=>:children)}
-    sql_match(/\ASELECT \* FROM t WHERE \(t\.id IN \(10[12], 10[12]\)\)\z/, /\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
-    parents.must_equal [ts[2], ts[3], nil, nil]
-    parents[0..1].map{|x| x.children}.must_equal [[ts[0]], [ts[1]]]
-  end
-
-  it "association getter methods should support eager callbacks via :eager" do
-    parents = ts.map{|x| x.parent(:eager=>proc{|ds| ds.where{name > 'M'}.eager(:children)})}
-    sql_match(/\ASELECT \* FROM t WHERE \(\(t\.id IN \(10[12], 10[12]\)\) AND \(name > 'M'\)\)\z/, /\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
-    parents.must_equal [ts[2], ts[3], nil, nil]
-    parents[0..1].map{|x| x.children}.must_equal [[ts[0]], [ts[1]]]
-  end
-
-  it "should handle case where an association is valid on an instance, but not on all instances" do
-    c = Class.new(@c)
-    c.many_to_one :parent2, :class=>@c, :key=>:parent_id
-    @c.dataset.row_proc = proc{|r| (r[:parent_id] == 101 ? c : @c).call(r)}
-    @c.all{|x| x.parent2 if x.is_a?(c)}
-    sql_match('SELECT * FROM t', 'SELECT * FROM t WHERE id = 101')
-  end
-
-  it "association getter methods should not eagerly load the association if an instance is frozen" do
-    ts.first.freeze
-    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match('SELECT * FROM t WHERE id = 101', 'SELECT * FROM t WHERE (t.id IN (102))')
-    ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
-    sql_match('SELECT * FROM t WHERE (t.parent_id = 1)', /\ASELECT \* FROM t WHERE \(t\.parent_id IN/)
-    ts.map{|x| x.parent}.must_equal [ts[2], ts[3], nil, nil]
-    sql_match('SELECT * FROM t WHERE id = 101')
-    ts.map{|x| x.children}.must_equal [[], [], [ts[0]], [ts[1]]]
-    sql_match('SELECT * FROM t WHERE (t.parent_id = 1)')
-  end
-
-  it "#marshallable should make marshalling not fail" do
-    Marshal.dump(ts.map{|x| x.marshallable!})
-  end
-end

data/spec/extensions/thread_local_timezones_spec.rb

@@ -1,67 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-Sequel.extension :thread_local_timezones
-
-describe "Sequel thread_local_timezones extension" do
-  after do
-    Sequel.default_timezone = nil
-    Sequel.thread_application_timezone = nil
-    Sequel.thread_database_timezone = nil
-    Sequel.thread_typecast_timezone = nil
-  end
-  
-  it "should allow specifying thread local timezones via thread_*_timezone=" do
-    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.must_equal :local
-    Sequel.thread_database_timezone = :utc
-    Sequel.database_timezone.must_equal :utc
-    Sequel.thread_typecast_timezone = 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.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.must_equal :utc
-    Sequel.thread_typecast_timezone = :nil
-    Sequel.typecast_timezone.must_equal nil
-  end
-    
-  it "should be thread safe" do
-    q, q1, q2 = Queue.new, Queue.new, Queue.new
-    tz1, tz2 = nil, nil
-    t1 = Thread.new do
-      Sequel.thread_application_timezone = :utc
-      q2.push nil
-      q.pop
-      tz1 = Sequel.application_timezone
-    end
-    t2 = Thread.new do
-      Sequel.thread_application_timezone = :local
-      q2.push nil
-      q1.pop
-      tz2 = Sequel.application_timezone
-    end
-    q2.pop
-    q2.pop
-    q.push nil
-    q1.push nil
-    t1.join
-    t2.join
-    tz1.must_equal :utc
-    tz2.must_equal :local
-  end
-end