gli_aziz_light 2.8.1

data/test/tc_subcommands.rb

@@ -0,0 +1,260 @@
+require 'test_helper'
+
+class TC_testSubCommand < Clean::Test::TestCase
+  include TestHelper
+
+  def setup
+    @fake_stdout = FakeStdOut.new
+    @fake_stderr = FakeStdOut.new
+
+    @original_stdout = $stdout
+    $stdout = @fake_stdout
+    @original_stderr = $stderr
+    $stderr = @fake_stderr
+
+    @app = CLIApp.new
+    @app.reset
+    @app.subcommand_option_handling :legacy
+    @app.error_device=@fake_stderr
+    ENV.delete('GLI_DEBUG')
+  end
+
+  def teardown
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+
+  ['add','new'].each do |name|
+    test_that "We run the 'add' subcommand using '#{name}'" do
+      Given we_have_a_command_with_two_subcommands
+      When  run_app('remote',name,'-f','foo','bar')
+      Then  assert_command_ran_with(:add, :command_options => {:f => true}, :args => %w(foo bar))
+    end
+  end
+
+  test_that "with subcommands, but not using one on the command-line, we run the base action" do
+    Given we_have_a_command_with_two_subcommands
+    When  run_app('remote','foo','bar')
+    Then  assert_command_ran_with(:base, :command_options => {:f => false}, :args => %w(foo bar))
+  end
+
+  test_that "switches and flags defined on a subcommand are available" do
+    Given we_have_a_command_with_two_subcommands(:switches => [:addswitch], :flags => [:addflag])
+    When  run_app('remote','add','--addswitch','--addflag','foo','bar')
+    Then  assert_command_ran_with(:add,:command_options => { :addswitch => true, :addflag => 'foo', :f => false },
+                                       :args => ['bar'])
+  end
+
+  test_that "--help works for subcommands in :normal handling mode" do
+    Given { @app.subcommand_option_handling :normal }
+    And we_have_a_command_with_two_subcommands
+    When { @app.run(["remote", "add", "--help"]) rescue nil }
+    Then { assert_no_match /^error/, @fake_stderr.to_s, "should not output an error message" }
+  end
+
+  test_that "--help works for subcommands in :legacy handling mode" do
+    Given { @app.subcommand_option_handling :legacy }
+    And we_have_a_command_with_two_subcommands
+    When { @app.run(["remote", "add", "--help"]) rescue nil }
+    Then { assert_no_match /^error/, @fake_stderr.to_s, "should not output an error message" }
+  end
+
+  test_that "we can reopen commands to add new subcommands" do
+    Given {
+      @app.command :remote do |p|
+        p.command :add do |c|
+          c.action do |global_options,command_options,args|
+            @ran_command = :add
+          end
+        end
+      end
+      @app.command :remote do |p|
+        p.command :new do |c|
+          c.action do |global_options,command_options,args|
+            @ran_command = :new
+          end
+        end
+      end
+    }
+    When run_app('remote','new')
+    Then { assert_equal(@ran_command, :new) }
+    When run_app('remote', 'add')
+    Then { assert_equal(@ran_command, :add) }
+  end
+
+  test_that "reopening commands doesn't re-add them to the output" do
+    Given {
+      @app.command :remote do |p|
+        p.command(:add) { }
+      end
+      @app.command :remote do |p|
+        p.command(:new) { }
+      end
+    }
+    command_names = @app.instance_variable_get("@commands_declaration_order").collect { |c| c.name }
+    assert_equal 1, command_names.grep(:remote).size
+  end
+
+
+  test_that "we can reopen commands doesn't cause conflicts" do
+    Given {
+      @app.command :remote do |p|
+        p.command :add do |c|
+          c.action do |global_options,command_options,args|
+            @ran_command = :remote_add
+          end
+        end
+      end
+      @app.command :local do |p|
+        p.command :add do |c|
+          c.action do |global_options,command_options,args|
+            @ran_command = :local_add
+          end
+        end
+      end
+    }
+    When run_app('remote','add')
+    Then { assert_equal(@ran_command, :remote_add) }
+    When run_app('local', 'add')
+    Then { assert_equal(@ran_command, :local_add) }
+  end
+
+
+  test_that "we can nest subcommands very deep" do
+    Given {
+      @run_results = { :add => nil, :rename => nil, :base => nil }
+      @app.command :remote do |c|
+
+        c.switch :f
+        c.command :add do |add|
+          add.command :some do |some|
+            some.command :cmd do |cmd|
+              cmd.switch :s
+              cmd.action do |global_options,command_options,args|
+                @run_results[:cmd] = [global_options,command_options,args]
+              end
+            end
+          end
+        end
+      end
+      ENV['GLI_DEBUG'] = 'true'
+    }
+    When run_app('remote','add','some','cmd','-s','blah')
+    Then assert_command_ran_with(:cmd, :command_options => {:s => true, :f => false},:args => ['blah'])
+  end
+
+  test_that "when any command in the chain has no action, but there's still arguments, indicate we have an unknown command" do
+    Given a_very_deeply_nested_command_structure
+    Then {
+      assert_raises GLI::UnknownCommand do
+        When run_app('remote','add','some','foo')
+      end
+      assert_match /Unknown command 'foo'/,@fake_stderr.to_s
+    }
+  end
+
+  test_that "when a command in the chain has no action, but there's NO additional arguments, indicate we need a subcommand" do
+    Given a_very_deeply_nested_command_structure
+    Then {
+      assert_raises GLI::BadCommandLine do
+        When run_app('remote','add','some')
+      end
+      assert_match /Command 'some' requires a subcommand/,@fake_stderr.to_s
+    }
+  end
+
+  private
+
+  def run_app(*args)
+    lambda { @exit_code = @app.run(args) }
+  end
+
+  def a_very_deeply_nested_command_structure
+    lambda {
+      @run_results = { :add => nil, :rename => nil, :base => nil }
+      @app.command :remote do |c|
+
+        c.switch :f
+        c.command :add do |add|
+          add.command :some do |some|
+            some.command :cmd do |cmd|
+              cmd.switch :s
+              cmd.action do |global_options,command_options,args|
+                @run_results[:cmd] = [global_options,command_options,args]
+              end
+            end
+          end
+        end
+      end
+      ENV['GLI_DEBUG'] = 'true'
+    }
+  end
+
+  # expected_command - name of command exepcted to have been run
+  # options:
+  #   - global_options => hash of expected options
+  #   - command_options => hash of expected command options
+  #   - args => array of expected args
+  def assert_command_ran_with(expected_command,options)
+    lambda {
+      global_options = options[:global_options] || { :help => false }
+      @run_results.each do |command,results|
+        if command == expected_command
+          results.map! { |r| r.reject { |k, v| k == :cli } }
+          assert_equal(indifferent_hash(global_options),results[0])
+          assert_equal(indifferent_hash(options[:command_options]),results[1])
+          assert_equal(options[:args],results[2])
+        else
+          assert_nil results
+        end
+      end
+    }
+  end
+
+  def indifferent_hash(possibly_nil_hash)
+    return {} if possibly_nil_hash.nil?
+    possibly_nil_hash.keys.each do |key|
+      if key.kind_of? Symbol
+        possibly_nil_hash[key.to_s] = possibly_nil_hash[key] unless possibly_nil_hash.has_key?(key.to_s)
+      elsif key.kind_of? String
+        possibly_nil_hash[key.to_sym] = possibly_nil_hash[key] unless possibly_nil_hash.has_key?(key.to_sym)
+      end
+    end
+    possibly_nil_hash
+  end
+
+  # options - 
+  #     :flags => flags to add to :add
+  #     :switiches => switiches to add to :add
+  def we_have_a_command_with_two_subcommands(options = {})
+    lambda {
+      @run_results = { :add => nil, :rename => nil, :base => nil }
+      @app.command :remote do |c|
+
+        c.switch :f
+
+        c.desc "add a remote"
+        c.command [:add,:new] do |add|
+
+          Array(options[:flags]).each { |_| add.flag _ }
+          Array(options[:switches]).each { |_| add.switch _ }
+          add.action do |global_options,command_options,args|
+            @run_results[:add] = [global_options,command_options,args]
+          end
+        end
+
+        c.desc "rename a remote"
+        c.command :rename do |rename|
+          rename.action do |global_options,command_options,args|
+            @run_results[:rename] = [global_options,command_options,args]
+          end
+        end
+
+        c.action do |global_options,command_options,args|
+          @run_results[:base] = [global_options,command_options,args]
+        end
+      end
+      ENV['GLI_DEBUG'] = 'true'
+    }
+  end
+end

data/test/tc_switch.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class TC_testSwitch < Clean::Test::TestCase
+  include TestHelper
+
+  def test_basics_simple
+    Given switch_with_names(:filename)
+    Then attributes_should_be_set
+    And name_should_be(:filename)
+    And aliases_should_be(nil)
+  end
+
+  def test_basics_kinda_complex
+    Given switch_with_names([:f])
+    Then attributes_should_be_set
+    And name_should_be(:f)
+    And aliases_should_be(nil)
+  end
+
+  def test_basics_complex
+    Given switch_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","--[no-]file","--[no-]filename"],@switch.arguments_for_option_parser
+    }
+  end
+
+  def test_includes_negatable
+    assert_equal '-a',GLI::Switch.name_as_string('a')
+    assert_equal '--[no-]foo',GLI::Switch.name_as_string('foo')
+  end
+
+  private 
+
+  def switch_with_names(names)
+    lambda do
+      @options = {
+        :desc => 'Filename',
+        :long_desc => 'The Filename',
+      }
+      @switch = GLI::Switch.new(names,@options)
+      @cli_option = @switch
+    end
+  end
+
+  def attributes_should_be_set
+    lambda {
+      assert_equal(@options[:desc],@switch.description)
+      assert_equal(@options[:long_desc],@switch.long_description)
+    }
+  end
+
+end

data/test/tc_terminal.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class TC_testTerminal < Clean::Test::TestCase
+  include TestHelper
+
+  def test_command_exists
+    assert GLI::Terminal.instance.command_exists?('ls')
+    assert !GLI::Terminal.instance.command_exists?('asdfasfasdf')
+  end
+
+  def setup
+    @old_columns = ENV['COLUMNS']
+    @old_lines = ENV['LINES']
+  end
+
+  def teardown
+    ENV['COLUMNS'] = @old_columns 
+    ENV['LINES'] = @old_lines
+    GLI::Terminal.default_size = [80,24]
+  end
+
+  def test_shared_instance_is_same
+    assert_equal GLI::Terminal.instance,GLI::Terminal.instance
+  end
+
+  def test_size_based_on_columns
+    ENV['COLUMNS'] = '666'
+    ENV['LINES'] = '777'
+    assert_equal [666,777],GLI::Terminal.instance.size
+  end
+
+  def test_size_using_tput
+    terminal = GLI::Terminal.new
+    terminal.make_unsafe!
+    GLI::Terminal.instance_eval do
+      def run_command(command)
+        if command == 'tput cols'
+          return '888'
+        elsif command == 'tput lines'
+          return '999'
+        else
+          raise "Unexpected command called: #{command}"
+        end
+      end
+      def command_exists?(command); true; end
+      def jruby?; true; end
+    end
+    ENV['COLUMNS'] = 'foo'
+    assert_equal [888,999],terminal.size
+  end
+
+  def test_size_using_stty
+    terminal = GLI::Terminal.new
+    terminal.make_unsafe!
+    GLI::Terminal.instance_eval do
+      def run_command(command)
+
+        if RUBY_PLATFORM == 'java'
+          return '5678' if command == 'tput cols'
+          return '1234' if command == 'tput lines'
+        else 
+          return '1234 5678' if command == 'stty size'
+          return '1234 5678' if command == 'stty'
+        end
+
+        raise "Unexpected command called: #{command} for #{RUBY_PLATFORM}"
+      end
+      def command_exists?(command); true; end
+      def jruby?; false; end
+      def solaris?; false; end
+    end
+    ENV['COLUMNS'] = 'foo'
+    assert_equal [5678,1234],terminal.size
+  end
+
+  def test_size_using_default
+    terminal = GLI::Terminal.new
+    terminal.make_unsafe!
+    GLI::Terminal.instance_eval do
+      def command_exists?(command); false; end
+      def jruby?; false; end
+      def solaris?; false; end
+    end
+    ENV['COLUMNS'] = 'foo'
+    assert_equal [80,24],terminal.size
+    # While we have this set up, lets make sure the default change falls through
+    GLI::Terminal.default_size = [90,45]
+    assert_equal [90,45],terminal.size
+  end
+
+  def test_size_using_default_when_exception
+    terminal = GLI::Terminal.new
+    GLI::Terminal.instance_eval do
+      def jruby?; raise "Problem"; end
+      def solaris?; false; end
+    end
+    ENV['COLUMNS'] = 'foo'
+    assert_equal [80,24],terminal.size
+  end
+end

data/test/tc_verbatim_wrapper.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class TC_testVerbatimWrapper < Clean::Test::TestCase
+  include TestHelper
+
+  test_that "verbatim wrapper handles nil" do
+    Given {
+      @wrapper = GLI::Commands::HelpModules::VerbatimWrapper.new(any_int,any_int)
+    }
+    When {
+      @result = @wrapper.wrap(nil)
+    }
+    Then {
+      assert_equal '',@result
+    }
+  end
+
+  test_that "verbatim wrapper doesn't touch the input" do
+    Given {
+      @wrapper = GLI::Commands::HelpModules::VerbatimWrapper.new(any_int,any_int)
+      @input = <<EOS
+      |This is|an ASCII|table|
+      +-------+--------+-----+
+      | foo   |  bar   | baz |
+      +-------+--------+-----+
+EOS
+    }
+    When {
+      @result = @wrapper.wrap(@input)
+    }
+    Then {
+      assert_equal @input,@result
+    }
+  end
+
+end