sequel 2.11.0 → 2.12.0

data/spec/model/schema_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "table_exists?" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  it "should get the table name and question the model's db if table_exists?" do
+    @model.should_receive(:table_name).and_return(:items)
+    @model.db.should_receive(:table_exists?)
+    @model.table_exists?
+  end
+
+end
+
+describe Sequel::Model, "create_table and schema" do
+
+  before(:each) do
+    MODEL_DB.reset
+    deprec do
+      @model = Class.new(Sequel::Model) do
+        set_schema(:items) do
+          text :name
+          float :price, :null => false
+        end
+      end
+    end
+  end
+
+  deprec_specify "should get the create table SQL list from the db and execute it line by line" do
+    @model.create_table
+    MODEL_DB.sqls.should == ['CREATE TABLE items (name text, price float NOT NULL)']
+  end
+
+  deprec_specify "should reload the schema from the database" do
+    schem = {:name=>{:type=>:string}, :price=>{:type=>:float}}
+    @model.db.should_receive(:schema).with(:items, :reload=>true).and_return(schem.to_a.sort_by{|x| x[0].to_s})
+    @model.create_table
+    @model.db_schema.should == schem
+    @model.instance_variable_get(:@columns).should == [:name, :price]
+  end
+
+  deprec_specify "should return the schema generator via schema" do
+    @model.schema.should be_a_kind_of(Sequel::Schema::Generator)
+  end
+
+  deprec_specify "should use the superclasses schema if it exists" do
+    @submodel = Class.new(@model)
+    @submodel.schema.should be_a_kind_of(Sequel::Schema::Generator)
+  end
+
+  deprec_specify "should return nil if no schema is present" do
+    @model = Class.new(Sequel::Model)
+    @model.schema.should == nil
+    @submodel = Class.new(@model)
+    @submodel.schema.should == nil
+  end
+end
+
+describe Sequel::Model, "drop_table" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+
+  deprec_specify "should get the drop table SQL for the associated table and then execute the SQL." do
+    @model.should_receive(:table_name).and_return(:items)
+    @model.db.should_receive(:drop_table_sql).with(:items)
+    @model.db.should_receive(:execute).and_return(:true)
+    @model.drop_table
+  end
+
+end
+
+describe Sequel::Model, "create_table!" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @model = Class.new(Sequel::Model(:items))
+  end
+  
+  deprec_specify "should drop table if it exists and then create the table" do
+    @model.should_receive(:drop_table).and_return(true)
+    @model.should_receive(:create_table).and_return(true)
+
+    @model.create_table!
+  end
+
+end

data/spec/model/spec_helper.rb

@@ -0,0 +1,124 @@
+require 'rubygems'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel/core'
+end
+unless Sequel.const_defined?('Model')
+  $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
+  require 'sequel/model'
+end
+
+Sequel.virtual_row_instance_eval = true
+
+module Spec::Example::ExampleMethods
+  def deprec
+    output = Sequel::Deprecation.output = nil
+    begin
+      yield
+    ensure
+      Sequel::Deprecation.output = output
+    end
+  end
+end
+
+module Spec::Example::ExampleGroupMethods
+  def deprec_specify(*args, &block)
+    specify(*args) do
+      output = Sequel::Deprecation.output
+      Sequel::Deprecation.output = nil
+      begin
+        instance_eval(&block)
+      ensure
+        Sequel::Deprecation.output = output
+      end
+    end
+  end
+end
+
+class MockDataset < Sequel::Dataset
+  def insert(*args)
+    @db.execute insert_sql(*args)
+  end
+  
+  def update(*args)
+    @db.execute update_sql(*args)
+  end
+  
+  def delete(*args)
+    @db.execute delete_sql(*args)
+  end
+  
+  def fetch_rows(sql)
+    return if sql =~ /information_schema/
+    @db.execute(sql)
+    yield({:id => 1, :x => 1})
+  end
+
+  def quoted_identifier(c)
+    "\"#{c}\""
+  end
+end
+
+class MockDatabase < Sequel::Database
+  @@quote_identifiers = false
+  self.identifier_input_method = nil
+  self.identifier_output_method = nil
+  attr_reader :sqls
+  
+  def execute(sql, opts={})
+    @sqls ||= []
+    @sqls << sql
+  end
+
+  def reset
+    @sqls = []
+  end
+
+  def schema(table_name, opts)
+    if table_name
+      [[:id, {:primary_key=>true}]]
+    else
+      {table_name=>[[:id, {:primary_key=>true}]]}
+    end
+  end
+
+   def transaction(opts={})
+    return yield if @transactions.include?(Thread.current)
+    execute('BEGIN')
+    begin
+      @transactions << Thread.current
+      yield
+    rescue Exception => e
+      execute('ROLLBACK')
+      transaction_error(e)
+    ensure
+      unless e
+        execute('COMMIT')
+      end
+      @transactions.delete(Thread.current)
+    end
+  end
+
+  def dataset(opts=nil); MockDataset.new(self, opts); end
+end
+
+class << Sequel::Model
+  alias orig_columns columns
+  alias orig_str_columns str_columns
+  def columns(*cols)
+    return if cols.empty?
+    define_method(:columns){cols}
+    @dataset.instance_variable_set(:@columns, cols) if @dataset
+    define_method(:str_columns){cols.map{|x|x.to_s.freeze}}
+    def_column_accessor(*cols)
+    @columns = cols
+    @db_schema = {}
+    cols.each{|c| @db_schema[c] = {}}
+  end
+  def simple_table
+    nil
+  end
+end
+
+Sequel::Model.use_transactions = false
+Sequel::Model.db = MODEL_DB = MockDatabase.new

data/spec/model/validations_spec.rb

@@ -0,0 +1,1080 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model::Errors do
+  before do
+    @errors = Sequel::Model::Errors.new
+  end
+  
+  specify "should be clearable using #clear" do
+    @errors.add(:a, 'b')
+    @errors.should == {:a=>['b']}
+    @errors.clear
+    @errors.should == {}
+  end
+  
+  specify "should be empty if no errors are added" do
+    @errors.should be_empty
+    @errors[:blah] << "blah"
+    @errors.should_not be_empty
+  end
+  
+  specify "should return errors for a specific attribute using #on or #[]" do
+    @errors[:blah].should == []
+    @errors.on(:blah).should == []
+
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    @errors.on(:blah).should == ['blah']
+
+    @errors[:bleu].should == []
+    @errors.on(:bleu).should == []
+  end
+  
+  specify "should accept errors using #[] << or #add" do
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    
+    @errors.add :blah, 'zzzz'
+    @errors[:blah].should == ['blah', 'zzzz']
+  end
+  
+  specify "should return full messages using #full_messages" do
+    @errors.full_messages.should == []
+    
+    @errors[:blow] << 'blieuh'
+    @errors[:blow] << 'blich'
+    @errors[:blay] << 'bliu'
+    msgs = @errors.full_messages
+    msgs.size.should == 3
+    msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
+  end
+
+  specify "should return the number of error messages using #count" do
+    @errors.count.should == 0
+    @errors.add(:a, 'b')
+    @errors.count.should == 1
+    @errors.add(:a, 'c')
+    @errors.count.should == 2
+    @errors.add(:b, 'c')
+    @errors.count.should == 3
+  end
+
+  specify "should return the array of error messages for a given attribute using #on" do
+    @errors.add(:a, 'b')
+    @errors.on(:a).should == ['b']
+    @errors.add(:a, 'c')
+    @errors.on(:a).should == ['b', 'c']
+    @errors.add(:b, 'c')
+    @errors.on(:a).should == ['b', 'c']
+  end
+
+  specify "should return nil if there are no error messages for a given attribute using #on" do
+    @errors.on(:a).should == nil
+    @errors.add(:b, 'b')
+    @errors.on(:a).should == nil
+  end
+end
+
+describe Sequel::Model do
+  before do
+    deprec do
+      @c = Class.new(Sequel::Model) do
+        def self.validates_coolness_of(attr)
+          validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
+        end
+      end
+    end
+  end
+  
+  deprec_specify "should respond to validates, validations, has_validations?" do
+    @c.should respond_to(:validations)
+    @c.should respond_to(:has_validations?)
+  end
+  
+  deprec_specify "should acccept validation definitions using validates_each" do
+    @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
+    o = @c.new
+    o.should_receive(:xx).once.and_return(40)
+    o.should_receive(:yy).once.and_return(60)
+    o.valid?.should == false
+    o.errors.full_messages.should == ['xx too low']
+  end
+
+  deprec_specify "should return true/false for has_validations?" do
+    @c.has_validations?.should == false
+    @c.validates_each(:xx) {1}
+    @c.has_validations?.should == true
+  end
+  
+  deprec_specify "should validate multiple attributes at once" do
+    o = @c.new
+    def o.xx
+      1
+    end
+    def o.yy
+      2
+    end
+    vals = nil
+    atts = nil
+    @c.validates_each([:xx, :yy]){|obj,a,v| atts=a; vals=v}
+    o.valid?
+    vals.should == [1,2]
+    atts.should == [:xx, :yy]
+  end
+  
+  deprec_specify "should respect allow_missing option when using multiple attributes" do
+    o = @c.new
+    def o.xx
+      self[:xx]
+    end
+    def o.yy
+      self[:yy]
+    end
+    vals = nil
+    atts = nil
+    @c.validates_each([:xx, :yy], :allow_missing=>true){|obj,a,v| atts=a; vals=v}
+
+    o.values[:xx] = 1
+    o.valid?
+    vals.should == [1,nil]
+    atts.should == [:xx, :yy]
+
+    vals = nil
+    atts = nil
+    o.values.clear
+    o.values[:yy] = 2
+    o.valid?
+    vals.should == [nil, 2]
+    atts.should == [:xx, :yy]
+
+    vals = nil
+    atts = nil
+    o.values.clear
+    o.valid?.should == true
+    vals.should == nil
+    atts.should == nil
+  end
+  
+  deprec_specify "should overwrite existing validation with the same tag and attribute" do
+    @c.validates_each(:xx, :xx, :tag=>:low) {|o, a, v| o.xxx; o.errors[a] << 'too low' if v < 50}
+    @c.validates_each(:yy, :yy) {|o, a, v| o.yyy; o.errors[a] << 'too low' if v < 50}
+    @c.validates_presence_of(:zz, :zz)
+    @c.validates_length_of(:aa, :aa, :tag=>:blah)
+    o = @c.new
+    def o.zz
+      @a ||= 0
+      @a += 1
+    end
+    def o.aa
+      @b ||= 0
+      @b += 1
+    end
+    o.should_receive(:xx).once.and_return(40)
+    o.should_receive(:yy).once.and_return(60)
+    o.should_receive(:xxx).once
+    o.should_receive(:yyy).twice
+    o.valid?.should == false
+    o.zz.should == 2
+    o.aa.should == 2
+    o.errors.full_messages.should == ['xx too low']
+  end
+
+  deprec_specify "should provide a validates method that takes block with validation definitions" do
+    @c.validates do
+      coolness_of :blah
+    end
+    @c.validations[:blah].should_not be_empty
+    o = @c.new
+    o.should_receive(:blah).once.and_return(nil)
+    o.valid?.should == false
+    o.errors.full_messages.should == ['blah is not cool']
+  end
+end
+
+describe Sequel::Model do
+  before do
+    @c = Class.new(Sequel::Model) do
+      columns :score
+      def validate
+        errors[:score] << 'too low' if score < 87
+      end
+    end
+    
+    @o = @c.new
+  end
+  
+  specify "should supply a #valid? method that returns true if validations pass" do
+    @o.score = 50
+    @o.should_not be_valid
+    @o.score = 100
+    @o.should be_valid
+  end
+  
+  specify "should provide an errors object" do
+    @o.score = 100
+    @o.should be_valid
+    @o.errors.should be_empty
+    
+    @o.score = 86
+    @o.should_not be_valid
+    @o.errors[:score].should == ['too low']
+    @o.errors[:blah].should be_empty
+  end
+end
+
+describe 'Sequel::Model::Validation::Generator' do
+  before do
+    $testit = nil
+    
+    @c = Class.new(Sequel::Model) do
+      def self.validates_blah
+        $testit = 1324
+      end
+    end
+  end
+  
+  deprec_specify "should instance_eval the block, sending everything to its receiver" do
+    @c.class_eval do
+      validates do
+        blah
+      end
+    end
+    $testit.should == 1324
+  end
+end
+
+describe Sequel::Model do
+  before do
+    @c = Class.new(Sequel::Model) do
+      columns :value
+      
+      def self.filter(*args)
+        o = Object.new
+        def o.count; 2; end
+        o
+      end
+
+      def skip; false; end
+      def dont_skip; true; end
+    end
+    @m = @c.new
+  end
+
+  deprec_specify "should validate acceptance_of" do
+    @c.validates_acceptance_of :value
+    @m.should be_valid
+    @m.value = '1'
+    @m.should be_valid
+  end
+  
+  deprec_specify "should validate acceptance_of with accept" do
+    @c.validates_acceptance_of :value, :accept => 'true'
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = 'true'
+    @m.should be_valid
+  end
+  
+  deprec_specify "should validate acceptance_of with allow_nil => false" do
+    @c.validates_acceptance_of :value, :allow_nil => false
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate acceptance_of with allow_missing => true" do
+    @c.validates_acceptance_of :value, :allow_missing => true
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate acceptance_of with allow_missing => true and allow_nil => false" do
+    @c.validates_acceptance_of :value, :allow_missing => true, :allow_nil => false
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate acceptance_of with if => true" do
+    @c.validates_acceptance_of :value, :if => :dont_skip
+    @m.value = '0'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate acceptance_of with if => false" do
+    @c.validates_acceptance_of :value, :if => :skip
+    @m.value = '0'
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate acceptance_of with if proc that evaluates to true" do
+    @c.validates_acceptance_of :value, :if => proc{true}
+    @m.value = '0'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate acceptance_of with if proc that evaluates to false" do
+    @c.validates_acceptance_of :value, :if => proc{false}
+    @m.value = '0'
+    @m.should be_valid
+  end
+
+  deprec_specify "should raise an error if :if option is not a Symbol, Proc, or nil" do
+    @c.validates_acceptance_of :value, :if => 1
+    @m.value = '0'
+    proc{@m.valid?}.should raise_error(Sequel::Error)
+  end
+
+  deprec_specify "should validate confirmation_of" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_confirmation_of :value
+    
+    @m.value = 'blah'
+    @m.should_not be_valid
+    
+    @m.value_confirmation = 'blah'
+    @m.should be_valid
+  end
+  
+  deprec_specify "should validate confirmation_of with if => true" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_confirmation_of :value, :if => :dont_skip
+
+    @m.value = 'blah'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate confirmation_of with if => false" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_confirmation_of :value, :if => :skip
+
+    @m.value = 'blah'
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate confirmation_of with allow_missing => true" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_acceptance_of :value, :allow_missing => true
+    @m.should be_valid
+    @m.value_confirmation = 'blah'
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate format_of" do
+    @c.validates_format_of :value, :with => /.+_.+/
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = 'abc_def'
+    @m.should be_valid
+  end
+  
+  deprec_specify "should raise for validate_format_of without regexp" do
+    proc {@c.validates_format_of :value}.should raise_error(ArgumentError)
+    proc {@c.validates_format_of :value, :with => :blah}.should raise_error(ArgumentError)
+  end
+  
+  deprec_specify "should validate format_of with if => true" do
+    @c.validates_format_of :value, :with => /_/, :if => :dont_skip
+
+    @m.value = 'a'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate format_of with if => false" do
+    @c.validates_format_of :value, :with => /_/, :if => :skip
+
+    @m.value = 'a'
+    @m.should be_valid
+  end
+  
+  deprec_specify "should validate format_of with allow_missing => true" do
+    @c.validates_format_of :value, :allow_missing => true, :with=>/./
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate length_of with maximum" do
+    @c.validates_length_of :value, :maximum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate length_of with minimum" do
+    @c.validates_length_of :value, :minimum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate length_of with within" do
+    @c.validates_length_of :value, :within => 2..5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate length_of with is" do
+    @c.validates_length_of :value, :is => 3
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '12'
+    @m.should_not be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+  
+  deprec_specify "should validate length_of with allow_nil" do
+    @c.validates_length_of :value, :is => 3, :allow_nil => true
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate length_of with if => true" do
+    @c.validates_length_of :value, :is => 3, :if => :dont_skip
+
+    @m.value = 'a'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate length_of with if => false" do
+    @c.validates_length_of :value, :is => 3, :if => :skip
+
+    @m.value = 'a'
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate length_of with allow_missing => true" do
+    @c.validates_length_of :value, :allow_missing => true, :minimum => 5
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should allow multiple calls to validates_length_of with different options without overwriting" do
+    @c.validates_length_of :value, :maximum => 5
+    @c.validates_length_of :value, :minimum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate numericality_of" do
+    @c.validates_numericality_of :value
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should be_valid
+    @m.value = '+1'
+    @m.should be_valid
+    @m.value = '-1'
+    @m.should be_valid
+    @m.value = '+1.123'
+    @m.should be_valid
+    @m.value = '-0.123'
+    @m.should be_valid
+    @m.value = '-0.123E10'
+    @m.should be_valid
+    @m.value = '32.123e10'
+    @m.should be_valid
+    @m.value = '+32.123E10'
+    @m.should be_valid
+    @m.should be_valid
+    @m.value = '.0123'
+  end
+
+  deprec_specify "should validate numericality_of with only_integer" do
+    @c.validates_numericality_of :value, :only_integer => true
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should_not be_valid
+  end
+  
+  deprec_specify "should validate numericality_of with if => true" do
+    @c.validates_numericality_of :value, :if => :dont_skip
+
+    @m.value = 'a'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate numericality_of with if => false" do
+    @c.validates_numericality_of :value, :if => :skip
+
+    @m.value = 'a'
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate numericality_of with allow_missing => true" do
+    @c.validates_numericality_of :value, :allow_missing => true
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate presence_of" do
+    @c.validates_presence_of :value
+    @m.should_not be_valid
+    @m.value = ''
+    @m.should_not be_valid
+    @m.value = 1234
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+    @m.value = true
+    @m.should be_valid
+    @m.value = false
+    @m.should be_valid
+  end
+  
+  deprec_specify "should validate inclusion_of with an array" do
+    @c.validates_inclusion_of :value, :in => [1,2]
+    @m.should_not be_valid
+    @m.value = 1
+    @m.should be_valid
+    @m.value = 1.5
+    @m.should_not be_valid
+    @m.value = 2
+    @m.should be_valid    
+    @m.value = 3
+    @m.should_not be_valid 
+  end
+  
+  deprec_specify "should validate inclusion_of with a range" do
+    @c.validates_inclusion_of :value, :in => 1..4
+    @m.should_not be_valid
+    @m.value = 1
+    @m.should be_valid
+    @m.value = 1.5
+    @m.should be_valid
+    @m.value = 0
+    @m.should_not be_valid
+    @m.value = 5
+    @m.should_not be_valid    
+  end
+  
+  deprec_specify "should raise an error if inclusion_of doesn't receive a valid :in option" do
+    lambda {
+      @c.validates_inclusion_of :value
+    }.should raise_error(ArgumentError)
+    
+    lambda {
+      @c.validates_inclusion_of :value, :in => 1
+    }.should raise_error(ArgumentError)
+  end
+  
+  deprec_specify "should raise an error if inclusion_of handles :allow_nil too" do
+    @c.validates_inclusion_of :value, :in => 1..4, :allow_nil => true
+    @m.value = nil
+    @m.should be_valid
+    @m.value = 0
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate presence_of with if => true" do
+    @c.validates_presence_of :value, :if => :dont_skip
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate presence_of with if => false" do
+    @c.validates_presence_of :value, :if => :skip
+    @m.should be_valid
+  end
+
+  deprec_specify "should validate presence_of with allow_missing => true" do
+    @c.validates_presence_of :value, :allow_missing => true
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate uniqueness_of with if => true" do
+    @c.validates_uniqueness_of :value, :if => :dont_skip
+
+    @m.value = 'a'
+    @m.should_not be_valid
+  end
+
+  deprec_specify "should validate uniqueness_of with if => false" do
+    @c.validates_uniqueness_of :value, :if => :skip
+
+    @m.value = 'a'
+    @m.should be_valid
+  end
+  
+  deprec_specify "should validate uniqueness_of with allow_missing => true" do
+    @c.validates_uniqueness_of :value, :allow_missing => true
+    @m.should be_valid
+    @m.value = nil
+    @m.should_not be_valid
+  end
+end
+
+context "Superclass validations" do
+  before do
+    deprec do
+      @c1 = Class.new(Sequel::Model) do
+        columns :value
+        validates_length_of :value, :minimum => 5
+      end
+    
+      @c2 = Class.new(@c1) do
+        columns :value
+        validates_format_of :value, :with => /^[a-z]+$/
+      end
+    end
+  end
+  
+  deprec_specify "should be checked when validating" do
+    o = @c2.new
+    o.value = 'ab'
+    o.valid?.should == false
+    o.errors.full_messages.should == [
+      'value is too short'
+    ]
+
+    o.value = '12'
+    o.valid?.should == false
+    o.errors.full_messages.should == [
+      'value is too short',
+      'value is invalid'
+    ]
+
+    o.value = 'abcde'
+    o.valid?.should be_true
+  end
+  
+  deprec_specify "should be skipped if skip_superclass_validations is called" do
+    @c2.skip_superclass_validations
+
+    o = @c2.new
+    o.value = 'ab'
+    o.valid?.should be_true
+
+    o.value = '12'
+    o.valid?.should == false
+    o.errors.full_messages.should == [
+      'value is invalid'
+    ]
+
+    o.value = 'abcde'
+    o.valid?.should be_true
+  end
+end
+
+context ".validates with block" do
+  deprec_specify "should support calling .each" do
+    @c = Class.new(Sequel::Model) do
+      columns :vvv
+      validates do
+        each :vvv do |o, a, v|
+          o.errors[a] << "is less than zero" if v.to_i < 0
+        end
+      end
+    end
+    
+    o = @c.new
+    o.vvv = 1
+    o.should be_valid
+    o.vvv = -1
+    o.should_not be_valid
+  end
+end
+
+describe Sequel::Model, "Validations" do
+
+  before(:all) do
+    class ::Person < Sequel::Model
+      columns :id,:name,:first_name,:last_name,:middle_name,:initials,:age, :terms
+    end
+
+    class ::Smurf < Person
+    end
+    
+    class ::Cow < Sequel::Model
+      columns :id, :name, :got_milk
+    end
+
+    class ::User < Sequel::Model
+      columns :id, :username, :password
+    end
+    
+    class ::Address < Sequel::Model
+      columns :id, :zip_code
+    end
+  end
+  
+  deprec_specify "should validate the acceptance of a column" do
+    class ::Cow < Sequel::Model
+      validations.clear
+      validates_acceptance_of :got_milk, :accept => 'blah', :allow_nil => false
+    end
+    
+    @cow = Cow.new
+    @cow.should_not be_valid
+    @cow.errors.full_messages.should == ["got_milk is not accepted"]
+    
+    @cow.got_milk = "blah"
+    @cow.should be_valid
+  end
+  
+  deprec_specify "should validate the confirmation of a column" do
+    class ::User < Sequel::Model
+      def password_confirmation
+        "test"
+      end
+      
+      validations.clear
+      validates_confirmation_of :password
+    end
+    
+    @user = User.new
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ["password is not confirmed"]
+    
+    @user.password = "test"
+    @user.should be_valid
+  end
+  
+  deprec_specify "should validate format of column" do
+    class ::Person < Sequel::Model
+      validates_format_of :first_name, :with => /^[a-zA-Z]+$/
+    end
+
+    @person = Person.new :first_name => "Lancelot99"
+    @person.valid?.should be_false
+    @person = Person.new :first_name => "Anita"
+    @person.valid?.should be_true
+  end
+  
+  deprec_specify "should validate length of column" do
+    class ::Person < Sequel::Model
+      validations.clear
+      validates_length_of :first_name, :maximum => 30
+      validates_length_of :last_name, :minimum => 30
+      validates_length_of :middle_name, :within => 1..5
+      validates_length_of :initials, :is => 2
+    end
+    
+    @person = Person.new(
+      :first_name => "Anamethatiswaytofreakinglongandwayoverthirtycharacters",
+      :last_name => "Alastnameunderthirtychars",
+      :initials => "LGC",
+      :middle_name => "danger"
+    )
+    
+    @person.should_not be_valid
+    @person.errors.full_messages.size.should == 4
+    @person.errors.full_messages.should include(
+      'first_name is too long',
+      'last_name is too short',
+      'middle_name is the wrong length',
+      'initials is the wrong length'
+    )
+    
+    @person.first_name  = "Lancelot"
+    @person.last_name   = "1234567890123456789012345678901"
+    @person.initials    = "LC"
+    @person.middle_name = "Will"
+    @person.should be_valid
+  end
+  
+  deprec_specify "should validate that a column doesn't have a string value" do
+    p = Class.new(Sequel::Model)
+    p.class_eval do
+      columns :age, :price, :confirmed
+      self.raise_on_typecast_failure = false
+      validates_not_string :age
+      validates_not_string :confirmed
+      validates_not_string :price, :message=>'is not valid'
+      @db_schema = {:age=>{:type=>:integer}}
+    end
+    
+    @person = p.new
+    @person.should be_valid
+
+    @person.confirmed = 't'
+    @person.should_not be_valid
+    @person.errors.full_messages.should == ['confirmed is a string']
+    @person.confirmed = true
+    @person.should be_valid
+
+    @person.age = 'a'
+    @person.should_not be_valid
+    @person.errors.full_messages.should == ['age is not a valid integer']
+    @person.db_schema[:age][:type] = :datetime
+    @person.should_not be_valid
+    @person.errors.full_messages.should == ['age is not a valid datetime']
+    @person.age = 20
+    @person.should be_valid
+
+    @person.price = 'a'
+    @person.should_not be_valid
+    @person.errors.full_messages.should == ['price is not valid']
+    @person.price = 20
+    @person.should be_valid
+  end
+  
+  deprec_specify "should validate numericality of column" do
+    class ::Person < Sequel::Model
+      validations.clear
+      validates_numericality_of :age
+    end
+    
+    @person = Person.new :age => "Twenty"
+    @person.should_not be_valid
+    @person.errors.full_messages.should == ['age is not a number']
+    
+    @person.age = 20
+    @person.should be_valid
+  end
+  
+  deprec_specify "should validate the presence of a column" do
+    class ::Cow < Sequel::Model
+      validations.clear
+      validates_presence_of :name
+    end
+    
+    @cow = Cow.new
+    @cow.should_not be_valid
+    @cow.errors.full_messages.should == ['name is not present']
+    
+    @cow.name = "Betsy"
+    @cow.should be_valid
+  end
+ 
+  deprec_specify "should validate the uniqueness of a column" do
+    class ::User < Sequel::Model
+      validations.clear
+      validates do
+        uniqueness_of :username
+      end
+    end
+    User.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        
+        case sql
+        when /COUNT.*username = '0records'/
+          yield({:v => 0})
+        when /COUNT.*username = '2records'/
+          yield({:v => 2})
+        when /COUNT.*username = '1record'/
+          yield({:v => 1})
+        when /username = '1record'/
+          yield({:id => 3, :username => "1record", :password => "test"})
+        end
+      end
+    })
+    
+    @user = User.new(:username => "2records", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    @user = User.new(:username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    @user = User.load(:id=>4, :username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username is already taken']
+
+    @user = User.load(:id=>3, :username => "1record", :password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+
+    @user = User.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+  end
+  
+  deprec_specify "should validate the uniqueness of multiple columns" do
+    class ::User < Sequel::Model
+      validations.clear
+      validates do
+        uniqueness_of [:username, :password]
+      end
+    end
+    User.dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        
+        case sql
+        when /COUNT.*username = '0records'/
+          yield({:v => 0})
+        when /COUNT.*username = '2records'/
+          yield({:v => 2})
+        when /COUNT.*username = '1record'/
+          yield({:v => 1})
+        when /username = '1record'/
+          if sql =~ /password = 'anothertest'/
+            yield({:id => 3, :username => "1record", :password => "anothertest"})
+          else
+            yield({:id => 4, :username => "1record", :password => "test"})
+          end
+        end
+      end
+    })
+    
+    @user = User.new(:username => "2records", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username and password is already taken']
+
+    @user = User.new(:username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username and password is already taken']
+
+    @user = User.load(:id=>4, :username => "1record", :password => "anothertest")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username and password is already taken']
+
+    @user = User.load(:id=>3, :username => "1record", :password => "test")
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ['username and password is already taken']
+
+    @user = User.load(:id=>3, :username => "1record", :password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+
+    @user = User.new(:username => "0records", :password => "anothertest")
+    @user.should be_valid
+    @user.errors.full_messages.should == []
+  end
+  
+  deprec_specify "should have a validates block that contains multiple validations" do
+    class ::Person < Sequel::Model
+      validations.clear
+      validates do
+        format_of :first_name, :with => /^[a-zA-Z]+$/
+        length_of :first_name, :maximum => 30
+      end
+    end
+
+    Person.validations[:first_name].size.should == 2
+    
+    @person = Person.new :first_name => "Lancelot99"
+    @person.valid?.should be_false
+    
+    @person2 = Person.new :first_name => "Wayne"
+    @person2.valid?.should be_true
+  end
+
+  deprec_specify "should allow 'longhand' validations direcly within the model." do
+    lambda {
+      class ::Person < Sequel::Model
+        validations.clear
+        validates_length_of :first_name, :maximum => 30
+      end
+    }.should_not raise_error
+    Person.validations.length.should eql(1)
+  end
+
+  deprec_specify "should define a has_validations? method which returns true if the model has validations, false otherwise" do
+    class ::Person < Sequel::Model
+      validations.clear
+      validates do
+        format_of :first_name, :with => /\w+/
+        length_of :first_name, :maximum => 30
+      end
+    end
+
+    class ::Smurf < Person
+      validations.clear
+    end
+
+    Person.should have_validations
+    Smurf.should_not have_validations
+  end
+
+  deprec_specify "should validate correctly instances initialized with string keys" do
+    class ::Can < Sequel::Model
+      columns :id, :name
+      
+      validates_length_of :name, :minimum => 4
+    end
+    
+    Can.new('name' => 'ab').should_not be_valid
+    Can.new('name' => 'abcd').should be_valid
+  end
+  
+end
+
+describe "Model#save!" do
+  before do
+    @c = Class.new(Sequel::Model(:people)) do
+      def columns; [:id]; end
+      
+      validates_each :id do |o, a, v|
+        o.errors[a] << 'blah' unless v == 5
+      end
+    end
+    @m = @c.load(:id => 4)
+    MODEL_DB.reset
+  end
+  
+  deprec_specify "should save regardless of validations" do
+    @m.should_not be_valid
+    @m.save!
+    MODEL_DB.sqls.should == ['UPDATE people SET id = 4 WHERE (id = 4)']
+  end
+end
+
+describe "Model#save" do
+  before do
+    @c = Class.new(Sequel::Model(:people)) do
+      columns :id
+
+      def validate
+        errors[:id] << 'blah' unless id == 5
+      end
+    end
+    @m = @c.load(:id => 4)
+    MODEL_DB.reset
+  end
+
+  specify "should save only if validations pass" do
+    @m.raise_on_save_failure = false
+    @m.should_not be_valid
+    @m.save
+    MODEL_DB.sqls.should be_empty
+    
+    @m.id = 5
+    @m.should be_valid
+    @m.save.should_not be_false
+    MODEL_DB.sqls.should == ['UPDATE people SET id = 5 WHERE (id = 5)']
+  end
+  
+  specify "should skip validations if the :validate=>false option is used" do
+    @m.raise_on_save_failure = false
+    @m.should_not be_valid
+    @m.save(:validate=>false)
+    MODEL_DB.sqls.should == ['UPDATE people SET id = 4 WHERE (id = 4)']
+  end
+    
+  specify "should raise error if validations fail and raise_on_save_faiure is true" do
+    proc{@m.save}.should raise_error(Sequel::ValidationFailed)
+  end
+  
+  specify "should return nil if validations fail and raise_on_save_faiure is false" do
+    @m.raise_on_save_failure = false
+    @m.save.should == nil
+  end
+end