rubycom 0.3.2 → 0.4.0

data/test/rubycom/output_handler_test.rb

@@ -0,0 +1,76 @@
+require "#{File.dirname(__FILE__)}/../../lib/rubycom/output_handler.rb"
+
+require "#{File.dirname(__FILE__)}/util_test_module.rb"
+require "#{File.dirname(__FILE__)}/util_test_composite.rb"
+require "#{File.dirname(__FILE__)}/util_test_no_singleton.rb"
+
+require 'test/unit'
+
+class OutputHandlerTest < Test::Unit::TestCase
+
+  def capture_out(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+
+  def test_process_output
+    test_result = 'test command output'
+
+    result = capture_out { Rubycom::OutputHandler.process_output(test_result) }
+
+    expected = "test command output\n"
+    assert_equal(expected, result)
+  end
+
+  def test_process_output_empty
+    test_result = ''
+
+    result = capture_out { Rubycom::OutputHandler.process_output(test_result) }
+
+    expected = "\n"
+    assert_equal(expected, result)
+  end
+
+  def test_process_output_nil
+    test_result = nil
+
+    result = capture_out { Rubycom::OutputHandler.process_output(test_result) }
+
+    expected = "\n"
+    assert_equal(expected, result)
+  end
+
+  def test_process_output_object
+    test_result = Object.new
+
+    result = capture_out { Rubycom::OutputHandler.process_output(test_result) }
+
+    expected = "--- !ruby/object {}\n"
+    assert_equal(expected, result)
+  end
+
+  def test_process_output_array
+    test_result = []
+
+    result = capture_out { Rubycom::OutputHandler.process_output(test_result) }
+
+    expected = "--- []\n"
+    assert_equal(expected, result)
+  end
+
+  def test_process_output_hash
+    test_result = {test: 'val'}
+
+    result = capture_out { Rubycom::OutputHandler.process_output(test_result) }
+
+    expected = "---\n:test: val\n"
+    assert_equal(expected, result)
+  end
+
+end

data/test/rubycom/parameter_extract_test.rb

@@ -0,0 +1,141 @@
+require "#{File.dirname(__FILE__)}/../../lib/rubycom/parameter_extract.rb"
+
+require "#{File.dirname(__FILE__)}/util_test_module.rb"
+require "#{File.dirname(__FILE__)}/util_test_composite.rb"
+require "#{File.dirname(__FILE__)}/util_test_no_singleton.rb"
+
+require 'test/unit'
+
+class ParameterExtractTest < Test::Unit::TestCase
+
+  def test_extract_parameters
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return", "testing_argument"], :opts => {"test_option_int" => 10}}
+    result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc)
+    test_command.parameters.each{|_, sym|
+      assert(result.has_key?(sym), 'extracted parameters should include values for each method parameter')
+    }
+    assert_equal('testing_argument', result[:test_arg])
+    assert_equal(10, result[:test_option_int])
+  end
+
+  def test_extract_parameters_help_opt
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return", "testing_argument"], :opts => {"test_option_int" => 10, "help" => true}}
+    result = nil
+    assert_raise(Rubycom::ParameterExtractError) { result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc) }
+    expected = nil
+    assert_equal(expected, result)
+  end
+
+  def test_extract_parameters_help_flag
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return", "testing_argument"], :opts => {"test_option_int" => 10}, :flags => {"h" => true}}
+    result = nil
+    assert_raise(Rubycom::ParameterExtractError) { result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc) }
+    expected = nil
+    assert_equal(expected, result)
+  end
+
+  def test_extract_parameters_unknown_opts
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return", "testing_argument"], :opts => {"test_option_int" => 10, "extraneous_opt" => true}}
+    result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc)
+    test_command.parameters.each{|_, sym|
+      assert(result.has_key?(sym), 'extracted parameters should include values for each method parameter')
+    }
+    assert_equal('testing_argument', result[:test_arg])
+    assert_equal(10, result[:test_option_int])
+  end
+
+  def test_extract_parameters_unknown_flags
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return", "testing_argument"], :opts => {"test_option_int" => 10}, :flags => {"z" => true}}
+    result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc)
+    test_command.parameters.each{|_, sym|
+      assert(result.has_key?(sym), 'extracted parameters should include values for each method parameter')
+    }
+    assert_equal('testing_argument', result[:test_arg])
+    assert_equal(10, result[:test_option_int])
+  end
+
+  def test_extract_parameters_default
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return", "testing_argument"]}
+    result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc)
+    test_command.parameters.each{|_, sym|
+      assert(result.has_key?(sym), 'extracted parameters should include values for each method parameter')
+    }
+    assert_equal('testing_argument', result[:test_arg])
+    assert_equal(1, result[:test_option_int])
+  end
+
+  def test_extract_parameters_arr
+    test_command = UtilTestModule.public_method(:test_command_options_arr)
+    test_command_doc = {
+        :parameters => [
+            {:default => 'test_option_default', :doc => "an optional test argument", :doc_type => "String", :param_name => "test_option", :type => :opt},
+            {:default => nil, :doc => "an optional array of arguments", :doc_type => "Array", :param_name => "test_options", :type => :rest}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_options_arr", 'test_option1', 'test_option2', 1.0, false]}
+    result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc)
+    test_command.parameters.each{|_, sym|
+      assert(result.has_key?(sym), 'extracted parameters should include values for each method parameter')
+    }
+    assert_equal('test_option1', result[:test_option])
+    assert_equal(['test_option2', 1.0, false], result[:test_options])
+  end
+
+  def test_extract_parameters_missing_required
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_command_doc = {
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :type => :req},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :type => :opt}
+        ]
+    }
+    test_command_line = {:args => ["UtilTestModule", "test_command_with_return"], :opts => {"test_option_int" => 10}}
+    result = nil
+    assert_raise(Rubycom::ParameterExtractError) { result = Rubycom::ParameterExtract.extract_parameters(test_command, test_command_line, test_command_doc) }
+    expected = nil
+    assert_equal(expected, result)
+  end
+
+end

data/test/rubycom/rubycom_test.rb

@@ -1,548 +1,290 @@
-require "#{File.dirname(__FILE__)}/../../lib/rubycom.rb"
-
-require "#{File.dirname(__FILE__)}/util_test_module.rb"
-require "#{File.dirname(__FILE__)}/util_test_composite.rb"
-require "#{File.dirname(__FILE__)}/util_test_no_singleton.rb"
-
-require 'test/unit'
-require 'time'
-
-class RubycomTest < Test::Unit::TestCase
-
-  def test_run
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_with_arg", "HelloWorld"]
-    result = Rubycom.run(base, args)
-
-    expected = "test_arg=HelloWorld"
-    expected_out = expected
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_help
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["help"]
-    result = Rubycom.run(base, args)
-
-    expected = <<-END.gsub(/^ {4}/,'')
-    Usage:
-        UtilTestModule <command> [args]
-
-    Commands:
-    test_command                -  A basic test command
-    test_command_no_docs
-    test_command_with_arg       -  A test_command with one arg
-    test_command_arg_named_arg  -  A test_command with an arg named arg
-    test_command_with_args      -  A test_command with two args
-    test_command_with_options   -  A test_command with an optional argument
-    test_command_all_options    -  A test_command with all optional arguments
-    test_command_options_arr    -  A test_command with an options array
-    test_command_with_return    -  A test_command with a return argument
-    test_command_arg_timestamp  -  A test_command with a Timestamp argument and an unnecessarily
-                                   long description which should overflow when
-                                   it tries to line up with other descriptions.
-    test_command_arg_false      -  A test_command with a Boolean argument
-    test_command_arg_arr        -  A test_command with an array argument
-    test_command_arg_hash       -  A test_command with an Hash argument
-    test_command_mixed_options  -  A test_command with several mixed options
-
-    Default Commands:
-    help                 - prints this help page
-    job                  - run a job file
-    register_completions - setup bash tab completion
-    tab_complete         - print a list of possible matches for a given word
-
-    END
-    expected_out = expected
-    assert_equal(expected.gsub(/\n|\r|\s/, ''), result.gsub(/\n|\r|\s/, ''))
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_nil_return
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command"]
-    result = Rubycom.run(base, args)
-
-    expected = nil
-    expected_out = "command test\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_hash_return
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    time = Time.now.to_s
-    args = ["test_command_arg_timestamp", time]
-    result = Rubycom.run(base, args)
-
-    expected = {:test_time => Time.parse(time)}
-    expected_out = {test_time: Time.parse(time)}.to_yaml
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_all_optional
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_all_options"]
-    result = Rubycom.run(base, args)
-
-    e_test_arg = 'test_arg_default'
-    e_test_option = 'test_option_default'
-    expected = nil
-    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_all_opt_override_first
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_all_options", "test_arg_modified"]
-    result = Rubycom.run(base, args)
-
-    e_test_arg = 'test_arg_modified'
-    e_test_option = 'test_option_default'
-    expected = nil
-    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_all_opt_override_first_alt
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_all_options", "-test_arg=test_arg_modified"]
-    result = Rubycom.run(base, args)
-
-    e_test_arg = 'test_arg_modified'
-    e_test_option = 'test_option_default'
-    expected = nil
-    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_all_opt_override_second
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_all_options", "-test_option=test_option_modified"]
-    result = Rubycom.run(base, args)
-
-    e_test_arg = 'test_arg_default'
-    e_test_option = 'test_option_modified'
-    expected = nil
-    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_all_opt_use_all_opt
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_all_options", "-test_arg=test_arg_modified", "-test_option=test_option_modified"]
-    result = Rubycom.run(base, args)
-
-    e_test_arg = 'test_arg_modified'
-    e_test_option = 'test_option_modified'
-    expected = nil
-    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_all_opt_reverse
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_all_options", "-test_option=test_option_modified", "-test_arg=test_arg_modified"]
-    result = Rubycom.run(base, args)
-
-    e_test_arg = 'test_arg_modified'
-    e_test_option = 'test_option_modified'
-    expected = nil
-    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n"
-    assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_options_arr
-    mod = "util_test_module.rb"
-    command = "test_command_options_arr"
-    args = "test_option1 test_option2 1.0 false"
-    expected = 'Output is test_option=test_option1,test_option_arr=["test_option2", 1.0, false]'+"\n\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_run_multi_args
-    mod = "util_test_composite.rb"
-    sub_mod = "UtilTestModule"
-    command = "test_command_with_args"
-    args = "a b"
-    expected = 'test_arg=a,another_test_arg=b'+"\n\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{sub_mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_run_missing_required_arg
-    tst_out = ''
-
-    def tst_out.puts(data)
-      self << data.to_s << "\n"
-      nil
-    end
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_with_return", "-test_option_int=2"]
-    result = Rubycom.run(base, args)
-
-    expected = nil
-    expected_out = "No argument available for test_arg\n"
-
-    assert_equal(expected, result)
-    assert_equal(expected_out, tst_out.lines.first)
-    Rubycom::Documentation.get_command_usage(base,args[0],args[1..-1]).each_line{|expected_line|
-      assert_equal(true, tst_out.lines.include?(expected_line))
-    }
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_run_composite
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestComposite
-    args = ["test_composite_command", "Hello Composite"]
-    result = Rubycom.run(base, args)
-
-    expected = "Hello Composite"
-    expected_out = "Hello Composite"
-    assert_equal(expected, result)
-    assert_equal(expected_out, tst_out.split(/\n|\r|\r\n/).first)
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
-  end
-
-  def test_full_run_mixed_args
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = "testing_arg \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
-    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_args_for_opts
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = "testing_arg test2 testing_option test_hsh_arg true some other args"
-    expected = "test_arg=testing_arg test_arr=test2 test_opt=testing_option test_hsh=test_hsh_arg test_bool=true test_rest=[\"some\", \"other\", \"args\"]"+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_mixed_args_solid_arr
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = "testing_arg [test1,test2] -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" some other args"
-    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=some test_rest=["other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_mixed_args_quoted_solid_arr
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = 'testing_arg "[test1,test2]" -test_opt="testing_option" "{a: "test_hsh_arg"}" -test_bool=false some other args'
-    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=false test_rest=["some", "other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_mixed_args_odd_sp
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = 'testing_arg "[ test1 ,  test2 ]" -test_opt="testing_option" "{ a:    "test_hsh_arg" }" -test_bool=false some other args'
-    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=false test_rest=["some", "other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_mixed_args_hash_rocket
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = 'testing_arg "[ test1 ,  test2 ]" -test_opt="testing_option" "{ :a =>    "test_hsh_arg" }" false some other args'
-    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={ :a =>    test_hsh_arg } test_bool=false test_rest=["some", "other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_mixed_args_no_rest
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = "testing_arg \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\""
-    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=[]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_sharp_arg
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = '#' + " \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
-    expected = 'test_arg=# test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_full_run_bang_arg
-    mod = "util_test_module.rb"
-    command = "test_command_mixed_options"
-    args = "! \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
-    expected = 'test_arg=! test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
-    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_nil_arg
-    mod = UtilTestComposite
-    args = nil
-    expected = ["test_composite_command", "UtilTestNoSingleton", "UtilTestModule"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_empty_arg
-    mod = UtilTestComposite
-    args = ['']
-    expected = ["test_composite_command", "UtilTestNoSingleton", "UtilTestModule"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_partial_module
-    mod = UtilTestComposite
-    args = ['Util']
-    expected = ["UtilTestNoSingleton", "UtilTestModule"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_partial_module_single_match
-    mod = UtilTestComposite
-    args = ['UtilTestM']
-    expected = ["UtilTestModule"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_whole_module
-    mod = UtilTestComposite
-    args = ['UtilTestModule']
-    expected = ["test_command",
-                "test_command_no_docs",
-                "test_command_with_arg",
-                "test_command_arg_named_arg",
-                "test_command_with_args",
-                "test_command_with_options",
-                "test_command_all_options",
-                "test_command_options_arr",
-                "test_command_with_return",
-                "test_command_arg_timestamp",
-                "test_command_arg_false",
-                "test_command_arg_arr",
-                "test_command_arg_hash",
-                "test_command_mixed_options"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_empty_sub_command
-    mod = UtilTestComposite
-    args = ['UtilTestModule', '']
-    expected = ["test_command",
-                "test_command_no_docs",
-                "test_command_with_arg",
-                "test_command_arg_named_arg",
-                "test_command_with_args",
-                "test_command_with_options",
-                "test_command_all_options",
-                "test_command_options_arr",
-                "test_command_with_return",
-                "test_command_arg_timestamp",
-                "test_command_arg_false",
-                "test_command_arg_arr",
-                "test_command_arg_hash",
-                "test_command_mixed_options"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_partial_sub_command
-    mod = UtilTestComposite
-    args = ['UtilTestModule', 'test_command_ar']
-    expected = ["test_command_arg_named_arg",
-                "test_command_arg_timestamp",
-                "test_command_arg_false",
-                "test_command_arg_arr",
-                "test_command_arg_hash"]
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_whole_sub_command_single_match
-    mod = UtilTestComposite
-    args = ['UtilTestModule', 'test_command_with_options']
-    expected = ['']
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_whole_sub_command_multi_match
-    mod = UtilTestComposite
-    args = ['UtilTestModule', 'test_command_with_arg']
-    expected = ['']
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-  def test_tab_complete_whole_sub_command_with_empty
-    mod = UtilTestComposite
-    args = ['UtilTestModule', 'test_command_with_args', '']
-    expected = ['']
-    result =  Rubycom.tab_complete(mod, args)
-    assert_equal(expected, result)
-  end
-
-end
+require "#{File.dirname(__FILE__)}/../../lib/rubycom.rb"
+
+require "#{File.dirname(__FILE__)}/util_test_module.rb"
+require "#{File.dirname(__FILE__)}/util_test_composite.rb"
+require "#{File.dirname(__FILE__)}/util_test_no_singleton.rb"
+
+require 'test/unit'
+require 'time'
+
+class RubycomTest < Test::Unit::TestCase
+
+  def capture_out(&block)
+    original_stdout = $stdout
+    $stdout = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stdout = original_stdout
+    end
+    fake.string
+  end
+
+  def capture_err(&block)
+    original_stderr = $stderr
+    $stderr = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stderr = original_stderr
+    end
+    fake.string
+  end
+
+  def test_run
+    base = UtilTestModule
+    args = %w(test_command_with_arg HelloWorld)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    expected = "test_arg=HelloWorld"
+    assert_equal(expected, result)
+    assert_equal(expected+"\n", result_out)
+  end
+
+  def test_run_help
+    base = UtilTestModule
+    args = %w(help)
+    result = nil
+    result_err = capture_err { result = Rubycom.run(base, args) }
+
+    assert_equal(nil, result)
+    assert(result_err.gsub(/\n|\r|\s/, '').size > 0, 'help output should not be empty')
+    assert(result_err.include?('Help Requested'), 'help output should state that help was requested')
+  end
+
+  def test_run_nil_return
+    base = UtilTestModule
+    args = %w(test_command)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    expected_out = "command test\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_hash_return
+    base = UtilTestModule
+    time = "#{Time.now.to_s}"
+    args = ['test_command_arg_timestamp', time]
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    expected = {test_time: Time.parse(time)}
+    expected_out = expected.to_yaml
+    assert_equal(expected, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_all_optional
+    base = UtilTestModule
+    args = %w(test_command_all_options)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    e_test_arg = 'test_arg_default'
+    e_test_option = 'test_option_default'
+    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_all_opt_override_first
+    base = UtilTestModule
+    args = %w(test_command_all_options test_arg_modified)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    e_test_arg = 'test_arg_modified'
+    e_test_option = 'test_option_default'
+    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_all_opt_override_first_alt
+    base = UtilTestModule
+    args = %w(test_command_all_options -test_arg=test_arg_modified)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    e_test_arg = 'test_arg_modified'
+    e_test_option = 'test_option_default'
+    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_all_opt_override_second
+    base = UtilTestModule
+    args = %w(test_command_all_options -test_option=test_option_modified)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    e_test_arg = 'test_arg_default'
+    e_test_option = 'test_option_modified'
+    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_all_opt_use_all_opt
+    base = UtilTestModule
+    args = %w(test_command_all_options -test_arg=test_arg_modified -test_option=test_option_modified)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    e_test_arg = 'test_arg_modified'
+    e_test_option = 'test_option_modified'
+    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_all_opt_reverse
+    base = UtilTestModule
+    args = %w(test_command_all_options -test_option=test_option_modified -test_arg=test_arg_modified)
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    e_test_arg = 'test_arg_modified'
+    e_test_option = 'test_option_modified'
+    expected_out = "Output is test_arg=#{e_test_arg},test_option=#{e_test_option}\n\n"
+    assert_equal(nil, result)
+    assert_equal(expected_out, result_out)
+  end
+
+  def test_run_options_arr
+    mod = 'util_test_module.rb'
+    command = 'test_command_options_arr'
+    args = 'test_option1 test_option2 1.0 false'
+    expected = 'Output is test_option=test_option1,test_option_arr=["test_option2", 1.0, false]'+"\n\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_run_multi_args
+    mod = 'util_test_bin.rb'
+    sub_mod = 'UtilTestModule'
+    command = 'test_command_with_args'
+    args = 'a b'
+    expected = 'test_arg=a,another_test_arg=b'+"\n\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{sub_mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_run_missing_required_arg
+    base = UtilTestModule
+    args = %w(test_command_with_return -test_option_int=2)
+    result = nil
+    result_err = capture_err { result = Rubycom.run(base, args) }
+    expected = 'Missing required argument: test_arg'
+    assert_equal(nil, result)
+    assert(result_err.gsub(/\n|\r|\s/, '').size > 0, 'error output should not be empty')
+    assert(result_err.include?(expected), "error output should include #{expected} but was #{result}")
+  end
+
+  def test_run_composite
+    base = UtilTestComposite
+    args = ['test_composite_command', '\'Hello Composite\'']
+    result = nil
+    result_out = capture_out { result = Rubycom.run(base, args) }
+
+    expected = "Hello Composite"
+    expected_out = expected+"\n"
+    assert_equal(expected_out, result_out)
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_args
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = "testing_arg \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
+    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_names_with_shorts
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_names'
+    args = "testing_arg \"[test1, test2]\" -opt='testing_option' -h =\"{a: 'test_hsh_arg'}\" --bool true some other args"
+    expected = 'arg_test=testing_arg arr=["test1", "test2"] opt=testing_option hsh={"a"=>"test_hsh_arg"} bool=true rest_test=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_names_all_separators
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_names'
+    args = "testing_arg --arr = \"[test1, test2]\" -opt= 'testing_option' -h =\"{a: 'test_hsh_arg'}\" --bool true some other args"
+    expected = 'arg_test=testing_arg arr=["test1", "test2"] opt=testing_option hsh={"a"=>"test_hsh_arg"} bool=true rest_test=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_args_for_opts
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = 'testing_arg test2 testing_option test_hsh_arg true some other args'
+    expected = "test_arg=testing_arg test_arr=test2 test_opt=testing_option test_hsh=test_hsh_arg test_bool=true test_rest=[\"some\", \"other\", \"args\"]"+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_args_solid_arr
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = "testing_arg [test1,test2] -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" some other args"
+    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=some test_rest=["other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_args_quoted_solid_arr
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = 'testing_arg "[test1,test2]" -test_opt="testing_option" "{a: "test_hsh_arg"}" -test_bool=false some other args'
+    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=false test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_args_odd_sp
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = 'testing_arg "[ test1 ,  test2 ]" -test_opt="testing_option" "{ a:    "test_hsh_arg" }" -test_bool=false some other args'
+    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=false test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_args_hash_rocket
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = 'testing_arg "[ test1 ,  test2 ]" -test_opt="testing_option" "{ :a =>    "test_hsh_arg" }" false some other args'
+    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={ :a =>    test_hsh_arg } test_bool=false test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_mixed_args_rest_no_extra
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = "testing_arg \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\""
+    expected = 'test_arg=testing_arg test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=[]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_bang_arg
+    mod = 'util_test_module.rb'
+    command = 'test_command_mixed_options'
+    args = "! \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
+    expected = 'test_arg=! test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+end