rubycom 0.3.2 → 0.4.0

data/test/rubycom/command_interface_test.rb

@@ -0,0 +1,293 @@
+require "#{File.dirname(__FILE__)}/../../lib/rubycom/command_interface.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 CommandInterfaceTest < Test::Unit::TestCase
+
+  def test_build_interface_nil_command
+    test_command = nil
+    test_doc = {
+        :short_doc => "A command module used for testing.",
+        :full_doc => "A command module used for testing\n\nThis module contains most of the test case input methods.",
+        :sub_command_docs => {
+            :non_command => "A test non-command method.",
+            :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."
+        }
+    }
+    result = nil
+    assert_raise(ArgumentError) { result = Rubycom::CommandInterface.build_interface(test_command, test_doc) }
+
+    assert_equal(nil, result, "#{result} should be nil")
+  end
+
+  def test_build_interface_nil_doc
+    test_command = UtilTestModule
+    test_doc = nil
+    result = nil
+    assert_raise(ArgumentError) { result = Rubycom::CommandInterface.build_interface(test_command, test_doc) }
+
+    assert_equal(nil, result, "#{result} should be nil")
+  end
+
+  def test_build_interface_empty_doc
+    test_command = UtilTestModule
+    test_doc = {}
+    result = Rubycom::CommandInterface.build_interface(test_command, test_doc)
+
+    assert_equal(result.gsub(/\s|\n|\r\n/,''), "Usage:UtilTestModule<command>[args]Description:","#{result} should be empty")
+  end
+
+  def test_build_interface_module
+    test_command = UtilTestModule
+    test_doc = {
+        :short_doc => "A command module used for testing.",
+        :full_doc => "A command module used for testing\n\nThis module contains most of the test case input methods.",
+        :sub_command_docs => {
+            :non_command => "A test non-command method.",
+            :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."
+        }
+    }
+    result = Rubycom::CommandInterface.build_interface(test_command, test_doc)
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_doc[:full_doc].gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_doc[:full_doc]}")
+    test_doc[:sub_command_docs].each{|cmd,doc|
+      assert(result.include?(cmd.to_s),"#{result} should include #{cmd.to_s}")
+      assert(result.gsub(/\s|\n|\r\n/,'').include?(doc.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{doc}")
+    }
+  end
+
+  def test_build_interface_method
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_doc = {
+        :full_doc => "A test_command with a return argument",
+        :short_doc => "A test_command with a return argument.",
+        :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 }
+        ],
+        :tags => [
+            {:name => "test_arg", :tag_name => "param", :text => "a test argument", :types => ["String"]},
+            {:name => "test_option_int", :tag_name => "param", :text => "an optional test argument which happens to be an Integer", :types => ["Integer"]},
+            {:name => nil, :tag_name => "return", :text => "an array including both params if test_option_int != 1", :types => ["Array"]},
+            {:name => nil, :tag_name => "return", :text => "a the first param if test_option_int == 1", :types => ["String"]}
+        ]
+    }
+    result = Rubycom::CommandInterface.build_interface(test_command, test_doc)
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_doc[:full_doc].gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_doc[:full_doc]}")
+    test_doc[:tags].each{|tag|
+      if tag[:name].nil?
+        assert(result.include?(tag[:tag_name].to_s),"#{result} should include #{tag[:tag_name].to_s}")
+      else
+        assert(result.include?(tag[:name].to_s),"#{result} should include #{tag[:name].to_s}")
+      end
+      assert(result.gsub(/\s|\n|\r\n/,'').include?("#{tag[:types]}"),"#{result} should include #{tag[:types]}")
+      assert(result.gsub(/\s|\n|\r\n/,'').include?(tag[:text].gsub(/\s|\n|\r\n/,'')),"#{result} should include #{tag[:text]}")
+    }
+  end
+
+  def test_build_usage_module
+    test_command = UtilTestModule
+    test_doc = {
+        :short_doc => "A command module used for testing.",
+        :full_doc => "A command module used for testing\n\nThis module contains most of the test case input methods.",
+        :sub_command_docs => {
+            :non_command => "A test non-command method.",
+            :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."
+        }
+    }
+    result = Rubycom::CommandInterface.build_usage(test_command, test_doc)
+
+    assert(result.include?(test_command.to_s),"#{result} should include #{test_command.to_s}")
+  end
+
+  def test_build_usage_method
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_doc = {
+        :full_doc => "A test_command with a return argument",
+        :short_doc => "A test_command with a return argument.",
+        :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}
+        ],
+        :tags => [
+            {:name => "test_arg", :tag_name => "param", :text => "a test argument", :types => ["String"]},
+            {:name => "test_option_int", :tag_name => "param", :text => "an optional test argument which happens to be an Integer", :types => ["Integer"]},
+            {:name => nil, :tag_name => "return", :text => "an array including both params if test_option_int != 1", :types => ["Array"]},
+            {:name => nil, :tag_name => "return", :text => "the first param if test_option_int == 1", :types => ["String"]}
+        ]
+    }
+    result = Rubycom::CommandInterface.build_usage(test_command, test_doc)
+
+    assert(result.include?(test_command.name.to_s),"#{result} should include #{test_command.name.to_s}")
+    test_doc[:parameters].each{|param|
+      if param[:type] == :req
+        assert(result.include?("<#{param[:param_name]}>"),"#{result} should include <#{param[:param_name]}>")
+      else
+        assert(result.include?(param[:param_name]),"#{result} should include #{param[:param_name]}")
+      end
+    }
+  end
+
+  def test_build_options_module
+    test_command = UtilTestModule
+    test_doc = {
+        :short_doc => "A command module used for testing.",
+        :full_doc => "A command module used for testing\n\nThis module contains most of the test case input methods.",
+        :sub_command_docs => {
+            :non_command => "A test non-command method.",
+            :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."
+        }
+    }
+    result = Rubycom::CommandInterface.build_options(test_command, test_doc)
+
+    assert(result.include?("<command>"),"#{result} should include <command>")
+  end
+
+  def test_build_options_method
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_doc = {
+        :full_doc => "A test_command with a return argument",
+        :short_doc => "A test_command with a return argument.",
+        :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}
+        ],
+        :tags => [
+            {:name => "test_arg", :tag_name => "param", :text => "a test argument", :types => ["String"]},
+            {:name => "test_option_int", :tag_name => "param", :text => "an optional test argument which happens to be an Integer", :types => ["Integer"]},
+            {:name => nil, :tag_name => "return", :text => "an array including both params if test_option_int != 1", :types => ["Array"]},
+            {:name => nil, :tag_name => "return", :text => "the first param if test_option_int == 1", :types => ["String"]}
+        ]
+    }
+    result = Rubycom::CommandInterface.build_options(test_command, test_doc)
+
+    test_doc[:parameters].each{|param|
+      if param[:type] == :req
+        assert(result.include?("<#{param[:param_name]}>"),"#{result} should include <#{param[:param_name]}>")
+      else
+        assert(result.include?(param[:param_name]),"#{result} should include #{param[:param_name]}")
+      end
+    }
+  end
+
+  def test_build_details_module
+    test_command = UtilTestModule
+    test_doc = {
+        :short_doc => "A command module used for testing.",
+        :full_doc => "A command module used for testing\n\nThis module contains most of the test case input methods.",
+        :sub_command_docs => {
+            :non_command => "A test non-command method.",
+            :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."
+        }
+    }
+    result = Rubycom::CommandInterface.build_details(test_command, test_doc)
+
+    assert(result.include?("Sub Commands:"),"#{result} should include Sub Commands:")
+    test_doc[:sub_command_docs].each{|cmd,doc|
+      assert(result.include?(cmd.to_s),"#{result} should include #{cmd.to_s}")
+      assert(result.gsub(/\s|\n|\r\n/,'').include?(doc.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{doc}")
+    }
+  end
+
+  def test_build_details_method
+    test_command = UtilTestModule.public_method(:test_command_with_return)
+    test_doc = {
+        :full_doc => "A test_command with a return argument",
+        :short_doc => "A test_command with a return argument.",
+        :parameters => [
+            {:default => nil, :doc => "a test argument", :doc_type => "String", :param_name => "test_arg", :required => true},
+            {:default => 1, :doc => "an optional test argument which happens to be an Integer", :doc_type => "Integer", :param_name => "test_option_int", :required => false}
+        ],
+        :tags => [
+            {:name => "test_arg", :tag_name => "param", :text => "a test argument", :types => ["String"]},
+            {:name => "test_option_int", :tag_name => "param", :text => "an optional test argument which happens to be an Integer", :types => ["Integer"]},
+            {:name => nil, :tag_name => "return", :text => "an array including both params if test_option_int != 1", :types => ["Array"]},
+            {:name => nil, :tag_name => "return", :text => "the first param if test_option_int == 1", :types => ["String"]}
+        ]
+    }
+    result = Rubycom::CommandInterface.build_details(test_command, test_doc)
+
+    assert(result.include?("Parameters:"),"#{result} should include Parameters:")
+    assert(result.include?("Returns:"),"#{result} should include Returns:")
+    test_doc[:tags].each{|tag|
+      if tag[:name].nil?
+        assert(result.include?(tag[:tag_name].to_s),"#{result} should include #{tag[:tag_name].to_s}")
+      else
+        assert(result.include?(tag[:name].to_s),"#{result} should include #{tag[:name].to_s}")
+      end
+      assert(result.gsub(/\s|\n|\r\n/,'').include?("#{tag[:types]}"),"#{result} should include #{tag[:types]}")
+      assert(result.gsub(/\s|\n|\r\n/,'').include?(tag[:text].gsub(/\s|\n|\r\n/,'')),"#{result} should include #{tag[:text]}")
+    }
+  end
+
+end

data/test/rubycom/completions_test.rb

@@ -0,0 +1,94 @@
+require "#{File.dirname(__FILE__)}/../../lib/rubycom/completions.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 CompletionsTest < Test::Unit::TestCase
+
+  def test_tab_complete_nil
+    base = nil
+    arguments = nil
+    command_plugin = nil
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = []
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_empty
+    base = ''
+    arguments = []
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = []
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_command_empty
+    base = UtilTestModule
+    arguments = []
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = UtilTestModule.singleton_methods(false).map{|n|n.to_s}
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_command_single_match
+    base = UtilTestModule
+    arguments = ['test_command']
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = []
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_command_all_match
+    base = UtilTestModule
+    arguments = ['test_']
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = UtilTestModule.singleton_methods(false).map{|n|n.to_s}
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_command_partial_match
+    base = UtilTestModule
+    arguments = ['test_command_with']
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = UtilTestModule.singleton_methods(false).map{|n|n.to_s}.select{|n|n.start_with?(arguments[0])}
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_module_empty
+    base = UtilTestComposite
+    arguments = []
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = UtilTestComposite.singleton_methods(false).map{|n|n.to_s}+
+        UtilTestComposite.included_modules.reject{|n|n == Rubycom}.map{|n|n.to_s}
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_module_partial_match
+    base = UtilTestComposite
+    arguments = ['Util']
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = UtilTestComposite.included_modules.reject{|n|n == Rubycom}.map{|n|n.to_s}
+    assert_equal(expected, result)
+  end
+
+  def test_tab_complete_module_single_match
+    base = UtilTestComposite
+    arguments = ['UtilTestModule']
+    command_plugin = Rubycom::SingletonCommands
+    result = Rubycom::Completions.tab_complete(base, arguments, command_plugin)
+    expected = UtilTestModule.singleton_methods(false).map{|n|n.to_s}
+    assert_equal(expected, result)
+  end
+
+end
+

data/test/rubycom/error_handler_test.rb

@@ -0,0 +1,72 @@
+require "#{File.dirname(__FILE__)}/../../lib/rubycom/error_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 ErrorHandlerTest < Test::Unit::TestCase
+
+  def capture_err(&block)
+    original_stderr = $stderr
+    $stderr = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stderr = original_stderr
+    end
+    fake.string
+  end
+
+  def test_handle_error
+    test_error = StandardError.new("test error")
+    test_cli_output = 'some test output'
+
+    result = capture_err { Rubycom::ErrorHandler.handle_error(test_error, test_cli_output) }
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_error.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_error.to_s}")
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_cli_output.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_cli_output}")
+  end
+
+  def test_handle_error_string
+    test_error = 'test error string'
+    test_cli_output = 'some test output'
+
+    result = capture_err { Rubycom::ErrorHandler.handle_error(test_error, test_cli_output) }
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_error.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_error.to_s}")
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_cli_output.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_cli_output}")
+  end
+
+  def test_handle_error_nil
+    test_error = nil
+    test_cli_output = nil
+
+    result = capture_err { Rubycom::ErrorHandler.handle_error(test_error, test_cli_output) }
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_error.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_error.to_s}")
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_cli_output.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_cli_output}")
+  end
+
+  def test_handle_error_empty
+    test_error = ''
+    test_cli_output = ''
+
+    result = capture_err { Rubycom::ErrorHandler.handle_error(test_error, test_cli_output) }
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_error.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_error.to_s}")
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_cli_output.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_cli_output}")
+  end
+
+  def test_handle_error_object
+    test_error = Object.new
+    test_cli_output = Object.new
+
+    result = capture_err { Rubycom::ErrorHandler.handle_error(test_error, test_cli_output) }
+
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_error.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_error.to_s}")
+    assert(result.gsub(/\s|\n|\r\n/,'').include?(test_cli_output.to_s.gsub(/\s|\n|\r\n/,'')),"#{result} should include #{test_cli_output}")
+  end
+
+end