sequel 3.47.0 → 3.48.0

data/spec/extensions/after_initialize_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::AfterInitialize" do
+  before do
+    @db = Sequel.mock(:host=>'mysql', :numrows=>1)
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @c.class_eval do
+      columns :id, :name
+      plugin :after_initialize
+      def after_initialize
+        self.name *= 2
+        self.id *= 3 if id
+      end
+    end
+  end
+
+  it "should have after_initialize hook be called for new objects" do
+    @c.new(:name=>'foo').values.should == {:name=>'foofoo'}
+  end
+
+  it "should have after_initialize hook be called for objects loaded from the database" do
+    @c.call(:id=>1, :name=>'foo').values.should == {:id=>3, :name=>'foofoo'}
+  end
+end

data/spec/extensions/association_proxies_spec.rb

@@ -6,7 +6,7 @@ describe "Sequel::Plugins::AssociationProxies" do
     end
     class ::Item < Sequel::Model
       plugin :association_proxies
-      many_to_many :tags
+      many_to_many :tags, :extend=>Module.new{def size; count end}
     end
     @i = Item.load(:id=>1)
     @t = @i.tags
@@ -29,6 +29,33 @@ describe "Sequel::Plugins::AssociationProxies" do
     @i.associations.has_key?(:tags).should == false
   end
   
+  it "should accept block to plugin to specify which methods to proxy to dataset" do
+    Item.plugin :association_proxies do |opts|
+      opts[:method] == :where || opts[:arguments].length == 2 || opts[:block]
+    end
+    @i.associations.has_key?(:tags).should == false
+    @t.where(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+    @t.filter('a = ?', 1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+    @t.filter{{:a=>1}}.sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+
+    @i.associations.has_key?(:tags).should == false
+    Item.plugin :association_proxies do |opts|
+      proxy_arg = opts[:proxy_argument]
+      proxy_block = opts[:proxy_block]
+      cached = opts[:instance].associations[opts[:reflection][:name]]
+      is_size = opts[:method] == :size
+      is_size && !cached && !proxy_arg && !proxy_block
+    end
+    @t.size.should == 1
+    Item.db.sqls.should == ["SELECT count(*) AS count FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) LIMIT 1"]
+    @i.tags{|ds| ds}.size.should == 1
+    Item.db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1))"]
+    @i.tags(true).size.should == 1
+    Item.db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1))"]
+    @t.size.should == 1
+    Item.db.sqls.should == []
+  end
+  
   it "should reload the cached association if sent an array method and the reload flag was given" do
     @t.select{|x| false}.should == []
     Item.db.sqls.length.should == 1
@@ -47,4 +74,13 @@ describe "Sequel::Plugins::AssociationProxies" do
     Tag.one_to_one :item
     proc{Tag.load(:id=>1, :item_id=>2).item.filter(:a=>1)}.should raise_error(NoMethodError)
   end
+
+  it "should work correctly in subclasses" do
+    i = Class.new(Item).load(:id=>1)
+    i.associations.has_key?(:tags).should == false
+    i.tags.select{|x| false}.should == []
+    i.associations.has_key?(:tags).should == true
+    i.tags.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
+  end
+  
 end

data/spec/extensions/auto_validations_spec.rb

@@ -7,17 +7,19 @@ describe "Sequel::Plugins::AutoValidations" do
     def db.schema(t, *)
       t = t.first_source if t.is_a?(Sequel::Dataset)
       return [] if t != :test
-      [[:id, {:primary_key=>true, :type=>:integer}],
+      [[:id, {:primary_key=>true, :type=>:integer, :allow_null=>false}],
        [:name, {:primary_key=>false, :type=>:string, :allow_null=>false}],
        [:num, {:primary_key=>false, :type=>:integer, :allow_null=>true}],
-       [:d, {:primary_key=>false, :type=>:date, :allow_null=>false}]]
+       [:d, {:primary_key=>false, :type=>:date, :allow_null=>false}],
+       [:nnd, {:primary_key=>false, :type=>:string, :allow_null=>false, :ruby_default=>'nnd'}]]
     end
+    def db.supports_index_parsing?() true end
     def db.indexes(t, *)
       return [] if t != :test
       {:a=>{:columns=>[:name, :num], :unique=>true}, :b=>{:columns=>[:num], :unique=>false}}
     end
     @c = Class.new(Sequel::Model(db[:test]))
-    @c.send(:def_column_accessor, :id, :name, :num, :d)
+    @c.send(:def_column_accessor, :id, :name, :num, :d, :nnd)
     @c.raise_on_typecast_failure = false
     @c.plugin :auto_validations
     @m = @c.new
@@ -41,10 +43,24 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.errors.should == {[:name, :num]=>["is already taken"]}
   end
 
+  it "should support :not_null=>:presence option" do
+    @c.plugin :auto_validations, :not_null=>:presence
+    @m.set(:d=>Date.today, :num=>'')
+    @m.valid?.should be_false
+    @m.errors.should == {:name=>["is not present"]}
+  end
+
+  it "should automatically validate explicit nil values for columns with not nil defaults" do
+    @m.set(:d=>Date.today, :name=>1, :nnd=>nil)
+    @m.id = nil
+    @m.valid?.should be_false
+    @m.errors.should == {:id=>["is not present"], :nnd=>["is not present"]}
+  end
+
   it "should allow skipping validations by type" do
     @c = Class.new(@c)
     @m = @c.new
-    @c.skip_auto_validations(:presence)
+    @c.skip_auto_validations(:not_null)
     @m.valid?.should be_true
 
     @m.set(:d=>'/', :num=>'a', :name=>'1')

data/spec/extensions/blacklist_security_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe Sequel::Model, "#(set|update)_except" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      plugin :blacklist_security
+      set_primary_key :id
+      columns :x, :y, :z, :id
+      set_restricted_columns :y
+    end
+    @c.strict_param_setting = false
+    @o1 = @c.new
+    MODEL_DB.reset
+  end
+
+  it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
+    @c.strict_param_setting = true
+    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.should raise_error(Sequel::Error)
+    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3}, :x, :y)}.should raise_error(Sequel::Error)
+    (o = @c.new).set_except({:z => 3}, :x, :y)
+    o.values.should == {:z=>3}
+  end
+
+  it "#set_except should not set given attributes or the primary key" do
+    @o1.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
+    @o1.values.should == {:x => 1}
+    @o1.set_except({:x => 4, :y => 2, :z=>3, :id=>4}, :y, :z)
+    @o1.values.should == {:x => 4}
+  end
+
+  it "#update_except should not update given attributes" do
+    @o1.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    @c.new.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, :y, :z)
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+  end
+end
+
+describe Sequel::Model, ".restricted_columns " do
+  before do
+    @c = Class.new(Sequel::Model(:blahblah))
+    @c.class_eval do
+      plugin :blacklist_security
+      columns :x, :y, :z
+    end
+    @c.strict_param_setting = false
+    @c.instance_variable_set(:@columns, [:x, :y, :z])
+  end
+  
+  it "should set the restricted columns correctly" do
+    @c.restricted_columns.should == nil
+    @c.set_restricted_columns :x
+    @c.restricted_columns.should == [:x]
+    @c.set_restricted_columns :x, :y
+    @c.restricted_columns.should == [:x, :y]
+  end
+
+  it "should not set restricted columns by default" do
+    @c.set_restricted_columns :z
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :z => 6)
+    i.values.should == {:x => 4, :y => 5}
+
+    @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7}
+    i = @c.new
+    i.update(:x => 7, :z => 9)
+    i.values.should == {:x => 7}
+    MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+  end
+
+  it "should have allowed take precedence over restricted" do
+    @c.set_allowed_columns :x, :y
+    @c.set_restricted_columns :y, :z
+    i = @c.new(:x => 1, :y => 2, :z => 3)
+    i.values.should == {:x => 1, :y => 2}
+    i.set(:x => 4, :y => 5, :z => 6)
+    i.values.should == {:x => 4, :y => 5}
+
+    @c.instance_dataset._fetch = @c.dataset._fetch = {:y => 7}
+    i = @c.new
+    i.update(:y => 7, :z => 9)
+    i.values.should == {:y => 7}
+    MODEL_DB.sqls.should == ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+  end
+end

data/spec/extensions/boolean_readers_spec.rb

@@ -2,7 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "BooleanReaders plugin" do
   before do
-    @db = Sequel::Database.new({})
+    @db = Sequel::Database.new
+    def @db.supports_schema_parsing?() true end
     def @db.schema(*args)
       [[:id, {}], [:z, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]
     end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "class_table_inheritance plugin" do
   before do
     @db = Sequel.mock(:autoid=>proc{|sql| 1})
+    def @db.supports_schema_parsing?() true end
     def @db.schema(table, opts={})
       {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
        :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
@@ -54,6 +55,12 @@ describe "class_table_inheritance plugin" do
     Staff.simple_table.should == nil
   end
   
+    specify "should have working row_proc if using set_dataset in subclass to remove columns" do
+      Manager.set_dataset(Manager.dataset.select(*(Manager.columns - [:blah])))
+      Manager.dataset._fetch = {:id=>1, :kind=>'Executive'}
+      Manager[1].should == Executive.load(:id=>1, :kind=>'Executive')
+    end
+
   specify "should use a joined dataset in subclasses" do
     Employee.dataset.sql.should == 'SELECT * FROM employees'
     Manager.dataset.sql.should == 'SELECT * FROM employees INNER JOIN managers USING (id)'

data/spec/extensions/columns_introspection_spec.rb

@@ -8,8 +8,6 @@ describe "Sequel::Dataset.introspect_all_columns" do
       # Handle case where introspect_all_columns has already been called
       alias columns columns_without_introspection unless instance_methods(false).map{|x| x.to_s}.include?('columns')
     end
-    Sequel::Dataset.introspect_all_columns
-    @db.reset
   end
   after do
     class Sequel::Dataset
@@ -17,7 +15,9 @@ describe "Sequel::Dataset.introspect_all_columns" do
     end
   end
 
-  specify "should turn on column introspection by default" do
+  qspecify "should turn on column introspection by default" do
+    Sequel::Dataset.introspect_all_columns
+    @db.reset
     @ds.select(:x).columns.should == [:x]
     @db.sqls.length.should == 0
   end

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -20,7 +20,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
     set_fetch({})
     @ds = @db[:items]
     @ds.instance_variable_set(:@columns, [:name])
-    @ds2 = @db.dup[:items2]
+    @ds2 = Sequel.mock[:items2]
     @ds2.instance_variable_set(:@columns, [:name])
   end
 
@@ -31,8 +31,9 @@ describe "Sequel::Plugins::ConstraintValidations" do
   it "should parse constraint validations when loading plugin" do
     @c = model_class
     @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
-    @db.constraint_validations.should == {'items'=>[[:validates_presence, :name]]}
+    @db.constraint_validations.should == {"items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}]}
     @c.constraint_validations.should == [[:validates_presence, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 
   it "should parse constraint validations with a custom constraint validations table" do
@@ -40,8 +41,9 @@ describe "Sequel::Plugins::ConstraintValidations" do
     @db.sqls
     c.plugin :constraint_validations, :constraint_validations_table=>:foo
     @db.sqls.should == ["SELECT * FROM foo"]
-    @db.constraint_validations.should == {'items'=>[[:validates_presence, :name]]}
+    @db.constraint_validations.should == {"items"=>[{:allow_nil=>nil, :constraint_name=>nil, :message=>nil, :validation_type=>"presence", :column=>"name", :argument=>nil, :table=>"items"}]}
     c.constraint_validations.should == [[:validates_presence, :name]]
+    c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 
   it "should populate constraint_validations when subclassing" do
@@ -52,6 +54,20 @@ describe "Sequel::Plugins::ConstraintValidations" do
     sc.set_dataset @ds
     @db.sqls.should == []
     sc.constraint_validations.should == [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.should == {: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.should == ["SELECT * FROM foo"]
+    sc = Class.new(c)
+    sc.plugin :constraint_validations
+    sc.constraint_validations_table.should == :foo
+    sc.set_dataset @ds
+    @db.sqls.should == []
+    sc.constraint_validations.should == [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 
   it "should populate constraint_validations when changing the model's dataset" do
@@ -64,114 +80,174 @@ describe "Sequel::Plugins::ConstraintValidations" do
     sc.set_dataset @ds
     @db.sqls.should == []
     sc.constraint_validations.should == [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.should == {: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
-    @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
+    @ds2.db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
     sc = Class.new(c)
     sc.set_dataset @ds
     @db.sqls.should == ["SELECT * FROM sequel_constraint_validations"]
     sc.constraint_validations.should == [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.should == {: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
-    @db.sqls.should == ["SELECT * FROM foo"]
+    @ds2.db.sqls.should == ["SELECT * FROM foo"]
     sc = Class.new(c)
     sc.set_dataset @ds
     @db.sqls.should == ["SELECT * FROM foo"]
     sc.constraint_validations.should == [[:validates_presence, :name]]
+    sc.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 
   it "should correctly retrieve :message option from constraint validations table" do
     model_class(:message=>'foo').constraint_validations.should == [[:validates_presence, :name, {:message=>'foo'}]]
+    @c.constraint_validation_reflections.should == {:name=>[[:presence, {:message=>'foo'}]]}
   end
 
   it "should correctly retrieve :allow_nil option from constraint validations table" do
     model_class(:allow_nil=>true).constraint_validations.should == [[:validates_presence, :name, {:allow_nil=>true}]]
+    @c.constraint_validation_reflections.should == {:name=>[[:presence, {:allow_nil=>true}]]}
   end
 
   it "should handle presence validation" do
     model_class(:validation_type=>'presence').constraint_validations.should == [[:validates_presence, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 
   it "should handle exact_length validation" do
     model_class(:validation_type=>'exact_length', :argument=>'5').constraint_validations.should == [[:validates_exact_length, 5, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:exact_length, {:argument=>5}]]}
   end
 
   it "should handle min_length validation" do
     model_class(:validation_type=>'min_length', :argument=>'5').constraint_validations.should == [[:validates_min_length, 5, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:min_length, {:argument=>5}]]}
   end
 
   it "should handle max_length validation" do
     model_class(:validation_type=>'max_length', :argument=>'5').constraint_validations.should == [[:validates_max_length, 5, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:max_length, {:argument=>5}]]}
   end
 
   it "should handle length_range validation" do
     model_class(:validation_type=>'length_range', :argument=>'3..5').constraint_validations.should == [[:validates_length_range, 3..5, :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_length_range, 3...5, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:length_range, {:argument=>3...5}]]}
   end
 
   it "should handle format validation" do
     model_class(:validation_type=>'format', :argument=>'^foo.*').constraint_validations.should == [[:validates_format, /^foo.*/, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/^foo.*/}]]}
   end
 
   it "should handle format validation with case insensitive format" do
     model_class(:validation_type=>'iformat', :argument=>'^foo.*').constraint_validations.should == [[:validates_format, /^foo.*/i, :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_includes, %w'a b c', :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_includes, [1, 2, 3], :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_includes, 3..5, :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_includes, 3...5, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:includes, {:argument=>3...5}]]}
   end
 
   it "should handle like validation" do
     model_class(:validation_type=>'like', :argument=>'foo').constraint_validations.should == [[:validates_format, /\Afoo\z/, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\Afoo\z/}]]}
   end
 
   it "should handle ilike validation" do
     model_class(:validation_type=>'ilike', :argument=>'foo').constraint_validations.should == [[:validates_format, /\Afoo\z/i, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\Afoo\z/i}]]}
   end
 
   it "should handle like validation with % metacharacter" do
     model_class(:validation_type=>'like', :argument=>'%foo%').constraint_validations.should == [[:validates_format, /\A.*foo.*\z/, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\A.*foo.*\z/}]]}
   end
 
   it "should handle like validation with %% metacharacter" do
     model_class(:validation_type=>'like', :argument=>'%%foo%%').constraint_validations.should == [[:validates_format, /\A%foo%\z/, :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_format, /\Af.o\z/, :name]]
+    @c.constraint_validation_reflections.should == {: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.should == [[:validates_format, /\A\\wfoo\\d\z/, :name]]
+    @c.constraint_validation_reflections.should == {:name=>[[:format, {:argument=>/\A\\wfoo\\d\z/}]]}
   end
 
   it "should handle unique validation" do
     model_class(:validation_type=>'unique').constraint_validations.should == [[:validates_unique, [:name]]]
+    @c.constraint_validation_reflections.should == {:name=>[[:unique, {}]]}
   end
 
   it "should handle unique validation with multiple columns" do
     model_class(:validation_type=>'unique', :column=>'name,id').constraint_validations.should == [[:validates_unique, [:name, :id]]]
+    @c.constraint_validation_reflections.should == {[: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.should == [[:validates_unique, [:name], {:message=>'is bad'}]]
+    c.constraint_validation_reflections.should == {:name=>[[:unique, {:message=>'is bad'}]]}
+    c.dataset._fetch = {:count=>1}
+    o = c.new(:name=>'a')
+    o.valid?.should == false
+    o.errors.full_messages.should == ['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.should == [[:validates_unique, [:name], {:message=>'is bad', :allow_nil=>true}]]
+    c.constraint_validation_reflections.should == {:name=>[[:unique, {:message=>'is bad', :allow_nil=>true}]]}
+    c.dataset._fetch = {:count=>1}
+    o = c.new(:name=>'a')
+    o.valid?.should == false
+    o.errors.full_messages.should == ['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.should == [[:validates_unique, [:name], {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]
+    sc.constraint_validation_reflections.should == {:name=>[[:unique, {:message=>'is bad', :allow_missing=>true, :allow_nil=>false}]]}
+    sc.dataset._fetch = {:count=>1}
+    o = sc.new(:name=>'a')
+    o.valid?.should == false
+    o.errors.full_messages.should == ['name is bad']
   end
 
   it "should used parsed constraint validations when validating" do
@@ -185,6 +261,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c = Class.new(Sequel::Model(@db[Sequel.identifier(:sch__items)]))
     c.plugin :constraint_validations
     c.constraint_validations.should == [[:validates_presence, :name]]
+    c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 
   it "should handle a table name specified as SQL::QualifiedIdentifier" do
@@ -192,5 +269,6 @@ describe "Sequel::Plugins::ConstraintValidations" do
     c = Class.new(Sequel::Model(@db[Sequel.qualify(:sch, :items)]))
     c.plugin :constraint_validations
     c.constraint_validations.should == [[:validates_presence, :name]]
+    c.constraint_validation_reflections.should == {:name=>[[:presence, {}]]}
   end
 end