hammer_cli 0.0.18 → 0.1.0

data/test/unit/options/field_filter_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+describe HammerCLI::Output::FieldFilter do
+
+  let(:fields) { [
+    Fields::Field.new(:label => "field"),
+    Fields::Collection.new(:label => "collection"),
+    Fields::Id.new(:label => "id")
+  ] }
+  let(:field_labels) { fields.map(&:label).sort }
+
+  it "lets all fields go by default" do
+    f = HammerCLI::Output::FieldFilter.new
+    f.filter(fields).map(&:label).sort.must_equal ["field", "collection", "id"].sort
+  end
+
+  it "filters fields by class" do
+    f = HammerCLI::Output::FieldFilter.new([Fields::Id])
+    f.filter(fields).map(&:label).sort.must_equal ["field", "collection"].sort
+  end
+
+  it "filters fields by superclass" do
+    f = HammerCLI::Output::FieldFilter.new([Fields::ContainerField])
+    f.filter(fields).map(&:label).sort.must_equal ["field", "id"].sort
+  end
+
+end

data/test/unit/options/normalizers_test.rb

@@ -122,6 +122,33 @@ describe HammerCLI::Options::Normalizers do
     end
   end
 
+  describe 'json input' do
+    let(:formatter) { HammerCLI::Options::Normalizers::JSONInput.new }
+
+    it "should return a hash on valid json file" do
+      file = File.join(File.dirname(__FILE__), '../fixtures/json_input/valid.json')
+      formatter.format(file).must_equal({ "units" => [ { "name" => "zip", "version" => "10.0" },
+                                        { "name" => "zap", "version" => "9.0" }] })
+    end
+
+    it "should raise exception on invalid json file contents" do
+      file = File.join(File.dirname(__FILE__), '../fixtures/json_input/invalid.json')
+      proc { formatter.format(file) }.must_raise ArgumentError
+    end
+
+    it "should return a hash on valid json string" do
+      json_string = '{ "units":[{ "name":"zip", "version":"10.0" }, { "name":"zap", "version":"9.0" }] }'
+      formatter.format(json_string).must_equal({ "units" => [ { "name" => "zip", "version" => "10.0" },
+                                                              { "name" => "zap", "version" => "9.0" }] })
+    end
+
+    it "should raise exception on invalid json string" do
+      json_string = "{ units:[{ name:zip, version:10.0 }, { name:zap, version:9.0 }] }"
+      proc { formatter.format(json_string) }.must_raise ArgumentError
+    end
+
+  end
+
   describe 'enum' do
 
     let(:formatter) { HammerCLI::Options::Normalizers::Enum.new ['a', 'b'] }
@@ -144,5 +171,31 @@ describe HammerCLI::Options::Normalizers do
 
   end
 
+  describe 'datetime' do
+
+    let(:formatter) { HammerCLI::Options::Normalizers::DateTime.new }
+
+    it "should raise argument error when the value is nil" do
+      proc { formatter.format(nil) }.must_raise ArgumentError
+    end
+
+    it "should raise argument error when the value is not a date" do
+      proc { formatter.format("not a date") }.must_raise ArgumentError
+    end
+
+    it "should accept and parse iso8601" do
+      formatter.format("1986-01-01T08:30:20").must_equal("1986-01-01T08:30:20+00:00")
+    end
+
+    it "should accept and parse YYYY-MM-DD HH:MM:SS" do
+      formatter.format("1986-01-01 08:30:20").must_equal("1986-01-01T08:30:20+00:00")
+    end
+
+    it "should accept and parse YYYY/MM/DD HH:MM:SS" do
+      formatter.format("1986/01/01 08:30:20").must_equal("1986-01-01T08:30:20+00:00")
+    end
+
+  end
+
 end
 

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

@@ -2,24 +2,176 @@ require File.join(File.dirname(__FILE__), '../../test_helper')
 
 describe HammerCLI::Output::Adapter::Base do
 
-  let(:adapter) { HammerCLI::Output::Adapter::Base.new }
+  let(:context) {{}}
+  let(:adapter) { HammerCLI::Output::Adapter::Base.new(context, HammerCLI::Output::Output.formatters) }
 
   context "print_collection" do
 
-    let(:field_name) { Fields::DataField.new(:path => [:name], :label => "Name") }
-    let(:fields) {
-      [field_name]
-    }
+    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(:contacts)      { Fields::Collection.new(:path => [:contacts], :label => "Contacts") }
+    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 [{
-      :name => "John Doe"
+      :id => 112,
+      :name => "John",
+      :surname => "Doe",
+      :address => {
+        :city => "New York"
+      },
+      :contacts => [
+        {
+          :desc => 'personal email',
+          :contact => 'john.doe@doughnut.com'
+        },
+        {
+          :desc => 'telephone',
+          :contact => '123456789'
+        }
+      ],
+      :params => [
+        {
+          :name => 'weight',
+          :value => '83'
+        },
+        {
+          :name => 'size',
+          :value => '32'
+        }
+      ]
     }]}
 
-    it "should print field name" do
-      proc { adapter.print_collection(fields, data) }.must_output(/.*Name[ ]*:.*/, "")
+    it "should print one field" do
+      fields = [name]
+      expected_output = [
+        "Name: John",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "doesn't print label when it's nil" do
+      fields = [unlabeled]
+      expected_output = [
+        "John",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "aligns multiple fields" do
+      fields = [name, surname, unlabeled]
+      expected_output = [
+        "Name:    John",
+        "Surname: Doe",
+        "John",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "should field with nested data" do
+      fields = [address_city]
+      expected_output = [
+        "City: New York",
+        "\n"
+      ].join("\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]
+
+      expected_output = [
+        "Address: ",
+        "    City: New York",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+
+    it "should print collection" do
+      contacts.output_definition.append [desc, contact]
+      fields = [contacts]
+
+      expected_output = [
+        "Contacts: ",
+        " 1) Description: personal email",
+        "    Contact:     john.doe@doughnut.com",
+        " 2) Description: telephone",
+        "    Contact:     123456789",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "hides ids by default" do
+      fields = [id, name]
+      expected_output = [
+        "Name: John",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+    end
+
+    it "skips blank values" do
+      fields = [name, blank]
+      expected_output = [
+        "Name: John",
+        "\n"
+      ].join("\n")
+
+      proc { adapter.print_collection(fields, data) }.must_output(expected_output)
     end
 
-    it "should print field value" do
-      proc { adapter.print_collection(fields, data) }.must_output(/.*John Doe.*/, "")
+    it "should print key -> value" do
+      params_collection.output_definition.append [param]
+      fields = [params_collection]
+
+      expected_output = [
+        "Parameters: ",
+        " 1) weight => 83",
+        " 2) size => 32",
+        "\n"
+      ].join("\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]
+        expected_output = [
+          "Id:   112",
+          "Name: John",
+          "\n"
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      end
+
     end
 
   end

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

@@ -6,8 +6,8 @@ describe HammerCLI::Output::Adapter::CSValues do
 
   context "print_collection" 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(:field_name) { Fields::Field.new(:path => [:name], :label => "Name") }
+    let(:field_started_at) { Fields::Field.new(:path => [:started_at], :label => "Started At") }
     let(:fields) {
       [field_name, field_started_at]
     }
@@ -52,10 +52,23 @@ describe HammerCLI::Output::Adapter::CSValues do
           end
         end
 
-        adapter = HammerCLI::Output::Adapter::CSValues.new({}, { :DataField => [ DotFormatter.new ]})
+        adapter = HammerCLI::Output::Adapter::CSValues.new({}, { :Field => [ DotFormatter.new ]})
         out, err = capture_io { adapter.print_collection(fields, data) }
         out.must_match(/.*-DOT-.*/)
       end
+
+      it "should not replace nil with empty string before it applies formatters" do
+        class NilFormatter < HammerCLI::Output::Formatters::FieldFormatter
+          def format(data)
+            'NIL' if data.nil?
+          end
+        end
+
+        adapter = HammerCLI::Output::Adapter::CSValues.new({}, { :Field => [ NilFormatter.new ]})
+        nil_data = HammerCLI::Output::RecordCollection.new [{ :name => nil }]
+        out, err = capture_io { adapter.print_collection([field_name], nil_data) }
+        out.must_match(/.*NIL.*/)
+      end
     end
   end
 

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

@@ -6,12 +6,20 @@ describe HammerCLI::Output::Adapter::Table do
 
   context "print_collection" do
 
-    let(:field_name) { Fields::DataField.new(:path => [:name], :label => "Name") }
+    let(:field_name) { Fields::Field.new(:path => [:fullname], :label => "Name") }
+    let(:field_firstname) { Fields::Field.new(:path => [:firstname], :label => "Firstname") }
+    let(:field_lastname) { Fields::Field.new(:path => [:lastname], :label => "Lastname") }
+
     let(:fields) {
       [field_name]
     }
+
     let(:data) { HammerCLI::Output::RecordCollection.new [{
-      :name => "John Doe"
+      :id => 1,
+      :firstname => "John",
+      :lastname => "Doe",
+      :fullname => "John Doe",
+      :long => "SomeVeryLongString"
     }]}
 
     it "should print column name " do
@@ -40,6 +48,74 @@ describe HammerCLI::Output::Adapter::Table do
       end
     end
 
+    context "column width" do
+
+      it "truncates string when it exceeds maximum width" do
+        first_field = Fields::Field.new(:path => [:long], :label => "Long", :max_width => 10)
+        fields = [first_field, field_lastname]
+
+        expected_output = [
+          "-----------|---------",
+          "LONG       | LASTNAME",
+          "-----------|---------",
+          "SomeVer... | Doe     ",
+          "-----------|---------",
+          ""
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      end
+
+      it "truncates string when it exceeds width" do
+        first_field = Fields::Field.new(:path => [:long], :label => "Long", :width => 10)
+        fields = [first_field, field_lastname]
+
+        expected_output = [
+          "-----------|---------",
+          "LONG       | LASTNAME",
+          "-----------|---------",
+          "SomeVer... | Doe     ",
+          "-----------|---------",
+          ""
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, 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]
+
+        expected_output = [
+          "--------------------------|---------",
+          "LONG                      | LASTNAME",
+          "--------------------------|---------",
+          "SomeVeryLongString        | Doe     ",
+          "--------------------------|---------",
+          ""
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, 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]
+
+        expected_output = [
+          "--------------------------|---------",
+          "LONG                      | LASTNAME",
+          "--------------------------|---------",
+          "SomeVeryLongString        | Doe     ",
+          "--------------------------|---------",
+          ""
+        ].join("\n")
+
+        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
+      end
+
+    end
+
     context "formatters" do
       it "should apply formatters" do
         class DotFormatter < HammerCLI::Output::Formatters::FieldFormatter
@@ -48,28 +124,36 @@ describe HammerCLI::Output::Adapter::Table do
           end
         end
 
-        adapter = HammerCLI::Output::Adapter::Table.new({}, { :DataField => [ DotFormatter.new ]})
+        adapter = HammerCLI::Output::Adapter::Table.new({}, { :Field => [ DotFormatter.new ]})
         out, err = capture_io { adapter.print_collection(fields, data) }
         out.must_match(/.*-DOT-.*/)
       end
     end
 
     context "sort_columns" do
-      let(:field_firstname) { Fields::DataField.new(:path => [:firstname], :label => "Firstname") }
-      let(:field_lastname) { Fields::DataField.new(:path => [:lastname], :label => "Lastname") }
       let(:fields) {
         [field_firstname, field_lastname]
       }
-      let(:data) { HammerCLI::Output::RecordCollection.new [{
-        :firstname => "John",
-        :lastname => "Doe"
-      }]}
 
       it "should sort output" do
-        TablePrint::Printer.any_instance.stubs(:table_print).returns(
-          "LASTNAME | FIRSTNAME\n---------|----------\nDoe      | John     \n")
-        proc { adapter.print_collection(fields, data) }.must_output(
-          "----------|---------\nFIRSTNAME | LASTNAME\n----------|---------\nJohn      | Doe     \n----------|---------\n")
+
+        table_print_output = [
+          "LASTNAME | FIRSTNAME",
+          "---------|----------",
+          "Doe      | John     "
+        ].join("\n")
+
+        expected_output = [
+          "----------|---------",
+          "FIRSTNAME | LASTNAME",
+          "----------|---------",
+          "John      | Doe     ",
+          "----------|---------",
+          ""
+        ].join("\n")
+
+        TablePrint::Printer.any_instance.stubs(:table_print).returns(table_print_output)
+        proc { adapter.print_collection(fields, data) }.must_output(expected_output)
       end
     end
   end