hammer_cli 0.1.0 → 0.1.1

data/test/unit/abstract_test.rb

@@ -267,6 +267,68 @@ describe HammerCLI::AbstractCommand do
 
   end
 
+  describe "option builder" do
+
+    it "uses builder container as default" do
+      HammerCLI::AbstractCommand.option_builder.class.must_equal HammerCLI::OptionBuilderContainer
+    end
+
+    it "Default builder container is empty" do
+      HammerCLI::AbstractCommand.option_builder.builders.empty?.must_equal true
+    end
+
+    it "can be initialized with custom builder" do
+      cmd = Class.new(HammerCLI::AbstractCommand) do
+        def self.custom_option_builders
+          [:builder_1, :builder_2]
+        end
+      end
+
+      cmd.option_builder.builders.must_equal [:builder_1, :builder_2]
+    end
+
+  end
+
+  describe "build options" do
+
+    class TestOptionBuilder
+
+      def build(build_options={})
+        [
+          HammerCLI::Options::OptionDefinition.new(["--test"], "TEST", "test"),
+          HammerCLI::Options::OptionDefinition.new(["--test2"], "TEST2", "test2")
+        ]
+      end
+
+    end
+
+    class TestBuilderCmd < HammerCLI::AbstractCommand
+
+      def self.option_builder
+        TestOptionBuilder.new
+      end
+
+    end
+
+    before :each do
+      # define implicit options and clear them all
+      TestBuilderCmd.recognised_options
+      TestBuilderCmd.declared_options.clear
+    end
+
+    it "should use option builder" do
+      TestBuilderCmd.build_options
+      TestBuilderCmd.recognised_options.map(&:switches).flatten.sort.must_equal ["--test", "--test2"].sort
+    end
+
+    it "should skip options that already exist" do
+      TestBuilderCmd.option(["--test"], "TEST", "original_test")
+      TestBuilderCmd.build_options
+      TestBuilderCmd.recognised_options.map(&:description).flatten.sort.must_equal ["original_test", "test2"].sort
+    end
+
+  end
+
   it "should inherit command_name" do
     class CmdName1 < HammerCLI::AbstractCommand
       command_name 'cmd'

data/test/unit/apipie/command_test.rb

@@ -26,92 +26,12 @@ describe HammerCLI::Apipie::Command do
   let(:ctx) { { :adapter => :silent, :interactive => false } }
   let(:cmd_class) { TestCommand.dup }
   let(:cmd) { cmd_class.new("", ctx) }
+  let(:cmd_run) { cmd.run([]) }
 
   before :each do
     HammerCLI::Connection.drop_all
   end
 
-  context "setting identifiers" do
-
-    let(:option_switches) { cmd_class.declared_options.map(&:switches).sort }
-    let(:option_attribute_names) { cmd_class.declared_options.map(&:attribute_name).sort }
-
-    class Cmd1 < TestCommand
-      identifiers :id, :name, :label
-      apipie_options
-    end
-
-    class Cmd2 < Cmd1
-      identifiers :id
-      apipie_options
-    end
-
-    it "must not set any option by default" do
-      cmd_class.apipie_options
-      cmd_class.declared_options.must_equal []
-    end
-
-    it "can set option --id" do
-      cmd_class.identifiers :id
-      cmd_class.apipie_options
-      option_switches.must_equal [["--id"]]
-      option_attribute_names.must_equal [HammerCLI.option_accessor_name("id")]
-    end
-
-    it "can set option --name" do
-      cmd_class.identifiers :name
-      cmd_class.apipie_options
-      option_switches.must_equal [["--name"]]
-      option_attribute_names.must_equal [HammerCLI.option_accessor_name("name")]
-    end
-
-    it "can set option --label" do
-      cmd_class.identifiers :label
-      cmd_class.apipie_options
-      option_switches.must_equal [["--label"]]
-      option_attribute_names.must_equal [HammerCLI.option_accessor_name("label")]
-    end
-
-    it "can set multiple identifiers" do
-      cmd_class.identifiers :id, :name, :label
-      cmd_class.apipie_options
-      option_switches.must_equal [["--id"], ["--label"], ["--name"]]
-      option_attribute_names.must_equal HammerCLI.option_accessor_name("id", "label", "name")
-    end
-
-    it "can change option reader" do
-      cmd_class.identifiers :name, :id => :option_id_read_method
-      cmd_class.apipie_options
-      option_switches.must_equal [["--id"], ["--name"]]
-      option_attribute_names.must_equal HammerCLI.option_accessor_name("id_read_method", "name")
-    end
-
-    it "can override inentifiers in inherrited classes" do
-      Cmd2.new("").class.declared_options.map(&:switches).must_equal [["--id"]]
-    end
-
-    context "require identifiers" do
-
-      it "must require one of declared identifiers" do
-        cmd_class.identifiers :id, :name
-        cmd_class.apipie_options
-        cmd.run(["--id=1"]).must_equal HammerCLI::EX_OK
-      end
-
-      it "must raise exception when no attribute is passed" do
-        cmd_class.identifiers :id, :name
-        cmd_class.apipie_options
-        cmd.run([]).must_equal HammerCLI::EX_USAGE
-      end
-
-      it "must run without error when no identifiers are declared" do
-        cmd.run([]).must_equal HammerCLI::EX_OK
-      end
-
-    end
-
-  end
-
   context "setting resources" do
 
     it "should set resource and action together" do
@@ -164,126 +84,21 @@ describe HammerCLI::Apipie::Command do
     end
   end
 
-  context "apipie generated options" do
-
-    class DocumentedCommand < HammerCLI::Apipie::Command
-      def self.resource_config
-        { :apidoc_cache_dir => 'test/unit/fixtures/apipie', :apidoc_cache_name => 'documented' }
-      end
-    end
-
-    let(:cmd_class) { DocumentedCommand.dup }
-    let(:cmd) { cmd_class.new("", ctx) }
-
-    context "with one simple param" do
-
-      let(:option) { cmd_class.declared_options[0] }
-
-      before :each do
-        cmd_class.resource :documented, :index
-        cmd_class.apipie_options
-      end
-
-      it "should create an option for the parameter" do
-        cmd_class.declared_options.length.must_equal 1
-      end
-
-      it "should set correct switch" do
-        option.switches.must_be :include?, '--se-arch-val-ue'
-      end
-
-      it "should set correct attribute name" do
-        option.attribute_name.must_equal HammerCLI.option_accessor_name('se_arch_val_ue')
-      end
-
-      it "should set description with html tags stripped" do
-        option.description.must_equal 'filter results'
-      end
-    end
-
-    context "required options" do
-      before :each do
-        cmd_class.resource :documented, :create
-        cmd_class.apipie_options
-      end
-
-      let(:required_options) { cmd_class.declared_options.reject{|opt| !opt.required?} }
-
-      it "should set required flag for the required options" do
-        required_options.map(&:attribute_name).sort.must_equal [HammerCLI.option_accessor_name("array_param")]
-      end
-    end
-
-    context "with hash params" do
-      before :each do
-        cmd_class.resource :documented, :create
-        cmd_class.apipie_options
-      end
-
-      it "should create options for all parameters except the hash" do
-        cmd_class.declared_options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name", "provider")
-      end
-
-      it "should name the options correctly" do
-        cmd_class.declared_options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name", "provider")
-      end
-    end
-
-    context "array params" do
-      before :each do
-        cmd_class.resource :documented, :create
-        cmd_class.apipie_options
-      end
-
-      let(:cmd) do
-        cmd_class.new("").tap do |cmd|
-          cmd.stubs(:execute).returns(0)
-        end
-      end
-
-      it "should parse comma separated string to array" do
-        cmd.run(["--array-param=valA,valB,valC"])
-        cmd.get_option_value(:array_param).must_equal ['valA', 'valB', 'valC']
-      end
-
-      it "should parse string to array of length 1" do
-        cmd.run(["--array-param=valA"])
-        cmd.get_option_value(:array_param).must_equal ['valA']
-      end
+  it "should raise exception when no action is defined" do
+    cmd.stubs(:handle_exception).returns(HammerCLI::EX_SOFTWARE)
+    cmd_run.must_equal HammerCLI::EX_SOFTWARE
+  end
 
-      it "should parse empty string to empty array" do
-        cmd.run(['--array-param='])
-        cmd.get_option_value(:array_param).must_equal []
-      end
+  context "resource defined" do
 
+    before :each do
+      HammerCLI::Connection.drop_all
+      ApipieBindings::API.any_instance.stubs(:call).returns([])
+      cmd.class.resource :architectures, :index
     end
 
-
-    context "filtering options" do
-      before :each do
-        cmd_class.resource :documented, :create
-      end
-
-      it "should skip filtered options" do
-        cmd_class.apipie_options :without => ["provider", "name"]
-        cmd_class.declared_options.map(&:attribute_name).sort.must_equal [HammerCLI.option_accessor_name("array_param")]
-      end
-
-      it "should skip filtered options defined as symbols" do
-        cmd_class.apipie_options :without => [:provider, :name]
-        cmd_class.declared_options.map(&:attribute_name).sort.must_equal [HammerCLI.option_accessor_name("array_param")]
-      end
-
-      it "should skip single filtered option in array" do
-        cmd_class.apipie_options :without => ["provider"]
-        cmd_class.declared_options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name")
-      end
-
-      it "should skip single filtered option" do
-        cmd_class.apipie_options :without => "provider"
-        cmd_class.declared_options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name")
-      end
-
+    it "should perform a call to api when resource is defined" do
+      cmd_run.must_equal 0
     end
 
   end

data/test/unit/apipie/option_builder_test.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+
+describe HammerCLI::OptionBuilderContainer do
+
+end
+
+describe HammerCLI::Apipie::OptionBuilder do
+
+  let(:api) do
+    ApipieBindings::API.new({
+      :apidoc_cache_dir => 'test/unit/fixtures/apipie',
+      :apidoc_cache_name => 'documented'
+    })
+  end
+
+  before :each do
+    HammerCLI::I18n.clear
+  end
+
+  let(:action) {api.resource(:documented).action(:index)}
+  let(:builder) { HammerCLI::Apipie::OptionBuilder.new(action) }
+  let(:builder_options) { {} }
+  let(:options) { builder.build(builder_options) }
+
+  context "with one simple param" do
+
+    it "should create an option for the parameter" do
+      options.length.must_equal 1
+    end
+
+    it "should set correct switch" do
+      options[0].switches.must_be :include?, '--se-arch-val-ue'
+    end
+
+    it "should set correct attribute name" do
+      options[0].attribute_name.must_equal HammerCLI.option_accessor_name('se_arch_val_ue')
+    end
+
+    it "should set description with html tags stripped" do
+      options[0].description.must_equal 'filter results'
+    end
+  end
+
+
+  context "required options" do
+
+    let(:action) {api.resource(:documented).action(:create)}
+    let(:required_options) { builder.build.reject{|opt| !opt.required?} }
+
+    it "should set required flag for the required options" do
+      required_options.map(&:attribute_name).sort.must_equal [HammerCLI.option_accessor_name("array_param")]
+    end
+
+    it "should not require any option when requirements are disabled" do
+      builder.require_options = false
+      required_options.map(&:attribute_name).sort.must_equal []
+    end
+  end
+
+
+  context "with hash params" do
+    let(:action) {api.resource(:documented).action(:create)}
+
+    it "should create options for all parameters except the hash" do
+      options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name", "provider")
+    end
+
+    it "should name the options correctly" do
+      options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name", "provider")
+    end
+  end
+
+  context "setting correct normalizers" do
+    let(:action) {api.resource(:documented).action(:create)}
+
+    it "should set array normalizer" do
+      array_option = options.find {|o| o.attribute_name == HammerCLI.option_accessor_name("array_param") }
+      array_option.value_formatter.class.must_equal HammerCLI::Options::Normalizers::List
+    end
+
+  end
+
+
+  context "filtering options" do
+    let(:action) {api.resource(:documented).action(:create)}
+
+    it "should skip filtered options" do
+      builder_options[:without] = ["provider", "name"]
+      options.map(&:attribute_name).sort.must_equal [HammerCLI.option_accessor_name("array_param")]
+    end
+
+    it "should skip filtered options defined as symbols" do
+      builder_options[:without] = [:provider, :name]
+      options.map(&:attribute_name).sort.must_equal [HammerCLI.option_accessor_name("array_param")]
+    end
+
+    it "should skip single filtered option in array" do
+      builder_options[:without] = ["provider"]
+      options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name")
+    end
+
+    it "should skip single filtered option" do
+      builder_options[:without] = "provider"
+      options.map(&:attribute_name).sort.must_equal HammerCLI.option_accessor_name("array_param", "name")
+    end
+
+  end
+end
+

data/test/unit/i18n_test.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+
+describe HammerCLI::I18n do
+
+  class TestLocaleDomain < HammerCLI::I18n::AbstractLocaleDomain
+
+    def initialize(name, available)
+      @name = name
+      @available = available
+    end
+
+    def locale_dir
+      File.dirname(__FILE__)
+    end
+
+    def domain_name
+      @name
+    end
+
+    def available?
+      @available
+    end
+  end
+
+  before :each do
+    HammerCLI::I18n.clear
+  end
+
+  let(:domain1) { TestLocaleDomain.new('domain1', true) }
+  let(:domain2) { TestLocaleDomain.new('domain2', true) }
+  let(:unavailable_domain) { TestLocaleDomain.new('domain3', false) }
+
+  it "registers available domains at gettext" do
+    FastGettext.expects(:add_text_domain).with do |name, options|
+      (name == domain1.domain_name) && (options[:path] == domain1.locale_dir) && (options[:type] == domain1.type)
+    end
+    HammerCLI::I18n.add_domain(domain1)
+  end
+
+  it "skips registering domains that are not available" do
+    HammerCLI::I18n.add_domain(domain1)
+    HammerCLI::I18n.add_domain(domain2)
+    HammerCLI::I18n.add_domain(unavailable_domain)
+    HammerCLI::I18n.domains.must_equal [domain1, domain2]
+  end
+
+
+end
+