optparse-plus 3.0.0

data/test/unit/execution_strategy/test_rbx_open_4.rb

@@ -0,0 +1,25 @@
+require 'base_test'
+require 'mocha/test_unit'
+
+# Define this symbol without requiring the library;
+# all we're going to do is mock calls to it
+module Open4
+end
+
+module ExecutionStrategy
+  class TestRBXOpen_4 < BaseTest
+    include OptparsePlus::ExecutionStrategy
+
+    test_that "exception_meaning_command_not_found returns Errno::EINVAL" do
+      Given {
+        @strategy = RBXOpen_4.new
+      }
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should == [Errno::EINVAL,Errno::ENOENT]
+      }
+    end
+  end
+end

data/test/unit/test/test_integration_test_assertions.rb

@@ -0,0 +1,211 @@
+require 'base_test'
+require 'optparse_plus'
+require 'optparse_plus/test/integration_test_assertions'
+require 'fileutils'
+require 'tmpdir'
+
+class TestIntegrationTestAssertions < BaseTest
+  include OptparsePlus::IntegrationTestAssertions
+  include FileUtils
+
+  def setup
+    @pwd = pwd
+    @tmpdir = Dir.mktmpdir
+    chdir @tmpdir
+  end
+
+  def teardown
+    chdir @pwd
+    rm_rf @tmpdir
+  end
+
+  test_that "assert_file works with one regexp" do
+    Given { some_file }
+    When {
+      @code = ->() { assert_file("some_file.txt", contains: /foo/) }
+    }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_file works with many regexps" do
+    Given { some_file }
+    When {
+      @code = ->() { assert_file("some_file.txt", contains: [ /foo/, /bar/ ]) }
+    }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_file fails if any regexp fails to match" do
+    Given { some_file }
+    When {
+      @code = ->() { assert_file("some_file.txt", contains: [ /foo/, /baz/ ]) }
+    }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_banner without takes_options passes for a banner with the bin name and no '[options]'" do
+    Given {
+      @bin_name = "foobar"
+      @stdout = "Usage: foobar"
+    }
+    When {
+      @code = ->() { assert_banner(@stdout,@bin_name,takes_options: false) }
+    }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_banner without takes_options fails for a banner with the bin name and '[options]'" do
+    Given {
+      @bin_name = "foobar"
+      @stdout = "Usage: foobar [options]"
+    }
+    When {
+      @code = ->() { assert_banner(@stdout,@bin_name,takes_options: false) }
+    }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_banner with takes_options passes for a banner with the bin name and '[options]'" do
+    Given {
+      @bin_name = "foobar"
+      @stdout = "Usage: foobar [options]\nOptions\n  --help"
+    }
+    When {
+      @code = ->() { assert_banner(@stdout,@bin_name,takes_options: true) }
+    }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_banner with takes_options fails for a banner with the bin name but no '[options]'" do
+    Given {
+      @bin_name = "foobar"
+      @stdout = "Usage: foobar\nOptions\n  --help"
+    }
+    When {
+      @code = ->() { assert_banner(@stdout,@bin_name,takes_options: true) }
+    }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_banner with takes_options and takes_arguments passes for a banner with the bin name, '[options]' and the arg list" do
+    Given {
+      @bin_name = "foobar"
+      @stdout = "Usage: foobar [options] some_arg [some_other_arg]\nOptions\n  --help"
+    }
+    When {
+      @code = ->() {
+        assert_banner(@stdout,
+                      @bin_name,
+                      takes_options: true,
+                      takes_arguments: { some_arg: :required, some_other_arg: :optional }
+                     )
+      }
+    }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_banner with takes_options and takes_arguments failes for a banner with the bin name, '[options]' and no arg list" do
+    Given {
+      @bin_name = "foobar"
+      @stdout = "Usage: foobar [options]\nOptions\n  --help"
+    }
+    When {
+      @code = ->() {
+        assert_banner(@stdout,
+                      @bin_name,
+                      takes_options: true,
+                      takes_arguments: { some_arg: :required, some_other_arg: :optional }
+                     )
+      }
+    }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_options with one option passes when stdout contains that option" do
+    Given { @stdout = some_options }
+    When { @code = ->() { assert_option(@stdout,"--help") } }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_options with many option passes when stdout contains that option" do
+    Given { @stdout = some_options }
+    When { @code = ->() { assert_option(@stdout,"-h", "--help") } }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_options fails when stdout does not the option" do
+    Given { @stdout = some_options }
+    When { @code = ->() { assert_option(@stdout,"--bleorg") } }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_oneline_summary passes when the stdout has at least three lines, the second of which is blank and the third of which has some words in it" do
+    Given {
+      @stdout = [
+        "Usage: foobar",
+        "",
+        "The awesome app of awesome",
+      ].join("\n")
+    }
+    When { @code = ->() { assert_oneline_summary(@stdout) } }
+    Then { refute_raises(&@code) }
+  end
+
+  test_that "assert_oneline_summary fails when the stdout has at least three lines, the second of which is blank and the third of which has only one word in it" do
+    Given {
+      @stdout = [
+        "Usage: foobar",
+        "",
+        "awesome",
+      ].join("\n")
+    }
+    When { @code = ->() { assert_oneline_summary(@stdout) } }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_oneline_summary fails when the stdout has at least three lines, the second of which is not blank and the third of which has words in it" do
+    Given {
+      @stdout = [
+        "Usage: foobar",
+        "foo",
+        "awesome app of awesome",
+      ].join("\n")
+    }
+    When { @code = ->() { assert_oneline_summary(@stdout) } }
+    Then { assert_raises(&@code) }
+  end
+
+  test_that "assert_oneline_summary fails when the stdout has less than three lines" do
+    Given {
+      @stdout = [
+        "Usage: foobar",
+        "awesome app of awesome",
+      ].join("\n")
+    }
+    When { @code = ->() { assert_oneline_summary(@stdout) } }
+    Then { assert_raises(&@code) }
+  end
+
+private
+
+  def some_options
+    [
+      "-h, --help     Get Help",
+      "--version      Show the version",
+      "--[no-]output  Print output",
+    ].join("\n")
+  end
+
+  def refute_raises(&block)
+    block.()
+  rescue Exception => ex
+    assert false, "Expected block NOT to raise, but got a #{ex.class}/#{ex.message}"
+  end
+
+  def some_file
+    File.open("some_file.txt","w") do |file|
+      file.puts "foo"
+      file.puts "bar"
+    end
+  end
+end

data/test/unit/test_cli_logger.rb

@@ -0,0 +1,219 @@
+require 'base_test'
+require 'optparse_plus'
+require 'stringio'
+require 'tempfile'
+
+class TestCLILogger < BaseTest
+  include OptparsePlus
+  
+  def setup
+    @blank_format = proc { |severity,datetime,progname,msg|
+      msg + "\n"
+    }
+    @real_stderr = $stderr
+    @real_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+  end
+
+  def teardown
+    $stderr = @real_stderr
+    $stdout = @real_stdout
+  end
+
+  test_that "when both stderr and stdin are ttys, split the log messages between them and don't format" do
+    Given {
+      class << $stderr
+        def tty?; true; end
+      end
+      class << $stdout
+        def tty?; true; end
+      end
+
+      @logger = CLILogger.new
+      @logger.level = Logger::DEBUG
+    }
+
+    When log_all_levels
+
+    Then {
+      $stdout.string.should be == "debug\ninfo\n"
+      $stderr.string.should be == "warn\nerror\nfatal\n"
+    }
+  end
+
+  test_that "when both stderr and stdin are ttys, setting the level higher than WARN should affect the error logger" do
+    Given {
+      class << $stderr
+        def tty?; true; end
+      end
+      class << $stdout
+        def tty?; true; end
+      end
+
+      @logger = CLILogger.new
+      @logger.level = Logger::ERROR
+    }
+
+    When log_all_levels
+
+    Then {
+      $stdout.string.should be == ""
+      $stderr.string.should be == "error\nfatal\n"
+    }
+  end
+
+  test_that "logger sends debug and info to stdout, and warns, errors, and fatals to stderr" do
+    Given a_logger_with_blank_format
+    When log_all_levels
+
+    Then stdout_should_have_everything
+    And {
+      $stderr.string.should be == "warn\nerror\nfatal\n"
+    }
+  end
+
+  test_that "we can control what goes to stderr" do
+    Given a_logger_with_blank_format :at_error_level => Logger::Severity::FATAL
+
+    When log_all_levels
+
+    Then stdout_should_have_everything
+    And {
+      $stderr.string.should be == "fatal\n"
+    }
+  end
+
+  test_that "we can log to alternate devices easily" do
+    Given {
+      @out = StringIO.new
+      @err = StringIO.new
+
+      @logger = CLILogger.new(@out,@err)
+      @logger.level = Logger::DEBUG
+      @logger.formatter = @blank_format
+    }
+
+    When log_all_levels
+
+    Then {
+      @out.string.should be == "debug\ninfo\nwarn\nerror\nfatal\n"
+      @err.string.should be == "warn\nerror\nfatal\n"
+    }
+  end
+
+
+  test_that "error logger ignores the log level" do
+    Given a_logger_with_blank_format :at_level => Logger::Severity::FATAL
+    When log_all_levels
+
+    Then {
+      $stdout.string.should be == "fatal\n"
+      $stderr.string.should be == "warn\nerror\nfatal\n"
+    }
+  end
+
+  test_that "both loggers use the same date format" do
+    Given {
+    @logger = CLILogger.new
+    @logger.level = Logger::DEBUG
+    @logger.datetime_format = "the time"
+    }
+
+    When {
+      @logger.debug("debug")
+      @logger.error("error")
+    }
+
+    Then {
+      $stdout.string.should match(/the time.*DEBUG.*debug/)
+      $stderr.string.should match(/the time.*ERROR.*error/)
+    }
+  end
+
+  test_that "error logger does not get <<" do
+    Given a_logger_with_blank_format
+    When {
+      @logger << "foo"
+    }
+    Then {
+      $stdout.string.should be == "foo"
+      $stderr.string.should be == ""
+    }
+  end
+
+  test_that "error logger can have a different format" do
+    Given {
+      @logger = logger_with_blank_format
+      @logger.error_formatter = proc do |severity,datetime,progname,msg|
+        "ERROR_LOGGER: #{msg}\n"
+      end
+    }
+    When {
+      @logger.debug("debug")
+      @logger.error("error")
+    }
+    Then {
+      $stdout.string.should be == "debug\nerror\n"
+      $stderr.string.should be == "ERROR_LOGGER: error\n"
+    }
+  end
+
+  test_that "we can use filenames as log devices" do
+    Given {
+      tempfile = Tempfile.new("stderr_log")
+      @stdout_file = tempfile.path
+      tempfile.close
+
+      tempfile = Tempfile.new("stdout_log")
+      @stderr_file = tempfile.path
+      tempfile.close
+    }
+    When {
+      @logger = CLILogger.new(@stdout_file,@stderr_file)
+      @logger.info("some info")
+      @logger.error("some error")
+    }
+    Then {
+      File.read(@stdout_file).should =~ /some info/
+      File.read(@stderr_file).should =~ /some error/
+    }
+  end
+
+  private 
+
+  def log_all_levels
+    proc do
+      @logger.debug("debug")
+      @logger.info("info")
+      @logger.warn("warn")
+      @logger.error("error")
+      @logger.fatal("fatal")
+    end
+  end
+
+
+  def logger_with_blank_format
+    logger = CLILogger.new
+    logger.formatter = @blank_format
+    logger.level = Logger::Severity::DEBUG
+    logger
+  end
+
+  # options - :at_level - level to set the logger
+  def a_logger_with_blank_format(options = {})
+    proc do
+      @logger = logger_with_blank_format
+      @logger.level = options[:at_level] if options[:at_level]
+      @logger.error_level = options[:at_error_level] if options[:at_error_level]
+    end
+  end
+
+  def stdout_should_have_everything
+    proc do
+      $stdout.string.should be == "debug\ninfo\nwarn\nerror\nfatal\n"
+    end
+  end
+
+
+end