hammer_cli 0.1.3 → 0.1.4

data/test/unit/modules_test.rb

@@ -28,7 +28,7 @@ describe HammerCLI::Modules do
 
   describe "names" do
     it "must return list of modules" do
-      HammerCLI::Modules.names.sort.must_equal ["hammer_cli_tom", "hammer_cli_jerry"].sort
+      HammerCLI::Modules.names.must_equal ["hammer_cli_jerry", "hammer_cli_tom"]
     end
 
     it "must return empty array by default" do
@@ -42,8 +42,9 @@ describe HammerCLI::Modules do
         :tom => {},
         :modules => ['hammer_cli_tom', 'hammer_cli_jerry'],
       })
-      HammerCLI::Modules.names.sort.must_equal ["hammer_cli_tom", "hammer_cli_jerry"].sort
+      HammerCLI::Modules.names.must_equal ["hammer_cli_jerry", "hammer_cli_tom"]
     end
+
   end
 
   describe "find by name" do
@@ -68,6 +69,16 @@ describe HammerCLI::Modules do
       HammerCLI::Modules.load_all
     end
 
+    it "must detect dependency on disabled module" do
+      HammerCLI::Settings.clear
+      HammerCLI::Settings.load({
+        :tom => { :enable_module => false },
+        :jerry => { :enable_module => true },
+      })
+      HammerCLI::Modules.stubs(:load).returns(nil)
+      HammerCLI::Modules.stubs(:loaded_modules).returns(['hammer_cli_jerry', 'hammer_cli_tom'])
+      proc { HammerCLI::Modules.load_all }.must_raise HammerCLI::ModuleDisabledButRequired
+    end
   end
 
   describe "load a module" do

data/test/unit/options/matcher_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+
+describe HammerCLI::Options::Matcher do
+
+  let(:option_a1) { Clamp::Option::Definition.new("--opt_a1", "OPT_A", "some option") }
+  let(:option_a2) { Clamp::Option::Definition.new("--opt_a2", "OPT_A", "some option") }
+  let(:option_a3) { Clamp::Option::Definition.new("--opt_a3", "OPT_A", "some option") }
+  let(:option_b1) { Clamp::Option::Definition.new("--opt_b1", "OPT_B", "some option") }
+
+  it "tests value" do
+    matcher = HammerCLI::Options::Matcher.new(
+      :long_switch => '--opt_a1'
+    )
+    matcher.matches?(option_a1).must_equal true
+    matcher.matches?(option_a2).must_equal false
+  end
+
+  it "tests regex" do
+    matcher = HammerCLI::Options::Matcher.new(
+      :long_switch => /--opt_a.*/
+    )
+    matcher.matches?(option_a1).must_equal true
+    matcher.matches?(option_a2).must_equal true
+    matcher.matches?(option_b1).must_equal false
+  end
+
+  it "tests multiple conditions" do
+    matcher = HammerCLI::Options::Matcher.new(
+      :long_switch => /--opt_.1/,
+      :type => 'OPT_A'
+    )
+    matcher.matches?(option_a1).must_equal true
+    matcher.matches?(option_a2).must_equal false
+    matcher.matches?(option_a3).must_equal false
+    matcher.matches?(option_b1).must_equal false
+  end
+
+  it "tests multiple values or regexes" do
+    matcher = HammerCLI::Options::Matcher.new(
+      :long_switch => [/--opt_.1/, "--opt_a3"]
+    )
+    matcher.matches?(option_a1).must_equal true
+    matcher.matches?(option_a2).must_equal false
+    matcher.matches?(option_a3).must_equal true
+    matcher.matches?(option_b1).must_equal true
+  end
+
+  it "tests nil for unknown methods" do
+    matcher = HammerCLI::Options::Matcher.new(
+      :unknown_method => "some value"
+    )
+    matcher.matches?(option_a1).must_equal false
+
+    matcher = HammerCLI::Options::Matcher.new(
+      :unknown_method => nil
+    )
+    matcher.matches?(option_a1).must_equal true
+  end
+
+end

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

@@ -0,0 +1,214 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+
+describe HammerCLI::Output::Adapter::Json do
+
+  let(:context) {{}}
+  let(:adapter) { HammerCLI::Output::Adapter::Json.new(context, HammerCLI::Output::Output.formatters) }
+
+  context "print_collection" do
+
+    let(:id)            { Fields::Id.new(:path => [:id], :label => "Id") }
+    let(:name)          { Fields::Field.new(:path => [:name], :label => "Name") }
+    let(:unlabeled)     { Fields::Field.new(:path => [:name]) }
+    let(:surname)       { Fields::Field.new(:path => [:surname], :label => "Surname") }
+    let(:address_city)  { Fields::Field.new(:path => [:address, :city], :label => "City") }
+    let(:city)          { Fields::Field.new(:path => [:city], :label => "City") }
+    let(:label_address) { Fields::Label.new(:path => [:address], :label => "Address") }
+    let(:num_contacts)  { Fields::Collection.new(:path => [:contacts], :label => "Contacts") }
+    let(:num_one_contact)  { Fields::Collection.new(:path => [:one_contact], :label => "Contacts") }
+    let(:contacts)      { Fields::Collection.new(:path => [:contacts], :label => "Contacts", :numbered => false) }
+    let(:one_contact)      { Fields::Collection.new(:path => [:one_contact], :label => "Contacts", :numbered => false) }
+    let(:desc)          { Fields::Field.new(:path => [:desc], :label => "Description") }
+    let(:contact)       { Fields::Field.new(:path => [:contact], :label => "Contact") }
+    let(:params)        { Fields::KeyValueList.new(:path => [:params], :label => "Parameters") }
+    let(:params_collection) { Fields::Collection.new(:path => [:params], :label => "Parameters") }
+    let(:param)             { Fields::KeyValue.new(:path => nil, :label => nil) }
+    let(:blank)             { Fields::Field.new(:path => [:blank], :label => "Blank", :hide_blank => true) }
+
+    let(:data) { HammerCLI::Output::RecordCollection.new [{
+      :id => 112,
+      :name => "John",
+      :surname => "Doe",
+      :address => {
+        :city => "New York"
+      },
+      :contacts => [
+        {
+          :desc => 'personal email',
+          :contact => 'john.doe@doughnut.com'
+        },
+        {
+          :desc => 'telephone',
+          :contact => '123456789'
+        }
+      ],
+      :one_contact => [
+        {
+          :desc => 'personal email',
+          :contact => 'john.doe@doughnut.com'
+        }
+      ],
+      :params => [
+        {
+          :name => 'weight',
+          :value => '83'
+        },
+        {
+          :name => 'size',
+          :value => '32'
+        }
+      ]
+    }]}
+
+    it "should print one field" do
+      fields = [name]
+      expected_output = JSON.pretty_generate([{ 'Name' => 'John' }]) + "\n"
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should field with nested data" do
+      fields = [address_city]
+      expected_output = JSON.pretty_generate([{ 'City' => 'New York' }]) + "\n"
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print labeled fields" do
+      label_address.output_definition.append [city]
+      fields = [label_address]
+      hash = [{
+                'Address' => {
+                  'City' => 'New York'
+                }
+              }]
+      expected_output = JSON.pretty_generate(hash) + "\n"
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print collection" do
+      num_contacts.output_definition.append [desc, contact]
+      fields = [num_contacts]
+      hash = [{
+                'Contacts' => {
+                  1 => {
+                    'Description' => 'personal email',
+                    'Contact' => 'john.doe@doughnut.com'
+                  },
+                  2 => {
+                    'Description' => 'telephone',
+                    'Contact' => '123456789'
+                  }
+                }
+              }]
+
+      expected_output = JSON.pretty_generate(hash) + "\n"
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print collection with one element" do
+      num_one_contact.output_definition.append [desc, contact]
+      fields = [num_one_contact]
+      hash = [{
+                'Contacts' => {
+                  1 => {
+                    'Description' => 'personal email',
+                    'Contact' => 'john.doe@doughnut.com'
+                  }
+                }
+              }]
+
+      expected_output = JSON.pretty_generate(hash) + "\n"
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print unnumbered collection" do
+      contacts.output_definition.append [desc, contact]
+      fields = [contacts]
+      hash = [{
+                'Contacts' => [
+                               {
+                                 'Description' => 'personal email',
+                                 'Contact' => 'john.doe@doughnut.com'
+                               },
+                               {
+                                 'Description' => 'telephone',
+                                 'Contact' => '123456789'
+                               }]
+              }]
+
+      expected_output = JSON.pretty_generate(hash) + "\n"
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print unnumbered collection with one element" do
+      one_contact.output_definition.append [desc, contact]
+      fields = [one_contact]
+      hash = [{
+                'Contacts' => [
+                               {
+                                 'Description' => 'personal email',
+                                 'Contact' => 'john.doe@doughnut.com'
+                               }]
+              }]
+
+      expected_output = JSON.pretty_generate(hash) + "\n"
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+
+    it "hides ids by default" do
+      fields = [id, name]
+      hash = [{'Name' => 'John'}]
+      expected_output = JSON.pretty_generate(hash) + "\n"
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "skips blank values" do
+      fields = [name, blank]
+      hash = [{'Name' => 'John'}]
+      expected_output = JSON.pretty_generate(hash) + "\n"
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print key -> value" do
+      params_collection.output_definition.append [param]
+      fields = [params_collection]
+
+      hash = [{
+                'Parameters' => {
+                  1 => {
+                    :name => 'weight',
+                    :value => '83'
+                  },
+                  2 => {
+                    :name => 'size',
+                    :value => '32'
+                  }
+                }
+              }]
+      expected_output = JSON.pretty_generate(hash) + "\n"
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    context "show ids" do
+
+      let(:context) { {:show_ids => true} }
+
+      it "shows ids if it's required in the context" do
+        fields = [id, name]
+        hash = [{
+                  'Id' => 112,
+                  'Name' => 'John'
+                }]
+        expected_output = JSON.pretty_generate(hash) + "\n"
+        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      end
+
+    end
+
+  end
+
+end

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

@@ -23,6 +23,8 @@ describe HammerCLI::Output::Adapter::Table do
       :long => "SomeVeryLongString"
     }]}
 
+    let(:empty_data) { HammerCLI::Output::RecordCollection.new [] }
+
     it "should print column name " do
       proc { adapter.print_collection(fields, data) }.must_output(/.*NAME.*/, "")
     end
@@ -42,11 +44,32 @@ describe HammerCLI::Output::Adapter::Table do
         out.wont_match(/.*ID.*/)
       end
 
+      it "should ommit column of type Id by default but no data" do
+        expected_output = [
+                           "----",
+                           "NAME",
+                           "----",
+                           ""
+                          ].join("\n")
+        proc { adapter.print_collection(fields, empty_data) }.must_output(expected_output)
+      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_collection(fields, data) }
         out.must_match(/.*ID.*/)
       end
+
+      it "should print column of type ID when --show-ids is set but no data" do
+        expected_output = [
+                           "-----|---",
+                           "NAME | ID",
+                           "-----|---",
+                           "",
+                          ].join("\n")
+        adapter = HammerCLI::Output::Adapter::Table.new( { :show_ids => true } )
+        proc { adapter.print_collection(fields, empty_data) }.must_output(expected_output)
+      end
     end
 
     context "column width" do
@@ -83,6 +106,19 @@ describe HammerCLI::Output::Adapter::Table do
         proc { adapter.print_collection(fields, data) }.must_output(expected_output)
       end
 
+    it "sets width to the longest column name when no data" do
+      first_field = Fields::Field.new(:path => [:long], :label => "VeryLongTableHeaderName")
+      fields = [first_field, field_lastname]
+
+      expected_output = [
+                         "------------------------|---------",
+                         "VERYLONGTABLEHEADERNAME | LASTNAME",
+                         "------------------------|---------",
+                         ""
+                        ].join("\n")
+      proc { adapter.print_collection(fields, empty_data) }.must_output(expected_output)
+    end
+
       it "sets certain width" do
         first_field = Fields::Field.new(:path => [:long], :label => "Long", :width => 25)
         fields = [first_field, field_lastname]
@@ -99,6 +135,21 @@ describe HammerCLI::Output::Adapter::Table do
         proc { adapter.print_collection(fields, data) }.must_output(expected_output)
       end
 
+      it "sets certain width when no data" do
+        first_field = Fields::Field.new(:path => [:long], :label => "Long", :width => 25)
+        fields = [first_field, field_lastname]
+
+        expected_output = [
+          "--------------------------|---------",
+          "LONG                      | LASTNAME",
+          "--------------------------|---------",
+          ""
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, empty_data) }.must_output(expected_output)
+      end
+
+
       it "gives preference to width over maximal width" do
         first_field = Fields::Field.new(:path => [:long], :label => "Long", :width => 25, :max_width => 10)
         fields = [first_field, field_lastname]
@@ -115,6 +166,21 @@ describe HammerCLI::Output::Adapter::Table do
         proc { adapter.print_collection(fields, data) }.must_output(expected_output)
       end
 
+      it "gives preference to width over maximal width when no data" do
+        first_field = Fields::Field.new(:path => [:long], :label => "Long", :width => 25, :max_width => 10)
+        fields = [first_field, field_lastname]
+
+        expected_output = [
+          "--------------------------|---------",
+          "LONG                      | LASTNAME",
+          "--------------------------|---------",
+          ""
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, empty_data) }.must_output(expected_output)
+      end
+
+
     end
 
     context "formatters" do

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

@@ -0,0 +1,213 @@
+require File.join(File.dirname(__FILE__), '../../test_helper')
+require 'yaml'
+describe HammerCLI::Output::Adapter::Yaml do
+
+  let(:context) {{}}
+  let(:adapter) { HammerCLI::Output::Adapter::Yaml.new(context, HammerCLI::Output::Output.formatters) }
+
+  context "print_collection" do
+
+    let(:id)            { Fields::Id.new(:path => [:id], :label => "Id") }
+    let(:name)          { Fields::Field.new(:path => [:name], :label => "Name") }
+    let(:unlabeled)     { Fields::Field.new(:path => [:name]) }
+    let(:surname)       { Fields::Field.new(:path => [:surname], :label => "Surname") }
+    let(:address_city)  { Fields::Field.new(:path => [:address, :city], :label => "City") }
+    let(:city)          { Fields::Field.new(:path => [:city], :label => "City") }
+    let(:label_address) { Fields::Label.new(:path => [:address], :label => "Address") }
+    let(:num_contacts)  { Fields::Collection.new(:path => [:contacts], :label => "Contacts") }
+    let(:num_one_contact)  { Fields::Collection.new(:path => [:one_contact], :label => "Contacts") }
+    let(:contacts)      { Fields::Collection.new(:path => [:contacts], :label => "Contacts", :numbered => false) }
+    let(:one_contact)      { Fields::Collection.new(:path => [:one_contact], :label => "Contacts", :numbered => false) }
+    let(:desc)          { Fields::Field.new(:path => [:desc], :label => "Description") }
+    let(:contact)       { Fields::Field.new(:path => [:contact], :label => "Contact") }
+    let(:params)        { Fields::KeyValueList.new(:path => [:params], :label => "Parameters") }
+    let(:params_collection) { Fields::Collection.new(:path => [:params], :label => "Parameters") }
+    let(:param)             { Fields::KeyValue.new(:path => nil, :label => nil) }
+    let(:blank)             { Fields::Field.new(:path => [:blank], :label => "Blank", :hide_blank => true) }
+
+    let(:data) { HammerCLI::Output::RecordCollection.new [{
+      :id => 112,
+      :name => "John",
+      :surname => "Doe",
+      :address => {
+        :city => "New York"
+      },
+      :contacts => [
+        {
+          :desc => 'personal email',
+          :contact => 'john.doe@doughnut.com'
+        },
+        {
+          :desc => 'telephone',
+          :contact => '123456789'
+        }
+      ],
+      :one_contact => [
+        {
+          :desc => 'personal email',
+          :contact => 'john.doe@doughnut.com'
+        }
+      ],
+      :params => [
+        {
+          :name => 'weight',
+          :value => '83'
+        },
+        {
+          :name => 'size',
+          :value => '32'
+        }
+      ]
+    }]}
+
+    it "should print one field" do
+      fields = [name]
+      expected_output = YAML.dump([{ 'Name' => 'John' }])
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should field with nested data" do
+      fields = [address_city]
+      expected_output = YAML.dump([{ 'City' => 'New York' }])
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print labeled fields" do
+      label_address.output_definition.append [city]
+      fields = [label_address]
+      hash = [{
+                'Address' => {
+                  'City' => 'New York'
+                }
+              }]
+      expected_output = YAML.dump(hash)
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print collection" do
+      num_contacts.output_definition.append [desc, contact]
+      fields = [num_contacts]
+      hash = [{
+                'Contacts' => {
+                  1 => {
+                    'Description' => 'personal email',
+                    'Contact' => 'john.doe@doughnut.com'
+                  },
+                  2 => {
+                    'Description' => 'telephone',
+                    'Contact' => '123456789'
+                  }
+                }
+              }]
+
+      expected_output = YAML.dump(hash)
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print collection with one element" do
+      num_one_contact.output_definition.append [desc, contact]
+      fields = [num_one_contact]
+      hash = [{
+                'Contacts' => {
+                  1 => {
+                    'Description' => 'personal email',
+                    'Contact' => 'john.doe@doughnut.com'
+                  }
+                }
+              }]
+
+      expected_output = YAML.dump(hash)
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print unnumbered collection" do
+      contacts.output_definition.append [desc, contact]
+      fields = [contacts]
+      hash = [{
+                'Contacts' => [
+                               {
+                                 'Description' => 'personal email',
+                                 'Contact' => 'john.doe@doughnut.com'
+                               },
+                               {
+                                 'Description' => 'telephone',
+                                 'Contact' => '123456789'
+                               }]
+              }]
+
+      expected_output = YAML.dump(hash)
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print unnumbered collection with one element" do
+      one_contact.output_definition.append [desc, contact]
+      fields = [one_contact]
+      hash = [{
+                'Contacts' => [
+                               {
+                                 'Description' => 'personal email',
+                                 'Contact' => 'john.doe@doughnut.com'
+                               }]
+              }]
+
+      expected_output = YAML.dump(hash)
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+
+    it "hides ids by default" do
+      fields = [id, name]
+      hash = [{'Name' => 'John'}]
+      expected_output = YAML.dump(hash)
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "skips blank values" do
+      fields = [name, blank]
+      hash = [{'Name' => 'John'}]
+      expected_output = YAML.dump(hash)
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should print key -> value" do
+      params_collection.output_definition.append [param]
+      fields = [params_collection]
+
+      hash = [{
+                'Parameters' => {
+                  1 => {
+                    :name => 'weight',
+                    :value => '83'
+                  },
+                  2 => {
+                    :name => 'size',
+                    :value => '32'
+                  }
+                }
+              }]
+      expected_output = YAML.dump(hash)
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    context "show ids" do
+
+      let(:context) { {:show_ids => true} }
+
+      it "shows ids if it's required in the context" do
+        fields = [id, name]
+        hash = [{
+                  'Id' => 112,
+                  'Name' => 'John'
+                }]
+        expected_output = YAML.dump(hash)
+        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      end
+
+    end
+
+  end
+
+end