command_kit 0.4.1 → 0.5.1

data/spec/commands_spec.rb

@@ -1,865 +0,0 @@
-require 'spec_helper'
-require 'command_kit/commands'
-
-describe CommandKit::Commands do
-  module TestCommands
-    class TestEmptyCommands
-
-      include CommandKit::Commands
-
-    end
-
-    class TestCommands
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-      end
-
-      class Test2 < CommandKit::Command
-      end
-
-      command Test1
-      command Test2
-
-    end
-
-    class TestCommandsWithAliases
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-      end
-
-      class Test2 < CommandKit::Command
-      end
-
-      command Test1, aliases: %w[t1]
-      command Test2, aliases: %w[t2]
-
-    end
-
-    class TestCommandsWithExplicitNames
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-      end
-
-      class Test2 < CommandKit::Command
-      end
-
-      command 'command-name-1', Test1
-      command 'command-name-2', Test2
-
-    end
-
-    class TestCommandsWithExplicitNamesAndAliases
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-      end
-
-      class Test2 < CommandKit::Command
-      end
-
-      command 'command-name-1', Test1, aliases: %w[t1]
-      command 'command-name-2', Test2, aliases: %w[t2]
-
-    end
-
-    class TestCommandsWithExplicitSummaries
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-      end
-
-      class Test2 < CommandKit::Command
-      end
-
-      command Test1, summary: 'Explicit summary 1'
-      command Test2, summary: 'Explicit summary 2'
-
-    end
-
-    class TestCommandsWithCustomExitStatus
-
-      include CommandKit::Commands
-
-      class Test < CommandKit::Command
-
-        def run(*argv)
-          exit(2)
-        end
-
-      end
-
-      command Test
-
-    end
-
-    class TestCommandsWithGlobalOptions
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-      end
-
-      class Test2 < CommandKit::Command
-      end
-
-      option :foo, short: '-f',
-                   desc: "Global --foo option"
-
-      option :bar, short: '-b',
-                   value: {
-                     required: true,
-                     type: String,
-                     usage: 'BAR'
-                   },
-                   desc: "Global --bar option"
-
-      command Test1
-      command Test2
-
-    end
-
-    class TestCommandsWithCommandArguments
-
-      include CommandKit::Commands
-
-      class Test1 < CommandKit::Command
-        argument :arg1, required: false,
-                        desc: 'Argument 1'
-
-        argument :arg2, required: false,
-                        desc: 'Argument 2'
-      end
-
-      class Test2 < CommandKit::Command
-        argument :arg1, required: false,
-                        desc: 'Argument 1'
-
-        argument :arg2, required: false,
-                        desc: 'Argument 2'
-      end
-
-      command Test1
-      command Test2
-
-    end
-
-  end
-
-  let(:command_class) { TestCommands::TestCommands }
-
-  describe ".included" do
-    subject { command_class }
-
-    it "must set .usage to '[options] [COMMAND [ARGS...]]'" do
-      expect(subject.usage).to eq('[options] [COMMAND [ARGS...]]')
-    end
-
-    it "must add a 'command' argument" do
-      expect(subject.arguments[:command]).to_not be_nil
-      expect(subject.arguments[:command].required?).to be(false)
-      expect(subject.arguments[:command].desc).to eq('The command name to run')
-    end
-
-    it "must add a 'args' argument" do
-      expect(subject.arguments[:args]).to_not be_nil
-      expect(subject.arguments[:args].required?).to be(false)
-      expect(subject.arguments[:args].repeats?).to be(true)
-      expect(subject.arguments[:args].desc).to eq('Additional arguments for the command')
-    end
-
-    it "must add a 'help' command" do
-      expect(subject.commands['help']).to_not be(nil)
-      expect(subject.commands['help'].command).to be(described_class::Help)
-    end
-  end
-
-  describe ".commands" do
-    subject { command_class }
-
-    it "must return a Hash" do
-      expect(subject.commands).to be_kind_of(Hash)
-    end
-
-    it "must provide a default 'help' command" do
-      expect(subject.commands['help']).to_not be_nil
-      expect(subject.commands['help'].command).to eq(CommandKit::Commands::Help)
-    end
-
-    context "when additional commands are defined in a superclass" do
-      module TestCommands
-        class TestInheritedCommands < TestCommands
-
-          class Test3 < CommandKit::Command
-
-            def run
-              puts 'test command three'
-            end
-
-          end
-
-          command :test3, Test3
-
-        end
-      end
-
-      let(:command_superclass) { TestCommands::TestCommands }
-      let(:command_class)      { TestCommands::TestInheritedCommands }
-
-      it "must inherit the superclass'es commands" do
-        expect(subject.commands['test1']).to eq(command_superclass.commands['test1'])
-        expect(subject.commands['test2']).to eq(command_superclass.commands['test2'])
-      end
-
-      it "must allow defining additional commands in the subclass" do
-        expect(subject.commands['test3']).to_not be_nil
-        expect(subject.commands['test3'].command).to eq(command_class::Test3)
-      end
-
-      it "must not change the superclass'es commands" do
-        expect(command_superclass.commands['test3']).to be(nil)
-      end
-    end
-  end
-
-  describe ".command_aliases" do
-    subject { command_class }
-
-    it "must return an empty Hash by default" do
-      expect(subject.command_aliases).to eq({})
-    end
-
-    context "when commands have aliases" do
-      let(:command_class) { TestCommands::TestCommandsWithAliases }
-
-      it "must contain the mapping of aliases to command names" do
-      expect(subject.command_aliases).to eq({
-        't1' => 'test1',
-        't2' => 'test2'
-      })
-      end
-    end
-
-    context "when additional command aliases are defined in a superclass" do
-      module TestCommands
-        class TestInheritedCommandsWithAliases < TestCommandsWithAliases
-
-          class Test3 < CommandKit::Command
-
-            def run
-              puts 'test command three'
-            end
-
-          end
-
-          command :test3, Test3, aliases: %w[t3]
-
-        end
-      end
-
-      let(:command_superclass) { TestCommands::TestCommandsWithAliases }
-      let(:command_class)      { TestCommands::TestInheritedCommandsWithAliases }
-
-      it "must inherit the superclass'es command aliases" do
-        expect(subject.command_aliases['t1']).to eq(command_superclass.command_aliases['t1'])
-        expect(subject.command_aliases['t2']).to eq(command_superclass.command_aliases['t2'])
-      end
-
-      it "must allow defining additional command aliases in the subclass" do
-        expect(subject.command_aliases['t3']).to eq('test3')
-      end
-
-      it "must not change the superclass'es command aliases" do
-        expect(command_superclass.command_aliases['test3']).to be(nil)
-      end
-    end
-  end
-
-  describe ".command" do
-    subject { command_class }
-
-    context "when given only a command class" do
-      module TestCommands
-        class TestCommandWithOnlyACommandClass
-          include CommandKit::Commands
-
-          class Test < CommandKit::Command
-          end
-
-          command Test
-        end
-      end
-
-      let(:command_class) { TestCommands::TestCommandWithOnlyACommandClass }
-
-      it "must default the command name to the command class'es command_name" do
-        expect(subject.commands['test']).to_not be_nil
-        expect(subject.commands['test'].command).to eq(command_class::Test)
-      end
-
-      context "and aliases:" do
-        let(:command_class) { TestCommands::TestCommandsWithAliases }
-
-        it "must populate aliases with the aliases and the command names" do
-          expect(subject.command_aliases['t1']).to eq(command_class::Test1.command_name)
-          expect(subject.command_aliases['t2']).to eq(command_class::Test2.command_name)
-        end
-      end
-    end
-
-    context "when given a command name and a command class" do
-      let(:command_class) { TestCommands::TestCommandsWithExplicitNames }
-
-      it "must not add an entry for the command class'es command_name" do
-        expect(subject.commands['test1']).to be_nil
-        expect(subject.commands['test2']).to be_nil
-      end
-
-      it "must add an entry for the command name" do
-        expect(subject.commands['command-name-1']).to_not be_nil
-        expect(subject.commands['command-name-1'].command).to eq(command_class::Test1)
-
-        expect(subject.commands['command-name-2']).to_not be_nil
-        expect(subject.commands['command-name-2'].command).to eq(command_class::Test2)
-      end
-
-      context "and aliases:" do
-        let(:command_class) { TestCommands::TestCommandsWithExplicitNamesAndAliases }
-
-        it "must populate aliases with the aliases and the explicit command names" do
-          expect(subject.command_aliases['t1']).to eq('command-name-1')
-          expect(subject.command_aliases['t2']).to eq('command-name-2')
-        end
-      end
-
-      context "when the command name is a Symbol" do
-        module TestCommands
-          class TestCommandWithASymbolCommandName
-            include CommandKit::Commands
-
-            class Test < CommandKit::Command
-            end
-
-            command :test_sym, Test
-          end
-        end
-
-        let(:command_class) { TestCommands::TestCommandWithASymbolCommandName }
-
-        it "must not add an entry for the command class'es command_name" do
-          expect(subject.commands['test']).to be_nil
-        end
-
-        it "must not add entries with Symbol keys" do
-          expect(subject.commands.keys).to all(be_kind_of(String))
-        end
-
-        it "must convert the command name to a String" do
-          expect(subject.commands['test_sym']).to_not be_nil
-          expect(subject.commands['test_sym'].command).to eq(command_class::Test)
-        end
-      end
-    end
-
-    context "when given an explicit summary: keyword argument" do
-      let(:command_class) { TestCommands::TestCommandsWithExplicitSummaries }
-
-      it "must initialize the Subcommand#summary" do
-        expect(subject.commands['test1'].summary).to eq('Explicit summary 1')
-        expect(subject.commands['test2'].summary).to eq('Explicit summary 2')
-      end
-    end
-  end
-
-  describe ".get_command" do
-    subject { command_class }
-
-    context "when given a command name" do
-      let(:command_class) { TestCommands::TestCommands }
-
-      it "must return the command's class" do
-        expect(subject.get_command('test1')).to eq(command_class::Test1)
-        expect(subject.get_command('test2')).to eq(command_class::Test2)
-      end
-    end
-
-    context "when given a command's alias name" do
-      let(:command_class) { TestCommands::TestCommandsWithAliases }
-
-      it "must return the command's class associated with the alias" do
-        expect(subject.get_command('t1')).to eq(command_class::Test1)
-        expect(subject.get_command('t2')).to eq(command_class::Test2)
-      end
-    end
-
-    context "when given an unknown command name" do
-      it "must return nil" do
-        expect(subject.get_command('foo')).to be(nil)
-      end
-    end
-  end
-
-  subject { command_class.new }
-
-  describe "#command" do
-    module TestCommands
-      class TestSubCommandInitialization
-        include CommandKit::Commands
-
-        class Test < CommandKit::Command
-        end
-
-        command 'test', Test
-      end
-    end
-
-    let(:command_class) { TestCommands::TestSubCommandInitialization }
-    let(:subcommand_class) { command_class::Test }
-
-    context "when given a valid command name" do
-      it "must lookup the command and initialize it" do
-        expect(subject.command(subcommand_class.command_name)).to be_kind_of(subcommand_class)
-      end
-    end
-
-    context "when given a command alias" do
-      let(:command_class) { TestCommands::TestCommandsWithAliases }
-
-      it "must lookup the command and initialize it" do
-        expect(subject.command('t1')).to be_kind_of(command_class::Test1)
-        expect(subject.command('t2')).to be_kind_of(command_class::Test2)
-      end
-    end
-
-    context "when given an unknown command name" do
-      it "must return nil" do
-        expect(subject.command('foo')).to be_nil
-      end
-    end
-
-    context "when the command includes CommandKit::Commands::ParentCommand" do
-      module TestCommands
-        class TestSubCommandInitializationWithParentCommand
-          include CommandKit::Commands
-
-          class Test
-            include CommandKit::Commands::ParentCommand
-          end
-
-          command 'test', Test
-        end
-      end
-
-      let(:command_class) { TestCommands::TestSubCommandInitializationWithParentCommand }
-      let(:subcommand_class) { command_class::Test }
-
-      it "must initialize the sub-command with a parent_command value" do
-        subcommand = subject.command('test')
-
-        expect(subcommand.parent_command).to be(subject)
-      end
-    end
-
-    context "when the command includes CommandKit::CommandName" do
-      module TestCommands
-        class TestSubCommandInitializationWithCommandName
-          include CommandKit::Commands
-
-          class Test
-            include CommandKit::CommandName
-          end
-
-          command 'test', Test
-        end
-      end
-
-      let(:command_class) { TestCommands::TestSubCommandInitializationWithCommandName }
-      let(:subcommand_class) { command_class::Test }
-      let(:expected_subcommand_name) do
-        "#{command_class.command_name} #{subcommand_class.command_name}"
-      end
-
-      it "must initialize the sub-command with the command and subcommand name" do
-        subcommand = subject.command('test')
-
-        expect(subcommand.command_name).to eq(expected_subcommand_name)
-      end
-    end
-
-    context "when the command includes CommandKit::Stdio" do
-      module TestCommands
-        class TestSubCommandInitializationWithStdio
-          include CommandKit::Commands
-
-          class Test
-            include CommandKit::Stdio
-          end
-
-          command 'test', Test
-        end
-      end
-
-      let(:command_class) { TestCommands::TestSubCommandInitializationWithStdio }
-      let(:subcommand_class) { command_class::Test }
-
-      let(:stdin)  { StringIO.new }
-      let(:stdout) { StringIO.new }
-      let(:stderr) { StringIO.new }
-
-      subject do
-        command_class.new(stdin: stdin, stdout: stdout, stderr: stderr)
-      end
-
-      it "must initialize the sub-command with the command's #stdin, #stdout, #stderr" do
-        subcommand = subject.command('test')
-
-        expect(subcommand.stdin).to be(stdin)
-        expect(subcommand.stdout).to be(stdout)
-        expect(subcommand.stderr).to be(stderr)
-      end
-    end
-
-    context "when the command includes CommandKit::Env" do
-      module TestCommands
-        class TestSubCommandInitializationWithEnv
-          include CommandKit::Commands
-
-          class Test
-            include CommandKit::Env
-          end
-
-          command 'test', Test
-        end
-      end
-
-      let(:command_class) { TestCommands::TestSubCommandInitializationWithEnv }
-      let(:subcommand_class) { command_class::Test }
-
-      let(:env) { {'FOO' => 'bar'} }
-      subject { command_class.new(env: env) }
-
-      it "must initialize the sub-command with a copy of the command's #env" do
-        subcommand = subject.command('test')
-
-        expect(subcommand.env).to eq(env)
-        expect(subcommand.env).to_not be(env)
-      end
-    end
-
-    context "when the command includes CommandKit::Options" do
-      module TestCommands
-        class TestSubCommandInitializationWithOptions
-          include CommandKit::Commands
-
-          class Test
-            include CommandKit::Options
-          end
-
-          command 'test', Test
-        end
-      end
-
-      let(:command_class) { TestCommands::TestSubCommandInitializationWithOptions }
-      let(:subcommand_class) { command_class::Test }
-
-      let(:options) { {foo: 'bar'} }
-      subject { command_class.new(options: options) }
-
-      it "must initialize the sub-command with a copy of the command's #options Hash" do
-        subcommand = subject.command('test')
-
-        expect(subcommand.options).to eq(options)
-        expect(subcommand.options).to_not be(options)
-      end
-    end
-  end
-
-  describe "#invoke" do
-    context "when given a valid command name" do
-      let(:command_name) { 'test2' }
-      let(:argv) { %w[--opt arg1 arg2] }
-
-      it "must call the command's #main method with the given argv" do
-        expect_any_instance_of(command_class::Test2).to receive(:main).with(argv)
-
-        subject.invoke(command_name,*argv)
-      end
-
-      context "when the command returns a custom exit code" do
-        let(:command_class) { TestCommands::TestCommandsWithCustomExitStatus }
-
-        it "must return the exit code" do
-          expect(subject.invoke('test')).to eq(2)
-        end
-      end
-    end
-
-    context "when given an unknown command name" do
-      let(:command_name) { 'xxx' }
-      let(:argv) { %w[--opt arg1 arg2] }
-
-      it "must call #on_unknown_command with the given name and argv" do
-        expect(subject).to receive(:on_unknown_command).with(command_name,argv)
-
-        subject.invoke(command_name,*argv)
-      end
-    end
-  end
-
-  let(:unknown_command) { 'xxx' }
-
-  describe "#command_not_found" do
-    it "must print an error message to stderr and exit with 1" do
-      expect(subject).to receive(:exit).with(1)
-
-      expect { subject.command_not_found(unknown_command) }.to output(
-        "#{subject.command_name}: '#{unknown_command}' is not a #{subject.command_name} command. See `#{subject.command_name} help`" + $/
-      ).to_stderr
-    end
-  end
-
-  describe "#on_unknown_command" do
-    it "must call #command_not_found with the given command name by default" do
-      expect(subject).to receive(:command_not_found).with(unknown_command)
-
-      subject.on_unknown_command(unknown_command)
-    end
-  end
-
-  describe "#option_parser" do
-    let(:command_name) { 'test1'     }
-    let(:command_argv) { %w[foo bar baz] }
-    let(:argv) { [command_name, *command_argv] }
-
-    it "must stop before the first non-option argument" do
-      expect(subject.option_parser.parse(argv)).to eq(
-        [command_name, *command_argv]
-      )
-    end
-
-    context "when an unknown command name is given" do
-      let(:command_argv) { %w[bar baz] }
-      let(:argv) { ['foo', command_name, *command_argv] }
-
-      it "must stop before the first non-option argument" do
-        expect(subject.option_parser.parse(argv)).to eq(argv)
-      end
-    end
-
-    context "when additional global options are defined" do
-      let(:command_class) { TestCommands::TestCommandsWithGlobalOptions }
-      let(:bar) { '2' }
-      let(:argv) do
-        ['--foo', '--bar', bar.to_s, command_name, *command_argv]
-      end
-
-      it "must parse the global options, but stop before the first non-option associated argument" do
-        expect(subject.option_parser.parse(argv)).to eq(
-          [command_name, *command_argv]
-        )
-
-        expect(subject.options[:foo]).to be(true)
-        expect(subject.options[:bar]).to eq(bar)
-      end
-    end
-  end
-
-  describe "#run" do
-    context "when a command name is the first argument" do
-      let(:command) { 'test1' }
-      let(:exit_status) { 2 }
-
-      it "must invoke the command and exit with it's status" do
-        expect(subject).to receive(:invoke).with(command).and_return(exit_status)
-        expect(subject).to receive(:exit).with(exit_status)
-
-        subject.run(command)
-      end
-
-      context "when additional argv is given after the command name" do
-        let(:argv) { %w[--opt arg1 arg2] }
-
-        it "must pass the additional argv to the command" do
-          expect(subject).to receive(:invoke).with(command,*argv).and_return(exit_status)
-          expect(subject).to receive(:exit).with(exit_status)
-
-          subject.run(command,*argv)
-        end
-      end
-    end
-
-    context "when given no arguments" do
-      let(:exit_status) { 1 }
-
-      it "must default to calling #help and exit with 1" do
-        expect(subject).to receive(:help)
-        expect(subject).to receive(:exit).with(exit_status)
-
-        subject.run()
-      end
-    end
-  end
-
-  describe "#main" do
-    let(:command_class) { TestCommands::TestCommandsWithCommandArguments }
-
-    context "when a command name is the first argument" do
-      let(:command) { 'test1'   }
-      let(:argv)    { [command] }
-
-      it "must return 0" do
-        expect(subject.main(argv)).to eq(0)
-      end
-    end
-
-    context "when given additional command arguments" do
-      let(:argv) { %w[test1 arg1 arg2] }
-
-      it "must pass them to the command" do
-        expect(subject.main(argv)).to eq(0)
-      end
-    end
-
-    context "when given no arguments" do
-      let(:exit_status) { 1 }
-      let(:argv)        { %w[] }
-
-      it "must call #help and return 1" do
-        expect(subject).to receive(:help)
-
-        expect(subject.main(argv)).to eq(exit_status)
-      end
-    end
-  end
-
-  describe "#help_commands" do
-    it "must print usage and the list of available commands" do
-      expect { subject.help_commands }.to output(
-        [
-          "",
-          "Commands:",
-          "    help",
-          "    test1",
-          "    test2",
-          ""
-        ].join($/)
-      ).to_stdout
-    end
-
-    context "when the commands have custom names" do
-      let(:command_class) { TestCommands::TestCommandsWithExplicitNames }
-
-      it "must print the command names, not the command class'es #command_name" do
-        expect { subject.help_commands }.to output(
-          [
-            "",
-            "Commands:",
-            "    command-name-1",
-            "    command-name-2",
-            "    help",
-            ""
-          ].join($/)
-        ).to_stdout
-      end
-    end
-
-    context "when the commands have summaries" do
-      let(:command_class) { TestCommands::TestCommandsWithExplicitSummaries }
-
-      it "must print the command names and their summaries" do
-        expect { subject.help_commands }.to output(
-          [
-            "",
-            "Commands:",
-            "    help",
-            "    test1\t#{command_class.commands['test1'].summary}",
-            "    test2\t#{command_class.commands['test2'].summary}",
-            ""
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-
-  describe "#help" do
-    it "must print the list of available commands after other help output" do
-      expect { subject.help }.to output(
-        [
-          "Usage: #{subject.command_name} [options] [COMMAND [ARGS...]]",
-          "",
-          "Options:",
-          "    -h, --help                       Print help information",
-          "",
-          "Arguments:",
-          "    [COMMAND]                        The command name to run",
-          "    [ARGS ...]                       Additional arguments for the command",
-          "",
-          "Commands:",
-          "    help",
-          "    test1",
-          "    test2",
-          ""
-        ].join($/)
-      ).to_stdout
-    end
-
-    context "when the command has command alises" do
-      let(:command_class) { TestCommands::TestCommandsWithAliases }
-
-      it "must print the command names, along with their command aliases" do
-        expect { subject.help }.to output(
-          [
-            "Usage: #{subject.command_name} [options] [COMMAND [ARGS...]]",
-            "",
-            "Options:",
-            "    -h, --help                       Print help information",
-            "",
-            "Arguments:",
-            "    [COMMAND]                        The command name to run",
-            "    [ARGS ...]                       Additional arguments for the command",
-            "",
-            "Commands:",
-            "    help",
-            "    test1, t1",
-            "    test2, t2",
-            ""
-          ].join($/)
-        ).to_stdout
-      end
-    end
-
-    context "when the command defines additional global options" do
-      let(:command_class) { TestCommands::TestCommandsWithGlobalOptions }
-
-      it "must print any global options" do
-        expect { subject.help }.to output(
-          [
-            "Usage: #{subject.command_name} [options] [COMMAND [ARGS...]]",
-            "",
-            "Options:",
-            "    -f, --foo                        Global --foo option",
-            "    -b, --bar BAR                    Global --bar option",
-            "    -h, --help                       Print help information",
-            "",
-            "Arguments:",
-            "    [COMMAND]                        The command name to run",
-            "    [ARGS ...]                       Additional arguments for the command",
-            "",
-            "Commands:",
-            "    help",
-            "    test1",
-            "    test2",
-            ""
-          ].join($/)
-        ).to_stdout
-      end
-    end
-  end
-end