gli 2.9.0 → 2.20.0

data/test/integration/gli_powered_app_test.rb

@@ -0,0 +1,52 @@
+require_relative "test_helper"
+require "open3"
+
+class GLIPoweredAppTest < MiniTest::Test
+  include TestHelper
+
+  def teardown
+    FileUtils.rm_f("todo.rdoc")
+  end
+
+  def test_help_works
+    out = run_app("help")
+    assert_top_level_help(out)
+  end
+
+  def test_unknown_command_exits_nonzero
+    out, err, status = run_app("asdfasdfasdf", expect_failure: true, return_err_and_status: true)
+    assert_match /Unknown command 'asdfasdfasdf'/,err
+    assert_equal 64, status.exitstatus
+    assert_top_level_help(out)
+  end
+
+  def test_unknown_switch_exits_nonzero
+    out, err, status = run_app("list --foo", expect_failure: true, return_err_and_status: true)
+    assert_match /Unknown option \-\-foo/,err
+    assert_equal 64, status.exitstatus
+    assert_match /COMMAND OPTIONS/, out
+  end
+
+  def test_missing_args_exits_nonzero
+    out, err, status = run_app("list", expect_failure: true, return_err_and_status: true)
+    assert_match /required_flag is required, required_flag2 is required/,err
+    assert_equal 64, status.exitstatus
+    assert_match /COMMAND OPTIONS/, out
+  end
+
+  def test_doc_generation
+    out, err, status = run_app("_doc", return_err_and_status: true)
+    assert File.exists?("todo.rdoc")
+  end
+
+private
+  def assert_top_level_help(out)
+    assert_match /SYNOPSIS/, out
+    assert_match /GLOBAL OPTIONS/, out
+    assert_match /COMMANDS/, out
+  end
+
+  def run_app(args="", return_err_and_status: false, expect_failure: false)
+    run_command("test/apps/todo/bin/todo",args,return_err_and_status:return_err_and_status,expect_failure:expect_failure)
+  end
+end

data/test/integration/scaffold_test.rb

@@ -0,0 +1,30 @@
+require_relative "test_helper"
+require "open3"
+
+class ScaffoldCommandTest < MiniTest::Test
+  include TestHelper
+
+  def test_scaffolded_app_has_reasonable_setup
+    FileUtils.rm_rf "scaffold_test"
+    run_gli("init scaffold_test")
+    assert Dir.exist? "scaffold_test"
+    FileUtils.chdir "scaffold_test" do
+      run_command("bundle install", "", return_err_and_status: false, expect_failure: false)
+
+      scaffold_lib = "lib:../lib"
+
+      # help works
+      out = run_command("bin/scaffold_test","--help", return_err_and_status: false, expect_failure: false, rubylib: scaffold_lib)
+      assert_match /SYNOPSIS/,out
+      assert_match /GLOBAL OPTIONS/,out
+      assert_match /COMMANDS/,out
+
+      # can run unit tests
+      out = run_command("bundle exec ","rake test", return_err_and_status: false, expect_failure: false, rubylib: scaffold_lib)
+      assert_match /0 failures/,out
+      assert_match /0 errors/,out
+      assert_match /0 skips/,out
+    end
+  end
+
+end

data/test/integration/test_helper.rb

@@ -0,0 +1,52 @@
+require "minitest/autorun"
+require "pathname"
+require "fileutils"
+
+# Copied from https://github.com/splattael/minitest-around
+# so as to avoid an explicit dependency
+Minitest::Test.class_eval do
+  alias_method :run_without_around, :run
+  def run(*args)
+    if defined?(around)
+      result = nil
+      around { result = run_without_around(*args) }
+      result
+    else
+      run_without_around(*args)
+    end
+  end
+end
+
+module TestHelper
+  def around(&block)
+    Bundler.with_original_env do
+      root = Pathname(__FILE__).dirname / ".." / ".."
+      FileUtils.chdir root do
+        block.()
+      end
+    end
+  end
+
+  def run_gli(args="", return_err_and_status: false, expect_failure: false)
+    run_command("bin/gli",args,return_err_and_status:return_err_and_status,expect_failure:expect_failure)
+  end
+
+  def run_command(command,args,return_err_and_status:,expect_failure:,rubylib:nil)
+    command_line_invocation = "#{command} #{args}"
+    env = {}
+    if !rubylib.nil?
+      env["RUBYLIB"] = rubylib
+    end
+    stdout_string, stderr_string, status = Open3.capture3(env,command_line_invocation)
+    if expect_failure
+      refute_equal 0,status.exitstatus,"Expected failure for '#{command_line_invocation}' but it succeeded"
+    else
+      assert_equal 0,status.exitstatus,"Expected success for '#{command_line_invocation}' but it failed:\n#{stdout_string}\n\n#{stderr_string}\n\n"
+    end
+    if return_err_and_status
+      [ stdout_string, stderr_string, status ]
+    else
+      stdout_string
+    end
+  end
+end

data/test/unit/command_finder_test.rb

@@ -0,0 +1,54 @@
+require_relative "test_helper"
+
+class CommandFinderTest < MiniTest::Test
+  include TestHelper
+
+  def setup
+    @app = CLIApp.new
+    [:status, :deployable, :some_command, :some_similar_command].each do |command|
+      @app.commands[command] = GLI::Command.new(:names => command)
+    end
+  end
+
+  def teardown
+  end
+
+  def test_unknown_command_name
+    assert_raises(GLI::UnknownCommand) do
+      GLI::CommandFinder.new(@app.commands, :default_command => :status).find_command(:unfindable_command)
+    end
+  end
+
+  def test_no_command_name_without_default
+    assert_raises(GLI::UnknownCommand) do
+      GLI::CommandFinder.new(@app.commands).find_command(nil)
+    end
+  end
+
+  def test_no_command_name_with_default
+    actual = GLI::CommandFinder.new(@app.commands, :default_command => :status).find_command(nil)
+    expected = @app.commands[:status]
+
+    assert_equal(actual, expected)
+  end
+
+  def test_ambigous_command
+    assert_raises(GLI::AmbiguousCommand) do
+      GLI::CommandFinder.new(@app.commands, :default_command => :status).find_command(:some)
+    end
+  end
+
+  def test_partial_name_with_autocorrect_enabled
+    actual = GLI::CommandFinder.new(@app.commands, :default_command => :status).find_command(:deploy)
+    expected = @app.commands[:deployable]
+
+    assert_equal(actual, expected)
+  end
+
+  def test_partial_name_with_autocorrect_disabled
+    assert_raises(GLI::UnknownCommand) do
+      GLI::CommandFinder.new(@app.commands, :default_command => :status, :autocomplete => false)
+        .find_command(:deploy)
+    end
+  end
+end

data/test/{tc_command.rb → unit/command_test.rb}

@@ -1,7 +1,7 @@
-require 'test_helper'
-require 'tempfile'
+require_relative "test_helper"
+require_relative "support/fake_std_out"
 
-class TC_testCommand < Clean::Test::TestCase
+class CommandTest < MiniTest::Test
   include TestHelper
   def setup
     @fake_stdout = FakeStdOut.new
@@ -40,8 +40,6 @@ class TC_testCommand < Clean::Test::TestCase
 
   def test_basic_command
     [false,true].each do |openstruct|
-    end
-    [true].each do |openstruct|
       create_app(openstruct)
       openstruct_message = openstruct ? ", with use_openstruct" : ""
       args_args = [%w(-g basic -v -c foo bar baz quux), %w(-g basic -v --configure=foo bar baz quux)]
@@ -61,6 +59,12 @@ class TC_testCommand < Clean::Test::TestCase
     end
   end
 
+  def test_openstruct_with_nested_commands
+    create_app(true)
+    @app.run(["top","nested"])
+    assert(!@error_called,"Error block should not have been called: #{@exception_caught.inspect}")
+  end
+
   def test_around_filter
     @around_block_called = false
     @app.around do |global_options, command, options, arguments, code|
@@ -432,7 +436,7 @@ class TC_testCommand < Clean::Test::TestCase
   private
 
   def assert_contained(output,regexp)
-    assert_not_nil output.contained?(regexp),
+    refute_nil output.contained?(regexp),
       "Expected output to contain #{regexp.inspect}, output was:\n#{output}"
   end
 
@@ -459,9 +463,10 @@ class TC_testCommand < Clean::Test::TestCase
     @pre_called = false
     @post_called = false
     @error_called = false
+    @exception_caught = nil
     @app.pre { |g,c,o,a| @pre_called = true }
     @app.post { |g,c,o,a| @post_called = true }
-    @app.on_error { |g,c,o,a| @error_called = true }
+    @app.on_error { |exception| @error_called = true; @exception_caught = exception }
     @glob = nil
     @verbose = nil
     @glob_verbose = nil
@@ -503,6 +508,14 @@ class TC_testCommand < Clean::Test::TestCase
     @app.command [:test_wrap] do |c|
       c.action {}
     end
+
+    @app.desc "A top-level command"
+    @app.command [:top] do |c|
+      c.desc "A nested command"
+      c.command [:nested] do |nested|
+        nested.action {}
+      end
+    end
   end
 
 end

data/test/unit/compound_command_test.rb

@@ -0,0 +1,17 @@
+require_relative "test_helper"
+
+class CompoundCommandFinderTest < MiniTest::Test
+  include TestHelper
+
+  def test_exception_for_missing_commands
+    @name = "new"
+    @unknown_name = "create"
+    @existing_command = OpenStruct.new(:name => @name)
+    @base = OpenStruct.new( :commands => { @name => @existing_command })
+
+    @code = lambda { GLI::Commands::CompoundCommand.new(@base,{:foo => [@name,@unknown_name]}) }
+
+    ex = assert_raises(RuntimeError,&@code)
+    assert_match /#{Regexp.escape(@unknown_name)}/,ex.message
+  end
+end

data/test/{tc_doc.rb → unit/doc_test.rb}

@@ -1,5 +1,4 @@
-require 'test_helper'
-require 'pp'
+require_relative "test_helper"
 
 class String
   def blank?
@@ -19,7 +18,7 @@ class Object
   end
 end
 
-class TC_testDoc < Clean::Test::TestCase
+class DocTest < MiniTest::Test
   include TestHelper
 
   class TestApp
@@ -112,42 +111,30 @@ class TC_testDoc < Clean::Test::TestCase
     @@counter = -1 # we pre-increment so this makes 0 first
   end
 
-  test_that "a GLI app with documentation gets the callbacks for each element" do
-    Given :the_test_app
-    And :the_expected_output
-    And {
-      @documenter = GLI::Commands::Doc.new(@app)
-      @listener = TestListener.new
-    }
-    When {
-      @documenter.document(@listener)
-    }
-    Then {
-      lines_expected = @string.split(/\n/)
-      lines_got = @listener.to_s.split(/\n/)
-      lines_expected.zip(lines_got).each_with_index do |(expected,got),index|
-        assert_equal expected,got,"At index #{index}"
-      end
-    }
+  def test_app_without_docs_gets_callbacks_for_each_element
+    setup_test_app
+    construct_expected_output
+    @documenter = GLI::Commands::Doc.new(@app)
+    @listener = TestListener.new
+    @documenter.document(@listener)
+    lines_expected = @string.split(/\n/)
+    lines_got = @listener.to_s.split(/\n/)
+    lines_expected.zip(lines_got).each_with_index do |(expected,got),index|
+      assert_equal expected,got,"At index #{index}"
+    end
   end
 
-  test_that "the doc command works as a GLI command" do
-    Given :the_test_app
-    And :the_expected_output
-    And {
-      @documenter = GLI::Commands::Doc.new(@app)
-      @listener = TestListener.new
-    }
-    When {
-      @documenter.execute({},{:format => "TC_testDoc::TestListener"},[])
-    }
-    Then {
-      lines_expected = @string.split(/\n/)
-      lines_got = TestListener.last.to_s.split(/\n/)
-      lines_expected.zip(lines_got).each_with_index do |(expected,got),index|
-        assert_equal expected,got,"At index #{index}"
-      end
-    }
+  def test_doc_command_works_as_GLI_command
+    setup_test_app
+    construct_expected_output
+    @documenter = GLI::Commands::Doc.new(@app)
+    @listener = TestListener.new
+    @documenter.execute({},{:format => "DocTest::TestListener"},[])
+    lines_expected = @string.split(/\n/)
+    lines_got = TestListener.last.to_s.split(/\n/)
+    lines_expected.zip(lines_got).each_with_index do |(expected,got),index|
+      assert_equal expected,got,"At index #{index}"
+    end
   end
 
 private
@@ -158,36 +145,36 @@ private
     @@counter
   end
 
-  def the_test_app
+  def setup_test_app
     @app = TestApp.new
     @app.instance_eval do
       program_desc "program desc"
       program_long_desc "program long desc"
       version "1.3.4"
 
-      TC_testDoc.flag_with_everything_specified(self)
-      TC_testDoc.flag_with_everything_omitted(self)
-      TC_testDoc.switch_with_everything_specified(self)
-      TC_testDoc.switch_with_everything_omitted(self)
+      DocTest.flag_with_everything_specified(self)
+      DocTest.flag_with_everything_omitted(self)
+      DocTest.switch_with_everything_specified(self)
+      DocTest.switch_with_everything_omitted(self)
 
       desc      "command desc"
       long_desc "command long desc"
       arg_name  "cmd_arg_name"
       command [:command1,:com1] do |c|
-        TC_testDoc.flag_with_everything_specified(c)
-        TC_testDoc.flag_with_everything_omitted(c)
-        TC_testDoc.switch_with_everything_specified(c)
-        TC_testDoc.switch_with_everything_omitted(c)
+        DocTest.flag_with_everything_specified(c)
+        DocTest.flag_with_everything_omitted(c)
+        DocTest.switch_with_everything_specified(c)
+        DocTest.switch_with_everything_omitted(c)
 
         c.desc      "subcommand desc"
         c.long_desc "subcommand long desc"
         c.arg_name  "subcmd_arg_name"
         c.action { |g,o,a| }
         c.command [:sub,:subcommand] do |sub|
-          TC_testDoc.flag_with_everything_specified(sub,:subflag)
-          TC_testDoc.flag_with_everything_omitted(sub,:subflag2)
-          TC_testDoc.switch_with_everything_specified(sub,:subswitch)
-          TC_testDoc.switch_with_everything_omitted(sub,:subswitch2)
+          DocTest.flag_with_everything_specified(sub,:subflag)
+          DocTest.flag_with_everything_omitted(sub,:subflag2)
+          DocTest.switch_with_everything_specified(sub,:subswitch)
+          DocTest.switch_with_everything_omitted(sub,:subswitch2)
           sub.action { |g,o,a| }
         end
         c.command [:default] do |sub|
@@ -227,7 +214,7 @@ private
   def self.switch_with_everything_omitted(on,name=[:S,:switch2])
     on.switch name
   end
-  def the_expected_output
+  def construct_expected_output
     # Oh yeah.  Creating a string representing the structure of the calls.
     @string =<<EOS
 BEGIN

data/test/{tc_flag.rb → unit/flag_test.rb}

@@ -1,39 +1,36 @@
-require 'test_helper'
+require_relative "test_helper"
 
-class TC_testFlag < Clean::Test::TestCase
+class FlagTest < MiniTest::Test
   include TestHelper
 
   def test_basics_simple
-    Given flag_with_names(:f)
-    Then attributes_should_be_set
-    And name_should_be(:f)
-    And aliases_should_be(nil)
+    setup_for_flag_with_names(:f)
+    assert_attributes_set
+    assert_equal(:f,@cli_option.name)
+    assert_nil @cli_option.aliases
   end
 
   def test_basics_kinda_complex
-    Given flag_with_names([:f])
-    Then attributes_should_be_set
-    And name_should_be(:f)
-    And aliases_should_be(nil)
+    setup_for_flag_with_names([:f])
+    assert_attributes_set
+    assert_equal(:f,@cli_option.name)
+    assert_nil @cli_option.aliases
   end
 
   def test_basics_complex
-    Given flag_with_names([:f,:file,:filename])
-    Then attributes_should_be_set
-    And name_should_be(:f)
-    And aliases_should_be([:file,:filename])
-    And {
-      assert_equal ["-f VAL","--file VAL","--filename VAL",/foobar/,Float],@flag.arguments_for_option_parser
-    }
+    setup_for_flag_with_names([:f,:file,:filename])
+    assert_attributes_set
+    assert_equal(:f,@cli_option.name)
+    assert_equal [:file,:filename], @cli_option.aliases
+    assert_equal ["-f VAL","--file VAL","--filename VAL",/foobar/,Float],@flag.arguments_for_option_parser
   end
 
   def test_flag_can_mask_its_value
-    Given flag_with_names(:password, :mask => true)
-    Then attributes_should_be_set(:safe_default_value => "********")
+    setup_for_flag_with_names(:password, :mask => true)
+    assert_attributes_set(:safe_default_value => "********")
   end
 
-  def flag_with_names(names,options = {})
-    lambda do
+  def setup_for_flag_with_names(names,options = {})
       @options = {
         :desc => 'Filename',
         :long_desc => 'The Filename',
@@ -45,11 +42,9 @@ class TC_testFlag < Clean::Test::TestCase
       }.merge(options)
       @flag = GLI::Flag.new(names,@options)
       @cli_option = @flag
-    end
   end
 
-  def attributes_should_be_set(override={})
-    lambda {
+  def assert_attributes_set(override={})
       expected = @options.merge(override)
       assert_equal(expected[:desc],@flag.description)
       assert_equal(expected[:long_desc],@flag.long_description)
@@ -57,6 +52,5 @@ class TC_testFlag < Clean::Test::TestCase
       assert_equal(expected[:safe_default_value],@flag.safe_default_value)
       assert_equal(expected[:must_match],@flag.must_match)
       assert_equal(expected[:type],@flag.type)
-    }
   end
 end