mv-core 0.1.0

data/lib/migration_validators/core/statement_builder.rb

@@ -0,0 +1,60 @@
+module MigrationValidators
+  module Core
+    class StatementBuilder
+      attr_reader :actions
+
+      def initialize value = "", builder = nil
+        @stmt = value
+        @actions = builder ? builder.actions.clone : {}
+      end
+
+      def to_s
+        @stmt
+      end
+
+      def operation name, &block
+        @actions[name.to_s] = block || lambda{|stmt| stmt}
+      end
+
+      def compile value
+        StatementBuilder.new value, self
+      end
+
+      def merge! builder
+        @actions.merge!(builder.actions) if builder
+      end
+
+      alias_method :old_method_missing, :method_missing
+      def method_missing method_name, *args
+        call_action(method_name, *args) || old_method_missing(method_name, *args)
+      end
+
+      protected
+      
+
+      attr_accessor :stmt
+
+      def clear! 
+        @stmt = ""
+      end
+
+      def change *args, &block
+        @stmt = instance_exec(*args, &block).to_s
+      end
+
+      private
+
+      def call_action action_name, *args
+        block = @actions[action_name.to_s]
+
+        if (block)
+          change(@stmt, *args, &block)
+          return self
+        end
+
+        return nil
+      end
+
+    end
+  end
+end

data/lib/migration_validators/core/validator_container.rb

@@ -0,0 +1,110 @@
+module MigrationValidators
+  module Core
+    class ValidatorContainer < StatementBuilder
+      attr_reader :name
+
+      def initialize name, definitions, builder = nil
+        super "", builder
+
+        @name = name
+        @definitions = definitions
+
+        group do |validator|
+          validator.name
+        end
+
+        constraint_name do |group_key|
+          group_key.to_s
+        end
+
+        operation :create do |stmt, group_name|
+          stmt
+        end
+
+        operation :drop do
+          ""
+        end
+
+        operation :join do |stmt, stmt_1|
+          [stmt, stmt_1].delete_if(&:blank?).join(" JOIN ")
+        end
+      end
+
+      def group &block
+        @group_proc = block
+      end
+
+      def constraint_name &block
+        @constraint_name_proc = block
+      end
+
+      def add_validators validators
+        res, constraint_name = process_validators(validators) do |existing_validators|
+          validators + existing_validators
+        end
+
+        validators.each {|validator| validator.save_to_constraint(constraint_name) }
+
+        res
+      end
+
+      def remove_validators validators
+        res, constraint_name = process_validators(validators) do |existing_validators|
+          existing_validators - validators
+        end
+
+        validators.each {|validator| validator.remove_from_constraint(constraint_name) }
+
+        res
+      end
+
+      private
+
+      def process_validators validators
+        validators.group_by(&@group_proc).inject([]) do |res, (group_name, group)|
+          constraint_name = @constraint_name_proc.call(group_name)
+          constraint_validators = MigrationValidators::Core::DbValidator.constraint_validators(constraint_name)
+
+          group = yield(constraint_validators).uniq
+
+          stmt = drop_group(constraint_name, group_name)
+          res << stmt unless stmt.blank?
+
+          unless group.blank?
+            stmt = create_group(constraint_name, group_name, group) 
+            res << stmt unless stmt.blank?
+          end
+          [res, constraint_name]
+        end
+      end
+
+      def isolate 
+        clear!
+        yield if block_given?
+        res = self.to_s
+        clear!
+        res
+      end
+
+      def drop_group constraint_name, group_name
+        isolate { drop(constraint_name, group_name) }
+      end
+
+      def create_group constraint_name, group_name, group
+        isolate do
+          group.each do |validator|
+            definition = @definitions[validator.validator_name.to_s] || @definitions[validator.validator_name.to_sym]
+
+            raise MigrationValidators::MigrationValidatorsException.new("Validator defintion for #{validator.validator_name} is not defined.") unless definition
+
+            definition.clone(self).process(validator).each do |statement|
+              join(statement)
+            end
+          end
+          
+          create(constraint_name, group_name) unless group.blank?
+        end
+      end
+    end 
+  end
+end

data/lib/migration_validators/core/validator_definition.rb

@@ -0,0 +1,91 @@
+module MigrationValidators
+  module Core
+    class ValidatorDefinition < StatementBuilder
+      attr_reader :validator
+
+      def initialize definition = nil, validator = nil, properties = {}, posts = []
+        super "", definition
+
+        @properties = properties
+        @posts = posts
+
+        self.validator = validator if validator
+
+        operation :bind_to_error do |stmt, error|
+          stmt
+        end
+      end
+
+      def validator= validator
+        @validator = validator
+        @stmt = validator.column_name
+      end
+
+      def column
+        clone
+      end
+
+      def clone builder = nil
+        res = ValidatorDefinition.new self, validator, @properties.clone, @posts.clone
+        res.merge!(builder) if builder
+        res
+      end
+
+      def property name = "", opts = {}, &block
+        @properties[name.to_s] ||= [opts, block]
+      end
+
+      def post opts = {}, &block
+        @posts << [opts, block]
+      end
+
+      def process validator, filter = []
+        self.validator = validator
+
+        return [] if validator.options.nil?
+
+        unless filter.blank? 
+          filter = filter.collect(&:to_s)
+          options = validator.options.select{|name, value| filter.include?(name.to_s) }
+        else
+          options = validator.options
+        end
+
+        res = options.inject([]) do |res, (property_name, property_value)|
+          res << self.to_s if handle_property(property_name, property_value)
+          res
+        end
+
+        return res unless res.blank?
+        return (handle_property("", options) && res << self.to_s) || []
+      end
+
+      private 
+
+      def handle_property property_name, property_value
+          opts, block = @properties[property_name.to_s]
+
+          if (block)
+            at_least_one_property_handled = true
+            change(property_value, &block)
+            apply_posts
+            bind_to_error(message(opts))
+
+            return true
+          end
+
+          false
+      end
+
+      def apply_posts 
+        @posts.each{|opts, post_block| change(&post_block) if validator.satisfies(opts)}
+      end
+
+      def message opts
+        validator.options[opts[:message]] || 
+        validator.options[:message] ||
+        validator.error_message
+      end
+    end
+  end
+end

data/lib/migration_validators/core/validator_router.rb

@@ -0,0 +1,45 @@
+module MigrationValidators
+  module Core
+    class ValidatorRouter 
+      def initialize containers
+        @containers = containers
+        @routes = {}
+      end
+
+      def to container_name, conditions = {}
+        raise "Container name is undefined" if container_name.blank?
+
+        @routes[container_name] ||= conditions[:if]
+      end
+
+      def add_validators validators
+        process(validators) do |container, filtered_validators|
+          container.add_validators(filtered_validators)
+        end
+      end
+      
+      def remove_validators validators
+        process(validators) do |container, filtered_validators|
+          container.remove_validators(filtered_validators)
+        end
+      end
+
+      private
+
+      def process validators
+        @routes.inject([]) do |res, (container_name, conditions)| 
+          filtered_validators = validators.select {|validator| validator.satisfies(conditions)}
+
+          unless filtered_validators.blank?
+            container = @containers[container_name]
+            raise MigrationValidators::MigrationValidatorsException.new("Routing error. Contianer #{container_name} is not defined.") if container.nil?
+
+            res.concat(yield(container, filtered_validators))
+          end
+
+          res
+        end
+      end
+    end
+  end
+end

data/lib/mv-core.rb

@@ -0,0 +1,100 @@
+require 'active_support'
+require 'active_record'
+
+require File.expand_path(File.dirname(__FILE__)) + '/options'
+
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/connection_adapters/table'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/connection_adapters/abstract_adapter'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/connection_adapters/native_adapter'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/connection_adapters/table_definition'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/base'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/migration'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/schema'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/active_record/schema_dumper'
+
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/core/db_validator'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/core/adapter_wrapper'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/core/statement_builder'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/core/validator_definition'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/core/validator_container'
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/core/validator_router'
+
+require File.expand_path(File.dirname(__FILE__)) + '/migration_validators/adapters/base'
+
+module MigrationValidators
+  class MigrationValidatorsException < Exception; end
+  class << self
+    def validators
+      @validators ||= {}
+    end
+
+    def dumpers
+      @dumpers ||= {}
+    end
+
+    def register_adapter! name, klass
+      validators[name] = klass
+      reload_validator
+    end
+
+    def register_dumper! name, klass
+      dumpers[name] = klass
+    end
+
+    def current_connection_adapter
+      ::ActiveRecord::Base.connection_pool.spec.config[:adapter]
+    end
+  
+    def dumper 
+      @dumper || dumpers[current_adapter].new
+    end
+
+    def adapter= adapter
+      @adapter = adapter
+      @validator = nil
+    end
+
+    def adapter
+      @adapter
+    end
+
+    def validator 
+      return nil unless @adapter || validators[current_connection_adapter]
+
+      @validator ||= MigrationValidators::Core::AdapterWrapper.new(@adapter || validators[current_connection_adapter].new)
+    end
+
+    def reload_validator
+      @adapter = nil
+      @validator = nil
+    end
+
+    def load!
+      ::ActiveRecord::ConnectionAdapters::TableDefinition.class_eval { include MigrationValidators::ActiveRecord::ConnectionAdapters::TableDefinition }
+      ::ActiveRecord::ConnectionAdapters::Table.class_eval { include MigrationValidators::ActiveRecord::ConnectionAdapters::Table }
+      ::ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval { include MigrationValidators::ActiveRecord::ConnectionAdapters::AbstractAdapter }
+      ::ActiveRecord::Base.instance_eval { include MigrationValidators::ActiveRecord::Base }
+      ::ActiveRecord::Migration.instance_eval { include MigrationValidators::ActiveRecord::Migration }
+      ::ActiveRecord::Schema.instance_eval { include MigrationValidators::ActiveRecord::Schema }
+      ::ActiveRecord::SchemaDumper.instance_eval { include MigrationValidators::ActiveRecord::SchemaDumper }
+
+      ::ActiveRecord::SchemaDumper.ignore_tables << MigrationValidators.migration_validators_table_name.to_s
+    end
+  end
+end
+
+Dir.glob('adapters/**/*.rb').each {|file_name| require file_name}
+
+if defined?(Rails::Railtie)
+  module Foreigner
+    class Railtie < Rails::Railtie
+      initializer 'migration-validators.load' do
+        ActiveSupport.on_load :active_record do
+          MigrationValidators.load!
+        end
+      end
+    end
+  end
+else
+  MigrationValidators.load!
+end

data/lib/options.rb

@@ -0,0 +1,7 @@
+module MigrationValidators
+  @migration_validators_table_name = :migration_validators
+
+  class << self
+    attr_accessor :migration_validators_table_name
+  end
+end

data/spec/migration_validators/active_record/connection_adapters/abstract_adapter_spec.rb

@@ -0,0 +1,440 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+
+AbstractAdapter = ::ActiveRecord::ConnectionAdapters::AbstractAdapter
+
+describe ::ActiveRecord::ConnectionAdapters::AbstractAdapter, "migration validators extension", :type => :mv_test do
+
+  before :all do
+    use_memory_db
+    @migrations_table = ::ActiveRecord::Migrator::schema_migrations_table_name
+    @validators_table = MigrationValidators.migration_validators_table_name
+  end
+
+  before :each do
+    MigrationValidators::Core::DbValidator.rollback
+  end
+
+  describe :initialize_migration_validators_table do
+    before :each do
+      db.drop_table @validators_table if db.table_exists?(@validators_table)
+    end
+
+    it "creates table if it's not created" do
+      db.initialize_migration_validators_table
+      db.table_exists?(@validators_table).should be_true
+    end
+
+    it "should not throw an error if table already exists" do
+      db.initialize_migration_validators_table
+
+      lambda { db.initialize_migration_validators_table }.should_not raise_error
+    end
+  end
+
+  describe :initialize_schema_migrations_table do
+    before :each do
+
+      db.do_internally do
+        db.drop_table @migrations_table if db.table_exists?(@migrations_table)
+        db.drop_table @validators_table if db.table_exists?(@validators_table)
+      end
+      db.initialize_schema_migrations_table
+    end
+
+    it "should initialize migrations table as usuall" do
+      db.table_exists?(@migrations_table).should be_true
+    end
+
+    it "should also initialize validators table" do
+      db.table_exists?(@validators_table).should be_true
+    end
+  end
+
+  describe "synchronization with schema statements" do
+    before :each do
+
+      db.do_internally do
+        db.drop_table :new_table_name if db.table_exists?(:new_table_name)
+        db.drop_table :table_name if db.table_exists?(:table_name)
+        db.create_table(:table_name) do |t|
+          t.string :column_name 
+          t.string :column_name1
+        end 
+      end
+
+      MigrationValidators::Core::DbValidator.delete_all
+    end
+
+    describe :drop_table do
+      it "drops all validators of the dropped table" do
+        db.validate_column :table_name, :column_name, :uniqueness => {:message => "some message"}
+        MigrationValidators::Core::DbValidator.commit
+
+        db.drop_table :table_name
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.count.should be_zero
+      end
+
+      it "still drops table" do
+        db.drop_table :table_name
+        db.table_exists?(:table_name).should be_false
+      end
+    end
+
+    describe :remove_column do
+      it "removes column validators" do
+        db.validate_column :table_name, :column_name, :uniqueness => {:message => "some message"}
+        db.validate_column :table_name, :column_name1, :uniqueness => {:message => "some message"}
+        MigrationValidators::Core::DbValidator.commit
+
+        db.remove_column :table_name, :column_name1
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.count.should == 1
+        MigrationValidators::Core::DbValidator.first.column_name.should == "column_name"
+      end
+
+      it "still removes column" do
+        db.remove_column :table_name, :column_name1
+        db.column_exists?(:table_name, :column_name1).should be_false
+      end
+    end
+
+
+    describe :rename_column do
+      it "updates column name in validators table" do
+        db.validate_column :table_name, :column_name, :uniqueness => {:message => "some message"}
+        db.validate_column :table_name, :column_name1, :uniqueness => {:message => "some message"}
+        MigrationValidators::Core::DbValidator.commit
+
+        db.rename_column :table_name, :column_name1, :column_name2
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.column_validators(:table_name, :column_name2).should_not be_blank
+      end
+
+      it "still renames column" do
+        db.rename_column :table_name, :column_name1, :column_name2
+        MigrationValidators::Core::DbValidator.commit
+
+        db.column_exists?(:table_name, :column_name1).should be_false
+        db.column_exists?(:table_name, :column_name2).should be_true
+      end
+    end
+
+    describe :rename_table do
+      it "updates table name in validators table" do
+        db.validate_column :table_name, :column_name, :uniqueness => {:message => "some message"}
+        MigrationValidators::Core::DbValidator.commit
+
+        db.rename_table :table_name, :new_table_name
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.table_validators(:new_table_name).should_not be_blank
+      end
+
+      it "still renames table" do
+        db.rename_table :table_name, :new_table_name
+
+        db.table_exists?(:table_name).should be_false
+        db.table_exists?(:new_table_name).should be_true
+      end
+    end
+
+    describe :add_column do
+      before :each do
+        db.add_column :table_name, :new_column, :integer, :validates => {:uniqueness => true}
+        MigrationValidators::Core::DbValidator.commit
+      end
+
+      it "should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:table_name, :new_column).should_not be_blank
+      end
+
+      it "should still add column" do
+        db.column_exists?(:table_name, :new_column).should be_true
+      end
+    end
+
+    describe :change_column do
+      before :each do
+        db.add_column :table_name, :new_column, :integer, :validates => {:uniqueness => true}
+        MigrationValidators::Core::DbValidator.commit
+
+        db.change_column :table_name, :new_column, :string, :validates => {:presense => true}
+        MigrationValidators::Core::DbValidator.commit
+      end
+
+      it "should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:table_name, :new_column).first.validator_name.should == "presense"
+      end
+
+      it "should still change column" do
+        db.columns(:table_name).find{|col| col.name.to_sym == :new_column}.type.should == :string
+      end
+    end
+
+    describe :create_table do
+      before :each do
+        db.drop_table :created_table if db.table_exists?(:created_table)
+        db.create_table :created_table do |t|
+          t.column :column, :string, :validates => {:presense => true} 
+          t.string :string_column, :validates => {:presense => true} 
+          t.text :text_column, :validates => {:presense => true} 
+          t.integer :integer_column, :validates => {:presense => true} 
+          t.float :float_column, :validates => {:presense => true} 
+          t.decimal :decimal_column, :validates => {:presense => true} 
+          t.datetime :datetime_column, :validates => {:presense => true} 
+          t.time :time_column, :validates => {:presense => true} 
+          t.date :date_column, :validates => {:presense => true} 
+          t.binary :binary_column, :validates => {:presense => true} 
+          t.boolean :boolean_column, :validates => {:presense => true} 
+        end
+
+        MigrationValidators::Core::DbValidator.commit
+      end
+
+      it "with generall column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :column).should_not be_blank
+      end
+
+      it "with string column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :string_column).should_not be_blank
+      end
+
+      it "with text column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :text_column).should_not be_blank
+      end
+
+      it "with integer column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :integer_column).should_not be_blank
+      end
+
+      it "with float column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :float_column).should_not be_blank
+      end
+
+      it "with decimal column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :decimal_column).should_not be_blank
+      end
+
+      it "with datetime column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :datetime_column).should_not be_blank
+      end
+
+      it "with time column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :time_column).should_not be_blank
+      end
+
+      it "with date column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :date_column).should_not be_blank
+      end
+
+      it "with binary column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :binary_column).should_not be_blank
+      end
+
+      it "with boolean column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :boolean_column).should_not be_blank
+      end
+    end
+  end
+
+  describe :change_table do
+    describe "create_columns" do
+      before :each do
+        db.drop_table :created_table if db.table_exists?(:created_table)
+        db.create_table(:created_table) {|t| t.string :dummy_column }
+        db.change_table :created_table do |t|
+          t.column :column, :string, :validates => {:presense => true} 
+          t.string :string_column, :validates => {:presense => true} 
+          t.text :text_column, :validates => {:presense => true} 
+          t.integer :integer_column, :validates => {:presense => true} 
+          t.float :float_column, :validates => {:presense => true} 
+          t.decimal :decimal_column, :validates => {:presense => true} 
+          t.datetime :datetime_column, :validates => {:presense => true} 
+          t.time :time_column, :validates => {:presense => true} 
+          t.date :date_column, :validates => {:presense => true} 
+          t.binary :binary_column, :validates => {:presense => true} 
+          t.boolean :boolean_column, :validates => {:presense => true} 
+        end
+
+        MigrationValidators::Core::DbValidator.commit
+      end
+
+      it "with generall column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :column).should_not be_blank
+      end
+
+      it "with string column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :string_column).should_not be_blank
+      end
+
+      it "with text column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :text_column).should_not be_blank
+      end
+
+      it "with integer column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :integer_column).should_not be_blank
+      end
+
+      it "with float column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :float_column).should_not be_blank
+      end
+
+      it "with decimal column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :decimal_column).should_not be_blank
+      end
+
+      it "with datetime column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :datetime_column).should_not be_blank
+      end
+
+      it "with time column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :time_column).should_not be_blank
+      end
+
+      it "with date column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :date_column).should_not be_blank
+      end
+
+      it "with binary column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :binary_column).should_not be_blank
+      end
+
+      it "with boolean column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :boolean_column).should_not be_blank
+      end
+    end
+
+    describe "change_existing_columns" do
+      before :each do
+        db.drop_table :created_table if db.table_exists?(:created_table)
+
+        db.create_table :created_table do |t|
+          t.column :column, :string, :validates => {:presense => true} 
+          t.column :column_1, :string, :validates => {:presense => true} 
+          t.column :column_to_remove, :string, :validates => {:presense => true}
+          t.column :old_column_name, :string, :validates => {:presense => true}
+        end
+
+        MigrationValidators::Core::DbValidator.commit
+
+
+        db.change_table :created_table do |t|
+          t.change :column, :string, :validates => {:presense => false} 
+          t.remove :column_to_remove
+          t.rename :old_column_name, :new_column_name
+          t.change_validates :column_1, :presense => false
+        end
+
+        MigrationValidators::Core::DbValidator.commit
+      end
+
+      it "with generall column should update validators table" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :column).should be_blank
+      end
+
+      it "should track column removing" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :column_to_remove).should be_blank
+      end
+
+      it "should trach column renaming" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :old_column_name).should be_blank
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :new_column_name).should_not be_blank
+      end
+
+      it "supports special change_validates method" do
+        MigrationValidators::Core::DbValidator.column_validators(:created_table, :column_1).should be_blank
+      end
+    end
+  end
+
+
+  describe "operations with validators" do
+    before :each do
+      db.create_table(:table_name) do |t|
+        t.string :column_name 
+      end unless db.table_exists?(:table_name)
+      
+      MigrationValidators::Core::DbValidator.remove_table_validators :table_name
+      MigrationValidators::Core::DbValidator.commit
+    end
+
+    describe :validate_column do
+      it "raises an exception if 0 validators defined" do
+        lambda {
+          db.validate_column :table_name, :column_name, {}
+        }.should raise_error(MigrationValidators::MigrationValidatorsException, /at least one column validator should be defined/)
+      end
+
+      it "adds all specified validators to the validator table" do
+
+        db.validate_column :table_name, 
+                           :column_name, 
+                           :uniqueness => {:message => "unique"}, 
+                           :inclusion => {:message => "inclusion"}
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.column_validators("table_name", "column_name").length.should == 2
+      end
+
+      it "stores validator options if they defined as hash" do
+        db.validate_column :table_name, 
+                           :column_name, 
+                           :uniqueness => {:message => "unique"}
+        MigrationValidators::Core::DbValidator.commit
+
+
+        MigrationValidators::Core::DbValidator.table_validators("table_name").first.options[:message].should == "unique"
+      end
+
+      it "should treat true in validator options as empty options list" do
+        db.validate_column :table_name, 
+                           :column_name, 
+                           :uniqueness => true
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.table_validators("table_name").first.options.should == {}
+      end
+
+      it "should treat false in validator option as validator removing request" do
+        db.validate_column :table_name, 
+                           :column_name, 
+                           :uniqueness => true
+        MigrationValidators::Core::DbValidator.commit
+
+        db.validate_column :table_name, 
+                           :column_name, 
+                           :uniqueness => false
+        MigrationValidators::Core::DbValidator.commit
+
+        MigrationValidators::Core::DbValidator.table_validators(:table_name).should be_blank
+      end
+
+      it "should not allow nil instead of false as validator parameter" do
+        lambda {
+          db.validate_column :table_name, 
+                             :column_name, 
+                             :uniqueness => nil
+          MigrationValidators::Core::DbValidator.commit
+        }.should raise_error(MigrationValidators::MigrationValidatorsException, /use false to remove column validator/)
+      end
+
+      it "takes name of the context table if blank table name specified as parameter" do
+        db.in_context_of_table :table_name do
+          db.validate_column nil, 
+                             :column_name, 
+                             :uniqueness => true 
+          MigrationValidators::Core::DbValidator.commit
+        end
+
+        MigrationValidators::Core::DbValidator.column_validators("table_name", "column_name").length.should == 1
+      end
+    end
+
+    describe :validate_table, "supports" do
+    end
+  end
+end