dm-hibernate-migrations 1.0.0

data/spec/integration/migration_runner_spec.rb

@@ -0,0 +1,89 @@
+require '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 "should return an empty array if no migrations have been defined" do
+        migrations.should be_kind_of(Array)
+        migrations.should have(0).item
+      end
+    end
+
+    describe 'migration runnner' 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) { }
+      end
+
+      after(:each) do
+        migrations.clear
+      end
+
+      describe '#migration' do
+
+        it 'should create a new migration object, and add it to the list of migrations' do
+          migrations.should be_kind_of(Array)
+          migrations.should have(1).item
+          migrations.first.name.should == "create_people_table"
+        end
+
+        it 'should allow multiple migrations to be added' do
+          migration( 2, :add_dob_to_people) { }
+          migration( 2, :add_favorite_pet_to_people) { }
+          migration( 3, :add_something_else_to_people) { }
+          migrations.should have(4).items
+        end
+
+        it 'should raise an error on adding with a duplicated name' do
+          lambda { migration( 1, :create_people_table) { } }.should raise_error(RuntimeError, /Migration name conflict/)
+        end
+
+      end
+
+      describe '#migrate_up! and #migrate_down!' do
+        before(:each) do
+          migration( 2, :add_dob_to_people) { }
+          migration( 2, :add_favorite_pet_to_people) { }
+          migration( 3, :add_something_else_to_people) { }
+        end
+
+        it 'calling migrate_up! should migrate up all the migrations' do
+          # add our expectation that migrate_up should be called
+          migrations.each do |m|
+            m.should_receive(:perform_up)
+          end
+          migrate_up!
+        end
+
+        it 'calling migrate_up! with an arguement should only migrate to that level' do
+          migrations.each do |m|
+            if m.position <= 2
+              m.should_receive(:perform_up)
+            else
+              m.should_not_receive(:perform_up)
+            end
+          end
+          migrate_up!(2)
+        end
+
+        it 'calling migrate_down! should migrate down all the migrations' do
+          # add our expectation that migrate_up should be called
+          migrations.each do |m|
+            m.should_receive(:perform_down)
+          end
+          migrate_down!
+        end
+
+      end
+    end
+  end
+end

data/spec/integration/migration_spec.rb

@@ -0,0 +1,138 @@
+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
+
+      it "should have a postition attribute" do
+        @migration.should respond_to(:position)
+        @migration.should respond_to(:position=)
+        @migration.position.should == 1
+      end
+
+      it "should have a name attribute" do
+        @migration.should respond_to(:name)
+        @migration.should respond_to(:name=)
+        @migration.name.should == :create_people_table
+      end
+
+      it "should have a :database option" do
+        adapter = DataMapper::Spec.adapter(:alternate)
+        m = DataMapper::Migration.new(2, :create_dogs_table, :database => :alternate) {}
+        m.instance_variable_get(:@adapter).should == adapter
+      end
+
+      it "should use the default database by default" do
+        @migration.instance_variable_get(:@database).name.should == :default
+      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,190 @@
+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").should have(3).items
+        @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
+      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
+    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
+
+    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