wavefront-cli 2.18.0 → 3.0.0

data/spec/.rubocop.yml

@@ -17,3 +17,6 @@ Metrics/AbcSize:
 
 Metrics/ClassLength:
   Max: 300
+
+Metrics/CyclomaticComplexity:
+  Max: 10

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'webmock/minitest'
 require 'spy/integration'
 require 'inifile'
@@ -76,7 +77,7 @@ CANNED_RESPONSE = DummyResponse.new
 # @param call [Hash]
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/PerceivedComplexity
-def cmd_to_call(word, args, call, sdk_class = nil)
+def cmd_to_call(word, args, call, sdk_class = nil, extra_method = nil)
   headers = { 'Accept':          /.*/,
               'Accept-Encoding': /.*/,
               'Authorization':  'Bearer 0123456789-ABCDEF',
@@ -114,6 +115,18 @@ def cmd_to_call(word, args, call, sdk_class = nil)
           end
 
           require "wavefront-sdk/#{sdk_class.name.split('::').last.downcase}"
+          # This lets us mock out methods which happen after the
+          # thing we're interested in. For instance when you
+          # favourite a dashboard, the CLI calls do_favs to display
+          # the new favourite list, sending another API call, which
+          # has been tested elsewhere.
+          #
+          if extra_method
+            Spy.on_instance_method(
+              Object.const_get(extra_method.first), extra_method.last
+            ).and_return(true)
+          end
+
           Spy.on_instance_method(
             Object.const_get('Wavefront::ApiCaller'), :respond
           ).and_return(CANNED_RESPONSE)
@@ -309,6 +322,36 @@ def load_raw_query_response
              symbolize_names: true)
 end
 
+# We keep a bunch of Wavefront API responses as text files alongside
+# canned responses in various formats. This class groups helpers for
+# doing that.
+#
+class OutputTester
+  # @param file [String] filename to load
+  # @param only_items [Bool] true for the items hash, false for the
+  #   whole loadedobject
+  # @return [Object] canned raw responses used to test outputs
+  #
+  def load_input(file, only_items = true)
+    ret = JSON.parse(IO.read(RES_DIR + 'display' + file),
+                     symbolize_names: true)
+    only_items ? ret[:items] : ret
+  end
+
+  # @param file [String] file to load
+  # @return [String]
+  #
+  def load_expected(file)
+    IO.read(RES_DIR + 'display' + file)
+  end
+
+  def in_and_out(input, expected, only_items = true)
+    [load_input(input, only_items), load_expected(expected)]
+  end
+end
+
+OUTPUT_TESTER = OutputTester.new
+
 # stdlib extensions
 #
 class Hash
@@ -318,3 +361,40 @@ class Hash
     Marshal.load(Marshal.dump(self))
   end
 end
+
+require 'wavefront-sdk/core/response'
+require_relative '../lib/wavefront-cli/base'
+
+# For the given command word, loads up a canned API response and
+# feeds it in to the appropriate display class, running the given
+# method and returning standard out and standard error.
+#
+# @param word [String] command word, e.g. 'alert'
+# @param method [Symbol] display method to run, e.g. :do_list
+# @param klass [Class, Nil] CLI class. Worked out from the command
+#   word in most cases, but must be overriden for two-word things.
+# @return [Array] [stdout, stderr]
+#
+def command_output(word, method, klass = nil, infile = nil)
+  infile ||= "#{word}-list.json"
+  json = IO.read(RES_DIR + 'responses' + infile)
+  resp = Wavefront::Response.new(json, 200)
+  klass ||= Object.const_get(format('WavefrontCli::%s', word.capitalize))
+  klass = klass.new(format: :human)
+
+  capture_io { klass.display(resp, method) }
+end
+
+def test_list_output(word, klass = nil)
+  it 'tests terse output' do
+    out, err = command_output(word, :do_list_brief, klass)
+    refute_empty(out)
+    assert_empty(err)
+  end
+
+  it 'tests long output' do
+    out, err = command_output(word, :do_list_long, klass)
+    refute_empty(out)
+    assert_empty(err)
+  end
+end

data/spec/wavefront-cli/alert_spec.rb

@@ -89,4 +89,5 @@ describe "#{word} command" do
   cmd_to_call(word, 'queries', path: "/api/v2/#{word}?limit=999&offset=0")
   tag_tests(word, id, bad_id)
   noop_tests(word, id, true)
+  test_list_output(word)
 end

data/spec/wavefront-cli/cloudintegration_spec.rb

@@ -38,4 +38,5 @@ describe 'cloudintegration command' do
   invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",
                      "undelete #{bad_id}", "disable #{bad_id}",
                      "enable #{bad_id}"])
+  test_list_output(word, k)
 end

data/spec/wavefront-cli/dashboard_spec.rb

@@ -7,6 +7,28 @@ word = 'dashboard'
 require_relative '../spec_helper'
 require_relative "../../lib/wavefront-cli/#{word}"
 
+# Method tests. CLI tests follow
+#
+class WavefrontCliDashboardTest < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    @wf = WavefrontCli::Dashboard.new({})
+  end
+
+  def test_user_lists
+    assert_equal({ modify: [],
+                   view: [{ name: 'a@bc.com', id: 'a@bc.com' },
+                          { name: 'x@yz.com', id: 'x@yz.com' }] },
+                 wf.user_lists(:view, %w[a@bc.com x@yz.com]))
+
+    assert_equal({ view: [],
+                   modify: [{ name: 'a@bc.com', id: 'a@bc.com' },
+                            { name: 'x@yz.com', id: 'x@yz.com' }] },
+                 wf.user_lists(:modify, %w[a@bc.com x@yz.com]))
+  end
+end
+
 describe "#{word} command" do
   missing_creds(word, ['list', "describe #{id}", "delete #{id}",
                        "undelete #{id}", "history #{id}"])
@@ -39,14 +61,35 @@ describe "#{word} command" do
                                   matchingMethod: 'EXACT' }],
                         sort: { field: 'id', ascending: true } },
               headers: JSON_POST_HEADERS)
+  cmd_to_call(word,
+              'favs',
+              method: :post,
+              path:   "/api/v2/search/#{word}",
+              body:   { limit:  999,
+                        offset: 0,
+                        query:  [{ key:             'favorite',
+                                   value:           'true',
+                                   matchingMethod: 'EXACT' }],
+                        sort:   { field:     'id',
+                                  ascending: true } }.to_json)
+
+  cmd_to_call(word,
+              "fav #{id}",
+              { method: :post,
+                path:   "/api/v2/#{word}/#{id}/favorite" },
+              nil,
+              ['WavefrontCli::Dashboard', :do_favs])
 
-  cmd_to_call(word, "fav #{id}",
-              method: :post, path: "/api/v2/#{word}/#{id}/favorite")
-  cmd_to_call(word, "unfav #{id}",
-              method: :post, path: "/api/v2/#{word}/#{id}/unfavorite")
+  cmd_to_call(word,
+              "unfav #{id}",
+              { method: :post,
+                path:   "/api/v2/#{word}/#{id}/unfavorite" },
+              nil,
+              ['WavefrontCli::Dashboard', :do_favs])
   cmd_to_call(word, "undelete #{id}",
               method: :post, path: "/api/v2/#{word}/#{id}/undelete")
   invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",
                      "undelete #{bad_id}"])
   tag_tests(word, id, bad_id)
+  test_list_output(word)
 end

data/spec/wavefront-cli/derivedmetric_spec.rb

@@ -77,4 +77,5 @@ describe "#{word} command" do
                         tags:                   %w[tag1 tag2],
                         query:                  'ts(series)' },
                 headers: JSON_POST_HEADERS }, k)
+  test_list_output(word, k)
 end

data/spec/wavefront-cli/display/base_spec.rb

@@ -21,17 +21,24 @@ class WavefrontDisplayBaseTest < MiniTest::Test
     @wff = WavefrontDisplay::Base.new(S_DATA, S_OPTIONS.merge(fields: 'id'))
   end
 
-  def test_put_id_first
-    assert_equal(wf.put_id_first(k1: 1, k2: 2, id: 3, k4: 4),
-                 id: 3, k1: 1, k2: 2, k4: 4)
-    assert_equal(wf.put_id_first(id: 3, k1: 1, k2: 2, k4: 4),
-                 id: 3, k1: 1, k2: 2, k4: 4)
-    assert_equal(wf.put_id_first(k2: 1, k1: 2, k4: 4),
-                 k2: 1, k1: 2, k4: 4)
+  def test_prioritise_keys
+    assert_equal({ a: 1, b: 2, c: 3, d: 4 },
+                 wf.prioritize_keys({ b: 2, c: 3, a: 1, d: 4 }, %i[a b]))
+
+    assert_equal({ id: 'my id', name: 'my name', numbers: [1, 2, 3] },
+                 wf.prioritize_keys({ name: 'my name',
+                                      numbers: [1, 2, 3],
+                                      id: 'my id' }, %i[id name]))
+
+    assert_equal({ name: 'my name', id: 'my id', numbers: [1, 2, 3] },
+                 wf.prioritize_keys({ name: 'my name',
+                                      numbers: [1, 2, 3],
+                                      id: 'my id' }, %i[name id]))
+    assert_equal([{ a: 1, b: 2, c: 3, d: 4 }, { a: 5, b: 6 }],
+                 wf.prioritize_keys([{ b: 2, c: 3, a: 1, d: 4 },
+                                     { b: 6, a: 5 }], %i[a b]))
   end
 
-  def test_run; end
-
   def test_friendly_name
     assert_equal(wf.friendly_name, 'base')
   end

data/spec/wavefront-cli/display/printer/long_spec.rb

@@ -6,135 +6,104 @@ require_relative '../../../spec_helper'
 
 # Test verbose printing stuff
 #
-class WavefrontDisplayPrinterLong < MiniTest::Test
+class TestWavefrontDisplayPrinterLong < MiniTest::Test
   attr_reader :wf
 
   def setup
     @wf = WavefrontDisplayPrinter::Long.new({})
   end
 
-  def test_mk_line_1
-    wf.instance_variable_set(:@kw, 5)
-    wf.instance_variable_set(:@indent_str, '')
-    assert_equal('     value', wf.mk_line('', 'value'))
-    assert_equal('     value', wf.mk_line(nil, 'value'))
-    assert_equal('key  value', wf.mk_line('key', 'value'))
+  def test_preened_data
+    assert_equal([{ k1: 1 }], wf.preened_data([{ k1: 1, k2: 2 }], [:k1]))
+    assert_equal([{ k1: 1, k2: 2 }], wf.preened_data([{ k1: 1, k2: 2 }]))
+    assert_equal([{}], wf.preened_data([{ k1: 1, k2: 2 }], [:k3]))
+    assert_equal([{ k1: 1, k2: 2 }], wf.preened_data([{ k1: 1, k2: 2 }],
+                                                     %i[k1 k2]))
+    assert_equal([{ k1: 1 }, { k1: 10 }],
+                 wf.preened_data([{ k1: 1, k2: 2 }, { k1: 10, k2: 12 }],
+                                 [:k1]))
+
+    assert_equal([{ 'k1' => 1 }, { 'k1' => 10 }],
+                 wf.preened_data([{ 'k1' => 1,  'k2' => 2 },
+                                  { 'k1' => 10, 'k2' => 12 }],
+                                 [:k1]))
   end
 
-  def test_mk_line_2
-    wf = WavefrontDisplayPrinter::Long.new({})
-    wf.mk_indent(2)
-    wf.instance_variable_set(:@kw, 5)
-    assert_equal('       value', wf.mk_line('', 'value'))
-    assert_equal('       value', wf.mk_line(nil, 'value'))
-    assert_equal('  key  value', wf.mk_line('key', 'value'))
+  def test_preened_value
+    assert_equal('test', wf.preened_value('test'))
+    assert_equal('test', wf.preened_value('<b>test</b>'))
+    assert_equal('test test', wf.preened_value('<b>test</b> <i>test</i>'))
   end
 
-  def test_mk_line_3
-    wf.instance_variable_set(:@kw, 7)
-    wf.instance_variable_set(:@indent_str, '  ')
-    assert_equal('  key    value', wf.mk_line('key', 'value'))
-    assert_equal('         value', wf.mk_line(nil, 'value'))
-    assert_equal('         value', wf.mk_line('', 'value'))
-    assert_equal("  key    a long string which must be\n" \
-                 '         folded once',
-                 wf.mk_line('key', 'a long string which must be ' \
-                                   'folded once', 40))
-    assert_equal("  key    a very long string whose very length\n" \
-                 "         means that the method is going to\n" \
-                 '         have to fold it twice',
-                 wf.mk_line('key', 'a very long string whose very ' \
-                            'length means that the method is going to ' \
-                            'have to fold it twice', 49))
+  def test_smart_value
+    wf1 = WavefrontDisplayPrinter::Long.new({}, nil, nil, none: false)
+    assert_equal('value', wf.smart_value('value'))
+    assert_equal('<none>', wf.smart_value(''))
+    assert_equal('', wf1.smart_value(''))
   end
 
-  def test_mk_indent
-    wf.mk_indent(2)
-    assert_equal(wf.instance_variable_get(:@indent_str), '  ')
+  def test_opts
+    pr = WavefrontDisplayPrinter::Long.new({}, {})
+    assert_equal(pr.default_opts, pr.opts)
+
+    pr = WavefrontDisplayPrinter::Long.new({}, nil, nil,
+                                           indent: 4, padding: 3)
+    assert_equal({ indent:    4,
+                   padding:   3,
+                   separator: true,
+                   none:      true }, pr.opts)
+
+    pr = WavefrontDisplayPrinter::Long.new({}, nil, nil, none: false)
+    assert_equal({ indent:    2,
+                   padding:   2,
+                   separator: true,
+                   none:      false }, pr.opts)
   end
 
-  def test_preen_fields
-    assert_equal(wf.preen_fields({ k1: 1, k2: 2 }, [:k1]), k1: 1)
-    assert_equal(wf.preen_fields(k1: 1, k2: 2), k1: 1, k2: 2)
-    assert_equal(wf.preen_fields({ k1: 1, k2: 2 }, [:k3]), {})
-    assert_equal(wf.preen_fields({ k1: 1, k2: 2 }, %i[k1 k2]),
-                 k1: 1, k2: 2)
-  end
-
-  def test_preen_value
-    assert_equal(wf.preen_value('test'), 'test')
-    assert_equal(wf.preen_value('<b>test</b>'), 'test')
-    assert_equal(wf.preen_value('<b>test</b> <i>test</i>'), 'test test')
-  end
-
-  def test_blank?
-    assert wf.blank?('')
-    assert wf.blank?([])
-    assert wf.blank?({})
-    refute wf.blank?('test')
-    refute wf.blank?(5)
-    refute wf.blank?([1, 2])
-    refute wf.blank?(a: 1)
-  end
+  def test_longest_key_col
+    input = [['short', 'short', 0],
+             ['loooooooooooong', 'long', 1],
+             ['long-ish', 'longish', 0]]
 
-  def test_parse_line_1
-    assert_nil wf.parse_line(:k, [])
-    spy = Spy.on(wf, :add_hash)
-    wf.parse_line('key', k1: 1, k2: 2)
-    assert spy.has_been_called_with?('key', k1: 1, k2: 2)
-  end
+    pr = WavefrontDisplayPrinter::Long.new({})
+    assert_equal(19, pr.longest_key_col(input))
 
-  def test_parse_line_2
-    spy = Spy.on(wf, :add_array)
-    wf.parse_line('key', [1, 2, 3, 4])
-    assert spy.has_been_called_with?('key', [1, 2, 3, 4])
-  end
+    pr = WavefrontDisplayPrinter::Long.new({}, nil, nil, indent: 4)
+    assert_equal(21, pr.longest_key_col(input))
 
-  def test_parse_line_3
-    spy = Spy.on(wf, :add_line)
-    wf.parse_line('key', 'value')
-    assert spy.has_been_called_with?('key', 'value')
+    pr = WavefrontDisplayPrinter::Long.new({}, nil, nil, padding: 5)
+    assert_equal(22, pr.longest_key_col(input))
   end
 
-  def test_add_array
-    spy = Spy.on(wf, :add_line)
-    wf.add_array('key', %w[value1 value2 value3 value4])
-    assert spy.has_been_called_with?('key', 'value1')
-    assert spy.has_been_called_with?(nil, 'value2')
-    assert spy.has_been_called_with?(nil, 'value3')
-    assert spy.has_been_called_with?(nil, 'value4')
-  end
+  def test_to_s
+    assert_equal("today\n  weather   sunny\n  day       Tuesday",
+                 WavefrontDisplayPrinter::Long.new(
+                   today: { weather: 'sunny', day: :Tuesday }
+                 ).to_s)
 
-  def test_add_hash_1
-    hash = { sk1: 'value1', sk2: 'value2' }
-    wf.instance_variable_set(:@kw, 10)
-    wf.instance_variable_set(:@indent_step, 2)
-    tc_spy = Spy.on(wf, :_two_columns)
-    hr_spy = Spy.on(wf, :add_rule)
-    wf.add_hash('key', hash)
-    assert tc_spy.has_been_called_with?([hash], 6)
-    refute hr_spy.has_been_called?
+    assert_equal("key1   val1\nkey2   val2",
+                 WavefrontDisplayPrinter::Long.new(
+                   key1: 'val1', key2: 'val2'
+                 ).to_s)
   end
 
-  def test_add_hash_2
-    hash = { sk1: 'value1', sk2: 'value2' }
-    wf.instance_variable_set(:@kw, 10)
-    wf.instance_variable_set(:@indent_step, 2)
-    tc_spy = Spy.on(wf, :_two_columns)
-    hr_spy = Spy.on(wf, :add_rule)
-    wf.add_hash('key', hash, 3, 1)
-    assert tc_spy.has_been_called_with?([hash], 6)
-    assert hr_spy.has_been_called?
+  def test_end_to_end
+    input, expected = OUTPUT_TESTER.in_and_out('user-input.json',
+                                               'user-human-long')
+    output = WavefrontDisplayPrinter::Long.new(input).to_s
+    assert_equal(expected, output + "\n")
+
+    input, expected = OUTPUT_TESTER.in_and_out('user-input.json',
+                                               'user-human-long-no_sep')
+    output = WavefrontDisplayPrinter::Long.new(input, nil, nil,
+                                               separator: false).to_s
+    assert_equal(expected, output + "\n")
   end
 
-  def test_add_hash_3
-    hash = { sk1: 'value1', sk2: 'value2' }
-    wf.instance_variable_set(:@kw, 10)
-    wf.instance_variable_set(:@indent_step, 2)
-    tc_spy = Spy.on(wf, :_two_columns)
-    hr_spy = Spy.on(wf, :add_rule)
-    wf.add_hash('key', hash, 3, 2)
-    assert tc_spy.has_been_called_with?([hash], 6)
-    refute hr_spy.has_been_called?
+  def test_end_to_end_fold
+    input, expected = OUTPUT_TESTER.in_and_out('alert-input.json',
+                                               'alert-human-long')
+    output = WavefrontDisplayPrinter::Long.new(input).to_s
+    assert_equal(expected, output + "\n")
   end
 end