methadone-rehab 1.9.2

data/test/execution_strategy/test_open_4.rb

@@ -0,0 +1,86 @@
+require 'base_test'
+require 'mocha/setup'
+
+# 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 "run_command handles array arguments properly" do
+      Given {
+        @command = [any_string, any_string, 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/setup'
+
+# 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 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,Errno::ENOENT]
+      }
+    end
+  end
+end

data/test/test_cli_logger.rb

@@ -0,0 +1,219 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+require 'tempfile'
+
+class TestCLILogger < BaseTest
+  include Methadone
+  
+  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 == "debug\ninfo\n"
+      $stderr.string.should == "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 == ""
+      $stderr.string.should == "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 == "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 == "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 == "debug\ninfo\nwarn\nerror\nfatal\n"
+      @err.string.should == "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 == "fatal\n"
+      $stderr.string.should == "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 == "foo"
+      $stderr.string.should == ""
+    }
+  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 == "debug\nerror\n"
+      $stderr.string.should == "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 == "debug\ninfo\nwarn\nerror\nfatal\n"
+    end
+  end
+
+
+end

data/test/test_cli_logging.rb

@@ -0,0 +1,243 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+
+class TestCLILogging < BaseTest
+  include Methadone
+
+  SLEEP_TIME = 0.1
+
+  def setup
+    @blank_format = proc do |severity,datetime,progname,msg|
+      msg + "\n"
+    end
+    @real_stderr = $stderr
+    @real_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+  end
+
+  def teardown
+    $stderr = @real_stderr
+    $stdout = @real_stdout
+  end
+
+  test_that "a class can include CLILogging and get terser logging" do
+    Given {
+      @class_with_logger = MyClassThatLogsToStdout.new
+    }
+
+    When {
+      @class_with_logger.doit
+    }
+
+    Then {
+      $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
+      $stderr.string.should == "warn\nerror\nfatal\n"
+    }
+  end
+
+  test_that "another class using CLILogging gets the same logger instance" do
+    Given {
+      @first = MyClassThatLogsToStdout.new
+      @second = MyOtherClassThatLogsToStdout.new
+    }
+    Then {
+      @first.logger_id.should == @second.logger_id
+    }
+  end
+
+  test_that "we can change the global logger via self." do
+    Given {
+      @first = MyClassThatLogsToStdout.new
+      @second = MyOtherClassThatLogsToStdout.new
+      @logger_id = @second.logger_id
+    }
+    When {
+      @second.instance_eval do
+        self.logger=(Methadone::CLILogger.new)
+      end
+    }
+    Then {
+      @logger_id.should_not == @second.logger_id
+      @first.logger_id.should == @second.logger_id
+    }
+  end
+
+  test_that "we can change the global logger change_logger()" do
+    Given {
+      @first = MyClassThatLogsToStdout.new
+      @second = MyOtherClassThatLogsToStdout.new
+      @logger_id = @second.logger_id
+    }
+    When {
+      @second.instance_eval do
+        change_logger(Logger.new(STDERR))
+      end
+    }
+    Then {
+      @logger_id.should_not == @second.logger_id
+      @first.logger_id.should == @second.logger_id
+    }
+  end
+
+  test_that "we cannot use a nil logger" do
+    Given {
+      @other_class = MyOtherClassThatLogsToStdout.new
+    }
+    Then {
+      lambda { 
+        MyOtherClassThatLogsToStdout.new.instance_eval do
+          self.logger=(nil)
+        end
+      }.should raise_error(ArgumentError)
+    }
+  end
+
+  test_that "when we call use_log_level_option, it sets up logging level CLI options" do
+    Given {
+      @app = MyAppThatActsLikeItUsesMain.new
+      @app.call_use_log_level_option
+      @level = any_int
+    }
+    When {
+      @app.use_option(@level)
+    }
+    Then {
+      @app.logger.level.should == @level
+    }
+  end
+
+  test_that "when we call use_log_level_option, then later change the logger, that logger gets the proper level set" do
+    Given {
+      @app = MyAppThatActsLikeItUsesMain.new
+      @app.call_use_log_level_option
+      @level = any_int
+    }
+    When {
+      @app.use_option(@level)
+      @other_logger = OpenStruct.new
+      @app.change_logger(@other_logger)
+    }
+    Then {
+      @other_logger.level.should == @level
+    }
+  end
+
+
+  test_that "when we enable runtime log level toggling, it toggles the log level on receiving the set signal" do
+    Given {
+      @app = MyAppThatActsLikeItUsesMain.new
+      @app.call_use_log_level_option( :toggle_debug_on_signal => 'USR2' )
+      @level = Logger::INFO
+      @app.use_option(@level)
+    }
+    When {
+      send_signal_and_wait_a_moment('USR2')
+    }
+    Then {
+      @app.logger.level.should == Logger::DEBUG
+    }
+  end
+
+  test_that "when we toggle the log level and change the logger, the new logger has also it's log level increased" do
+    Given {
+      @app = MyAppThatActsLikeItUsesMain.new
+      @app.call_use_log_level_option( :toggle_debug_on_signal => 'USR2' )
+      @level = Logger::INFO
+      @app.use_option(@level)
+    }
+    When {
+      send_signal_and_wait_a_moment('USR2')
+      @other_logger = OpenStruct.new
+      @app.change_logger(@other_logger)
+    }
+    Then {
+      @other_logger.level.should == Logger::DEBUG
+    }
+  end
+
+  test_that "when we enable runtime log level toggling and send the signal twice, the original log level is restored" do
+    Given {
+      @app = MyAppThatActsLikeItUsesMain.new
+      @app.call_use_log_level_option( :toggle_debug_on_signal => 'USR2' )
+      @level = Logger::INFO
+      @app.use_option(@level)
+    }
+    When {
+      send_signal_and_wait_a_moment('USR2')
+      send_signal_and_wait_a_moment('USR2')
+    }
+    Then {
+      @app.logger.level.should == Logger::INFO
+    }
+  end
+
+
+  class MyAppThatActsLikeItUsesMain
+    include Methadone::CLILogging
+
+    def call_use_log_level_option(args = {})
+      use_log_level_option(args)
+    end
+
+    def use_option(level)
+      @block.call(level)
+    end
+
+    def on(*args,&block)
+      @block = block
+    end
+
+    def logger
+      @logger ||= OpenStruct.new
+    end
+  end
+
+  class MyClassThatLogsToStdout
+    include Methadone::CLILogging
+
+    def initialize
+      logger.formatter = proc do |severity,datetime,progname,msg|
+        msg + "\n"
+      end
+      logger.level = Logger::DEBUG
+    end
+
+    def doit
+      debug("debug")
+      info("info")
+      warn("warn")
+      error("error")
+      fatal("fatal")
+    end
+
+    def logger_id; logger.object_id; end
+  end
+
+
+  class MyOtherClassThatLogsToStdout
+    include Methadone::CLILogging
+
+    def initialize
+      logger.formatter = proc do |severity,datetime,progname,msg|
+        msg + "\n"
+      end
+    end
+
+    def doit
+      debug("debug")
+      info("info")
+      warn("warn")
+      error("error")
+      fatal("fatal")
+    end
+
+    def logger_id; logger.object_id; end
+  end
+
+  def send_signal_and_wait_a_moment(signal)
+    Process.kill(signal, $$)
+    sleep(SLEEP_TIME) # call sleep to give the trap handler a chance to kick in
+  end
+end