dm-migrations 0.10.2 → 1.0.0.rc1

data/lib/dm-migrations/auto_migration.rb

@@ -0,0 +1,238 @@
+require 'dm-core'
+
+module DataMapper
+  module Migrations
+    module SingletonMethods
+
+      # destructively migrates the repository upwards to match model definitions
+      #
+      # @param [Symbol] name repository to act on, :default is the default
+      #
+      # @api public
+      def migrate!(repository_name = nil)
+        repository(repository_name).migrate!
+      end
+
+      # drops and recreates the repository upwards to match model definitions
+      #
+      # @param [Symbol] name repository to act on, :default is the default
+      #
+      # @api public
+      def auto_migrate!(repository_name = nil)
+        repository_execute(:auto_migrate!, repository_name)
+      end
+
+      # @api public
+      def auto_upgrade!(repository_name = nil)
+        repository_execute(:auto_upgrade!, repository_name)
+      end
+
+    private
+
+      # @api semipublic
+      def auto_migrate_down!(repository_name)
+        repository_execute(:auto_migrate_down!, repository_name)
+      end
+
+      # @api semipublic
+      def auto_migrate_up!(repository_name)
+        repository_execute(:auto_migrate_up!, repository_name)
+      end
+
+      # @api private
+      def repository_execute(method, repository_name)
+        DataMapper::Model.descendants.each do |model|
+          model.send(method, repository_name || model.default_repository_name)
+        end
+      end
+    end
+
+    module Repository
+      # Determine whether a particular named storage exists in this repository
+      #
+      # @param [String]
+      #   storage_name name of the storage to test for
+      #
+      # @return [Boolean]
+      #   true if the data-store +storage_name+ exists
+      #
+      # @api semipublic
+      def storage_exists?(storage_name)
+        adapter = self.adapter
+        if adapter.respond_to?(:storage_exists?)
+          adapter.storage_exists?(storage_name)
+        end
+      end
+
+      # @api semipublic
+      def upgrade_model_storage(model)
+        adapter = self.adapter
+        if adapter.respond_to?(:upgrade_model_storage)
+          adapter.upgrade_model_storage(model)
+        end
+      end
+
+      # @api semipublic
+      def create_model_storage(model)
+        adapter = self.adapter
+        if adapter.respond_to?(:create_model_storage)
+          adapter.create_model_storage(model)
+        end
+      end
+
+      # @api semipublic
+      def destroy_model_storage(model)
+        adapter = self.adapter
+        if adapter.respond_to?(:destroy_model_storage)
+          adapter.destroy_model_storage(model)
+        end
+      end
+
+      # Destructively automigrates the data-store to match the model.
+      # First migrates all models down and then up.
+      # REPEAT: THIS IS DESTRUCTIVE
+      #
+      # @api public
+      def auto_migrate!
+        DataMapper.auto_migrate!(name)
+      end
+
+      # Safely migrates the data-store to match the model
+      # preserving data already in the data-store
+      #
+      # @api public
+      def auto_upgrade!
+        DataMapper.auto_upgrade!(name)
+      end
+    end # module Repository
+
+    module Model
+
+      # @api private
+      def self.included(mod)
+        mod.descendants.each { |model| model.extend self }
+      end
+
+      # @api semipublic
+      def storage_exists?(repository_name = default_repository_name)
+        repository(repository_name).storage_exists?(storage_name(repository_name))
+      end
+
+      # Destructively automigrates the data-store to match the model
+      # REPEAT: THIS IS DESTRUCTIVE
+      #
+      # @param Symbol repository_name the repository to be migrated
+      #
+      # @api public
+      def auto_migrate!(repository_name = self.repository_name)
+        assert_valid(true)
+        auto_migrate_down!(repository_name)
+        auto_migrate_up!(repository_name)
+      end
+
+      # Safely migrates the data-store to match the model
+      # preserving data already in the data-store
+      #
+      # @param Symbol repository_name the repository to be migrated
+      #
+      # @api public
+      def auto_upgrade!(repository_name = self.repository_name)
+        assert_valid(true)
+        base_model = self.base_model
+        if base_model == self
+          repository(repository_name).upgrade_model_storage(self)
+        else
+          base_model.auto_upgrade!(repository_name)
+        end
+      end
+
+      # Destructively migrates the data-store down, which basically
+      # deletes all the models.
+      # REPEAT: THIS IS DESTRUCTIVE
+      #
+      # @param Symbol repository_name the repository to be migrated
+      #
+      # @api private
+      def auto_migrate_down!(repository_name = self.repository_name)
+        assert_valid(true)
+        base_model = self.base_model
+        if base_model == self
+          repository(repository_name).destroy_model_storage(self)
+        else
+          base_model.auto_migrate_down!(repository_name)
+        end
+      end
+
+      # Auto migrates the data-store to match the model
+      #
+      # @param Symbol repository_name the repository to be migrated
+      #
+      # @api private
+      def auto_migrate_up!(repository_name = self.repository_name)
+        assert_valid(true)
+        base_model = self.base_model
+        if base_model == self
+          repository(repository_name).create_model_storage(self)
+        else
+          base_model.auto_migrate_up!(repository_name)
+        end
+      end
+
+    end # module Model
+
+    def self.include_migration_api
+      DataMapper.extend(Migrations::SingletonMethods)
+      DataMapper::Model.send(:include, Migrations::Model)
+      DataMapper::Repository.send(:include, Migrations::Repository)
+      DataMapper::Model.append_extensions(Migrations::Model)
+      DataMapper::Repository.adapters.values.each do |adapter|
+        Adapters.include_migration_api(ActiveSupport::Inflector.demodulize(adapter.class.name))
+      end
+    end
+
+  end
+
+  module Adapters
+
+    extend Chainable
+
+    class << self
+
+      def include_migration_api(const_name)
+        require auto_migration_extensions(const_name)
+        adapter = const_get(const_name)
+        if DataMapper::Migrations.const_defined?(const_name)
+          adapter.send(:include, migration_module(const_name))
+        end
+      rescue LoadError
+        # do nothing
+      end
+
+      def migration_module(const_name)
+        DataMapper::Migrations.const_get(const_name)
+      end
+
+    private
+
+      # @api private
+      def auto_migration_extensions(const_name)
+        name = adapter_name(const_name)
+        name = 'do' if name == 'dataobjects'
+        "dm-migrations/adapters/dm-#{name}-adapter"
+      end
+
+    end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+        include_migration_api(const_name)
+        super
+      end
+    end
+
+  end # module Adapters
+
+  Migrations.include_migration_api
+
+end # module DataMapper

data/lib/dm-migrations/migration.rb

@@ -22,9 +22,9 @@ module DataMapper
       @adapter = @database.adapter
 
       case @adapter.class.to_s
-      when /Sqlite3/  then @adapter.extend(SQL::Sqlite3)
+      when /Sqlite/   then @adapter.extend(SQL::Sqlite)
       when /Mysql/    then @adapter.extend(SQL::Mysql)
-      when /Postgres/ then @adapter.extend(SQL::Postgresql)
+      when /Postgres/ then @adapter.extend(SQL::Postgres)
       else
         raise "Unsupported Migration Adapter #{@adapter.class}"
       end
@@ -115,7 +115,7 @@ module DataMapper
     end
 
     # Orders migrations by position, so we know what order to run them in.
-    # First order by postition, then by name, so at least the order is predictable.
+    # First order by position, then by name, so at least the order is predictable.
     def <=> other
       if self.position == other.position
         self.name.to_s <=> other.name.to_s

data/lib/dm-migrations/sql.rb

@@ -1,5 +1,5 @@
 require 'dm-migrations/sql/table_creator'
 require 'dm-migrations/sql/table_modifier'
-require 'dm-migrations/sql/sqlite3'
+require 'dm-migrations/sql/sqlite'
 require 'dm-migrations/sql/mysql'
-require 'dm-migrations/sql/postgresql'
+require 'dm-migrations/sql/postgres'

data/lib/dm-migrations/sql/mysql.rb

@@ -12,9 +12,9 @@ module SQL
     end
 
     def recreate_database
-      execute "DROP DATABASE #{db_name}"
-      execute "CREATE DATABASE #{db_name}"
-      execute "USE #{db_name}"
+      execute "DROP DATABASE #{schema_name}"
+      execute "CREATE DATABASE #{schema_name}"
+      execute "USE #{schema_name}"
     end
 
     def supports_serial?

data/lib/dm-migrations/sql/{postgresql.rb → postgres.rb}

@@ -1,12 +1,12 @@
 module SQL
-  module Postgresql
+  module Postgres
 
     def supports_schema_transactions?
       true
     end
 
     def table(table_name)
-      SQL::Postgresql::Table.new(self, table_name)
+      SQL::Postgres::Table.new(self, table_name)
     end
 
     def recreate_database
@@ -41,7 +41,7 @@ module SQL
         @adapter, @name = adapter, table_name
         @columns = []
         adapter.query_table(table_name).each do |col_struct|
-          @columns << SQL::Postgresql::Column.new(col_struct)
+          @columns << SQL::Postgres::Column.new(col_struct)
         end
 
         query_column_constraints

data/lib/dm-migrations/sql/{sqlite3.rb → sqlite.rb}

@@ -1,14 +1,14 @@
 require 'dm-migrations/sql/table'
 
 module SQL
-  module Sqlite3
+  module Sqlite
 
     def supports_schema_transactions?
       true
     end
 
     def table(table_name)
-      SQL::Sqlite3::Table.new(self, table_name)
+      SQL::Sqlite::Table.new(self, table_name)
     end
 
     def recreate_database
@@ -29,7 +29,7 @@ module SQL
       def initialize(adapter, table_name)
         @columns = []
         adapter.table_info(table_name).each do |col_struct|
-          @columns << SQL::Sqlite3::Column.new(col_struct)
+          @columns << SQL::Sqlite::Column.new(col_struct)
         end
       end
     end

data/spec/integration/auto_migration_spec.rb

@@ -0,0 +1,506 @@
+require 'spec_helper'
+
+require 'dm-migrations/auto_migration'
+
+describe DataMapper::Migrations do
+  def capture_log(mod)
+    original, mod.logger = mod.logger, DataObjects::Logger.new(@log = StringIO.new, :debug)
+    yield
+  ensure
+    @log.rewind
+    @output = @log.readlines.map do |line|
+      line.chomp.gsub(/\A.+?~ \(\d+\.?\d*\)\s+/, '')
+    end
+
+    mod.logger = original
+  end
+
+  supported_by :mysql do
+    before :all do
+      module ::Blog
+        class Article
+          include DataMapper::Resource
+        end
+      end
+
+      @model = ::Blog::Article
+    end
+
+    describe '#auto_migrate' do
+      describe 'Integer property' do
+        [
+          [                    0,                    1, 'TINYINT(1) UNSIGNED'   ],
+          [                    0,                    9, 'TINYINT(1) UNSIGNED'   ],
+          [                    0,                   10, 'TINYINT(2) UNSIGNED'   ],
+          [                    0,                   99, 'TINYINT(2) UNSIGNED'   ],
+          [                    0,                  100, 'TINYINT(3) UNSIGNED'   ],
+          [                    0,                  255, 'TINYINT(3) UNSIGNED'   ],
+          [                    0,                  256, 'SMALLINT(3) UNSIGNED'  ],
+          [                    0,                  999, 'SMALLINT(3) UNSIGNED'  ],
+          [                    0,                 1000, 'SMALLINT(4) UNSIGNED'  ],
+          [                    0,                 9999, 'SMALLINT(4) UNSIGNED'  ],
+          [                    0,                10000, 'SMALLINT(5) UNSIGNED'  ],
+          [                    0,                65535, 'SMALLINT(5) UNSIGNED'  ],
+          [                    0,                65536, 'MEDIUMINT(5) UNSIGNED' ],
+          [                    0,                99999, 'MEDIUMINT(5) UNSIGNED' ],
+          [                    0,               100000, 'MEDIUMINT(6) UNSIGNED' ],
+          [                    0,               999999, 'MEDIUMINT(6) UNSIGNED' ],
+          [                    0,              1000000, 'MEDIUMINT(7) UNSIGNED' ],
+          [                    0,              9999999, 'MEDIUMINT(7) UNSIGNED' ],
+          [                    0,             10000000, 'MEDIUMINT(8) UNSIGNED' ],
+          [                    0,             16777215, 'MEDIUMINT(8) UNSIGNED' ],
+          [                    0,             16777216, 'INT(8) UNSIGNED'       ],
+          [                    0,             99999999, 'INT(8) UNSIGNED'       ],
+          [                    0,            100000000, 'INT(9) UNSIGNED'       ],
+          [                    0,            999999999, 'INT(9) UNSIGNED'       ],
+          [                    0,           1000000000, 'INT(10) UNSIGNED'      ],
+          [                    0,           4294967295, 'INT(10) UNSIGNED'      ],
+          [                    0,           4294967296, 'BIGINT(10) UNSIGNED'   ],
+          [                    0,           9999999999, 'BIGINT(10) UNSIGNED'   ],
+          [                    0,          10000000000, 'BIGINT(11) UNSIGNED'   ],
+          [                    0,          99999999999, 'BIGINT(11) UNSIGNED'   ],
+          [                    0,         100000000000, 'BIGINT(12) UNSIGNED'   ],
+          [                    0,         999999999999, 'BIGINT(12) UNSIGNED'   ],
+          [                    0,        1000000000000, 'BIGINT(13) UNSIGNED'   ],
+          [                    0,        9999999999999, 'BIGINT(13) UNSIGNED'   ],
+          [                    0,       10000000000000, 'BIGINT(14) UNSIGNED'   ],
+          [                    0,       99999999999999, 'BIGINT(14) UNSIGNED'   ],
+          [                    0,      100000000000000, 'BIGINT(15) UNSIGNED'   ],
+          [                    0,      999999999999999, 'BIGINT(15) UNSIGNED'   ],
+          [                    0,     1000000000000000, 'BIGINT(16) UNSIGNED'   ],
+          [                    0,     9999999999999999, 'BIGINT(16) UNSIGNED'   ],
+          [                    0,    10000000000000000, 'BIGINT(17) UNSIGNED'   ],
+          [                    0,    99999999999999999, 'BIGINT(17) UNSIGNED'   ],
+          [                    0,   100000000000000000, 'BIGINT(18) UNSIGNED'   ],
+          [                    0,   999999999999999999, 'BIGINT(18) UNSIGNED'   ],
+          [                    0,  1000000000000000000, 'BIGINT(19) UNSIGNED'   ],
+          [                    0,  9999999999999999999, 'BIGINT(19) UNSIGNED'   ],
+          [                    0, 10000000000000000000, 'BIGINT(20) UNSIGNED'   ],
+          [                    0, 18446744073709551615, 'BIGINT(20) UNSIGNED'   ],
+
+          [                   -1,                    0, 'TINYINT(2)'            ],
+          [                   -1,                    9, 'TINYINT(2)'            ],
+          [                   -1,                   10, 'TINYINT(2)'            ],
+          [                   -1,                   99, 'TINYINT(2)'            ],
+          [                   -1,                  100, 'TINYINT(3)'            ],
+          [                   -1,                  127, 'TINYINT(3)'            ],
+          [                   -1,                  128, 'SMALLINT(3)'           ],
+          [                   -1,                  999, 'SMALLINT(3)'           ],
+          [                   -1,                 1000, 'SMALLINT(4)'           ],
+          [                   -1,                 9999, 'SMALLINT(4)'           ],
+          [                   -1,                10000, 'SMALLINT(5)'           ],
+          [                   -1,                32767, 'SMALLINT(5)'           ],
+          [                   -1,                32768, 'MEDIUMINT(5)'          ],
+          [                   -1,                99999, 'MEDIUMINT(5)'          ],
+          [                   -1,               100000, 'MEDIUMINT(6)'          ],
+          [                   -1,               999999, 'MEDIUMINT(6)'          ],
+          [                   -1,              1000000, 'MEDIUMINT(7)'          ],
+          [                   -1,              8388607, 'MEDIUMINT(7)'          ],
+          [                   -1,              8388608, 'INT(7)'                ],
+          [                   -1,              9999999, 'INT(7)'                ],
+          [                   -1,             10000000, 'INT(8)'                ],
+          [                   -1,             99999999, 'INT(8)'                ],
+          [                   -1,            100000000, 'INT(9)'                ],
+          [                   -1,            999999999, 'INT(9)'                ],
+          [                   -1,           1000000000, 'INT(10)'               ],
+          [                   -1,           2147483647, 'INT(10)'               ],
+          [                   -1,           2147483648, 'BIGINT(10)'            ],
+          [                   -1,           9999999999, 'BIGINT(10)'            ],
+          [                   -1,          10000000000, 'BIGINT(11)'            ],
+          [                   -1,          99999999999, 'BIGINT(11)'            ],
+          [                   -1,         100000000000, 'BIGINT(12)'            ],
+          [                   -1,         999999999999, 'BIGINT(12)'            ],
+          [                   -1,        1000000000000, 'BIGINT(13)'            ],
+          [                   -1,        9999999999999, 'BIGINT(13)'            ],
+          [                   -1,       10000000000000, 'BIGINT(14)'            ],
+          [                   -1,       99999999999999, 'BIGINT(14)'            ],
+          [                   -1,      100000000000000, 'BIGINT(15)'            ],
+          [                   -1,      999999999999999, 'BIGINT(15)'            ],
+          [                   -1,     1000000000000000, 'BIGINT(16)'            ],
+          [                   -1,     9999999999999999, 'BIGINT(16)'            ],
+          [                   -1,    10000000000000000, 'BIGINT(17)'            ],
+          [                   -1,    99999999999999999, 'BIGINT(17)'            ],
+          [                   -1,   100000000000000000, 'BIGINT(18)'            ],
+          [                   -1,   999999999999999999, 'BIGINT(18)'            ],
+          [                   -1,  1000000000000000000, 'BIGINT(19)'            ],
+          [                   -1,  9223372036854775807, 'BIGINT(19)'            ],
+
+          [                   -1,                    0, 'TINYINT(2)'            ],
+          [                   -9,                    0, 'TINYINT(2)'            ],
+          [                  -10,                    0, 'TINYINT(3)'            ],
+          [                  -99,                    0, 'TINYINT(3)'            ],
+          [                 -100,                    0, 'TINYINT(4)'            ],
+          [                 -128,                    0, 'TINYINT(4)'            ],
+          [                 -129,                    0, 'SMALLINT(4)'           ],
+          [                 -999,                    0, 'SMALLINT(4)'           ],
+          [                -1000,                    0, 'SMALLINT(5)'           ],
+          [                -9999,                    0, 'SMALLINT(5)'           ],
+          [               -10000,                    0, 'SMALLINT(6)'           ],
+          [               -32768,                    0, 'SMALLINT(6)'           ],
+          [               -32769,                    0, 'MEDIUMINT(6)'          ],
+          [               -99999,                    0, 'MEDIUMINT(6)'          ],
+          [              -100000,                    0, 'MEDIUMINT(7)'          ],
+          [              -999999,                    0, 'MEDIUMINT(7)'          ],
+          [             -1000000,                    0, 'MEDIUMINT(8)'          ],
+          [             -8388608,                    0, 'MEDIUMINT(8)'          ],
+          [             -8388609,                    0, 'INT(8)'                ],
+          [             -9999999,                    0, 'INT(8)'                ],
+          [            -10000000,                    0, 'INT(9)'                ],
+          [            -99999999,                    0, 'INT(9)'                ],
+          [           -100000000,                    0, 'INT(10)'               ],
+          [           -999999999,                    0, 'INT(10)'               ],
+          [          -1000000000,                    0, 'INT(11)'               ],
+          [          -2147483648,                    0, 'INT(11)'               ],
+          [          -2147483649,                    0, 'BIGINT(11)'            ],
+          [          -9999999999,                    0, 'BIGINT(11)'            ],
+          [         -10000000000,                    0, 'BIGINT(12)'            ],
+          [         -99999999999,                    0, 'BIGINT(12)'            ],
+          [        -100000000000,                    0, 'BIGINT(13)'            ],
+          [        -999999999999,                    0, 'BIGINT(13)'            ],
+          [       -1000000000000,                    0, 'BIGINT(14)'            ],
+          [       -9999999999999,                    0, 'BIGINT(14)'            ],
+          [      -10000000000000,                    0, 'BIGINT(15)'            ],
+          [      -99999999999999,                    0, 'BIGINT(15)'            ],
+          [     -100000000000000,                    0, 'BIGINT(16)'            ],
+          [     -999999999999999,                    0, 'BIGINT(16)'            ],
+          [    -1000000000000000,                    0, 'BIGINT(17)'            ],
+          [    -9999999999999999,                    0, 'BIGINT(17)'            ],
+          [   -10000000000000000,                    0, 'BIGINT(18)'            ],
+          [   -99999999999999999,                    0, 'BIGINT(18)'            ],
+          [  -100000000000000000,                    0, 'BIGINT(19)'            ],
+          [  -999999999999999999,                    0, 'BIGINT(19)'            ],
+          [ -1000000000000000000,                    0, 'BIGINT(20)'            ],
+          [ -9223372036854775808,                    0, 'BIGINT(20)'            ],
+
+          [                  nil,           2147483647, 'INT(10) UNSIGNED'      ],
+          [                    0,                  nil, 'INT(10) UNSIGNED'      ],
+          [                  nil,                  nil, 'INTEGER'               ],
+        ].each do |min, max, statement|
+          options = { :key => true }
+          options[:min] = min if min
+          options[:max] = max if max
+
+          describe "with a min of #{min} and a max of #{max}" do
+            before :all do
+              @property = @model.property(:id, Integer, options)
+
+              @response = capture_log(DataObjects::Mysql) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output.last.should =~ %r{\ACREATE TABLE `blog_articles` \(`id` #{Regexp.escape(statement)} NOT NULL, PRIMARY KEY\(`id`\)\) ENGINE = InnoDB CHARACTER SET [a-z\d]+ COLLATE (?:[a-z\d](?:_?[a-z\d]+)*)\z}
+            end
+
+            options.only(:min, :max).each do |key, value|
+              it "should allow the #{key} value #{value} to be stored" do
+                lambda {
+                  resource = @model.create(@property => value)
+                  @model.first(@property => value).should eql(resource)
+                }.should_not raise_error
+              end
+            end
+          end
+        end
+      end
+
+      describe 'Text property' do
+        before :all do
+          @model.property(:id, DataMapper::Property::Serial)
+        end
+
+        [
+          [ 0,          'TINYTEXT'   ],
+          [ 1,          'TINYTEXT'   ],
+          [ 255,        'TINYTEXT'   ],
+          [ 256,        'TEXT'       ],
+          [ 65535,      'TEXT'       ],
+          [ 65536,      'MEDIUMTEXT' ],
+          [ 16777215,   'MEDIUMTEXT' ],
+          [ 16777216,   'LONGTEXT'   ],
+          [ 4294967295, 'LONGTEXT'   ],
+
+          [ nil,        'TEXT'       ],
+        ].each do |length, statement|
+          options = {}
+          options[:length] = length if length
+
+          describe "with a length of #{length}" do
+            before :all do
+              @property = @model.property(:body, DataMapper::Types::Text, options)
+
+              @response = capture_log(DataObjects::Mysql) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output.last.should =~ %r{\ACREATE TABLE `blog_articles` \(`id` INT\(10\) UNSIGNED NOT NULL AUTO_INCREMENT, `body` #{Regexp.escape(statement)}, PRIMARY KEY\(`id`\)\) ENGINE = InnoDB CHARACTER SET [a-z\d]+ COLLATE (?:[a-z\d](?:_?[a-z\d]+)*)\z}
+            end
+          end
+        end
+      end
+
+      describe 'String property' do
+        before :all do
+          @model.property(:id, DataMapper::Property::Serial)
+        end
+
+        [
+          [ 1,          'VARCHAR(1)'   ],
+          [ 50,         'VARCHAR(50)'  ],
+          [ 255,        'VARCHAR(255)' ],
+          [ nil,        'VARCHAR(50)'  ],
+        ].each do |length, statement|
+          options = {}
+          options[:length] = length if length
+
+          describe "with a length of #{length}" do
+            before :all do
+              @property = @model.property(:title, String, options)
+
+              @response = capture_log(DataObjects::Mysql) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output.last.should =~ %r{\ACREATE TABLE `blog_articles` \(`id` INT\(10\) UNSIGNED NOT NULL AUTO_INCREMENT, `title` #{Regexp.escape(statement)}, PRIMARY KEY\(`id`\)\) ENGINE = InnoDB CHARACTER SET [a-z\d]+ COLLATE (?:[a-z\d](?:_?[a-z\d]+)*)\z}
+            end
+          end
+        end
+      end
+    end
+  end
+
+  supported_by :postgres do
+    before :all do
+      module ::Blog
+        class Article
+          include DataMapper::Resource
+        end
+      end
+
+      @model = ::Blog::Article
+    end
+
+    describe '#auto_migrate' do
+      describe 'Integer property' do
+        [
+          [                    0,                   1, 'SMALLINT' ],
+          [                    0,               32767, 'SMALLINT' ],
+          [                    0,               32768, 'INTEGER'  ],
+          [                    0,          2147483647, 'INTEGER'  ],
+          [                    0,          2147483648, 'BIGINT'   ],
+          [                    0, 9223372036854775807, 'BIGINT'   ],
+
+          [                   -1,                   1, 'SMALLINT' ],
+          [                   -1,               32767, 'SMALLINT' ],
+          [                   -1,               32768, 'INTEGER'  ],
+          [                   -1,          2147483647, 'INTEGER'  ],
+          [                   -1,          2147483648, 'BIGINT'   ],
+          [                   -1, 9223372036854775807, 'BIGINT'   ],
+
+          [                   -1,                   0, 'SMALLINT' ],
+          [               -32768,                   0, 'SMALLINT' ],
+          [               -32769,                   0, 'INTEGER'  ],
+          [          -2147483648,                   0, 'INTEGER'  ],
+          [          -2147483649,                   0, 'BIGINT'   ],
+          [ -9223372036854775808,                   0, 'BIGINT'   ],
+
+          [                  nil,          2147483647, 'INTEGER'  ],
+          [                    0,                 nil, 'INTEGER'  ],
+          [                  nil,                 nil, 'INTEGER'  ],
+        ].each do |min, max, statement|
+          options = { :key => true }
+          options[:min] = min if min
+          options[:max] = max if max
+
+          describe "with a min of #{min} and a max of #{max}" do
+            before :all do
+              @property = @model.property(:id, Integer, options)
+
+              @response = capture_log(DataObjects::Postgres) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output[-2].should == "CREATE TABLE \"blog_articles\" (\"id\" #{statement} NOT NULL, PRIMARY KEY(\"id\"))"
+            end
+
+            options.only(:min, :max).each do |key, value|
+              it "should allow the #{key} value #{value} to be stored" do
+                lambda {
+                  resource = @model.create(@property => value)
+                  @model.first(@property => value).should eql(resource)
+                }.should_not raise_error
+              end
+            end
+          end
+        end
+      end
+
+      describe 'Serial property' do
+        [
+          [                   1, 'SERIAL'    ],
+          [          2147483647, 'SERIAL'    ],
+          [          2147483648, 'BIGSERIAL' ],
+          [ 9223372036854775807, 'BIGSERIAL' ],
+
+          [                 nil, 'SERIAL'    ],
+        ].each do |max, statement|
+          options = {}
+          options[:max] = max if max
+
+          describe "with a max of #{max}" do
+            before :all do
+              @property = @model.property(:id, DataMapper::Property::Serial, options)
+
+              @response = capture_log(DataObjects::Postgres) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output[-2].should == "CREATE TABLE \"blog_articles\" (\"id\" #{statement} NOT NULL, PRIMARY KEY(\"id\"))"
+            end
+
+            options.only(:min, :max).each do |key, value|
+              it "should allow the #{key} value #{value} to be stored" do
+                lambda {
+                  resource = @model.create(@property => value)
+                  @model.first(@property => value).should eql(resource)
+                }.should_not raise_error
+              end
+            end
+          end
+        end
+      end
+
+      describe 'String property' do
+        before :all do
+          @model.property(:id, DataMapper::Property::Serial)
+        end
+
+        [
+          [ 1,          'VARCHAR(1)'   ],
+          [ 50,         'VARCHAR(50)'  ],
+          [ 255,        'VARCHAR(255)' ],
+          [ nil,        'VARCHAR(50)'  ],
+        ].each do |length, statement|
+          options = {}
+          options[:length] = length if length
+
+          describe "with a length of #{length}" do
+            before :all do
+              @property = @model.property(:title, String, options)
+
+              @response = capture_log(DataObjects::Postgres) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output[-2].should == "CREATE TABLE \"blog_articles\" (\"id\" SERIAL NOT NULL, \"title\" #{statement}, PRIMARY KEY(\"id\"))"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  supported_by :sqlserver do
+    before :all do
+      module ::Blog
+        class Article
+          include DataMapper::Resource
+        end
+      end
+
+      @model = ::Blog::Article
+    end
+
+    describe '#auto_migrate' do
+      describe 'Integer property' do
+        [
+          [                    0,                   1, 'TINYINT'  ],
+          [                    0,                 255, 'TINYINT'  ],
+          [                    0,                 256, 'SMALLINT' ],
+          [                    0,               32767, 'SMALLINT' ],
+          [                    0,               32768, 'INT'      ],
+          [                    0,          2147483647, 'INT'      ],
+          [                    0,          2147483648, 'BIGINT'   ],
+          [                    0, 9223372036854775807, 'BIGINT'   ],
+
+          [                   -1,                   1, 'SMALLINT' ],
+          [                   -1,                 255, 'SMALLINT' ],
+          [                   -1,                 256, 'SMALLINT' ],
+          [                   -1,               32767, 'SMALLINT' ],
+          [                   -1,               32768, 'INT'      ],
+          [                   -1,          2147483647, 'INT'      ],
+          [                   -1,          2147483648, 'BIGINT'   ],
+          [                   -1, 9223372036854775807, 'BIGINT'   ],
+
+          [                   -1,                   0, 'SMALLINT' ],
+          [               -32768,                   0, 'SMALLINT' ],
+          [               -32769,                   0, 'INT'      ],
+          [          -2147483648,                   0, 'INT'      ],
+          [          -2147483649,                   0, 'BIGINT'   ],
+          [ -9223372036854775808,                   0, 'BIGINT'   ],
+
+          [                  nil,          2147483647, 'INT'      ],
+          [                    0,                 nil, 'INT'      ],
+          [                  nil,                 nil, 'INTEGER'  ],
+        ].each do |min, max, statement|
+          options = { :key => true }
+          options[:min] = min if min
+          options[:max] = max if max
+
+          describe "with a min of #{min} and a max of #{max}" do
+            before :all do
+              @property = @model.property(:id, Integer, options)
+
+              @response = capture_log(DataObjects::Sqlserver) { @model.auto_migrate! }
+            end
+
+            it 'should return true' do
+              @response.should be_true
+            end
+
+            it "should create a #{statement} column" do
+              @output.last.should == "CREATE TABLE \"blog_articles\" (\"id\" #{statement} NOT NULL, PRIMARY KEY(\"id\"))"
+            end
+
+            options.only(:min, :max).each do |key, value|
+              it "should allow the #{key} value #{value} to be stored" do
+                lambda {
+                  resource = @model.create(@property => value)
+                  @model.first(@property => value).should eql(resource)
+                }.should_not raise_error
+              end
+            end
+          end
+        end
+      end
+
+      describe 'String property' do
+        it 'needs specs'
+      end
+    end
+  end
+
+end