sequel 5.29.0 → 5.30.0

data/spec/extensions/connection_expiration_spec.rb

@@ -1,151 +0,0 @@
-require_relative "spec_helper"
-
-connection_expiration_specs = shared_description do
-  describe "connection expiration" do
-    before do
-      @m = Module.new do
-        def disconnect_connection(conn)
-          @sqls << 'disconnect'
-        end
-      end
-      @db.extend @m
-      @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 handle Database#disconnect calls while the connection is checked out" do
-      @db.synchronize{|c| @db.disconnect}
-    end
-
-    it "should handle disconnected connections" do
-      proc{@db.synchronize{|c| raise Sequel::DatabaseDisconnectError}}.must_raise Sequel::DatabaseDisconnectError
-      @db.sqls.must_equal ['disconnect']
-    end
-
-    it "should handle :connection_handling => :disconnect setting" do
-      @db = Sequel.mock(@db.opts.merge(:connection_handling => :disconnect))
-      @db.extend @m
-      @db.extension(:connection_expiration)
-      @db.synchronize{}
-      @db.sqls.must_equal ['disconnect']
-    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
-      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
-
-    it "should not vary expiration timestamps by default" do
-      c1 = @db.synchronize{|c| c}
-      @db.pool.instance_variable_get(:@connection_expiration_timestamps)[c1].last.must_equal 2
-    end
-
-    it "should support #connection_expiration_random_delay to vary expiration timestamps" do
-      @db.pool.connection_expiration_random_delay = 1
-      c1 = @db.synchronize{|c| c}
-      @db.pool.instance_variable_get(:@connection_expiration_timestamps)[c1].last.wont_equal 2
-    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)
-      timer, max = timestamps[conn]
-      timestamps[conn] = [timer - sleep_time, max]
-      @db.pool.instance_variable_set(:@connection_expiration_timestamps, timestamps)
-    end
-  end
-end
-
-describe "Sequel::ConnectionExpiration with threaded pool" do
-  before do
-    @db = Sequel.mock(:test=>false)
-  end
-  include connection_expiration_specs
-end
-describe "Sequel::ConnectionExpiration with sharded threaded pool" do
-  before do
-    @db = Sequel.mock(:test=>false, :servers=>{})
-  end
-  include connection_expiration_specs
-end

data/spec/extensions/connection_validator_spec.rb

@@ -1,144 +0,0 @@
-require_relative "spec_helper"
-
-connection_validator_specs = shared_description do
-  describe "connection validator" do
-    before do
-      @m = 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.extend @m
-      @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 handle Database#disconnect calls while the connection is checked out" do
-      @db.synchronize{|c| @db.disconnect}
-    end
-
-    it "should handle disconnected connections" do
-      proc{@db.synchronize{|c| raise Sequel::DatabaseDisconnectError}}.must_raise Sequel::DatabaseDisconnectError
-      @db.sqls.must_equal ['disconnect']
-    end
-
-    it "should handle :connection_handling => :disconnect setting" do
-      @db = Sequel.mock(@db.opts.merge(:connection_handling => :disconnect))
-      @db.extend @m
-      @db.extension(:connection_validator)
-      @db.synchronize{}
-      @db.sqls.must_equal ['disconnect']
-    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
-      def @db.valid_connection?(c) synchronize{}; true end
-      @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(:test=>false)
-  end
-  include connection_validator_specs
-end
-describe "Sequel::ConnectionValidator with sharded threaded pool" do
-  before do
-    @db = Sequel.mock(:test=>false, :servers=>{})
-  end
-  include connection_validator_specs
-end

data/spec/extensions/constant_sql_override_spec.rb

@@ -1,24 +0,0 @@
-require_relative "spec_helper"
-
-describe "constant_sql_override extension" do
-  before do
-    @db = Sequel.mock.extension(:constant_sql_override)
-  end
-
-  it 'overrides configured constants' do
-    @db.set_constant_sql(Sequel::CURRENT_TIMESTAMP, "CURRENT TIMESTAMP AT TIME ZONE 'UTC'")
-    @db[:tbl].where(foo: Sequel::CURRENT_TIMESTAMP).first
-    @db.sqls.must_equal ["SELECT * FROM tbl WHERE (foo = CURRENT TIMESTAMP AT TIME ZONE 'UTC') LIMIT 1"]
-  end
-
-  it 'does not change behavior for unconfigured constants' do
-    @db[:tbl].where(foo: Sequel::CURRENT_TIMESTAMP).first
-    @db.sqls.must_equal ["SELECT * FROM tbl WHERE (foo = CURRENT_TIMESTAMP) LIMIT 1"]
-  end
-
-  it 'freezes the constant_sqls hash when frozen' do
-    @db.freeze
-    @db.constant_sqls.frozen?.must_equal true
-    proc{@db.set_constant_sql(Sequel::CURRENT_TIMESTAMP, "CURRENT TIMESTAMP AT TIME ZONE 'UTC'")}.must_raise RuntimeError
-  end
-end

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -1,300 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::ConstraintValidations" do
-  def model_class(opts={})
-    return @c if @c
-    @c = Class.new(Sequel::Model(@db[:items]))
-    @c.columns :name
-    @db.sqls
-    set_fetch(opts)
-    @c.plugin :constraint_validations
-    @c
-  end
-
-  def set_fetch(opts)
-    @db.fetch = {:table=>'items', :message=>nil, :allow_nil=>nil, :constraint_name=>nil, :validation_type=>'presence', :argument=>nil, :column=>'name'}.merge(opts)
-  end
-
-  before do
-    @db = Sequel.mock
-    set_fetch({})
-    @ds = @db[:items]
-    @ds.send(:columns=, [:name])
-    @ds2 = Sequel.mock[:items2]
-    @ds2.send(:columns=, [:name])
-  end
-
-  it "should load the validation_helpers plugin into the class" do
-    model_class.new.must_respond_to(:validates_presence)
-  end
-
-  it "should parse constraint validations when loading plugin" do
-    @c = model_class
-    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
-    @db.constraint_validations.must_equal("items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}])
-    @c.constraint_validations.must_equal [[:validates_presence, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should parse constraint validations with a custom constraint validations table" do
-    c = Class.new(Sequel::Model(@db[:items]))
-    @db.sqls
-    c.plugin :constraint_validations, :constraint_validations_table=>:foo
-    @db.sqls.must_equal ["SELECT * FROM foo"]
-    @db.constraint_validations.must_equal("items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}])
-    c.constraint_validations.must_equal [[:validates_presence, :name]]
-    c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should populate constraint_validations when subclassing" do
-    c = Class.new(Sequel::Model(@db))
-    c.plugin :constraint_validations
-    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
-    sc = Class.new(c)
-    sc.set_dataset @ds
-    @db.sqls.must_equal []
-    sc.constraint_validations.must_equal [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should handle plugin being loaded in subclass when superclass uses a custom constraint validations table" do
-    c = Class.new(Sequel::Model(@db))
-    c.plugin :constraint_validations, :constraint_validations_table=>:foo
-    @db.sqls.must_equal ["SELECT * FROM foo"]
-    sc = Class.new(c)
-    sc.plugin :constraint_validations
-    sc.constraint_validations_table.must_equal :foo
-    sc.set_dataset @ds
-    @db.sqls.must_equal []
-    sc.constraint_validations.must_equal [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should populate constraint_validations when changing the model's dataset" do
-    c = Class.new(Sequel::Model(@db[:foo]))
-    c.columns :name
-    @db.sqls
-    c.plugin :constraint_validations
-    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
-    sc = Class.new(c)
-    sc.set_dataset @ds
-    @db.sqls.must_equal []
-    sc.constraint_validations.must_equal [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should reparse constraint validations when changing the model's database" do
-    c = Class.new(Sequel::Model(@ds2))
-    c.plugin :constraint_validations
-    @ds2.db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
-    sc = Class.new(c)
-    sc.set_dataset @ds
-    @db.sqls.must_equal ["SELECT * FROM sequel_constraint_validations"]
-    sc.constraint_validations.must_equal [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should reparse constraint validations when changing the model's database with a custom constraint validations table" do
-    c = Class.new(Sequel::Model(@ds2))
-    c.plugin :constraint_validations, :constraint_validations_table=>:foo
-    @ds2.db.sqls.must_equal ["SELECT * FROM foo"]
-    sc = Class.new(c)
-    sc.set_dataset @ds
-    @db.sqls.must_equal ["SELECT * FROM foo"]
-    sc.constraint_validations.must_equal [[:validates_presence, :name]]
-    sc.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should correctly retrieve :message option from constraint validations table" do
-    model_class(:message=>'foo').constraint_validations.must_equal [[:validates_presence, :name, {:message=>'foo'}]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {:message=>'foo'}]])
-  end
-
-  it "should correctly retrieve :allow_nil option from constraint validations table" do
-    model_class(:allow_nil=>true).constraint_validations.must_equal [[:validates_presence, :name, {:allow_nil=>true}]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {:allow_nil=>true}]])
-  end
-
-  it "should handle presence validation" do
-    model_class(:validation_type=>'presence').constraint_validations.must_equal [[:validates_presence, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should handle exact_length validation" do
-    model_class(:validation_type=>'exact_length', :argument=>'5').constraint_validations.must_equal [[:validates_exact_length, 5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:exact_length, {:argument=>5}]])
-  end
-
-  it "should handle min_length validation" do
-    model_class(:validation_type=>'min_length', :argument=>'5').constraint_validations.must_equal [[:validates_min_length, 5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:min_length, {:argument=>5}]])
-  end
-
-  it "should handle max_length validation" do
-    model_class(:validation_type=>'max_length', :argument=>'5').constraint_validations.must_equal [[:validates_max_length, 5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:max_length, {:argument=>5}]])
-  end
-
-  it "should handle length_range validation" do
-    model_class(:validation_type=>'length_range', :argument=>'3..5').constraint_validations.must_equal [[:validates_length_range, 3..5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:length_range, {:argument=>3..5}]])
-  end
-
-  it "should handle length_range validation with an exclusive end" do
-    model_class(:validation_type=>'length_range', :argument=>'3...5').constraint_validations.must_equal [[:validates_length_range, 3...5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:length_range, {:argument=>3...5}]])
-  end
-
-  it "should handle format validation" do
-    model_class(:validation_type=>'format', :argument=>'^foo.*').constraint_validations.must_equal [[:validates_format, /^foo.*/, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/^foo.*/}]])
-  end
-
-  it "should handle format validation with case insensitive format" do
-    model_class(:validation_type=>'iformat', :argument=>'^foo.*').constraint_validations.must_equal [[:validates_format, /^foo.*/i, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/^foo.*/i}]])
-  end
-
-  it "should handle includes validation with array of strings" do
-    model_class(:validation_type=>'includes_str_array', :argument=>'a,b,c').constraint_validations.must_equal [[:validates_includes, %w'a b c', :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>%w'a b c'}]])
-  end
-
-  it "should handle includes validation with array of integers" do
-    model_class(:validation_type=>'includes_int_array', :argument=>'1,2,3').constraint_validations.must_equal [[:validates_includes, [1, 2, 3], :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>[1, 2, 3]}]])
-  end
-
-  it "should handle includes validation with inclusive range of integers" do
-    model_class(:validation_type=>'includes_int_range', :argument=>'3..5').constraint_validations.must_equal [[:validates_includes, 3..5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>3..5}]])
-  end
-
-  it "should handle includes validation with exclusive range of integers" do
-    model_class(:validation_type=>'includes_int_range', :argument=>'3...5').constraint_validations.must_equal [[:validates_includes, 3...5, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:includes, {:argument=>3...5}]])
-  end
-
-  it "should handle like validation" do
-    model_class(:validation_type=>'like', :argument=>'foo').constraint_validations.must_equal [[:validates_format, /\Afoo\z/, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Afoo\z/}]])
-  end
-
-  it "should handle ilike validation" do
-    model_class(:validation_type=>'ilike', :argument=>'foo').constraint_validations.must_equal [[:validates_format, /\Afoo\z/i, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Afoo\z/i}]])
-  end
-
-  it "should handle operator validation" do
-    [[:str_lt, :<], [:str_lte, :<=], [:str_gt, :>], [:str_gte, :>=]].each do |vt, op|
-      model_class(:validation_type=>vt.to_s, :argument=>'a').constraint_validations.must_equal [[:validates_operator, op, 'a', :name]]
-      @c.constraint_validation_reflections.must_equal(:name=>[[:operator, {:operator=>op, :argument=>'a'}]])
-      @c = @c.db.constraint_validations = nil
-    end
-
-    [[:int_lt, :<], [:int_lte, :<=], [:int_gt, :>], [:int_gte, :>=]].each do |vt, op|
-      model_class(:validation_type=>vt.to_s, :argument=>'1').constraint_validations.must_equal [[:validates_operator, op, 1, :name]]
-      @c.constraint_validation_reflections.must_equal(:name=>[[:operator, {:operator=>op, :argument=>1}]])
-      @c = @c.db.constraint_validations = nil
-    end
-  end
-
-  it "should handle like validation with % metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'%foo%').constraint_validations.must_equal [[:validates_format, /\A.*foo.*\z/, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A.*foo.*\z/}]])
-  end
-
-  it "should handle like validation with %% metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'%%foo%%').constraint_validations.must_equal [[:validates_format, /\A%foo%\z/, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A%foo%\z/}]])
-  end
-
-  it "should handle like validation with _ metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'f_o').constraint_validations.must_equal [[:validates_format, /\Af.o\z/, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Af.o\z/}]])
-  end
-
-  it "should handle like validation with Regexp metacharacter" do
-    model_class(:validation_type=>'like', :argument=>'\wfoo\d').constraint_validations.must_equal [[:validates_format, /\A\\wfoo\\d\z/, :name]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A\\wfoo\\d\z/}]])
-  end
-
-  it "should handle unique validation" do
-    model_class(:validation_type=>'unique').constraint_validations.must_equal [[:validates_unique, [:name]]]
-    @c.constraint_validation_reflections.must_equal(:name=>[[:unique, {}]])
-  end
-
-  it "should handle unique validation with multiple columns" do
-    model_class(:validation_type=>'unique', :column=>'name,id').constraint_validations.must_equal [[:validates_unique, [:name, :id]]]
-    @c.constraint_validation_reflections.must_equal([:name, :id]=>[[:unique, {}]])
-  end
-
-  it "should handle :validation_options" do
-    c = model_class(:validation_type=>'unique', :column=>'name')
-    c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad'}}
-    c.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad'}]]
-    c.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad'}]])
-    c.dataset = c.dataset.with_fetch(:count=>1)
-    o = c.new(:name=>'a')
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['name is bad']
-  end
-
-  it "should handle :validation_options merging with constraint validation options" do
-    c = model_class(:validation_type=>'unique', :column=>'name', :allow_nil=>true)
-    c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad'}}
-    c.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad', :allow_nil=>true}]]
-    c.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad', :allow_nil=>true}]])
-    c.dataset = c.dataset.with_fetch(:count=>1)
-    o = c.new(:name=>'a')
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['name is bad']
-  end
-
-  it "should handle :validation_options merging with subclasses" do
-    c = model_class(:validation_type=>'unique', :column=>'name')
-    c.plugin :constraint_validations, :validation_options=>{:unique=>{:message=>'is bad', :allow_nil=>true}}
-    sc = Class.new(c)
-    sc.plugin :constraint_validations, :validation_options=>{:unique=>{:allow_missing=>true, :allow_nil=>false}}
-    sc.constraint_validations.must_equal [[:validates_unique, [:name], {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]
-    sc.constraint_validation_reflections.must_equal(:name=>[[:unique, {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]])
-    sc.dataset = sc.dataset.with_fetch(:count=>1)
-    o = sc.new(:name=>'a')
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['name is bad']
-  end
-
-  it "should used parsed constraint validations when validating" do
-    o = model_class.new
-    o.valid?.must_equal false
-    o.errors.full_messages.must_equal ['name is not present']
-  end
-
-  it "should handle a table name specified as SQL::Identifier" do
-    set_fetch(:table=>'sch__items')
-    c = Class.new(Sequel::Model(@db[Sequel.identifier(:sch__items)]))
-    c.plugin :constraint_validations
-    c.constraint_validations.must_equal [[:validates_presence, :name]]
-    c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should handle a table name specified as SQL::QualifiedIdentifier" do
-    set_fetch(:table=>'sch.items')
-    c = Class.new(Sequel::Model(@db[Sequel.qualify(:sch, :items)]))
-    c.plugin :constraint_validations
-    c.constraint_validations.must_equal [[:validates_presence, :name]]
-    c.constraint_validation_reflections.must_equal(:name=>[[:presence, {}]])
-  end
-
-  it "should freeze constraint validations data when freezing model class" do
-    @c = model_class
-    @c.freeze
-    @c.constraint_validations.frozen?.must_equal true
-    @c.constraint_validations.all?(&:frozen?).must_equal true
-    @c.constraint_validation_reflections.frozen?.must_equal true
-    @c.constraint_validation_reflections.values.all?(&:frozen?).must_equal true
-    @c.constraint_validation_reflections.values.all?{|r| r.all?(&:frozen?)}.must_equal true
-    @c.instance_variable_get(:@constraint_validation_options).frozen?.must_equal true
-    @c.instance_variable_get(:@constraint_validation_options).values.all?(&:frozen?).must_equal true
-  end
-end