optparse-plus 3.0.0

data/test/unit/test_sh.rb

@@ -0,0 +1,404 @@
+require 'base_test'
+require 'optparse_plus'
+
+class TestSH < BaseTest
+  include OptparsePlus::SH
+  include OptparsePlus::CLILogging
+
+  class CapturingLogger
+    attr_reader :debugs, :infos, :warns, :errors, :fatals
+
+    def initialize
+      @debugs = []
+      @infos = []
+      @warns = []
+      @errors = []
+      @fatals = []
+    end
+
+    def debug(msg); @debugs << msg; end
+    def info(msg); @infos << msg; end
+    def warn(msg); @warns << msg; end
+    def error(msg)
+      # Try to figure out what's going on on Travis
+      STDERR.puts msg if RUBY_PLATFORM == 'java'
+      @errors << msg
+    end
+    def fatal(msg); @fatals << msg; end
+
+  end
+
+  [:sh,:sh!].each do |method|
+    test_that "#{method} runs a successful command and logs about it" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+      }
+      When {
+        @exit_code = self.send(method,@command)
+      }
+      Then {
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
+
+    test_that "#{method}, when the command succeeds and given a block of one argument, gives that block the stdout" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+        @stdout_received = nil
+      }
+      When {
+        @exit_code = self.send(method,@command) do |stdout|
+          @stdout_received = stdout
+        end
+      }
+      Then {
+        @stdout_received.should be == test_command_stdout
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
+
+    test_that "#{method}, when the command succeeds and given a block of zero arguments, calls the block" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+        @block_called = false
+      }
+      When {
+        @exit_code = self.send(method,@command) do
+          @block_called = true
+        end
+      }
+      Then {
+        @block_called.should be == true
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
+
+    test_that "#{method}, when the command succeeds and given a lambda of zero arguments, calls the lambda" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+        @block_called = false
+        @lambda = lambda { @block_called = true }
+      }
+      When {
+        @exit_code = self.send(method,@command,&@lambda)
+      }
+      Then {
+        @block_called.should be == true
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
+
+    test_that "#{method}, when the command succeeds and given a block of two arguments, calls the block with the stdout and stderr" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+        @block_called = false
+        @stdout_received = nil
+        @stderr_received = nil
+      }
+      When {
+        @exit_code = self.send(method,@command) do |stdout,stderr|
+          @stdout_received = stdout
+          @stderr_received = stderr
+        end
+      }
+      Then {
+        @stdout_received.should be == test_command_stdout
+        @stderr_received.length.should be == 0
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
+
+    test_that "#{method}, when the command succeeds and given a block of three arguments, calls the block with the stdout, stderr, and exit code" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+        @block_called = false
+        @stdout_received = nil
+        @stderr_received = nil
+        @exitstatus_received = nil
+      }
+      When {
+        @exit_code = self.send(method,@command) do |stdout,stderr,exitstatus|
+          @stdout_received = stdout
+          @stderr_received = stderr
+          @exitstatus_received = exitstatus
+        end
+      }
+      Then {
+        @stdout_received.should be == test_command_stdout
+        @stderr_received.length.should be == 0
+        @exitstatus_received.should be == 0
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
+  end
+
+  test_that "sh, when the command fails and given a block, doesn't call the block" do
+    Given {
+      use_capturing_logger
+      @command = test_command("foo")
+      @block_called = false
+    }
+    When {
+      @exit_code = sh @command do
+        @block_called = true
+      end
+    }
+    Then {
+      @exit_code.should be == 1
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  test_that "sh, when the command fails with an unexpected status, and given a block, doesn't call the block" do
+    Given {
+      use_capturing_logger
+      @command = test_command("foo")
+      @block_called = false
+    }
+    When {
+      @exit_code = sh @command, :expected => [2] do
+        @block_called = true
+      end
+    }
+    Then {
+      @exit_code.should be == 1
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  [1,[1],[1,2]].each do |expected|
+    [:sh,:sh!].each do |method|
+      test_that "#{method}, when the command fails with an expected error code (using syntax #{expected}/#{expected.class}), treats it as success" do
+        Given {
+          use_capturing_logger
+          @command = test_command("foo")
+          @block_called = false
+          @exitstatus_received = nil
+        }
+        When {
+          @exit_code = self.send(method,@command,:expected => expected) do |_,_,exitstatus|
+            @block_called = true
+            @exitstatus_received = exitstatus
+          end
+        }
+        Then {
+          @exit_code.should be == 1
+          @block_called.should be == true
+          @exitstatus_received.should be == 1
+          @logger.debugs[0].should be == "Executing '#{test_command}foo'"
+          @logger.debugs[1].should be == "stdout output of '#{test_command}foo': #{test_command_stdout}"
+          @logger.warns[0].should be == "stderr output of '#{test_command}foo': #{test_command_stderr}"
+        }
+      end
+    end
+  end
+
+  test_that "sh runs a command that will fail and logs about it" do
+    Given {
+      use_capturing_logger
+      @command = test_command("foo")
+    }
+    When {
+      @exit_code = sh @command
+    }
+    Then {
+      @exit_code.should be == 1
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  test_that "sh runs a non-existent command that will fail and logs about it" do
+    Given {
+      use_capturing_logger
+      @command = "asdfasdfasdfas"
+    }
+    When {
+      @exit_code = sh @command
+    }
+    Then {
+      @exit_code.should be == 127 # consistent with what bash does
+      @logger.errors[0].should match(/^Error running '#{@command}': .+$/)
+    }
+  end
+
+  test_that "sh! runs a command that will fail and logs about it, but throws an exception" do
+    Given {
+      use_capturing_logger
+      @command = test_command("foo")
+    }
+    When {
+      @code = lambda { sh! @command }
+    }
+    Then {
+      exception = assert_raises(OptparsePlus::FailedCommandError,&@code)
+      exception.command.should be == @command
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  test_that "sh! runs a command that will fail and includes an error message that appears in the exception" do
+    Given {
+      use_capturing_logger
+      @command = test_command("foo")
+      @custom_error_message = any_sentence
+    }
+    When {
+      @code = lambda { sh! @command, :on_fail => @custom_error_message }
+    }
+    Then {
+      exception = assert_raises(OptparsePlus::FailedCommandError,&@code)
+      exception.command.should be == @command
+      exception.message.should be == @custom_error_message
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  class MyTestApp
+    include OptparsePlus::SH
+    def initialize(logger=nil)
+      set_sh_logger(logger) if logger
+    end
+  end
+
+  test_that "when we don't have CLILogging included, we can still provide our own logger" do
+    Given {
+      @logger = CapturingLogger.new
+      @test_app = MyTestApp.new(@logger)
+      @command = test_command
+    }
+    When {
+      @exit_code = @test_app.sh @command
+    }
+    Then {
+      assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+    }
+  end
+
+  test_that "when we don't have CLILogging included and fail to provide a logger, an exception is thrown" do
+    Given {
+      @test_app = MyTestApp.new
+      @command = test_command
+    }
+    When {
+      @code = lambda { @test_app.sh @command }
+    }
+    Then {
+      assert_raises(StandardError,&@code)
+    }
+  end
+
+  class MyExecutionStrategy
+    include Clean::Test::Any
+    attr_reader :command
+
+    def initialize(exitcode)
+      @exitcode = exitcode
+      @command = nil
+    end
+
+    def run_command(command)
+      @command = command
+      if @exitcode.kind_of? Integer
+        [any_string,any_string,OpenStruct.new(:exitstatus => @exitcode)]
+      else
+        [any_string,any_string,@exitcode]
+      end
+    end
+
+    def exception_meaning_command_not_found
+      RuntimeError
+    end
+  end
+
+  class MyExecutionStrategyApp
+    include OptparsePlus::CLILogging
+    include OptparsePlus::SH
+
+    attr_reader :strategy
+
+    def initialize(exit_code)
+      @strategy = MyExecutionStrategy.new(exit_code)
+      set_execution_strategy(@strategy)
+      set_sh_logger(CapturingLogger.new)
+    end
+  end
+
+  test_that "when I provide a custom execution strategy, it gets used" do
+    Given {
+      @exit_code = any_int :min => 0, :max => 127
+      @app = MyExecutionStrategyApp.new(@exit_code)
+      @command = "ls"
+    }
+    When {
+      @results = @app.sh(@command)
+    }
+    Then {
+      @app.strategy.command.should be == @command
+      @results.should be == @exit_code
+    }
+  end
+
+  test_that "when the execution strategy returns a non-int, but truthy value, it gets coerced into a 0" do
+    Given {
+      @app = MyExecutionStrategyApp.new(true)
+      @command = "ls"
+    }
+    When {
+      @results = @app.sh(@command)
+    }
+    Then {
+      @app.strategy.command.should be == @command
+      @results.should be == 0
+    }
+  end
+
+  test_that "when the execution strategy returns a non-int, but falsey value, it gets coerced into a 1" do
+    Given {
+      @app = MyExecutionStrategyApp.new(false)
+      @command = "ls"
+    }
+    When {
+      @results = @app.sh(@command)
+    }
+    Then {
+      @app.strategy.command.should be == @command
+      @results.should be == 1
+    }
+  end
+
+private
+
+  def assert_successful_command_execution(exit_code,logger,command,stdout)
+    exit_code.should be == 0
+    logger.debugs[0].should be == "Executing '#{command}'"
+    logger.debugs[1].should be == "stdout output of '#{command}': #{stdout}"
+    logger.warns.length.should be == 0
+  end
+
+  def assert_logger_output_for_failure(logger,command,stdout,stderr)
+    logger.debugs[0].should be == "Executing '#{command}'"
+    logger.infos[0].should be == "stdout output of '#{command}': #{stdout}"
+    logger.warns[0].should be == "stderr output of '#{command}': #{stderr}"
+    logger.warns[1].should be == "Error running '#{command}'"
+  end
+
+  def use_capturing_logger
+    @logger = CapturingLogger.new
+    change_logger(@logger)
+  end
+
+  # Runs the test command which exits with the length of ARGV/args
+  def test_command(args='')
+    File.join(File.expand_path(File.dirname(__FILE__)),'command_for_tests.sh') + ' ' + args
+  end
+
+  def test_command_stdout; "standard output"; end
+  def test_command_stderr; "standard error"; end
+
+end

metadata

@@ -0,0 +1,260 @@
+--- !ruby/object:Gem::Specification
+name: optparse-plus
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- davetron5000
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: sdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: clean_test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: OptparsePlus provides a lot of small but useful features for developing
+  a command-line app, including an opinionated bootstrapping process, some helpful
+  integration test support, and some classes to bridge logging and output into a simple,
+  unified, interface
+email:
+- davetron5000 at gmail.com
+executables:
+- optparse_plus
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- bin/optparse_plus
+- fix.rb
+- lib/optparse-plus.rb
+- lib/optparse_plus.rb
+- lib/optparse_plus/argv_parser.rb
+- lib/optparse_plus/cli.rb
+- lib/optparse_plus/cli_logger.rb
+- lib/optparse_plus/cli_logging.rb
+- lib/optparse_plus/cucumber.rb
+- lib/optparse_plus/error.rb
+- lib/optparse_plus/execution_strategy/base.rb
+- lib/optparse_plus/execution_strategy/jvm.rb
+- lib/optparse_plus/execution_strategy/mri.rb
+- lib/optparse_plus/execution_strategy/open_3.rb
+- lib/optparse_plus/execution_strategy/open_4.rb
+- lib/optparse_plus/execution_strategy/rbx_open_4.rb
+- lib/optparse_plus/exit_now.rb
+- lib/optparse_plus/main.rb
+- lib/optparse_plus/process_status.rb
+- lib/optparse_plus/sh.rb
+- lib/optparse_plus/test/base_integration_test.rb
+- lib/optparse_plus/test/integration_test_assertions.rb
+- lib/optparse_plus/version.rb
+- optparse_plus.gemspec
+- templates/full/.gitignore.erb
+- templates/full/README.rdoc.erb
+- templates/full/Rakefile.erb
+- templates/full/_license_head.txt.erb
+- templates/full/apache_LICENSE.txt.erb
+- templates/full/bin/executable.erb
+- templates/full/custom_LICENSE.txt.erb
+- templates/full/gplv2_LICENSE.txt.erb
+- templates/full/gplv3_LICENSE.txt.erb
+- templates/full/mit_LICENSE.txt.erb
+- templates/rspec/spec/something_spec.rb.erb
+- templates/test_unit/test/integration/test_cli.rb.erb
+- templates/test_unit/test/unit/test_something.rb.erb
+- test/integration/base_integration_test.rb
+- test/integration/test_bootstrap.rb
+- test/integration/test_cli.rb
+- test/integration/test_license.rb
+- test/integration/test_readme.rb
+- test/integration/test_rspec.rb
+- test/integration/test_version.rb
+- test/unit/base_test.rb
+- test/unit/command_for_tests.sh
+- test/unit/execution_strategy/test_base.rb
+- test/unit/execution_strategy/test_jvm.rb
+- test/unit/execution_strategy/test_mri.rb
+- test/unit/execution_strategy/test_open_3.rb
+- test/unit/execution_strategy/test_open_4.rb
+- test/unit/execution_strategy/test_rbx_open_4.rb
+- test/unit/test/test_integration_test_assertions.rb
+- test/unit/test_cli_logger.rb
+- test/unit/test_cli_logging.rb
+- test/unit/test_exit_now.rb
+- test/unit/test_main.rb
+- test/unit/test_sh.rb
+homepage: http://github.com/davetron5000/optparse-plus
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Wrapper around the Standard Library's Option Parser to make CLIs Easier
+test_files:
+- test/integration/base_integration_test.rb
+- test/integration/test_bootstrap.rb
+- test/integration/test_cli.rb
+- test/integration/test_license.rb
+- test/integration/test_readme.rb
+- test/integration/test_rspec.rb
+- test/integration/test_version.rb
+- test/unit/base_test.rb
+- test/unit/command_for_tests.sh
+- test/unit/execution_strategy/test_base.rb
+- test/unit/execution_strategy/test_jvm.rb
+- test/unit/execution_strategy/test_mri.rb
+- test/unit/execution_strategy/test_open_3.rb
+- test/unit/execution_strategy/test_open_4.rb
+- test/unit/execution_strategy/test_rbx_open_4.rb
+- test/unit/test/test_integration_test_assertions.rb
+- test/unit/test_cli_logger.rb
+- test/unit/test_cli_logging.rb
+- test/unit/test_exit_now.rb
+- test/unit/test_main.rb
+- test/unit/test_sh.rb