hammer_cli 3.7.0 → 3.9.0

data/test/unit/output/formatters_test.rb

@@ -4,30 +4,30 @@ describe HammerCLI::Output::Formatters::FormatterLibrary do
   it "accepts formatter" do
     lib = HammerCLI::Output::Formatters::FormatterLibrary.new(
       :Id => HammerCLI::Output::Formatters::FieldFormatter.new)
-    lib.formatter_for_type(Fields::Id).must_be_instance_of HammerCLI::Output::Formatters::FormatterContainer
+    _(lib.formatter_for_type(Fields::Id)).must_be_instance_of HammerCLI::Output::Formatters::FormatterContainer
   end
 
   it "can add formatter to instance" do
     lib = HammerCLI::Output::Formatters::FormatterLibrary.new
     lib.register_formatter :Id, HammerCLI::Output::Formatters::FieldFormatter.new
-    lib.formatter_for_type(Fields::Id).must_be_instance_of HammerCLI::Output::Formatters::FormatterContainer
+    _(lib.formatter_for_type(Fields::Id)).must_be_instance_of HammerCLI::Output::Formatters::FormatterContainer
   end
 end
 
 describe HammerCLI::Output::Formatters::FieldFormatter do
   let(:formatter) { HammerCLI::Output::Formatters::FieldFormatter.new }
   it "has format method" do
-    formatter.respond_to?(:format).must_equal true
+    _(formatter.respond_to?(:format)).must_equal true
   end
 
   it "has features" do
-    formatter.required_features.must_be_kind_of Array
+    _(formatter.required_features).must_be_kind_of Array
   end
 
   it "should know if it has matching features" do
     formatter.stubs(:required_features).returns([:feature])
-    formatter.match?([:feature]).must_equal true
-    formatter.match?([:nofeature]).must_equal false
+    _(formatter.match?([:feature])).must_equal true
+    _(formatter.match?([:nofeature])).must_equal false
   end
 end
 
@@ -41,37 +41,37 @@ describe HammerCLI::Output::Formatters::FormatterContainer do
 
   it "accepts formatter" do
     container = HammerCLI::Output::Formatters::FormatterContainer.new(TestFormatter.new)
-    container.format('').must_equal '.'
+    _(container.format('')).must_equal '.'
   end
 
   it "has format method" do
     container = HammerCLI::Output::Formatters::FormatterContainer.new
-    container.respond_to?(:format).must_equal true
+    _(container.respond_to?(:format)).must_equal true
   end
 
   it "can add formatter to instance" do
     container = HammerCLI::Output::Formatters::FormatterContainer.new(TestFormatter.new)
     container.add_formatter TestFormatter.new
-    container.format('').must_equal '..'
+    _(container.format('')).must_equal '..'
   end
 end
 
 describe HammerCLI::Output::Formatters::ColorFormatter do
   it "colorizes the value" do
     formatter = HammerCLI::Output::Formatters::ColorFormatter.new(:red)
-    formatter.format('red').must_equal "\e[31mred\e[0m"
+    _(formatter.format('red')).must_equal "\e[31mred\e[0m"
   end
 end
 
 describe HammerCLI::Output::Formatters::DateFormatter do
   it "formats the date" do
     formatter = HammerCLI::Output::Formatters::DateFormatter.new
-    formatter.format('2000-01-01 21:01:01').must_equal "2000/01/01 21:01:01"
+    _(formatter.format('2000-01-01 21:01:01')).must_equal "2000/01/01 21:01:01"
   end
 
   it "returns empty string on wrong value" do
     formatter = HammerCLI::Output::Formatters::DateFormatter.new
-    formatter.format('wrong value').must_equal ""
+    _(formatter.format('wrong value')).must_equal ""
   end
 end
 
@@ -79,23 +79,23 @@ describe HammerCLI::Output::Formatters::ListFormatter do
   let(:formatter) { HammerCLI::Output::Formatters::ListFormatter.new }
 
   it "serializes the value" do
-    formatter.format([1, 2]).must_equal '1, 2'
+    _(formatter.format([1, 2])).must_equal '1, 2'
   end
 
   it "returns empty string when the input is nil" do
-    formatter.format(nil).must_equal ''
+    _(formatter.format(nil)).must_equal ''
   end
 
   it "returns string value when the input is not a list" do
-    formatter.format('some string').must_equal 'some string'
+    _(formatter.format('some string')).must_equal 'some string'
   end
 
   it 'can put the string on a new line' do
-    formatter.format([1, 2], :on_new_line => true).must_equal "\n  1, 2"
+    _(formatter.format([1, 2], :on_new_line => true)).must_equal "\n  1, 2"
   end
 
   it 'allows to change the separator' do
-    formatter.format([1, 2, 3], :separator => '#').must_equal "1#2#3"
+    _(formatter.format([1, 2, 3], :separator => '#')).must_equal "1#2#3"
   end
 
   it 'can format list vertically' do
@@ -105,7 +105,7 @@ describe HammerCLI::Output::Formatters::ListFormatter do
       '  value 2',
     ].join("\n")
 
-    formatter.format(['value 1', 'value 2'], :separator => "\n", :on_new_line => true).must_equal expected_output
+    _(formatter.format(['value 1', 'value 2'], :separator => "\n", :on_new_line => true)).must_equal expected_output
   end
 end
 
@@ -121,17 +121,17 @@ describe HammerCLI::Output::Formatters::KeyValueFormatter do
 
   it "serializes the value" do
     formatter = HammerCLI::Output::Formatters::KeyValueFormatter.new
-    formatter.format(params).must_equal 'Name => Value'
+    _(formatter.format(params)).must_equal 'Name => Value'
   end
 
   it "returns empty string when the input is nil" do
     formatter = HammerCLI::Output::Formatters::KeyValueFormatter.new
-    formatter.format(nil).must_equal ''
+    _(formatter.format(nil)).must_equal ''
   end
 
   it "returns empty string value when the input is not a hash" do
     formatter = HammerCLI::Output::Formatters::KeyValueFormatter.new
-    formatter.format('some string').must_equal ''
+    _(formatter.format('some string')).must_equal ''
   end
 end
 
@@ -141,17 +141,17 @@ describe HammerCLI::Output::Formatters::LongTextFormatter do
 
   it "prepends new line" do
     formatter = HammerCLI::Output::Formatters::LongTextFormatter.new
-    formatter.format("Some\nmultiline\ntext").must_equal "\n  Some\n  multiline\n  text"
+    _(formatter.format("Some\nmultiline\ntext")).must_equal "\n  Some\n  multiline\n  text"
   end
 
   it "accepts nil" do
     formatter = HammerCLI::Output::Formatters::LongTextFormatter.new
-    formatter.format(nil).must_equal "\n  "
+    _(formatter.format(nil)).must_equal "\n  "
   end
 
   it "enables to switch indentation off" do
     formatter = HammerCLI::Output::Formatters::LongTextFormatter.new(:indent => false)
-    formatter.format("Some\nmultiline\ntext").must_equal "\nSome\nmultiline\ntext"
+    _(formatter.format("Some\nmultiline\ntext")).must_equal "\nSome\nmultiline\ntext"
   end
 
 end
@@ -160,11 +160,11 @@ describe HammerCLI::Output::Formatters::InlineTextFormatter do
   let(:formatter) { HammerCLI::Output::Formatters::InlineTextFormatter.new }
 
   it 'prints multiline text to one line' do
-    formatter.format("Some\nmultiline\ntext").must_equal('Some multiline text')
+    _(formatter.format("Some\nmultiline\ntext")).must_equal('Some multiline text')
   end
 
   it 'accepts nil' do
-    formatter.format(nil).must_equal('')
+    _(formatter.format(nil)).must_equal('')
   end
 end
 
@@ -175,26 +175,26 @@ describe HammerCLI::Output::Formatters::MultilineTextFormatter do
   let(:long_multiline_text) { 'Lorem ipsum dolor' * 5 }
 
   it 'prints multiline text' do
-    formatter.format(multiline_text).must_equal(
+    _(formatter.format(multiline_text)).must_equal(
       "#{indentation}Some#{indentation}multiline#{indentation}text"
     )
   end
 
   it 'accepts nil' do
-    formatter.format(nil).must_equal(indentation)
+    _(formatter.format(nil)).must_equal(indentation)
   end
 
   it 'accepts field width param' do
-    formatter.format(long_multiline_text, width: 80)
+    _(formatter.format(long_multiline_text, width: 80))
              .must_equal(indentation + long_multiline_text[0..-6] +
                          indentation + long_multiline_text[-5..-1])
   end
 
   it 'deals with strange params' do
-    formatter.format(long_multiline_text, width: -1)
+    _(formatter.format(long_multiline_text, width: -1))
              .must_equal(indentation + long_multiline_text[0..-26] +
                          indentation + long_multiline_text[-25..-1])
-    formatter.format(long_multiline_text, width: 999)
+    _(formatter.format(long_multiline_text, width: 999))
              .must_equal(indentation + long_multiline_text)
   end
 end
@@ -204,16 +204,16 @@ describe HammerCLI::Output::Formatters::BooleanFormatter do
   let(:formatter) { HammerCLI::Output::Formatters::BooleanFormatter.new }
 
   it "says yes for true like objects" do
-    formatter.format(true).must_equal "yes"
-    formatter.format("yes").must_equal "yes"
-    formatter.format("no").must_equal "yes"
-    formatter.format(1).must_equal "yes"
+    _(formatter.format(true)).must_equal "yes"
+    _(formatter.format("yes")).must_equal "yes"
+    _(formatter.format("no")).must_equal "yes"
+    _(formatter.format(1)).must_equal "yes"
   end
 
   it "says no for false, nil, empty string and 0" do
-    formatter.format(nil).must_equal "no"
-    formatter.format(false).must_equal "no"
-    formatter.format("").must_equal "no"
-    formatter.format(0).must_equal "no"
+    _(formatter.format(nil)).must_equal "no"
+    _(formatter.format(false)).must_equal "no"
+    _(formatter.format("")).must_equal "no"
+    _(formatter.format(0)).must_equal "no"
   end
 end

data/test/unit/output/output_test.rb

@@ -79,27 +79,27 @@ describe HammerCLI::Output::Output do
   context "adapters" do
     it "should register adapter" do
       out_class.register_adapter(:test, HammerCLI::Output::Adapter::Silent)
-      out_class.adapters[:test].must_equal(HammerCLI::Output::Adapter::Silent)
+      _(out_class.adapters[:test]).must_equal(HammerCLI::Output::Adapter::Silent)
     end
 
     it "should return required default adapter" do
       out = out_class.new({}, {:default_adapter => :silent})
-      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Silent
+      _(out.adapter).must_be_instance_of HammerCLI::Output::Adapter::Silent
     end
 
     it "should use adapter form context" do
       out = out_class.new({:adapter => :silent})
-      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Silent
+      _(out.adapter).must_be_instance_of HammerCLI::Output::Adapter::Silent
     end
 
     it "should prioritize adapter from the context" do
       out = out_class.new({:adapter => :table}, {:default_adapter => :silent})
-      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Table
+      _(out.adapter).must_be_instance_of HammerCLI::Output::Adapter::Table
     end
 
     it "should use base adapter if the requested default was not found" do
       out = out_class.new({}, {:default_adapter => :unknown})
-      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Base
+      _(out.adapter).must_be_instance_of HammerCLI::Output::Adapter::Base
     end
   end
 
@@ -107,8 +107,8 @@ describe HammerCLI::Output::Output do
     it "should register formatter" do
       formatter = HammerCLI::Output::Formatters::FieldFormatter.new
       out_class.register_formatter(formatter, :type1, :type2)
-      out_class.formatters[:type1].must_equal([formatter])
-      out_class.formatters[:type2].must_equal([formatter])
+      _(out_class.formatters[:type1]).must_equal([formatter])
+      _(out_class.formatters[:type2]).must_equal([formatter])
     end
   end
 
@@ -128,7 +128,7 @@ describe HammerCLI::Output::Output do
       )
     end
     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(:surname)    { Fields::Field.new(:path => [:surname], :label => 'Surname') }
     let(:definition) { HammerCLI::Output::Definition.new }
     let(:expected_record_output) do
@@ -174,14 +174,14 @@ describe HammerCLI::Output::Output do
       end
 
       it 'should not print record data' do
-        definition.append([id, name, surname])
+        definition.append([id, firstname, surname])
         assert_output('', nil) do
           output.print_record(definition, data.first)
         end
       end
 
       it 'should not print collection data' do
-        definition.append([id, name, surname])
+        definition.append([id, firstname, surname])
         assert_output('', nil) do
           output.print_record(definition, data)
         end
@@ -223,14 +223,14 @@ describe HammerCLI::Output::Output do
       end
 
       it 'should print record data' do
-        definition.append([id, name, surname])
+        definition.append([id, firstname, surname])
         assert_output(expected_record_output, nil) do
           output.print_record(definition, data.first)
         end
       end
 
       it 'should print collection data' do
-        definition.append([id, name, surname])
+        definition.append([id, firstname, surname])
         assert_output(expected_record_output, nil) do
           output.print_record(definition, data)
         end
@@ -271,14 +271,14 @@ describe HammerCLI::Output::Output do
       end
 
       it 'should print record data' do
-        definition.append([id, name, surname])
+        definition.append([id, firstname, surname])
         assert_output(expected_record_output, nil) do
           output.print_record(definition, data.first)
         end
       end
 
       it 'should print collection data' do
-        definition.append([id, name, surname])
+        definition.append([id, firstname, surname])
         assert_output(expected_record_output, nil) do
           output.print_record(definition, data)
         end

data/test/unit/output/record_collection_test.rb

@@ -7,28 +7,28 @@ describe HammerCLI::Output::RecordCollection do
   let(:set) { HammerCLI::Output::RecordCollection.new(data, meta) }
 
   it "should keep records and its meta data" do
-    set.must_equal data
-    set.meta.total.must_equal 6
-    set.meta.subtotal.must_equal 5
-    set.meta.total.must_equal 6
-    set.meta.page.must_equal 2
-    set.meta.per_page.must_equal 3
-    set.meta.search.must_equal 'name~=xx'
-    set.meta.sort_by.must_equal 'name'
-    set.meta.sort_order.must_equal 'ASC'
+    _(set).must_equal data
+    _(set.meta.total).must_equal 6
+    _(set.meta.subtotal).must_equal 5
+    _(set.meta.total).must_equal 6
+    _(set.meta.page).must_equal 2
+    _(set.meta.per_page).must_equal 3
+    _(set.meta.search).must_equal 'name~=xx'
+    _(set.meta.sort_by).must_equal 'name'
+    _(set.meta.sort_order).must_equal 'ASC'
   end
 
   it "should wrap the data into list" do
     record = { :key => :value, :key2 => :value }
     rs = HammerCLI::Output::RecordCollection.new(record)
-    rs.must_be_kind_of Array
+    _(rs).must_be_kind_of Array
   end
 
   it "sould accept MetaData as option" do
     metadata = HammerCLI::Output::MetaData.new(meta)
     set = HammerCLI::Output::RecordCollection.new(data, :meta => metadata)
-    set.meta.must_equal metadata
-    set.meta.total.must_equal 6
+    _(set.meta).must_equal metadata
+    _(set.meta.total).must_equal 6
   end
 end
 
@@ -37,23 +37,23 @@ describe HammerCLI::Output::MetaData do
   let(:meta) { HammerCLI::Output::MetaData.new(:total => "6", :page => "2", :per_page => "3", :subtotal => "5") }
 
   it "converts numeric metadata to numbers" do
-    meta.total.must_equal 6
-    meta.page.must_equal 2
-    meta.per_page.must_equal 3
-    meta.subtotal.must_equal 5
+    _(meta.total).must_equal 6
+    _(meta.page).must_equal 2
+    _(meta.per_page).must_equal 3
+    _(meta.subtotal).must_equal 5
   end
 
   describe "pagination_set?" do
     let(:pagination_data) { { :total => 6, :page => 2, :per_page => 3, :subtotal => 5 } }
 
     it "can tell if pagination data are set" do
-      meta.pagination_set?.must_equal true
+      _(meta.pagination_set?).must_equal true
     end
 
     it "can tell if pagination data are not set" do
       pagination_data.keys.each do |key|
         meta = HammerCLI::Output::MetaData.new(pagination_data.clone.reject { |k| k == key })
-        meta.pagination_set?.must_equal false
+        _(meta.pagination_set?).must_equal false
       end
     end
   end

data/test/unit/settings_test.rb

@@ -10,83 +10,83 @@ describe HammerCLI::Settings do
   let(:settings) { HammerCLI::Settings }
 
   it "returns nil when nothing is loaded" do
-    settings.get(:a).must_be_nil
-    settings.get(:a, :b).must_be_nil
+    _(settings.get(:a)).must_be_nil
+    _(settings.get(:a, :b)).must_be_nil
   end
 
   it "returns nil on unknown key" do
     settings.load({:a => 1})
-    settings.get(:b).must_be_nil
+    _(settings.get(:b)).must_be_nil
   end
 
   it "returns correct value" do
     settings.load({:a => 1})
-    settings.get(:a).must_equal 1
+    _(settings.get(:a)).must_equal 1
   end
 
   it "takes both strings and symbols" do
     settings.load({:a => 1, 'b' => 2})
-    settings.get('a').must_equal 1
-    settings.get(:b).must_equal 2
+    _(settings.get('a')).must_equal 1
+    _(settings.get(:b)).must_equal 2
   end
 
   it "finds nested settings" do
     settings.load({:a => {:b => 1}})
-    settings.get(:a, :b).must_equal 1
-    settings.get(:a, 'b').must_equal 1
-    settings.get('a', :b).must_equal 1
+    _(settings.get(:a, :b)).must_equal 1
+    _(settings.get(:a, 'b')).must_equal 1
+    _(settings.get('a', :b)).must_equal 1
   end
 
   it "loads all settings" do
     settings.load({:a => 1, :b => 2})
-    settings.get(:a).must_equal 1
-    settings.get(:b).must_equal 2
+    _(settings.get(:a)).must_equal 1
+    _(settings.get(:b)).must_equal 2
   end
 
   it "dumps all settings" do
     settings.empty
     data = {:a => 1, :b => 2}
     settings.load(data)
-    settings.dump.must_equal data
+    _(settings.dump).must_equal data
   end
 
   it "merges hash settings on second load" do
     settings.load({:a => 1, :b => 2, :d => {:e => 4, :f => 5}})
     settings.load({:b => 'B', :c => 'C', :d => {:e => 'E'}})
-    settings.get(:a).must_equal 1
-    settings.get(:b).must_equal 'B'
-    settings.get(:c).must_equal 'C'
-    settings.get(:d, :e).must_equal 'E'
-    settings.get(:d, :f).must_equal 5
+    _(settings.get(:a)).must_equal 1
+    _(settings.get(:b)).must_equal 'B'
+    _(settings.get(:c)).must_equal 'C'
+    _(settings.get(:d, :e)).must_equal 'E'
+    _(settings.get(:d, :f)).must_equal 5
   end
 
   it "merges array settings on second load" do
     settings.load({:x => [:a, :b]})
     settings.load({:x => [:c, :d]})
-    settings.get(:x)[0].must_equal :a
-    settings.get(:x)[1].must_equal :b
-    settings.get(:x)[2].must_equal :c
-    settings.get(:x)[3].must_equal :d
-    settings.get(:x).size.must_equal 4
+    _(settings.get(:x)[0]).must_equal :a
+    _(settings.get(:x)[1]).must_equal :b
+    _(settings.get(:x)[2]).must_equal :c
+    _(settings.get(:x)[3]).must_equal :d
+    _(settings.get(:x).size).must_equal 4
   end
 
   it "clear wipes all settings but default values" do
     settings.load({:a => 1, :b => 2})
     settings.clear
-    settings.get(:a).must_be_nil
-    settings.get(:b).must_be_nil
-    settings.default_settings.each { |key, val| settings.get(key).must_equal val }
+    _(settings.get(:a)).must_be_nil
+    _(settings.get(:b)).must_be_nil
+    settings.default_settings.each { |key, val| _(settings.get(key)).must_equal val }
   end
 
   it "empty wipes all settings including default values" do
     settings.load({:a => 1, :b => 2})
     settings.empty
-    settings.dump.must_equal({})
+    _(settings.dump).must_equal({})
   end
 
   it "initializes settings with default settings" do
     settings.instance_variable_set(:@settings_hash, nil)
-    settings.dump.must_equal settings.default_settings
+    _(settings.dump).must_equal settings.default_settings
   end
 
   context "load from paths" do
@@ -115,19 +115,19 @@ describe HammerCLI::Settings do
 
     it "loads settings from file" do
       [config1.path, config2.path].each { |config| settings.load_from_file config }
-      settings.get(:host).must_equal 'https://localhost.localdomain/'
-      settings.get(:username).must_equal 'admin'
+      _(settings.get(:host)).must_equal 'https://localhost.localdomain/'
+      _(settings.get(:username)).must_equal 'admin'
     end
 
     it "clears path history on clear invokation" do
       settings.load_from_paths [config2.path]
       settings.clear
-      settings.path_history.must_equal []
+      _(settings.path_history).must_equal []
     end
 
     it "store config path history" do
       [config1.path, config2.path].each { |config| settings.load_from_file config }
-      settings.path_history.must_equal [config1.path, config2.path]
+      _(settings.path_history).must_equal [config1.path, config2.path]
     end
 
     it "loads settings from dir" do
@@ -146,10 +146,10 @@ describe HammerCLI::Settings do
         settings.load_from_paths [dir]
         settings.load_from_file config1.path
 
-        settings.get(:host).must_equal 'https://localhost/'
-        settings.get(:username).must_equal 'admin'
-        settings.get(:param1).must_equal 'value1'
-        settings.get(:module, :param2).must_equal 'value2'
+        _(settings.get(:host)).must_equal 'https://localhost/'
+        _(settings.get(:username)).must_equal 'admin'
+        _(settings.get(:param1)).must_equal 'value1'
+        _(settings.get(:module, :param2)).must_equal 'value2'
 
       ensure
         FileUtils.remove_entry dir