hammer_cli 0.6.1 → 0.7.0

data/test/unit/defaults_test.rb

@@ -1,44 +1,106 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 describe HammerCLI::Defaults do
 
-  FILEPATH = File.join(File.dirname(__FILE__), '/fixtures/defaults/defaults.yml')
+  let(:filepath) { File.join(File.dirname(__FILE__), '/fixtures/defaults/defaults.yml') }
 
   before(:all) do
-    settings = YAML::load(File.open(FILEPATH))
+    settings = YAML::load(File.open(filepath))
 
-    @defaults = HammerCLI::Defaults.new(settings[:defaults], FILEPATH)
+    @defaults = HammerCLI::Defaults.new(settings[:defaults], filepath)
     @defaults.stubs(:write_to_file).returns true
   end
 
-  it "Should add a default param to defaults file, without a provider" do
-    defaults_result = @defaults.add_defaults_to_conf({"organization_id"=> 3}, nil)
-    assert_equal 3, defaults_result[:defaults][:organization_id][:value]
-  end
+  describe '#add_defaults_to_conf' do
+    it "Should add a default param to defaults file, without a provider" do
+      defaults_result = @defaults.add_defaults_to_conf({"organization_id"=> 3}, nil)
+      assert_equal 3, defaults_result[:defaults][:organization_id][:value]
+    end
+
+    it "Should update dashed default when underscored default is set" do
+      defaults_result = @defaults.add_defaults_to_conf({"location-id"=> 3}, nil)
+      assert_equal 3, defaults_result[:defaults][:'location-id'][:value]
+      assert_equal nil, defaults_result[:defaults][:location_id]
+    end
+
+    context "dashed" do
+      let(:filepath) { File.join(File.dirname(__FILE__), '/fixtures/defaults/defaults_dashed.yml') }
+      it "Should update underscored default when dashed default is set" do
+        defaults_result = @defaults.add_defaults_to_conf({"location_id"=> 3}, nil)
+        assert_equal 3, defaults_result[:defaults][:location_id][:value]
+        assert_equal nil, defaults_result[:defaults][:'location-id']
+      end
+    end
 
-  it "Should add a default param to defaults file, with provider" do
-    defaults_result = @defaults.add_defaults_to_conf({"location_id"=>nil}, :foreman)
-    assert_equal :foreman, defaults_result[:defaults][:location_id][:provider]
+    it "Should add a default param to defaults file, with provider" do
+      defaults_result = @defaults.add_defaults_to_conf({"location_id"=>nil}, :foreman)
+      assert_equal :foreman, defaults_result[:defaults][:location_id][:provider]
+    end
   end
 
-  it "Should remove default param from defaults file" do
-    defaults_result = @defaults.delete_default_from_conf(:organization_id)
-    assert_nil defaults_result[:defaults][:organization_id]
+  describe '#delete_default_from_conf' do
+    it "Should remove default param from defaults file" do
+      defaults_result = @defaults.delete_default_from_conf(:organization_id)
+      assert_nil defaults_result[:defaults][:organization_id]
+    end
+
+    it "Should remove dashed default param from defaults file" do
+      defaults_result = @defaults.delete_default_from_conf(:"organization-id")
+      assert_nil defaults_result[:defaults][:organization_id]
+    end
+
+    context "dashed" do
+      let(:filepath) { File.join(File.dirname(__FILE__), '/fixtures/defaults/defaults_dashed.yml') }
+      it "Should remove default param from defaults file" do
+        defaults_result = @defaults.delete_default_from_conf(:organization_id)
+        assert_nil defaults_result[:defaults][:'organization-id']
+      end
+
+      it "Should remove dashed default param from defaults file" do
+        defaults_result = @defaults.delete_default_from_conf(:"organization-id")
+        assert_nil defaults_result[:defaults][:'organization-id']
+      end
+    end
   end
 
-  it "should get the default param, without provider" do
-    assert_equal 2, @defaults.get_defaults("location_id")
+  describe '#defaults_set' do
+    it "should check if the defaults is set" do
+      assert_equal true, @defaults.defaults_set?("location_id")
+    end
   end
 
-  it "should get the default param, with provider" do
-    fake_provider = mock()
-    fake_provider.stubs(:provider_name).returns(:foreman)
-    fake_provider.expects(:get_defaults).with(:organization_id).returns(3)
-    @defaults.register_provider(fake_provider)
-    assert_equal 3, @defaults.get_defaults("organization_id")
+
+  describe '#get_defaults' do
+    it "should get the default param, without provider" do
+      assert_equal 2, @defaults.get_defaults("location_id")
+    end
+
+    it "should get the default param, with provider" do
+      fake_provider = mock()
+      fake_provider.stubs(:provider_name).returns(:foreman)
+      fake_provider.expects(:get_defaults).with(:organization_id).returns(3)
+      @defaults.register_provider(fake_provider)
+      assert_equal 3, @defaults.get_defaults("organization_id")
+    end
+
+    context 'dashed params' do
+      let(:filepath) { File.join(File.dirname(__FILE__), '/fixtures/defaults/defaults_dashed.yml') }
+
+      it "should get the default param, without provider" do
+        assert_equal 2, @defaults.get_defaults("location_id")
+      end
+
+      it "should get the default param, with provider" do
+        fake_provider = mock()
+        fake_provider.stubs(:provider_name).returns(:foreman)
+        fake_provider.expects(:get_defaults).with(:organization_id).returns(3)
+        @defaults.register_provider(fake_provider)
+        assert_equal 3, @defaults.get_defaults("organization_id")
+      end
+    end
   end
 
   it "should return empty defaults when the settings file is not present" do
-    defaults = HammerCLI::Defaults.new(nil, FILEPATH)
+    defaults = HammerCLI::Defaults.new(nil, filepath)
     assert_equal({}, defaults.defaults_settings)
   end
 

data/test/unit/fixtures/defaults/defaults_dashed.yml

@@ -0,0 +1,6 @@
+---
+:defaults:
+  :organization-id:
+    :provider: 'foreman'
+  :location-id:
+    :value: 2

data/test/unit/options/normalizers_test.rb

@@ -52,52 +52,64 @@ describe HammerCLI::Options::Normalizers do
       proc { formatter.format("a") }.must_raise ArgumentError
     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'})
-    end
+    describe 'key=value format' do
+      it "should parse a comma separated string" do
+        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'})
-    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'})
+      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'})
-    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'})
+      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'})
-    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'})
+      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'})
-    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'})
+      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'})
-    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'})
+      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'})
-    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'})
+      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({'a' => '1', 'b' => ['1 1', ' 2 ', ' 3 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({'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({'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({'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'})
-    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'})
+      end
+
+      it "should parse empty array" do
+        formatter.format("a=1,b=[],c=3").must_equal({'a' => '1', 'b' => [], 'c' => '3'})
+      end
 
-    it "should parse empty array" do
-      formatter.format("a=1,b=[],c=3").must_equal({'a' => '1', 'b' => [], 'c' => '3'})
+      it "should parse a comma separated string 2" do
+        proc { formatter.format("a=1,b,c=3") }.must_raise ArgumentError
+      end
     end
 
-    it "should parse a comma separated string 2" do
-      proc { formatter.format("a=1,b,c=3") }.must_raise ArgumentError
+    describe 'json format' do
+      it 'parses arrays' do
+        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]})
+      end
     end
   end
 

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

@@ -20,6 +20,10 @@ describe HammerCLI::Output::Adapter::Abstract do
     end
   end
 
+  it "allows default pagination" do
+    adapter.paginate_by_default?.must_equal true
+  end
+
   it "should filter formatters with incompatible tags" do
 
     HammerCLI::Output::Formatters::FormatterLibrary.expects(:new).with({ :type => [] })

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

@@ -5,6 +5,10 @@ describe HammerCLI::Output::Adapter::Base do
   let(:context) {{}}
   let(:adapter) { HammerCLI::Output::Adapter::Base.new(context, HammerCLI::Output::Output.formatters) }
 
+  it "allows default pagination" do
+    adapter.paginate_by_default?.must_equal true
+  end
+
   context "print_collection" do
 
     let(:id)            { Fields::Id.new(:path => [:id], :label => "Id") }

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

@@ -4,6 +4,10 @@ describe HammerCLI::Output::Adapter::CSValues do
 
   let(:adapter) { HammerCLI::Output::Adapter::CSValues.new }
 
+  it "forbids default pagination" do
+    adapter.paginate_by_default?.must_equal false
+  end
+
   context "print_collection" do
 
     let(:field_name) { Fields::Field.new(:path => [:name], :label => "Name") }

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

@@ -5,6 +5,10 @@ describe HammerCLI::Output::Adapter::Json do
   let(:context) {{}}
   let(:adapter) { HammerCLI::Output::Adapter::Json.new(context, HammerCLI::Output::Output.formatters) }
 
+  it "forbids default pagination" do
+    adapter.paginate_by_default?.must_equal false
+  end
+
   context "print_message" do
     it "prints the message" do
       params = { :a => 'Test', :b => 83 }

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

@@ -4,6 +4,10 @@ describe HammerCLI::Output::Adapter::Table do
 
   let(:adapter) { HammerCLI::Output::Adapter::Table.new }
 
+  it "allows default pagination" do
+    adapter.paginate_by_default?.must_equal true
+  end
+
   context "print_collection" do
 
     let(:field_name) { Fields::Field.new(:path => [:fullname], :label => "Name") }
@@ -15,14 +19,14 @@ describe HammerCLI::Output::Adapter::Table do
       [field_name]
     }
 
-    let(:data) { HammerCLI::Output::RecordCollection.new [{
+    let(:record) { {
       :id => 1,
       :firstname => "John",
       :lastname => "Doe",
       :fullname => "John Doe",
       :long => "SomeVeryLongString"
-    }]}
-
+    } }
+    let(:data) { HammerCLI::Output::RecordCollection.new [record] }
     let(:empty_data) { HammerCLI::Output::RecordCollection.new [] }
 
     it "should print column name " do
@@ -33,6 +37,18 @@ describe HammerCLI::Output::Adapter::Table do
       proc { adapter.print_collection(fields, data) }.must_output(/.*John Doe.*/, "")
     end
 
+    context "pagination" do
+      it "should print pagination info if data are not complete" do
+        data = HammerCLI::Output::RecordCollection.new([record], { :total => 2, :page => 1, :per_page => 1, :subtotal => 2 })
+        proc { adapter.print_collection(fields, data) }.must_output(/.*Page 1 of 2 (use --page and --per-page for navigation)*/, "")
+      end
+
+      it "should print pagination info if data are complete" do
+        data = HammerCLI::Output::RecordCollection.new([record], { :total => 1, :page => 1, :per_page => 1, :subtotal => 1 })
+        proc { adapter.print_collection(fields, data) }.must_output("--------\nNAME    \n--------\nJohn Doe\n--------\n", "")
+      end
+    end
+
     context "handle ids" do
       let(:field_id) { Fields::Id.new(:path => [:some_id], :label => "Id") }
       let(:fields) {

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

@@ -5,6 +5,10 @@ describe HammerCLI::Output::Adapter::Yaml do
   let(:context) {{}}
   let(:adapter) { HammerCLI::Output::Adapter::Yaml.new(context, HammerCLI::Output::Output.formatters) }
 
+  it "forbids default pagination" do
+    adapter.paginate_by_default?.must_equal false
+  end
+
   context "print_message" do
     it "prints the message" do
       params = { :a => 'Test', :b => 83 }

data/test/unit/output/record_collection_test.rb

@@ -30,5 +30,31 @@ describe HammerCLI::Output::RecordCollection do
     set.meta.must_equal metadata
     set.meta.total.must_equal 6
   end
+end
+
+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
+  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
+    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
+      end
+    end
+  end
 end

data/test/unit/settings_test.rb

@@ -49,7 +49,7 @@ describe HammerCLI::Settings do
     settings.dump.must_equal data
   end
 
-  it "merges settings on second load" do
+  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
@@ -59,6 +59,16 @@ describe HammerCLI::Settings do
     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
+  end
+
   it "clear wipes all settings" do
     settings.load({:a => 1, :b => 2})
     settings.clear

data/test/unit/validator_test.rb

@@ -14,8 +14,8 @@ describe "constraints" do
       @option_a = 1
       @option_b = 1
       @option_c = 1
-      @option_d = nil
-      @option_e = nil
+      @option_unset_d = nil
+      @option_unset_e = nil
     end
   end
 
@@ -23,7 +23,7 @@ describe "constraints" do
     FakeCmd.new
   }
 
-  let(:option_names) { ["a", "b", "c", "d", "e"] }
+  let(:option_names) { ["a", "b", "c", "unset-d", "unset-e"] }
   let(:options_def) {
     option_names.collect{ |n| Clamp::Option::Definition.new(["-"+n, "--option-"+n], n.upcase, "Option "+n.upcase) }
   }
@@ -107,13 +107,66 @@ describe "constraints" do
       end
 
       it "should return false when one of the options is missing" do
-        constraint = cls.new(options, [:option_a, :option_b, :option_c, :option_d])
+        constraint = cls.new(options, [:option_a, :option_b, :option_c, :option_unset_d])
         constraint.exist?.must_equal false
       end
     end
 
   end
 
+  describe HammerCLI::Validator::OneOptionConstraint do
+    let(:cls) { HammerCLI::Validator::OneOptionConstraint }
+
+    describe "exist?" do
+      it "should return true when the option exist" do
+        constraint = cls.new(options, :option_a)
+        constraint.exist?.must_equal true
+      end
+
+      it "should return false when the option is missing" do
+        constraint = cls.new(options, :option_unset_d)
+        constraint.exist?.must_equal false
+      end
+    end
+
+    describe "#rejected" do
+      it "returns nil when the option is missing" do
+        constraint = cls.new(options, :option_unset_d)
+        constraint.rejected.must_equal nil
+      end
+
+      it "raises exception when the option is present" do
+        constraint = cls.new(options, :option_a)
+        e = proc{ constraint.rejected }.must_raise HammerCLI::Validator::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_a)
+        constraint.required.must_equal nil
+      end
+
+      it "raises exception when the option is present" do
+        constraint = cls.new(options, :option_unset_d)
+        e = proc{ constraint.required }.must_raise HammerCLI::Validator::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_a)
+        constraint.value.must_equal 1
+      end
+      it "returns nil when the option is missing" do
+        constraint = cls.new(options, :option_unset_d)
+        constraint.value.must_equal nil
+      end
+    end
+  end
+
   describe HammerCLI::Validator::AnyConstraint do
 
     let(:cls) { HammerCLI::Validator::AnyConstraint }
@@ -126,17 +179,69 @@ describe "constraints" do
       end
 
       it "should return true when one of the options exist" do
-        constraint = cls.new(options, [:option_a, :option_d, :option_e])
+        constraint = cls.new(options, [:option_a, :option_unset_d, :option_unset_e])
         constraint.exist?.must_equal true
       end
 
       it "should return false when all the options are missing" do
-        constraint = cls.new(options, [:option_d, :option_e])
+        constraint = cls.new(options, [:option_unset_d, :option_unset_e])
         constraint.exist?.must_equal false
       end
     end
 
   end
 
+  describe HammerCLI::Validator::OneOfConstraint do
 
+    let(:cls) { HammerCLI::Validator::OneOfConstraint }
+
+    it "raises exception when nothing to check is set" do
+      e = proc{ cls.new(options, []) }.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_a, :option_unset_d, :option_unset_e])
+        constraint.exist?.must_equal true
+      end
+
+      it "should return false when the option isn't present" do
+        constraint = cls.new(options, [:option_unset_d, :option_unset_e])
+        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_a, :option_b])
+        constraint.exist?.must_equal false
+      end
+    end
+
+    describe "#rejected" do
+      it "raises not implemented exception" do
+        constraint = cls.new(options, [:option_a, :option_unset_d])
+        e = proc{ 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_a, :option_unset_d, :option_unset_e])
+        constraint.required.must_equal nil
+      end
+
+      it "raises exception when none of the options is present" do
+        constraint = cls.new(options, [:option_unset_d, :option_unset_e])
+        e = proc{ constraint.required }.must_raise HammerCLI::Validator::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_a, :option_b])
+        e = proc{ constraint.required }.must_raise HammerCLI::Validator::ValidationError
+        e.message.must_equal 'Only one of options --option-a, --option-b can be set'
+      end
+    end
+  end
 end