methadone 0.5.1 → 1.0.0.rc1

data/lib/methadone/version.rb

@@ -1,3 +1,3 @@
 module Methadone
-  VERSION = "0.5.1"
+  VERSION = "1.0.0.rc1"
 end

data/methadone.gemspec

@@ -26,4 +26,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency("aruba")
   s.add_development_dependency("simplecov", "~> 0.5")
   s.add_development_dependency("clean_test", "~> 0.10")
+  s.add_development_dependency("mocha")
 end

data/test/command_for_tests.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+STDOUT.puts "standard output"
+STDERR.puts "standard error" if ARGV.length > 0
+exit ARGV.length

data/test/execution_strategy/test_base.rb

@@ -0,0 +1,24 @@
+require 'base_test'
+
+module ExecutionStrategy
+  class TestBase < BaseTest
+    include Methadone::ExecutionStrategy
+
+    [
+      [:run_command,["ls"]],
+      [:exception_meaning_command_not_found,[]],
+    ].each do |(method,args)|
+      test_that "#{method} isn't implemented" do
+        Given {
+          @strategy = Base.new
+        }
+        When {
+          @code = lambda { @strategy.send(method,*args) }
+        }
+        Then {
+          assert_raises(RuntimeError,&@code)
+        }
+      end
+    end
+  end
+end

data/test/execution_strategy/test_jvm.rb

@@ -0,0 +1,77 @@
+require 'base_test'
+require 'mocha'
+
+# Defined by JRuby, but this test must pass on any Ruby
+class NativeException
+end
+
+module ExecutionStrategy
+  class TestJVM < BaseTest
+    include Methadone::ExecutionStrategy
+
+    test_that "run_command proxies to Open3.capture3" do
+      Given {
+        @process = mock('java.lang.Process')
+        @runtime = mock('java.lang.Runtime')
+        @command = "ls"
+        @stdout = any_string
+        @stderr = any_string
+        @exitstatus = any_int :min => 1, :max => 127
+      }
+      When the_test_runs
+      Then {
+        expects_lang = mock()
+        JVM.any_instance.expects(:java).returns(expects_lang)
+        expects_Runtime = mock()
+        expects_lang.expects(:lang).returns(expects_Runtime)
+        runtime_klass = mock()
+        expects_Runtime.expects(:Runtime).returns(runtime_klass)
+        runtime_klass.expects(:get_runtime).returns(@runtime)
+        @runtime.expects(:exec).with(@command).returns(@process)
+
+        stdin = mock()
+        @process.expects(:get_output_stream).returns(stdin)
+        stdin.expects(:close)
+
+        stdout_input_stream = mock('InputStream')
+        @process.expects(:get_input_stream).returns(stdout_input_stream)
+        stdout_input_stream.expects(:read).times(2).returns(
+          @stdout,
+          -1)
+
+        stderr_input_stream = mock('InputStream')
+        @process.expects(:get_error_stream).returns(stderr_input_stream)
+        stderr_input_stream.expects(:read).times(2).returns(
+          @stderr,
+          -1)
+
+        @process.expects(:wait_for).returns(@exitstatus)
+      }
+
+      Given new_jvm_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should == @stdout
+        @results[1].should == @stderr
+        @results[2].exitstatus.should == @exitstatus
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns NativeException" do
+      Given new_jvm_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should == NativeException
+      }
+    end
+
+  private
+    def new_jvm_strategy
+      lambda { @strategy = JVM.new }
+    end
+  end
+end

data/test/execution_strategy/test_mri.rb

@@ -0,0 +1,32 @@
+require 'base_test'
+
+module ExecutionStrategy
+  class TestMRI < BaseTest
+    include Methadone::ExecutionStrategy
+
+    test_that "run_command isn't implemented" do
+      Given new_mri_strategy
+      When {
+        @code = lambda { @strategy.run_command("ls") }
+      }
+      Then {
+        assert_raises(RuntimeError,&@code)
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns Errno::ENOENT" do
+      Given new_mri_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should == Errno::ENOENT
+      }
+    end
+
+  private
+    def new_mri_strategy
+      lambda { @strategy = MRI.new }
+    end
+  end
+end

data/test/execution_strategy/test_open_3.rb

@@ -0,0 +1,47 @@
+require 'base_test'
+require 'mocha'
+require 'open3'
+
+module ExecutionStrategy
+  class TestOpen_3 < BaseTest
+    include Methadone::ExecutionStrategy
+
+    test_that "run_command proxies to Open3.capture3" do
+      Given {
+        @command = any_string
+        @stdout = any_string
+        @stderr = any_string
+        @status = stub('Process::Status')
+      }
+      When the_test_runs
+      Then {
+        Open3.expects(:capture3).with(@command).returns([@stdout,@stderr,@status])
+      }
+
+      Given new_open_3_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should == @stdout
+        @results[1].should == @stderr
+        @results[2].should be @status
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns Errno::ENOENT" do
+      Given new_open_3_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should == Errno::ENOENT
+      }
+    end
+
+  private
+    def new_open_3_strategy
+      lambda { @strategy = Open_3.new }
+    end
+  end
+end

data/test/execution_strategy/test_open_4.rb

@@ -0,0 +1,57 @@
+require 'base_test'
+require 'mocha'
+
+# Define this symbol without requiring the library;
+# all we're goingn to do is mock calls to it
+module Open4
+end
+
+module ExecutionStrategy
+  class TestOpen_4 < BaseTest
+    include Methadone::ExecutionStrategy
+
+    test_that "run_command proxies to Open4.capture4" do
+      Given {
+        @command = any_string
+        @stdin_io = mock("IO")
+        @stdout = any_string
+        @stdout_io = StringIO.new(@stdout)
+        @stderr = any_string
+        @stderr_io = StringIO.new(@stderr)
+        @pid = any_int :min => 2, :max => 65536
+        @status = stub('Process::Status')
+      }
+      When the_test_runs
+      Then {
+        Open4.expects(:popen4).with(@command).returns([@pid,@stdin_io,@stdout_io,@stderr_io])
+        @stdin_io.expects(:close)
+        Process.expects(:waitpid2).with(@pid).returns([any_string,@status])
+      }
+
+      Given new_open_4_strategy
+      When {
+        @results = @strategy.run_command(@command)
+      }
+      Then {
+        @results[0].should == @stdout
+        @results[1].should == @stderr
+        @results[2].should be @status
+      }
+    end
+
+    test_that "exception_meaning_command_not_found returns Errno::ENOENT" do
+      Given new_open_4_strategy
+      When {
+        @klass = @strategy.exception_meaning_command_not_found
+      }
+      Then {
+        @klass.should == Errno::ENOENT
+      }
+    end
+
+  private
+    def new_open_4_strategy
+      lambda { @strategy = Open_4.new }
+    end
+  end
+end

data/test/execution_strategy/test_rbx_open_4.rb

@@ -0,0 +1,25 @@
+require 'base_test'
+require 'mocha'
+
+# Define this symbol without requiring the library;
+# all we're goingn to do is mock calls to it
+module Open4
+end
+
+module ExecutionStrategy
+  class TestRBXOpen_4 < BaseTest
+    include Methadone::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
+      }
+    end
+  end
+end

data/test/test_sh.rb

@@ -0,0 +1,269 @@
+require 'test/unit'
+require 'clean_test/test_case'
+
+class TestSH < Clean::Test::TestCase
+  include Methadone::SH
+  include Methadone::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); @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 == 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 == 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 == 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 == test_command_stdout
+        @stderr_received.length.should == 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 == 1
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  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 == 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 == 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(Methadone::FailedCommandError,&@code)
+      exception.command.should == @command
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  class MyTestApp
+    include Methadone::SH
+    def initialize(logger)
+      set_sh_logger(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
+
+  class MyExecutionStrategy
+    include Clean::Test::Any
+    attr_reader :command
+
+    def initialize(exitcode)
+      @exitcode = exitcode
+      @command = nil
+    end
+
+    def run_command(command)
+      @command = command
+      [any_string,any_string,OpenStruct.new(:exitstatus => @exit_code)]
+    end
+
+    def exception_meaning_command_not_found
+      RuntimeError
+    end
+  end
+
+  class MyExecutionStrategyApp
+    include Methadone::CLILogging
+    include Methadone::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 == @command
+      @results.should == @exitstatus
+    }
+  end
+
+private
+
+  def assert_successful_command_execution(exit_code,logger,command,stdout)
+    exit_code.should == 0
+    logger.debugs[0].should == "Executing '#{command}'"
+    logger.debugs[1].should == "Output of '#{command}': #{stdout}"
+    logger.warns.length.should == 0
+  end
+
+  def assert_logger_output_for_failure(logger,command,stdout,stderr)
+    logger.debugs[0].should == "Executing '#{command}'"
+    logger.infos[0].should == "Output of '#{command}': #{stdout}"
+    logger.warns[0].should == "Error output of '#{command}': #{stderr}"
+    logger.warns[1].should == "Error running '#{command}'"
+  end
+
+  def use_capturing_logger
+    @logger = CapturingLogger.new
+    change_logger(@logger)
+  end
+
+  def test_command(args='')
+    File.join(File.dirname(__FILE__),'command_for_tests.rb') + ' ' + args
+  end
+
+  def test_command_stdout; "standard output"; end
+  def test_command_stderr; "standard error"; end
+
+end