methadone-rehab 1.9.2

data/test/test_exit_now.rb

@@ -0,0 +1,37 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+
+class TestExitNow < BaseTest
+  include Methadone
+  include Methadone::ExitNow
+
+  test_that "exit_now raises the proper error" do
+    Given {
+      @exit_code = any_int :min => 1
+      @message = any_string
+    }
+    When {
+      @code = lambda { exit_now!(@exit_code,@message) }
+    }
+    Then {
+      exception = assert_raises(Methadone::Error,&@code)
+      exception.exit_code.should == @exit_code
+      exception.message.should == @message
+    }
+  end
+
+  test_that "exit_now without an exit code uses 1 as the exit code" do
+    Given {
+      @message = any_string
+    }
+    When {
+      @code = lambda { exit_now!(@message) }
+    }
+    Then {
+      exception = assert_raises(Methadone::Error,&@code)
+      exception.exit_code.should == 1
+      exception.message.should == @message
+    }
+  end
+end 

data/test/test_main.rb

@@ -0,0 +1,1213 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+require 'fileutils'
+
+class TestMain < BaseTest
+  include Methadone::Main
+
+  def setup
+    @original_argv = ARGV.clone
+    ARGV.clear
+    @old_stdout = $stdout
+    $stdout = StringIO.new
+    @logged = StringIO.new
+    @custom_logger = Logger.new(@logged)
+
+    @original_home = ENV['HOME']
+    fake_home = '/tmp/fake-home'
+    FileUtils.rm_rf(fake_home)
+    FileUtils.mkdir(fake_home)
+    ENV['HOME'] = fake_home
+  end
+
+  # Override the built-in logger so we can capture it
+  def logger
+    @custom_logger
+  end
+
+  def teardown
+    set_argv @original_argv
+    ENV.delete('DEBUG')
+    ENV.delete('APP_OPTS')
+    $stdout = @old_stdout
+    ENV['HOME'] = @original_home
+  end
+
+  test_that "my main block gets called by run and has access to CLILogging" do
+    Given {
+      @called = false
+      main do
+        begin
+          logger.debug "debug"
+          logger.info "info"
+          logger.warn "warn"
+          logger.error "error"
+          logger.fatal "fatal"
+          @called = true
+        rescue => ex
+          puts ex.message
+        end
+      end
+    }
+    When run_go_safely
+    Then main_shouldve_been_called
+  end
+
+  test_that "my main block does not get command-line parameters that were not specified by args, but they are still available in ARGV" do
+    Given {
+      @params = []
+      @argv = []
+      main do |param1,param2,param3|
+        @params << param1
+        @params << param2
+        @params << param3
+        @argv = ::ARGV
+      end
+      set_argv %w(one two three)
+    }
+    When run_go_safely
+    Then {
+      @params.should == [nil,nil,nil]
+      @argv.should == %w(one two three)
+    }
+  end
+
+  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_that "my main block can ask for arguments that it might not receive" do
+    Given {
+      @params = []
+      @argv = []
+      arg 'param1'
+      main do |param1,param2,param3|
+        @params << param1
+        @params << param2
+        @params << param3
+        @argv = ::ARGV
+      end
+      set_argv %w(one two)
+    }
+    When run_go_safely
+    Then {
+      @params.should == ['one',nil,nil]
+      @argv.should == ['two']
+    }
+  end
+
+  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|
+      Given main_that_exits non_number
+      Then {
+        assert_exits(0,"for value #{non_number}") { When run_go!  }
+      }
+    end
+  end
+
+  test_that "go exits with the numeric value that main evaluated to" do
+    [0,1,2,3].each do |exit_status|
+      Given main_that_exits exit_status
+      Then {
+        assert_exits(exit_status) { When run_go! }
+      }
+    end
+  end
+
+  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 {
+      leak_exceptions false
+      main do
+        raise "oh noes"
+      end
+    }
+    Then {
+      assert_exits(70) { When run_go! }
+      assert_logged_at_error "oh noes"
+    }
+  end
+
+  test_that "go allows the exception raised to leak through if DEBUG is set in the environment" do
+    Given {
+      ENV['DEBUG'] = 'true'
+      main do
+        raise ArgumentError,"oh noes"
+      end
+    }
+    Then {
+      assert_raises ArgumentError do
+        When run_go!
+      end
+    }
+  end
+
+  test_that "An exception that's not a StandardError causes the excepteion to break through and raise" do
+    Given {
+      main do
+        raise Exception,"oh noes"
+      end
+    }
+    Then {
+      ex = assert_raises Exception do
+        When run_go!
+      end
+      assert_equal "oh noes",ex.message
+    }
+  end
+
+  test_that "Non-methadone exceptions leak through if we configure it that way" do
+    Given {
+      main do
+        raise StandardError,"oh noes"
+      end
+      leak_exceptions true
+    }
+    Then {
+      ex = assert_raises StandardError do
+        When run_go!
+      end
+      assert_equal "oh noes",ex.message
+    }
+  end
+
+  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_that "go allows the special methadone exception to leak through if DEBUG is set in the environment" do
+    Given {
+      ENV['DEBUG'] = 'true'
+      main do
+        raise Methadone::Error.new(4,"oh noes")
+      end
+    }
+    Then {
+      assert_raises Methadone::Error do
+        When run_go!
+      end
+    }
+  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
+
+  test_that "when we help_now! we exit and show help" do
+    Given {
+      @message = any_sentence
+      main do
+        help_now!(@message)
+      end
+
+      opts.on("--switch") { options[:switch] = true }
+      opts.on("--flag FLAG") { |value| options[:flag] = value }
+
+      set_argv []
+    }
+
+    Then {
+      assert_exits(64) { When run_go! }
+      assert $stdout.string.include?(opts.to_s),"Expected #{$stdout.string} to contain #{opts.to_s}"
+      assert_logged_at_error @message
+    }
+  end
+
+  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)
+    }
+
+    When run_go_safely
+
+    Then {
+      @switch.should be true
+      @flag.should == 'value'
+    }
+  end
+
+  test_that "when the command line is invalid, we exit with 64 and print the CLI help" do
+    Given {
+      main do
+      end
+
+      opts.on("--switch") { options[:switch] = true }
+      opts.on("--flag FLAG") { |value| options[:flag] = value }
+
+      set_argv %w(--invalid --flag value)
+    }
+
+    Then {
+      assert_exits(64) { When run_go! }
+      assert $stdout.string.include?(opts.to_s),"Expected #{$stdout.string} to contain #{opts.to_s}"
+    }
+  end
+
+  test_that "when setting defaults they get copied to strings/symbols as well" do
+    Given {
+      @flag_with_string_key_defalt = nil
+      @flag_with_symbol_key_defalt = nil
+      reset!
+      main do
+        @flag_with_string_key_defalt = options[:foo]
+        @flag_with_symbol_key_defalt = options['bar']
+      end
+      options['foo'] = 'FOO'
+      options[:bar] = 'BAR'
+      on("--foo")
+      on("--bar")
+    }
+    When run_go_safely
+    Then {
+      assert_equal 'FOO',@flag_with_string_key_defalt
+      assert_equal 'BAR',@flag_with_symbol_key_defalt
+    }
+  end
+
+  test_that "passing non-strings wont' break automagic stuff" do
+    Given {
+      @foo = nil
+      @bar = nil
+      main do
+        @foo = options[:foo]
+        @bar = options[:bar]
+      end
+      on("--foo ARG",OptionParser::DecimalInteger)
+      on("--bar ARG",/^\d/)
+      set_argv %w(--foo 88 --bar 4)
+    }
+    When run_go_safely
+    Then {
+      assert_equal 88,@foo,@logged.string + $stdout.string
+      assert_equal '4',@bar,@logged.string + $stdout.string
+    }
+  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
+      @with_dashes = nil
+      main do
+        @switch      = [options[:switch],options['switch']]
+        @flag        = [options[:flag],options['flag']]
+        @f           = [options[:f],options['f']]
+        @negatable   = [options[:negatable],options['negatable']]
+        @other       = [options[:other],options['other']]
+        @some_other  = [options[:some_other],options['some_other']]
+        @with_dashes = [options[:'flag-with-dashes'],options['flag-with-dashes']]
+      end
+
+      on("--switch")
+      on("--[no-]negatable")
+      on("--flag FLAG","-f","Some documentation string")
+      on("--flag-with-dashes FOO")
+      on("--other") do
+        options[:some_other] = true
+      end
+
+      set_argv %w(--switch --flag value --negatable --other --flag-with-dashes=BAR)
+    }
+
+    When run_go_safely
+
+    Then {
+      @switch[0].should be true
+      @some_other[0].should be true
+      @other[0].should_not be true
+      @flag[0].should == 'value'
+      @f[0].should == 'value'
+      @with_dashes[0].should == 'BAR'
+
+      @switch[1].should be true
+      @some_other[1].should be nil # ** this is set manually
+      @other[1].should_not be true
+      @flag[1].should == 'value'
+      @f[1].should == 'value'
+      @with_dashes[1].should == 'BAR'
+
+      opts.to_s.should match /Some documentation string/
+    }
+  end
+
+  test_that "without specifying options, options in brackets doesn't show up in our banner" do
+    Given {
+      main {}
+    }
+
+    Then {
+      opts.banner.should_not match /\[options\]/
+    }
+  end
+
+  test_that "when specifying an option, [options] shows up in the banner" do
+    Given {
+      main {}
+      on("-s")
+    }
+
+    Then {
+      opts.banner.should match /\[options\]/
+    }
+
+  end
+
+  test_that "I can specify which arguments my app takes and if they are required as well as document them" do
+    Given {
+      main {}
+      @db_name_desc = any_string
+      @user_desc = any_string
+      @password_desc = any_string
+
+      arg :db_name, @db_name_desc
+      arg :user, :required, @user_desc
+      arg :password, :optional, @password_desc
+    }
+    When run_go_safely
+    Then {
+      opts.banner.should match /db_name user \[password\]$/
+      opts.to_s.should match /#{@db_name_desc}/
+      opts.to_s.should match /#{@user_desc}/
+      opts.to_s.should match /#{@password_desc}/
+    }
+  end
+
+  test_that "I can specify which arguments my app takes and if they are singular or plural" do
+    Given {
+      main {}
+
+      arg :db_name
+      arg :user, :required, :one
+      arg :tables, :many
+    }
+
+    Then {
+      opts.banner.should match /db_name user tables...$/
+    }
+  end
+
+  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_that "I can set a description for my app" do
+    Given {
+      main {}
+      description "An app of total awesome"
+
+    }
+    Then {
+      opts.banner.should match /^An app of total awesome$/
+    }
+  end
+
+  test_that "when I override the banner, we don't automatically do anything" do
+    Given {
+      main {}
+      opts.banner = "FOOBAR"
+
+      on("-s")
+    }
+    When {opts}
+    Then {
+      opts.banner.should == 'FOOBAR'
+    }
+  end
+
+  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)
+    }
+
+    Then {
+      assert_exits(64) { When run_go! }
+      assert_logged_at_error("parse error: 'bar' is required")
+    }
+  end
+
+  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)
+    }
+
+    Then {
+      assert_exits(64) { When run_go! }
+      assert_logged_at_error("parse error: at least one 'bar' is required")
+    }
+  end
+
+  test_that "when I specify a version, it shows up in the banner" do
+    Given  {
+      main{}
+      version "0.0.1"
+    }
+
+    Then {
+      opts.banner.should match /^v0.0.1/m
+    }
+  end
+
+  test_that "when I specify a version, I can get help via --version" do
+    Given  {
+      main{}
+      version "0.0.1"
+      set_argv(['--version'])
+    }
+    Then run_go_safely
+    And {
+      opts.to_s.should match /Show help\/version info/m
+      $stdout.string.should match /^#{@version}$/
+    }
+  end
+
+  test_that "when I specify a version with custom help, it shows up" do
+    @version_message = "SHOW ME VERSIONS"
+    Given  {
+      main{}
+      version "0.0.1",@version_message
+      set_argv(['--verison'])
+    }
+    Then run_go_safely
+    And {
+      opts.to_s.should match /#{@version_message}/
+    }
+  end
+
+  test_that "when I specify a version with :basic format, only the command and version show up and the help is 'show version info'" do
+    @version = "2.0.9.pre"
+    Given {
+      version @version, :basic
+      set_argv %w(--version)
+    }
+    When run_go_safely
+    Then {
+      opts.to_s.should match /^ *--version.*Show version info$/
+      $stdout.string.should match /^#{::File.basename($0)} version #{@version}$/
+    }
+  end
+
+  test_that "when I specify a version with :terse format, only the version show up and the help is 'show version'" do
+    @version = "2.0.9.pre"
+    Given {
+      version @version, :terse
+      set_argv %w(--version)
+    }
+    When run_go_safely
+    Then {
+      opts.to_s.should match /^ *--version.*Show version$/
+      $stdout.string.should match /^#{@version}$/
+    }
+  end
+
+  test_that "default values for boolean options are put into the docstring" do
+    Given {
+      main {}
+      options[:foo] = false
+      options[:bar] = true
+      on("--foo","Do the foo")
+      on("--[no-]bar", "Bar it like crazy")
+    }
+    When {
+      @help_string = opts.to_s
+    }
+    When {
+      @help_string.should match /--foo.*\n.*\(default: false\)/
+      @help_string.should match /--\[no-\]bar.*\n.*\(default: true\)/
+    }
+  end
+
+  test_that "default values for options are put into the docstring" do
+    Given {
+      main {}
+      options[:foo] = "bar"
+      on("--foo ARG","Indicate the type of foo")
+    }
+    When {
+      @help_string = opts.to_s
+    }
+    When {
+      @help_string.should match /\(default: bar\)/
+    }
+
+  end
+
+  test_that "default values for options with several names are put into the docstring" do
+    Given {
+      main {}
+      options[:foo] = "bar"
+      on("-f ARG","--foo","Indicate the type of foo")
+    }
+    When {
+      @help_string = opts.to_s
+    }
+    When {
+      @help_string.should match /\(default: bar\)/
+    }
+  end
+
+  test_that "when getting defaults from an environment variable, show it in the help output" do
+    Given app_to_use_environment
+    When run_go_safely
+    And {
+      @help_string = opts.to_s
+    }
+    Then {
+      @help_string.should match /Default values can be placed in the APP_OPTS environment variable/
+    }
+  end
+
+  test_that "when we want to get opts from the environment, we can" do
+    Given app_to_use_environment
+    And {
+      @flag_value = '56'
+      @some_arg = any_string
+      set_argv([])
+      ENV['APP_OPTS'] = "--switch --flag=#{@flag_value} #{@some_arg}"
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,'',&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+      @args.should == [@some_arg]
+    }
+  end
+
+  test_that "environment args are overridden by the command line" do
+    Given app_to_use_environment
+    And {
+      @flag_value = any_string
+      ENV['APP_OPTS'] = "--switch --flag=#{any_string}"
+      set_argv(['--flag',@flag_value])
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,'',&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+  end
+
+  test_that "environment args correctly handle spaces" do
+    Given app_to_use_environment
+    And {
+      @flag_value = any_string + ' ' + any_string
+      ENV['APP_OPTS'] = "--switch --flag='#{@flag_value}'"
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,'',&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+  end
+
+  test_that "environment args correctly handle spaces via backslash stuff" do
+    Given app_to_use_environment
+    And {
+      cli_flag_value = any_string(:max => 4) + "\\ " + any_string(:max => 4)
+      @flag_value = cli_flag_value.gsub("\\ "," ")
+      ENV['APP_OPTS'] = "--switch --flag=#{cli_flag_value}"
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,'',&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+  end
+
+  test_that "we can get defaults from a YAML config file if it's specified" do
+    Given app_to_use_rc_file
+    And {
+      @flag_value = any_string
+      rc_file = File.join(ENV['HOME'],'.my_app.rc')
+      File.open(rc_file,'w') do |file|
+        file.puts({
+          'switch' => true,
+          'flag' => @flag_value,
+        }.to_yaml)
+      end
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+
+  end
+
+  test_that "we can get defaults from an absolute config filename" do
+    tempfile = Tempfile.new('methadone_test.rc')
+    Given app_to_use_rc_file(tempfile.path)
+    And {
+      @flag_value = any_string
+      rc_file = File.join(tempfile.path)
+      File.open(rc_file,'w') do |file|
+        file.puts({
+          'switch' => true,
+          'flag' => @flag_value,
+        }.to_yaml)
+      end
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+
+  end
+
+
+  test_that "we can specify an rc file even if it doesn't exist" do
+    Given app_to_use_rc_file
+    And {
+      @flag_value = any_string
+      rc_file = File.join(ENV['HOME'],'.my_app.rc')
+      raise "Something's wrong, expection rc file not to exist" if File.exists?(rc_file)
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @switch.should == nil
+      @flag.should == nil
+    }
+  end
+
+  test_that "we can use a simpler, text format for the rc file" do
+    Given app_to_use_rc_file
+    And {
+      @flag_value = any_string
+      rc_file = File.join(ENV['HOME'],'.my_app.rc')
+      File.open(rc_file,'w') do |file|
+        file.puts "--switch --flag=#{@flag_value}"
+      end
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+
+  end
+
+  test_that "the text format for the rc file attempts to respect quoted arguments" do
+    Given app_to_use_rc_file
+    And {
+      @flag_value = any_string(:max => 10) + " " + any_string(:max => 10)
+      rc_file = File.join(ENV['HOME'],'.my_app.rc')
+      File.open(rc_file,'w') do |file|
+        file.puts "--switch --flag='#{@flag_value}'"
+      end
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @switch.should == true
+      @flag.should == @flag_value
+    }
+  end
+
+  test_that "with an ill-formed rc file, we get a reasonable error message" do
+    Given app_to_use_rc_file
+    And {
+      @flag_value = any_string
+      rc_file = File.join(ENV['HOME'],'.my_app.rc')
+      File.open(rc_file,'w') do |file|
+        file.puts OpenStruct.new(:foo => :bar).to_yaml
+      end
+    }
+    When {
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(64,&@code)
+    }
+
+  end
+
+  test_that "we can call methods prior to calling main without a problem" do
+    Given {
+      description "An app of total awesome"
+      opts.on("--switch") { options[:switch] = true }
+      main {}
+    }
+    Then {
+      opts.banner.should match /^An app of total awesome$/
+      opts.to_s.should match /--switch/
+    }
+  end
+
+  test_that "usage is displayed if called with no arguments given when help_if_bare specified" do
+    Given {
+      help_if_bare
+      on("--required VALUE")
+      main {puts 'main called'}
+    }
+    When {
+      @code = lambda {go!}
+    }
+    Then {
+      assert_exits(64,&@code)
+      $stdout.string.should_not match /main called/
+      $stdout.string.should match /Usage:.*--required VALUE/m
+    }
+  end
+
+  test_that "arguments are filled according to their need" do
+    Given {
+      @can_use_one = nil
+      @any_will_do = nil
+      @need_1 = nil
+      @at_least_one = nil
+      @if_youve_got_one = nil
+      @any_left = nil
+      @last_one = nil
+      arg 'can_use_one', :optional, Integer
+      arg 'any_will_do', :any
+      arg 'need_1', :required
+      arg 'at_least_one', :many
+      arg 'if_youve_got_one', :optional
+      arg 'any_left', :any
+      arg 'last_one', :required
+      main do |can_use_one,any_will_do,need_1,at_least_one,if_youve_got_one,any_left,last_one|
+        @can_use_one = can_use_one
+        @any_will_do = any_will_do
+        @need_1 = need_1
+        @at_least_one = at_least_one
+        @if_youve_got_one = if_youve_got_one
+        @any_left = any_left
+        @last_one = last_one
+      end
+      set_argv %w(1 2 3 4 5 6 7 8 9 10)
+    }
+    When run_go_safely
+    Then {
+      @can_use_one.should == '1'
+      @any_will_do.should == %w(2 3 4 5 6 7)
+      @need_1.should == '8'
+      @at_least_one.should == ['9']
+      @if_youve_got_one.should == nil
+      @any_left.should == []
+      @last_one.should == '10'
+    }
+  end
+
+  test_that "arguments can be given valid values" do
+    Given {
+      arg "foo", %w(one two three)
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(two)
+    }
+    When run_go_safely
+    Then {
+      @foo = 'two'
+    }
+  end
+
+  test_that "arguments can be given valid values, and raise errors when they don't match" do
+    Given {
+      arg "foo", %w(one two three)
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(four)
+    }
+    When run_go_safely
+    Then {
+      assert_logged_at_error("parse error: foo: 'four' is invalid")
+      @foo = nil
+    }
+  end
+
+  test_that "arguments that take multiple values can be given valid values" do
+    Given {
+      arg "foo", :many, %w(one two three)
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(two one two)
+    }
+    When run_go_safely
+    Then {
+      @foo = %w(two one two)
+    }
+  end
+
+  test_that "arguments that take multiple values can be given valid values, and raise errors when they don't match" do
+    Given {
+      arg "foo", :many, %w(one two three)
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(four one two seven)
+    }
+    When run_go_safely
+    Then {
+      assert_logged_at_error("parse error: foo: The following value(s) were invalid: 'four seven'")
+      @foo = nil
+    }
+  end
+  test_that "arguments can be given regexp filters" do
+    Given {
+      arg "foo", /^th/
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(this)
+    }
+    When run_go_safely
+    Then {
+      @foo = 'this'
+    }
+  end
+
+  test_that "arguments can be given regexp filters, and raise errors when they don't match" do
+    Given {
+      arg "foo", :optional, /^th/
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(width)
+    }
+    When run_go_safely
+    Then {
+      assert_logged_at_error("parse error: foo: 'width' is invalid")
+      @foo = nil
+    }
+  end
+
+  test_that "arguments that take multiple values can be given regexp filters" do
+    Given {
+      arg "foo", :many, /^th/
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(this that the\ other)
+    }
+    When run_go_safely
+    Then {
+      @foo = %w(this that the\ other)
+    }
+  end
+
+  test_that "arguments that take multiple values can be given regexp filters, and raise errors when they don't match" do
+    Given {
+      arg "foo", :any, /^th/
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(there is this theory on things that grow)
+    }
+    When run_go_safely
+    Then {
+      assert_logged_at_error("parse error: foo: The following value(s) were invalid: 'is on grow'")
+      @foo = nil
+    }
+  end
+
+  test_that "arguments can be given multiple filters, requiring only one be accepted" do
+    Given {
+      arg "foo", :any, /^....$/, ['one', 'two', 'six'], /\A..?e.?e.?\z/
+      @foo = nil
+      main do |foo|
+        @foo = foo
+      end
+      set_argv %w(one two three four five six seven)
+    }
+    When run_go_safely
+    Then {
+      @foo = %w(one two three four five six seven)
+    }
+  end
+
+  test_that "options can be mutually exclusive" do
+    Given {
+      @first = nil
+      @second = nil
+      reset!
+      main do
+        @first = options[:f]
+        @second = options[:s]
+      end
+
+      on("-f", "--first", "First Option")
+      on("-s", "Second Option", :excludes => :f)
+    }
+    When {
+      set_argv %w(-f)
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @first.should be_truthy
+      @second.should be_nil
+    }
+  end
+
+  test_that "options can be mutually exclusive, which raise an error if both are used" do
+    Given {
+
+      @first = nil
+      @second = nil
+      reset!
+      main do
+        @first = options[:f]
+        @second = options[:s]
+      end
+      on("-f", "--first", "First Option")
+      on("-s", "Second Option", :excludes => :f)
+    }
+    When {
+      set_argv %w(-f -s)
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(64,&@code)
+      assert_logged_at_error("parse error: -s cannot be used if already using -f|--first")
+      $stdout.string.should match /Usage:/
+    }
+  end
+
+  test_that "options can be mutually exclusive, which raise an error if both are used - order doesn't matter" do
+    Given {
+
+      @first = nil
+      @second = nil
+      reset!
+      main do
+        @first = options[:f]
+        @second = options[:s]
+      end
+      on("-f", "--first", "First Option")
+      on("-s", "Second Option", :excludes => :f)
+    }
+    When {
+      set_argv %w(-s -f)
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(64,&@code)
+      assert_logged_at_error("parse error: -s cannot be used if already using -f|--first")
+      $stdout.string.should match /Usage:/
+    }
+  end
+
+  test_that "options can be mutually exclusive, the enemy of my enemy is my friend" do
+    Given {
+
+      @first = nil
+      @second = nil
+      @third = nil
+      reset!
+      main do
+        @first = options[:f]
+        @second = options[:s]
+        @third = options[:third]
+      end
+      on("-f", "--first", "First Option")
+      on("--another-one", "Second Option", :excludes => :f)
+      on("--third TEST", "Second Option", :excludes => "another-one")
+    }
+    When {
+      set_argv %w(-f --third value)
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(0,&@code)
+      @first.should be_truthy
+      @second.should be_nil
+      @third.should == 'value'
+    }
+  end
+
+  test_that "options can be options can require other options to be present" do
+    Given {
+
+      @first = nil
+      @second = nil
+      @third = nil
+      reset!
+      main do
+        @first = options[:f]
+        @second = options[:s]
+        @third = options[:third]
+      end
+      on("-f", "--first", "First Option")
+      on("-a","--another-one", "Second Option")
+      on("--third TEST", "Second Option", :requires => [:first,'another-one'])
+    }
+    When {
+      set_argv %w(-f --third value)
+      @code = lambda { go! }
+    }
+    Then {
+      assert_exits(64,&@code)
+      assert_logged_at_error("parse error: Missing option -a|--another-one required by option --third TEST")
+      $stdout.string.should match /Usage:/
+    }
+  end
+
+private
+
+  def app_to_use_rc_file(rc_file = '.my_app.rc')
+    lambda {
+      reset!
+      @switch = nil
+      @flag = nil
+      @args = nil
+      main do |*args|
+        @switch = options[:switch]
+        @flag = options[:flag]
+        @args = args
+      end
+
+      defaults_from_config_file rc_file
+
+      on('--switch','Some Switch')
+      on('--flag FOO','Some Flag')
+    }
+  end
+
+  def main_that_exits(exit_status)
+    proc { main { exit_status } }
+  end
+
+  def app_to_use_environment
+    lambda {
+      @switch = nil
+      @flag = nil
+      @args = nil
+      arg :args, :any
+      main do |args|
+        @switch = options[:switch]
+        @flag = options[:flag]
+        @args = args
+      end
+
+      defaults_from_env_var 'APP_OPTS'
+
+      on('--switch','Some Switch')
+      on('--flag FOO','Some Flag')
+    }
+  end
+
+  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!
+  rescue SystemExit
+  end
+
+  def run_go!; proc { go! }; end
+
+  def assert_logged_at_error(expected_message)
+    @logged.string.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,@logged.string
+  end
+
+  def set_argv(args)
+    ARGV.clear
+    args.each { |arg| ARGV << arg }
+  end
+end