hummingbird 0.0.1

data/test/fixtures/no_basedir_user_config.yml

@@ -0,0 +1,3 @@
+---
+planfile: 'user-application.plan'
+migrations_dir: 'user-migrations-dir'

data/test/fixtures/no_connection_string_config.yml

@@ -0,0 +1,5 @@
+---
+basedir: 'sql'
+planfile: 'application.plan'
+migrations_dir: 'migrations-dir'
+migrations_table: 'application_migrations'

data/test/fixtures/no_migrations_dir_config.yml

@@ -0,0 +1,3 @@
+---
+basedir: 'sql'
+planfile: 'application.plan'

data/test/fixtures/no_migrations_dir_user_config.yml

@@ -0,0 +1,3 @@
+---
+basedir: 'user-sql'
+planfile: 'user-application.plan'

data/test/fixtures/no_migrations_table_config.yml

@@ -0,0 +1,4 @@
+---
+basedir: 'sql'
+planfile: 'application.plan'
+migrations_dir: 'migrations-dir'

data/test/fixtures/no_planfile_config.yml

@@ -0,0 +1,3 @@
+---
+basedir: 'sql'
+migrations_dir: 'migrations'

data/test/fixtures/no_planfile_user_config.yml

@@ -0,0 +1,3 @@
+---
+basedir: 'user-sql'
+migrations_dir: 'user-migrations-dir'

data/test/fixtures/plan/basic.plan

@@ -0,0 +1,4 @@
+file1.sql
+file2.sql
+file3.sql
+file4.sql

data/test/fixtures/sql/migrations/basic/file1.sql

@@ -0,0 +1 @@
+CREATE TABLE table1 (name text);

data/test/fixtures/sql/migrations/basic/file2.sql

@@ -0,0 +1 @@
+CREATE TABLE table2 (name text);

data/test/fixtures/sql/migrations/basic/file3.sql

@@ -0,0 +1 @@
+CREATE TABLE table3 (name text);

data/test/fixtures/sql/migrations/basic/file4.sql

@@ -0,0 +1 @@
+CREATE TABLE table4 (name text);

data/test/fixtures/sql/migrations_table.sql

@@ -0,0 +1,4 @@
+CREATE TABLE hummingbird_migrations (
+  migration_name text,
+  run_on integer
+);

data/test/fixtures/user_config.yml

@@ -0,0 +1,4 @@
+---
+basedir: 'user-sql'
+planfile: 'user-application.plan'
+migrations_dir: 'user-migrations-dir'

data/test/lib/hummingbird/configuration_test.rb

@@ -0,0 +1,153 @@
+require 'test_helper'
+
+describe Hummingbird::Configuration do
+  before do
+    @tempdir = tempdir
+  end
+
+  it 'defines the CONFIG_FILE basename constant' do
+    assert_equal 'hummingbird.yml', Hummingbird::Configuration::CONFIG_FILE
+  end
+
+  it 'defines the USER_CONFIG_FILE basename constant' do
+    assert_equal '.hummingbird.yml', Hummingbird::Configuration::USER_CONFIG_FILE
+  end
+
+  it 'loads the hummingbird.yml file from the specified config_dir' do
+    copy_fixture_to(
+      'basic_config.yml',
+      File.join(@tempdir, Hummingbird::Configuration::CONFIG_FILE)
+    )
+
+    config = Hummingbird::Configuration.new(@tempdir)
+
+    assert_equal 'sql',                                     config.basedir
+    assert_equal _with_basedir(config, 'application.plan'), config.planfile
+    assert_equal _with_basedir(config, 'migrations-dir'),   config.migrations_dir
+    assert_equal :application_migrations,                   config.migrations_table
+    assert_equal 'sequel connection string',                config.connection_string
+  end
+
+  it "defaults #basedir to be '.'" do
+    copy_fixture_to(
+      'no_basedir_config.yml',
+      File.join(@tempdir, Hummingbird::Configuration::CONFIG_FILE)
+    )
+
+    config = Hummingbird::Configuration.new(@tempdir)
+
+    assert_equal '.', config.basedir
+  end
+
+  it "defaults #planfile to be basedir + 'hummingbird.plan'" do
+    copy_fixture_to(
+      'no_planfile_config.yml',
+      File.join(@tempdir, Hummingbird::Configuration::CONFIG_FILE)
+    )
+
+    config = Hummingbird::Configuration.new(@tempdir)
+
+    assert_equal _with_basedir(config,'hummingbird.plan'), config.planfile
+  end
+
+  it "defaults #migrations_dir to be basedir + 'migrations'" do
+    copy_fixture_to(
+      'no_migrations_dir_config.yml',
+      File.join(@tempdir, Hummingbird::Configuration::CONFIG_FILE)
+    )
+
+    config = Hummingbird::Configuration.new(@tempdir)
+
+    assert_equal _with_basedir(config,'migrations'), config.migrations_dir
+  end
+
+  it 'defaults #migrations_table to be :hummingbird_migrations' do
+    copy_fixture_to(
+      'no_migrations_table_config.yml',
+      File.join(@tempdir, Hummingbird::Configuration::CONFIG_FILE)
+    )
+
+    config = Hummingbird::Configuration.new(@tempdir)
+
+    assert_equal :hummingbird_migrations, config.migrations_table
+  end
+
+  it "does not have a default #connection_string" do
+    copy_fixture_to(
+      'no_connection_string_config.yml',
+      File.join(@tempdir, Hummingbird::Configuration::CONFIG_FILE)
+    )
+
+    config = Hummingbird::Configuration.new(@tempdir)
+
+    assert_equal nil, config.connection_string
+  end
+
+  it "prefers the user's configuration file if one is present" do
+    [['basic_config.yml', Hummingbird::Configuration::CONFIG_FILE],
+      ['user_config.yml', Hummingbird::Configuration::USER_CONFIG_FILE]].each do |s,d|
+      copy_fixture_to(s, File.join(@tempdir, d))
+    end
+
+    config = nil
+    FileUtils.stub :pwd, @tempdir do
+      config = Hummingbird::Configuration.new(@tempdir)
+    end
+
+    assert_equal 'user-sql',                                    config.basedir
+    assert_equal _with_basedir(config,'user-application.plan'), config.planfile
+    assert_equal _with_basedir(config,'user-migrations-dir'),   config.migrations_dir
+  end
+
+  it "uses non-user basedir if not present for user" do
+    [['basic_config.yml', Hummingbird::Configuration::CONFIG_FILE],
+      ['no_basedir_user_config.yml', Hummingbird::Configuration::USER_CONFIG_FILE]].each do |s,d|
+      copy_fixture_to(s, File.join(@tempdir, d))
+    end
+
+    config = nil
+    FileUtils.stub :pwd, @tempdir do
+      config = Hummingbird::Configuration.new(@tempdir)
+    end
+
+    assert_equal 'sql',                                          config.basedir
+    assert_equal _with_basedir(config, 'user-application.plan'), config.planfile
+    assert_equal _with_basedir(config, 'user-migrations-dir'),   config.migrations_dir
+  end
+
+  it "uses non-user planfile if not present for user" do
+    [['basic_config.yml', Hummingbird::Configuration::CONFIG_FILE],
+      ['no_planfile_user_config.yml', Hummingbird::Configuration::USER_CONFIG_FILE]].each do |s,d|
+      copy_fixture_to(s, File.join(@tempdir, d))
+    end
+
+    config = nil
+    FileUtils.stub :pwd, @tempdir do
+      config = Hummingbird::Configuration.new(@tempdir)
+    end
+
+    assert_equal 'user-sql',                                   config.basedir
+    assert_equal _with_basedir(config, 'application.plan'),    config.planfile
+    assert_equal _with_basedir(config, 'user-migrations-dir'), config.migrations_dir
+  end
+
+  it "uses non-user migrations_dir if not present for user" do
+    [['basic_config.yml', Hummingbird::Configuration::CONFIG_FILE],
+      ['no_migrations_dir_user_config.yml', Hummingbird::Configuration::USER_CONFIG_FILE]].each do |s,d|
+      copy_fixture_to(s, File.join(@tempdir, d))
+    end
+
+    config = nil
+    FileUtils.stub :pwd, @tempdir do
+      config = Hummingbird::Configuration.new(@tempdir)
+    end
+
+    assert_equal 'user-sql',                                     config.basedir
+    assert_equal _with_basedir(config, 'user-application.plan'), config.planfile
+    assert_equal _with_basedir(config, 'migrations-dir'),        config.migrations_dir
+  end
+
+  def _with_basedir(config,path)
+    File.expand_path(File.join(config.basedir,path))
+  end
+end

data/test/lib/hummingbird/database_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+require 'sqlite3'
+
+describe Hummingbird::Database do
+  describe 'with an sqlite3 database' do
+    it 'reports the database as uninitialized if the migrations table is not found' do
+      sqlite_db = tempfile
+      sqlite_db.close
+
+      db = Hummingbird::Database.new("sqlite://#{sqlite_db.path}", :hummingbird_migrations)
+
+      assert_equal false, db.initialized?, 'DB should not be initialized'
+    end
+
+    it 'reports the database as initialized if the migrations table exists' do
+      sqlite_db_path = tempfile.path
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+
+      sqlite_db.execute "create table hummingbird_migrations (migration_name text);"
+
+      db = Hummingbird::Database.new("sqlite://#{sqlite_db_path}", :hummingbird_migrations)
+
+      assert_equal true, db.initialized?, 'DB should be initialized'
+    end
+
+    it 'returns an empty list of already run migrations if the database has not already been initialized' do
+      sqlite_db_path = tempfile.path
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+
+      db = Hummingbird::Database.new("sqlite://#{sqlite_db_path}", :hummingbird_migrations)
+
+      assert_set_equal [], db.already_run_migrations
+    end
+
+    it 'returns a list of the migrations that have already been run, in ascending run order of run date' do
+      sqlite_db_path = tempfile.path
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      [ ['third_migration.sql',  DateTime.new(2012,10,11,12,0,0,'-7').strftime('%s')],
+        ['first_migration.sql',  DateTime.new(2012,10, 1,13,0,0,'-7').strftime('%s')],
+        ['second_migration.sql', DateTime.new(2012,10, 8, 8,0,0,'-7').strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      db = Hummingbird::Database.new("sqlite://#{sqlite_db_path}", :hummingbird_migrations)
+
+      assert_equal(
+        [ { migration_name: 'first_migration.sql',  run_on: DateTime.new(2012,10, 1,13,0,0,'-7').strftime('%s').to_i },
+          { migration_name: 'second_migration.sql', run_on: DateTime.new(2012,10, 8, 8,0,0,'-7').strftime('%s').to_i },
+          { migration_name: 'third_migration.sql',  run_on: DateTime.new(2012,10,11,12,0,0,'-7').strftime('%s').to_i }
+        ],
+        db.already_run_migrations
+      )
+    end
+
+    it 'records and runs migrations specified via #run_migration' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+
+      db = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      migration_time = DateTime.new(2012,10,15,14,03,40,'-7')
+      DateTime.stub :now, migration_time do
+        db.run_migration('test_migration.sql', 'CREATE TABLE test_table (col1 text);')
+      end
+
+      assert_equal(
+        [{migration_name: 'test_migration.sql', run_on: migration_time.strftime('%s').to_i}],
+        db.already_run_migrations
+      )
+
+      assert_includes Sequel.connect(connect_string).tables, :test_table
+    end
+
+    it 'allows bootstrapping the DB via #run_migration' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+
+      db = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      seconds = 40
+      DateTime.stub :now, lambda { DateTime.new(2012,10,15,14,03,seconds+=1,'-7') } do
+        db.run_migration('bootstrap_hummingbird.sql', read_fixture('sql', 'migrations_table.sql'))
+        db.run_migration('test_migration.sql', 'CREATE TABLE test_table (col1 text);')
+      end
+
+      assert_equal(
+        [
+          {migration_name: 'bootstrap_hummingbird.sql', run_on: DateTime.new(2012,10,15,14,03,41,'-7').strftime('%s').to_i},
+          {migration_name: 'test_migration.sql',        run_on: DateTime.new(2012,10,15,14,03,42,'-7').strftime('%s').to_i}
+        ],
+        db.already_run_migrations
+      )
+
+      assert_includes Sequel.connect(connect_string).tables, :test_table
+    end
+  end
+end

data/test/lib/hummingbird/plan_test.rb

@@ -0,0 +1,230 @@
+require 'test_helper'
+require 'sqlite3'
+
+describe Hummingbird::Plan do
+  it 'reads the planned file list from the planfile' do
+    plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), tempdir)
+
+    assert_equal(
+      ['file1.sql','file2.sql','file3.sql','file4.sql'],
+      plan.planned_files
+    )
+  end
+
+  it 'gets the list of migration files from examining config.migration_dir' do
+    migration_dir = tempdir
+    migration_files = ['migration1.sql','migration2.sql','migration3.sql']
+    FileUtils.touch migration_files.map {|f| File.join(migration_dir,f)}
+
+    plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), migration_dir)
+
+    assert_equal(
+      migration_files.sort,
+      plan.migration_files.sort
+    )
+  end
+
+  it 'recurses into config.migration_dir to get the list of migration files' do
+    migration_dir = tempdir
+    migration_files = [['a','b','migration1.sql'],['a','migration2.sql'],['migration3.sql']].map {|f| File.join(*f)}
+    FileUtils.mkdir_p(File.join(migration_dir, 'a', 'b'))
+    FileUtils.touch migration_files.map {|f| File.join(migration_dir, f)}
+
+    plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), migration_dir)
+
+    assert_equal(
+      migration_files.sort,
+      plan.migration_files.sort
+    )
+  end
+
+  it 'returns the list of files missing from the plan' do
+    migration_dir = tempdir
+    migration_files = (0..6).map {|n| "file#{n}.sql"}
+    FileUtils.touch migration_files.map {|f| File.join(migration_dir,f)}
+
+    plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), migration_dir)
+
+    assert_set_equal [migration_files[0],*migration_files[-2,2]], plan.files_missing_from_plan, 'Wrong files missing from plan'
+    assert_set_equal [], plan.files_missing_from_migration_dir, 'Wrong files missing from migration_dir'
+  end
+
+  it 'returns the list of extra files in the plan' do
+    migration_dir = tempdir
+    migration_files = (2..3).map {|n| "file#{n}.sql"}
+    FileUtils.touch migration_files.map {|f| File.join(migration_dir,f)}
+
+    plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), migration_dir)
+
+    assert_set_equal ['file1.sql','file4.sql'], plan.files_missing_from_migration_dir, 'Wrong files missing from migration_dir'
+    assert_set_equal [], plan.files_missing_from_plan, 'Wrong files missing from plan'
+  end
+
+  it 'reports no files missing when plan, and migration_dir are in sync' do
+    migration_dir = tempdir
+    migration_files = (1..4).map {|n| "file#{n}.sql"}
+    FileUtils.touch migration_files.map {|f| File.join(migration_dir,f)}
+
+    plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), migration_dir)
+
+    assert_set_equal [], plan.files_missing_from_migration_dir, 'Wrong files missing from migration_dir'
+    assert_set_equal [], plan.files_missing_from_plan, 'Wrong files missing from plan'
+  end
+
+  describe '#to_be_run_migration_file_names' do
+    it 'returns all planned files when the db is uninitialized' do
+      sqlite_db_path = tempfile.path
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new("sqlite://#{sqlite_db_path}", :hummingbird_migrations)
+
+      assert_equal(
+        ['file1.sql','file2.sql','file3.sql','file4.sql'],
+        plan.to_be_run_migration_file_names(db.already_run_migrations)
+      )
+    end
+
+    it 'returns all planned files when no migrations have been run' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      assert_equal(
+        ['file1.sql','file2.sql','file3.sql','file4.sql'],
+        plan.to_be_run_migration_file_names(db.already_run_migrations)
+      )
+    end
+
+    it 'returns all planned files after the last run migration when plan and DB are in sync to that point' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      [ ['file1.sql', DateTime.new(2012,10, 1,12,0,0,'-7').strftime('%s')],
+        ['file2.sql', DateTime.new(2012,10,11,13,0,0,'-7').strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      assert_equal(
+        ['file3.sql','file4.sql'],
+        plan.to_be_run_migration_file_names(db.already_run_migrations)
+      )
+    end
+
+    it 'raises when a yet-to-be-run planned file is before a recorded migration' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      file3_run_on = DateTime.new(2012,10,11,13,0,0,'-7')
+      [ ['file1.sql', DateTime.new(2012,10, 1,12,0,0,'-7').strftime('%s')],
+        ['file3.sql', file3_run_on.strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      e = assert_raises Hummingbird::PlanError do
+        plan.to_be_run_migration_file_names(db.already_run_migrations)
+      end
+
+      assert_equal "Plan has 'file2.sql' before 'file3.sql' which was run on #{file3_run_on.new_offset(0)}", e.message
+    end
+
+    it 'raises when the plan file is not in the same order as the recorded migrations' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      file4_run_on = DateTime.new(2012,10,2,13,1,1,'-7')
+      [ ['file1.sql', DateTime.new(2012,10,1,12,0,0,'-7').strftime('%s')],
+        ['file4.sql', file4_run_on.strftime('%s')],
+        ['file3.sql', DateTime.new(2012,10,3,14,2,2,'-7').strftime('%s')],
+        ['file2.sql', DateTime.new(2012,10,4,15,3,3,'-7').strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      e = assert_raises Hummingbird::PlanError do
+        plan.to_be_run_migration_file_names(db.already_run_migrations)
+      end
+
+      assert_equal "Plan has 'file2.sql' before 'file4.sql' which was run on #{file4_run_on.new_offset(0)}", e.message
+    end
+
+    it 'raises when a recorded migration is missing from the plan' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      [ ['file1.sql', DateTime.new(2012,10,1,12,0,0,'-7').strftime('%s')],
+        ['file2.sql', DateTime.new(2012,10,2,13,1,1,'-7').strftime('%s')],
+        ['file3.sql', DateTime.new(2012,10,3,14,2,2,'-7').strftime('%s')],
+        ['file4.sql', DateTime.new(2012,10,4,15,3,3,'-7').strftime('%s')],
+        ['file5.sql', DateTime.new(2012,10,5,16,4,4,'-7').strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      e = assert_raises Hummingbird::PlanError do
+        plan.to_be_run_migration_file_names(db.already_run_migrations)
+      end
+
+      assert_equal "Plan is missing the following already run migrations: file5.sql", e.message
+    end
+
+    it 'does not modify #planned_files' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      [ ['file1.sql', DateTime.new(2012,10, 1,12,0,0,'-7').strftime('%s')],
+        ['file2.sql', DateTime.new(2012,10,11,13,0,0,'-7').strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      assert_equal ['file1.sql','file2.sql','file3.sql','file4.sql'], plan.planned_files
+
+      plan.to_be_run_migration_file_names(db.already_run_migrations)
+
+      assert_equal ['file1.sql','file2.sql','file3.sql','file4.sql'], plan.planned_files
+    end
+  end
+
+  describe '#migrations_to_be_run' do
+    it 'attaches the migration file contents to the #to_be_run_migration_file_names list' do
+      sqlite_db_path = tempfile.path
+      connect_string = "sqlite://#{sqlite_db_path}"
+      sqlite_db = SQLite3::Database.new(sqlite_db_path)
+      sqlite_db.execute read_fixture('sql', 'migrations_table.sql')
+      stmt = sqlite_db.prepare('INSERT INTO hummingbird_migrations (migration_name, run_on) VALUES (?,?);')
+      [ ['file1.sql', DateTime.new(2012,10, 1,12,0,0,'-7').strftime('%s')],
+        ['file2.sql', DateTime.new(2012,10,11,13,0,0,'-7').strftime('%s')]].each {|data| stmt.execute(*data)}
+
+      plan = Hummingbird::Plan.new(path_to_fixture('plan','basic.plan'), path_to_fixture('sql','migrations','basic'))
+      db   = Hummingbird::Database.new(connect_string, :hummingbird_migrations)
+
+      migrations = plan.stub :to_be_run_migration_file_names, ['file3.sql','file4.sql'] do
+        plan.migrations_to_be_run(db.already_run_migrations)
+      end
+
+      assert_equal(
+        [
+          {migration_name: 'file3.sql', sql: "CREATE TABLE table3 (name text);\n"},
+          {migration_name: 'file4.sql', sql: "CREATE TABLE table4 (name text);\n"},
+        ],
+        migrations
+      )
+    end
+  end
+end