ardb 0.27.3 → 0.29.0

data/test/unit/cli_tests.rb

@@ -1,18 +1,14 @@
-require 'assert'
-require 'ardb/cli'
+require "assert"
+require "ardb/cli"
 
-require 'ardb/adapter_spy'
-require 'ardb/migration'
+require "ardb"
+require "ardb/adapter_spy"
+require "ardb/migration"
 
 class Ardb::CLI
-
   class UnitTests < Assert::Context
     desc "Ardb::CLI"
     setup do
-      @kernel_spy = KernelSpy.new
-      @stdout = IOSpy.new
-      @stderr = IOSpy.new
-
       @cli_class = Ardb::CLI
     end
     subject{ @cli_class }
@@ -29,50 +25,52 @@ class Ardb::CLI
     end
 
     should "know its commands" do
-      assert_equal 5, COMMANDS.size
-
-      assert_instance_of InvalidCommand, COMMANDS[Factory.string]
-
-      assert_equal ConnectCommand,           COMMANDS['connect']
-      assert_equal CreateCommand,            COMMANDS['create']
-      assert_equal DropCommand,              COMMANDS['drop']
-      assert_equal MigrateCommand,           COMMANDS['migrate']
-      assert_equal GenerateMigrationCommand, COMMANDS['generate-migration']
+      assert_equal 9, COMMANDS.size
+
+      assert_instance_of InvalidCommand,           COMMANDS[Factory.string]
+      assert_instance_of ConnectCommand,           COMMANDS["connect"]
+      assert_instance_of CreateCommand,            COMMANDS["create"]
+      assert_instance_of DropCommand,              COMMANDS["drop"]
+      assert_instance_of GenerateMigrationCommand, COMMANDS["generate-migration"]
+      assert_instance_of MigrateCommand,           COMMANDS["migrate"]
+      assert_instance_of MigrateUpCommand,         COMMANDS["migrate-up"]
+      assert_instance_of MigrateDownCommand,       COMMANDS["migrate-down"]
+      assert_instance_of MigrateForwardCommand,    COMMANDS["migrate-forward"]
+      assert_instance_of MigrateBackwardCommand,   COMMANDS["migrate-backward"]
     end
-
   end
 
   class InitTests < UnitTests
     desc "when init"
     setup do
+      @kernel_spy = KernelSpy.new
+      @stdout     = IOSpy.new
+      @stderr     = IOSpy.new
+
       @cli = @cli_class.new(@kernel_spy, @stdout, @stderr)
     end
     subject{ @cli }
 
     should have_imeths :run
-
   end
 
   class RunSetupTests < InitTests
     setup do
       @command_name = Factory.string
-      @argv = [@command_name, Factory.string]
-
-      @command_class = Class.new
-      COMMANDS[@command_name] = @command_class
+      @command_class = Class.new{ include ValidCommand }
+      Assert.stub(@command_class, :command_name) { @command_name }
 
-      @command_spy = CommandSpy.new
-      Assert.stub(@command_class, :new).with(@argv){ @command_spy }
-
-      @ardb_init_called_with = nil
-      Assert.stub(Ardb, :init){ |*args| @ardb_init_called_with = args }
+      @command_spy  = CommandSpy.new(@command_name)
+      Assert.stub(@command_class, :new){ @command_spy }
+      COMMANDS.add(@command_class)
 
       @invalid_command = InvalidCommand.new(@command_name)
+
+      @argv = [@command_name, Factory.string]
     end
     teardown do
-      COMMANDS.delete(@command_name)
+      COMMANDS.remove(@command_class)
     end
-
   end
 
   class RunTests < RunSetupTests
@@ -85,10 +83,6 @@ class Ardb::CLI
       assert_includes Dir.pwd, $LOAD_PATH
     end
 
-    should "init Ardb without establishing a connection" do
-      assert_equal [false], @ardb_init_called_with
-    end
-
     should "have run the command" do
       assert_true @command_spy.run_called
     end
@@ -96,7 +90,6 @@ class Ardb::CLI
     should "have successfully exited" do
       assert_equal 0, @kernel_spy.exit_status
     end
-
   end
 
   class RunWithNoArgsTests < RunSetupTests
@@ -106,14 +99,13 @@ class Ardb::CLI
     end
 
     should "output the invalid command's help" do
-      assert_equal @invalid_command.help, @stdout.read
+      assert_equal @invalid_command.command_help, @stdout.read
       assert_empty @stderr.read
     end
 
     should "have successfully exited" do
       assert_equal 0, @kernel_spy.exit_status
     end
-
   end
 
   class RunWithInvalidCommandTests < RunSetupTests
@@ -125,15 +117,14 @@ class Ardb::CLI
     end
 
     should "output that it is invalid and output the invalid command's help" do
-      exp = "'#{@name}' is not a command.\n\n"
+      exp = "\"#{@name}\" is not a command.\n\n"
       assert_equal exp, @stderr.read
-      assert_equal @invalid_command.help, @stdout.read
+      assert_equal @invalid_command.command_help, @stdout.read
     end
 
     should "have unsuccessfully exited" do
       assert_equal 1, @kernel_spy.exit_status
     end
-
   end
 
   class RunWithCommandExitErrorTests < RunSetupTests
@@ -147,30 +138,28 @@ class Ardb::CLI
       assert_equal 1, @kernel_spy.exit_status
       assert_empty @stderr.read
     end
-
   end
 
   class RunWithHelpTests < RunSetupTests
     desc "and run with the help switch"
     setup do
-      @cli.run([ '--help' ])
+      @cli.run([ "--help" ])
     end
 
     should "output the invalid command's help" do
-      assert_equal @invalid_command.help, @stdout.read
+      assert_equal @invalid_command.command_help, @stdout.read
       assert_empty @stderr.read
     end
 
     should "have successfully exited" do
       assert_equal 0, @kernel_spy.exit_status
     end
-
   end
 
   class RunWithVersionTests < RunSetupTests
     desc "and run with the version switch"
     setup do
-      @cli.run([ '--version' ])
+      @cli.run([ "--version" ])
     end
 
     should "output its version" do
@@ -181,13 +170,12 @@ class Ardb::CLI
     should "have successfully exited" do
       assert_equal 0, @kernel_spy.exit_status
     end
-
   end
 
   class RunWithErrorTests < RunSetupTests
     setup do
       @exception = RuntimeError.new(Factory.string)
-      Assert.stub(@command_class, :new).with(@argv){ raise @exception }
+      Assert.stub(@command_spy, :run){ raise @exception }
       @cli.run(@argv)
     end
 
@@ -201,7 +189,6 @@ class Ardb::CLI
     should "have unsuccessfully exited" do
       assert_equal 1, @kernel_spy.exit_status
     end
-
   end
 
   class InvalidCommandTests < UnitTests
@@ -213,328 +200,441 @@ class Ardb::CLI
     end
     subject{ @cmd }
 
-    should have_readers :name, :argv, :clirb
-    should have_imeths :new, :run, :help
+    should have_readers :name, :clirb
+    should have_imeths :new, :run, :command_help
 
     should "know its attrs" do
       assert_equal @name, subject.name
-      assert_equal [],    subject.argv
-
-      assert_instance_of Ardb::CLIRB, subject.clirb
+      assert_instance_of CLIRB, subject.clirb
     end
 
     should "set its argv and return itself using `new`" do
-      args = [Factory.string, Factory.string]
-      result = subject.new(args)
-      assert_same subject, result
-      assert_equal [@name, args].flatten, subject.argv
+      assert_same subject, subject.new
     end
 
-    should "parse its argv on run`" do
-      assert_raises(Ardb::CLIRB::HelpExit){ subject.new(['--help']).run }
-      assert_raises(Ardb::CLIRB::VersionExit){ subject.new(['--version']).run }
+    should "parse its argv on run" do
+      assert_raises(CLIRB::HelpExit){ subject.new.run([ "--help" ]) }
+      assert_raises(CLIRB::VersionExit){ subject.new.run([ "--version" ]) }
     end
 
-    should "raise a help exit if its argv is empty" do
-      cmd = @command_class.new([nil, ''].choice)
-      assert_raises(Ardb::CLIRB::HelpExit){ cmd.new([]).run }
+    should "raise a help exit if its name is empty" do
+      cmd = @command_class.new([nil, ""].sample)
+      argv = [Factory.string, Factory.string]
+      assert_raises(CLIRB::HelpExit){ cmd.new.run(argv) }
     end
 
     should "raise an invalid command error when run" do
-      assert_raises(InvalidCommandError){ subject.new([Factory.string]).run }
+      assert_raises(InvalidCommandError){ subject.new.run([Factory.string]) }
     end
 
     should "know its help" do
       exp = "Usage: ardb [COMMAND] [options]\n\n" \
-            "Commands: #{COMMANDS.keys.sort.join(', ')}\n" \
-            "Options: #{subject.clirb}"
-      assert_equal exp, subject.help
+            "Options: #{subject.clirb}\n" \
+            "Commands:\n" \
+            "#{COMMANDS.to_s.split("\n").map{ |l| "  #{l}" }.join("\n")}\n"
+      assert_equal exp, subject.command_help
     end
-
   end
 
-  class ConnectCommandTests < UnitTests
-    desc "ConnectCommand"
+  class CommandSetupTests < UnitTests
     setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
+      @stdout, @stderr = IOSpy.new, IOSpy.new
 
-      @ardb_init_called = false
-      Assert.stub(Ardb, :init){ @ardb_init_called = true }
+      @ardb_init_called_with = nil
+      Assert.stub(Ardb, :init){ |*args| @ardb_init_called_with = args }
 
-      @command_class = ConnectCommand
-      @cmd = @command_class.new([], @stdout, @stderr)
+      @adapter_spy = Ardb::AdapterSpy.new
+      Assert.stub(Ardb, :adapter){ @adapter_spy }
     end
     subject{ @cmd }
+  end
 
-    should have_readers :clirb
+  class ValidCommandTests < CommandSetupTests
+    desc "ValidCommand"
+    setup do
+      @command_class = Class.new{ include ValidCommand }
+      @cmd = @command_class.new
+    end
+
+    should have_cmeths :command_name, :command_summary
+
+    should have_imeths :clirb, :run
+    should have_imeths :command_name, :command_summary, :command_help
 
     should "know its CLI.RB" do
-      assert_instance_of Ardb::CLIRB, subject.clirb
+      assert_instance_of CLIRB, subject.clirb
     end
 
-    should "know its help" do
-      exp = "Usage: ardb connect [options]\n\n" \
-            "Options: #{subject.clirb}"
-      assert_equal exp, subject.help
+    should "parse its args when run" do
+      argv = Factory.integer(3).times.map{ Factory.string }
+      subject.run(argv, @stdout, @stderr)
+      assert_equal argv, subject.clirb.args
+    end
+
+    should "take custom CLIRB build procs" do
+      cmd = @command_class.new do
+        option "test", "testing", :abbrev => "t"
+      end
+      cmd.run(["-t"], @stdout, @stderr)
+      assert_true cmd.clirb.opts["test"]
+    end
+
+    should "not implement its command name" do
+      assert_raises NotImplementedError do
+        subject.command_name
+      end
     end
 
-    should "parse its args, init ardb and connect to the db on run" do
-      subject.run
+    should "default its command summary" do
+      assert_equal "", subject.command_summary
+    end
+
+    should "know its command help" do
+      Assert.stub(subject, :command_name)    { "some-command" }
+      Assert.stub(subject, :command_summary) { "some-summary" }
+
+      exp = "Usage: ardb #{subject.command_name} [options]\n\n" \
+            "Options: #{subject.clirb}\n" \
+            "Description:\n" \
+            "  #{subject.command_summary}"
+      assert_equal exp, subject.command_help
+    end
+  end
+
+  class ConnectCommandTests < CommandSetupTests
+    desc "ConnectCommand"
+    setup do
+      @command_class = ConnectCommand
+      @cmd = @command_class.new
+    end
+
+    should "be a valid command" do
+      assert_kind_of ValidCommand, subject
+    end
 
-      assert_equal [], subject.clirb.args
+    should "know its command name and summary" do
+      exp = "connect"
+      assert_equal exp, subject.command_name
 
-      assert_true @ardb_init_called
+      exp = "Connect to the configured DB"
+      assert_equal exp, subject.command_summary
+    end
+
+    should "init ardb and connect to the db when run" do
+      subject.run([], @stdout, @stderr)
+
+      assert_equal [false], @ardb_init_called_with
       assert_true @adapter_spy.connect_db_called?
 
-      exp = "connected to #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`\n"
+      exp = "connected to #{Ardb.config.adapter} db #{Ardb.config.database.inspect}\n"
       assert_equal exp, @stdout.read
     end
 
-    should "output any errors and raise an exit error on run" do
+    should "output any errors and raise an exit error when run" do
       err = StandardError.new(Factory.string)
       err.set_backtrace(Factory.integer(3).times.map{ Factory.path })
-      Assert.stub(Ardb, :init){ raise err }
+      Assert.stub(@adapter_spy, :connect_db){ raise err }
 
-      assert_raises(CommandExitError){ subject.run }
+      assert_raises(CommandExitError){ subject.run([], @stdout, @stderr) }
       err_output = @stderr.read
 
       assert_includes err.to_s,                 err_output
       assert_includes err.backtrace.join("\n"), err_output
 
-      exp = "error connecting to #{Ardb.config.db.database.inspect} database " \
-            "with #{Ardb.config.db_settings.inspect}"
+      exp = "error connecting to #{Ardb.config.database.inspect} database " \
+            "with #{Ardb.config.activerecord_connect_hash.inspect}"
       assert_includes exp, err_output
     end
-
   end
 
-  class CreateCommandTests < UnitTests
+  class CreateCommandTests < CommandSetupTests
     desc "CreateCommand"
     setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
-
       @command_class = CreateCommand
-      @cmd = @command_class.new([], @stdout, @stderr)
+      @cmd = @command_class.new
     end
-    subject{ @cmd }
-
-    should have_readers :clirb
 
-    should "know its CLI.RB" do
-      assert_instance_of Ardb::CLIRB, subject.clirb
+    should "be a valid command" do
+      assert_kind_of ValidCommand, subject
     end
 
-    should "know its help" do
-      exp = "Usage: ardb create [options]\n\n" \
-            "Options: #{subject.clirb}"
-      assert_equal exp, subject.help
+    should "know its command name and summary" do
+      exp = "create"
+      assert_equal exp, subject.command_name
+
+      exp = "Create the configured DB"
+      assert_equal exp, subject.command_summary
     end
 
-    should "parse its args and create the db on run" do
-      subject.run
+    should "init ardb and create the db when run" do
+      subject.run([], @stdout, @stderr)
 
-      assert_equal [], subject.clirb.args
+      assert_equal [false], @ardb_init_called_with
       assert_true @adapter_spy.create_db_called?
 
-      exp = "created #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`\n"
+      exp = "created #{Ardb.config.adapter} db #{Ardb.config.database.inspect}\n"
       assert_equal exp, @stdout.read
     end
 
-    should "output any errors and raise an exit error on run" do
+    should "output any errors and raise an exit error when run" do
       err = StandardError.new(Factory.string)
       Assert.stub(@adapter_spy, :create_db){ raise err }
 
-      assert_raises(CommandExitError){ subject.run }
+      assert_raises(CommandExitError){ subject.run([], @stdout, @stderr) }
       err_output = @stderr.read
 
       assert_includes err.to_s, err_output
-      exp = "error creating #{Ardb.config.db.database.inspect} database"
+      exp = "error creating #{Ardb.config.database.inspect} database"
       assert_includes exp, err_output
     end
-
   end
 
-  class DropCommandTests < UnitTests
+  class DropCommandTests < CommandSetupTests
     desc "DropCommand"
     setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
-
       @command_class = DropCommand
-      @cmd = @command_class.new([], @stdout, @stderr)
+      @cmd = @command_class.new
     end
-    subject{ @cmd }
-
-    should have_readers :clirb
 
-    should "know its CLI.RB" do
-      assert_instance_of Ardb::CLIRB, subject.clirb
+    should "be a valid command" do
+      assert_kind_of ValidCommand, subject
     end
 
-    should "know its help" do
-      exp = "Usage: ardb drop [options]\n\n" \
-            "Options: #{subject.clirb}"
-      assert_equal exp, subject.help
+    should "know its command name and summary" do
+      exp = "drop"
+      assert_equal exp, subject.command_name
+
+      exp = "Drop the configured DB"
+      assert_equal exp, subject.command_summary
     end
 
-    should "parse its args and drop the db on run" do
-      subject.run
+    should "init ardb and drop the db when run" do
+      subject.run([], @stdout, @stderr)
 
-      assert_equal [], subject.clirb.args
+      assert_equal [true], @ardb_init_called_with
       assert_true @adapter_spy.drop_db_called?
 
-      exp = "dropped #{Ardb.config.db.adapter} db `#{Ardb.config.db.database}`\n"
+      exp = "dropped #{Ardb.config.adapter} db #{Ardb.config.database.inspect}\n"
       assert_equal exp, @stdout.read
     end
 
-    should "output any errors and raise an exit error on run" do
+    should "output any errors and raise an exit error when run" do
       err = StandardError.new(Factory.string)
       Assert.stub(@adapter_spy, :drop_db){ raise err }
 
-      assert_raises(CommandExitError){ subject.run }
+      assert_raises(CommandExitError){ subject.run([], @stdout, @stderr) }
       err_output = @stderr.read
 
       assert_includes err.to_s, err_output
-      exp = "error dropping #{Ardb.config.db.database.inspect} database"
+      exp = "error dropping #{Ardb.config.database.inspect} database"
       assert_includes exp, err_output
     end
-
   end
 
-  class MigrateCommandTests < UnitTests
-    desc "MigrateCommand"
+  class GenerateMigrationCommandTests < CommandSetupTests
+    desc "GenerateMigrationCommand"
     setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
+      @identifier = Factory.migration_id
 
-      @ardb_init_called = false
-      Assert.stub(Ardb, :init){ @ardb_init_called = true }
+      @migration_spy   = nil
+      @migration_class = Ardb::Migration
+      Assert.stub(@migration_class, :new) do |*args|
+        @migration_spy = MigrationSpy.new(*args)
+      end
 
-      @command_class = MigrateCommand
-      @cmd = @command_class.new([], @stdout, @stderr)
+      @command_class = GenerateMigrationCommand
+      @cmd = @command_class.new
     end
-    subject{ @cmd }
 
-    should have_readers :clirb
+    should "be a valid command" do
+      assert_kind_of ValidCommand, subject
+    end
 
-    should "know its CLI.RB" do
-      assert_instance_of Ardb::CLIRB, subject.clirb
+    should "know its command name and summary" do
+      exp = "generate-migration"
+      assert_equal exp, subject.command_name
+
+      exp = "Generate a MIGRATION-NAME migration file"
+      assert_equal exp, subject.command_summary
     end
 
-    should "know its help" do
-      exp = "Usage: ardb migrate [options]\n\n" \
-            "Options: #{subject.clirb}"
-      assert_equal exp, subject.help
+    should "init ardb and save a migration for the identifier when run" do
+      subject.run([@identifier], @stdout, @stderr)
+
+      assert_equal [false],     @ardb_init_called_with
+      assert_equal Ardb.config, @migration_spy.ardb_config
+      assert_equal @identifier, @migration_spy.identifier
+      assert_true @migration_spy.save_called
+
+      exp = "generated #{@migration_spy.file_path}\n"
+      assert_equal exp, @stdout.read
     end
 
-    should "parse its args, init ardb and migrate the db, dump schema on run" do
-      subject.run
+    should "re-raise a specific argument error on migration \"no identifer\" errors" do
+      Assert.stub(@migration_class, :new){ raise Ardb::Migration::NoIdentifierError }
+      err = nil
+      begin
+        cmd = @command_class.new
+        cmd.run([])
+      rescue ArgumentError => err
+      end
 
-      assert_equal [], subject.clirb.args
+      assert_not_nil err
+      exp = "MIGRATION-NAME must be provided"
+      assert_equal exp, err.message
+      assert_not_empty err.backtrace
+    end
 
-      assert_true @ardb_init_called
+    should "output any errors and raise an exit error when run" do
+      err = StandardError.new(Factory.string)
+      err.set_backtrace(Factory.integer(3).times.map{ Factory.path })
+      Assert.stub(@migration_class, :new){ raise err }
+
+      assert_raises(CommandExitError){ subject.run([@identifier], @stdout, @stderr) }
+      err_output = @stderr.read
+
+      assert_includes err.to_s,                 err_output
+      assert_includes err.backtrace.join("\n"), err_output
+
+      exp = "error generating migration"
+      assert_includes exp, err_output
+    end
+  end
+
+  class MigrateCommandTests < CommandSetupTests
+    desc "MigrateCommand"
+    setup do
+      @orig_env_var_migrate_no_schema = ENV["ARDB_MIGRATE_NO_SCHEMA"]
+      @command_class = MigrateCommand
+      @cmd = @command_class.new
+    end
+    teardown do
+      ENV["ARDB_MIGRATE_NO_SCHEMA"] = @orig_env_var_migrate_no_schema
+    end
+
+    should "be a migrate command" do
+      assert_kind_of MigrateCommandBehaviors, subject
+    end
+
+    should "know its command name and summary" do
+      exp = "migrate"
+      assert_equal exp, subject.command_name
+
+      exp = "Migrate the configured DB"
+      assert_equal exp, subject.command_summary
+    end
+
+    should "init ardb, migrate the db and dump the schema when run" do
+      subject.run([], @stdout, @stderr)
+
+      assert_equal [true], @ardb_init_called_with
       assert_true @adapter_spy.migrate_db_called?
       assert_true @adapter_spy.dump_schema_called?
     end
 
-    should "init ardb and only migrate on run with no schema dump env var set" do
-      current_no_schema = ENV['ARDB_MIGRATE_NO_SCHEMA']
-      ENV['ARDB_MIGRATE_NO_SCHEMA'] = 'yes'
-      subject.run
-      ENV['ARDB_MIGRATE_NO_SCHEMA'] = current_no_schema
+    should "only init ardb and migrate when run with no schema dump env var set" do
+      ENV["ARDB_MIGRATE_NO_SCHEMA"] = "yes"
+      subject.run([], @stdout, @stderr)
 
-      assert_true @ardb_init_called
+      assert_equal [true], @ardb_init_called_with
       assert_true @adapter_spy.migrate_db_called?
       assert_false @adapter_spy.dump_schema_called?
     end
 
-    should "output any errors and raise an exit error on run" do
+    should "output any errors and raise an exit error when run" do
       err = StandardError.new(Factory.string)
       err.set_backtrace(Factory.integer(3).times.map{ Factory.path })
-      Assert.stub(Ardb, :init){ raise err }
+      Assert.stub(@adapter_spy, :migrate_db){ raise err }
 
-      assert_raises(CommandExitError){ subject.run }
+      assert_raises(CommandExitError){ subject.run([], @stdout, @stderr) }
       err_output = @stderr.read
 
       assert_includes err.to_s,                 err_output
       assert_includes err.backtrace.join("\n"), err_output
 
-      exp = "error migrating #{Ardb.config.db.database.inspect} database"
+      exp = "error migrating #{Ardb.config.database.inspect} database"
       assert_includes exp, err_output
     end
-
   end
 
-  class GenerateMigrationCommandTests < UnitTests
-    desc "GenerateMigrationCommand"
+  class MigrateUpCommandTests < CommandSetupTests
+    desc "MigrateUpCommand"
     setup do
-      @migration_spy   = nil
-      @migration_class = Ardb::Migration
-      Assert.stub(@migration_class, :new) do |*args|
-        @migration_spy = MigrationSpy.new(*args)
-      end
+      @command_class = MigrateUpCommand
+      @cmd = @command_class.new
+    end
 
-      @command_class = GenerateMigrationCommand
-      @identifier    = Factory.migration_id
-      @cmd = @command_class.new([@identifier], @stdout, @stderr)
+    should "be a migrate command" do
+      assert_kind_of MigrateCommandBehaviors, subject
     end
-    subject{ @cmd }
 
-    should have_readers :clirb
+    should "know its command name and summary" do
+      exp = "migrate-up"
+      assert_equal exp, subject.command_name
 
-    should "know its CLI.RB" do
-      assert_instance_of Ardb::CLIRB, subject.clirb
+      exp = "Migrate the configured DB up"
+      assert_equal exp, subject.command_summary
     end
+  end
 
-    should "know its help" do
-      exp = "Usage: ardb generate-migration [options] MIGRATION-NAME\n\n" \
-            "Options: #{subject.clirb}"
-      assert_equal exp, subject.help
+  class MigrateDownCommandTests < CommandSetupTests
+    desc "MigrateDownCommand"
+    setup do
+      @command_class = MigrateDownCommand
+      @cmd = @command_class.new
     end
 
-    should "parse its args and save a migration for the identifier on run" do
-      subject.run
+    should "be a migrate command" do
+      assert_kind_of MigrateCommandBehaviors, subject
+    end
 
-      assert_equal [@identifier], subject.clirb.args
-      assert_equal @identifier,   @migration_spy.identifier
-      assert_true @migration_spy.save_called
+    should "know its command name and summary" do
+      exp = "migrate-down"
+      assert_equal exp, subject.command_name
 
-      exp = "generated #{@migration_spy.file_path}\n"
-      assert_equal exp, @stdout.read
+      exp = "Migrate the configured DB down"
+      assert_equal exp, subject.command_summary
     end
+  end
 
-    should "re-raise a specific argument error on migration 'no identifer' errors" do
-      Assert.stub(@migration_class, :new) { raise Ardb::Migration::NoIdentifierError }
-      err = nil
-      begin
-        cmd = @command_class.new([])
-        cmd.run
-      rescue ArgumentError => err
-      end
+  class MigrateForwardCommandTests < CommandSetupTests
+    desc "MigrateForwardCommand"
+    setup do
+      @command_class = MigrateForwardCommand
+      @cmd = @command_class.new
+    end
 
-      assert_not_nil err
-      exp = "MIGRATION-NAME must be provided"
-      assert_equal exp, err.message
-      assert_not_empty err.backtrace
+    should "be a migrate command" do
+      assert_kind_of MigrateCommandBehaviors, subject
     end
 
-    should "output any errors and raise an exit error on run" do
-      err = StandardError.new(Factory.string)
-      err.set_backtrace(Factory.integer(3).times.map{ Factory.path })
-      Assert.stub(@migration_class, :new){ raise err }
+    should "know its command name and summary" do
+      exp = "migrate-forward"
+      assert_equal exp, subject.command_name
 
-      assert_raises(CommandExitError){ subject.run }
-      err_output = @stderr.read
+      exp = "Migrate the configured DB forward"
+      assert_equal exp, subject.command_summary
+    end
+  end
 
-      assert_includes err.to_s,                 err_output
-      assert_includes err.backtrace.join("\n"), err_output
+  class MigrateBackwardCommandTests < CommandSetupTests
+    desc "MigrateBackwardCommand"
+    setup do
+      @command_class = MigrateBackwardCommand
+      @cmd = @command_class.new
+    end
 
-      exp = "error generating migration"
-      assert_includes exp, err_output
+    should "be a migrate command" do
+      assert_kind_of MigrateCommandBehaviors, subject
     end
 
+    should "know its command name and summary" do
+      exp = "migrate-backward"
+      assert_equal exp, subject.command_name
+
+      exp = "Migrate the configured DB backward"
+      assert_equal exp, subject.command_summary
+    end
   end
 
   class CLISpy
@@ -550,18 +650,27 @@ class Ardb::CLI
   end
 
   class CommandSpy
-    attr_reader :run_called
+    attr_reader :command_name, :argv, :stdout, :stderr, :run_called
 
-    def initialize
+    def initialize(command_name)
+      @command_name = command_name
+      @argv = nil
+      @stdout, @stderr = nil, nil
       @run_called = false
     end
 
-    def run
+    def run(argv, stdout = nil, stderr = nil)
+      @argv = argv
+      @stdout, @stderr = stdout, stderr
       @run_called = true
     end
 
-    def help
-      Factory.text
+    def command_summary
+      @command_summary ||= Factory.string
+    end
+
+    def command_help
+      @command_help ||= Factory.text
     end
   end
 
@@ -593,10 +702,11 @@ class Ardb::CLI
   end
 
   class MigrationSpy
-    attr_reader :identifier, :file_path, :save_called
+    attr_reader :ardb_config, :identifier, :file_path, :save_called
 
-    def initialize(*args)
-      @identifier  = args.first
+    def initialize(ardb_config, identifier)
+      @ardb_config = ardb_config
+      @identifier  = identifier
       @file_path   = Factory.path
       @save_called = false
     end
@@ -606,5 +716,4 @@ class Ardb::CLI
       self
     end
   end
-
 end