hammer_cli 0.0.9 → 0.0.10

data/test/unit/abstract_test.rb

@@ -0,0 +1,296 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'tempfile'
+
+
+describe HammerCLI::AbstractCommand do
+
+  context "output" do
+
+    let(:cmd_class) { Class.new(HammerCLI::AbstractCommand) }
+    let(:cmd) { cmd_class.new("", { :adapter => :silent }) }
+    it "should define adapter" do
+      cmd.adapter.must_equal :base
+    end
+
+    it "should provide instance of output with default adapter set" do
+      cmd.output.default_adapter.must_equal cmd.adapter
+    end
+
+    it "should hold instance of output definition" do
+      cmd.output_definition.must_be_instance_of HammerCLI::Output::Definition
+    end
+
+    it "can append existing definition" do
+      definition = HammerCLI::Output::Definition.new
+      definition.fields << Fields::Field.new
+      definition.fields << Fields::Field.new
+
+      cmd_class.output(definition) do
+      end
+      cmd_class.output_definition.fields.length.must_equal definition.fields.length
+    end
+
+    it "can append existing definition without passing a block" do
+      definition = HammerCLI::Output::Definition.new
+      definition.fields << Fields::Field.new
+      definition.fields << Fields::Field.new
+
+      cmd_class.output(definition)
+      cmd_class.output_definition.fields.length.must_equal definition.fields.length
+    end
+
+    it "can define fields" do
+      cmd_class.output do
+        field :test_1, "test 1"
+        field :test_2, "test 2"
+      end
+      cmd_class.output_definition.fields.length.must_equal 2
+    end
+  end
+
+  context "exception handler" do
+
+    class Handler
+      def initialize(options={})
+      end
+      def handle_exception(e)
+        raise e
+      end
+    end
+
+    module ModA
+      module ModB
+        class TestCmd < HammerCLI::AbstractCommand
+        end
+      end
+    end
+
+    it "should return instance of hammer cli exception handler by default" do
+      cmd = ModA::ModB::TestCmd.new ""
+      cmd.exception_handler.must_be_instance_of HammerCLI::ExceptionHandler
+    end
+
+    it "should return instance of exception handler class defined in a module" do
+      ModA::ModB.expects(:exception_handler_class).returns(Handler)
+      cmd = ModA::ModB::TestCmd.new ""
+      cmd.exception_handler.must_be_instance_of Handler
+    end
+
+    it "should return instance of exception handler class defined deeper in a module hierrarchy" do
+      ModA.expects(:exception_handler_class).returns(Handler)
+      cmd = ModA::ModB::TestCmd.new ""
+      cmd.exception_handler.must_be_instance_of Handler
+    end
+  end
+
+  context "logging" do
+
+    before :each do
+      @log_output = Logging::Appenders['__test__']
+      @log_output.reset
+    end
+
+    it "should log what has been executed" do
+      test_command = Class.new(HammerCLI::AbstractCommand).new("")
+      test_command.run []
+      @log_output.readline.strip.must_equal "INFO  HammerCLI::AbstractCommand : Called with options: {}"
+    end
+
+    it "password should be hidden in logs" do
+      test_command_class = Class.new(HammerCLI::AbstractCommand)
+      test_command_class.option(['--password'], 'PASSWORD', 'Password')
+      test_command = test_command_class.new("")
+      test_command.run ['--password=pass']
+      @log_output.readline.strip.must_equal "INFO  HammerCLI::AbstractCommand : Called with options: {\"password\"=>\"***\"}"
+    end
+
+    class TestLogCmd < HammerCLI::AbstractCommand
+      def execute
+        logger.error "Test"
+        0
+      end
+    end
+
+    it "should have logger named by the class by default" do
+      test_command = Class.new(TestLogCmd).new("")
+      test_command.run []
+      @log_output.read.must_include "ERROR  TestLogCmd : Test"
+    end
+
+    class TestLogCmd2 < HammerCLI::AbstractCommand
+      def execute
+        logger('My logger').error "Test"
+        0
+      end
+    end
+
+    it "should have logger that accepts custom name" do
+      test_command = Class.new(TestLogCmd2).new("")
+      test_command.run []
+      @log_output.read.must_include "ERROR  My logger : Test"
+    end
+
+    class TestLogCmd3 < HammerCLI::AbstractCommand
+      def execute
+        logger.watch "Test", {}
+        0
+      end
+    end
+
+    it "should have logger that can inspect object" do
+      test_command = Class.new(TestLogCmd3).new("")
+      test_command.run []
+      @log_output.read.must_include "DEBUG  TestLogCmd3 : Test\n{}"
+    end
+
+    class TestLogCmd4 < HammerCLI::AbstractCommand
+      def execute
+        logger.watch "Test", { :a => 'a' }, { :plain => true }
+        0
+      end
+    end
+
+    it "should have logger.watch output without colors" do
+      test_command = Class.new(TestLogCmd4).new("")
+      test_command.run []
+      @log_output.read.must_include "DEBUG  TestLogCmd4 : Test\n{\n  :a => \"a\"\n}"
+    end
+
+    class TestLogCmd5 < HammerCLI::AbstractCommand
+      def execute
+        logger.watch "Test", { :a => 'a' }
+        0
+      end
+    end
+
+    it "should have logger.watch colorized output switch in settings" do
+      test_command = Class.new(TestLogCmd5).new("")
+      HammerCLI::Settings.clear
+      HammerCLI::Settings.load(:watch_plain => true)
+      test_command.run []
+      @log_output.read.must_include "DEBUG  TestLogCmd5 : Test\n{\n  :a => \"a\"\n}"
+    end
+  end
+
+  context "subcommand behavior" do
+
+    class Subcommand1 < HammerCLI::AbstractCommand; end
+    class Subcommand2 < HammerCLI::AbstractCommand; end
+
+    let(:main_cmd) { HammerCLI::AbstractCommand.dup }
+
+    before :each do
+      @log_output = Logging::Appenders['__test__']
+      @log_output.reset
+
+      main_cmd.recognised_subcommands.clear
+      main_cmd.subcommand("some_command", "description", Subcommand1)
+      main_cmd.subcommand("ping", "description", Subcommand1)
+    end
+
+    describe "subcommand!" do
+
+      it "should replace commands with the same name" do
+        main_cmd.subcommand!("ping", "description", Subcommand2)
+        main_cmd.find_subcommand("some_command").wont_be_nil
+        main_cmd.find_subcommand("ping").wont_be_nil
+        main_cmd.find_subcommand("ping").subcommand_class.must_equal Subcommand2
+        main_cmd.recognised_subcommands.count.must_equal 2
+      end
+
+      it "should write a message to log when replacing subcommand" do
+        main_cmd.subcommand!("ping", "description", Subcommand2)
+        @log_output.readline.strip.must_equal "INFO  Clamp::Command : subcommand ping (Subcommand1) was removed."
+        @log_output.readline.strip.must_equal "INFO  Clamp::Command : subcommand ping (Subcommand2) was created."
+      end
+
+      it "should add the subcommand" do
+        main_cmd.subcommand!("new_command", "description", Subcommand2)
+        main_cmd.find_subcommand("new_command").wont_be_nil
+        main_cmd.find_subcommand("some_command").wont_be_nil
+        main_cmd.find_subcommand("ping").wont_be_nil
+        main_cmd.recognised_subcommands.count.must_equal 3
+      end
+
+    end
+
+
+    describe "subcommand" do
+
+      it "should throw an exception for conflicting commands" do
+        proc do
+          main_cmd.subcommand("ping", "description", Subcommand2)
+        end.must_raise HammerCLI::CommandConflict
+      end
+
+      it "should add the subcommand" do
+        main_cmd.subcommand("new_command", "description", Subcommand2)
+        main_cmd.find_subcommand("new_command").wont_be_nil
+        main_cmd.find_subcommand("some_command").wont_be_nil
+        main_cmd.find_subcommand("ping").wont_be_nil
+        main_cmd.recognised_subcommands.count.must_equal 3
+      end
+
+    end
+
+    describe "remove_subcommand" do
+      it "should remove the subcommand" do
+        main_cmd.remove_subcommand('ping')
+        main_cmd.find_subcommand("ping").must_be_nil
+      end
+
+      it "should write a message to log when removing subcommand" do
+        main_cmd.remove_subcommand('ping')
+        @log_output.readline.strip.must_equal "INFO  Clamp::Command : subcommand ping (Subcommand1) was removed."
+      end
+
+    end
+  end
+
+  describe "options" do
+
+    class TestOptionCmd < HammerCLI::AbstractCommand
+      option "--test", "TEST", "Test option"
+      option "--test-format", "TEST_FORMAT", "Test option with a formatter",
+        :format => HammerCLI::Options::Normalizers::List.new
+    end
+
+    it "should create instances of hammer options" do
+      opt = TestOptionCmd.find_option("--test")
+      opt.kind_of?(HammerCLI::Options::OptionDefinition).must_equal true
+    end
+
+    it "should set options' formatters" do
+      opt = TestOptionCmd.find_option("--test-format")
+      opt.value_formatter.kind_of?(HammerCLI::Options::Normalizers::List).must_equal true
+    end
+
+  end
+
+  it "should inherit command_name" do
+    class CmdName1 < HammerCLI::AbstractCommand
+      command_name 'cmd'
+    end
+
+    class CmdName2 < CmdName1
+    end
+
+    CmdName2.command_name.must_equal 'cmd'
+  end
+
+  it "should inherit output definition" do
+    class CmdOD1 < HammerCLI::AbstractCommand
+      output do
+        label 'Label' do
+        end        
+      end
+    end
+
+    class CmdOD2 < CmdOD1
+    end
+
+    CmdOD2.output_definition.fields.length.must_equal 1
+  end
+
+end
+

data/test/unit/apipie/command_test.rb

@@ -0,0 +1,270 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+require File.join(File.dirname(__FILE__), 'fake_api')
+
+
+describe HammerCLI::Apipie::Command do
+
+  class ParentCommand < HammerCLI::Apipie::Command
+    action :show
+  end
+
+  class CommandA < HammerCLI::Apipie::Command
+    resource FakeApi::Resources::Architecture, :index
+
+    class CommandB < ParentCommand
+    end
+  end
+  
+  class CommandC < CommandA
+  end
+
+
+  let(:cmd_class) { HammerCLI::Apipie::Command.dup }
+  let(:cmd) { cmd_class.new("") }
+
+  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 < HammerCLI::Apipie::Command
+      identifiers :id, :name, :label
+    end
+
+    class Cmd2 < Cmd1
+      identifiers :id
+    end
+
+    it "must not set any option by default" do
+      cmd
+      cmd_class.declared_options.must_equal []
+    end
+
+    it "can set option --id" do
+      cmd_class.identifiers :id
+      cmd
+      option_switches.must_equal [["--id"]]
+      option_attribute_names.must_equal ["id"]
+    end
+
+    it "can set option --name" do
+      cmd_class.identifiers :name
+      cmd
+      option_switches.must_equal [["--name"]]
+      option_attribute_names.must_equal ["name"]
+    end
+
+    it "can set option --label" do
+      cmd_class.identifiers :label
+      cmd
+      option_switches.must_equal [["--label"]]
+      option_attribute_names.must_equal ["label"]
+    end
+
+    it "can set multiple identifiers" do
+      cmd_class.identifiers :id, :name, :label
+      cmd
+      option_switches.must_equal [["--id"], ["--label"], ["--name"]]
+      option_attribute_names.must_equal ["id", "label", "name"]
+    end
+
+    it "can change option reader" do
+      cmd_class.identifiers :name, :id => :id_read_method
+      cmd
+      option_switches.must_equal [["--id"], ["--name"]]
+      option_attribute_names.must_equal ["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.run(["--id=1"]).must_equal HammerCLI::EX_OK
+      end
+
+      it "must raise exception when no attribute is passed" do
+        cmd_class.identifiers :id, :name
+        proc { cmd.run([]) }.must_raise Clamp::UsageError
+      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
+      cmd_class.resource FakeApi::Resources::Architecture, :index
+
+      cmd.resource.resource_class.must_equal FakeApi::Resources::Architecture
+      cmd_class.resource.resource_class.must_equal FakeApi::Resources::Architecture
+
+      cmd.action.must_equal :index
+      cmd_class.action.must_equal :index
+    end
+
+    it "should set resource alone" do
+      cmd_class.resource FakeApi::Resources::Architecture
+
+      cmd.resource.resource_class.must_equal FakeApi::Resources::Architecture
+      cmd_class.resource.resource_class.must_equal FakeApi::Resources::Architecture
+
+      cmd.action.must_equal nil
+      cmd_class.action.must_equal nil
+    end
+
+    it "should set resource and action alone" do
+      cmd_class.resource FakeApi::Resources::Architecture
+      cmd_class.action :index
+
+      cmd.resource.resource_class.must_equal FakeApi::Resources::Architecture
+      cmd_class.resource.resource_class.must_equal FakeApi::Resources::Architecture
+
+      cmd.action.must_equal :index
+      cmd_class.action.must_equal :index
+    end
+
+    it "inherits action from a parent class" do
+      cmd_b = CommandA::CommandB.new("")
+      cmd_b.action.must_equal :show
+      cmd_b.class.action.must_equal :show
+    end
+
+    it "looks up resource in the class' modules" do
+      cmd_b = CommandA::CommandB.new("")
+      cmd_b.resource.resource_class.must_equal FakeApi::Resources::Architecture
+      cmd_b.class.resource.resource_class.must_equal FakeApi::Resources::Architecture
+    end
+
+    it "looks up resource in the superclass" do
+      cmd_c = CommandC.new("")
+      cmd_c.resource.resource_class.must_equal FakeApi::Resources::Architecture
+      cmd_c.class.resource.resource_class.must_equal FakeApi::Resources::Architecture
+    end
+  end
+
+  context "apipie generated options" do
+
+    context "with one simple param" do
+
+      let(:option) { cmd_class.declared_options[0] }
+
+      before :each do
+        cmd_class.resource FakeApi::Resources::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 '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 FakeApi::Resources::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 ["array_param"]
+      end
+    end
+
+    context "with hash params" do
+      before :each do
+        cmd_class.resource FakeApi::Resources::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 ["array_param", "name", "provider"]
+      end
+
+      it "should name the options correctly" do
+        cmd_class.declared_options.map(&:attribute_name).sort.must_equal ["array_param", "name", "provider"]
+      end
+    end
+
+    context "array params" do
+      before :each do
+        cmd_class.resource FakeApi::Resources::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.array_param.must_equal ['valA', 'valB', 'valC']
+      end
+
+      it "should parse string to array of length 1" do
+        cmd.run(["--array-param=valA"])
+        cmd.array_param.must_equal ['valA']
+      end
+
+      it "should parse empty string to empty array" do
+        cmd.run(['--array-param='])
+        cmd.array_param.must_equal []
+      end
+
+    end
+
+
+    context "filtering options" do
+      before :each do
+        cmd_class.resource FakeApi::Resources::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 ["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 ["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 ["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 ["array_param", "name"]
+      end
+
+    end
+
+  end
+
+end
+

data/test/unit/apipie/fake_api.rb

@@ -0,0 +1,101 @@
+  module FakeApi
+    module Resources
+      class Architecture
+        def initialize(attrs=nil)
+        end
+        def self.doc
+          {
+            "name"=>"Architecture",
+            "methods"=>[
+              {
+                "name"=>"some_action",
+                "examples"=>[],
+                "errors"=>[],
+                "params"=>[]
+              }
+            ]
+          }
+        end
+      end
+      class CamelCaseName
+        def initialize(attrs=nil)
+        end
+
+        def self.doc
+          {
+            "name"=>"CamelCaseName",
+            "methods"=>[]
+          }
+        end
+      end
+      class Documented
+        def initialize(attrs=nil)
+        end
+
+        def self.doc
+          {
+            "name"=>"Documented",
+            "api_url"=>"/api",
+            "version"=>"v2",
+            "short_description"=>nil,
+            "full_description"=>nil,
+            "doc_url"=>"/apidoc/v2/documented",
+            "methods"=>[
+              {
+                "name"=>"index",
+                "examples"=>[],
+                "errors"=>[],
+                "params"=>
+                 [{"allow_nil"=>false,
+                   "name"=>"se_arch_val-ue",
+                   "full_name"=>"se_arch_val-ue_full_name",
+                   "validator"=>"Must be String",
+                   "description"=>"<p>filter results</p>",
+                   "expected_type"=>"string",
+                   "required"=>false}],
+                "full_description"=>""},
+              {
+
+                "name"=>"create",
+                "examples"=>[],
+                "errors"=>[],
+                "params"=>
+                 [{"allow_nil"=>false,
+                   "name"=>"documented",
+                   "full_name"=>"documented",
+                   "validator"=>"Must be a Hash",
+                   "description"=>"",
+                   "expected_type"=>"hash",
+                   "required"=>true,
+                   "params"=>
+                    [{"name"=>"name",
+                      "allow_nil"=>false,
+                      "full_name"=>"documented[name]",
+                      "validator"=>"Must be String",
+                      "expected_type"=>"string",
+                      "description"=>"",
+                      "required"=>false},
+                     {"name"=>"provider",
+                      "allow_nil"=>false,
+                      "full_name"=>"documented[provider]",
+                      "validator"=>"Must be String",
+                      "expected_type"=>"string",
+                      "description"=>
+                       "<p>Providers include Libvirt, Ovirt, EC2, Vmware, Openstack, Rackspace</p>",
+                      "required"=>false},
+                     {"name"=>"array_param",
+                      "allow_nil"=>false,
+                      "full_name"=>"documented[array_param]",
+                      "validator"=>"Must be Array",
+                      "expected_type"=>"string",
+                      "description"=>"",
+                      "required"=>true},]
+                    }],
+                "full_description"=>""
+              }
+            ]
+          }
+        end
+      end
+    end
+  end

data/test/unit/apipie/read_command_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+require File.join(File.dirname(__FILE__), 'fake_api')
+
+
+describe HammerCLI::Apipie::ReadCommand do
+
+  let(:cmd_class) { HammerCLI::Apipie::ReadCommand.dup }
+  let(:cmd) { cmd_class.new("", { :adapter => :silent }) }
+  let(:cmd_run) { cmd.run([]) }
+
+  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
+
+  context "resource defined" do
+
+    before :each do
+      cmd_class.resource FakeApi::Resources::Architecture, "some_action"
+
+      arch = FakeApi::Resources::Architecture.new
+      arch.expects(:some_action).returns([])
+      FakeApi::Resources::Architecture.stubs(:new).returns(arch)
+    end
+
+    it "should perform a call to api when resource is defined" do
+      cmd_run.must_equal 0
+    end
+
+  end
+
+
+end
+