ardm-migrations 1.2.0

data/spec/integration/migration_spec.rb

@@ -0,0 +1,157 @@
+require '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) { }
+      end
+
+      before do
+        $stderr, @original = StringIO.new, $stderr
+      end
+
+      after do
+        $stderr = @original
+      end
+
+      it "should have a postition attribute" do
+        @migration.should respond_to(:position)
+
+        @migration.position.should == 1
+      end
+
+      it "should have a name attribute" do
+        @migration.should respond_to(:name)
+
+        @migration.name.should == :create_people_table
+      end
+
+      it "should have a :repository option" do
+        m = DataMapper::Migration.new(2, :create_dogs_table, :repository => :alternate) {}
+
+        m.instance_variable_get(:@repository).should == :alternate
+      end
+
+      it "should use the default repository by default" do
+        @migration.instance_variable_get(:@repository).should == :default
+      end
+
+      it "should still support a :database option" do
+        m = DataMapper::Migration.new(2, :create_legacy_table, :database => :legacy) {}
+
+        m.instance_variable_get(:@repository).should == :legacy
+      end
+
+      it "warns when :database is used" do
+        m = DataMapper::Migration.new(2, :create_legacy_table, :database => :legacy) {}
+        $stderr.string.chomp.should == 'Using the :database option with migrations is deprecated, use :repository instead'
+      end
+
+      it "should have a verbose option" do
+        m = DataMapper::Migration.new(2, :create_dogs_table, :verbose => false) {}
+        m.instance_variable_get(:@verbose).should == false
+      end
+
+      it "should be verbose by default" do
+        m = DataMapper::Migration.new(2, :create_dogs_table) {}
+        m.instance_variable_get(:@verbose).should == true
+      end
+
+      it "should be sortable, first by position, then name" do
+        m1 = DataMapper::Migration.new(1, :create_people_table) {}
+        m2 = DataMapper::Migration.new(2, :create_dogs_table) {}
+        m3 = DataMapper::Migration.new(2, :create_cats_table) {}
+        m4 = DataMapper::Migration.new(4, :create_birds_table) {}
+
+        [m1, m2, m3, m4].sort.should == [m1, m3, m2, m4]
+      end
+
+      adapter = DataMapper::Spec.adapter_name
+
+      expected_module_lambda = {
+        :sqlite   => lambda { SQL::Sqlite   },
+        :mysql    => lambda { SQL::Mysql    },
+        :postgres => lambda { SQL::Postgres }
+      }[adapter.to_sym]
+
+      expected_module = expected_module_lambda ? expected_module_lambda.call : nil
+
+      if expected_module
+        it "should extend with #{expected_module} when adapter is #{adapter}" do
+          migration = DataMapper::Migration.new(1, :"#{adapter}_adapter_test") { }
+          (class << migration.adapter; self; end).included_modules.should include(expected_module)
+        end
+      end
+    end
+
+    describe DataMapper::Migration, 'defining actions' do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+      end
+
+      it "should have an #up method" do
+        @migration.should respond_to(:up)
+      end
+
+      it "should save the block passed into the #up method in @up_action" do
+        action = lambda {}
+        @migration.up(&action)
+
+        @migration.instance_variable_get(:@up_action).should == action
+      end
+
+      it "should have a #down method" do
+        @migration.should respond_to(:down)
+      end
+
+      it "should save the block passed into the #down method in @down_action" do
+        action = lambda {}
+        @migration.down(&action)
+
+        @migration.instance_variable_get(:@down_action).should == action
+      end
+
+      it "should make available an #execute method" do
+        @migration.should respond_to(:execute)
+      end
+
+      it "should run 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) { }
+        @migration.stub!(:write) # so that we don't actually write anything to the console!
+      end
+
+      it "should #say a string with an indent" do
+        @migration.should_receive(:write).with("   Foobar")
+        @migration.say("Foobar", 2)
+      end
+
+      it "should #say with a default indent of 4" do
+        @migration.should_receive(:write).with("     Foobar")
+        @migration.say("Foobar")
+      end
+
+      it "should #say_with_time the running time of a block" do
+        @migration.should_receive(:write).with(/Block/)
+        @migration.should_receive(:write).with(/-> [\d]+/)
+
+        @migration.say_with_time("Block"){ }
+      end
+
+    end
+
+  end
+
+end

data/spec/integration/sql_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+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   then @adapter.extend(SQL::Sqlite)
+        when :mysql    then @adapter.extend(SQL::Mysql)
+        when :postgres then @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
+        end
+      end
+
+      it "should have a #create_table helper" do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+        @migration.should respond_to(:create_table)
+      end
+
+      it "should have a table_name" do
+        @creator.table_name.should == "people"
+      end
+
+      it "should have an adapter" do
+        @creator.instance_eval("@adapter").should == @adapter
+      end
+
+      it "should have an options hash" do
+        @creator.opts.should be_kind_of(Hash)
+        @creator.opts.should == {}
+      end
+
+      it "should have an array of columns" do
+        @creator.instance_eval("@columns").should be_kind_of(Array)
+        @creator.instance_eval("@columns").size.should == 3
+        @creator.instance_eval("@columns").first.should be_kind_of(DataMapper::Migration::TableCreator::Column)
+      end
+
+      it "should quote the table name for the adapter" do
+        @creator.quoted_table_name.should == (DataMapper::Spec.adapter_name.to_sym == :mysql ? '`people`' : '"people"')
+      end
+
+      it "should allow for custom options" do
+        columns = @creator.instance_eval("@columns")
+        col = columns.detect{|c| c.name == "long_string"}
+        col.instance_eval("@type").should include("200")
+      end
+
+      it "should generate a NOT NULL column when :allow_nil is false" do
+        @creator.instance_eval("@columns")[1].type.should match(/NOT NULL/)
+      end
+
+      case DataMapper::Spec.adapter_name.to_sym
+      when :mysql
+        it "should create an InnoDB database for MySQL" do
+          #can't get an exact == comparison here because character set and collation may differ per connection
+          @creator.to_sql.should match(/^CREATE TABLE `people` \(`id` SERIAL PRIMARY KEY, `name` VARCHAR\(50\) NOT NULL, `long_string` VARCHAR\(200\)\) ENGINE = InnoDB CHARACTER SET \w+ COLLATE \w+\z/)
+        end
+
+        it "should allow 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
+
+          creator.to_sql.should match(/^CREATE TABLE `people` \(`id` SERIAL PRIMARY KEY\) ENGINE = MyISAM CHARACTER SET big5 COLLATE big5_chinese_ci\z/)
+        end
+
+        it "should respect 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
+
+          creator.to_sql.should match(/^CREATE TABLE `people` \(`id` SERIAL PRIMARY KEY\) ENGINE = MyISAM CHARACTER SET \w+ COLLATE \w+\z/)
+        end
+
+      when :postgres
+        it "should output a CREATE TABLE statement when sent #to_sql" do
+          @creator.to_sql.should == %q{CREATE TABLE "people" ("id" SERIAL PRIMARY KEY, "name" VARCHAR(50) NOT NULL, "long_string" VARCHAR(200))}
+        end
+      when :sqlite3
+        it "should output a CREATE TABLE statement when sent #to_sql" do
+          @creator.to_sql.should == %q{CREATE TABLE "people" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "name" VARCHAR(50) NOT NULL, "long_string" VARCHAR(200))}
+        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
+          @creator.to_sql.should 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) { }
+
+      end
+
+      it "should have a #modify_table helper" do
+        @migration.should respond_to(:modify_table)
+      end
+
+      case DataMapper::Spec.adapter_name.to_sym
+      when :postgres
+        before do
+          @modifier = DataMapper::Migration::TableModifier.new(@adapter, :people) do
+            change_column :name, 'VARCHAR(200)'
+          end
+        end
+
+        it "should alter the column" do
+          @modifier.to_sql.should == %q{ALTER TABLE "people" ALTER COLUMN "name" VARCHAR(200)}
+        end
+      end
+    end
+
+    describe DataMapper::Migration, "other helpers" do
+      before do
+        @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) { }
+      end
+
+      it "should have a #drop_table helper" do
+        @migration.should 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 "should know if the migration_info table exists" do
+        @migration.send(:migration_info_table_exists?).should be(true)
+      end
+
+      it "should know if the migration_info table does not exist" do
+        DataMapper::Spec.adapter.execute("DROP TABLE migration_info") rescue nil
+        @migration.send(:migration_info_table_exists?).should be(false)
+      end
+
+      it "should be able to find the migration_info record for itself" do
+        insert_migration_record
+        @migration.send(:migration_record).should_not be_empty
+      end
+
+      it "should know if a migration needs_up?" do
+        @migration.send(:needs_up?).should be(true)
+        insert_migration_record
+        @migration.send(:needs_up?).should be(false)
+      end
+
+      it "should know if a migration needs_down?" do
+        @migration.send(:needs_down?).should be(false)
+        insert_migration_record
+        @migration.send(:needs_down?).should be(true)
+      end
+
+      it "should properly quote the migration_info table via the adapter for use in queries" do
+        @migration.send(:migration_info_table).should == @migration.quote_table_name("migration_info")
+      end
+
+      it "should properly quote the migration_info.migration_name column via the adapter for use in queries" do
+        @migration.send(:migration_name_column).should == @migration.quote_column_name("migration_name")
+      end
+
+      it "should properly quote the migration's name for use in queries"
+      # TODO how to i call the adapter's #escape_sql method?
+
+      it "should create the migration_info table if it doesn't exist" do
+        DataMapper::Spec.adapter.execute("DROP TABLE migration_info")
+        @migration.send(:migration_info_table_exists?).should be(false)
+        @migration.send(:create_migration_info_table_if_needed)
+        @migration.send(:migration_info_table_exists?).should be(true)
+      end
+
+      it "should insert a record into the migration_info table on up" do
+        @migration.send(:migration_record).should be_empty
+        @migration.perform_up.should == :ran_up
+        @migration.send(:migration_record).should_not be_empty
+      end
+
+      it "should remove a record from the migration_info table on down" do
+        insert_migration_record
+        @migration.send(:migration_record).should_not be_empty
+        @migration.perform_down.should == :ran_down
+        @migration.send(:migration_record).should be_empty
+      end
+
+      it "should not run the up action if the record exists in the table" do
+        insert_migration_record
+        @migration.perform_up.should_not == :ran_up
+      end
+
+      it "should not run the down action if the record does not exist in the table" do
+        @migration.perform_down.should_not == :ran_down
+      end
+
+    end
+  end
+end

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,30 @@
+require 'spec'
+require 'isolated/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
+
+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'
+
+      class ::Person
+        include DataMapper::Resource
+        property :id, Serial
+      end
+
+      @model   = Person
+
+    end
+
+    it_should_behave_like "require 'dm-migrations'"
+
+  end
+
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,30 @@
+require 'spec'
+require 'isolated/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
+
+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
+
+      class ::Person
+        include DataMapper::Resource
+        property :id, Serial
+      end
+
+      @model   = Person
+
+    end
+
+    it_should_behave_like "require 'dm-migrations'"
+
+  end
+
+end

data/spec/isolated/require_spec.rb

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

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--loadby random
+--format profile
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+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'
+
+Spec::Runner.configure do |config|
+
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+
+  config.after :all do
+    DataMapper::Spec.cleanup_models
+  end
+
+end