dm-migrations 0.10.2 → 1.0.0.rc1

data/spec/integration/migration_runner_spec.rb

@@ -1,16 +1,26 @@
 require 'spec_helper'
 
-ADAPTERS.each do |adapter|
-  describe "Using Adapter #{adapter}, " do
+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
 

data/spec/integration/migration_spec.rb

@@ -1,8 +1,15 @@
 require 'spec_helper'
 
-ADAPTERS.each do |adapter|
-  describe "Using Adapter #{adapter}, " do
+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
@@ -20,10 +27,9 @@ ADAPTERS.each do |adapter|
       end
 
       it "should have a :database option" do
-        DataMapper.setup(:other, "sqlite3://#{Dir.pwd}/migration_other.db")
-
-        m = DataMapper::Migration.new(2, :create_dogs_table, :database => :other) {}
-        m.instance_variable_get(:@database).name.should == :other
+        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
@@ -49,15 +55,21 @@ ADAPTERS.each do |adapter|
         [m1, m2, m3, m4].sort.should == [m1, m3, m2, m4]
       end
 
-      expected_module = {
-        :sqlite3  => lambda { SQL::Sqlite3 },
-        :mysql    => lambda { SQL::Mysql },
-        :postgres => lambda { SQL::Postgresql }
-      }[adapter][]
+      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
 
-      it "should extend with #{expected_module} when adapter is #{adapter}" do
-        migration = DataMapper::Migration.new(1, :"#{adapter}_adapter_test", :database => adapter) { }
-        (class << migration.adapter; self; end).included_modules.should include(expected_module)
+      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
 
@@ -120,5 +132,7 @@ ADAPTERS.each do |adapter|
       end
 
     end
+
   end
+
 end

data/spec/integration/sql_spec.rb

@@ -1,24 +1,26 @@
 require 'spec_helper'
 
-ADAPTERS.each do |adapter|
-  describe "Using Adapter #{adapter}," do
+describe "SQL generation" do
 
-    def repository(*args)
-      DataMapper.repository(*args)
-    end
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
 
     describe DataMapper::Migration, "#create_table helper" do
       before :all do
-        case adapter
-        when :sqlite3  then repository(adapter).adapter.extend(SQL::Sqlite3)
-        when :mysql    then repository(adapter).adapter.extend(SQL::Mysql)
-        when :postgres then repository(adapter).adapter.extend(SQL::Postgresql)
+
+        @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(repository(adapter).adapter, :people) do
-          column :id,          DataMapper::Types::Serial
+        @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
@@ -34,7 +36,7 @@ ADAPTERS.each do |adapter|
       end
 
       it "should have an adapter" do
-        @creator.instance_eval("@adapter").should == repository(adapter).adapter
+        @creator.instance_eval("@adapter").should == @adapter
       end
 
       it "should have an options hash" do
@@ -49,7 +51,7 @@ ADAPTERS.each do |adapter|
       end
 
       it "should quote the table name for the adapter" do
-        @creator.quoted_table_name.should == (adapter == :mysql ? '`people`' : '"people"')
+        @creator.quoted_table_name.should == (DataMapper::Spec.adapter_name.to_sym == :mysql ? '`people`' : '"people"')
       end
 
       it "should allow for custom options" do
@@ -62,7 +64,7 @@ ADAPTERS.each do |adapter|
         @creator.instance_eval("@columns")[1].type.should match(/NOT NULL/)
       end
 
-      case adapter
+      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
@@ -102,7 +104,7 @@ ADAPTERS.each do |adapter|
     end
 
     describe DataMapper::Migration, "version tracking" do
-      before do
+      before(:each) do
         @migration = DataMapper::Migration.new(1, :create_people_table, :verbose => false) do
           up   { :ran_up }
           down { :ran_down }
@@ -111,8 +113,10 @@ ADAPTERS.each do |adapter|
         @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.repository.adapter.execute("INSERT INTO migration_info (migration_name) VALUES ('create_people_table')")
+        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
@@ -120,7 +124,7 @@ ADAPTERS.each do |adapter|
       end
 
       it "should know if the migration_info table does not exist" do
-        repository.adapter.execute("DROP TABLE migration_info") rescue nil
+        DataMapper::Spec.adapter.execute("DROP TABLE migration_info") rescue nil
         @migration.send(:migration_info_table_exists?).should be_false
       end
 
@@ -153,7 +157,7 @@ ADAPTERS.each do |adapter|
       # TODO how to i call the adapter's #escape_sql method?
 
       it "should create the migration_info table if it doesn't exist" do
-        repository.adapter.execute("DROP TABLE migration_info")
+        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
@@ -181,9 +185,6 @@ ADAPTERS.each do |adapter|
         @migration.perform_down.should_not == :ran_down
       end
 
-      after do
-        repository.adapter.execute("DELETE FROM migration_info") if @migration.send(:migration_info_table_exists?)
-      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'
+require 'dm-core/spec/lib/adapter_helpers'
+
+# 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
+
+describe "require 'dm-migrations' after calling DataMapper.setup" do
+  extend DataMapper::Spec::Adapters::Helpers
+
+  before(:all) do
+
+    @adapter = DataMapper::Spec.adapter
+    require 'dm-migrations'
+
+    class ::Person
+      include DataMapper::Resource
+      property :id, Serial
+    end
+
+    @model   = Person
+
+  end
+
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+    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'
+require 'dm-core/spec/lib/adapter_helpers'
+
+# 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
+
+describe "require 'dm-migrations' before calling DataMapper.setup" do
+  extend DataMapper::Spec::Adapters::Helpers
+
+  before(:all) do
+
+    require 'dm-migrations'
+    @adapter = DataMapper::Spec.adapter
+
+    class ::Person
+      include DataMapper::Resource
+      property :id, Serial
+    end
+
+    @model   = Person
+
+  end
+
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+    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/spec_helper.rb

@@ -1,31 +1,16 @@
-require 'rubygems'
+require 'dm-migrations'
+require 'dm-migrations/migration_runner'
 
-# use local dm-core if running from a typical dev checkout.
-lib = File.join('..', '..', 'dm-core', 'lib')
-$LOAD_PATH.unshift(lib) if File.directory?(lib)
-require 'dm-core'
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/adapter_helpers'
+require 'dm-core/spec/lib/spec_helper'
 
-# Support running specs with 'rake spec' and 'spec'
-$LOAD_PATH.unshift('lib') unless $LOAD_PATH.include?('lib')
+Spec::Runner.configure do |config|
 
-require 'dm-migrations'
-require 'dm-migrations/migration_runner'
+  config.extend(DataMapper::Spec::Adapters::Helpers)
 
-ADAPTERS = []
-def load_driver(name, default_uri)
-  begin
-    DataMapper.setup(name, default_uri)
-    DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
-    ADAPTERS << name
-    true
-  rescue LoadError => e
-    warn "Could not load do_#{name}: #{e}"
-    false
+  config.after :all do
+    DataMapper::Spec.cleanup_models
   end
-end
-
-ENV['ADAPTER'] ||= 'sqlite3'
 
-load_driver(:sqlite3,  'sqlite3::memory:')
-load_driver(:mysql,    'mysql://localhost/dm_core_test')
-load_driver(:postgres, 'postgres://postgres@localhost/dm_core_test')
+end

data/spec/unit/migration_spec.rb

@@ -1,443 +1,444 @@
 require 'spec_helper'
 
 describe 'Migration' do
-
-  before do
-    @adapter = mock('adapter', :class => DataMapper::Adapters::Sqlite3Adapter)
-    @repo = mock('DataMapper.repository', :adapter => @adapter)
-    DataMapper.stub!(:repository).and_return(@repo)
-    @m = DataMapper::Migration.new(1, :do_nothing, {}) {}
-    @m.stub!(:write) # silence any output
-  end
-
-  [:position, :name, :database, :adapter].each do |meth|
-    it "should respond to ##{meth}" do
-      @m.should respond_to(meth)
-    end
-  end
-
-  describe 'initialization' do
-    it 'should set @position from the given position' do
-      @m.instance_variable_get(:@position).should == 1
-    end
-
-    it 'should set @name from the given name' do
-      @m.instance_variable_get(:@name).should == :do_nothing
-    end
-
-    it 'should set @options from the options hash' do
-      @m.instance_variable_get(:@options).should == {}
+  supported_by :postgres, :mysql, :sqlite do
+    before do
+      @adapter = mock('adapter', :class => DataMapper::Spec.adapter.class)
+      @repo = mock('DataMapper.repository', :adapter => @adapter)
+      DataMapper.stub!(:repository).and_return(@repo)
+      @m = DataMapper::Migration.new(1, :do_nothing, {}) {}
+      @m.stub!(:write) # silence any output
     end
 
-    it 'should set @database from the default repository if no :database option is given' do
-      DataMapper.should_receive(:repository).with(:default).and_return(@repo)
-      DataMapper::Migration.new(1, :do_nothing, {}) {}
+    [:position, :name, :database, :adapter].each do |meth|
+      it "should respond to ##{meth}" do
+        @m.should respond_to(meth)
+      end
     end
 
-    it 'should set @database to the repository specified with the :database option' do
-      DataMapper.should_receive(:repository).with(:foobar).and_return(@repo)
-      DataMapper::Migration.new(1, :do_nothing, :database => :foobar) {}
-    end
+    describe 'initialization' do
+      it 'should set @position from the given position' do
+        @m.instance_variable_get(:@position).should == 1
+      end
 
-    it 'should determine the class of the adapter to be extended' do
-      @adapter.should_receive(:class).and_return(DataMapper::Adapters::Sqlite3Adapter)
-      DataMapper::Migration.new(1, :do_nothing, {}) {}
-    end
+      it 'should set @name from the given name' do
+        @m.instance_variable_get(:@name).should == :do_nothing
+      end
 
-    it 'should extend the adapter with the right module' do
-      @adapter.should_receive(:extend).with(SQL::Sqlite3)
-      DataMapper::Migration.new(1, :do_nothing, {}) {}
-    end
+      it 'should set @options from the options hash' do
+        @m.instance_variable_get(:@options).should == {}
+      end
 
-    it 'should raise "Unsupported adapter" on an unknown adapter' do
-      @adapter.should_receive(:class).any_number_of_times.and_return("InvalidAdapter")
-      lambda {
+      it 'should set @database from the default repository if no :database option is given' do
+        DataMapper.should_receive(:repository).with(:default).and_return(@repo)
         DataMapper::Migration.new(1, :do_nothing, {}) {}
-      }.should raise_error
-    end
-
-    it 'should set @verbose from the options hash' do
-      m = DataMapper::Migration.new(1, :do_nothing, :verbose => false) {}
-      m.instance_variable_get(:@verbose).should be_false
-    end
+      end
 
-    it 'should set @verbose to true by default' do
-      @m.instance_variable_get(:@verbose).should be_true
-    end
+      it 'should set @database to the repository specified with the :database option' do
+        DataMapper.should_receive(:repository).with(:foobar).and_return(@repo)
+        DataMapper::Migration.new(1, :do_nothing, :database => :foobar) {}
+      end
 
-    it 'should set the @up_action to an empty block' do
-      @m.instance_variable_get(:@up_action).should be_kind_of(Proc)
-    end
+      it 'should determine the class of the adapter to be extended' do
+        @adapter.should_receive(:class).and_return(DataMapper::Spec.adapter.class)
+        DataMapper::Migration.new(1, :do_nothing, {}) {}
+      end
 
-    it 'should set the @down_action to an empty block' do
-      @m.instance_variable_get(:@down_action).should be_kind_of(Proc)
-    end
+      it 'should extend the adapter with the right module' do
+        @adapter.should_receive(:extend).with(SQL.const_get(DataMapper::Spec.adapter_name.capitalize))
+        DataMapper::Migration.new(1, :do_nothing, {}) {}
+      end
 
-    it 'should evaluate the given block'
+      it 'should raise "Unsupported adapter" on an unknown adapter' do
+        @adapter.should_receive(:class).any_number_of_times.and_return("InvalidAdapter")
+        lambda {
+          DataMapper::Migration.new(1, :do_nothing, {}) {}
+        }.should raise_error
+      end
 
-  end
+      it 'should set @verbose from the options hash' do
+        m = DataMapper::Migration.new(1, :do_nothing, :verbose => false) {}
+        m.instance_variable_get(:@verbose).should be_false
+      end
 
-  it 'should set the @up_action when #up is called with a block' do
-    action = lambda {}
-    @m.up(&action)
-    @m.instance_variable_get(:@up_action).should == action
-  end
+      it 'should set @verbose to true by default' do
+        @m.instance_variable_get(:@verbose).should be_true
+      end
 
-  it 'should set the @up_action when #up is called with a block' do
-    action = lambda {}
-    @m.down(&action)
-    @m.instance_variable_get(:@down_action).should == action
-  end
+      it 'should set the @up_action to an empty block' do
+        @m.instance_variable_get(:@up_action).should be_kind_of(Proc)
+      end
 
-  describe 'perform_up' do
-    before do
-      @up_action = mock('proc', :call => true)
-      @m.instance_variable_set(:@up_action, @up_action)
-      @m.stub!(:needs_up?).and_return(true)
-      @m.stub!(:update_migration_info)
-    end
+      it 'should set the @down_action to an empty block' do
+        @m.instance_variable_get(:@down_action).should be_kind_of(Proc)
+      end
 
-    it 'should call the action assigned to @up_action and return the result' do
-      @up_action.should_receive(:call).and_return(:result)
-      @m.perform_up.should == :result
-    end
+      it 'should evaluate the given block'
 
-    it 'should output a status message with the position and name of the migration' do
-      @m.should_receive(:write).with(/Performing Up Migration #1: do_nothing/)
-      @m.perform_up
     end
 
-    it 'should not run if it doesnt need to be' do
-      @m.should_receive(:needs_up?).and_return(false)
-      @up_action.should_not_receive(:call)
-      @m.perform_up
+    it 'should set the @up_action when #up is called with a block' do
+      action = lambda {}
+      @m.up(&action)
+      @m.instance_variable_get(:@up_action).should == action
     end
 
-    it 'should update the migration info table' do
-      @m.should_receive(:update_migration_info).with(:up)
-      @m.perform_up
+    it 'should set the @up_action when #up is called with a block' do
+      action = lambda {}
+      @m.down(&action)
+      @m.instance_variable_get(:@down_action).should == action
     end
 
-    it 'should not update the migration info table if the migration does not need run' do
-      @m.should_receive(:needs_up?).and_return(false)
-      @m.should_not_receive(:update_migration_info)
-      @m.perform_up
-    end
+    describe 'perform_up' do
+      before do
+        @up_action = mock('proc', :call => true)
+        @m.instance_variable_set(:@up_action, @up_action)
+        @m.stub!(:needs_up?).and_return(true)
+        @m.stub!(:update_migration_info)
+      end
 
-  end
+      it 'should call the action assigned to @up_action and return the result' do
+        @up_action.should_receive(:call).and_return(:result)
+        @m.perform_up.should == :result
+      end
 
-  describe 'perform_down' do
-    before do
-      @down_action = mock('proc', :call => true)
-      @m.instance_variable_set(:@down_action, @down_action)
-      @m.stub!(:needs_down?).and_return(true)
-      @m.stub!(:update_migration_info)
-    end
+      it 'should output a status message with the position and name of the migration' do
+        @m.should_receive(:write).with(/Performing Up Migration #1: do_nothing/)
+        @m.perform_up
+      end
 
-    it 'should call the action assigned to @down_action and return the result' do
-      @down_action.should_receive(:call).and_return(:result)
-      @m.perform_down.should == :result
-    end
+      it 'should not run if it doesnt need to be' do
+        @m.should_receive(:needs_up?).and_return(false)
+        @up_action.should_not_receive(:call)
+        @m.perform_up
+      end
 
-    it 'should output a status message with the position and name of the migration' do
-      @m.should_receive(:write).with(/Performing Down Migration #1: do_nothing/)
-      @m.perform_down
-    end
+      it 'should update the migration info table' do
+        @m.should_receive(:update_migration_info).with(:up)
+        @m.perform_up
+      end
 
-    it 'should not run if it doesnt need to be' do
-      @m.should_receive(:needs_down?).and_return(false)
-      @down_action.should_not_receive(:call)
-      @m.perform_down
-    end
+      it 'should not update the migration info table if the migration does not need run' do
+        @m.should_receive(:needs_up?).and_return(false)
+        @m.should_not_receive(:update_migration_info)
+        @m.perform_up
+      end
 
-    it 'should update the migration info table' do
-      @m.should_receive(:update_migration_info).with(:down)
-      @m.perform_down
     end
 
-    it 'should not update the migration info table if the migration does not need run' do
-      @m.should_receive(:needs_down?).and_return(false)
-      @m.should_not_receive(:update_migration_info)
-      @m.perform_down
-    end
+    describe 'perform_down' do
+      before do
+        @down_action = mock('proc', :call => true)
+        @m.instance_variable_set(:@down_action, @down_action)
+        @m.stub!(:needs_down?).and_return(true)
+        @m.stub!(:update_migration_info)
+      end
 
-  end
+      it 'should call the action assigned to @down_action and return the result' do
+        @down_action.should_receive(:call).and_return(:result)
+        @m.perform_down.should == :result
+      end
 
-  describe 'methods used in the action blocks' do
+      it 'should output a status message with the position and name of the migration' do
+        @m.should_receive(:write).with(/Performing Down Migration #1: do_nothing/)
+        @m.perform_down
+      end
 
-    describe '#execute' do
-      before do
-        @adapter.stub!(:execute)
+      it 'should not run if it doesnt need to be' do
+        @m.should_receive(:needs_down?).and_return(false)
+        @down_action.should_not_receive(:call)
+        @m.perform_down
       end
 
-      it 'should send the SQL it its executing to the adapter execute method' do
-        @adapter.should_receive(:execute).with('SELECT SOME SQL')
-        @m.execute('SELECT SOME SQL')
+      it 'should update the migration info table' do
+        @m.should_receive(:update_migration_info).with(:down)
+        @m.perform_down
       end
 
-      it 'should output the SQL it is executing' do
-        @m.should_receive(:write).with(/SELECT SOME SQL/)
-        @m.execute('SELECT SOME SQL')
+      it 'should not update the migration info table if the migration does not need run' do
+        @m.should_receive(:needs_down?).and_return(false)
+        @m.should_not_receive(:update_migration_info)
+        @m.perform_down
       end
+
     end
 
-    describe 'helpers' do
-      before do
-        @m.stub!(:execute) # don't actually run anything
-      end
+    describe 'methods used in the action blocks' do
 
-      describe '#create_table' do
+      describe '#execute' do
         before do
-          @tc = mock('TableCreator', :to_sql => 'CREATE TABLE')
-          SQL::TableCreator.stub!(:new).and_return(@tc)
+          @adapter.stub!(:execute)
         end
 
-        it 'should create a new TableCreator object' do
-          SQL::TableCreator.should_receive(:new).with(@adapter, :users, {}).and_return(@tc)
-          @m.create_table(:users) { }
+        it 'should send the SQL it its executing to the adapter execute method' do
+          @adapter.should_receive(:execute).with('SELECT SOME SQL')
+          @m.execute('SELECT SOME SQL')
         end
 
-        it 'should convert the TableCreator object to an sql statement' do
-          @tc.should_receive(:to_sql).and_return('CREATE TABLE')
-          @m.create_table(:users) { }
+        it 'should output the SQL it is executing' do
+          @m.should_receive(:write).with(/SELECT SOME SQL/)
+          @m.execute('SELECT SOME SQL')
         end
+      end
 
-        it 'should execute the create table sql' do
-          @m.should_receive(:execute).with('CREATE TABLE')
-          @m.create_table(:users) { }
+      describe 'helpers' do
+        before do
+          @m.stub!(:execute) # don't actually run anything
         end
 
-      end
+        describe '#create_table' do
+          before do
+            @tc = mock('TableCreator', :to_sql => 'CREATE TABLE')
+            SQL::TableCreator.stub!(:new).and_return(@tc)
+          end
 
-      describe '#drop_table' do
-        it 'should quote the table name' do
-          @adapter.should_receive(:quote_name).with('users')
-          @m.drop_table :users
-        end
+          it 'should create a new TableCreator object' do
+            SQL::TableCreator.should_receive(:new).with(@adapter, :users, {}).and_return(@tc)
+            @m.create_table(:users) { }
+          end
 
-        it 'should execute the DROP TABLE sql for the table' do
-          @adapter.stub!(:quote_name).and_return("'users'")
-          @m.should_receive(:execute).with(%{DROP TABLE 'users'})
-          @m.drop_table :users
-        end
+          it 'should convert the TableCreator object to an sql statement' do
+            @tc.should_receive(:to_sql).and_return('CREATE TABLE')
+            @m.create_table(:users) { }
+          end
 
-      end
+          it 'should execute the create table sql' do
+            @m.should_receive(:execute).with('CREATE TABLE')
+            @m.create_table(:users) { }
+          end
 
-      describe '#modify_table' do
-        before do
-          @tm = mock('TableModifier', :statements => [])
-          SQL::TableModifier.stub!(:new).and_return(@tm)
         end
 
-        it 'should create a new TableModifier object' do
-          SQL::TableModifier.should_receive(:new).with(@adapter, :users, {}).and_return(@tm)
-          @m.modify_table(:users){ }
-        end
+        describe '#drop_table' do
+          it 'should quote the table name' do
+            @adapter.should_receive(:quote_name).with('users')
+            @m.drop_table :users
+          end
 
-        it 'should get the statements from the TableModifier object' do
-          @tm.should_receive(:statements).and_return([])
-          @m.modify_table(:users){ }
-        end
+          it 'should execute the DROP TABLE sql for the table' do
+            @adapter.stub!(:quote_name).and_return("'users'")
+            @m.should_receive(:execute).with(%{DROP TABLE 'users'})
+            @m.drop_table :users
+          end
 
-        it 'should iterate over the statements and execute each one' do
-          @tm.should_receive(:statements).and_return(['SELECT 1', 'SELECT 2'])
-          @m.should_receive(:execute).with('SELECT 1')
-          @m.should_receive(:execute).with('SELECT 2')
-          @m.modify_table(:users){ }
         end
 
-      end
+        describe '#modify_table' do
+          before do
+            @tm = mock('TableModifier', :statements => [])
+            SQL::TableModifier.stub!(:new).and_return(@tm)
+          end
 
-      describe 'sorting' do
-        it 'should order things by position' do
-          m1 = DataMapper::Migration.new(1, :do_nothing){}
-          m2 = DataMapper::Migration.new(2, :do_nothing_else){}
+          it 'should create a new TableModifier object' do
+            SQL::TableModifier.should_receive(:new).with(@adapter, :users, {}).and_return(@tm)
+            @m.modify_table(:users){ }
+          end
 
-          (m1 <=> m2).should == -1
-        end
+          it 'should get the statements from the TableModifier object' do
+            @tm.should_receive(:statements).and_return([])
+            @m.modify_table(:users){ }
+          end
 
-        it 'should order things by name when they have the same position' do
-          m1 = DataMapper::Migration.new(1, :do_nothing_a){}
-          m2 = DataMapper::Migration.new(1, :do_nothing_b){}
+          it 'should iterate over the statements and execute each one' do
+            @tm.should_receive(:statements).and_return(['SELECT 1', 'SELECT 2'])
+            @m.should_receive(:execute).with('SELECT 1')
+            @m.should_receive(:execute).with('SELECT 2')
+            @m.modify_table(:users){ }
+          end
 
-          (m1 <=> m2).should == -1
         end
 
-      end
+        describe 'sorting' do
+          it 'should order things by position' do
+            m1 = DataMapper::Migration.new(1, :do_nothing){}
+            m2 = DataMapper::Migration.new(2, :do_nothing_else){}
 
-      describe 'formatting output' do
-        describe '#say' do
-          it 'should output the message' do
-            @m.should_receive(:write).with(/Paul/)
-            @m.say("Paul")
+            (m1 <=> m2).should == -1
           end
 
-          it 'should indent the message with 4 spaces by default' do
-            @m.should_receive(:write).with(/^\s{4}/)
-            @m.say("Paul")
-          end
+          it 'should order things by name when they have the same position' do
+            m1 = DataMapper::Migration.new(1, :do_nothing_a){}
+            m2 = DataMapper::Migration.new(1, :do_nothing_b){}
 
-          it 'should indext the message with a given number of spaces' do
-            @m.should_receive(:write).with(/^\s{3}/)
-            @m.say("Paul", 3)
+            (m1 <=> m2).should == -1
           end
+
         end
 
-        describe '#say_with_time' do
-          before do
-            @m.stub!(:say)
+        describe 'formatting output' do
+          describe '#say' do
+            it 'should output the message' do
+              @m.should_receive(:write).with(/Paul/)
+              @m.say("Paul")
+            end
+
+            it 'should indent the message with 4 spaces by default' do
+              @m.should_receive(:write).with(/^\s{4}/)
+              @m.say("Paul")
+            end
+
+            it 'should indext the message with a given number of spaces' do
+              @m.should_receive(:write).with(/^\s{3}/)
+              @m.say("Paul", 3)
+            end
           end
 
-          it 'should say the message with an indent of 2' do
-            @m.should_receive(:say).with("Paul", 2)
-            @m.say_with_time("Paul"){}
-          end
+          describe '#say_with_time' do
+            before do
+              @m.stub!(:say)
+            end
 
-          it 'should output the time it took' do
-            @m.should_receive(:say).with(/\d+/, 2)
-            @m.say_with_time("Paul"){}
-          end
-        end
+            it 'should say the message with an indent of 2' do
+              @m.should_receive(:say).with("Paul", 2)
+              @m.say_with_time("Paul"){}
+            end
 
-        describe '#write' do
-          before do
-            # need a new migration object, because the main one had #write stubbed to silence output
-            @m = DataMapper::Migration.new(1, :do_nothing) {}
+            it 'should output the time it took' do
+              @m.should_receive(:say).with(/\d+/, 2)
+              @m.say_with_time("Paul"){}
+            end
           end
 
-          it 'should puts the message' do
-            @m.should_receive(:puts).with("Paul")
-            @m.write("Paul")
-          end
+          describe '#write' do
+            before do
+              # need a new migration object, because the main one had #write stubbed to silence output
+              @m = DataMapper::Migration.new(1, :do_nothing) {}
+            end
 
-          it 'should not puts the message if @verbose is false' do
-            @m.instance_variable_set(:@verbose, false)
-            @m.should_not_receive(:puts)
-            @m.write("Paul")
-          end
+            it 'should puts the message' do
+              @m.should_receive(:puts).with("Paul")
+              @m.write("Paul")
+            end
 
-        end
+            it 'should not puts the message if @verbose is false' do
+              @m.instance_variable_set(:@verbose, false)
+              @m.should_not_receive(:puts)
+              @m.write("Paul")
+            end
 
-      end
+          end
 
-      describe 'working with the migration_info table' do
-        before do
-          @adapter.stub!(:storage_exists?).and_return(true)
-          # --- Please remove stubs ---
-          @adapter.stub!(:quote_name).and_return { |name| "'#{name}'" }
         end
 
-        describe '#update_migration_info' do
-          it 'should add a record of the migration' do
-            @m.should_receive(:execute).with(
-              %Q{INSERT INTO 'migration_info' ('migration_name') VALUES ('do_nothing')}
-            )
-            @m.update_migration_info(:up)
+        describe 'working with the migration_info table' do
+          before do
+            @adapter.stub!(:storage_exists?).and_return(true)
+            # --- Please remove stubs ---
+            @adapter.stub!(:quote_name).and_return { |name| "'#{name}'" }
           end
 
-          it 'should remove the record of the migration' do
-            @m.should_receive(:execute).with(
-              %Q{DELETE FROM 'migration_info' WHERE 'migration_name' = 'do_nothing'}
-            )
-            @m.update_migration_info(:down)
+          describe '#update_migration_info' do
+            it 'should add a record of the migration' do
+              @m.should_receive(:execute).with(
+                %Q{INSERT INTO 'migration_info' ('migration_name') VALUES ('do_nothing')}
+              )
+              @m.update_migration_info(:up)
+            end
+
+            it 'should remove the record of the migration' do
+              @m.should_receive(:execute).with(
+                %Q{DELETE FROM 'migration_info' WHERE 'migration_name' = 'do_nothing'}
+              )
+              @m.update_migration_info(:down)
+            end
+
+            it 'should try to create the migration_info table' do
+              @m.should_receive(:create_migration_info_table_if_needed)
+              @m.update_migration_info(:up)
+            end
           end
 
-          it 'should try to create the migration_info table' do
-            @m.should_receive(:create_migration_info_table_if_needed)
-            @m.update_migration_info(:up)
+          describe '#create_migration_info_table_if_needed' do
+            it 'should create the migration info table' do
+              @m.should_receive(:migration_info_table_exists?).and_return(false)
+              @m.should_receive(:execute).with(
+                %Q{CREATE TABLE 'migration_info' ('migration_name' VARCHAR(255) UNIQUE)}
+              )
+              @m.create_migration_info_table_if_needed
+            end
+
+            it 'should not try to create the migration info table if it already exists' do
+              @m.should_receive(:migration_info_table_exists?).and_return(true)
+              @m.should_not_receive(:execute)
+              @m.create_migration_info_table_if_needed
+            end
           end
-        end
 
-        describe '#create_migration_info_table_if_needed' do
-          it 'should create the migration info table' do
-            @m.should_receive(:migration_info_table_exists?).and_return(false)
-            @m.should_receive(:execute).with(
-              %Q{CREATE TABLE 'migration_info' ('migration_name' VARCHAR(255) UNIQUE)}
-            )
-            @m.create_migration_info_table_if_needed
+          it 'should quote the name of the migration for use in sql' do
+            @m.quoted_name.should == %{'do_nothing'}
           end
 
-          it 'should not try to create the migration info table if it already exists' do
-            @m.should_receive(:migration_info_table_exists?).and_return(true)
-            @m.should_not_receive(:execute)
-            @m.create_migration_info_table_if_needed
+          it 'should query the adapter to see if the migration_info table exists' do
+            @adapter.should_receive(:storage_exists?).with('migration_info').and_return(true)
+            @m.migration_info_table_exists?.should == true
           end
-        end
 
-        it 'should quote the name of the migration for use in sql' do
-          @m.quoted_name.should == %{'do_nothing'}
-        end
+          describe '#migration_record' do
+            it 'should query for the migration' do
+              @adapter.should_receive(:select).with(
+                %Q{SELECT 'migration_name' FROM 'migration_info' WHERE 'migration_name' = 'do_nothing'}
+              )
+              @m.migration_record
+            end
 
-        it 'should query the adapter to see if the migration_info table exists' do
-          @adapter.should_receive(:storage_exists?).with('migration_info').and_return(true)
-          @m.migration_info_table_exists?.should == true
-        end
+            it 'should not try to query if the table does not exist' do
+              @m.stub!(:migration_info_table_exists?).and_return(false)
+              @adapter.should_not_receive(:select)
+              @m.migration_record
+            end
 
-        describe '#migration_record' do
-          it 'should query for the migration' do
-            @adapter.should_receive(:select).with(
-              %Q{SELECT 'migration_name' FROM 'migration_info' WHERE 'migration_name' = 'do_nothing'}
-            )
-            @m.migration_record
           end
 
-          it 'should not try to query if the table does not exist' do
-            @m.stub!(:migration_info_table_exists?).and_return(false)
-            @adapter.should_not_receive(:select)
-            @m.migration_record
-          end
+          describe '#needs_up?' do
+            it 'should be true if there is no record' do
+              @m.should_receive(:migration_record).and_return([])
+              @m.needs_up?.should == true
+            end
 
-        end
+            it 'should be false if the record exists' do
+              @m.should_receive(:migration_record).and_return([:not_empty])
+              @m.needs_up?.should == false
+            end
 
-        describe '#needs_up?' do
-          it 'should be true if there is no record' do
-            @m.should_receive(:migration_record).and_return([])
-            @m.needs_up?.should == true
-          end
+            it 'should be true if there is no migration_info table' do
+              @m.should_receive(:migration_info_table_exists?).and_return(false)
+              @m.needs_up?.should == true
+            end
 
-          it 'should be false if the record exists' do
-            @m.should_receive(:migration_record).and_return([:not_empty])
-            @m.needs_up?.should == false
           end
 
-          it 'should be true if there is no migration_info table' do
-            @m.should_receive(:migration_info_table_exists?).and_return(false)
-            @m.needs_up?.should == true
-          end
+          describe '#needs_down?' do
+            it 'should be false if there is no record' do
+              @m.should_receive(:migration_record).and_return([])
+              @m.needs_down?.should == false
+            end
 
-        end
+            it 'should be true if the record exists' do
+              @m.should_receive(:migration_record).and_return([:not_empty])
+              @m.needs_down?.should == true
+            end
 
-        describe '#needs_down?' do
-          it 'should be false if there is no record' do
-            @m.should_receive(:migration_record).and_return([])
-            @m.needs_down?.should == false
-          end
+            it 'should be false if there is no migration_info table' do
+              @m.should_receive(:migration_info_table_exists?).and_return(false)
+              @m.needs_down?.should == false
+            end
 
-          it 'should be true if the record exists' do
-            @m.should_receive(:migration_record).and_return([:not_empty])
-            @m.needs_down?.should == true
           end
 
-          it 'should be false if there is no migration_info table' do
-            @m.should_receive(:migration_info_table_exists?).and_return(false)
-            @m.needs_down?.should == false
+          it 'should have the adapter quote the migration_info table' do
+            @adapter.should_receive(:quote_name).with('migration_info').and_return("'migration_info'")
+            @m.migration_info_table.should == "'migration_info'"
           end
 
-        end
-
-        it 'should have the adapter quote the migration_info table' do
-          @adapter.should_receive(:quote_name).with('migration_info').and_return("'migration_info'")
-          @m.migration_info_table.should == "'migration_info'"
-        end
+          it 'should have a quoted migration_name_column' do
+            @adapter.should_receive(:quote_name).with('migration_name').and_return("'migration_name'")
+            @m.migration_name_column.should == "'migration_name'"
+          end
 
-        it 'should have a quoted migration_name_column' do
-          @adapter.should_receive(:quote_name).with('migration_name').and_return("'migration_name'")
-          @m.migration_name_column.should == "'migration_name'"
         end
 
       end
 
     end
-
   end
 end