sequel 5.8.0 → 5.38.0

data/spec/extensions/string_agg_spec.rb

@@ -1,90 +0,0 @@
-require_relative "spec_helper"
-
-
-describe "string_agg extension" do
-  dbf = lambda do |db_type|
-    db = Sequel.connect("mock://#{db_type}")
-    db.extension :string_agg
-    db
-  end
-
-  before(:all) do
-    Sequel.extension :string_agg
-  end
-  before do
-    @sa1 = Sequel.string_agg(:c)
-    @sa2 = Sequel.string_agg(:c, '-')
-    @sa3 = Sequel.string_agg(:c, '-').order(:o)
-    @sa4 = Sequel.string_agg(:c).order(:o).distinct
-  end
-
-  it "should use existing method" do
-    db = Sequel.mock
-    db.extend_datasets do
-      def string_agg_sql_append(sql, sa)
-        sql << "sa(#{sa.expr})"
-      end
-    end
-    db.extension :string_agg
-    db.literal(Sequel.string_agg(:c)).must_equal "sa(c)"
-  end
-
-  it "should correctly literalize on Postgres" do
-    ds = dbf.call(:postgres).dataset.with_quote_identifiers(false)
-    ds.literal(@sa1).must_equal "string_agg(c, ',')"
-    ds.literal(@sa2).must_equal "string_agg(c, '-')"
-    ds.literal(@sa3).must_equal "string_agg(c, '-' ORDER BY o)"
-    ds.literal(@sa4).must_equal "string_agg(DISTINCT c, ',' ORDER BY o)"
-  end
-
-  it "should correctly literalize on SQLAnywhere" do
-    ds = dbf.call(:sqlanywhere).dataset.with_quote_identifiers(false).with_extend{def input_identifier(v) v.to_s end}
-    ds.literal(@sa1).must_equal "list(c, ',')"
-    ds.literal(@sa2).must_equal "list(c, '-')"
-    ds.literal(@sa3).must_equal "list(c, '-' ORDER BY o)"
-    ds.literal(@sa4).must_equal "list(DISTINCT c, ',' ORDER BY o)"
-  end
-
-  it "should correctly literalize on MySQL, H2, HSQLDB" do
-    [:mysql, :h2, :hsqldb].each do |type|
-      db = dbf.call(type)
-      db.define_singleton_method(:database_type){type}
-      ds = db.dataset.with_quote_identifiers(false).with_extend{def input_identifier(v) v.to_s end}
-      ds.literal(@sa1).upcase.must_equal "GROUP_CONCAT(C SEPARATOR ',')"
-      ds.literal(@sa2).upcase.must_equal "GROUP_CONCAT(C SEPARATOR '-')"
-      ds.literal(@sa3).upcase.must_equal "GROUP_CONCAT(C ORDER BY O SEPARATOR '-')"
-      ds.literal(@sa4).upcase.must_equal "GROUP_CONCAT(DISTINCT C ORDER BY O SEPARATOR ',')"
-    end
-  end
-
-  it "should correctly literalize on Oracle and DB2" do
-    [:oracle, :db2].each do |type|
-      ds = dbf.call(type).dataset.with_quote_identifiers(false).with_extend{def input_identifier(v) v.to_s end}
-      ds.literal(@sa1).must_equal "listagg(c, ',') WITHIN GROUP (ORDER BY 1)"
-      ds.literal(@sa2).must_equal "listagg(c, '-') WITHIN GROUP (ORDER BY 1)"
-      ds.literal(@sa3).must_equal "listagg(c, '-') WITHIN GROUP (ORDER BY o)"
-      proc{ds.literal(@sa4)}.must_raise Sequel::Error
-    end
-  end
-
-  it "should raise Sequel::Error on unsupported database" do
-    proc{dbf.call(:foo).literal(@sa1)}.must_raise Sequel::Error
-  end
-
-  it "should handle order without arguments" do
-    db = dbf.call(:postgres)
-    db.dataset.with_quote_identifiers(false).literal(@sa1.order).must_equal "string_agg(c, ',')"
-  end
-
-  it "should handle operations on object" do
-    ds = dbf.call(:postgres).dataset.with_quote_identifiers(false)
-    ds.literal(@sa1 + 'b').must_equal "(string_agg(c, ',') || 'b')"
-    ds.literal(@sa1.like('b')).must_equal "(string_agg(c, ',') LIKE 'b' ESCAPE '\\')"
-    ds.literal(@sa1 < 'b').must_equal "(string_agg(c, ',') < 'b')"
-    ds.literal(@sa1.as(:b)).must_equal "string_agg(c, ',') AS b"
-    ds.literal(@sa1.cast(:b)).must_equal "CAST(string_agg(c, ',') AS b)"
-    ds.literal(@sa1.desc).must_equal "string_agg(c, ',') DESC"
-    ds.literal(@sa1 =~ /a/).must_equal "(string_agg(c, ',') ~ 'a')"
-    ds.literal(@sa1.sql_subscript(1)).must_equal "string_agg(c, ',')[1]"
-  end
-end

data/spec/extensions/string_date_time_spec.rb

@@ -1,95 +0,0 @@
-require_relative "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_relative "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,79 +0,0 @@
-require_relative "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 "#freeze_descendents should finalize the associations for all descendents" do
-    sc1 = Class.new(@c)
-    sc1.set_dataset :bars
-    sc1.set_primary_key :foo
-    sc2 = Class.new(@c)
-    sc2.set_dataset :bazs
-    sc2.many_to_one :bar, :class=>sc1
-    @c.freeze_descendents
-    sc1.frozen?.must_equal true
-    sc2.frozen?.must_equal true
-    sc2.association_reflection(:bar)[:primary_key].must_equal :foo
-  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_relative "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.dataset_module{subset(:published, :published => true)}
-    @c.where(@c.published_conditions).sql.must_equal @c.published.sql
-
-    @c.dataset_module{where(:active, :active)}
-    @c.where(@c.active_conditions).sql.must_equal @c.active.sql
-
-    @c.dataset_module{subset(:active_published, Sequel.&(: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.dataset_module{subset(:published, &p1)}
-    @c.where(@c.published_conditions).sql.must_equal @c.published.sql
-
-    p2 = :active
-    @c.dataset_module{subset(:active, p2)}
-    @c.where(@c.active_conditions).sql.must_equal @c.active.sql
-
-    @c.dataset_module{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/symbol_aref_refinement_spec.rb

@@ -1,28 +0,0 @@
-require_relative "spec_helper"
-
-if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
-Sequel.extension :symbol_aref_refinement
-using Sequel::SymbolAref
-
-describe "symbol_aref_refinement extension" do
-  before do
-    @db = Sequel.mock
-  end
-
-  it "Symbol#[] should create qualified identifier if given a symbol" do
-    @db.literal(:x[:y]).must_equal "x.y"
-  end
-
-  it "Symbol#[] should create qualified identifier if given an identifier" do
-    @db.literal(:x[Sequel[:y]]).must_equal "x.y"
-  end
-
-  it "Symbol#[] should create qualified identifier if given a qualified identifier" do
-    @db.literal(:x[:y[:z]]).must_equal "x.y.z"
-  end
-
-  it "should not affect other arguments to Symbol#[]" do
-    :x[0].must_equal "x"
-  end
-end
-end

data/spec/extensions/symbol_as_refinement_spec.rb

@@ -1,21 +0,0 @@
-require_relative "spec_helper"
-
-if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
-Sequel.extension :symbol_as_refinement
-using Sequel::SymbolAs
-
-describe "symbol_as_refinement extension" do
-  before do
-    @db = Sequel.mock
-  end
-
-  it "Symbol#as should create aliased expression" do
-    @db.literal(:x.as(:y)).must_equal "x AS y"
-  end
-
-  it "Symbol#as should create aliased expression with columns" do
-    @db.literal(:x.as(:y, [:c1, :c2])).must_equal "x AS y(c1, c2)"
-  end
-end
-end
-

data/spec/extensions/synchronize_sql_spec.rb

@@ -1,124 +0,0 @@
-require_relative 'spec_helper'
-
-describe "synchronize_sql extension" do
-  module Sync
-    def literal_string_append(sql, v)
-      db.synchronize{super}
-    end
-  end
-
-  before do
-    @db = Sequel.mock
-    @db.pool.extend(Module.new do
-      def assign_connection(*args)
-        r = super
-        @times_connection_acquired ||= 0
-        @times_connection_acquired += 1 if r
-        return r
-      end
-
-      def times_connection_acquired
-        v = @times_connection_acquired
-        @times_connection_acquired = 0
-        v || 0
-      end
-    end)
-    @db.extend_datasets(Sync)
-    @ds = @db[:tab1]
-  end
-
-  it 'does not checkout a connection if SQL is given as a string' do
-    @ds.extension(:synchronize_sql).with_sql('SELECT 1').sql
-    @db.pool.times_connection_acquired.must_equal 0
-  end
-
-  it 'checks out an extra connection on insert_sql if there are no strings' do
-    @ds.insert_sql(:numeric_foo => 8)
-    @db.pool.times_connection_acquired.must_equal 0
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.insert_sql(:numeric_foo => 8)
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out just one connection on insert_sql if there are multiple strings' do
-    @ds.insert_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
-    @db.pool.times_connection_acquired.must_equal 3
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.insert_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'cheks out an extra connectrion on update_sql if there are no strings' do
-    @ds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:numeric_foo => 99)
-    @db.pool.times_connection_acquired.must_equal 0
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:numeric_foo => 99)
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out just one connection on update_sql if there are multiple strings' do
-    @ds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
-    @db.pool.times_connection_acquired.must_equal 3
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.where(:numeric_foo => [1, 2, 3, 4, 5]).update_sql(:string_foo1 => 'eight', :string_foo2 => 'nine', :string_foo3 => 'ten')
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out an extra connection on delete_sql if there are no strings' do
-    @ds.where(:numeric_foo => [1, 2, 3]).delete_sql
-    @db.pool.times_connection_acquired.must_equal 0
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.where(:numeric_foo => [1, 2, 3]).delete_sql
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out just one connection on delete_sql if there are multiple strings' do
-    @ds.where(:string_foo => ['one', 'two', 'three', 'four']).delete_sql
-    @db.pool.times_connection_acquired.must_equal 4
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.where(:string_foo => ['one', 'two', 'three', 'four']).delete_sql
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out an extra connection on select_sql if there are no strings' do
-    @ds.where(:numeric_foo => [1, 2, 3]).select_sql
-    @db.pool.times_connection_acquired.must_equal 0
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.where(:numeric_foo => [1, 2, 3]).select_sql
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out just one connection on select_sql if there are multiple strings' do
-    @ds.where(:string_foo => ['one', 'two', 'three', 'four']).select_sql
-    @db.pool.times_connection_acquired.must_equal 4
-
-    extds = @ds.extension(:synchronize_sql)
-    extds.where(:string_foo => ['one', 'two', 'three', 'four']).select_sql
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out an extra connection on fetch if there are no strings' do
-    @db.fetch('SELECT * FROM tab1 WHERE numeric_foo IN (?, ?, ?, ?)', 1, 2, 3, 4).select_sql
-    @db.pool.times_connection_acquired.must_equal 0
-
-    @db.extension(:synchronize_sql)
-    @db.fetch('SELECT * FROM tab1 WHERE numeric_foo IN (?, ?, ?, ?)', 1, 2, 3, 4).select_sql
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-
-  it 'checks out just one connection on fetch if there are multiple strings' do
-    @db.fetch('SELECT * FROM tab1 WHERE string_foo IN (?, ?, ?, ?)', 'one', 'two', 'three', 'four').select_sql
-    @db.pool.times_connection_acquired.must_equal 4
-
-    @db.extension(:synchronize_sql)
-    @db.fetch('SELECT * FROM tab1 WHERE string_foo IN (?, ?, ?, ?)', 'one', 'two', 'three', 'four').select_sql
-    @db.pool.times_connection_acquired.must_equal 1
-  end
-end