hammer_cli 0.0.9 → 0.0.10

data/test/unit/apipie/write_command_test.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+require File.join(File.dirname(__FILE__), 'fake_api')
+
+describe HammerCLI::Apipie::WriteCommand do
+
+  let(:cmd) { HammerCLI::Apipie::WriteCommand.new("") }
+  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
+
+    context "output" do
+      it "should print success message" do
+        cmd.class.success_message "XXX"
+        proc { cmd_run }.must_output /.*XXX.*/
+      end
+    end
+
+  end
+
+end
+

data/test/unit/exception_handler_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+
+describe HammerCLI::ExceptionHandler do
+
+  before(:each) do
+    @log_output = Logging::Appenders['__test__']
+    @log_output.reset
+  end
+
+  let(:output) { HammerCLI::Output::Output.new }
+  let(:handler) { HammerCLI::ExceptionHandler.new(:output => output)}
+  let(:heading) { "Something went wrong" }
+
+  it "should handle unauthorized" do
+    output.expects(:print_error).with(heading, "Invalid username or password")
+    handler.handle_exception(RestClient::Unauthorized.new, :heading => heading)
+  end
+
+  it "should handle general exception" do
+    output.expects(:print_error).with(heading, "Error: message")
+    handler.handle_exception(Exception.new('message'), :heading => heading)
+  end
+
+  it "should handle unknown exception" do
+    output.expects(:print_error).with(heading, "Error: message")
+    MyException = Class.new(Exception)
+    handler.handle_exception(MyException.new('message'), :heading => heading)
+  end
+
+  it "should handle resource not found" do
+    ex = RestClient::ResourceNotFound.new
+    output.expects(:print_error).with(heading, ex.message)
+    handler.handle_exception(ex, :heading => heading)
+  end
+
+  it "should log the error" do
+    ex = RestClient::ResourceNotFound.new
+    output.default_adapter = :silent
+    handler.handle_exception(ex)
+    @log_output.readline.strip.must_equal 'ERROR  Exception : Resource Not Found'
+  end
+
+end
+

data/test/unit/main_test.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe HammerCLI::MainCommand do
+
+  describe "loading context" do
+
+    let(:context) { {} }
+    let(:cmd) { HammerCLI::MainCommand.new("", context) }
+
+    before :each do
+      cmd.stubs(:execute).returns(1)
+    end
+
+    describe "username" do
+
+      it "should prioritize parameter" do
+        cmd.run(["-uuser"])
+        context[:username].must_equal "user"
+      end
+
+      it "should prioritize parameter 2" do
+        cmd.run([])
+        context[:username].must_equal nil
+      end
+
+    end
+
+
+    describe "password" do
+
+      it "should prioritize parameter" do
+        cmd.run(["-ppassword"])
+        context[:password].must_equal "password"
+      end
+
+      it "should prioritize parameter" do
+        cmd.run([])
+        context[:password].must_equal nil
+      end
+
+    end
+
+
+  end
+
+end
+

data/test/unit/options/normalizers_test.rb

@@ -0,0 +1,148 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+
+describe HammerCLI::Options::Normalizers do
+
+
+  describe 'abstract' do
+
+    let(:formatter) { HammerCLI::Options::Normalizers::AbstractNormalizer.new }
+
+    it "should raise exception on format" do
+      proc { formatter.format(nil) }.must_raise NotImplementedError
+    end
+
+  end
+
+  describe 'list' do
+
+    let(:formatter) { HammerCLI::Options::Normalizers::List.new }
+
+    it "should return empty array on nil" do
+      formatter.format(nil).must_equal []
+    end
+
+    it "should return empty array on empty string" do
+      formatter.format("").must_equal []
+    end
+
+    it "should parse a string" do
+      formatter.format("a").must_equal ['a']
+    end
+
+    it "should parse a comma separated string" do
+      formatter.format("a,b,c").must_equal ['a', 'b', 'c']
+    end
+  end
+
+
+  describe 'key_value_list' do
+
+    let(:formatter) { HammerCLI::Options::Normalizers::KeyValueList.new }
+
+    it "should return empty array on nil" do
+      formatter.format(nil).must_equal({})
+    end
+
+    it "should return empty array on empty string" do
+      formatter.format("").must_equal({})
+    end
+
+    it "should parse a string" 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
+
+    it "should parse a comma separated string 2" do
+      proc { formatter.format("a=1,b,c=3") }.must_raise ArgumentError
+    end
+  end
+
+  describe 'bool' do
+
+    let(:formatter) { HammerCLI::Options::Normalizers::Bool.new }
+
+    it "should return true on true" do
+      formatter.format("true").must_equal(true)
+      formatter.format("TRUE").must_equal(true)
+    end
+
+    it "should return true on t" do
+      formatter.format("t").must_equal(true)
+      formatter.format("T").must_equal(true)
+    end
+
+    it "should return true on yes" do
+      formatter.format("yes").must_equal(true)
+      formatter.format("YES").must_equal(true)
+    end
+
+    it "should return true on y" do
+      formatter.format("y").must_equal(true)
+      formatter.format("Y").must_equal(true)
+    end
+
+    it "should return true on 1" do
+      formatter.format("1").must_equal(true)
+    end
+
+    it "should return false on false" do
+      formatter.format("false").must_equal(false)
+      formatter.format("FALSE").must_equal(false)
+    end
+
+    it "should return false on f" do
+      formatter.format("f").must_equal(false)
+      formatter.format("F").must_equal(false)
+    end
+
+    it "should return false on no" do
+      formatter.format("no").must_equal(false)
+      formatter.format("NO").must_equal(false)
+    end
+
+    it "should return false on n" do
+      formatter.format("n").must_equal(false)
+      formatter.format("N").must_equal(false)
+    end
+
+    it "should return false on 0" do
+      formatter.format("0").must_equal(false)
+    end
+
+    it "should raise exception on nil" do
+      proc { formatter.format(nil) }.must_raise ArgumentError
+    end
+
+    it "should raise exception on other values" do
+      proc { formatter.format('unknown') }.must_raise ArgumentError
+    end
+  end
+
+  describe 'enum' do
+
+    let(:formatter) { HammerCLI::Options::Normalizers::Enum.new ['a', 'b'] }
+
+    it "should return return value when in the list" do
+      formatter.format("a").must_equal("a")
+    end
+
+    it "should rise argument error when the value is nil" do
+      proc { formatter.format(nil) }.must_raise ArgumentError
+    end
+
+    it "should rise argument error when the value is not in the list" do
+      proc { formatter.format("c") }.must_raise ArgumentError
+    end
+
+    it "should list allowed values in description" do
+      formatter.description.must_equal("One of 'a', 'b'")
+    end
+
+  end
+
+end
+

data/test/unit/options/option_definition_test.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+# require 'hammer_cli/options/option_definition'
+
+describe HammerCLI::Options::OptionDefinition do
+
+  class FakeFormatter < HammerCLI::Options::Normalizers::AbstractNormalizer
+    def format(val)
+      ">>>#{val}<<<"
+    end
+  end
+
+  class TestOptionFormattersCmd < HammerCLI::AbstractCommand
+    option "--test-format", "TEST_FORMAT", "Test option with a formatter",
+      :format => FakeFormatter.new,
+      :default => "A"
+  end
+
+  describe "formatters" do
+
+    it "should use formatter to format a default value" do
+      opt = TestOptionFormattersCmd.find_option("--test-format")
+
+      opt_instance = opt.of(TestOptionFormattersCmd.new([]))
+      opt_instance.read.must_equal '>>>A<<<'
+    end
+
+    it "should use formatter as a conversion block" do
+      opt = TestOptionFormattersCmd.find_option("--test-format")
+
+      opt_instance = opt.of(TestOptionFormattersCmd.new([]))
+      # clamp api changed in 0.6.2
+      if opt_instance.respond_to? :write 
+        opt_instance.write('B')
+      else
+        opt_instance.take('B')
+      end
+      opt_instance.read.must_equal '>>>B<<<'
+    end
+  end
+
+end
+

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

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Output::Adapter::Abstract do
+
+  let(:adapter_class) { HammerCLI::Output::Adapter::Abstract }
+  let(:adapter) { HammerCLI::Output::Adapter::Abstract.new }
+
+
+  it "should have tags" do
+    adapter.tags.must_be_kind_of Array
+  end
+
+  class UnknownTestFormatter < HammerCLI::Output::Formatters::FieldFormatter
+    def format(data)
+      data+'.'
+    end
+
+    def tags
+      [:unknown]
+    end
+  end
+
+  it "should filter formatters with incompatible tags" do
+
+    HammerCLI::Output::Formatters::FormatterLibrary.expects(:new).with({ :type => [] })
+    adapter = adapter_class.new({}, {:type => [UnknownTestFormatter.new]})
+  end
+
+  it "should keep compatible formatters" do
+    formatter = UnknownTestFormatter.new
+    HammerCLI::Output::Formatters::FormatterLibrary.expects(:new).with({ :type => [formatter] })
+    # set :unknown tag to abstract
+    adapter_class.any_instance.stubs(:tags).returns([:unknown])
+    adapter = adapter_class.new({}, {:type => [formatter]})
+  end
+
+  it "should put serializers first" do
+    formatter1 = UnknownTestFormatter.new
+    formatter1.stubs(:tags).returns([])
+    formatter2 = UnknownTestFormatter.new
+    formatter2.stubs(:tags).returns([:flat])
+    HammerCLI::Output::Formatters::FormatterLibrary.expects(:new).with({ :type => [formatter2, formatter1] })
+    # set :unknown tag to abstract
+    adapter_class.any_instance.stubs(:tags).returns([:flat])
+    adapter = adapter_class.new({}, {:type => [formatter1, formatter2]})
+  end
+
+
+  context "messages" do
+    it "should print message to stdout" do
+      proc { adapter.print_message("MESSAGE") }.must_output(/.*MESSAGE.*/, "")
+    end
+
+    it "should print formatted message with parameters" do
+      proc { adapter.print_message("MESSAGE %{a}s, %{b}s", :a => 'A', :b => 'B') }.must_output(/.*MESSAGE A, B.*/, "")
+    end
+
+  end
+
+  it "should raise not implemented on print_records" do
+    proc { adapter.print_records([], []) }.must_raise NotImplementedError
+  end
+
+  context "error messages" do
+    it "should print error message to stderr" do
+      proc { adapter.print_error("MESSAGE") }.must_output("", /.*MESSAGE.*/)
+    end
+
+    let(:expected_output) { "MESSAGE:\n"+
+                            "  error\n"+
+                            "  message\n"+
+                            "  details\n"
+    }
+
+    let(:expected_formatted_output) { "MESSAGE A, B:\n"+
+                                      "  error A\n"+
+                                      "  error B\n"
+    }
+
+    it "should print list details of error to stderr" do
+      proc { adapter.print_error("MESSAGE", ["error", "message", "details"]) }.must_output("", expected_output)
+    end
+
+    it "should print string details of error to stderr" do
+      proc { adapter.print_error("MESSAGE", "error\nmessage\ndetails") }.must_output("", expected_output)
+    end
+
+    it "should print formatted message with parameters" do
+      proc {
+        adapter.print_error("MESSAGE %{a}s, %{b}s", ["error %{a}s", "error %{b}s"], :a => 'A', :b => 'B')
+      }.must_output("", expected_formatted_output)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Output::Adapter::Base do
+
+  let(:adapter) { HammerCLI::Output::Adapter::Base.new }
+
+  context "print_records" do
+
+    let(:field_name) { Fields::DataField.new(:path => [:name], :label => "Name") }
+    let(:fields) {
+      [field_name]
+    }
+    let(:data) {[{
+      :name => "John Doe"
+    }]}
+
+    it "should print field name" do
+      proc { adapter.print_records(fields, data) }.must_output(/.*Name[ ]*:.*/, "")
+    end
+
+    it "should print field value" do
+      proc { adapter.print_records(fields, data) }.must_output(/.*John Doe.*/, "")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Output::Adapter::CSValues do
+
+  let(:adapter) { HammerCLI::Output::Adapter::CSValues.new }
+
+  context "print_records" do
+
+    let(:field_name) { Fields::DataField.new(:path => [:name], :label => "Name") }
+    let(:field_started_at) { Fields::DataField.new(:path => [:started_at], :label => "Started At") }
+    let(:fields) {
+      [field_name, field_started_at]
+    }
+    let(:data) {[{
+      :name => "John Doe",
+      :started_at => "2000"
+    }]}
+
+    it "should print column name" do
+      proc { adapter.print_records(fields, data) }.must_output(/.*Name,Started At.*/, "")
+    end
+
+    it "should print field value" do
+      proc { adapter.print_records(fields, data) }.must_output(/.*John Doe.*/, "")
+    end
+
+    context "handle ids" do
+      let(:field_id) { Fields::Id.new(:path => [:some_id], :label => "Id") }
+      let(:fields) {
+        [field_name, field_id]
+      }
+
+      it "should ommit column of type Id by default" do
+        out, err = capture_io { adapter.print_records(fields, data) }
+        out.wont_match(/.*Id.*/)
+        out.wont_match(/.*John Doe,.*/)
+      end
+
+      it "should print column of type Id when --show-ids is set" do
+        adapter = HammerCLI::Output::Adapter::CSValues.new( { :show_ids => true } )
+        out, err = capture_io { adapter.print_records(fields, data) }
+        out.must_match(/.*Id.*/)
+      end
+    end
+
+    context "formatters" do
+      it "should apply formatters" do
+        class DotFormatter < HammerCLI::Output::Formatters::FieldFormatter
+          def format(data)
+            '-DOT-'
+          end
+        end
+
+        adapter = HammerCLI::Output::Adapter::CSValues.new({}, { :DataField => [ DotFormatter.new ]})
+        out, err = capture_io { adapter.print_records(fields, data) }
+        out.must_match(/.*-DOT-.*/)
+      end
+    end
+  end
+
+  context "print message" do
+
+    it "shoud print a message" do
+      proc { adapter.print_message("SOME MESSAGE") }.must_output("Message\nSOME MESSAGE\n", "")
+    end
+
+    it "should print message, id and name of created/updated record" do
+      proc {
+        adapter.print_message("SOME MESSAGE", "id" => 83, "name" => "new_record")
+      }.must_output("Message,Id,Name\nSOME MESSAGE,83,new_record\n", "")
+    end
+
+  end
+
+end

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

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Output::Adapter::Table do
+
+  let(:adapter) { HammerCLI::Output::Adapter::Table.new }
+
+  context "print_records" do
+
+    let(:field_name) { Fields::DataField.new(:path => [:name], :label => "Name") }
+    let(:fields) {
+      [field_name]
+    }
+    let(:data) {[{
+      :name => "John Doe"
+    }]}
+
+    it "should print column name" do
+      proc { adapter.print_records(fields, data) }.must_output(/.*NAME.*/, "")
+    end
+
+    it "should print field value" do
+      proc { adapter.print_records(fields, data) }.must_output(/.*John Doe.*/, "")
+    end
+
+    context "handle ids" do
+      let(:field_id) { Fields::Id.new(:path => [:some_id], :label => "Id") }
+      let(:fields) {
+        [field_name, field_id]
+      }
+
+      it "should ommit column of type Id by default" do
+        out, err = capture_io { adapter.print_records(fields, data) }
+        out.wont_match(/.*ID.*/)
+      end
+
+      it "should print column of type Id when --show-ids is set" do
+        adapter = HammerCLI::Output::Adapter::Table.new( { :show_ids => true } )
+        out, err = capture_io { adapter.print_records(fields, data) }
+        out.must_match(/.*ID.*/)
+      end
+    end
+
+    context "formatters" do
+      it "should apply formatters" do 
+        class DotFormatter < HammerCLI::Output::Formatters::FieldFormatter
+          def format(data)
+            '-DOT-'
+          end
+        end
+
+        adapter = HammerCLI::Output::Adapter::Table.new({}, { :DataField => [ DotFormatter.new ]})
+        out, err = capture_io { adapter.print_records(fields, data) }
+        out.must_match(/.*-DOT-.*/)
+      end
+    end
+  end
+
+end

data/test/unit/output/definition_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+
+
+describe HammerCLI::Output::Definition do
+
+  let(:definition) { HammerCLI::Output::Definition.new }
+  let(:last_field) { definition.fields[-1] }
+  let(:field_count) { definition.fields.length }
+
+  it "should be able to add field" do
+    definition.fields << Fields::Field.new
+    field_count.must_equal 1
+  end
+
+  it "append should allow to add data from another definition" do
+    another_def = HammerCLI::Output::Definition.new
+    another_def.fields << Fields::Field.new
+    another_def.fields << Fields::Field.new
+
+    definition.append another_def.fields
+    field_count.must_equal another_def.fields.length
+    definition.fields.must_equal another_def.fields
+  end
+
+end
+