wavefront-cli 0.0.5 → 1.0.0

data/spec/wavefront-cli/base_spec.rb

@@ -26,6 +26,8 @@ DISP_DATA = {
   b: %w(list_1 list_2)
 }.freeze
 
+# Test base class
+#
 class WavefrontCliBaseTest < MiniTest::Test
   attr_reader :wf, :wf_cmd
 
@@ -37,11 +39,12 @@ class WavefrontCliBaseTest < MiniTest::Test
 
   def test_mk_creds
     assert_equal wf.mk_creds, endpoint: 'test.wavefront.com',
-                              token:    '0123456789-ABCDEF'
+                              token:    '0123456789-ABCDEF',
+                              agent:    "wavefront-cli-#{WF_CLI_VERSION}"
   end
 
   def test_dispatch
     assert_raises(WavefrontCli::Exception::UnhandledCommand) { wf.dispatch }
-    #assert_equal(wf_cmd.dispatch, nil)
+    # assert_equal(wf_cmd.dispatch, nil)
   end
 end

data/spec/wavefront-cli/cli_help_spec.rb

@@ -11,8 +11,8 @@ class WavefrontCliHelpTest < MiniTest::Test
   rescue SystemExit => e
     assert_equal(1, e.status)
     assert_match(/^Usage/, e.message)
-    assert_match(/^  wavefront --version$/, e.message)
-    assert_match(/^  wavefront --help$/, e.message)
+    assert_match(/^  \w+ --version$/, e.message)
+    assert_match(/^  \w+ --help$/, e.message)
   end
 
   def test_version
@@ -27,20 +27,22 @@ class WavefrontCliHelpTest < MiniTest::Test
   rescue SystemExit => e
     assert_equal(1, e.status)
     assert_match(/^Commands:$/, e.message)
-    CMDS.each do |cmd|
-      assert_match(/^  #{cmd} /, e.message)
-    end
+    CMDS.each { |cmd| assert_match(/^  #{cmd} /, e.message) }
   end
 
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
   def test_command_help
     CMDS.each do |cmd|
       begin
         WavefrontCliController.new([cmd, '--help'])
       rescue SystemExit => e
+        assert(e.message.split("\n").map(&:size).max <= TW)
         assert_equal(1, e.status)
         assert_match(/^Usage:/, e.message)
         assert_match(/^  #{CMD} #{cmd} /, e.message)
         assert_match(/^  #{CMD} #{cmd} --help$/, e.message)
+        next
       end
     end
   end

data/spec/wavefront-cli/cloudintegration_spec.rb

@@ -16,6 +16,15 @@ describe 'integration command' do
               { path: "/api/v2/cloudintegration/#{id}" }, k)
   cmd_to_call(word, "delete #{id}",
               { method: :delete, path: "/api/v2/cloudintegration/#{id}" }, k)
+  cmd_to_call(word, "search -L 100 id~#{id}",
+              { method: :post, path: "/api/v2/search/cloudintegration",
+                body:   { limit: "100",
+                          offset: 0,
+                          query: [{key: 'id',
+                                   value: id,
+                                   matchingMethod: 'CONTAINS'}],
+                          sort: {field: 'id', ascending: true}},
+                headers: JSON_POST_HEADERS }, WavefrontCli::CloudIntegration)
   cmd_to_call(word, "undelete #{id}",
               { method: :post,
                 path:    "/api/v2/cloudintegration/#{id}/undelete" }, k)

data/spec/wavefront-cli/commands/alert_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Alert commands and options
+#
+class WavefrontCommmandAlertTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandAlert.new
+    @col_width = 21
+  end
+end

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

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+CMD = 'test'.freeze
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './spec_helper'
+
+# Test base class for commands
+#
+class WavefrontCommmandBaseTest < MiniTest::Test
+  attr_reader :wf, :col_width, :skip_cmd
+
+  def setup
+    @wf = WavefrontCommandBase.new
+    @col_width = 18 # has to be manually set for each class
+  end
+
+  def word
+    self.class.name[17..-5]
+  end
+
+  def test_global_options
+    opts = wf.global_options
+    assert_instance_of(Array, opts)
+
+    opts.each do |o|
+      assert_instance_of(String, o)
+      assert_match(/^-\w, --\w+/, o)
+      refute o.end_with?('.')
+    end
+  end
+
+  def test_common_options
+    opts = wf.common_options
+    assert_instance_of(Array, opts)
+
+    opts.each do |o|
+      assert_instance_of(String, o)
+      assert_match(/^-\w, --\w+/, o)
+      refute o.end_with?('.')
+    end
+  end
+
+  def test_tag_commands
+    cmds = wf.tag_commands
+    assert_instance_of(Array, cmds)
+
+    cmds.each do |o|
+      assert_instance_of(String, o)
+      assert_match(/^tags* .* <id>/, o)
+    end
+  end
+
+  def test_word
+    assert_equal(wf.word, word.downcase)
+  end
+
+  def test_sdk_class
+    assert_equal(wf.sdk_class, word)
+  end
+
+  def test_sdk_file
+    assert_equal(wf.sdk_file, word.downcase)
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  def test_commands
+    assert wf.commands.start_with?("Usage:\n")
+    assert wf.commands.match(/ --help$/)
+
+    wf.commands(600).split("\n")[1..-1].each do |c|
+      next if skip_cmd && c.match(skip_cmd)
+      assert_match(/^  \w+/, c)
+      assert_includes(c, CMN) unless c =~ /--help$/
+    end
+  end
+
+  def test_options
+    assert wf.options(600).start_with?("Global options:\n")
+    assert_match(/\nOptions:\n/, wf.options)
+
+    wf.options(600).split("\n")[1..-1].each do |o|
+      next if o == 'Global options:' || o == 'Options:' || o.empty?
+      assert_instance_of(String, o)
+      assert_match(/^  -\w, --\w+/, o)
+      refute o.end_with?('.')
+    end
+
+    assert_equal(wf.options.split("\n").select(&:empty?).size, 1)
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def test_opt_row
+    assert_equal(wf.opt_row('-s, --short    short option', 10),
+                 "  -s, --short    short option\n")
+    assert_equal(wf.opt_row('-s, --short    short option', 8),
+                 "  -s, --short  short option\n")
+    assert_equal(wf.opt_row(
+                   '-l, --longoption    a long option with a quite ' \
+                   'long description which needs folding', 15
+    ),
+                 '  -l, --longoption    a long option with a quite long ' \
+                 "description which\n                      needs folding\n")
+    assert_equal(wf.opt_row(
+                   '-h, --hugeoption    an option with a very long, far ' \
+                   'too verbose description which is going need folding ' \
+                   'more than one time, let me tell you', 12
+    ),
+                 '  -h, --hugeoption an option with a very long, far too ' \
+                 "verbose description\n                   which is going " \
+                 'need folding more than one time, let me tell' \
+                 "\n                   you\n")
+  end
+
+  def test_option_column_width
+    assert_equal(wf.option_column_width, col_width)
+  end
+
+  def test_postscript
+    assert_instance_of(String, wf.postscript)
+  end
+
+  def test_docopt
+    x = wf.docopt
+    assert x.start_with?("Usage:\n")
+    assert_match("\nGlobal options:\n", x)
+    assert_match("--help\n", x)
+    assert_instance_of(String, x)
+  end
+end

data/spec/wavefront-cli/commands/dashboard_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Dashboard commands and options
+#
+class WavefrontCommmandDashboardTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandDashboard.new
+    @col_width = 21
+  end
+end

data/spec/wavefront-cli/commands/event_spec.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Event commands and options
+#
+class WavefrontCommmandEventTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandEvent.new
+    @col_width = 23
+    @skip_cmd = /event show/
+  end
+end

data/spec/wavefront-cli/commands/integration_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require_relative('../../../lib/wavefront-cli/commands/integration')
+require_relative './base_spec'
+
+# Test Cloud Integration commands and options
+#
+class WavefrontCommmandIntegrationTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandIntegration.new
+    @col_width = 19
+  end
+
+  def word
+    'CloudIntegration'
+  end
+
+  def test_word
+    assert_equal(wf.word, 'integration')
+  end
+end

data/spec/wavefront-cli/commands/link_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require_relative('../../../lib/wavefront-cli/commands/link')
+require_relative './base_spec'
+
+# Test External Link commands and options
+#
+class WavefrontCommmandLinkTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandLink.new
+    @col_width = 19
+  end
+
+  def word
+    'ExternalLink'
+  end
+
+  def test_word
+    assert_equal(wf.word, 'link')
+  end
+end

data/spec/wavefront-cli/commands/message_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Message commands and options
+#
+class WavefrontCommmandMessageTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandMessage.new
+    @col_width = 19
+  end
+end

data/spec/wavefront-cli/commands/metric_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Metric commands and options
+#
+class WavefrontCommmandMetricTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandMetric.new
+    @col_width = 19
+  end
+end

data/spec/wavefront-cli/commands/proxy_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Proxy commands and options
+#
+class WavefrontCommmandProxyTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandProxy.new
+    @col_width = 19
+  end
+end

data/spec/wavefront-cli/commands/query_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Query commands and options
+#
+class WavefrontCommmandQueryTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandQuery.new
+    @col_width = 24
+  end
+end

data/spec/wavefront-cli/commands/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+
+TW = 80

data/spec/wavefront-cli/commands/webhook_spec.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Webhook commands and options
+#
+class WavefrontCommmandWebhookTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandWebhook.new
+    @col_width = 19
+  end
+end

data/spec/wavefront-cli/commands/window_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require_relative('../../../lib/wavefront-cli/commands/window')
+require_relative './base_spec'
+
+# Test Maintenance Window commands and options
+#
+class WavefrontCommmandWindowTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandWindow.new
+    @col_width = 19
+  end
+
+  def word
+    'MaintenanceWindow'
+  end
+
+  def test_word
+    assert_equal(wf.word, 'window')
+  end
+end

data/spec/wavefront-cli/commands/write_spec.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/commands',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './base_spec'
+
+# Test Write commands and options
+#
+class WavefrontCommmandWriteTest < WavefrontCommmandBaseTest
+  def setup
+    @wf = WavefrontCommandWrite.new
+    @col_width = 25
+    @skip_cmd = /write (point|file)/
+  end
+end

data/spec/wavefront-cli/dashboard_spec.rb

@@ -18,17 +18,27 @@ describe "#{word} command" do
 
   it 'deletes with a check on inTrash' do
     stub_request(:get,
-                 "https://other.wavefront.com/api/v2/#{word}/#{id}").
-        with(headers: {'Accept': '*/*',
+                 "https://other.wavefront.com/api/v2/#{word}/#{id}")
+      .with(headers: { 'Accept': '*/*',
                        'Accept-Encoding':
                           'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
                        'Authorization': 'Bearer 0123456789-ABCDEF',
-                       'User-Agent': /wavefront.*/}).
-          to_return(:status => 200, :body => "", :headers => {})
+                       'User-Agent': /wavefront.*/ })
+      .to_return(status: 200, body: '', headers: {})
     cmd_to_call(word, "delete #{id}",
                 method: :delete, path: "/api/v2/#{word}/#{id}")
   end
 
+  cmd_to_call(word, "search id=#{id}",
+              { method: :post, path: "/api/v2/search/#{word}",
+                body:   { limit: 10,
+                          offset: 0,
+                          query: [{key: 'id',
+                                   value: id,
+                                   matchingMethod: 'EXACT'}],
+                          sort: {field: 'id', ascending: true}},
+                headers: JSON_POST_HEADERS })
+
   cmd_to_call(word, "undelete #{id}",
               method: :post, path: "/api/v2/#{word}/#{id}/undelete")
   invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",

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

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+CMD = 'test'.freeze
+
+require 'date'
+require 'map'
+require 'pathname'
+require_relative(File.join('../../../lib/wavefront-cli/display',
+                           Pathname.new(__FILE__).basename
+                           .to_s.sub('_spec.rb', '')))
+require_relative './spec_helper'
+
+S_DATA = Map.new()
+S_OPTIONS = { '<id>': 'abc123' }
+
+# Test base class for display methods
+#
+class WavefrontDisplayBaseTest < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    @wf = WavefrontDisplay::Base.new(S_DATA, S_OPTIONS)
+  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 })
+  end
+
+  def test_run
+  end
+
+  def test_friendly_name
+    assert_equal(wf.friendly_name, 'base')
+  end
+
+  def test_do_list
+    out = Spy.on(wf, :long_output)
+    wf.do_list
+    assert out.has_been_called?
+  end
+
+  def test_do_list_brief
+    out = Spy.on(wf, :multicolumn)
+    wf.do_list_brief
+    assert out.has_been_called?
+  end
+
+  def test_do_import
+    out = Spy.on(wf, :long_output)
+    assert_output("Imported base.\n") { wf.do_import }
+    assert out.has_been_called?
+  end
+
+  def test_do_delete
+    assert_output("Deleted base 'abc123'.\n") { wf.do_delete }
+  end
+
+  def test_do_undelete
+    assert_output("Undeleted base 'abc123'.\n") { wf.do_undelete }
+  end
+
+  def test_do_tag_add
+    assert_output("Tagged base 'abc123'.\n") { wf.do_tag_add }
+  end
+
+  def test_do_tag_delete
+    assert_output("Deleted tag from base 'abc123'.\n") { wf.do_tag_delete }
+  end
+
+  def test_do_tag_clear
+    assert_output("Cleared tags on base 'abc123'.\n") { wf.do_tag_clear }
+  end
+
+  def test_do_tag_set
+    assert_output("Set tags on base 'abc123'.\n") { wf.do_tag_set }
+  end
+
+  def test_do_tags
+    assert_output("No tags set on base 'abc123'.\n") { wf.do_tags }
+
+    assert_output("tag1\ntag2\n") do
+      WavefrontDisplay::Base.new(%w(tag1 tag2), S_OPTIONS).do_tags
+    end
+
+    assert_output("tag1\n") do
+      WavefrontDisplay::Base.new(%w(tag1), S_OPTIONS).do_tags
+    end
+  end
+
+  def test_drop_fields_1
+    data = { k1: 'string', k2: Time.now.to_i, k3: Time.now.to_i }
+    wf = WavefrontDisplay::Base.new(data)
+    wf.drop_fields
+    assert_equal(wf.instance_variable_get(:@data), data)
+  end
+
+  def test_drop_fields_2
+    data = { k1: 'string', k2: Time.now.to_i, k3: Time.now.to_i }
+    wf = WavefrontDisplay::Base.new(data)
+    wf.drop_fields(:k1)
+    assert_equal(wf.instance_variable_get(:@data),
+      { k2: Time.now.to_i, k3: Time.now.to_i })
+  end
+
+  def test_drop_fields_3
+    data = { k1: 'string', k2: Time.now.to_i, k3: Time.now.to_i }
+    wf = WavefrontDisplay::Base.new(data)
+    wf.drop_fields(:k1, :k3)
+    assert_equal(wf.instance_variable_get(:@data), k2: Time.now.to_i)
+  end
+
+  def test_readable_time_1
+    data = { k1: 'string', k2: Time.now.to_i, k3: Time.now.to_i }
+    wf = WavefrontDisplay::Base.new(data)
+    wf.readable_time
+    assert_equal(wf.instance_variable_get(:@data), data)
+  end
+
+  def test_readable_time_2
+    data = { k1: 'string', k2: 1499426615, k3: 1499426615 }
+    wf = WavefrontDisplay::Base.new(data)
+    wf.readable_time(:k2)
+    x = wf.data
+    assert x.is_a?(Hash)
+    assert_equal(x.size, 3)
+    assert_equal(x.keys, %i(k1 k2 k3))
+    assert_equal(x[:k1], 'string')
+    assert_match(/^20\d\d-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d$/, x[:k2])
+    assert_equal(x[:k3], 1499426615)
+  end
+
+  def test_readable_time_2
+    data = { k1: 'string', k2: 1499426615, k3: 1499426615 }
+    wf = WavefrontDisplay::Base.new(data)
+    wf.readable_time(:k2, :k3)
+    x = wf.data
+    assert x.is_a?(Hash)
+    assert_equal(x.size, 3)
+    assert_equal(x.keys, %i(k1 k2 k3))
+    assert_equal(x[:k1], 'string')
+    assert_match(/^20\d\d-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d$/, x[:k2])
+    assert_match(/^20\d\d-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d$/, x[:k3])
+  end
+
+  def test_human_time
+    assert_raises(ArgumentError) { wf.human_time([1,2,3]) }
+    assert_raises(ArgumentError) { wf.human_time(123) }
+    assert_raises(ArgumentError) { wf.human_time(12345678901234) }
+    assert_equal('2017-07-07 11:23:35', wf.human_time(1499426615, true))
+    assert_match(/^20\d\d-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d.\d{3}$/,
+                 wf.human_time(DateTime.now.strftime('%Q')))
+    assert_match(/^20\d\d-[01]\d-[0-3]\d [0-2]\d:[0-5]\d:[0-5]\d$/,
+                 wf.human_time(Time.now.to_i))
+    assert_equal('2017-07-07 11:23:35.123', wf.human_time(1499426615123,
+                                                          true))
+  end
+end

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require_relative '../../../../lib/wavefront-cli/display/printer/base'
+require_relative '../spec_helper'
+
+# Test base class
+#
+class WavefrontDisplayPrinterBase < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    @wf = WavefrontDisplayPrinter::Base.new
+  end
+
+  def test_key_width
+    assert_equal(wf.key_width, 0)
+    assert_equal(wf.key_width(key1: 1, row2: 2, longrow: 3), 9)
+    assert_equal(wf.key_width({ key1: 1, row2: 2, longrow: 3 }, 3), 10)
+  end
+end