thor_dleavitt 0.18.1

data/spec/shell/color_spec.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+describe Thor::Shell::Color do
+  def shell
+    @shell ||= Thor::Shell::Color.new
+  end
+
+  before do
+    allow_any_instance_of(StringIO).to receive(:tty?).and_return(true)
+  end
+
+  describe "#say" do
+    it "set the color if specified and tty?" do
+      out = capture(:stdout) do
+        shell.say "Wow! Now we have colors!", :green
+      end
+
+      expect(out.chomp).to eq("\e[32mWow! Now we have colors!\e[0m")
+    end
+
+    it "does not set the color if output is not a tty" do
+      out = capture(:stdout) do
+        expect($stdout).to receive(:tty?).and_return(false)
+        shell.say "Wow! Now we have colors!", :green
+      end
+
+      expect(out.chomp).to eq("Wow! Now we have colors!")
+    end
+
+    it "does not use a new line even with colors" do
+      out = capture(:stdout) do
+        shell.say "Wow! Now we have colors! ", :green
+      end
+
+      expect(out.chomp).to eq("\e[32mWow! Now we have colors! \e[0m")
+    end
+
+    it "handles an Array of colors" do
+      out = capture(:stdout) do
+        shell.say "Wow! Now we have colors *and* background colors", [:green, :on_red, :bold]
+      end
+
+      expect(out.chomp).to eq("\e[32m\e[41m\e[1mWow! Now we have colors *and* background colors\e[0m")
+    end
+  end
+
+  describe "#say_status" do
+    it "uses color to say status" do
+      out = capture(:stdout) do
+        shell.say_status :conflict, "README", :red
+      end
+
+      expect(out.chomp).to eq("\e[1m\e[31m    conflict\e[0m  README")
+    end
+  end
+
+  describe "#set_color" do
+    it "colors a string with a foreground color" do
+      red = shell.set_color "hi!", :red
+      expect(red).to eq("\e[31mhi!\e[0m")
+    end
+
+    it "colors a string with a background color" do
+      on_red = shell.set_color "hi!", :white, :on_red
+      expect(on_red).to eq("\e[37m\e[41mhi!\e[0m")
+    end
+
+    it "colors a string with a bold color" do
+      bold = shell.set_color "hi!", :white, true
+      expect(bold).to eq("\e[1m\e[37mhi!\e[0m")
+
+      bold = shell.set_color "hi!", :white, :bold
+      expect(bold).to eq("\e[37m\e[1mhi!\e[0m")
+
+      bold = shell.set_color "hi!", :white, :on_red, :bold
+      expect(bold).to eq("\e[37m\e[41m\e[1mhi!\e[0m")
+    end
+  end
+
+  describe "#file_collision" do
+    describe "when a block is given" do
+      it "invokes the diff command" do
+        allow($stdout).to receive(:print)
+        allow($stdout).to receive(:tty?).and_return(true)
+        expect($stdin).to receive(:gets).and_return('d')
+        expect($stdin).to receive(:gets).and_return('n')
+
+        output = capture(:stdout) { shell.file_collision('spec/fixtures/doc/README'){ "README\nEND\n" } }
+        expect(output).to match(/\e\[31m\- __start__\e\[0m/)
+        expect(output).to match(/^  README/)
+        expect(output).to match(/\e\[32m\+ END\e\[0m/)
+      end
+    end
+  end
+end

data/spec/shell/html_spec.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+describe Thor::Shell::HTML do
+  def shell
+    @shell ||= Thor::Shell::HTML.new
+  end
+
+  describe "#say" do
+    it "sets the color if specified" do
+      out = capture(:stdout) { shell.say "Wow! Now we have colors!", :green }
+      expect(out.chomp).to eq('<span style="color: green;">Wow! Now we have colors!</span>')
+    end
+
+    it "sets bold if specified" do
+      out = capture(:stdout) { shell.say "Wow! Now we have colors *and* bold!", [:green, :bold] }
+      expect(out.chomp).to eq('<span style="color: green; font-weight: bold;">Wow! Now we have colors *and* bold!</span>')
+    end
+
+    it "does not use a new line even with colors" do
+      out = capture(:stdout) { shell.say "Wow! Now we have colors! ", :green }
+      expect(out.chomp).to eq('<span style="color: green;">Wow! Now we have colors! </span>')
+    end
+  end
+
+  describe "#say_status" do
+    it "uses color to say status" do
+      expect($stdout).to receive(:print).with("<span style=\"color: red; font-weight: bold;\">    conflict</span>  README\n")
+      shell.say_status :conflict, "README", :red
+    end
+  end
+end

data/spec/shell_spec.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+describe Thor::Shell do
+  def shell
+    @shell ||= Thor::Base.shell.new
+  end
+
+  describe "#initialize" do
+    it "sets shell value" do
+      base = MyCounter.new [1, 2], { }, :shell => shell
+      expect(base.shell).to eq(shell)
+    end
+
+    it "sets the base value on the shell if an accessor is available" do
+      base = MyCounter.new [1, 2], { }, :shell => shell
+      expect(shell.base).to eq(base)
+    end
+  end
+
+  describe "#shell" do
+    it "returns the shell in use" do
+      expect(MyCounter.new([1,2]).shell).to be_kind_of(Thor::Base.shell)
+    end
+
+    it "uses $THOR_SHELL" do
+      class Thor::Shell::TestShell < Thor::Shell::Basic; end
+
+      expect(Thor::Base.shell).to eq(shell.class)
+      ENV['THOR_SHELL'] = 'TestShell'
+      Thor::Base.shell = nil
+      expect(Thor::Base.shell).to eq(Thor::Shell::TestShell)
+      ENV['THOR_SHELL'] = ''
+      Thor::Base.shell = shell.class
+      expect(Thor::Base.shell).to eq(shell.class)
+    end
+  end
+
+  describe "with_padding" do
+    it "uses padding for inside block outputs" do
+      base = MyCounter.new([1,2])
+      base.with_padding do
+        expect(capture(:stdout) { base.say_status :padding, "cool" }.strip).to eq("padding    cool")
+      end
+    end
+  end
+
+end

data/spec/subcommand_spec.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+describe Thor do
+
+  describe "#subcommand" do
+
+    it "maps a given subcommand to another Thor subclass" do
+      barn_help = capture(:stdout) { Scripts::MyDefaults.start(%w[barn]) }
+      expect(barn_help).to include("barn help [COMMAND]  # Describe subcommands or one specific subcommand")
+    end
+
+    it "passes commands to subcommand classes" do
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn open]) }.strip).to eq("Open sesame!")
+    end
+
+    it "passes arguments to subcommand classes" do
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn open shotgun]) }.strip).to eq("That's going to leave a mark.")
+    end
+
+    it "ignores unknown options (the subcommand class will handle them)" do
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn paint blue --coats 4])}.strip).to eq("4 coats of blue paint")
+    end
+
+    it "passes parsed options to subcommands" do
+      output = capture(:stdout) { TestSubcommands::Parent.start(%w[sub print_opt --opt output]) }
+      expect(output).to eq("output")
+    end
+  end
+
+end

data/spec/thor_spec.rb

@@ -0,0 +1,499 @@
+require 'helper'
+
+describe Thor do
+  describe "#method_option" do
+    it "sets options to the next method to be invoked" do
+      args = ["foo", "bar", "--force"]
+      arg, options = MyScript.start(args)
+      expect(options).to eq({ "force" => true })
+    end
+
+    describe ":lazy_default" do
+      it "is absent when option is not specified" do
+        arg, options = MyScript.start(["with_optional"])
+        expect(options).to eq({})
+      end
+
+      it "sets a default that can be overridden for strings" do
+        arg, options = MyScript.start(["with_optional", "--lazy"])
+        expect(options).to eq({ "lazy" => "yes" })
+
+        arg, options = MyScript.start(["with_optional", "--lazy", "yesyes!"])
+        expect(options).to eq({ "lazy" => "yesyes!" })
+      end
+
+      it "sets a default that can be overridden for numerics" do
+        arg, options = MyScript.start(["with_optional", "--lazy-numeric"])
+        expect(options).to eq({ "lazy_numeric" => 42 })
+
+        arg, options = MyScript.start(["with_optional", "--lazy-numeric", 20000])
+        expect(options).to eq({ "lazy_numeric" => 20000 })
+      end
+
+      it "sets a default that can be overridden for arrays" do
+        arg, options = MyScript.start(["with_optional", "--lazy-array"])
+        expect(options).to eq({ "lazy_array" => %w[eat at joes] })
+
+        arg, options = MyScript.start(["with_optional", "--lazy-array", "hello", "there"])
+        expect(options).to eq({ "lazy_array" => %w[hello there] })
+      end
+
+      it "sets a default that can be overridden for hashes" do
+        arg, options = MyScript.start(["with_optional", "--lazy-hash"])
+        expect(options).to eq({ "lazy_hash" => {'swedish' => 'meatballs'} })
+
+        arg, options = MyScript.start(["with_optional", "--lazy-hash", "polish:sausage"])
+        expect(options).to eq({ "lazy_hash" => {'polish' => 'sausage'} })
+      end
+    end
+
+    describe "when :for is supplied" do
+      it "updates an already defined command" do
+        args, options = MyChildScript.start(["animal", "horse", "--other=fish"])
+        expect(options[:other]).to eq("fish")
+      end
+
+      describe "and the target is on the parent class" do
+        it "updates an already defined command" do
+          args = ["example_default_command", "my_param", "--new-option=verified"]
+          options = Scripts::MyScript.start(args)
+          expect(options[:new_option]).to eq("verified")
+        end
+
+        it "adds a command to the command list if the updated command is on the parent class" do
+          expect(Scripts::MyScript.commands["example_default_command"]).to be
+        end
+
+        it "clones the parent command" do
+          expect(Scripts::MyScript.commands["example_default_command"]).not_to eq(MyChildScript.commands["example_default_command"])
+        end
+      end
+    end
+  end
+
+  describe "#default_command" do
+    it "sets a default command" do
+      expect(MyScript.default_command).to eq("example_default_command")
+    end
+
+    it "invokes the default command if no command is specified" do
+      expect(MyScript.start([])).to eq("default command")
+    end
+
+    it "invokes the default command if no command is specified even if switches are given" do
+      expect(MyScript.start(["--with", "option"])).to eq({"with"=>"option"})
+    end
+
+    it "inherits the default command from parent" do
+      expect(MyChildScript.default_command).to eq("example_default_command")
+    end
+  end
+
+  describe "#stop_on_unknown_option!" do
+    my_script = Class.new(Thor) do
+      class_option "verbose",   :type => :boolean
+      class_option "mode",      :type => :string
+
+      stop_on_unknown_option! :exec
+
+      desc "exec", "Run a command"
+      def exec(*args)
+        return options, args
+      end
+
+      desc "boring", "An ordinary command"
+      def boring(*args)
+        return options, args
+      end
+    end
+
+    it "passes remaining args to command when it encounters a non-option" do
+      expect(my_script.start(%w[exec command --verbose])).to eq [{}, ["command", "--verbose"]]
+    end
+
+    it "passes remaining args to command when it encounters an unknown option" do
+      expect(my_script.start(%w[exec --foo command --bar])).to eq [{}, ["--foo", "command", "--bar"]]
+    end
+
+    it "still accepts options that are given before non-options" do
+      expect(my_script.start(%w[exec --verbose command --foo])).to eq [{"verbose" => true}, ["command", "--foo"]]
+    end
+
+    it "still accepts options that require a value" do
+      expect(my_script.start(%w[exec --mode rashly command])).to eq [{"mode" => "rashly"}, ["command"]]
+    end
+
+    it "still passes everything after -- to command" do
+      expect(my_script.start(%w[exec -- --verbose])).to eq [{}, ["--verbose"]]
+    end
+
+    it "does not affect ordinary commands"  do
+      expect(my_script.start(%w[boring command --verbose])).to eq [{"verbose" => true}, ["command"]]
+    end
+
+    context "when provided with multiple command names" do
+      klass = Class.new(Thor) do
+        stop_on_unknown_option! :foo, :bar
+      end
+      it "affects all specified commands" do
+        expect(klass.stop_on_unknown_option?(double(:name => "foo"))).to be_true
+        expect(klass.stop_on_unknown_option?(double(:name => "bar"))).to be_true
+        expect(klass.stop_on_unknown_option?(double(:name => "baz"))).to be_false
+      end
+    end
+
+    context "when invoked several times" do
+      klass = Class.new(Thor) do
+        stop_on_unknown_option! :foo
+        stop_on_unknown_option! :bar
+      end
+      it "affects all specified commands" do
+        expect(klass.stop_on_unknown_option?(double(:name => "foo"))).to be_true
+        expect(klass.stop_on_unknown_option?(double(:name => "bar"))).to be_true
+        expect(klass.stop_on_unknown_option?(double(:name => "baz"))).to be_false
+      end
+    end
+
+    it "doesn't break new" do
+      expect(my_script.new).to be_a(Thor)
+    end
+  end
+
+  describe "#map" do
+    it "calls the alias of a method if one is provided" do
+      expect(MyScript.start(["-T", "fish"])).to eq(["fish"])
+    end
+
+    it "calls the alias of a method if several are provided via #map" do
+      expect(MyScript.start(["-f", "fish"])).to eq(["fish", {}])
+      expect(MyScript.start(["--foo", "fish"])).to eq(["fish", {}])
+    end
+
+    it "inherits all mappings from parent" do
+      expect(MyChildScript.default_command).to eq("example_default_command")
+    end
+  end
+
+  describe "#package_name" do
+    it "provides a proper description for a command when the package_name is assigned" do
+      content = capture(:stdout) { PackageNameScript.start(["help"]) }
+      expect(content).to match(/Baboon commands:/m)
+    end
+
+    # TODO: remove this, might be redundant, just wanted to prove full coverage
+    it "provides a proper description for a command when the package_name is NOT assigned" do
+      content = capture(:stdout) { MyScript.start(["help"]) }
+      expect(content).to match(/Commands:/m)
+    end
+  end
+
+  describe "#desc" do
+    it "provides description for a command" do
+      content = capture(:stdout) { MyScript.start(["help"]) }
+      expect(content).to match(/thor my_script:zoo\s+# zoo around/m)
+    end
+
+    it "provides no namespace if $thor_runner is false" do
+      begin
+        $thor_runner = false
+        content = capture(:stdout) { MyScript.start(["help"]) }
+        expect(content).to match(/thor zoo\s+# zoo around/m)
+      ensure
+        $thor_runner = true
+      end
+    end
+
+    describe "when :for is supplied" do
+      it "overwrites a previous defined command" do
+        expect(capture(:stdout) { MyChildScript.start(["help"]) }).to match(/animal KIND \s+# fish around/m)
+      end
+    end
+
+    describe "when :hide is supplied" do
+      it "does not show the command in help" do
+        expect(capture(:stdout) { MyScript.start(["help"]) }).not_to match(/this is hidden/m)
+      end
+
+      it "but the command is still invokable, does not show the command in help" do
+        expect(MyScript.start(["hidden", "yesyes"])).to eq(["yesyes"])
+      end
+    end
+  end
+
+  describe "#method_options" do
+    it "sets default options if called before an initializer" do
+      options = MyChildScript.class_options
+      expect(options[:force].type).to eq(:boolean)
+      expect(options[:param].type).to eq(:numeric)
+    end
+
+    it "overwrites default options if called on the method scope" do
+      args = ["zoo", "--force", "--param", "feathers"]
+      options = MyChildScript.start(args)
+      expect(options).to eq({ "force" => true, "param" => "feathers" })
+    end
+
+    it "allows default options to be merged with method options" do
+      args = ["animal", "bird", "--force", "--param", "1.0", "--other", "tweets"]
+      arg, options = MyChildScript.start(args)
+      expect(arg).to eq('bird')
+      expect(options).to eq({ "force"=>true, "param"=>1.0, "other"=>"tweets" })
+    end
+  end
+
+  describe "#start" do
+    it "calls a no-param method when no params are passed" do
+      expect(MyScript.start(["zoo"])).to eq(true)
+    end
+
+    it "calls a single-param method when a single param is passed" do
+      expect(MyScript.start(["animal", "fish"])).to eq(["fish"])
+    end
+
+    it "does not set options in attributes" do
+      expect(MyScript.start(["with_optional", "--all"])).to eq([nil, { "all" => true }, []])
+    end
+
+    it "raises an error if the wrong number of params are provided" do
+      arity_asserter = lambda do |args, msg|
+        stderr = capture(:stderr) { Scripts::Arities.start(args) }
+        expect(stderr.strip).to eq(msg)
+      end
+      arity_asserter.call ["zero_args",    "one"         ], %Q'ERROR: "thor zero_args" was called with arguments ["one"]\nUsage: "thor scripts:arities:zero_args"'
+      arity_asserter.call ["one_arg"                     ], %Q'ERROR: "thor one_arg" was called with no arguments\nUsage: "thor scripts:arities:one_arg ARG"'
+      arity_asserter.call ["one_arg",      "one", "two"  ], %Q'ERROR: "thor one_arg" was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:one_arg ARG"'
+      arity_asserter.call ["one_arg",      "one", "two"  ], %Q'ERROR: "thor one_arg" was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:one_arg ARG"'
+      arity_asserter.call ["two_args",     "one"         ], %Q'ERROR: "thor two_args" was called with arguments ["one"]\nUsage: "thor scripts:arities:two_args ARG1 ARG2"'
+      arity_asserter.call ["optional_arg", "one", "two"  ], %Q'ERROR: "thor optional_arg" was called with arguments ["one", "two"]\nUsage: "thor scripts:arities:optional_arg [ARG]"'
+    end
+
+    it "raises an error if the invoked command does not exist" do
+      expect(capture(:stderr) { Amazing.start(["animal"]) }.strip).to eq('Could not find command "animal" in "amazing" namespace.')
+    end
+
+    it "calls method_missing if an unknown method is passed in" do
+      expect(MyScript.start(["unk", "hello"])).to eq([:unk, ["hello"]])
+    end
+
+    it "does not call a private method no matter what" do
+      expect(capture(:stderr) { MyScript.start(["what"]) }.strip).to eq('Could not find command "what" in "my_script" namespace.')
+    end
+
+    it "uses command default options" do
+      options = MyChildScript.start(["animal", "fish"]).last
+      expect(options).to eq({ "other" => "method default" })
+    end
+
+    it "raises when an exception happens within the command call" do
+      expect{ MyScript.start(["call_myself_with_wrong_arity"]) }.to raise_error(ArgumentError)
+    end
+
+    context "when the user enters an unambiguous substring of a command" do
+      it "invokes a command" do
+        expect(MyScript.start(["z"])).to eq(MyScript.start(["zoo"]))
+      end
+
+      it "invokes a command, even when there's an alias it resolves to the same command" do
+        expect(MyScript.start(["hi", "arg"])).to eq(MyScript.start(["hidden", "arg"]))
+      end
+
+      it "invokes an alias" do
+        expect(MyScript.start(["animal_pri"])).to eq(MyScript.start(["zoo"]))
+      end
+    end
+
+    context "when the user enters an ambiguous substring of a command" do
+      it "raises an exception and displays a message that explains the ambiguity" do
+        shell = Thor::Base.shell.new
+        expect(shell).to receive(:error).with('Ambiguous command call matches [call_myself_with_wrong_arity, call_unexistent_method]')
+        MyScript.start(["call"], :shell => shell)
+      end
+
+      it "raises an exception when there is an alias" do
+        shell = Thor::Base.shell.new
+        expect(shell).to receive(:error).with('Ambiguous command f matches [foo, fu]')
+        MyScript.start(["f"], :shell => shell)
+      end
+    end
+
+  end
+
+  describe "#help" do
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+
+    describe "on general" do
+      before do
+        @content = capture(:stdout) { MyScript.help(shell) }
+      end
+
+      it "provides useful help info for the help method itself" do
+        expect(@content).to match(/help \[COMMAND\]\s+# Describe available commands/)
+      end
+
+      it "provides useful help info for a method with params" do
+        expect(@content).to match(/animal TYPE\s+# horse around/)
+      end
+
+      it "uses the maximum terminal size to show commands" do
+        expect(@shell).to receive(:terminal_width).and_return(80)
+        content = capture(:stdout) { MyScript.help(shell) }
+        expect(content).to match(/aaa\.\.\.$/)
+      end
+
+      it "provides description for commands from classes in the same namespace" do
+        expect(@content).to match(/baz\s+# do some bazing/)
+      end
+
+      it "shows superclass commands" do
+        content = capture(:stdout) { MyChildScript.help(shell) }
+        expect(content).to match(/foo BAR \s+# do some fooing/)
+      end
+
+      it "shows class options information" do
+        content = capture(:stdout) { MyChildScript.help(shell) }
+        expect(content).to match(/Options\:/)
+        expect(content).to match(/\[\-\-param=N\]/)
+      end
+
+      it "injects class arguments into default usage" do
+        content = capture(:stdout) { Scripts::MyScript.help(shell) }
+        expect(content).to match(/zoo ACCESSOR \-\-param\=PARAM/)
+      end
+    end
+
+    describe "for a specific command" do
+      it "provides full help info when talking about a specific command" do
+        expect(capture(:stdout) { MyScript.command_help(shell, "foo") }).to eq(<<-END)
+Usage:
+  thor my_script:foo BAR
+
+Options:
+  [--force]  # Force to do some fooing
+
+do some fooing
+  This is more info!
+  Everyone likes more info!
+END
+      end
+
+      it "raises an error if the command can't be found" do
+        expect {
+          MyScript.command_help(shell, "unknown")
+        }.to raise_error(Thor::UndefinedCommandError, 'Could not find command "unknown" in "my_script" namespace.')
+      end
+
+      it "normalizes names before claiming they don't exist" do
+        expect(capture(:stdout) { MyScript.command_help(shell, "name-with-dashes") }).to match(/thor my_script:name-with-dashes/)
+      end
+
+      it "uses the long description if it exists" do
+        expect(capture(:stdout) { MyScript.command_help(shell, "long_description") }).to eq(<<-HELP)
+Usage:
+  thor my_script:long_description
+
+Description:
+  This is a really really really long description. Here you go. So very long.
+
+  It even has two paragraphs.
+HELP
+      end
+
+      it "doesn't assign the long description to the next command without one" do
+        expect(capture(:stdout) {
+          MyScript.command_help(shell, "name_with_dashes")
+        }).not_to match(/so very long/i)
+      end
+    end
+
+    describe "instance method" do
+      it "calls the class method" do
+        expect(capture(:stdout) { MyScript.start(["help"]) }).to match(/Commands:/)
+      end
+
+      it "calls the class method" do
+        expect(capture(:stdout) { MyScript.start(["help", "foo"]) }).to match(/Usage:/)
+      end
+    end
+  end
+
+  describe "when creating commands" do
+    it "prints a warning if a public method is created without description or usage" do
+      expect(capture(:stdout) {
+        klass = Class.new(Thor)
+        klass.class_eval "def hello_from_thor; end"
+      }).to match(/\[WARNING\] Attempted to create command "hello_from_thor" without usage or description/)
+    end
+
+    it "does not print if overwriting a previous command" do
+      expect(capture(:stdout) {
+        klass = Class.new(Thor)
+        klass.class_eval "def help; end"
+      }).to be_empty
+    end
+  end
+
+  describe "edge-cases" do
+    it "can handle boolean options followed by arguments" do
+      klass = Class.new(Thor) do
+        method_option :loud, :type => :boolean
+        desc "hi NAME", "say hi to name"
+        def hi(name)
+          name.upcase! if options[:loud]
+          "Hi #{name}"
+        end
+      end
+
+      expect(klass.start(["hi", "jose"])).to eq("Hi jose")
+      expect(klass.start(["hi", "jose", "--loud"])).to eq("Hi JOSE")
+      expect(klass.start(["hi", "--loud", "jose"])).to eq("Hi JOSE")
+    end
+
+    it "passes through unknown options" do
+      klass = Class.new(Thor) do
+        desc "unknown", "passing unknown options"
+        def unknown(*args)
+          args
+        end
+      end
+
+      expect(klass.start(["unknown", "foo", "--bar", "baz", "bat", "--bam"])).to eq(["foo", "--bar", "baz", "bat", "--bam"])
+      expect(klass.start(["unknown", "--bar", "baz"])).to eq(["--bar", "baz"])
+    end
+
+    it "does not pass through unknown options with strict args" do
+      klass = Class.new(Thor) do
+        strict_args_position!
+
+        desc "unknown", "passing unknown options"
+        def unknown(*args)
+          args
+        end
+      end
+
+      expect(klass.start(["unknown", "--bar", "baz"])).to eq([])
+      expect(klass.start(["unknown", "foo", "--bar", "baz"])).to eq(["foo"])
+    end
+
+    it "strict args works in the inheritance chain" do
+      parent = Class.new(Thor) do
+        strict_args_position!
+      end
+
+      klass = Class.new(parent) do
+        desc "unknown", "passing unknown options"
+        def unknown(*args)
+          args
+        end
+      end
+
+      expect(klass.start(["unknown", "--bar", "baz"])).to eq([])
+      expect(klass.start(["unknown", "foo", "--bar", "baz"])).to eq(["foo"])
+    end
+
+    it "send as a command name" do
+      expect(MyScript.start(["send"])).to eq(true)
+    end
+  end
+end