sbf-dm-migrations 1.3.0.beta

data/spec/integration/migration_runner_spec.rb

@@ -0,0 +1,84 @@
+require_relative '../spec_helper'
+
+describe 'The migration runner' do
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+    before(:all) do
+      @adapter    = DataMapper::Spec.adapter
+      @repository = DataMapper.repository(@adapter.name)
+    end
+
+    describe 'empty migration runner' do
+      it 'returns an empty array if no migrations have been defined' do
+        expect(migrations).to be_kind_of(Array)
+        expect(migrations.size).to eq 0
+      end
+    end
+
+    describe 'migration runner' do
+      # set up some 'global' setup and teardown tasks
+      before(:each) do
+        # FIXME: workaround because dm-migrations can only handle the :default repo
+        # DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[adapter.to_sym]
+        migration(1, :create_people_table) { nil }
+      end
+
+      after(:each) do
+        migrations.clear
+      end
+
+      describe '#migration' do
+        it 'creates a new migration object, and add it to the list of migrations' do
+          expect(migrations).to be_kind_of(Array)
+          expect(migrations.size).to eq 1
+          expect(migrations.first.name).to eq 'create_people_table'
+        end
+
+        it 'allows multiple migrations to be added' do
+          migration(2, :add_dob_to_people) { nil }
+          migration(2, :add_favorite_pet_to_people) { nil }
+          migration(3, :add_something_else_to_people) { nil }
+          expect(migrations.size).to eq 4
+        end
+
+        it 'raises an error on adding with a duplicated name' do
+          expect { migration(1, :create_people_table) { nil } }.to raise_error(RuntimeError, /Migration name conflict/)
+        end
+      end
+
+      describe '#migrate_up! and #migrate_down!' do
+        before(:each) do
+          migration(2, :add_dob_to_people) { nil }
+          migration(2, :add_favorite_pet_to_people) { nil }
+          migration(3, :add_something_else_to_people) { nil }
+        end
+
+        it 'calling migrate_up! migrates up all the migrations' do
+          # add our expectation that migrate_up should be called
+          migrations.each do |m|
+            expect(m).to receive(:perform_up)
+          end
+          migrate_up!
+        end
+
+        it 'calling migrate_up! with an argument only migrates to that level' do
+          migrations.each do |m|
+            if m.position <= 2
+              expect(m).to receive(:perform_up)
+            else
+              expect(m).not_to receive(:perform_up)
+            end
+          end
+          migrate_up!(2)
+        end
+
+        it 'calling migrate_down! migrates down all the migrations' do
+          # add our expectation that migrate_up should be called
+          migrations.each do |m|
+            expect(m).to receive(:perform_down)
+          end
+          migrate_down!
+        end
+      end
+    end
+  end
+end

data/spec/integration/migration_spec.rb

@@ -0,0 +1,156 @@
+require_relative '../spec_helper'
+
+describe 'A Migration' do
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+    describe DataMapper::Migration, 'interface' do
+      before(:all) do
+        @adapter = DataMapper::Spec.adapter
+      end
+
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, verbose: false) { nil }
+      end
+
+      before do
+        @original = $stderr
+        $stderr = StringIO.new
+      end
+
+      after do
+        $stderr = @original
+      end
+
+      it 'has a position attribute' do
+        expect(@migration).to respond_to(:position)
+
+        expect(@migration.position).to eq 1
+      end
+
+      it 'has a name attribute' do
+        expect(@migration).to respond_to(:name)
+
+        expect(@migration.name).to eq :create_people_table
+      end
+
+      it 'has a :repository option' do
+        m = DataMapper::Migration.new(2, :create_dogs_table, repository: :alternate) { nil }
+
+        expect(m.instance_variable_get(:@repository)).to eq :alternate
+      end
+
+      it 'uses the default repository by default' do
+        expect(@migration.instance_variable_get(:@repository)).to eq :default
+      end
+
+      it 'still supports a :database option' do
+        m = DataMapper::Migration.new(2, :create_legacy_table, database: :legacy) { nil }
+
+        expect(m.instance_variable_get(:@repository)).to eq :legacy
+      end
+
+      it 'warns when :database is used' do
+        DataMapper::Migration.new(2, :create_legacy_table, database: :legacy) { nil }
+        expect($stderr.string.chomp).to eq 'Using the :database option with migrations is deprecated, use :repository instead'
+      end
+
+      it 'has a verbose option' do
+        m = DataMapper::Migration.new(2, :create_dogs_table, verbose: false) { nil }
+        expect(m.instance_variable_get(:@verbose)).to eq false
+      end
+
+      it 'is verbose by default' do
+        m = DataMapper::Migration.new(2, :create_dogs_table) { nil }
+        expect(m.instance_variable_get(:@verbose)).to eq true
+      end
+
+      it 'is sortable, first by position, then name' do
+        m1 = DataMapper::Migration.new(1, :create_people_table) { nil }
+        m2 = DataMapper::Migration.new(2, :create_dogs_table) { nil }
+        m3 = DataMapper::Migration.new(2, :create_cats_table) { nil }
+        m4 = DataMapper::Migration.new(4, :create_birds_table) { nil }
+
+        expect([m1, m2, m3, m4].sort).to eq [m1, m3, m2, m4]
+      end
+
+      adapter = DataMapper::Spec.adapter_name
+
+      expected_module_lambda = {
+        sqlite: -> { SQL::Sqlite },
+        mysql: -> { SQL::Mysql },
+        postgres: -> { SQL::Postgres }
+      }[adapter.to_sym]
+
+      expected_module = expected_module_lambda&.call
+
+      if expected_module
+        it "extends with #{expected_module} when adapter is #{adapter}" do
+          migration = DataMapper::Migration.new(1, :"#{adapter}_adapter_test") { nil }
+          expect((class << migration.adapter; self; end).included_modules).to include(expected_module)
+        end
+      end
+    end
+
+    describe DataMapper::Migration, 'defining actions' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, verbose: false) { nil }
+      end
+
+      it 'has an #up method' do
+        expect(@migration).to respond_to(:up)
+      end
+
+      it 'saves the block passed into the #up method in @up_action' do
+        action = -> {}
+        @migration.up(&action)
+
+        expect(@migration.instance_variable_get(:@up_action)).to eq action
+      end
+
+      it 'has a #down method' do
+        expect(@migration).to respond_to(:down)
+      end
+
+      it 'saves the block passed into the #down method in @down_action' do
+        action = -> {}
+        @migration.down(&action)
+
+        expect(@migration.instance_variable_get(:@down_action)).to eq action
+      end
+
+      it 'makes available an #execute method' do
+        expect(@migration).to respond_to(:execute)
+      end
+
+      it 'makes available an #select method' do
+        expect(@migration).to respond_to(:select)
+      end
+
+      it 'runs the sql passed into the #execute method'
+      # TODO: Find out how to stub the DataMapper::database.execute method
+    end
+
+    describe DataMapper::Migration, 'output' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table) { nil }
+        @migration.stub!(:write) # so that we don't actually write anything to the console!
+      end
+
+      it "#say's a string with an indent" do
+        expect(@migration).to receive(:write).with('   Foobar')
+        @migration.say('Foobar', 2)
+      end
+
+      it "#say's with a default indent of 4" do
+        expect(@migration).to receive(:write).with('     Foobar')
+        @migration.say('Foobar')
+      end
+
+      it '#say_with_time the running time of a block' do
+        expect(@migration).to receive(:write).with(/Block/)
+        expect(@migration).to receive(:write).with(/-> \d+/)
+
+        @migration.say_with_time('Block') { nil }
+      end
+    end
+  end
+end

data/spec/integration/sql_spec.rb

@@ -0,0 +1,290 @@
+require_relative '../spec_helper'
+
+# Column type is expected to be inherited from DataMapper::Property::Text (CLOB, TEXT or whatever)
+class MyCustomProperty < DataMapper::Property::Text; end
+
+describe 'SQL generation' do
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+    describe DataMapper::Migration, '#create_table helper' do
+      before :all do
+        @adapter    = DataMapper::Spec.adapter
+        @repository = DataMapper.repository(@adapter.name)
+
+        case DataMapper::Spec.adapter_name.to_sym
+        when :sqlite
+          @adapter.extend(SQL::Sqlite)
+        when :mysql
+          @adapter.extend(SQL::Mysql)
+        when :postgres
+          @adapter.extend(SQL::Postgres)
+        end
+      end
+
+      before do
+        @creator = DataMapper::Migration::TableCreator.new(@adapter, :people) do
+          column :id,          DataMapper::Property::Serial
+          column :name,        'VARCHAR(50)', allow_nil: false
+          column :long_string, String, size: 200
+          column :very_custom, MyCustomProperty
+        end
+      end
+
+      it 'has a #create_table helper' do
+        @migration = DataMapper::Migration.new(1, :create_people_table, verbose: false) { nil }
+        expect(@migration).to respond_to(:create_table)
+      end
+
+      it 'has a table_name' do
+        expect(@creator.table_name).to eq 'people'
+      end
+
+      it 'has an adapter' do
+        expect(@creator.instance_eval('@adapter', __FILE__, __LINE__)).to eq @adapter
+      end
+
+      it 'has an options hash' do
+        expect(@creator.opts).to be_kind_of(Hash)
+        expect(@creator.opts).to eq({})
+      end
+
+      it 'has an array of columns' do
+        expect(@creator.instance_eval('@columns', __FILE__, __LINE__)).to be_kind_of(Array)
+        expect(@creator.instance_eval('@columns', __FILE__, __LINE__).size).to eq 4
+        expect(@creator.instance_eval('@columns', __FILE__, __LINE__).first).to be_kind_of(DataMapper::Migration::TableCreator::Column)
+      end
+
+      it 'quotes the table name for the adapter' do
+        expect(@creator.quoted_table_name).to eq((DataMapper::Spec.adapter_name.to_sym == :mysql) ? '`people`' : '"people"')
+      end
+
+      it 'allows for custom options' do
+        columns = @creator.instance_eval('@columns', __FILE__, __LINE__)
+        col = columns.detect { |c| c.name == 'long_string' }
+        expect(col.instance_eval('@type', __FILE__, __LINE__)).to include('200')
+      end
+
+      it 'generates a NOT NULL column when :allow_nil is false' do
+        expect(@creator.instance_eval('@columns', __FILE__, __LINE__)[1].type).to match(/NOT NULL/)
+      end
+
+      case DataMapper::Spec.adapter_name.to_sym
+      when :mysql
+        it 'creates an InnoDB database for MySQL' do
+          # can't get an exact == comparison here because character set and collation may differ per connection
+          expect(@creator.to_sql).to match(/^CREATE TABLE `people` \(`id` SERIAL PRIMARY KEY, `name` VARCHAR\(50\) NOT NULL, `long_string` VARCHAR\(200\), `very_custom` TEXT\) ENGINE = InnoDB CHARACTER SET \w+ COLLATE \w+\z/)
+        end
+
+        it 'allows for custom table creation options for MySQL' do
+          opts = {
+            storage_engine: 'MyISAM',
+            character_set: 'big5',
+            collation: 'big5_chinese_ci'
+          }
+
+          creator = DataMapper::Migration::TableCreator.new(@adapter, :people, opts) do
+            column :id, DataMapper::Property::Serial
+          end
+
+          expect(creator.to_sql).to match(/^CREATE TABLE `people` \(`id` SERIAL PRIMARY KEY\) ENGINE = MyISAM CHARACTER SET big5 COLLATE big5_chinese_ci\z/)
+        end
+
+        it 'respects default storage engine types specified by the MySQL adapter' do
+          adapter = DataMapper::Spec.adapter
+          adapter.extend(SQL::Mysql)
+
+          adapter.storage_engine = 'MyISAM'
+
+          creator = DataMapper::Migration::TableCreator.new(adapter, :people) do
+            column :id, DataMapper::Property::Serial
+          end
+
+          expect(creator.to_sql).to match(/^CREATE TABLE `people` \(`id` SERIAL PRIMARY KEY\) ENGINE = MyISAM CHARACTER SET \w+ COLLATE \w+\z/)
+        end
+
+      when :postgres
+        it 'outputs a CREATE TABLE statement when sent #to_sql' do
+          expect(@creator.to_sql).to eq 'CREATE TABLE "people" ("id" SERIAL PRIMARY KEY, "name" VARCHAR(50) NOT NULL, "long_string" VARCHAR(200), ' \
+                                        '"very_custom" TEXT)'
+        end
+      when :sqlite3, :sqlite
+        it 'outputs a CREATE TABLE statement when sent #to_sql' do
+          expect(@creator.to_sql).to eq 'CREATE TABLE "people" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" VARCHAR(50) NOT NULL, "long_string" ' \
+                                        'VARCHAR(200), "very_custom" TEXT)'
+        end
+      end
+
+      context 'when the default string length is modified' do
+        before do
+          @original = DataMapper::Property::String.length
+          DataMapper::Property::String.length(255)
+
+          @creator = DataMapper::Migration::TableCreator.new(@adapter, :people) do
+            column :string, String
+          end
+        end
+
+        after do
+          DataMapper::Property::String.length(@original)
+        end
+
+        it 'uses the new length for the character column' do
+          expect(@creator.to_sql).to match(/CHAR\(255\)/)
+        end
+      end
+    end
+
+    describe DataMapper::Migration, '#modify_table helper' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, verbose: false) { nil }
+      end
+
+      it 'has a #modify_table helper' do
+        expect(@migration).to respond_to(:modify_table)
+      end
+
+      describe '#change_column' do
+        before do
+          @modifier = DataMapper::Migration::TableModifier.new(@adapter, :people) do
+            change_column :name, 'VARCHAR(200)'
+          end
+        end
+
+        case DataMapper::Spec.adapter_name.to_sym
+        when :mysql
+          it 'alters the column' do
+            expect(@modifier.to_sql).to eq 'ALTER TABLE `people` MODIFY COLUMN `name` VARCHAR(200)'
+          end
+        when :postgres
+          it 'alters the column' do
+            expect(@modifier.to_sql).to eq 'ALTER TABLE "people" ALTER COLUMN "name" VARCHAR(200)'
+          end
+        end
+      end
+
+      describe '#rename_column' do
+        case DataMapper::Spec.adapter_name.to_sym
+        when :postgres
+          before do
+            @modifier = DataMapper::Migration::TableModifier.new(@adapter, :people) do
+              rename_column :name, :first_name
+            end
+          end
+
+          it 'renames the column' do
+            expect(@modifier.to_sql).to eq 'ALTER TABLE "people" RENAME COLUMN "name" TO "first_name"'
+          end
+        when :mysql
+          before do
+            # create the table so the existing column schema can be introspected
+            @adapter.execute("CREATE TABLE `people` (name VARCHAR(50) DEFAULT 'John' NOT NULL)")
+
+            @modifier = DataMapper::Migration::TableModifier.new(@adapter, :people) do
+              rename_column :name, :first_name
+            end
+          end
+
+          after do
+            @adapter.execute('DROP TABLE `people`')
+          end
+
+          it 'changes the column' do
+            expect(@modifier.to_sql).to eq "ALTER TABLE `people` CHANGE `name` `first_name` varchar(50) DEFAULT 'John' NOT NULL"
+          end
+        end
+      end
+    end
+
+    describe DataMapper::Migration, 'other helpers' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, verbose: false) { nil }
+      end
+
+      it 'has a #drop_table helper' do
+        expect(@migration).to respond_to(:drop_table)
+      end
+    end
+
+    describe DataMapper::Migration, 'version tracking' do
+      before(:each) do
+        @migration = DataMapper::Migration.new(1, :create_people_table, verbose: false) do
+          up   { :ran_up }
+          down { :ran_down }
+        end
+
+        @migration.send(:create_migration_info_table_if_needed)
+      end
+
+      after(:each) { DataMapper::Spec.adapter.execute('DROP TABLE migration_info') rescue nil }
+
+      def insert_migration_record
+        DataMapper::Spec.adapter.execute("INSERT INTO migration_info (migration_name) VALUES ('create_people_table')")
+      end
+
+      it 'knows if the migration_info table exists' do
+        expect(@migration.send(:migration_info_table_exists?)).to be(true)
+      end
+
+      it 'knows if the migration_info table does not exist' do
+        DataMapper::Spec.adapter.execute('DROP TABLE migration_info') rescue nil
+        expect(@migration.send(:migration_info_table_exists?)).to be(false)
+      end
+
+      it 'is able to find the migration_info record for itself' do
+        insert_migration_record
+        expect(@migration.send(:migration_record)).not_to be_empty
+      end
+
+      it 'knows if a migration needs_up?' do
+        expect(@migration.send(:needs_up?)).to be(true)
+        insert_migration_record
+        expect(@migration.send(:needs_up?)).to be(false)
+      end
+
+      it 'knows if a migration needs_down?' do
+        expect(@migration.send(:needs_down?)).to be(false)
+        insert_migration_record
+        expect(@migration.send(:needs_down?)).to be(true)
+      end
+
+      it 'properly quotes the migration_info table via the adapter for use in queries' do
+        expect(@migration.send(:migration_info_table)).to eq @migration.quote_table_name('migration_info')
+      end
+
+      it 'properly quotes the migration_info.migration_name column via the adapter for use in queries' do
+        expect(@migration.send(:migration_name_column)).to eq @migration.quote_column_name('migration_name')
+      end
+
+      it "properly quotes the migration's name for use in queries"
+      # TODO: how to i call the adapter's #escape_sql method?
+
+      it "creates the migration_info table if it doesn't exist" do
+        DataMapper::Spec.adapter.execute('DROP TABLE migration_info')
+        expect(@migration.send(:migration_info_table_exists?)).to be(false)
+        @migration.send(:create_migration_info_table_if_needed)
+        expect(@migration.send(:migration_info_table_exists?)).to be(true)
+      end
+
+      it 'inserts a record into the migration_info table on up' do
+        expect(@migration.send(:migration_record)).to be_empty
+        expect(@migration.perform_up).to eq :ran_up
+        expect(@migration.send(:migration_record)).not_to be_empty
+      end
+
+      it 'removes a record from the migration_info table on down' do
+        insert_migration_record
+        expect(@migration.send(:migration_record)).not_to be_empty
+        expect(@migration.perform_down).to eq :ran_down
+        expect(@migration.send(:migration_record)).to be_empty
+      end
+
+      it 'does not run the up action if the record exists in the table' do
+        insert_migration_record
+        expect(@migration.perform_up).not_to eq :ran_up
+      end
+
+      it 'does not run the down action if the record does not exist in the table' do
+        expect(@migration.perform_down).not_to eq :ran_down
+      end
+    end
+  end
+end

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,24 @@
+require 'rspec'
+
+require_relative 'require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+class ::Person
+  include DataMapper::Resource
+  property :id, Serial
+end
+
+if %w(postgres mysql sqlite oracle sqlserver).include?(ENV['ADAPTER'])
+  describe "require 'dm-migrations' after calling DataMapper.setup" do
+    before(:all) do
+      @adapter = DataMapper::Spec.adapter
+      require 'dm-migrations'
+
+      @model = Person
+    end
+
+    it_behaves_like "require 'dm-migrations'"
+  end
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,24 @@
+require 'rspec'
+
+require_relative 'require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+class ::Person
+  include DataMapper::Resource
+  property :id, Serial
+end
+
+if %w(postgres mysql sqlite oracle sqlserver).include?(ENV['ADAPTER'])
+  describe "require 'dm-migrations' before calling DataMapper.setup" do
+    before(:all) do
+      require 'dm-migrations'
+      @adapter = DataMapper::Spec.adapter
+
+      @model = Person
+    end
+
+    it_behaves_like "require 'dm-migrations'"
+  end
+end

data/spec/isolated/require_spec.rb

@@ -0,0 +1,23 @@
+shared_examples "require 'dm-migrations'" do
+  it 'includes the migration api in the DataMapper namespace' do
+    expect(DataMapper.respond_to?(:migrate!)).to be(true)
+    expect(DataMapper.respond_to?(:auto_migrate!)).to be(true)
+    expect(DataMapper.respond_to?(:auto_upgrade!)).to be(true)
+    expect(DataMapper.respond_to?(:auto_migrate_up!, true)).to be(true)
+    expect(DataMapper.respond_to?(:auto_migrate_down!, true)).to be(true)
+  end
+
+  %w(Repository Model).each do |name|
+    it "includes the migration api in DataMapper::#{name}" do
+      expect(DataMapper.const_get(name) < DataMapper::Migrations.const_get(name)).to be(true)
+    end
+  end
+
+  it 'includes the migration api into the adapter' do
+    expect(@adapter.respond_to?(:storage_exists?)).to be(true)
+    expect(@adapter.respond_to?(:field_exists?)).to be(true)
+    expect(@adapter.respond_to?(:upgrade_model_storage)).to be(true)
+    expect(@adapter.respond_to?(:create_model_storage)).to be(true)
+    expect(@adapter.respond_to?(:destroy_model_storage)).to be(true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'dm-migrations'
+require 'dm-migrations/migration_runner'
+
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+require 'dm-core/spec/lib/spec_helper'
+require 'dm-core/spec/lib/pending_helpers'
+
+RSpec.configure do |config|
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+
+  config.after :all do
+    DataMapper::Spec.cleanup_models
+  end
+end