Merge pull request #160 from nanobowers/fix_assert_raises

Fix assert_raises to assert_raises_errmatch

lib/optimist.rb

@@ -429,7 +429,7 @@ def parse(cmdline = ARGV)
     end
 
     required.each do |sym, val|
-      raise CommandlineError, "option --#{@specs[sym].long} must be specified" unless given_args.include? sym
+      raise CommandlineError, "option --#{@specs[sym].long.long} must be specified" unless given_args.include? sym
     end
 
     ## parse parameters
@@ -553,7 +553,7 @@ def wrap(str, opts = {}) # :nodoc:
   def die(arg, msg = nil, error_code = nil)
     msg, error_code = nil, msg if msg.kind_of?(Integer)
     if msg
-      $stderr.puts "Error: argument --#{@specs[arg].long} #{msg}."
+      $stderr.puts "Error: argument --#{@specs[arg].long.long} #{msg}."
     else
       $stderr.puts "Error: #{arg}."
     end

test/optimist/alt_names_test.rb

@@ -9,7 +9,7 @@ def setup
     end
 
     def get_help_string
-      err = assert_raises(Optimist::HelpNeeded) do
+      assert_raises(Optimist::HelpNeeded) do
         @p.parse(%w(--help))
       end
       sio = StringIO.new "w"
@@ -23,18 +23,20 @@ def test_altshort
        assert_equal true, opts[:catarg]
        opts = @p.parse %w(-C)
        assert_equal true, opts[:catarg]
-       assert_raises(CommandlineError) { @p.parse %w(-c -C) }
-       assert_raises(CommandlineError) { @p.parse %w(-cC) }
+       err_regex = /option '-C' specified multiple times/
+       assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-c -C) }
+       assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(-cC) }
     end
 
     def test_altshort_invalid_none
-      assert_raises(ArgumentError) {
+      err_regex = /Cannot use :none with any other values in short option:/
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :something, "some opt", :short => [:s, :none]
       }
-      assert_raises(ArgumentError) {
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :something, "some opt", :short => [:none, :s]
       }
-      assert_raises(ArgumentError) {
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :zumthing, "some opt", :short => [:none, :none]
       }
     end
@@ -82,11 +84,11 @@ def test_altlong
       end
 
       [%w[--goodarg1], %w[--missing], %w[-a]].each do |a|
-        assert_raises(Optimist::CommandlineError) { @p.parse(a) }
+        assert_raises_errmatch(Optimist::CommandlineError, /unknown argument/) { @p.parse(a) }
       end
 
       ["", '--', '-bad', '---threedash'].each do |altitem|
-        assert_raises(ArgumentError) { @p.opt "badarg", "desc", :alt => altitem }
+        assert_raises_errmatch(ArgumentError, /invalid long option name/) { @p.opt "badarg", "desc", :alt => altitem }
       end
     end
 
@@ -116,15 +118,18 @@ def test_altlong_help
 
     def test_alt_duplicates
       # alt duplicates named option
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "cat" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :cat, 'desc', :alt => :cat
       }
       # alt duplicates :long 
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "feline" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :cat, 'desc', :long => :feline, :alt => [:feline]
       }
       # alt duplicates itself
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "aaa" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :abc, 'desc', :alt => [:aaa, :aaa]
       }
     end
@@ -135,22 +140,26 @@ def test_altlong_collisions
       @p.opt :bat, 'desc', :alt => [:baton, :twirl]
 
       # :alt collision with named option
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "fat" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :cat, 'desc', :alt => :fat
       }
 
       # :alt collision with :long option
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "cat" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :cat, 'desc', :alt => :rat
       }
 
       # :named option collision with existing :alt option
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "baton" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :baton, 'desc'
       }
 
       # :long option collision with existing :alt option
-      assert_raises(ArgumentError) {
+      err_regex = /long option name "twirl" is already taken; please specify a \(different\) :long\/:alt/ 
+      assert_raises_errmatch(ArgumentError, err_regex) {
         @p.opt :whirl, 'desc', :long => 'twirl'
       }
 

test/optimist/parser_constraint_test.rb

@@ -13,21 +13,25 @@ def parser
 
   def test_conflicts
     @p.opt :one
-    assert_raises(ArgumentError) { @p.conflicts :one, :two }
+    err_regex = /unknown option 'two'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.conflicts :one, :two }
     @p.opt :two
     @p.conflicts :one, :two
     @p.parse %w(--one)
     @p.parse %w(--two)
-    assert_raises(CommandlineError) { @p.parse %w(--one --two) }
+    err_regex = /only one of --one, --two can be given/
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --two) }
 
     @p.opt :hello
     @p.opt :yellow
     @p.opt :mellow
     @p.opt :jello
     @p.conflicts :hello, :yellow, :mellow, :jello
-    assert_raises(CommandlineError) { @p.parse %w(--hello --yellow --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
+    err_regex = /only one of --hello, --yellow, --mellow, --jello can be given/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --yellow --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --jello) }
 
     @p.parse %w(--hello)
     @p.parse %w(--jello)
@@ -37,8 +41,9 @@ def test_conflicts
     @p.parse %w(--mellow --one)
     @p.parse %w(--mellow --two)
 
-    assert_raises(CommandlineError) { @p.parse %w(--mellow --two --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--one --mellow --two --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow --two --jello) }
+    err_regex = /only one of --one, --two can be given/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --mellow --two --jello) }
   end
 
   def test_conflict_error_messages
@@ -51,30 +56,34 @@ def test_conflict_error_messages
 
   def test_either
     @p.opt :one
-    assert_raises(ArgumentError) { @p.either :one, :two }
+    err_regex = /unknown option 'two'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.either :one, :two }
     @p.opt :two
     @p.either :one, :two
     @p.parse %w(--one)
     @p.parse %w(--two)
-    assert_raises(CommandlineError) { @p.parse %w(--one --two) }
-    assert_raises(CommandlineError) { @p.parse %w() }
+    err_regex = /one and only one of --one, --two is required/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --two) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w() }
 
     @p.opt :hello
     @p.opt :yellow
     @p.opt :mellow
     @p.opt :jello
     @p.either :hello, :yellow, :mellow, :jello
-    assert_raises(CommandlineError) { @p.parse %w(--hello --yellow --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
+    err_regex = /one and only one of --hello, --yellow, --mellow, --jello is required/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --hello --yellow --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--two --hello --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --hello --jello) }
 
     @p.parse %w(--hello --one)
     @p.parse %w(--jello --two)
     @p.parse %w(--mellow --one)
     @p.parse %w(--mellow --two)
 
-    assert_raises(CommandlineError) { @p.parse %w(--mellow --two --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--one --mellow --two --jello) }
+    err_regex = /one and only one of/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow --two --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one --mellow --two --jello) }
   end
 
   def test_either_error_messages
@@ -89,29 +98,33 @@ def test_either_error_messages
 
   def test_depends
     @p.opt :one
-    assert_raises(ArgumentError) { @p.depends :one, :two }
+    err_regex = /unknown option 'two'/
+    assert_raises_errmatch(ArgumentError, err_regex) { @p.depends :one, :two }
     @p.opt :two
     @p.depends :one, :two
     @p.parse %w(--one --two)
-    assert_raises(CommandlineError) { @p.parse %w(--one) }
-    assert_raises(CommandlineError) { @p.parse %w(--two) }
+    err_regex = /--one, --two have a dependency and must be given together/
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--one) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--two) }
 
     @p.opt :hello
     @p.opt :yellow
     @p.opt :mellow
     @p.opt :jello
     @p.depends :hello, :yellow, :mellow, :jello
     @p.parse %w(--hello --yellow --mellow --jello)
-    assert_raises(CommandlineError) { @p.parse %w(--hello --mellow --jello) }
-    assert_raises(CommandlineError) { @p.parse %w(--hello --jello) }
+    err_regex = /-hello, --yellow, --mellow, --jello have a dependency and must be given together/
+
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --mellow --jello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello --jello) }
 
-    assert_raises(CommandlineError) { @p.parse %w(--hello) }
-    assert_raises(CommandlineError) { @p.parse %w(--mellow) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--hello) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow) }
 
     @p.parse %w(--hello --yellow --mellow --jello --one --two)
     @p.parse %w(--hello --yellow --mellow --jello --one --two a b c)
 
-    assert_raises(CommandlineError) { @p.parse %w(--mellow --two --jello --one) }
+    assert_raises_errmatch(CommandlineError, err_regex) { @p.parse %w(--mellow --two --jello --one) }
   end
 
   def test_depends_error_messages

test/optimist/parser_parse_test.rb

@@ -37,7 +37,7 @@ def test_help_with_arg_error
 
   def test_version_needed_unset
     parser.opt "arg"
-    assert_raises(CommandlineError) { parser.parse %w(-v) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '-v'/) { parser.parse %w(-v) }
   end
 
   def test_version_needed
@@ -54,7 +54,7 @@ def test_version_overridden
 
   def test_version_only_appears_if_set
     parser.opt "arg"
-    assert_raises(CommandlineError) { parser.parse %w(-v) }
+    assert_raises_errmatch(CommandlineError, /unknown argument '-v'/) { parser.parse %w(-v) }
   end
 
   def test_version_with_other_args

test/optimist/parser_permitted_test.rb

@@ -13,15 +13,15 @@ def test_permitted_flags_filter_inputs
 
     result = @p.parse(%w(--arg foo))
     assert_equal ["foo"], result["arg"]
-    assert_raises(CommandlineError) { @p.parse(%w(--arg baz)) }
+    assert_raises_errmatch(CommandlineError, /option '--arg' only accepts one of: foo, bar/) { @p.parse(%w(--arg baz)) }
   end
 
   def test_permitted_invalid_scalar_value
     err_regexp = /permitted values for option "(bad|mad|sad)" must be either nil, Range, Regexp or an Array/
-    assert_raises(ArgumentError, err_regexp) {
+    assert_raises_errmatch(ArgumentError, err_regexp) {
       @p.opt 'bad', 'desc', :permitted => 1
     }
-    assert_raises(ArgumentError, err_regexp) {
+    assert_raises_errmatch(ArgumentError, err_regexp) {
       @p.opt 'mad', 'desc', :permitted => "A"
     }
     assert_raises_errmatch(ArgumentError, err_regexp) {