ardb 0.27.3 → 0.28.0

data/test/unit/cli_tests.rb

@@ -1,6 +1,7 @@
 require 'assert'
 require 'ardb/cli'
 
+require 'ardb'
 require 'ardb/adapter_spy'
 require 'ardb/migration'
 
@@ -9,10 +10,6 @@ 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 }
@@ -32,12 +29,11 @@ class Ardb::CLI
       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_instance_of ConnectCommand,           COMMANDS['connect']
+      assert_instance_of CreateCommand,            COMMANDS['create']
+      assert_instance_of DropCommand,              COMMANDS['drop']
+      assert_instance_of MigrateCommand,           COMMANDS['migrate']
+      assert_instance_of GenerateMigrationCommand, COMMANDS['generate-migration']
     end
 
   end
@@ -45,6 +41,10 @@ class Ardb::CLI
   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 }
@@ -59,18 +59,14 @@ class Ardb::CLI
       @argv = [@command_name, Factory.string]
 
       @command_class = Class.new
-      COMMANDS[@command_name] = @command_class
-
-      @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
+      Assert.stub(@command_class, :new){ @command_spy }
+      COMMANDS.add(@command_class, @command_name)
 
       @invalid_command = InvalidCommand.new(@command_name)
     end
     teardown do
-      COMMANDS.delete(@command_name)
+      COMMANDS.remove(@command_name)
     end
 
   end
@@ -85,10 +81,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
@@ -187,7 +179,7 @@ class Ardb::CLI
   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
 
@@ -213,263 +205,305 @@ class Ardb::CLI
     end
     subject{ @cmd }
 
-    should have_readers :name, :argv, :clirb
+    should have_readers :name, :clirb
     should have_imeths :new, :run, :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}"
+            "Options: #{subject.clirb}\n" \
+            "Commands:\n" \
+            "#{COMMANDS.to_s.split("\n").map{ |l| "  #{l}" }.join("\n")}\n"
       assert_equal exp, subject.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 }
 
-    should have_readers :clirb
+  end
+
+  class ValidCommandTests < CommandSetupTests
+    desc "ValidCommand"
+    setup do
+      @command_class = Class.new{ include ValidCommand }
+      @cmd = @command_class.new
+    end
+
+    should have_imeths :clirb, :run, :summary
 
     should "know its CLI.RB" do
-      assert_instance_of Ardb::CLIRB, subject.clirb
+      assert_instance_of CLIRB, subject.clirb
+    end
+
+    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 "default its summary" do
+      assert_equal '', subject.summary
+    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
+
+    should "know its summary" do
+      exp = "Connect to the configured DB"
+      assert_equal exp, subject.summary
     end
 
     should "know its help" do
       exp = "Usage: ardb connect [options]\n\n" \
-            "Options: #{subject.clirb}"
+            "Options: #{subject.clirb}\n" \
+            "Description:\n" \
+            "  #{subject.summary}"
       assert_equal exp, subject.help
     end
 
-    should "parse its args, init ardb and connect to the db on run" do
-      subject.run
-
-      assert_equal [], subject.clirb.args
+    should "init ardb and connect to the db when run" do
+      subject.run([], @stdout, @stderr)
 
-      assert_true @ardb_init_called
+      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}`\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 "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 summary" do
+      exp = "Create the configured DB"
+      assert_equal exp, subject.summary
     end
 
     should "know its help" do
       exp = "Usage: ardb create [options]\n\n" \
-            "Options: #{subject.clirb}"
+            "Options: #{subject.clirb}\n" \
+            "Description:\n" \
+            "  #{subject.summary}"
       assert_equal exp, subject.help
     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}`\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 "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 summary" do
+      exp = "Drop the configured DB"
+      assert_equal exp, subject.summary
     end
 
     should "know its help" do
       exp = "Usage: ardb drop [options]\n\n" \
-            "Options: #{subject.clirb}"
+            "Options: #{subject.clirb}\n" \
+            "Description:\n" \
+            "  #{subject.summary}"
       assert_equal exp, subject.help
     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}`\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
+  class MigrateCommandTests < CommandSetupTests
     desc "MigrateCommand"
     setup do
-      @adapter_spy = Class.new{ include Ardb::AdapterSpy }.new
-      Assert.stub(Ardb::Adapter, Ardb.config.db.adapter.to_sym){ @adapter_spy }
-
-      @ardb_init_called = false
-      Assert.stub(Ardb, :init){ @ardb_init_called = true }
-
+      @orig_env_var_migrate_no_schema = ENV['ARDB_MIGRATE_NO_SCHEMA']
       @command_class = MigrateCommand
-      @cmd = @command_class.new([], @stdout, @stderr)
+      @cmd = @command_class.new
+    end
+    teardown do
+      ENV['ARDB_MIGRATE_NO_SCHEMA'] = @orig_env_var_migrate_no_schema
     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 summary" do
+      exp = "Migrate the configured DB"
+      assert_equal exp, subject.summary
     end
 
     should "know its help" do
       exp = "Usage: ardb migrate [options]\n\n" \
-            "Options: #{subject.clirb}"
+            "Options: #{subject.clirb}\n" \
+            "Description:\n" \
+            "  #{subject.summary}"
       assert_equal exp, subject.help
     end
 
-    should "parse its args, init ardb and migrate the db, dump schema on run" do
-      subject.run
-
-      assert_equal [], subject.clirb.args
+    should "init ardb, migrate the db and dump the schema when run" do
+      subject.run([], @stdout, @stderr)
 
-      assert_true @ardb_init_called
+      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']
+    should "only init ardb and migrate when run with no schema dump env var set" do
       ENV['ARDB_MIGRATE_NO_SCHEMA'] = 'yes'
-      subject.run
-      ENV['ARDB_MIGRATE_NO_SCHEMA'] = current_no_schema
+      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
+  class GenerateMigrationCommandTests < CommandSetupTests
     desc "GenerateMigrationCommand"
     setup do
+      @identifier = Factory.migration_id
+
       @migration_spy   = nil
       @migration_class = Ardb::Migration
       Assert.stub(@migration_class, :new) do |*args|
@@ -477,28 +511,32 @@ class Ardb::CLI
       end
 
       @command_class = GenerateMigrationCommand
-      @identifier    = Factory.migration_id
-      @cmd = @command_class.new([@identifier], @stdout, @stderr)
+      @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 summary" do
+      exp = "Generate a migration file given a MIGRATION-NAME"
+      assert_equal exp, subject.summary
     end
 
     should "know its help" do
       exp = "Usage: ardb generate-migration [options] MIGRATION-NAME\n\n" \
-            "Options: #{subject.clirb}"
+            "Options: #{subject.clirb}\n" \
+            "Description:\n" \
+            "  #{subject.summary}"
       assert_equal exp, subject.help
     end
 
-    should "parse its args and save a migration for the identifier on run" do
-      subject.run
+    should "init ardb and save a migration for the identifier when run" do
+      subject.run([@identifier], @stdout, @stderr)
 
-      assert_equal [@identifier], subject.clirb.args
-      assert_equal @identifier,   @migration_spy.identifier
+      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"
@@ -506,11 +544,11 @@ class Ardb::CLI
     end
 
     should "re-raise a specific argument error on migration 'no identifer' errors" do
-      Assert.stub(@migration_class, :new) { raise Ardb::Migration::NoIdentifierError }
+      Assert.stub(@migration_class, :new){ raise Ardb::Migration::NoIdentifierError }
       err = nil
       begin
-        cmd = @command_class.new([])
-        cmd.run
+        cmd = @command_class.new
+        cmd.run([])
       rescue ArgumentError => err
       end
 
@@ -520,12 +558,12 @@ class Ardb::CLI
       assert_not_empty err.backtrace
     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(@migration_class, :new){ raise err }
 
-      assert_raises(CommandExitError){ subject.run }
+      assert_raises(CommandExitError){ subject.run([@identifier], @stdout, @stderr) }
       err_output = @stderr.read
 
       assert_includes err.to_s,                 err_output
@@ -550,18 +588,26 @@ class Ardb::CLI
   end
 
   class CommandSpy
-    attr_reader :run_called
+    attr_reader :argv, :stdout, :stderr, :run_called
 
     def initialize
+      @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 summary
+      @summary ||= Factory.string
+    end
+
     def help
-      Factory.text
+      @help ||= Factory.text
     end
   end
 
@@ -593,10 +639,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