methadone 0.3.0 → 0.3.1

data/lib/methadone/version.rb

@@ -1,3 +1,3 @@
 module Methadone
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/methadone.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency("rdoc","~> 3.9")
   s.add_development_dependency("aruba")
   s.add_development_dependency("simplecov", "~> 0.5")
+  s.add_development_dependency("test_unit-given", ">= 0.1.1")
 end

data/templates/full/.gitignore.erb

@@ -0,0 +1,4 @@
+.DS_Store
+results.html
+pkg
+html

data/templates/full/README.rdoc.erb

@@ -0,0 +1,19 @@
+= <%= gemname %> - DESCRIBE YOUR GEM
+
+Author::  YOUR NAME (YOUR EMAIL)
+Copyright:: Copyright (c) <%= Time.now.year %> YOUR NAME
+License:: 
+
+DESCRIBE YOUR GEM HERE
+
+== Links
+
+* {Source on Github}[LINK TO GITHUB]
+* RDoc[LINK TO RDOC.INFO]
+
+== Install
+
+== Examples
+
+== Contributing
+

data/templates/full/Rakefile.erb

@@ -3,6 +3,7 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'cucumber'
 require 'cucumber/rake/task'
+gem 'rdoc' # we need the installed RDoc gem, not the system one
 require 'rdoc/task'
 
 include Rake::DSL
@@ -21,7 +22,9 @@ Cucumber::Rake::Task.new(:features) do |t|
 end
 
 Rake::RDocTask.new do |rd|
+  <% if using_readme %>
   rd.main = "README.rdoc"
+  <% end %>
   rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
 end
 

data/test/base_test.rb

@@ -4,8 +4,9 @@ SimpleCov.start do
 end
 require 'test/unit'
 require 'rspec/expectations'
+require 'test/unit/given'
 
-class BaseTest < Test::Unit::TestCase
+class BaseTest < Test::Unit::Given::TestCase
   # Copied from Rails; makes a test method using a string
   def self.test(name, &block)
     test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
@@ -19,4 +20,8 @@ class BaseTest < Test::Unit::TestCase
       end
     end
   end
+
+  def test_nothing
+    # Seems 1.8 wants to have a test here?
+  end
 end

data/test/test_cli_logger.rb

@@ -20,116 +20,136 @@ class TestCLILogger < BaseTest
     $stdout = @real_stdout
   end
 
-  test "when both stderr and stdin are ttys, split the log messages between them and don't format" do
-    class << $stderr
-      def tty?; true; end
-    end
-    class << $stdout
-      def tty?; true; end
-    end
-
-    logger = CLILogger.new
-    logger.level = Logger::DEBUG
+  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
+    }
 
-    logger.debug("debug")
-    logger.info("info")
-    logger.warn("warn")
-    logger.error("error")
-    logger.fatal("fatal")
+    When log_all_levels
 
-    $stdout.string.should == "debug\ninfo\n"
-    $stderr.string.should == "warn\nerror\nfatal\n"
+    Then {
+      $stdout.string.should == "debug\ninfo\n"
+      $stderr.string.should == "warn\nerror\nfatal\n"
+    }
   end
 
-  test "logger sends debug and info to stdout, and warns, errors, and fatals to stderr" do
-    logger = logger_with_blank_format
-
-    logger.debug("debug")
-    logger.info("info")
-    logger.warn("warn")
-    logger.error("error")
-    logger.fatal("fatal")
+  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
 
-    $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
-    $stderr.string.should == "warn\nerror\nfatal\n"
+    Then stdout_should_have_everything
+    And {
+      $stderr.string.should == "warn\nerror\nfatal\n"
+    }
   end
 
-  test "we can control what goes to stderr" do
-    logger = logger_with_blank_format
-    logger.error_level = Logger::Severity::FATAL
+  test_that "we can control what goes to stderr" do
+    Given a_logger_with_blank_format :at_error_level => Logger::Severity::FATAL
 
-    logger.debug("debug")
-    logger.info("info")
-    logger.warn("warn")
-    logger.error("error")
-    logger.fatal("fatal")
+    When log_all_levels
 
-    $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
-    $stderr.string.should == "fatal\n"
+    Then stdout_should_have_everything
+    And {
+      $stderr.string.should == "fatal\n"
+    }
   end
 
-  test "we can log to alternate devices easily" do
-    out = StringIO.new
-    err = StringIO.new
+  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
+      @logger = CLILogger.new(@out,@err)
+      @logger.level = Logger::DEBUG
+      @logger.formatter = @blank_format
+    }
 
-    logger.debug("debug")
-    logger.info("info")
-    logger.warn("warn")
-    logger.error("error")
-    logger.fatal("fatal")
+    When log_all_levels
 
-    out.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
-    err.string.should == "warn\nerror\nfatal\n"
+    Then {
+      @out.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
+      @err.string.should == "warn\nerror\nfatal\n"
+    }
   end
 
 
-  test "error logger ignores the log level" do
-    logger = logger_with_blank_format
-    logger.level = Logger::Severity::FATAL
-    logger.debug("debug")
-    logger.info("info")
-    logger.warn("warn")
-    logger.error("error")
-    logger.fatal("fatal")
+  test_that "error logger ignores the log level" do
+    Given a_logger_with_blank_format :at_level => Logger::Severity::FATAL
+    When log_all_levels
 
-    $stdout.string.should == "fatal\n"
-    $stderr.string.should == "warn\nerror\nfatal\n"
+    Then {
+      $stdout.string.should == "fatal\n"
+      $stderr.string.should == "warn\nerror\nfatal\n"
+    }
   end
 
-  test "both loggers use the same date format" do
-    logger = CLILogger.new
-    logger.level = Logger::DEBUG
-    logger.datetime_format = "the time"
-    logger.debug("debug")
-    logger.error("error")
-    $stdout.string.should match /the time.*DEBUG.*debug/
-    $stderr.string.should match /the time.*ERROR.*error/
+  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 "error logger does not get <<" do
-    logger = logger_with_blank_format
-    logger << "foo"
-    $stdout.string.should == "foo"
-    $stderr.string.should == ""
+  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 "error logger can have a different format" do
-    logger = logger_with_blank_format
-    logger.error_formatter = proc { |severity,datetime,progname,msg|
-      "ERROR_LOGGER: #{msg}\n"
+  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"
     }
-    logger.debug("debug")
-    logger.error("error")
-    $stdout.string.should == "debug\nerror\n"
-    $stderr.string.should == "ERROR_LOGGER: error\n"
   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
@@ -137,4 +157,20 @@ class TestCLILogger < BaseTest
     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

@@ -20,6 +20,55 @@ class TestCLILogging < BaseTest
     $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" do
+    Given {
+      @first = MyClassThatLogsToStdout.new
+      @second = MyOtherClassThatLogsToStdout.new
+      @logger_id = @second.logger_id
+    }
+    When {
+      @second.change_logger
+    }
+    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.change_to_nil_logger }.should raise_error(ArgumentError)
+    }
+  end
+
   class MyClassThatLogsToStdout
     include Methadone::CLILogging
 
@@ -41,32 +90,6 @@ class TestCLILogging < BaseTest
     def logger_id; logger.object_id; end
   end
 
-  test "a class can include CLILogging and get terser logging" do
-    MyClassThatLogsToStdout.new.doit
-    $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
-    $stderr.string.should == "warn\nerror\nfatal\n"
-  end
-
-  test "another class using CLILogging gets the same logger instance" do
-    first = MyClassThatLogsToStdout.new
-    second = MyOtherClassThatLogsToStdout.new
-    first.logger_id.should == second.logger_id
-  end
-
-  test "we can change the global logger" do
-    first = MyClassThatLogsToStdout.new
-    second = MyOtherClassThatLogsToStdout.new
-    logger_id = second.logger_id
-
-    second.change_logger
-
-    logger_id.should_not == second.logger_id
-    first.logger_id.should == second.logger_id
-  end
-
-  test "we cannot use a nil logger" do
-    lambda { MyOtherClassThatLogsToStdout.new.change_to_nil_logger }.should raise_error(ArgumentError)
-  end
 
   class MyOtherClassThatLogsToStdout
     include Methadone::CLILogging

data/test/test_main.rb

@@ -20,245 +20,336 @@ class TestMain < BaseTest
     set_argv @original_argv
   end
 
-  test "my main block gets called by run and has access to CLILogging" do
-    called = false
-    main do
-      begin
-      debug "debug"
-      info "info"
-      warn "warn"
-      error "error"
-      fatal "fatal"
-      called = true
-      rescue => ex
-        puts ex.message
+  test_that "my main block gets called by run and has access to CLILogging" do
+    Given {
+      @called = false
+      main do
+        begin
+          debug "debug"
+          info "info"
+          warn "warn"
+          error "error"
+          fatal "fatal"
+          @called = true
+        rescue => ex
+          puts ex.message
+        end
       end
-    end
-    safe_go!
-    assert called,"main block wasn't called"
+    }
+    When run_go_safely
+    Then main_shouldve_been_called
   end
 
-  test "my main block gets the command-line parameters" do
-    params = []
-    main do |param1,param2,param3|
-      params << param1
-      params << param2
-      params << param3
-    end
-    set_argv %w(one two three)
-    safe_go!
-    assert_equal %w(one two three),params
+  test_that "my main block gets the command-line parameters" do
+    Given {
+      @params = []
+      main do |param1,param2,param3|
+        @params << param1
+        @params << param2
+        @params << param3
+      end
+      set_argv %w(one two three)
+    }
+    When run_go_safely
+    Then {
+      @params.should == %w(one two three)
+    }
   end
 
-  test "my main block can freely ignore arguments given" do
-    called = false
-    main do
-      called = true
-    end
-    set_argv %w(one two three)
-    safe_go!
-    assert called,"Main block wasn't called?!"
+  test_that "my main block can freely ignore arguments given" do
+    Given {
+      @called = false
+      main do
+        @called = true
+      end
+      set_argv %w(one two three)
+    }
+    When run_go_safely
+    Then main_shouldve_been_called
   end
 
-  test "my main block can ask for arguments that it might not receive" do
-    params = []
-    main do |param1,param2,param3|
-      params << param1
-      params << param2
-      params << param3
-    end
-    set_argv %w(one two)
-    safe_go!
-    assert_equal ['one','two',nil],params
+  test_that "my main block can ask for arguments that it might not receive" do
+    Given {
+      @params = []
+      main do |param1,param2,param3|
+        @params << param1
+        @params << param2
+        @params << param3
+      end
+      set_argv %w(one two)
+    }
+    When run_go_safely
+    Then {
+      @params.should == ['one','two',nil]
+    }
   end
 
-  test "go exits zero when main evaluates to nil or some other non number" do
+  test_that "go exits zero when main evaluates to nil or some other non number" do
     [nil,'some string',Object.new,[],4.5].each do |non_number|
-      main { non_number }
-      assert_exits(0,"for value #{non_number}") { go! }
+      Given main_that_exits non_number
+      Then {
+        assert_exits(0,"for value #{non_number}") { When run_go!  }
+      }
     end
   end
 
-  test "go exits with the numeric value that main evaluated to" do
+  def run_go!; proc { go! }; end
+
+  test_that "go exits with the numeric value that main evaluated to" do
     [0,1,2,3].each do |exit_status|
-      main { exit_status }
-      assert_exits(exit_status) { go! }
+      Given main_that_exits exit_status
+      Then {
+        assert_exits(exit_status) { When run_go! }
+      }
     end
   end
 
-  test "go exits with 70, which is the Linux sysexits.h code for this sort of thing, if there's an exception" do
-    main do
-      raise "oh noes"
-    end
-    assert_exits(70) { go! }
-    assert_logged_at_error "oh noes"
+  def main_that_exits(exit_status)
+    proc { main { exit_status } }
   end
 
-  test "go exits with the exit status included in the special-purpose excepiton" do
-    main do
-      raise Methadone::Error.new(4,"oh noes")
-    end
-    assert_exits(4) { go! }
-    assert_logged_at_error "oh noes"
+  test_that "go exits with 70, which is the Linux sysexits.h code for this sort of thing, if there's an exception" do
+    Given {
+      main do
+        raise "oh noes"
+      end
+    }
+    Then {
+      assert_exits(70) { When run_go! }
+      assert_logged_at_error "oh noes"
+    }
   end
 
-  test "can exit with a specific status by using the helper method instead of making a new exception" do
-    main do
-      exit_now!(4,"oh noes")
-    end
-    assert_exits(4) { go! }
-    assert_logged_at_error "oh noes"
+  test_that "go exits with the exit status included in the special-purpose excepiton" do
+    Given {
+      main do
+        raise Methadone::Error.new(4,"oh noes")
+      end
+    }
+    Then {
+      assert_exits(4) { When run_go! }
+      assert_logged_at_error "oh noes"
+    }
   end
 
-  test "opts allows us to more expediently set up OptionParser" do
-    switch = nil
-    flag = nil
-    main do
-      switch = options[:switch]
-      flag = options[:flag]
-    end
+  test_that "can exit with a specific status by using the helper method instead of making a new exception" do
+    Given {
+      main do
+        exit_now!(4,"oh noes")
+      end
+    }
+    Then {
+      assert_exits(4) { When run_go! }
+      assert_logged_at_error "oh noes"
+    }
+  end
 
-    opts.on("--switch") { options[:switch] = true }
-    opts.on("--flag FLAG") { |value| options[:flag] = value }
+  test_that "opts allows us to more expediently set up OptionParser" do
+    Given {
+      @switch = nil
+      @flag = nil
+      main do
+        @switch = options[:switch]
+        @flag = options[:flag]
+      end
+
+      opts.on("--switch") { options[:switch] = true }
+      opts.on("--flag FLAG") { |value| options[:flag] = value }
 
-    set_argv %w(--switch --flag value)
+      set_argv %w(--switch --flag value)
+    }
 
-    safe_go!
+    When run_go_safely
 
-    assert switch
-    assert_equal 'value',flag
+    Then {
+      @switch.should be true
+      @flag.should == 'value'
+    }
   end
 
-  test "when the command line is invalid, we exit with 64" do
-    main do
-    end
+  test_that "when the command line is invalid, we exit with 64" do
+    Given {
+      main do
+      end
 
-    opts.on("--switch") { options[:switch] = true }
-    opts.on("--flag FLAG") { |value| options[:flag] = value }
+      opts.on("--switch") { options[:switch] = true }
+      opts.on("--flag FLAG") { |value| options[:flag] = value }
 
-    set_argv %w(--invalid --flag value)
+      set_argv %w(--invalid --flag value)
+    }
 
-    assert_exits(64) { go! }
+    Then {
+      assert_exits(64) { When run_go! }
+    }
   end
 
-  test "omitting the block to opts simply sets the value in the options hash and returns itself" do
-    switch = nil
-    negatable = nil
-    flag = nil
-    f = nil
-    other = nil
-    some_other = nil
-    main do
-      switch = options[:switch]
-      flag = options[:flag]
-      f = options[:f]
-      negatable = options[:negatable]
-      other = options[:other]
-      some_other = options[:some_other]
-    end
+  test_that "omitting the block to opts simply sets the value in the options hash and returns itself" do
+    Given {
+      @switch = nil
+      @negatable = nil
+      @flag = nil
+      @f = nil
+      @other = nil
+      @some_other = nil
+      main do
+        @switch = options[:switch]
+        @flag = options[:flag]
+        @f = options[:f]
+        @negatable = options[:negatable]
+        @other = options[:other]
+        @some_other = options[:some_other]
+      end
 
-    on("--switch")
-    on("--[no-]negatable")
-    on("--flag FLAG","-f","Some documentation string")
-    on("--other") do 
-      options[:some_other] = true
-    end
+      on("--switch")
+      on("--[no-]negatable")
+      on("--flag FLAG","-f","Some documentation string")
+      on("--other") do 
+        options[:some_other] = true
+      end
 
-    set_argv %w(--switch --flag value --negatable --other)
+      set_argv %w(--switch --flag value --negatable --other)
+    }
 
-    safe_go!
+    When run_go_safely
 
-    assert switch
-    assert some_other
-    refute other
-    assert_equal 'value',flag
-    assert_equal 'value',f,opts.to_s
-    assert_match /Some documentation string/,opts.to_s
+    Then {
+      @switch.should be true
+      @some_other.should be true
+      @other.should_not be true
+      @flag.should == 'value'
+      @f.should == 'value'
+      opts.to_s.should match /Some documentation string/
+    }
   end
 
-  test "without specifying options, [options] doesn't show up in our banner" do
-    main {}
+  test_that "without specifying options, [options] doesn't show up in our banner" do
+    Given {
+      main {}
+    }
 
-    refute_match /\[options\]/,opts.banner
+    Then {
+      opts.banner.should_not match /\[options\]/
+    }
   end
 
-  test "when specifying an option, [options] shows up in the banner" do
-    main {}
-    on("-s")
+  test_that "when specifying an option, [options] shows up in the banner" do
+    Given {
+      main {}
+      on("-s")
+    }
+
+    Then {
+      opts.banner.should match /\[options\]/
+    }
 
-    assert_match /\[options\]/,opts.banner
   end
 
-  test "I can specify which arguments my app takes and if they are required" do
-    main {}
-    
-    arg :db_name
-    arg :user, :required
-    arg :password, :optional
+  test_that "I can specify which arguments my app takes and if they are required" do
+    Given {
+      main {}
+
+      arg :db_name
+      arg :user, :required
+      arg :password, :optional
+    }
 
-    assert_match /db_name user \[password\]$/,opts.banner
+    Then {
+      opts.banner.should match /db_name user \[password\]$/
+    }
   end
 
-  test "I can specify which arguments my app takes and if they are singular or plural" do
-    main {}
-    
-    arg :db_name
-    arg :user, :required, :one
-    arg :tables, :many
+  test_that "I can specify which arguments my app takes and if they are singular or plural" do
+    Given {
+      main {}
 
-    assert_match /db_name user tables...$/,opts.banner
-  end
+      arg :db_name
+      arg :user, :required, :one
+      arg :tables, :many
+    }
 
-  test "I can specify which arguments my app takes and if they are singular or optional plural" do
-    main {}
-    
-    arg :db_name
-    arg :user, :required, :one
-    arg :tables, :any
+    Then {
+      opts.banner.should match /db_name user tables...$/
+    }
+  end
 
-    assert_match /db_name user \[tables...\]$/,opts.banner
+  test_that "I can specify which arguments my app takes and if they are singular or optional plural" do
+    Given {
+      main {}
+      
+      arg :db_name
+      arg :user, :required, :one
+      arg :tables, :any
+    }
+
+    Then {
+      opts.banner.should match /db_name user \[tables...\]$/
+    }
   end
 
-  test "I can set a description for my app" do
-    main {}
-    description "An app of total awesome"
+  test_that "I can set a description for my app" do
+    Given {
+      main {}
+      description "An app of total awesome"
 
-    assert_match /^An app of total awesome$/,opts.banner
+    }
+    Then {
+      opts.banner.should match /^An app of total awesome$/
+    }
   end
 
-  test "when I override the banner, we don't automatically do anything" do
-    main {}
-    opts.banner = "FOOBAR"
+  test_that "when I override the banner, we don't automatically do anything" do
+    Given {
+      main {}
+      opts.banner = "FOOBAR"
 
-    on("-s")
+      on("-s")
+    }
 
-    assert_equal "FOOBAR",opts.banner
+    Then {
+      opts.banner.should == 'FOOBAR'
+    }
   end
 
-  test "when I say an argument is required and its omitted, I get an error" do
-    main {}
-    arg :foo
-    arg :bar
+  test_that "when I say an argument is required and its omitted, I get an error" do
+    Given {
+      main {}
+      arg :foo
+      arg :bar
 
-    set_argv %w(blah)
+      set_argv %w(blah)
+    }
 
-    assert_exits(64) { go! }
-    assert_logged_at_error("parse error: 'bar' is required")
+    Then {
+      assert_exits(64) { When run_go! }
+      assert_logged_at_error("parse error: 'bar' is required")
+    }
   end
 
-  test "when I say an argument is many and its omitted, I get an error" do
-    main {}
-    arg :foo
-    arg :bar, :many
+  test_that "when I say an argument is many and its omitted, I get an error" do
+    Given {
+      main {}
+      arg :foo
+      arg :bar, :many
 
-    set_argv %w(blah)
+      set_argv %w(blah)
+    }
 
-    assert_exits(64) { go! }
-    assert_logged_at_error("parse error: at least one 'bar' is required")
+    Then {
+      assert_exits(64) { When run_go! }
+      assert_logged_at_error("parse error: at least one 'bar' is required")
+    }
   end
 
   private
 
+  def main_shouldve_been_called
+    Proc.new { assert @called,"Main block wasn't called?!" }
+  end
+  
+  def run_go_safely
+    Proc.new { safe_go! }
+  end
+
   # Calls go!, but traps the exit
   def safe_go!
     go!
@@ -266,14 +357,14 @@ class TestMain < BaseTest
   end
 
   def assert_logged_at_error(expected_message)
-    assert @logged.include?(expected_message),"#{@logged} didn't include '#{expected_message}'"
+    @logged.should include expected_message
   end
 
   def assert_exits(exit_code,message='',&block)
     block.call
     fail "Expected an exit of #{exit_code}, but we didn't even exit!"
   rescue SystemExit => ex
-    assert_equal exit_code,ex.status,message
+    ex.status.should == exit_code
   end
 
   def set_argv(args)