hammer_cli 0.0.9 → 0.0.10

data/test/unit/output/dsl_test.rb

@@ -0,0 +1,119 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+
+class CustomFieldType
+  attr_reader :options
+
+  def initialize(options)
+    @options = options
+  end
+end
+
+describe HammerCLI::Output::Dsl do
+
+  let(:dsl) { HammerCLI::Output::Dsl.new }
+  let(:field_type) { FieldType }
+  let(:first_field) { dsl.fields[0] }
+  let(:last_field) { dsl.fields[-1] }
+
+  it "should be empty after initialization" do
+    dsl.fields.length.must_equal 0
+  end
+
+  context "fields" do
+    it "should create DataField as default field type" do
+      dsl.build do
+        field :f, "F"
+      end
+      first_field.class.must_equal Fields::DataField
+    end
+
+    it "should create DataField of desired type" do
+      dsl.build do
+        field :f, "F", CustomFieldType
+      end
+      first_field.class.must_equal CustomFieldType
+    end
+
+    it "should store all field details" do
+      dsl.build do
+        field :f, "F"
+       end
+
+      first_field.must_equal last_field
+      first_field.path.must_equal [:f]
+      first_field.label.must_equal "F"
+    end
+
+    it "can define multiple fields" do
+      dsl.build do
+        field :name, "Name"
+        field :surname, "Surname"
+        field :email, "Email"
+      end
+
+      dsl.fields.length.must_equal 3
+    end
+  end
+
+  context "custom fields" do
+
+    let(:options) {{:a => 1, :b => 2}}
+
+    it "it creates field of a desired type" do
+      dsl.build do
+        custom_field CustomFieldType, :a => 1, :b => 2
+      end
+      first_field.class.must_equal CustomFieldType
+    end
+
+    it "passes all options to the field instance" do
+      dsl.build do
+        custom_field CustomFieldType, :a => 1, :b => 2
+      end
+      first_field.options.must_equal options
+    end
+
+  end
+
+  context "path definition" do
+
+    it "from appends to path" do
+      dsl.build do
+        from :key1 do
+          field :email, "Email"
+        end
+      end
+      last_field.path.must_equal [:key1, :email]
+    end
+
+    it "path can be nil to handle the parent structure" do
+      dsl.build do
+        from :key1 do
+          field nil, "Email"
+        end
+      end
+      last_field.path.must_equal [:key1]
+    end
+
+    it "from can be nested" do
+      dsl.build do
+        from :key1 do
+          from :key2 do
+            from :key3 do
+              field :name, "Name"
+            end
+            field :email, "Email"
+          end
+        end
+      end
+      first_field.path.must_equal [:key1, :key2, :key3, :name]
+      last_field.path.must_equal [:key1, :key2, :email]
+    end
+
+  end
+
+
+
+end
+

data/test/unit/output/fields_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+
+describe Fields::Field do
+
+  let(:field) { Fields::Field.new }
+
+  describe "get_value" do
+    it "should exist" do
+      assert field.respond_to? :get_value
+    end
+
+    it "should take data as a parameter" do
+      field.method(:get_value).arity.must_equal 1
+    end
+  end
+
+end
+
+describe Fields::LabeledField do
+
+  let(:label) { "Some Label" }
+  let(:field) { Fields::LabeledField.new :label => label }
+
+  context "labels" do
+    it "has label" do
+      assert field.respond_to? :label
+    end
+
+    it "is possible to set label in constructor" do
+      field.label.must_equal label
+    end
+  end
+
+end
+
+describe Fields::DataField do
+
+  let(:symbol_data) {{
+    :name => "John Doe",
+    :email => "john.doe@example.com",
+    :address => {
+      :city => {
+        :name => "New York",
+        :zip => "1234"
+      }
+    }
+  }}
+
+  let(:string_data) {{
+    "name" => "Eric Doe",
+    "email" => "eric.doe@example.com",
+    "address" => {
+      "city" => {
+        "name" => "Boston",
+        "zip" => "6789"
+      }
+    }
+  }}
+
+  let(:label) { "Some Label" }
+  let(:path) { [:address, :city, :name] }
+  let(:field) { Fields::DataField.new :label => label, :path => path }
+
+  it "stores label from constructor" do
+    field.label.must_equal label
+  end
+
+  it "stores path from constructor" do
+    field.path.must_equal path
+  end
+
+  it "default path should be empty array" do
+    Fields::DataField.new.path.must_equal []
+  end
+
+  context "getting data" do
+
+    it "should pick correct value" do
+      field.get_value(symbol_data).must_equal symbol_data[:address][:city][:name]
+    end
+
+    it "should pick correct value independent of key type" do
+      field.get_value(string_data).must_equal string_data["address"]["city"]["name"]
+    end
+
+    it "should pick correct value even if data contains empty key (#3352)" do
+      string_data[''] = {}
+      field.get_value(string_data).must_equal string_data["address"]["city"]["name"]
+    end
+
+
+  end
+
+end
+
+

data/test/unit/output/formatters_test.rb

@@ -0,0 +1,83 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+describe HammerCLI::Output::Formatters::FormatterLibrary do
+  it "accepts formatter" do
+    lib = HammerCLI::Output::Formatters::FormatterLibrary.new(
+      :Id => HammerCLI::Output::Formatters::FieldFormatter.new)
+    lib.formatter_for_type(Fields::Id).must_be_instance_of HammerCLI::Output::Formatters::FormatterContainer
+  end
+
+  it "can add formatter to instance" do
+    lib = HammerCLI::Output::Formatters::FormatterLibrary.new
+    lib.register_formatter :Id, HammerCLI::Output::Formatters::FieldFormatter.new
+    lib.formatter_for_type(Fields::Id).must_be_instance_of HammerCLI::Output::Formatters::FormatterContainer
+  end
+end
+
+describe HammerCLI::Output::Formatters::FieldFormatter do
+  let(:formatter) { HammerCLI::Output::Formatters::FieldFormatter.new }
+  it "has format method" do
+    formatter.respond_to?(:format).must_equal true
+  end
+
+  it "has tags" do
+    formatter.tags.must_be_kind_of Array
+  end
+
+  it "should know if it has matching tags" do
+    formatter.stubs(:tags).returns([:tag])
+    formatter.match?([:tag]).must_equal true
+    formatter.match?([:notag]).must_equal false
+  end
+end
+
+describe HammerCLI::Output::Formatters::FormatterContainer do
+
+  class TestFormatter
+    def format(data)
+      data+'.'
+    end
+  end
+
+  it "accepts formatter" do
+    container = HammerCLI::Output::Formatters::FormatterContainer.new(TestFormatter.new)
+    container.format('').must_equal '.'
+  end
+    
+  it "has format method" do
+    container = HammerCLI::Output::Formatters::FormatterContainer.new
+    container.respond_to?(:format).must_equal true
+  end
+
+  it "can add formatter to instance" do
+    container = HammerCLI::Output::Formatters::FormatterContainer.new(TestFormatter.new)
+    container.add_formatter TestFormatter.new
+    container.format('').must_equal '..'
+  end
+end
+
+describe HammerCLI::Output::Formatters::ColorFormatter do
+  it "colorizes the value" do
+    formatter = HammerCLI::Output::Formatters::ColorFormatter.new(:red)
+    formatter.format('red').must_equal "\e[31mred\e[0m"
+  end
+end
+
+describe HammerCLI::Output::Formatters::DateFormatter do
+  it "formats the date" do
+    formatter = HammerCLI::Output::Formatters::DateFormatter.new
+    formatter.format('2000-01-01 21:01:01').must_equal "2000/01/01 21:01:01"
+  end
+
+  it "returns empty string on wrong value" do
+    formatter = HammerCLI::Output::Formatters::DateFormatter.new
+    formatter.format('wrong value').must_equal ""
+  end  
+end
+
+describe HammerCLI::Output::Formatters::ListFormatter do
+  it "serializes the value" do
+    formatter = HammerCLI::Output::Formatters::ListFormatter.new
+    formatter.format([1, 2]).must_equal '1, 2'
+  end
+end

data/test/unit/output/output_test.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+describe HammerCLI::Output::Output do
+
+  let(:adapter) { HammerCLI::Output::Adapter::Silent }
+  let(:definition) { HammerCLI::Output::Definition.new }
+
+  let(:context) { { :adapter => :silent } }
+  let(:out_class) { HammerCLI::Output::Output }
+  let(:out) { out_class.new(context) }
+
+  context "messages" do
+
+    let(:msg) { "Some message" }
+    let(:details) { "Some\nmessage\ndetails" }
+    let(:msg_arg) { {:a => 'A'} }
+
+    it "prints info message via adapter" do
+      adapter.any_instance.expects(:print_message).with(msg, {})
+      out.print_message(msg)
+    end
+
+    it "prints info message via adapter with arguments" do
+      adapter.any_instance.expects(:print_message).with(msg, msg_arg)
+      out.print_message(msg, msg_arg)
+    end
+
+    it "prints error message via adapter" do
+      adapter.any_instance.expects(:print_error).with(msg, nil, {})
+      out.print_error(msg, nil)
+    end
+
+    it "prints error message via adapter with arguments" do
+      adapter.any_instance.expects(:print_error).with(msg, nil, msg_arg)
+      out.print_error(msg, nil, msg_arg)
+    end
+
+    it "prints error message with details via adapter" do
+      adapter.any_instance.expects(:print_error).with(msg, details, {})
+      out.print_error(msg, details)
+    end
+
+    it "prints error message from exception via adapter" do
+      adapter.any_instance.expects(:print_error).with(msg, nil, {})
+      out.print_error(Exception.new(msg), nil)
+    end
+  end
+
+  context "data" do
+
+    let(:item1) { {} }
+    let(:item2) { {} }
+    let(:collection) { [item1, item2] }
+
+    it "prints single resource" do
+      adapter.any_instance.expects(:print_records).with([], [{}])
+      out.print_records(definition, item1)
+    end
+
+    it "prints array of resources" do
+      adapter.any_instance.expects(:print_records).with([], collection)
+      out.print_records(definition, collection)
+    end
+
+  end
+
+  context "adapters" do
+    it "should register adapter" do
+      out_class.register_adapter(:test, HammerCLI::Output::Adapter::Silent)
+      out_class.adapters[:test].must_equal(HammerCLI::Output::Adapter::Silent)
+    end
+
+    it "should return required default adapter" do
+      out = out_class.new({}, {:default_adapter => :silent})
+      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Silent
+    end
+
+    it "should use adapter form context" do
+      out = out_class.new({:adapter => :silent})
+      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Silent
+    end
+
+    it "should prioritize adapter from the context" do
+      out = out_class.new({:adapter => :table}, {:default_adapter => :silent})
+      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Table
+    end
+
+    it "should use base adapter if the requested default was not found" do
+      out = out_class.new({}, {:default_adapter => :unknown})
+      out.adapter.must_be_instance_of HammerCLI::Output::Adapter::Base
+    end
+  end
+
+  context "formatters" do
+    it "should register formatter" do
+      formatter = HammerCLI::Output::Formatters::FieldFormatter.new
+      out_class.register_formatter(formatter, :type1, :type2)
+      out_class.formatters[:type1].must_equal([formatter])
+      out_class.formatters[:type2].must_equal([formatter])
+    end
+  end
+
+end
+

data/test/unit/settings_test.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe HammerCLI::Settings do
+
+  before :each do
+    # clean up global settings
+    HammerCLI::Settings.clear
+  end
+
+  let(:settings) { HammerCLI::Settings }
+
+  it "returns nil when nothing is loaded" do
+    settings.get(:a).must_be_nil
+    settings.get(:a, :b).must_be_nil
+  end
+
+  it "returns nil on unknown key" do
+    settings.load({:a => 1})
+    settings.get(:b).must_be_nil
+  end
+
+  it "returns correct value" do
+    settings.load({:a => 1})
+    settings.get(:a).must_equal 1
+  end
+
+  it "takes both strings and symbols" do
+    settings.load({:a => 1, 'b' => 2})
+    settings.get('a').must_equal 1
+    settings.get(:b).must_equal 2
+  end
+
+  it "finds nested settings" do
+    settings.load({:a => {:b => 1}})
+    settings.get(:a, :b).must_equal 1
+    settings.get(:a, 'b').must_equal 1
+    settings.get('a', :b).must_equal 1
+  end
+
+  it "loads all settings" do
+    settings.load({:a => 1, :b => 2})
+    settings.get(:a).must_equal 1
+    settings.get(:b).must_equal 2
+  end
+
+  it "merges 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
+    settings.get(:b).must_equal 'B'
+    settings.get(:c).must_equal 'C'
+    settings.get(:d, :e).must_equal 'E'
+    settings.get(:d, :f).must_equal 5
+  end
+
+  it "clear wipes all settings" do
+    settings.load({:a => 1, :b => 2})
+    settings.clear
+    settings.get(:a).must_be_nil
+    settings.get(:b).must_be_nil
+  end
+
+  context "load from file" do
+
+    let(:config1) do
+      config1 = Tempfile.new 'config'
+      config1 << ":host: 'https://localhost/'\n"
+      config1 << ":username: 'admin'\n"
+      config1.close
+      config1
+    end
+
+    let(:config2) do
+      config2 = Tempfile.new 'config2'
+      config2 << ":host: 'https://localhost.localdomain/'\n"
+      config2.close
+      config2
+    end
+
+    let(:config_without_creds) do
+      config_without_creds = Tempfile.new('config_without_creds')
+      config_without_creds << ":host: 'https://localhost.localdomain/'\n"
+      config_without_creds.close
+      config_without_creds
+    end
+
+    it "loads settings from file" do
+      settings.load_from_file [config2.path, config1.path]
+      settings.get(:host).must_equal 'https://localhost.localdomain/'
+      settings.get(:username).must_equal 'admin'
+    end
+
+    it "clears path history on clear invokation" do
+      settings.load_from_file [config2.path]
+      settings.clear
+      settings.path_history.must_equal []
+    end
+
+    it "store config path history" do
+      settings.load_from_file [config2.path, config1.path]
+      settings.path_history.must_equal [config1.path, config2.path]
+    end
+
+  end
+end
+

data/test/unit/test_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+require 'pathname'
+
+SimpleCov.use_merging true
+SimpleCov.start do
+  command_name 'MiniTest'
+  add_filter 'test'
+end
+SimpleCov.root Pathname.new(File.dirname(__FILE__) + "../../../")
+
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require "minitest-spec-context"
+require "mocha/setup"
+
+require 'hammer_cli'
+
+Logging.logger.root.appenders = Logging::Appenders['__test__'] || Logging::Appenders::StringIo.new('__test__')
+

data/test/unit/utils_test.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+
+describe String do
+
+  context "formatting" do
+
+    let(:str) { "AA%<a>s BB%<b>s" }
+    let(:curly_str) { "AA%{a}s BB%{b}s" }
+    let(:pos_str) { "AA%s BB%s" }
+
+    it "should not fail without expected parameters" do
+      str.format({}).must_equal 'AA BB'
+    end
+
+    it "should replace positional parameters" do
+      pos_str.format(['A', 'B']).must_equal 'AAA BBB'
+    end
+
+    it "should replace named parameters" do
+      str.format(:a => 'A', :b => 'B').must_equal 'AAA BBB'
+    end
+
+    it "should replace named parameters with string keys" do
+      str.format('a' => 'A', 'b' => 'B').must_equal 'AAA BBB'
+    end
+
+    it "should replace named parameters marked with curly brackets" do
+      curly_str.format(:a => 'A', :b => 'B').must_equal 'AAA BBB'
+    end
+
+  end
+
+end
+

data/test/unit/validator_test.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+
+# describe HammerCLI::OptionValidator do
+
+
+# end
+
+describe "constraints" do
+
+  class FakeCmd < Clamp::Command
+    def initialize
+      super("")
+      @option_a = 1
+      @option_b = 1
+      @option_c = 1
+      @option_d = nil
+      @option_e = nil
+    end
+  end
+
+  let(:cmd) {
+    FakeCmd.new
+  }
+
+  let(:option_names) { ["a", "b", "c", "d", "e"] }
+  let(:options_def) {
+    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
+
+    let(:cls) { HammerCLI::Validator::BaseConstraint }
+
+    describe "exist?" do
+      it "throws not implemented error" do
+        constraint = cls.new(options, [: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.stubs(:exist?).returns(true)
+        proc{ constraint.rejected }.must_raise HammerCLI::Validator::ValidationError
+      end
+
+      it "should raise exception with a message" do
+        constraint = cls.new(options, [])
+        constraint.stubs(:exist?).returns(true)
+        begin
+          constraint.rejected :msg => "CUSTOM MESSAGE"
+        rescue HammerCLI::Validator::ValidationError => e
+          e.message.must_equal "CUSTOM MESSAGE"
+        end
+      end
+
+      it "should return nil when exist? returns true" do
+        constraint = cls.new(options, [])
+        constraint.stubs(:exist?).returns(false)
+        constraint.rejected.must_equal nil
+      end
+    end
+
+    describe "required" do
+      it "should raise exception when exist? returns true" do
+        constraint = cls.new(options, [])
+        constraint.stubs(:exist?).returns(false)
+        proc{ constraint.required }.must_raise HammerCLI::Validator::ValidationError
+      end
+
+      it "should raise exception with a message" do
+        constraint = cls.new(options, [])
+        constraint.stubs(:exist?).returns(false)
+        begin
+          constraint.rejected :msg => "CUSTOM MESSAGE"
+        rescue HammerCLI::Validator::ValidationError => e
+          e.message.must_equal "CUSTOM MESSAGE"
+        end
+      end
+
+      it "should return nil when exist? returns true" do
+        constraint = cls.new(options, [])
+        constraint.stubs(:exist?).returns(true)
+        constraint.required.must_equal nil
+      end
+    end
+
+  end
+
+  describe HammerCLI::Validator::AllConstraint do
+
+    let(:cls) { HammerCLI::Validator::AllConstraint }
+
+    describe "exist?" do
+
+      it "should return true when no options are passed" do
+        constraint = cls.new(options, [])
+        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 false when one of the options is missing" do
+        constraint = cls.new(options, [:option_a, :option_b, :option_c, :option_d])
+        constraint.exist?.must_equal false
+      end
+    end
+
+  end
+
+  describe HammerCLI::Validator::AnyConstraint do
+
+    let(:cls) { HammerCLI::Validator::AnyConstraint }
+
+    describe "exist?" do
+
+      it "should return true when no options are passed" do
+        constraint = cls.new(options, [])
+        constraint.exist?.must_equal true
+      end
+
+      it "should return true when one of the options exist" do
+        constraint = cls.new(options, [:option_a, :option_d, :option_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.exist?.must_equal false
+      end
+    end
+
+  end
+
+
+end