sequel 5.20.0 → 5.49.0

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

data/spec/extensions/table_select_spec.rb

@@ -1,83 +0,0 @@
-require_relative "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 = Sequel.qualify(:s2, :albums)
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT s2.albums.* FROM s2.albums'
-  end
-
-  it "should handle aliases" do
-    @Album.dataset = Sequel.as(:albums, :b)
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT b.* FROM albums AS b'
-
-    @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
-
-  with_symbol_splitting "should handle splittable symbols" do
-    @Album.dataset = :albums___a
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT a.* FROM albums AS a'
-
-    @Album.dataset = :s__albums___a
-    @Album.dataset.sql.must_equal 'SELECT a.* FROM s.albums AS a'
-
-    @Album.dataset = :s__albums
-    @Album.dataset.sql.must_equal 'SELECT s.albums.* FROM s.albums'
-  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 add a table.* selection on existing dataset with subquery" do
-    @Album.dataset = @Album.db.from(:a1, :a2).from_self(:alias=>:foo)
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT foo.* FROM (SELECT * FROM a1, a2) AS foo'
-
-    @Album.dataset = @Album.db.from(:a1).cross_join(:a2).from_self(:alias=>:foo)
-    @Album.dataset.sql.must_equal 'SELECT foo.* FROM (SELECT * FROM a1 CROSS JOIN a2) AS foo'
-  end
-
-  it "should work with implicit subqueries used for joined datasets" do
-    @Album.dataset = @Album.db.from(:a1, :a2)
-    @Album.plugin :table_select
-    @Album.dataset.sql.must_equal 'SELECT a1.* FROM (SELECT * FROM a1, a2) AS a1'
-
-    @Album.dataset = @Album.db.from(:a1).cross_join(:a2)
-    @Album.dataset.sql.must_equal 'SELECT a1.* FROM (SELECT * FROM a1 CROSS JOIN a2) AS a1'
-  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