dm-hibernate-migrations 1.0.0

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

@@ -0,0 +1,45 @@
+require 'dm-migrations/sql/table'
+
+module SQL
+  module Sqlite
+
+    def supports_schema_transactions?
+      true
+    end
+
+    def table(table_name)
+      SQL::Sqlite::Table.new(self, table_name)
+    end
+
+    def recreate_database
+      DataMapper.logger.info "Dropping #{@uri.path}"
+      system "rm #{@uri.path}"
+      # do nothing, sqlite will automatically create the database file
+    end
+
+    def table_options
+      ''
+    end
+
+    def supports_serial?
+      true
+    end
+
+    class Table < SQL::Table
+      def initialize(adapter, table_name)
+        @columns = []
+        adapter.table_info(table_name).each do |col_struct|
+          @columns << SQL::Sqlite::Column.new(col_struct)
+        end
+      end
+    end
+
+    class Column < SQL::Column
+      def initialize(col_struct)
+        @name, @type, @default_value, @primary_key = col_struct.name, col_struct.type, col_struct.dflt_value, col_struct.pk
+
+        @not_null = col_struct.notnull == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'dm-migrations/sql/column'
+
+module SQL
+  class Table
+    attr_accessor :name, :columns
+
+    def to_s
+      name
+    end
+
+    def column(column_name)
+      @columns.select { |c| c.name == column_name.to_s }.first
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module SQL
+  class TableCreator
+    attr_accessor :table_name, :opts
+
+    def initialize(adapter, table_name, opts = {}, &block)
+      @adapter = adapter
+      @table_name = table_name.to_s
+      @opts = opts
+
+      @columns = []
+
+      self.instance_eval &block
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_name, table_name)
+    end
+
+    def column(name, type, opts = {})
+      @columns << Column.new(@adapter, name, type, opts)
+    end
+
+    def to_sql
+      "CREATE TABLE #{quoted_table_name} (#{@columns.map{ |c| c.to_sql }.join(', ')})#{@adapter.table_options}"
+    end
+
+    # A helper for using the native NOW() SQL function in a default
+    def now
+      SqlExpr.new('NOW()')
+    end
+
+    # A helper for using the native UUID() SQL function in a default
+    def uuid
+      SqlExpr.new('UUID()')
+    end
+
+    class SqlExpr
+      attr_accessor :sql
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def to_s
+        @sql.to_s
+      end
+    end
+
+    class Column
+      attr_accessor :name, :type
+
+      def initialize(adapter, name, type, opts = {})
+        @adapter = adapter
+        @name = name.to_s
+        @opts = opts
+        @type = build_type(type)
+      end
+
+      def to_sql
+        type
+      end
+
+      private
+
+      def build_type(type_class)
+        schema = { :name => @name, :quote_column_name => quoted_name }.merge(@opts)
+
+        [ :nullable, :nullable? ].each do |option|
+          next if (value = schema.delete(option)).nil?
+          warn "#{option.inspect} is deprecated, use :allow_nil instead"
+          schema[:allow_nil] = value unless schema.key?(:allow_nil)
+        end
+
+        unless schema.key?(:allow_nil)
+          schema[:allow_nil] = !schema[:not_null]
+        end
+
+        schema[:length] ||= schema.delete(:size) if schema.key?(:size)
+
+        if type_class.kind_of?(String)
+          schema[:primitive] = type_class
+        else
+          primitive = type_class.respond_to?(:primitive) ? type_class.primitive : type_class
+          options   = @adapter.class.type_map[primitive].dup
+
+          if type_class.respond_to?(:options) && type_class.options.kind_of?(options.class)
+            options.update(type_class.options)
+          end
+
+          schema = options.update(schema)
+        end
+
+        @adapter.send(:with_connection) do |connection|
+          @adapter.property_schema_statement(connection, schema)
+        end
+      end
+
+      def quoted_name
+        @adapter.send(:quote_name, name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module SQL
+  class TableModifier
+    attr_accessor :table_name, :opts, :statements, :adapter
+
+    def initialize(adapter, table_name, opts = {}, &block)
+      @adapter = adapter
+      @table_name = table_name.to_s
+      @opts = (opts)
+
+      @statements = []
+
+      self.instance_eval &block
+    end
+
+    def add_column(name, type, opts = {})
+      column = SQL::TableCreator::Column.new(@adapter, name, type, opts)
+      @statements << "ALTER TABLE #{quoted_table_name} ADD COLUMN #{column.to_sql}"
+    end
+
+    def drop_column(name)
+      # raise NotImplemented for SQLite3. Can't ALTER TABLE, need to copy table.
+      # We'd have to inspect it, and we can't, since we aren't executing any queries yet.
+      # TODO instead of building the SQL queries when executing the block, create AddColumn,
+      # AlterColumn and DropColumn objects that get #to_sql'd
+      if name.is_a?(Array)
+        name.each{ |n| drop_column(n) }
+      else
+        @statements << "ALTER TABLE #{quoted_table_name} DROP COLUMN #{quote_column_name(name)}"
+      end
+    end
+    alias drop_columns drop_column
+
+    def rename_column(name, new_name, opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << "ALTER TABLE #{quoted_table_name} RENAME COLUMN #{quote_column_name(name)} TO #{quote_column_name(new_name)}"
+    end
+
+    def change_column(name, type, opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quote_column_name(name)} TYPE #{type}"
+    end
+
+    def quote_column_name(name)
+      @adapter.send(:quote_name, name.to_s)
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_name, table_name)
+    end
+  end
+end

data/lib/spec/example/migration_example_group.rb

@@ -0,0 +1,73 @@
+require 'spec/matchers/migration_matchers'
+
+require 'spec'
+
+module Spec
+  module Example
+    class MigrationExampleGroup < Spec::Example::ExampleGroup
+      include Spec::Matchers::Migration
+
+      before(:all) do
+        if this_migration.adapter.supports_schema_transactions?
+          run_prereq_migrations
+        end
+      end
+
+      before(:each) do
+        if ! this_migration.adapter.supports_schema_transactions?
+          run_prereq_migrations
+        else
+          this_migration.adapter.begin_transaction
+        end
+      end
+
+      after(:each) do
+        if this_migration.adapter.supports_schema_transactions?
+          this_migration.adapter.rollback_transaction
+        end
+      end
+
+      after(:all) do
+        this_migration.adapter.recreate_database
+      end
+
+      def run_prereq_migrations
+        "running n-1 migrations"
+        all_databases.each do |db|
+          db.adapter.recreate_database
+        end
+        @@migrations.sort.each do |migration|
+          break if migration.name.to_s == migration_name.to_s
+          migration.perform_up
+        end
+      end
+
+      def run_migration
+        this_migration.perform_up
+      end
+
+      def migration_name
+        @migration_name ||= self.class.instance_variable_get("@description_text").to_s
+      end
+
+      def all_databases
+        @@migrations.map { |m| m.database }.uniq
+      end
+
+      def this_migration
+        @@migrations.select { |m| m.name.to_s == migration_name }.first
+      end
+
+      def select(sql)
+        this_migration.adapter.select(sql)
+      end
+
+      def table(table_name)
+        this_migration.adapter.table(table_name)
+      end
+
+      Spec::Example::ExampleGroupFactory.register(:migration, self)
+
+    end
+  end
+end

data/lib/spec/matchers/migration_matchers.rb

@@ -0,0 +1,106 @@
+module Spec
+  module Matchers
+    module Migration
+
+      def have_table(table_name)
+        HaveTableMatcher.new(table_name)
+      end
+
+      def have_column(column_name)
+        HaveColumnMatcher.new(column_name)
+      end
+
+      def permit_null
+        NullableColumnMatcher.new
+      end
+
+      def be_primary_key
+        PrimaryKeyMatcher.new
+      end
+
+      class HaveTableMatcher
+
+        attr_accessor :table_name, :repository
+
+        def initialize(table_name)
+          @table_name = table_name
+        end
+
+        def matches?(repository)
+          repository.adapter.storage_exists?(table_name)
+        end
+
+        def failure_message
+          %(expected #{repository} to have table '#{table_name}')
+        end
+
+        def negative_failure_message
+          %(expected #{repository} to not have table '#{table_name}')
+        end
+
+      end
+
+      class HaveColumnMatcher
+
+        attr_accessor :table, :column_name
+
+        def initialize(column_name)
+          @column_name = column_name
+        end
+
+        def matches?(table)
+          @table = table
+          table.columns.map { |c| c.name }.include?(column_name.to_s)
+        end
+
+        def failure_message
+          %(expected #{table} to have column '#{column_name}')
+        end
+
+        def negative_failure_message
+          %(expected #{table} to not have column '#{column_name}')
+        end
+
+      end
+
+      class NullableColumnMatcher
+
+        attr_accessor :column
+
+        def matches?(column)
+          @column = column
+          ! column.not_null
+        end
+
+        def failure_message
+          %(expected #{column.name} to permit NULL)
+        end
+
+        def negative_failure_message
+          %(expected #{column.name} to be NOT NULL)
+        end
+
+      end
+
+      class PrimaryKeyMatcher
+
+        attr_accessor :column
+
+        def matches?(column)
+          @column = column
+          column.primary_key
+        end
+
+        def failure_message
+          %(expected #{column.name} to be PRIMARY KEY)
+        end
+
+        def negative_failure_message
+          %(expected #{column.name} to not be PRIMARY KEY)
+        end
+
+      end
+
+    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