sequel 4.36.0 → 5.61.0

data/spec/extensions/columns_introspection_spec.rb

@@ -1,91 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
-
-Sequel.extension :columns_introspection
-
-describe "columns_introspection extension" do
-  before do
-    @db = Sequel.mock.extension(:columns_introspection)
-    @ds = @db[:a]
-    @db.sqls
-  end
-
-  it "should not issue a database query if the columns are already loaded" do
-    @ds.instance_variable_set(:@columns, [:x])
-    @ds.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-  
-  it "should handle plain symbols without a database query" do
-    @ds.select(:x).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle qualified symbols without a database query" do
-    @ds.select(:t__x).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle aliased symbols without a database query" do
-    @ds.select(:x___a).columns.must_equal [:a]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle qualified and aliased symbols without a database query" do
-    @ds.select(:t__x___a).columns.must_equal [:a]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle SQL::Identifiers " do
-    @ds.select(Sequel.identifier(:x)).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle SQL::QualifiedIdentifiers" do
-    @ds.select(Sequel.qualify(:t, :x)).columns.must_equal [:x]
-    @ds.select(Sequel.identifier(:x).qualify(:t)).columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle SQL::AliasedExpressions" do
-    @ds.select(Sequel.as(:x, :a)).columns.must_equal [:a]
-    @ds.select(Sequel.as(:x, Sequel.identifier(:a))).columns.must_equal [:a]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle selecting * from a single subselect with no joins without a database query if the subselect's columns can be handled" do
-    @ds.select(:x).from_self.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-    @ds.select(:x).from_self.from_self.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should handle selecting * from a single table with no joins without a database query if the database has cached schema columns for the table" do
-    @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
-    @ds.columns.must_equal [:x]
-    @db.sqls.length.must_equal 0
-  end
-
-  it "should issue a database query for multiple subselects or joins" do
-    @ds.from(@ds.select(:x), @ds.select(:y)).columns
-    @db.sqls.length.must_equal 1
-    @ds.select(:x).from_self.natural_join(:a).columns
-    @db.sqls.length.must_equal 1
-  end
-
-  it "should issue a database query when common table expressions are used" do
-    @db.instance_variable_set(:@schemas, "a"=>[[:x, {}]])
-    def @ds.supports_cte?(*) true end
-    @ds.with(:a, @ds).columns
-    @db.sqls.length.must_equal 1
-  end
-
-  it "should issue a database query if the wildcard is selected" do
-    @ds.columns
-    @db.sqls.length.must_equal 1
-  end
-
-  it "should issue a database query if an unsupported type is used" do
-    @ds.select(1).columns
-    @db.sqls.length.must_equal 1
-  end
-end

data/spec/extensions/composition_spec.rb

@@ -1,242 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Composition plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.plugin :composition
-    @c.columns :id, :year, :month, :day
-    @o = @c.load(:id=>1, :year=>1, :month=>2, :day=>3)
-    DB.reset
-  end
-  
-  it ".composition should add compositions" do
-    @o.wont_respond_to(:date)
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date.must_equal Date.new(1, 2, 3)
-  end
-
-  it "loading the plugin twice should not remove existing compositions" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.plugin :composition
-    @c.compositions.keys.must_equal [:date]
-  end
-
-  it ".composition should raise an error if :composer and :decomposer options are not present and :mapping option is not provided" do
-    proc{@c.composition :date}.must_raise(Sequel::Error)
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.composition :date, :mapping=>[]
-  end
-
-  it "should handle validations of underlying columns" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    o = @c.new
-    def o.validate
-      [:year, :month, :day].each{|c| errors.add(c, "not present") unless send(c)}
-    end
-    o.valid?.must_equal false
-    o.date = Date.new(1, 2, 3)
-    o.valid?.must_equal true
-  end
-
-  it "should set column values even when not validating" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.load({}).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)
-    sql = DB.sqls.last
-    sql.must_include("year = 4")
-    sql.must_include("month = 8")
-    sql.must_include("day = 12")
-  end
-
-  it ".compositions should return the reflection hash of compositions" do
-    @c.compositions.must_equal({})
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.compositions.keys.must_equal [:date]
-    r = @c.compositions.values.first
-    r[:mapping].must_equal [:year, :month, :day]
-    r[:composer].must_be_kind_of Proc
-    r[:decomposer].must_be_kind_of Proc
-  end
-
-  it "#compositions should be a hash of cached values of compositions" do
-    @o.compositions.must_equal({})
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date
-    @o.compositions.must_equal(:date=>Date.new(1, 2, 3))
-  end
-
-  it "should work with custom :composer and :decomposer options" do
-    @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
-    @o.date.must_equal Date.new(2, 4, 6)
-    @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 4")
-    sql.must_include("month = 8")
-    sql.must_include("day = 12")
-  end
-
-  it "should allow call super in composition getter and setter method definition in class" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.class_eval do
-      def date
-        super + 1
-      end
-      def date=(v)
-        super(v - 3)
-      end
-    end
-    @o.date.must_equal Date.new(1, 2, 4)
-    @o.compositions[:date].must_equal Date.new(1, 2, 3)
-    @o.date = Date.new(1, 3, 5)
-    @o.compositions[:date].must_equal Date.new(1, 3, 2)
-    @o.date.must_equal Date.new(1, 3, 3)
-  end
-
-  it "should mark the object as modified whenever the composition is set" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.modified?.must_equal false
-    @o.date = Date.new(3, 4, 5)
-    @o.modified?.must_equal true
-  end
-
-  it "should only decompose existing compositions" do
-    called = false
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{called = true}
-    called.must_equal false
-    @o.save
-    called.must_equal false
-    @o.date = Date.new(1,2,3)
-    called.must_equal false
-    @o.save_changes
-    called.must_equal true
-  end
-
-  it "should clear compositions cache when refreshing" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @o.date = Date.new(3, 4, 5)
-    @o.refresh
-    @o.compositions.must_equal({})
-  end
-
-  it "should not clear compositions cache when refreshing after save" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
-  end
-
-  it "should not clear compositions cache when saving with insert_select" do
-    def (@c.instance_dataset).supports_insert_select?() true end
-    def (@c.instance_dataset).insert_select(*) {:id=>1} end
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.must_equal(:date=>Date.new(3, 4, 5))
-  end
-
-  it "should instantiate compositions lazily" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.compositions.must_equal({})
-    @o.date
-    @o.compositions.must_equal(:date=>Date.new(1,2,3))
-  end
-
-  it "should cache value of composition" do
-    times = 0
-    @c.composition :date, :composer=>proc{times+=1}, :decomposer=>proc{}
-    times.must_equal 0
-    @o.date
-    times.must_equal 1
-    @o.date
-    times.must_equal 1
-  end
-
-  it ":class option should take an string, symbol, or class" do
-    @c.composition :date1, :class=>'Date', :mapping=>[:year, :month, :day]
-    @c.composition :date2, :class=>:Date, :mapping=>[:year, :month, :day]
-    @c.composition :date3, :class=>Date, :mapping=>[:year, :month, :day]
-    @o.date1.must_equal Date.new(1, 2, 3)
-    @o.date2.must_equal Date.new(1, 2, 3)
-    @o.date3.must_equal Date.new(1, 2, 3)
-  end
-
-  it ":mapping option should work with a single array of symbols" do
-    c = Class.new do
-      def initialize(y, m)
-        @y, @m = y, m
-      end
-      def year
-        @y * 2
-      end
-      def month
-        @m * 3
-      end
-    end
-    @c.composition :date, :class=>c, :mapping=>[:year, :month]
-    @o.date.year.must_equal 2
-    @o.date.month.must_equal 6
-    @o.date = c.new(3, 4)
-    @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 6")
-    sql.must_include("month = 12")
-  end
-
-  it ":mapping option should work with an array of two pairs of symbols" do
-    c = Class.new do
-      def initialize(y, m)
-        @y, @m = y, m
-      end
-      def y
-        @y * 2
-      end
-      def m
-        @m * 3
-      end
-    end
-    @c.composition :date, :class=>c, :mapping=>[[:year, :y], [:month, :m]]
-    @o.date.y.must_equal 2
-    @o.date.m.must_equal 6
-    @o.date = c.new(3, 4)
-    @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 6")
-    sql.must_include("month = 12")
-  end
-
-  it ":mapping option :composer should return nil if all values are nil" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.new.date.must_equal nil
-  end
-
-  it ":mapping option :decomposer should set all related fields to nil if nil" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date = nil
-    @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = NULL")
-    sql.must_include("month = NULL")
-    sql.must_include("day = NULL")
-  end
-
-  it "should work with frozen instances" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.freeze
-    @o.date.must_equal Date.new(1, 2, 3)
-    proc{@o.date = Date.today}.must_raise
-  end
-
-  it "should have #dup duplicate compositions" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    @o.date.must_equal Date.new(1, 2, 3)
-    @o.dup.compositions.must_equal @o.compositions
-    @o.dup.compositions.wont_be_same_as(@o.compositions)
-  end
-
-  it "should work correctly with subclasses" do
-    @c.composition :date, :mapping=>[:year, :month, :day]
-    c = Class.new(@c)
-    o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
-    o.date.must_equal Date.new(1, 2, 3)
-    o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 1")
-    sql.must_include("month = 2")
-    sql.must_include("day = 3")
-  end
-end

data/spec/extensions/connection_expiration_spec.rb

@@ -1,121 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-connection_expiration_specs = shared_description do
-  describe "connection expiration" do
-    before do
-      @db.extend(Module.new do
-        def disconnect_connection(conn)
-          @sqls << 'disconnect'
-        end
-      end)
-      @db.extension(:connection_expiration)
-      @db.pool.connection_expiration_timeout = 2
-    end
-
-    it "should still allow new connections" do
-      @db.synchronize{|c| c}.must_be_kind_of(Sequel::Mock::Connection)
-    end
-
-    it "should not override connection_expiration_timeout when loading extension" do
-      @db.extension(:connection_expiration)
-      @db.pool.connection_expiration_timeout.must_equal 2
-    end
-
-    it "should only expire if older than timeout" do
-      c1 = @db.synchronize{|c| c}
-      @db.sqls.must_equal []
-      @db.synchronize{|c| c}.must_be_same_as(c1)
-      @db.sqls.must_equal []
-    end
-
-    it "should disconnect connection if expired" do
-      c1 = @db.synchronize{|c| c}
-      @db.sqls.must_equal []
-      simulate_sleep(c1)
-      c2 = @db.synchronize{|c| c}
-      @db.sqls.must_equal ['disconnect']
-      c2.wont_be_same_as(c1)
-    end
-
-    it "should disconnect only expired connections among multiple" do
-      c1, c2 = multiple_connections
-
-      # Expire c1 only.
-      simulate_sleep(c1)
-      simulate_sleep(c2, 1)
-      c1, c2 = multiple_connections
-
-      c3 = @db.synchronize{|c| c}
-      @db.sqls.must_equal ['disconnect']
-      c3.wont_be_same_as(c1)
-      c3.must_be_same_as(c2)
-    end
-
-    it "should disconnect connections repeatedly if they are expired" do
-      c1, c2 = multiple_connections
-
-      simulate_sleep(c1)
-      simulate_sleep(c2)
-
-      c3 = @db.synchronize{|c| c}
-      @db.sqls.must_equal ['disconnect', 'disconnect']
-      c3.wont_be_same_as(c1)
-      c3.wont_be_same_as(c2)
-    end
-
-    it "should not leak connection references to expiring connections" do
-      c1 = @db.synchronize{|c| c}
-      simulate_sleep(c1)
-      c2 = @db.synchronize{|c| c}
-      c2.wont_be_same_as(c1)
-      @db.pool.instance_variable_get(:@connection_expiration_timestamps).must_include(c2)
-      @db.pool.instance_variable_get(:@connection_expiration_timestamps).wont_include(c1)
-    end
-
-    it "should not leak connection references during disconnect" do
-      c1, c2 = multiple_connections
-      @db.pool.instance_variable_get(:@connection_expiration_timestamps).size.must_equal 2
-      @db.disconnect
-      @db.pool.instance_variable_get(:@connection_expiration_timestamps).size.must_equal 0
-    end
-
-    def multiple_connections
-      q, q1 = Queue.new, Queue.new
-      c1 = nil
-      c2 = nil
-      @db.synchronize do |c|
-        Thread.new do
-          @db.synchronize do |cc|
-            c2 = cc
-          end
-          q1.pop
-          q.push nil
-        end
-        q1.push nil
-        q.pop
-        c1 = c
-      end
-      [c1, c2]
-    end
-
-    # Set the timestamp back in time to simulate sleep / passage of time.
-    def simulate_sleep(conn, sleep_time = 3)
-      timestamps = @db.pool.instance_variable_get(:@connection_expiration_timestamps)
-      timestamps[conn] -= sleep_time
-      @db.pool.instance_variable_set(:@connection_expiration_timestamps, timestamps)
-    end
-  end
-end
-
-describe "Sequel::ConnectionExpiration with threaded pool" do
-  before do
-    @db = Sequel.mock
-  end
-  include connection_expiration_specs
-end
-describe "Sequel::ConnectionExpiration with sharded threaded pool" do
-  before do
-    @db = Sequel.mock(:servers=>{})
-  end
-  include connection_expiration_specs
-end

data/spec/extensions/connection_validator_spec.rb

@@ -1,127 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-connection_validator_specs = shared_description do
-  describe "connection validator" do
-    before do
-      @db.extend(Module.new do
-        def disconnect_connection(conn)
-          @sqls << 'disconnect'
-        end
-        def valid_connection?(conn)
-          super
-          conn.valid
-        end
-        def connect(server)
-          conn = super
-          conn.extend(Module.new do
-            attr_accessor :valid
-          end)
-          conn.valid = true
-          conn
-        end
-      end)
-      @db.extension(:connection_validator)
-    end
-
-    it "should still allow new connections" do
-      @db.synchronize{|c| c}.must_be_kind_of(Sequel::Mock::Connection)
-    end
-
-    it "should only validate if connection idle longer than timeout" do
-      c1 = @db.synchronize{|c| c}
-      @db.sqls.must_equal []
-      @db.synchronize{|c| c}.must_be_same_as(c1)
-      @db.sqls.must_equal []
-      @db.pool.connection_validation_timeout = -1
-      @db.synchronize{|c| c}.must_be_same_as(c1)
-      @db.sqls.must_equal ['SELECT NULL']
-      @db.pool.connection_validation_timeout = 1
-      @db.synchronize{|c| c}.must_be_same_as(c1)
-      @db.sqls.must_equal []
-      @db.synchronize{|c| c}.must_be_same_as(c1)
-      @db.sqls.must_equal []
-    end
-
-    it "should disconnect connection if not valid" do
-      c1 = @db.synchronize{|c| c}
-      @db.sqls.must_equal []
-      c1.valid = false
-      @db.pool.connection_validation_timeout = -1
-      c2 = @db.synchronize{|c| c}
-      @db.sqls.must_equal ['SELECT NULL', 'disconnect']
-      c2.wont_be_same_as(c1)
-    end
-
-    it "should disconnect multiple connections repeatedly if they are not valid" do
-      q, q1 = Queue.new, Queue.new
-      c1 = nil
-      c2 = nil
-      @db.pool.connection_validation_timeout = -1
-      @db.synchronize do |c|
-        Thread.new do
-          @db.synchronize do |cc|
-            c2 = cc
-          end
-          q1.pop
-          q.push nil
-        end
-        q1.push nil
-        q.pop
-        c1 = c
-      end
-      c1.valid = false
-      c2.valid = false
-
-      c3 = @db.synchronize{|c| c}
-      @db.sqls.must_equal ['SELECT NULL', 'disconnect', 'SELECT NULL', 'disconnect']
-      c3.wont_be_same_as(c1)
-      c3.wont_be_same_as(c2)
-    end
-
-    it "should not leak connection references during disconnect" do
-      @db.synchronize{}
-      @db.pool.instance_variable_get(:@connection_timestamps).size.must_equal 1
-      @db.disconnect
-      @db.pool.instance_variable_get(:@connection_timestamps).size.must_equal 0
-    end
-
-    it "should not leak connection references" do
-      c1 = @db.synchronize do |c|
-        @db.pool.instance_variable_get(:@connection_timestamps).must_equal({})
-        c
-      end
-      @db.pool.instance_variable_get(:@connection_timestamps).must_include(c1)
-
-      c1.valid = false
-      @db.pool.connection_validation_timeout = -1
-      c2 = @db.synchronize do |c|
-        @db.pool.instance_variable_get(:@connection_timestamps).must_equal({})
-        c
-      end
-      c2.wont_be_same_as(c1)
-      @db.pool.instance_variable_get(:@connection_timestamps).wont_include(c1)
-      @db.pool.instance_variable_get(:@connection_timestamps).must_include(c2)
-    end
-
-    it "should handle case where determining validity requires a connection" do
-      @db.meta_def(:valid_connection?){|c| synchronize{}; true}
-      @db.pool.connection_validation_timeout = -1
-      c1 = @db.synchronize{|c| c}
-      @db.synchronize{|c| c}.must_be_same_as(c1)
-    end
-  end
-end
-
-describe "Sequel::ConnectionValidator with threaded pool" do
-  before do
-    @db = Sequel.mock
-  end
-  include connection_validator_specs
-end
-describe "Sequel::ConnectionValidator with sharded threaded pool" do
-  before do
-    @db = Sequel.mock(:servers=>{})
-  end
-  include connection_validator_specs
-end
-