hammer_cli 3.7.0 → 3.9.0

data/test/unit/options/validators/dsl_test.rb

@@ -22,7 +22,7 @@ describe "constraints" do
     describe "exist?" do
       it "throws not implemented error" do
         constraint = cls.new(options, option_values, [:option_a, :option_b, :option_c])
-        proc{ constraint.exist? }.must_raise NotImplementedError
+        _{ constraint.exist? }.must_raise NotImplementedError
       end
     end
 
@@ -30,7 +30,7 @@ describe "constraints" do
       it "should raise exception when exist? returns true" do
         constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(true)
-        proc{ constraint.rejected }.must_raise HammerCLI::Options::Validators::ValidationError
+        _{ constraint.rejected }.must_raise HammerCLI::Options::Validators::ValidationError
       end
 
       it "should raise exception with a message" do
@@ -39,14 +39,14 @@ describe "constraints" do
         begin
           constraint.rejected :msg => "CUSTOM MESSAGE"
         rescue HammerCLI::Options::Validators::ValidationError => e
-          e.message.must_equal "CUSTOM MESSAGE"
+          _(e.message).must_equal "CUSTOM MESSAGE"
         end
       end
 
       it "should return nil when exist? returns true" do
         constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(false)
-        constraint.rejected.must_equal nil
+        assert_nil constraint.rejected
       end
     end
 
@@ -54,7 +54,7 @@ describe "constraints" do
       it "should raise exception when exist? returns true" do
         constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(false)
-        proc{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
+        _{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
       end
 
       it "should raise exception with a message" do
@@ -63,14 +63,14 @@ describe "constraints" do
         begin
           constraint.rejected :msg => "CUSTOM MESSAGE"
         rescue HammerCLI::Options::Validators::ValidationError => e
-          e.message.must_equal "CUSTOM MESSAGE"
+          _(e.message).must_equal "CUSTOM MESSAGE"
         end
       end
 
       it "should return nil when exist? returns true" do
         constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(true)
-        constraint.required.must_equal nil
+        assert_nil constraint.required
       end
     end
 
@@ -84,17 +84,17 @@ describe "constraints" do
 
       it "should return true when no options are passed" do
         constraint = cls.new(options, option_values, [])
-        constraint.exist?.must_equal true
+        _(constraint.exist?).must_equal true
       end
 
       it "should return true when all the options exist" do
         constraint = cls.new(options, option_values, [:option_a, :option_b, :option_c])
-        constraint.exist?.must_equal true
+        _(constraint.exist?).must_equal true
       end
 
       it "should return false when one of the options is missing" do
         constraint = cls.new(options, option_values, [:option_a, :option_b, :option_c, :option_unset_d])
-        constraint.exist?.must_equal false
+        _(constraint.exist?).must_equal false
       end
     end
 
@@ -106,50 +106,50 @@ describe "constraints" do
     describe "exist?" do
       it "should return true when the option exist" do
         constraint = cls.new(options, option_values, :option_a)
-        constraint.exist?.must_equal true
+        _(constraint.exist?).must_equal true
       end
 
       it "should return false when the option is missing" do
         constraint = cls.new(options, option_values, :option_unset_d)
-        constraint.exist?.must_equal false
+        _(constraint.exist?).must_equal false
       end
     end
 
     describe "#rejected" do
       it "returns nil when the option is missing" do
         constraint = cls.new(options, option_values, :option_unset_d)
-        constraint.rejected.must_equal nil
+        assert_nil constraint.rejected
       end
 
       it "raises exception when the option is present" do
         constraint = cls.new(options, option_values, :option_a)
-        e = proc{ constraint.rejected }.must_raise HammerCLI::Options::Validators::ValidationError
-        e.message.must_equal "You can't set option --option-a."
+        e = _{ constraint.rejected }.must_raise HammerCLI::Options::Validators::ValidationError
+        _(e.message).must_equal "You can't set option --option-a."
       end
     end
 
     describe "#required" do
       it "returns nil when the option exist" do
         constraint = cls.new(options, option_values, :option_a)
-        constraint.required.must_equal nil
+        assert_nil constraint.required
       end
 
       it "raises exception when the option is present" do
         constraint = cls.new(options, option_values, :option_unset_d)
-        e = proc{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
-        e.message.must_equal 'Option --option-unset-d is required.'
+        e = _{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
+        _(e.message).must_equal 'Option --option-unset-d is required.'
       end
     end
 
     describe "#value" do
       it "returns value of the option" do
         constraint = cls.new(options, option_values, :option_a)
-        constraint.value.must_equal 1
+        _(constraint.value).must_equal 1
       end
 
       it "returns nil when the option is missing" do
         constraint = cls.new(options, option_values, :option_unset_d)
-        constraint.value.must_equal nil
+        assert_nil constraint.value
       end
     end
   end
@@ -162,17 +162,17 @@ describe "constraints" do
 
       it "should return true when no options are passed" do
         constraint = cls.new(options, option_values, [])
-        constraint.exist?.must_equal true
+        _(constraint.exist?).must_equal true
       end
 
       it "should return true when one of the options exist" do
         constraint = cls.new(options, option_values, [:option_a, :option_unset_d, :option_unset_e])
-        constraint.exist?.must_equal true
+        _(constraint.exist?).must_equal true
       end
 
       it "should return false when all the options are missing" do
         constraint = cls.new(options, option_values, [:option_unset_d, :option_unset_e])
-        constraint.exist?.must_equal false
+        _(constraint.exist?).must_equal false
       end
     end
 
@@ -183,51 +183,51 @@ describe "constraints" do
     let(:cls) { HammerCLI::Options::Validators::DSL::OneOfConstraint }
 
     it "raises exception when nothing to check is set" do
-      e = proc{ cls.new(options, option_values, []) }.must_raise RuntimeError
-      e.message.must_equal 'Set at least one expected option'
+      e = _{ cls.new(options, option_values, []) }.must_raise RuntimeError
+      _(e.message).must_equal 'Set at least one expected option'
     end
 
     describe "#exist?" do
       it "should return true when one of the options exist" do
         constraint = cls.new(options, option_values, [:option_a, :option_unset_d, :option_unset_e])
-        constraint.exist?.must_equal true
+        _(constraint.exist?).must_equal true
       end
 
       it "should return false when the option isn't present" do
         constraint = cls.new(options, option_values, [:option_unset_d, :option_unset_e])
-        constraint.exist?.must_equal false
+        _(constraint.exist?).must_equal false
       end
 
       it "should return false when more than one of the options is present" do
         constraint = cls.new(options, option_values, [:option_a, :option_b])
-        constraint.exist?.must_equal false
+        _(constraint.exist?).must_equal false
       end
     end
 
     describe "#rejected" do
       it "raises not implemented exception" do
         constraint = cls.new(options, option_values, [:option_a, :option_unset_d])
-        e = proc{ constraint.rejected }.must_raise NotImplementedError
-        e.message.must_equal '#rejected is unsupported for OneOfConstraint'
+        e = _{ constraint.rejected }.must_raise NotImplementedError
+        _(e.message).must_equal '#rejected is unsupported for OneOfConstraint'
       end
     end
 
     describe "#required" do
       it "returns nil when one of the options exist" do
         constraint = cls.new(options, option_values, [:option_a, :option_unset_d, :option_unset_e])
-        constraint.required.must_equal nil
+        assert_nil constraint.required
       end
 
       it "raises exception when none of the options is present" do
         constraint = cls.new(options, option_values, [:option_unset_d, :option_unset_e])
-        e = proc{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
-        e.message.must_equal 'One of options --option-unset-d, --option-unset-e is required.'
+        e = _{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
+        _(e.message).must_equal 'One of options --option-unset-d, --option-unset-e is required.'
       end
 
       it "raises exception when more than one of the options is present" do
         constraint = cls.new(options, option_values, [:option_a, :option_b])
-        e = proc{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
-        e.message.must_equal 'Only one of options --option-a, --option-b can be set.'
+        e = _{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
+        _(e.message).must_equal 'Only one of options --option-a, --option-b can be set.'
       end
     end
   end

data/test/unit/output/adapter/abstract_test.rb

@@ -7,7 +7,7 @@ describe HammerCLI::Output::Adapter::Abstract do
 
 
   it "should have features" do
-    adapter.features.must_be_kind_of Array
+    _(adapter.features).must_be_kind_of Array
   end
 
   class UnknownTestFormatter < HammerCLI::Output::Formatters::FieldFormatter
@@ -21,7 +21,7 @@ describe HammerCLI::Output::Adapter::Abstract do
   end
 
   it "allows default pagination" do
-    adapter.paginate_by_default?.must_equal true
+    _(adapter.paginate_by_default?).must_equal true
   end
 
   it "should filter formatters with incompatible features" do
@@ -52,25 +52,25 @@ describe HammerCLI::Output::Adapter::Abstract do
 
   context "messages" do
     it "should print message to stdout" do
-      proc { adapter.print_message("MESSAGE") }.must_output(/.*MESSAGE.*/, "")
+      _{ adapter.print_message("MESSAGE") }.must_output(/.*MESSAGE.*/, "")
     end
 
     it "should print formatted message with parameters" do
-      proc { adapter.print_message("MESSAGE %{a}, %{b}", :a => 'A', :b => 'B') }.must_output(/.*MESSAGE A, B.*/, "")
+      _{ adapter.print_message("MESSAGE %{a}, %{b}", :a => 'A', :b => 'B') }.must_output(/.*MESSAGE A, B.*/, "")
     end
 
     it 'should print message with nil params' do
-      proc { adapter.print_message('MESSAGE', nil) }.must_output(/.*MESSAGE.*/, '')
+      _{ adapter.print_message('MESSAGE', nil) }.must_output(/.*MESSAGE.*/, '')
     end
   end
 
   it "should raise not implemented on print_collection" do
-    proc { adapter.print_collection([], HammerCLI::Output::RecordCollection.new([])) }.must_raise NotImplementedError
+    _{ adapter.print_collection([], HammerCLI::Output::RecordCollection.new([])) }.must_raise NotImplementedError
   end
 
   context "error messages" do
     it "should print error message to stderr" do
-      proc { adapter.print_error("MESSAGE") }.must_output("", /.*MESSAGE.*/)
+      _{ adapter.print_error("MESSAGE") }.must_output("", /.*MESSAGE.*/)
     end
 
     let(:expected_output) { "MESSAGE:\n"+
@@ -85,15 +85,15 @@ describe HammerCLI::Output::Adapter::Abstract do
     }
 
     it "should print list details of error to stderr" do
-      proc { adapter.print_error("MESSAGE", ["error", "message", "details"]) }.must_output("", expected_output)
+      _{ adapter.print_error("MESSAGE", ["error", "message", "details"]) }.must_output("", expected_output)
     end
 
     it "should print string details of error to stderr" do
-      proc { adapter.print_error("MESSAGE", "error\nmessage\ndetails") }.must_output("", expected_output)
+      _{ adapter.print_error("MESSAGE", "error\nmessage\ndetails") }.must_output("", expected_output)
     end
 
     it "should print formatted message with parameters" do
-      proc {
+      _{
         adapter.print_error("MESSAGE %{a}, %{b}", ["error %{a}", "error %{b}"], :a => 'A', :b => 'B')
       }.must_output("", expected_formatted_output)
     end

data/test/unit/output/adapter/base_test.rb

@@ -6,13 +6,13 @@ describe HammerCLI::Output::Adapter::Base do
   let(:adapter) { HammerCLI::Output::Adapter::Base.new(context, HammerCLI::Output::Output.formatters) }
 
   it "allows default pagination" do
-    adapter.paginate_by_default?.must_equal true
+    _(adapter.paginate_by_default?).must_equal true
   end
 
   context "print_collection" do
 
     let(:id)            { Fields::Id.new(:path => [:id], :label => "Id") }
-    let(:name)          { Fields::Field.new(:path => [:name], :label => "Name") }
+    let(:firstname)     { Fields::Field.new(:path => [:name], :label => "Name") }
     let(:unlabeled)     { Fields::Field.new(:path => [:name]) }
     let(:surname)       { Fields::Field.new(:path => [:surname], :label => "Surname") }
     let(:address_city)  { Fields::Field.new(:path => [:address, :city], :label => "City") }
@@ -59,13 +59,13 @@ describe HammerCLI::Output::Adapter::Base do
     }]}
 
     it "should print one field" do
-      fields = [name]
+      fields = [firstname]
       expected_output = [
         "Name: John",
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "doesn't print label when it's nil" do
@@ -75,11 +75,11 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "aligns multiple fields" do
-      fields = [name, surname, unlabeled]
+      fields = [firstname, surname, unlabeled]
       expected_output = [
         "Name:    John",
         "Surname: Doe",
@@ -87,7 +87,7 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "should field with nested data" do
@@ -97,7 +97,7 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "should print labeled fields" do
@@ -110,7 +110,7 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
 
@@ -127,7 +127,7 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "should print unnumbered collection" do
@@ -143,46 +143,46 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "hides ids by default" do
-      fields = [id, name]
+      fields = [id, firstname]
       expected_output = [
         "Name: John",
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "skips blank values" do
-      fields = [name, blank]
+      fields = [firstname, blank]
       expected_output = [
         "Name: John",
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "does not print fields which data are missing from api by default" do
-      fields = [name, login]
+      fields = [firstname, login]
       expected_output = [
         "Name: John",
         "\n"
       ].join("\n")
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "prints fields which data are missing from api when field has hide_missing flag set to false" do
-      fields = [name, missing]
+      fields = [firstname, missing]
       expected_output = [
         "Name:    John",
         "Missing:",
         "\n"
       ].join("\n")
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     it "should print key -> value" do
@@ -196,7 +196,7 @@ describe HammerCLI::Output::Adapter::Base do
         "\n"
       ].join("\n")
 
-      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      _{ adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
     context 'printing by chunks' do
@@ -208,16 +208,16 @@ describe HammerCLI::Output::Adapter::Base do
         end
         HammerCLI::Output::RecordCollection.new(collection)
       end
-      let(:fields) { [id, name] }
+      let(:fields) { [id, firstname] }
 
       it 'prints single chunk' do
         expected_output = collection_count.times.each_with_object([]) do |t, r|
           r << ["Id:   #{t}", "Name: John #{t}", "\n"].join("\n")
         end.flatten(1).join
 
-        proc do
+        _{
           adapter.print_collection(fields, collection_data)
-        end.must_output(expected_output)
+        }.must_output(expected_output)
       end
 
       it 'prints first chunk' do
@@ -225,11 +225,11 @@ describe HammerCLI::Output::Adapter::Base do
           r << ["Id:   #{t}", "Name: John #{t}", "\n"].join("\n")
         end.flatten(1).join
 
-        proc do
+        _{
           adapter.print_collection(
             fields, collection_data[0...10], current_chunk: :first
           )
-        end.must_output(expected_output)
+        }.must_output(expected_output)
       end
 
       it 'prints another chunk' do
@@ -237,11 +237,11 @@ describe HammerCLI::Output::Adapter::Base do
           r << ["Id:   #{t}", "Name: John #{t}", "\n"].join("\n")
         end.flatten(1).join
 
-        proc do
+        _{
           adapter.print_collection(
             fields, collection_data[10...20], current_chunk: :another
           )
-        end.must_output(expected_output)
+        }.must_output(expected_output)
       end
 
       it 'prints last chunk' do
@@ -249,11 +249,11 @@ describe HammerCLI::Output::Adapter::Base do
           r << ["Id:   #{t}", "Name: John #{t}", "\n"].join("\n")
         end.flatten(1).join
 
-        proc do
+        _{
           adapter.print_collection(
             fields, collection_data[20...30], current_chunk: :last
           )
-        end.must_output(expected_output)
+        }.must_output(expected_output)
       end
     end
 
@@ -262,14 +262,14 @@ describe HammerCLI::Output::Adapter::Base do
       let(:context) { {:show_ids => true} }
 
       it "shows ids if it's required in the context" do
-        fields = [id, name]
+        fields = [id, firstname]
         expected_output = [
           "Id:   112",
           "Name: John",
           "\n"
         ].join("\n")
 
-        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+        _{ adapter.print_collection(fields, data) }.must_output(expected_output)
       end
 
     end
@@ -280,13 +280,13 @@ describe HammerCLI::Output::Adapter::Base do
       let(:context) { {:output_file => tempfile} }
 
       it "should not print to stdout when --output-file is set" do
-        fields = [name]
+        fields = [firstname]
 
-        proc { adapter.print_collection(fields, data) }.must_output("")
+        _{ adapter.print_collection(fields, data) }.must_output("")
       end
 
       it "should print to file if --output-file is set" do
-        fields = [name]
+        fields = [firstname]
         expected_output = [
           "Name: John",
           "\n"
@@ -294,14 +294,14 @@ describe HammerCLI::Output::Adapter::Base do
 
         adapter.print_collection(fields, data)
         tempfile.close
-        IO.read(tempfile.path).must_equal(expected_output)
+        _(IO.read(tempfile.path)).must_equal(expected_output)
       end
 
     end
 
     context 'print_message' do
       it 'should print message with nil params' do
-        proc { adapter.print_message('MESSAGE', nil) }.must_output(/.*MESSAGE.*/, '')
+        _{ adapter.print_message('MESSAGE', nil) }.must_output(/.*MESSAGE.*/, '')
       end
     end
   end