sequel 2.12.0 → 3.0.0

data/spec/model/spec_helper.rb

@@ -10,31 +10,6 @@ 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)
@@ -104,12 +79,10 @@ 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 = {}

data/spec/model/validations_spec.rb

@@ -75,122 +75,6 @@ describe Sequel::Model::Errors do
   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
@@ -222,821 +106,6 @@ describe Sequel::Model do
   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