hammer_cli 3.7.0 → 3.8.0

data/test/unit/options/normalizers_test.rb

@@ -8,7 +8,7 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::AbstractNormalizer.new }
 
     it "should raise exception on format" do
-      proc { formatter.format(nil) }.must_raise NotImplementedError
+      _{ formatter.format(nil) }.must_raise NotImplementedError
     end
 
   end
@@ -18,19 +18,19 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::Default.new }
 
     it "should not change any value" do
-      formatter.format('value').must_equal 'value'
+      _(formatter.format('value')).must_equal 'value'
     end
 
     it "should not change nil value" do
-      formatter.format(nil).must_be_nil
+      _(formatter.format(nil)).must_be_nil
       end
 
     it "has empty description" do
-      formatter.description.must_equal ''
+      _(formatter.description).must_equal ''
     end
 
     it "has empty completion" do
-      formatter.complete('test').must_equal []
+      _(formatter.complete('test')).must_equal []
     end
   end
 
@@ -39,44 +39,44 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::List.new }
 
     it "should return empty array on nil" do
-      formatter.format(nil).must_equal []
+      _(formatter.format(nil)).must_equal []
     end
 
     it "should return empty array on empty string" do
-      formatter.format("").must_equal []
+      _(formatter.format("")).must_equal []
     end
 
     it "should parse a string" do
-      formatter.format("a").must_equal ['a']
+      _(formatter.format("a")).must_equal ['a']
     end
 
     it "should parse a number" do
-      formatter.format("2").must_equal [2]
+      _(formatter.format("2")).must_equal [2]
     end
 
     it "should parse a comma separated string" do
-      formatter.format("a,b,c").must_equal ['a', 'b', 'c']
+      _(formatter.format("a,b,c")).must_equal ['a', 'b', 'c']
     end
 
     it "should parse a comma separated string with values including comma" do
-      formatter.format('a,b,"c,d"').must_equal ['a', 'b', 'c,d']
+      _(formatter.format('a,b,"c,d"')).must_equal ['a', 'b', 'c,d']
     end
 
     it "should parse a comma separated string with values including comma (doublequotes)" do
-      formatter.format("a,b,'c,d'").must_equal ['a', 'b', 'c,d']
+      _(formatter.format("a,b,'c,d'")).must_equal ['a', 'b', 'c,d']
     end
 
     it "should parse a comma separated string containig double quotes" do
-      formatter.format('a,b,\"c\"').must_equal ['a', 'b', '"c"']
+      _(formatter.format('a,b,\"c\"')).must_equal ['a', 'b', '"c"']
     end
 
     it "should catch quoting errors" do
-      proc { formatter.format('1,"3,4""s') }.must_raise ArgumentError
+      _{ formatter.format('1,"3,4""s') }.must_raise ArgumentError
     end
 
     it "should accept and parse JSON" do
       value = {'name' => 'bla', 'value' => 1}
-      formatter.format(value.to_json).must_equal([value])
+      _(formatter.format(value.to_json)).must_equal([value])
     end
   end
 
@@ -102,19 +102,19 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::ListNested.new(param.params) }
 
     it "should accept and parse JSON" do
-      formatter.format("{\"name\":\"bla\", \"value\":1}").must_equal(
+      _(formatter.format("{\"name\":\"bla\", \"value\":1}")).must_equal(
         JSON.parse("{\"name\":\"bla\", \"value\":1}")
       )
     end
 
     it "should parse simple input" do
-      formatter.format("name=test\\,value=1,name=other\\,value=2").must_equal(
+      _(formatter.format("name=test\\,value=1,name=other\\,value=2")).must_equal(
         [{'name' => 'test', 'value' => '1'}, {'name' => 'other', 'value' => '2'}]
       )
     end
 
     it "should parse unexpected input" do
-      formatter.format("name=test\\,value=1,name=other\\,value=2,unexp=doe").must_equal(
+      _(formatter.format("name=test\\,value=1,name=other\\,value=2,unexp=doe")).must_equal(
         [
           {'name' => 'test', 'value' => '1'}, {'name' => 'other', 'value' => '2'},
           {'unexp' => 'doe'}
@@ -123,15 +123,15 @@ describe HammerCLI::Options::Normalizers do
     end
 
     it "should accept arrays" do
-      formatter.format("name=test\\,value=1,name=other\\,value=[1\\,2\\,3]").must_equal(
+      _(formatter.format("name=test\\,value=1,name=other\\,value=[1\\,2\\,3]")).must_equal(
         [{'name' => 'test', 'value' => '1'}, {'name' => 'other', 'value' => ['1', '2', '3']}]
       )
     end
 
     it "should accept hashes" do
-      formatter.format(
+      _(formatter.format(
         "name=test\\,value={key=key1\\,value=1},name=other\\,value={key=key2\\,value=2}"
-      ).must_equal(
+      )).must_equal(
         [
           {'name' => 'test', 'value' => {'key' => 'key1', 'value' => '1'}},
           {'name' => 'other', 'value' => {'key' => 'key2', 'value' => '2'}},
@@ -140,10 +140,10 @@ describe HammerCLI::Options::Normalizers do
     end
 
     it "should accept combined input" do
-      formatter.format(
+      _(formatter.format(
         "name=foo\\,value=1\\,adds=[1\\,2\\,3]\\,cpu={name=ddd\\,type=abc}," \
         "name=bar\\,value=2\\,adds=[2\\,2\\,2]\\,cpu={name=ccc\\,type=cba}"
-      ).must_equal(
+      )).must_equal(
         [
           {'name' => 'foo', 'value' => '1', 'adds' => ['1','2','3'], 'cpu' => {'name' => 'ddd', 'type' => 'abc'}},
           {'name' => 'bar', 'value' => '2', 'adds' => ['2','2','2'], 'cpu' => {'name' => 'ccc', 'type' => 'cba'}}
@@ -157,100 +157,104 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::KeyValueList.new }
 
     it "should return empty array on nil" do
-      formatter.format(nil).must_equal({})
+      _(formatter.format(nil)).must_equal({})
     end
 
     it "should return empty array on empty string" do
-      formatter.format("").must_equal({})
+      _(formatter.format("")).must_equal({})
     end
 
     it "should parse a string" do
-      proc { formatter.format("a") }.must_raise ArgumentError
+      _{ formatter.format("a") }.must_raise ArgumentError
     end
 
     describe 'key=value format' do
+      it 'should parse values with commas' do
+        _(formatter.format('a=1,2,b=3,4')).must_equal({ 'a' => '1,2', 'b' => '3,4'})
+      end
+
       it "should parse a comma separated string" do
-        formatter.format("a=1,b=2,c=3").must_equal({'a' => '1', 'b' => '2', 'c' => '3'})
+        _(formatter.format("a=1,b=2,c=3")).must_equal({'a' => '1', 'b' => '2', 'c' => '3'})
       end
 
       it "should parse a comma separated string with spaces" do
-        formatter.format("a= 1 , b = 2 ,c =3").must_equal({'a' => '1', 'b' => '2', 'c' => '3'})
+        _(formatter.format("a= 1 , b = 2 ,c =3")).must_equal({'a' => '1', 'b' => '2', 'c' => '3'})
       end
 
       it 'should parse a comma separated string with spaces using single quotes' do
-        formatter.format("a= ' 1 ' , b =' 2',c ='3'").must_equal({ 'a' => "' 1 '", 'b' => "' 2'", 'c' => "'3'" })
+        _(formatter.format("a= ' 1 ' , b =' 2',c ='3'")).must_equal({ 'a' => "' 1 '", 'b' => "' 2'", 'c' => "'3'" })
       end
 
       it 'should parse a comma separated string with spaces using double quotes' do
-        formatter.format('a= " 1 " , b =" 2",c ="3"').must_equal({ 'a' => '" 1 "', 'b' => '" 2"', 'c' => '"3"' })
+        _(formatter.format('a= " 1 " , b =" 2",c ="3"')).must_equal({ 'a' => '" 1 "', 'b' => '" 2"', 'c' => '"3"' })
       end
 
       it 'should deal with equal sign in string value' do
-        formatter.format("a=1,b='2=2',c=3").must_equal({ 'a' => '1', 'b' => "'2=2'", 'c' => '3' })
+        _(formatter.format("a=1,b='2=2',c=3")).must_equal({ 'a' => '1', 'b' => "'2=2'", 'c' => '3' })
       end
 
       it 'should deal with equal sign in value' do
-        formatter.format('a=1,b=2=2,c=3').must_equal({ 'a' => '1', 'b' => '2=2', 'c' => '3' })
+        _(formatter.format('a=1,b=2=2,c=3')).must_equal({ 'a' => '1', 'b' => '2=2', 'c' => '3' })
       end
 
       it "should parse arrays" do
-        formatter.format("a=1,b=[1,2,3],c=3").must_equal({'a' => '1', 'b' => ['1', '2', '3'], 'c' => '3'})
+        _(formatter.format("a=1,b=[1,2,3],c=3")).must_equal({'a' => '1', 'b' => ['1', '2', '3'], 'c' => '3'})
       end
 
       it "should parse arrays with spaces" do
-        formatter.format("a=1,b=[1, 2, 3],c=3").must_equal({'a' => '1', 'b' => ['1', '2', '3'], 'c' => '3'})
+        _(formatter.format("a=1,b=[1, 2, 3],c=3")).must_equal({'a' => '1', 'b' => ['1', '2', '3'], 'c' => '3'})
       end
 
       it 'should parse arrays with spaces using by single quotes' do
-        formatter.format("a=1,b=['1 1', ' 2 ', ' 3 3'],c=3").must_equal(
+        _(formatter.format("a=1,b=['1 1', ' 2 ', ' 3 3'],c=3")).must_equal(
           { 'a' => '1', 'b' => ["'1 1'", "' 2 '", "' 3 3'"], 'c' => '3' }
         )
       end
 
       it 'should parse arrays with spaces using by double quotes' do
-        formatter.format('a=1,b=["1 1", " 2 ", " 3 3"],c=3').must_equal(
+        _(formatter.format('a=1,b=["1 1", " 2 ", " 3 3"],c=3')).must_equal(
           { 'a' => '1', 'b' => ['"1 1"', '" 2 "', '" 3 3"'], 'c' => '3' }
         )
       end
 
       it 'should parse arrays with spaces' do
-        formatter.format('a=1,b=[1 1,  2 ,  3 3],c=3').must_equal({ 'a' => '1', 'b' => ['1 1', '2', '3 3'], 'c' => '3' })
+        _(formatter.format('a=1,b=[1 1,  2 ,  3 3],c=3')).must_equal({ 'a' => '1', 'b' => ['1 1', '2', '3 3'], 'c' => '3' })
       end
 
       it "should parse array with one item" do
-        formatter.format("a=1,b=[abc],c=3").must_equal({'a' => '1', 'b' => ['abc'], 'c' => '3'})
+        _(formatter.format("a=1,b=[abc],c=3")).must_equal({'a' => '1', 'b' => ['abc'], 'c' => '3'})
       end
 
       it "should parse empty array" do
-        formatter.format("a=1,b=[],c=3").must_equal({'a' => '1', 'b' => [], 'c' => '3'})
+        _(formatter.format("a=1,b=[],c=3")).must_equal({'a' => '1', 'b' => [], 'c' => '3'})
       end
 
       it "should parse hash with one item" do
-        formatter.format("a=1,b={key=abc,value=abc},c=3").must_equal(
+        _(formatter.format("a=1,b={key=abc,value=abc},c=3")).must_equal(
           {'a' => '1', 'b' => {'key' => 'abc', 'value' => 'abc'}, 'c' => '3'}
         )
       end
 
       it "should parse empty hash" do
-        formatter.format("a=1,b={},c=3").must_equal({'a' => '1', 'b' => {}, 'c' => '3'})
+        _(formatter.format("a=1,b={},c=3")).must_equal({'a' => '1', 'b' => {}, 'c' => '3'})
       end
 
       it "should parse a comma separated string 2" do
-        proc { formatter.format("a=1,b,c=3") }.must_raise ArgumentError
+        _(formatter.format("a=1,b,c=3")).must_equal({ 'a' => '1,b', 'c' => '3' })
       end
 
       it 'should parse explicit strings' do
-        formatter.format('name="*"').must_equal({ 'name' => '"*"' })
+        _(formatter.format('name="*"')).must_equal({ 'name' => '"*"' })
       end
     end
 
     describe 'json format' do
       it 'parses arrays' do
-        formatter.format('["a", "b", 1]').must_equal(['a', 'b', 1])
+        _(formatter.format('["a", "b", 1]')).must_equal(['a', 'b', 1])
       end
 
       it 'parses objects' do
-        formatter.format('{"a": ["b", 1]}').must_equal({'a' => ['b', 1]})
+        _(formatter.format('{"a": ["b", 1]}')).must_equal({'a' => ['b', 1]})
       end
     end
   end
@@ -259,11 +263,11 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::Number.new }
 
     it "should return number on numeric values" do
-      formatter.format("1").must_equal 1
+      _(formatter.format("1")).must_equal 1
     end
 
     it "should raise ArgumentError on non-numeric values" do
-      proc { formatter.format("a") }.must_raise ArgumentError
+      _{ formatter.format("a") }.must_raise ArgumentError
     end
   end
 
@@ -272,59 +276,59 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::Bool.new }
 
     it "should return true on true" do
-      formatter.format("true").must_equal(true)
-      formatter.format("TRUE").must_equal(true)
+      _(formatter.format("true")).must_equal(true)
+      _(formatter.format("TRUE")).must_equal(true)
     end
 
     it "should return true on t" do
-      formatter.format("t").must_equal(true)
-      formatter.format("T").must_equal(true)
+      _(formatter.format("t")).must_equal(true)
+      _(formatter.format("T")).must_equal(true)
     end
 
     it "should return true on yes" do
-      formatter.format("yes").must_equal(true)
-      formatter.format("YES").must_equal(true)
+      _(formatter.format("yes")).must_equal(true)
+      _(formatter.format("YES")).must_equal(true)
     end
 
     it "should return true on y" do
-      formatter.format("y").must_equal(true)
-      formatter.format("Y").must_equal(true)
+      _(formatter.format("y")).must_equal(true)
+      _(formatter.format("Y")).must_equal(true)
     end
 
     it "should return true on 1" do
-      formatter.format("1").must_equal(true)
+      _(formatter.format("1")).must_equal(true)
     end
 
     it "should return false on false" do
-      formatter.format("false").must_equal(false)
-      formatter.format("FALSE").must_equal(false)
+      _(formatter.format("false")).must_equal(false)
+      _(formatter.format("FALSE")).must_equal(false)
     end
 
     it "should return false on f" do
-      formatter.format("f").must_equal(false)
-      formatter.format("F").must_equal(false)
+      _(formatter.format("f")).must_equal(false)
+      _(formatter.format("F")).must_equal(false)
     end
 
     it "should return false on no" do
-      formatter.format("no").must_equal(false)
-      formatter.format("NO").must_equal(false)
+      _(formatter.format("no")).must_equal(false)
+      _(formatter.format("NO")).must_equal(false)
     end
 
     it "should return false on n" do
-      formatter.format("n").must_equal(false)
-      formatter.format("N").must_equal(false)
+      _(formatter.format("n")).must_equal(false)
+      _(formatter.format("N")).must_equal(false)
     end
 
     it "should return false on 0" do
-      formatter.format("0").must_equal(false)
+      _(formatter.format("0")).must_equal(false)
     end
 
     it "should raise exception on nil" do
-      proc { formatter.format(nil) }.must_raise ArgumentError
+      _{ formatter.format(nil) }.must_raise ArgumentError
     end
 
     it "should raise exception on other values" do
-      proc { formatter.format('unknown') }.must_raise ArgumentError
+      _{ formatter.format('unknown') }.must_raise ArgumentError
     end
   end
 
@@ -333,24 +337,24 @@ describe HammerCLI::Options::Normalizers do
 
     it "should return a hash on valid json file" do
       file = File.join(File.dirname(__FILE__), '../fixtures/json_input/valid.json')
-      formatter.format(file).must_equal({ "units" => [ { "name" => "zip", "version" => "10.0" },
+      _(formatter.format(file)).must_equal({ "units" => [ { "name" => "zip", "version" => "10.0" },
                                         { "name" => "zap", "version" => "9.0" }] })
     end
 
     it "should raise exception on invalid json file contents" do
       file = File.join(File.dirname(__FILE__), '../fixtures/json_input/invalid.json')
-      proc { formatter.format(file) }.must_raise ArgumentError
+      _{ formatter.format(file) }.must_raise ArgumentError
     end
 
     it "should return a hash on valid json string" do
       json_string = '{ "units":[{ "name":"zip", "version":"10.0" }, { "name":"zap", "version":"9.0" }] }'
-      formatter.format(json_string).must_equal({ "units" => [ { "name" => "zip", "version" => "10.0" },
+      _(formatter.format(json_string)).must_equal({ "units" => [ { "name" => "zip", "version" => "10.0" },
                                                               { "name" => "zap", "version" => "9.0" }] })
     end
 
     it "should raise exception on invalid json string" do
       json_string = "{ units:[{ name:zip, version:10.0 }, { name:zap, version:9.0 }] }"
-      proc { formatter.format(json_string) }.must_raise ArgumentError
+      _{ formatter.format(json_string) }.must_raise ArgumentError
     end
 
   end
@@ -360,19 +364,19 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::Enum.new ['a', 'b'] }
 
     it "should return return value when in the list" do
-      formatter.format("a").must_equal("a")
+      _(formatter.format("a")).must_equal("a")
     end
 
     it "should rise argument error when the value is nil" do
-      proc { formatter.format(nil) }.must_raise ArgumentError
+      _{ formatter.format(nil) }.must_raise ArgumentError
     end
 
     it "should rise argument error when the value is not in the list" do
-      proc { formatter.format("c") }.must_raise ArgumentError
+      _{ formatter.format("c") }.must_raise ArgumentError
     end
 
     it "should list allowed values in description" do
-      formatter.description.must_equal("Possible value(s): 'a', 'b'")
+      _(formatter.description).must_equal("Possible value(s): 'a', 'b'")
     end
 
   end
@@ -382,32 +386,32 @@ describe HammerCLI::Options::Normalizers do
     let (:formatter) { HammerCLI::Options::Normalizers::EnumList.new ['1', '2', 'a', 'b'] }
 
     it "should return array of values when the values are allowed" do
-      formatter.format("a,b,1").must_equal(['a', 'b', '1'])
+      _(formatter.format("a,b,1")).must_equal(['a', 'b', '1'])
     end
 
     it "should raise argument error when any of the values isn't in the list" do
-      proc { formatter.format("c,d") }.must_raise ArgumentError
-      proc { formatter.format('1,x') }.must_raise ArgumentError
+      _{ formatter.format("c,d") }.must_raise ArgumentError
+      _{ formatter.format('1,x') }.must_raise ArgumentError
     end
 
     it "should remove duplicate values" do
-      formatter.format("a,a,a,a,a").must_equal ['a']
+      _(formatter.format("a,a,a,a,a")).must_equal ['a']
     end
 
     it "should not change order of the values" do
-      formatter.format("a,b,2,1").must_equal ['a', 'b', '2', '1']
+      _(formatter.format("a,b,2,1")).must_equal ['a', 'b', '2', '1']
     end
 
     it "should return empty array on nil" do
-      formatter.format(nil).must_equal []
+      _(formatter.format(nil)).must_equal []
     end
 
     it "should return empty array on empty string" do
-      formatter.format("").must_equal []
+      _(formatter.format("")).must_equal []
     end
 
     it "should list allowed values in description" do
-      formatter.description.must_equal("Any combination (comma separated list) of ''1', '2', 'a', 'b''")
+      _(formatter.description).must_equal("Any combination (comma separated list) of ''1', '2', 'a', 'b''")
     end
 
   end
@@ -417,23 +421,23 @@ describe HammerCLI::Options::Normalizers do
     let(:formatter) { HammerCLI::Options::Normalizers::DateTime.new }
 
     it "should raise argument error when the value is nil" do
-      proc { formatter.format(nil) }.must_raise ArgumentError
+      _{ formatter.format(nil) }.must_raise ArgumentError
     end
 
     it "should raise argument error when the value is not a date" do
-      proc { formatter.format("not a date") }.must_raise ArgumentError
+      _{ formatter.format("not a date") }.must_raise ArgumentError
     end
 
     it "should accept and parse iso8601" do
-      formatter.format("1986-01-01T08:30:20").must_equal("1986-01-01T08:30:20+00:00")
+      _(formatter.format("1986-01-01T08:30:20")).must_equal("1986-01-01T08:30:20+00:00")
     end
 
     it "should accept and parse YYYY-MM-DD HH:MM:SS" do
-      formatter.format("1986-01-01 08:30:20").must_equal("1986-01-01T08:30:20+00:00")
+      _(formatter.format("1986-01-01 08:30:20")).must_equal("1986-01-01T08:30:20+00:00")
     end
 
     it "should accept and parse YYYY/MM/DD HH:MM:SS" do
-      formatter.format("1986/01/01 08:30:20").must_equal("1986-01-01T08:30:20+00:00")
+      _(formatter.format("1986/01/01 08:30:20")).must_equal("1986-01-01T08:30:20+00:00")
     end
 
   end

data/test/unit/options/option_definition_test.rb

@@ -41,7 +41,7 @@ describe HammerCLI::Options::OptionDefinition do
       opt = TestOptionFormattersCmd.find_option("--test-format")
 
       opt_instance = opt.of(TestOptionFormattersCmd.new([]))
-      opt_instance.read.must_equal '>>>A<<<'
+      _(opt_instance.read).must_equal '>>>A<<<'
     end
 
     it "should use formatter as a conversion block" do
@@ -54,7 +54,7 @@ describe HammerCLI::Options::OptionDefinition do
       else
         opt_instance.take('B')
       end
-      opt_instance.read.must_equal '>>>B<<<'
+      _(opt_instance.read).must_equal '>>>B<<<'
     end
   end
 
@@ -64,8 +64,8 @@ describe HammerCLI::Options::OptionDefinition do
       cmd = TestDeprecatedOptionCmd.new("", context)
 
       _, err = capture_io { cmd.run(["--another-deprecated=VALUE"]) }
-      err.must_match(/Warning: Option --another-deprecated is deprecated. It is going to be removed/)
-      context[:old_option].must_equal "VALUE"
+      _(err).must_match(/Warning: Option --another-deprecated is deprecated. It is going to be removed/)
+      _(context[:old_option]).must_equal "VALUE"
     end
 
     it "prints deprecation warning (extended version)" do
@@ -73,8 +73,8 @@ describe HammerCLI::Options::OptionDefinition do
       cmd = TestDeprecatedOptionCmd.new("", context)
 
       _, err = capture_io { cmd.run(["--deprecated=VALUE"]) }
-      err.must_match(/Warning: Option --deprecated is deprecated. Use --test-option instead/)
-      context[:test_option].must_equal "VALUE"
+      _(err).must_match(/Warning: Option --deprecated is deprecated. Use --test-option instead/)
+      _(context[:test_option]).must_equal "VALUE"
     end
 
     it "doesn't print deprecation warning if the option is not used" do
@@ -82,22 +82,22 @@ describe HammerCLI::Options::OptionDefinition do
       cmd = TestDeprecatedOptionCmd.new('', context)
       cmd.find_option('--deprecated')
       _out, err = capture_io { cmd.run([]) }
-      err.must_equal ''
+      _(err).must_equal ''
     end
 
     it 'shows depracated message in help' do
       opt = opt_with_deprecation("Use --better-switch instead")
-      opt.description.must_equal "Test option (Deprecated: Use --better-switch instead)"
+      _(opt.description).must_equal "Test option (Deprecated: Use --better-switch instead)"
     end
 
     it 'shows flag specific depracated message in help' do
       opt = opt_with_deprecation('--test-option' => "Use --better-switch instead")
-      opt.description.must_equal "Test option (--test-option is deprecated: Use --better-switch instead)"
+      _(opt.description).must_equal "Test option (--test-option is deprecated: Use --better-switch instead)"
     end
 
     it 'shows multiple flag specific depracated messages in help' do
       opt = opt_with_deprecation('--test-option' => "Use --better-switch instead", '--test-option2' => 'This is deprecated too')
-      opt.description.must_equal "Test option (--test-option is deprecated: Use --better-switch instead, --test-option2 is deprecated: This is deprecated too)"
+      _(opt.description).must_equal "Test option (--test-option is deprecated: Use --better-switch instead, --test-option2 is deprecated: This is deprecated too)"
     end
   end
 
@@ -106,7 +106,7 @@ describe HammerCLI::Options::OptionDefinition do
       context = {}
       cmd = TestOptionFormattersCmd.new("", context)
       cmd.run(["--test-context=VALUE"])
-      context[:test_option].must_equal "VALUE"
+      _(context[:test_option]).must_equal "VALUE"
     end
   end
 end

data/test/unit/options/option_family_test.rb

@@ -15,34 +15,34 @@ describe HammerCLI::Options::OptionFamily do
 
   describe 'switch' do
     it 'returns nil if family is empty' do
-      family.switch.must_be_nil
+      _(family.switch).must_be_nil
     end
 
     it 'returns parent switch if family has no children' do
       family.parent('--test-one', '', '')
-      family.switch.must_equal '--test-one'
+      _(family.switch).must_equal '--test-one'
     end
 
     it 'returns switch based on members' do
-      full_family.switch.must_equal '--test[-two|-one]'
+      _(full_family.switch).must_equal '--test[-two|-one]'
     end
   end
 
   describe 'description' do
     it 'returns parent description if nothing passed to initializer' do
-      full_family.description.must_equal full_family.head.help[1]
+      _(full_family.description).must_equal full_family.head.help[1]
     end
 
     it 'returns description with deprecation message' do
-      full_family.description.must_equal 'Test (--test-one is deprecated: Use --test-two instead)'
+      _(full_family.description).must_equal 'Test (--test-one is deprecated: Use --test-two instead)'
     end
   end
 
   describe 'adopt' do
     it 'appends an option to children' do
       full_family.adopt(third_option)
-      full_family.children.size.must_equal 2
-      third_option.family.must_equal full_family
+      _(full_family.children.size).must_equal 2
+      _(third_option.family).must_equal full_family
     end
   end
 end