hammer_cli 0.15.1 → 0.16.0

data/test/unit/options/option_collector_test.rb

@@ -2,17 +2,17 @@ require_relative '../test_helper'
 
 describe HammerCLI::Options::OptionCollector do
   before do
-    recognised_options = [mock, mock]
-    source1_result = {:option1 => 1, :option2 => nil, :option4 => HammerCLI::NilValue}
-    source2_result = source1_result.merge({:option3 => 3})
+    @recognised_options = [mock('Option1'), mock('Option2')]
+    @source1_result = {:option1 => 1, :option2 => nil, :option4 => HammerCLI::NilValue}
+    @source2_result = @source1_result.merge({:option3 => 3})
 
-    source1 = mock
-    source1.expects(:get_options).with(recognised_options, {}).returns(source1_result)
+    @source1 = mock('Source1')
+    @source1.expects(:process).with(@recognised_options, {}).returns(@source1_result)
 
-    source2 = mock
-    source2.expects(:get_options).with(recognised_options, source1_result).returns(source2_result)
+    @source2 = mock('Source2')
+    @source2.expects(:process).with(@recognised_options, @source1_result).returns(@source2_result)
 
-    @collector = HammerCLI::Options::OptionCollector.new(recognised_options, [source1, source2])
+    @collector = HammerCLI::Options::OptionCollector.new(@recognised_options, [@source1, @source2])
   end
 
   describe '#options' do
@@ -26,10 +26,19 @@ describe HammerCLI::Options::OptionCollector do
       assert_equal({:option1 => 1, :option2 => nil, :option3 => 3, :option4 => nil}, @collector.all_options)
     end
   end
-  
+
   describe '#all_options_raw' do
     it 'returns all options with NIL values untranslated' do
       assert_equal({:option1 => 1, :option2 => nil, :option3 => 3, :option4 => HammerCLI::NilValue}, @collector.all_options_raw)
     end
+
+    it 'can process validations' do
+      validator = mock('Validator')
+      validator.expects(:process).with(@recognised_options, @source1_result).returns(@source1_result)
+
+      collector = HammerCLI::Options::OptionCollector.new(@recognised_options, [@source1, validator, @source2])
+
+      assert_equal({:option1 => 1, :option2 => nil, :option3 => 3, :option4 => HammerCLI::NilValue}, collector.all_options_raw)
+    end
   end
 end

data/test/unit/options/processor_list_test.rb

@@ -0,0 +1,70 @@
+require_relative '../test_helper'
+
+describe HammerCLI::Options::ProcessorList do
+  let(:processor1) { stub('Processor1', :name => 'P1') }
+  let(:processor2) { stub('Processor2', :name => 'P2') }
+  let(:processor3) { stub('Processor3', :name => 'P3') }
+  let(:new_processor) { stub('NewProcessor', :name => 'NewP') }
+
+  let(:pl) { HammerCLI::Options::ProcessorList.new([processor1, processor2, processor3], name: 'TheProcessor') }
+
+  describe '#name' do
+    it 'returns the given name' do
+      assert_equal 'TheProcessor', pl.name
+    end
+  end
+
+  describe '#insert_relative' do
+    it 'appends' do
+      pl.insert_relative(:append, nil, new_processor)
+      assert_equal pl.map(&:name), ['P1', 'P2', 'P3', 'NewP']
+    end
+
+    it 'prepends' do
+      pl.insert_relative(:prepend, nil, new_processor)
+      assert_equal pl.map(&:name), ['NewP', 'P1', 'P2', 'P3']
+    end
+
+    it 'inserts after' do
+      pl.insert_relative(:after, 'P2', new_processor)
+      assert_equal pl.map(&:name), ['P1', 'P2', 'NewP', 'P3']
+    end
+
+    it 'inserts before' do
+      pl.insert_relative(:before, 'P2', new_processor)
+      assert_equal pl.map(&:name), ['P1', 'NewP', 'P2', 'P3']
+    end
+
+    it 'raises an exception when the processor was not found' do
+      ex = assert_raises ArgumentError do
+        pl.insert_relative(:before, 'Unknown', new_processor)
+      end
+      assert_equal "Option processor 'Unknown' not found", ex.message
+    end
+  end
+
+  describe '#find_by_name' do
+    it 'finds a processor' do
+      assert_equal processor2, pl.find_by_name('P2')
+    end
+
+    it 'raises an exception when the processor was not found' do
+      ex = assert_raises ArgumentError do
+        pl.find_by_name('Unknown')
+      end
+      assert_equal "Option processor 'Unknown' not found", ex.message
+    end
+  end
+
+  describe '#process' do
+    it 'calls all processors' do
+      defined_options = []
+      pl[0].expects(:process).with(defined_options, { :initial => 0 }).returns({ :initial => 0, :p1 => 1 })
+      pl[1].expects(:process).with(defined_options, { :initial => 0, :p1 => 1 }).returns({ :p2 => 2 })
+      pl[2].expects(:process).with(defined_options, { :p2 => 2 }).returns({ :p3 => 3 })
+
+      result = pl.process(defined_options, { :initial => 0 })
+      assert_equal({ :p3 => 3 }, result)
+    end
+  end
+end

data/test/unit/{validator_test.rb → options/validators/dsl_test.rb}

@@ -1,61 +1,50 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
+require 'hammer_cli/options/validators/dsl_block_validator'
+require_relative '../../test_helper'
 
 describe "constraints" do
-
-  class FakeCmd < Clamp::Command
-    def initialize
-      context = {
-        :defaults => HammerCLI::Defaults.new({ :default => { :value => 2 }})
-      }
-      super("", context)
-      @option_a = 1
-      @option_b = 1
-      @option_c = 1
-      @option_unset_d = nil
-      @option_unset_e = nil
-    end
-  end
-
-  let(:cmd) {
-    FakeCmd.new
-  }
+  let(:option_values) {{
+    :option_a => 1,
+    :option_b => 1,
+    'option_c' => 1,
+    :option_unset_d => nil,
+    :option_unset_e => nil
+  }}
 
   let(:option_names) { ["a", "b", "c", "unset-d", "unset-e", "default"] }
-  let(:options_def) {
+  let(:options) {
     option_names.collect{ |n| Clamp::Option::Definition.new(["-"+n, "--option-"+n], n.upcase, "Option "+n.upcase) }
   }
-  let(:options) { options_def.collect{|d| d.of(cmd) } }
 
-  describe HammerCLI::Validator::BaseConstraint do
+  describe HammerCLI::Options::Validators::DSL::BaseConstraint do
 
-    let(:cls) { HammerCLI::Validator::BaseConstraint }
+    let(:cls) { HammerCLI::Options::Validators::DSL::BaseConstraint }
 
     describe "exist?" do
       it "throws not implemented error" do
-        constraint = cls.new(options, [:option_a, :option_b, :option_c])
+        constraint = cls.new(options, option_values, [:option_a, :option_b, :option_c])
         proc{ constraint.exist? }.must_raise NotImplementedError
       end
     end
 
     describe "rejected" do
       it "should raise exception when exist? returns true" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(true)
-        proc{ constraint.rejected }.must_raise HammerCLI::Validator::ValidationError
+        proc{ constraint.rejected }.must_raise HammerCLI::Options::Validators::ValidationError
       end
 
       it "should raise exception with a message" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(true)
         begin
           constraint.rejected :msg => "CUSTOM MESSAGE"
-        rescue HammerCLI::Validator::ValidationError => e
+        rescue HammerCLI::Options::Validators::ValidationError => e
           e.message.must_equal "CUSTOM MESSAGE"
         end
       end
 
       it "should return nil when exist? returns true" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(false)
         constraint.rejected.must_equal nil
       end
@@ -63,23 +52,23 @@ describe "constraints" do
 
     describe "required" do
       it "should raise exception when exist? returns true" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(false)
-        proc{ constraint.required }.must_raise HammerCLI::Validator::ValidationError
+        proc{ constraint.required }.must_raise HammerCLI::Options::Validators::ValidationError
       end
 
       it "should raise exception with a message" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(false)
         begin
           constraint.rejected :msg => "CUSTOM MESSAGE"
-        rescue HammerCLI::Validator::ValidationError => e
+        rescue HammerCLI::Options::Validators::ValidationError => e
           e.message.must_equal "CUSTOM MESSAGE"
         end
       end
 
       it "should return nil when exist? returns true" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.stubs(:exist?).returns(true)
         constraint.required.must_equal nil
       end
@@ -87,162 +76,137 @@ describe "constraints" do
 
   end
 
-  describe HammerCLI::Validator::AllConstraint do
+  describe HammerCLI::Options::Validators::DSL::AllConstraint do
 
-    let(:cls) { HammerCLI::Validator::AllConstraint }
+    let(:cls) { HammerCLI::Options::Validators::DSL::AllConstraint }
 
     describe "exist?" do
 
       it "should return true when no options are passed" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.exist?.must_equal true
       end
 
       it "should return true when all the options exist" do
-        constraint = cls.new(options, [:option_a, :option_b, :option_c])
-        constraint.exist?.must_equal true
-      end
-
-      it "should return true when all the options exist or are set in the defaults" do
-        constraint = cls.new(options, [:option_a, :option_b, :option_c, :option_default])
+        constraint = cls.new(options, option_values, [:option_a, :option_b, :option_c])
         constraint.exist?.must_equal true
       end
 
       it "should return false when one of the options is missing" do
-        constraint = cls.new(options, [:option_a, :option_b, :option_c, :option_unset_d])
+        constraint = cls.new(options, option_values, [: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 HammerCLI::Options::Validators::DSL::OneOptionConstraint do
+    let(:cls) { HammerCLI::Options::Validators::DSL::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 true when the option is set in the defaults" do
-        constraint = cls.new(options, :option_default)
+        constraint = cls.new(options, option_values, :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 = cls.new(options, option_values, :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 = cls.new(options, option_values, :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
+        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."
       end
     end
 
     describe "#required" do
       it "returns nil when the option exist" do
-        constraint = cls.new(options, :option_a)
+        constraint = cls.new(options, option_values, :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
+        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.'
       end
     end
 
     describe "#value" do
       it "returns value of the option" do
-        constraint = cls.new(options, :option_a)
+        constraint = cls.new(options, option_values, :option_a)
         constraint.value.must_equal 1
       end
 
-      it "returns value of the option defined in the defaults" do
-        constraint = cls.new(options, :option_default)
-        constraint.value.must_equal 2
-      end
-
       it "returns nil when the option is missing" do
-        constraint = cls.new(options, :option_unset_d)
+        constraint = cls.new(options, option_values, :option_unset_d)
         constraint.value.must_equal nil
       end
     end
   end
 
-  describe HammerCLI::Validator::AnyConstraint do
+  describe HammerCLI::Options::Validators::DSL::AnyConstraint do
 
-    let(:cls) { HammerCLI::Validator::AnyConstraint }
+    let(:cls) { HammerCLI::Options::Validators::DSL::AnyConstraint }
 
     describe "exist?" do
 
       it "should return true when no options are passed" do
-        constraint = cls.new(options, [])
+        constraint = cls.new(options, option_values, [])
         constraint.exist?.must_equal true
       end
 
       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 true when one of the options exist and is set in the defaults" do
-        constraint = cls.new(options, [:option_default, :option_unset_d, :option_unset_e])
+        constraint = cls.new(options, option_values, [: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_unset_d, :option_unset_e])
+        constraint = cls.new(options, option_values, [:option_unset_d, :option_unset_e])
         constraint.exist?.must_equal false
       end
     end
 
   end
 
-  describe HammerCLI::Validator::OneOfConstraint do
+  describe HammerCLI::Options::Validators::DSL::OneOfConstraint do
 
-    let(:cls) { HammerCLI::Validator::OneOfConstraint }
+    let(:cls) { HammerCLI::Options::Validators::DSL::OneOfConstraint }
 
     it "raises exception when nothing to check is set" do
-      e = proc{ cls.new(options, []) }.must_raise RuntimeError
+      e = proc{ 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_a, :option_unset_d, :option_unset_e])
-        constraint.exist?.must_equal true
-      end
-
-      it "should return true when one of the options exist and is set in the defaults" do
-        constraint = cls.new(options, [:option_default, :option_unset_d, :option_unset_e])
+        constraint = cls.new(options, option_values, [: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 = cls.new(options, option_values, [: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 = cls.new(options, option_values, [: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])
+        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'
       end
@@ -250,19 +214,19 @@ describe "constraints" do
 
     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 = cls.new(options, option_values, [: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
+        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.'
       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
+        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.'
       end
     end

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

@@ -59,6 +59,9 @@ describe HammerCLI::Output::Adapter::Abstract do
       proc { 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.*/, '')
+    end
   end
 
   it "should raise not implemented on print_collection" do