wavefront-cli 8.5.1 → 10.0.0

data/spec/support/command_base.rb

@@ -8,12 +8,14 @@ require_relative '../../lib/wavefront-cli/controller'
 # An abstract class which facilitates "end-to-end" testing of
 # commands.
 #
-class EndToEndTest < MiniTest::Test
+class EndToEndTest < Minitest::Test
+  attr_accessor :single_perm
   attr_reader :wf
 
   def setup
     before_setup if respond_to?(:before_setup)
     @wf = WavefrontCliController
+    @single_perm = false
   end
 
   def api_path
@@ -79,4 +81,14 @@ class EndToEndTest < MiniTest::Test
     { status: { result: 'OK', message: '', code: 200 },
       items: [] }.to_json
   end
+
+  def blank_envvars
+    %w[WAVEFRONT_ENDPOINT WAVEFRONT_PROXY WAVEFRONT_TOKEN].each do |v|
+      ENV[v] = nil
+    end
+  end
+
+  def config?
+    Pathname.new(Dir.home).join('.wavefront').exist?
+  end
 end

data/spec/support/minitest_assertions.rb

@@ -147,10 +147,13 @@ module Minitest
     end
 
     def assert_cmd_posts(command, api_path, payload = 'null',
-                         response = dummy_response)
+                         response = nil, extra_headers = {})
+      response ||= dummy_response
       all_permutations do |p|
         assert_posts("https://#{p[:endpoint]}#{api_path}",
-                     mk_headers(p[:token]), payload, response) do
+                     mk_headers(p[:token], extra_headers),
+                     payload,
+                     response) do
           wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
         end
       end
@@ -166,7 +169,7 @@ module Minitest
     end
 
     def assert_cmd_deletes(command, api_path, response = dummy_response)
-      permutations.each do |p|
+      all_permutations do |p|
         assert_deletes("https://#{p[:endpoint]}#{api_path}",
                        mk_headers(p[:token]), response) do
           wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
@@ -188,13 +191,14 @@ module Minitest
       assert_empty(err)
     end
 
-    # Run tests with all available permutations. We'll always need
-    # to mock out display, unless we don't, when even if we do, it
-    # won't matter.
+    # Run tests with all available permutations, unless the single_perm class
+    # variable is set. This lets us run tests faster by running fewer (but
+    # still a good random selection) and lets us run tests which must only be
+    # run once, like tests which pop stuff off the event stack.
     #
     def all_permutations
       perms = permutations
-      perms = [perms[2]]
+      perms = perms.shuffle.take(1) if @single_perm || ENV['FAST_TESTS']
 
       perms.each do |p|
         yield(p)
@@ -213,11 +217,11 @@ module Minitest
 
     private
 
-    def mk_headers(token = nil)
+    def mk_headers(token = nil, extra_headers = {})
       { Accept: /.*/,
         'Accept-Encoding': /.*/,
-        Authorization: 'Bearer ' + (token || '0123456789-ABCDEF'),
-        'User-Agent': "wavefront-cli-#{WF_CLI_VERSION}" }
+        Authorization: "Bearer #{token || '0123456789-ABCDEF'}",
+        'User-Agent': "wavefront-cli-#{WF_CLI_VERSION}" }.merge(extra_headers)
     end
 
     # Every command we simulate running is done under the following

data/spec/support/output_tester.rb

@@ -14,7 +14,7 @@ class OutputTester
   # @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),
+    ret = JSON.parse(File.read(RES_DIR.join('display', file)),
                      symbolize_names: true)
     only_items ? ret[:items] : ret
   end
@@ -23,7 +23,7 @@ class OutputTester
   # @return [String]
   #
   def load_expected(file)
-    IO.read(RES_DIR + 'display' + file)
+    File.read(RES_DIR.join('display', file))
   end
 
   def in_and_out(input, expected, only_items = true)

data/spec/support/supported_commands.rb

@@ -2,11 +2,13 @@
 
 require_relative '../constants'
 
+# Produces a list of wf's commands
+#
 class SupportedCommands
   attr_reader :cmd_dir
 
   def initialize
-    @cmd_dir = ROOT + 'lib' + 'wavefront-cli' + 'commands'
+    @cmd_dir = ROOT.join('lib', 'wavefront-cli', 'commands')
   end
 
   def all

data/spec/test_mixins/import.rb

@@ -61,11 +61,11 @@ module WavefrontCliTest
     private
 
     def import_file
-      RES_DIR + 'imports' + "#{api_path}.json"
+      RES_DIR.join('imports', "#{api_path}.json")
     end
 
     def update_file
-      RES_DIR + 'updates' + "#{api_path}.json"
+      RES_DIR.join('updates', "#{api_path}.json")
     end
   end
 end

data/spec/test_mixins/search.rb

@@ -18,17 +18,19 @@ module WavefrontCliTest
                          sort: { field: 'id', ascending: true })
       end
 
+      json_body = { limit: 10,
+                    offset: 0,
+                    query: [{ key: 'id',
+                              value: id,
+                              matchingMethod: 'EXACT',
+                              negated: false }],
+                    sort: { field: 'id', ascending: true } }.to_json
+
       assert_noop(
         "search id=#{id}",
         'uri: POST https://default.wavefront.com/api/v2/search/' \
         "#{search_api_path}",
-        'body: ' + { limit: 10,
-                     offset: 0,
-                     query: [{ key: 'id',
-                               value: id,
-                               matchingMethod: 'EXACT',
-                               negated: false }],
-                     sort: { field: 'id', ascending: true } }.to_json
+        "body: #{json_body}"
       )
       assert_abort_on_missing_creds("search id=#{id}")
       assert_usage('search')

data/spec/test_mixins/set.rb

@@ -23,7 +23,7 @@ module WavefrontCliTest
 
     def run_command(perm)
       wf.new("#{cmd_word} set #{set_key}=new_value #{id} " \
-            "#{perm[:cmdline]}".split)
+             "#{perm[:cmdline]}".split)
     rescue SystemExit => e
       p e
     end

data/spec/wavefront-cli/account_spec.rb

@@ -228,10 +228,12 @@ class AccountEndToEndTest < EndToEndTest
     cmd = "validate #{user_list.join(' ')}"
 
     quietly do
-      assert_cmd_posts(cmd,
-                       '/api/v2/account/validateAccounts',
-                       user_list.to_json,
-                       IO.read(RES_DIR + 'responses' + 'user-validate.json'))
+      assert_cmd_posts(
+        cmd,
+        '/api/v2/account/validateAccounts',
+        user_list.to_json,
+        File.read(RES_DIR.join('responses', 'user-validate.json'))
+      )
     end
 
     assert_noop(cmd,

data/spec/wavefront-cli/alert_spec.rb

@@ -21,6 +21,25 @@ class AlertEndToEndTest < EndToEndTest
   include WavefrontCliTest::History
   include WavefrontCliTest::Acl
 
+  # This test isn't run if whoever runs it has a config file, because it tests
+  # wf's behaviour only if that file does not exist. CI will never have that
+  # file.
+  #
+  def test_no_config_no_envvars
+    skip if config?
+
+    blank_envvars
+    wf = WavefrontCliController
+
+    out, err = capture_io do
+      assert_raises(SystemExit) { wf.new(%w[alert list]) }
+    end
+
+    assert_empty(err)
+    assert out.start_with?('Credential error. Missing api token.')
+    assert_match(/You may also run 'wf config setup'/, out)
+  end
+
   def test_latest
     quietly do
       assert_cmd_gets("latest #{id}", "/api/v2/alert/#{id}/history")
@@ -48,10 +67,12 @@ class AlertEndToEndTest < EndToEndTest
                        id: id, v: nil, name: nil)
     end
 
+    json_body = { id: id, name: nil, v: nil }.to_json
+
     assert_noop("clone #{id}",
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 "alert/#{id}/clone",
-                'body: ' + { id: id, name: nil, v: nil }.to_json)
+                "body: #{json_body}")
 
     assert_invalid_id("clone #{invalid_id}")
     assert_usage('clone')
@@ -65,10 +86,12 @@ class AlertEndToEndTest < EndToEndTest
                        id: id, v: 5, name: nil)
     end
 
+    json_body = { id: id, name: nil, v: 5 }.to_json
+
     assert_noop("clone #{id} --version 5",
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 "alert/#{id}/clone",
-                'body: ' + { id: id, name: nil, v: 5 }.to_json)
+                "body: #{json_body}")
 
     assert_invalid_id("clone -v 10 #{invalid_id}")
     assert_usage('clone -v')
@@ -173,7 +196,7 @@ class AlertEndToEndTest < EndToEndTest
     assert_noop('snoozed',
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 'search/alert',
-                'body: ' + state_search('snoozed').to_json)
+                "body: #{state_search('snoozed').to_json}")
 
     assert_abort_on_missing_creds('snoozed')
   end
@@ -193,7 +216,7 @@ class AlertEndToEndTest < EndToEndTest
     assert_noop('firing',
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 'search/alert',
-                'body: ' + state_search('firing').to_json)
+                "body: #{state_search('firing').to_json}")
 
     assert_abort_on_missing_creds('firing')
   end
@@ -213,7 +236,7 @@ class AlertEndToEndTest < EndToEndTest
     assert_noop('currently firing',
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 'search/alert',
-                'body: ' + state_search('firing').to_json)
+                "body: #{state_search('firing').to_json}")
 
     assert_abort_on_missing_creds('currently firing')
   end
@@ -233,7 +256,7 @@ class AlertEndToEndTest < EndToEndTest
     assert_noop('currently in_maintenance',
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 'search/alert',
-                'body: ' + state_search('in_maintenance').to_json)
+                "body: #{state_search('in_maintenance').to_json}")
 
     assert_abort_on_missing_creds('currently in_maintenance')
   end

data/spec/wavefront-cli/base_spec.rb

@@ -12,7 +12,7 @@ require_relative '../../lib/wavefront-cli/version'
 # class via an instantiation of a concrete class. I don't think any
 # of this matters.
 #
-class WavefrontCliBaseTest < MiniTest::Test
+class WavefrontCliBaseTest < Minitest::Test
   attr_reader :wf, :wf_cmd
 
   def setup

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

@@ -8,7 +8,7 @@ require_relative '../../../lib/wavefront-cli/commands/base'
 
 # Abstract class for testing commands
 #
-class WavefrontCommmandBaseTest < MiniTest::Test
+class WavefrontCommmandBaseTest < Minitest::Test
   attr_reader :wf, :col_width, :skip_cmd
 
   def setup
@@ -68,7 +68,7 @@ class WavefrontCommmandBaseTest < MiniTest::Test
     assert wf.commands.start_with?("Usage:\n")
     assert wf.commands.match(/ --help$/)
 
-    wf.commands(600).split("\n")[1..-1].each do |c|
+    wf.commands(600).split("\n")[1..].each do |c|
       next if skip_cmd && c.match(skip_cmd)
 
       assert_match(/^  \w+/, c)
@@ -80,7 +80,7 @@ class WavefrontCommmandBaseTest < MiniTest::Test
     assert wf.options(600).start_with?("Global options:\n")
     assert_match(/\nOptions:/, wf.options)
 
-    wf.options(600).split("\n")[1..-1].each do |o|
+    wf.options(600).split("\n")[1..].each do |o|
       next if o == 'Global options:' || o == 'Options:' || o.empty?
 
       assert_instance_of(String, o)

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

@@ -13,14 +13,14 @@ require_relative 'base_spec'
 class WavefrontCommmandConfigTest < WavefrontCommmandBaseTest
   def setup
     @wf = WavefrontCommandConfig.new
-    @col_width = 17
+    @col_width = 19
   end
 
   def test_options
-    refute wf.options(600).start_with?("Global options:\n")
+    assert wf.options(600).start_with?("Global options:\n")
     assert_match(/Options:\n/, wf.options)
 
-    wf.options(600).split("\n")[1..-1].each do |o|
+    wf.options(600).split("\n")[1..].each do |o|
       next if o == 'Global options:' || o == 'Options:' || o.empty?
 
       assert_instance_of(String, o)
@@ -28,14 +28,14 @@ class WavefrontCommmandConfigTest < WavefrontCommmandBaseTest
       refute o.end_with?('.')
     end
 
-    assert_equal(wf.options.split("\n").count(&:empty?), 0)
+    assert_equal(wf.options.split("\n").count(&:empty?), 1)
   end
 
   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|
+    wf.commands(600).split("\n")[1..].each do |c|
       next if skip_cmd && c.match(skip_cmd)
 
       assert_match(/^  \w+/, c)
@@ -45,7 +45,7 @@ class WavefrontCommmandConfigTest < WavefrontCommmandBaseTest
   def test_docopt
     x = wf.docopt
     assert x.start_with?("Usage:\n")
-    refute_match("\nGlobal options:\n", x)
+    assert_match("\nGlobal options:\n", x)
     assert_match("--help\n", x)
     assert_instance_of(String, x)
   end

data/spec/wavefront-cli/config_spec.rb

@@ -5,29 +5,32 @@ require 'pathname'
 require 'minitest/autorun'
 require_relative '../constants'
 require_relative '../../lib/wavefront-cli/config'
+require_relative '../support/command_base'
 
-DEF_CF = Pathname.new(ENV['HOME']) + '.wavefront'
+DEF_CF = Pathname.new(Dir.home).join('.wavefront')
 CONF_TMP = Pathname.new('/tmp/outfile')
+CMD_PATH = Pathname.new(__FILE__)
 
 # Test CLI configuration command
 #
-class WavefrontCliConfigTest < MiniTest::Test
+class WavefrontCliConfigTest < Minitest::Test
   attr_reader :wf, :wfo, :wfn
 
   def setup
+    blank_envvars
     @wf = WavefrontCli::Config.new({})
     @wfo = WavefrontCli::Config.new(config: CF)
     @wfn = WavefrontCli::Config.new(config: '/no/file')
   end
 
   def test_do_location
-    assert_output(format("%<file>s\n", file: CF)) { wfo.do_location }
-    assert_output("/no/file\n") { wfn.do_location }
-    assert_output(format("%<file>s\n", file: DEF_CF)) { wf.do_location }
+    assert_equal(DEF_CF, wf.do_location)
+    assert_equal(Pathname('/no/file'), wfn.do_location)
+    assert_equal(CF, wfo.do_location)
   end
 
   def test_do_profiles
-    assert_output("default\nother\n") { wfo.do_profiles }
+    assert_equal(%w[default other], wfo.do_profiles)
 
     assert_raises(WavefrontCli::Exception::ConfigFileNotFound) do
       wfn.do_profiles
@@ -35,10 +38,10 @@ class WavefrontCliConfigTest < MiniTest::Test
   end
 
   def test_do_show
-    out, err = capture_io { wfo.do_show }
-    assert_empty(err)
-    assert out.start_with?("[default]\n")
-    assert_equal(10, out.split("\n").size)
+    assert_equal(File.read(CF), wfo.do_show)
+    # assert_empty(err)
+    # assert out.start_with?("[default]\n")
+    # assert_equal(10, out.split("\n").size)
   end
 
   def test_input_prompt
@@ -56,7 +59,7 @@ class WavefrontCliConfigTest < MiniTest::Test
     out, err = capture_io { assert_instance_of(IniFile, wf.base_config) }
     assert_empty(err)
 
-    if (Pathname.new(ENV['HOME']) + '.wavefront').exist?
+    if Pathname.new(Dir.home).join('.wavefront').exist?
       assert_empty(out)
     else
       assert_match(/Creating new configuration file at/, out)
@@ -72,23 +75,25 @@ class WavefrontCliConfigTest < MiniTest::Test
     end
   end
 
-  def test_validate_input
-    assert_equal('str', wf.validate_input('str', nil,
-                                          proc { |v| v.is_a?(String) }))
+  def test_validate_thing_input
+    assert_equal('str', wf.validate_thing_input('str', nil,
+                                                proc { |v| v.is_a?(String) }))
 
-    assert_equal('defval', wf.validate_input('', 'defval',
-                                             proc { |v| v.is_a?(String) }))
+    assert_equal('defval', wf.validate_thing_input('', 'defval',
+                                                   proc { |v|
+                                                     v.is_a?(String)
+                                                   }))
 
     assert_raises(WavefrontCli::Exception::MandatoryValue) do
-      wf.validate_input('', nil, proc { |v| v.is_a?(String) })
+      wf.validate_thing_input('', nil, proc { |v| v.is_a?(String) })
     end
 
     assert_raises(WavefrontCli::Exception::InvalidValue) do
-      wf.validate_input(:symbol, nil, proc { |v| v.is_a?(String) })
+      wf.validate_thing_input(:symbol, nil, proc { |v| v.is_a?(String) })
     end
 
     assert_raises(WavefrontCli::Exception::InvalidValue) do
-      wf.validate_input('', 123, proc { |v| v.is_a?(String) })
+      wf.validate_thing_input('', 123, proc { |v| v.is_a?(String) })
     end
   end
 
@@ -196,7 +201,7 @@ class WavefrontCliConfigTest < MiniTest::Test
     assert_equal(
       "[other]\ntoken = abcdefab-0123-abcd-0123-abcdefabcdef\n" \
       "endpoint = other.wavefront.com\nproxy = otherwf.localnet\n\n",
-      IO.read(CONF_TMP)
+      File.read(CONF_TMP)
     )
 
     assert_raises(WavefrontCli::Exception::ProfileNotFound) do
@@ -204,41 +209,29 @@ class WavefrontCliConfigTest < MiniTest::Test
     end
   end
 
-  def test_do_envvars_1
-    blank_envvars
-    out, err = capture_io { wfo.do_envvars }
-    assert_empty(err)
-    out.each_line { |l| assert_match(/WAVEFRONT_[A-Z]+\s+unset$/, l) }
-    blank_envvars
+  def test_do_envvars_all_unset
+    assert_equal(['WAVEFRONT_ENDPOINT   unset',
+                  'WAVEFRONT_TOKEN      unset',
+                  'WAVEFRONT_PROXY      unset'], wfo.do_envvars)
   end
 
-  def test_do_envvars_2
-    blank_envvars
+  def test_do_envvars_proxy_set
     ENV['WAVEFRONT_PROXY'] = 'myproxy'
 
-    out, err = capture_io { wfo.do_envvars }
-    assert_empty(err)
-    assert_match(/WAVEFRONT_ENDPOINT+\s+unset$/, out)
-    assert_match(/WAVEFRONT_TOKEN+\s+unset$/, out)
-    assert_match(/WAVEFRONT_PROXY+\s+myproxy$/, out)
-    blank_envvars
+    assert_equal(['WAVEFRONT_ENDPOINT   unset',
+                  'WAVEFRONT_TOKEN      unset',
+                  'WAVEFRONT_PROXY      myproxy'], wfo.do_envvars)
   end
 
-  def test_do_envvars_3
-    blank_envvars
+  def test_do_envvars_proxy_and_token_set
     ENV['WAVEFRONT_PROXY'] = 'myproxy'
     ENV['WAVEFRONT_TOKEN'] = 'token'
 
-    out, err = capture_io { wfo.do_envvars }
-    assert_empty(err)
-    assert_match(/WAVEFRONT_ENDPOINT+\s+unset$/, out)
-    assert_match(/WAVEFRONT_TOKEN+\s+token$/, out)
-    assert_match(/WAVEFRONT_PROXY+\s+myproxy$/, out)
-    blank_envvars
+    assert_equal(['WAVEFRONT_ENDPOINT   unset',
+                  'WAVEFRONT_TOKEN      token',
+                  'WAVEFRONT_PROXY      myproxy'], wfo.do_envvars)
   end
 
-  def test_read_thing; end
-
   def test_present?
     assert wfo.present?
     assert_raises(WavefrontCli::Exception::ConfigFileNotFound) do
@@ -261,3 +254,50 @@ class WavefrontCliConfigTest < MiniTest::Test
     end
   end
 end
+
+class ConfigEndToEndTest < EndToEndTest
+  def test_location
+    assert_output("#{Pathname.new(Dir.home).join('.wavefront')}\n", '') do
+      wf.new('config location'.split)
+    end
+  end
+
+  def test_profiles
+    assert_output("default\nother\n", '') do
+      wf.new("config profiles -c #{CF}".split)
+    end
+  end
+
+  def test_envvars
+    out, err = capture_io { wf.new('config envvars'.split) }
+    assert_equal(3, out.lines.count)
+    assert_empty err
+    assert_match(/^WAVEFRONT_ENDPOINT /, out)
+    assert_match(/^WAVEFRONT_TOKEN /, out)
+    assert_match(/^WAVEFRONT_PROXY /, out)
+  end
+
+  def test_cluster
+    assert_abort_on_missing_creds('cluster')
+    quietly { assert_cmd_gets('cluster', '/api/v2/cluster/info') }
+  end
+
+  def test_about
+    out, err = capture_io { wf.new('config about'.split) }
+    lines = out.lines
+
+    assert_match(/^wf version *#{WF_CLI_VERSION}$/o, lines[0])
+    assert lines[1].start_with?('wf path')
+    assert lines[2].start_with?('SDK version')
+    assert lines[3].start_with?('SDK location')
+    assert lines[4].start_with?('Ruby version')
+    assert lines[5].start_with?('Ruby platform')
+    assert_empty err
+  end
+
+  private
+
+  def cmd_word
+    'config'
+  end
+end

data/spec/wavefront-cli/controller_spec.rb

@@ -8,7 +8,7 @@ require_relative '../../lib/wavefront-cli/controller'
 
 # Be sure the CLI behaves properly when people ask for help
 #
-class WavefrontCliHelpTest < MiniTest::Test
+class WavefrontCliHelpTest < Minitest::Test
   def test_development_mode
     refute defined?(DEVELOPMENT) if ENV['CI']
   end
@@ -94,14 +94,16 @@ end
 # tested above.
 #
 # rubocop:disable Lint/MissingSuper
+# rubocop:disable Style/RedundantInitialize
 class Giblets < WavefrontCliController
   def initialize; end
 end
+# rubocop:enable Style/RedundantInitialize
 # rubocop:enable Lint/MissingSuper
 
 # Here's the subclass
 #
-class GibletsTest < MiniTest::Test
+class GibletsTest < Minitest::Test
   attr_reader :wfc
 
   def setup

data/spec/wavefront-cli/dashboard_spec.rb

@@ -45,7 +45,7 @@ class DashboardEndToEndTest < EndToEndTest
     assert_repeated_output('No favourites.') do
       all_permutations do |perm|
         stub_request(:post, "https://#{perm[:endpoint]}/api/v2/search" \
-                     '/dashboard')
+                            '/dashboard')
           .with(body: { limit: 999,
                         offset: 0,
                         query: [{ key: 'favorite',

data/spec/wavefront-cli/derivedmetric_spec.rb

@@ -30,16 +30,18 @@ class DerivedMetricEndToEndTest < EndToEndTest
                        query: 'ts(series)')
     end
 
+    json_body = {
+      query: 'ts(series)',
+      name: 'mymetric',
+      minutes: 5,
+      includeObsoleteMetrics: false,
+      processRateMinutes: 1
+    }.to_json
+
     assert_noop('create mymetric ts(series)',
                 'uri: POST https://default.wavefront.com/api/v2/' \
                 'derivedmetric',
-                'body: ' + {
-                  query: 'ts(series)',
-                  name: 'mymetric',
-                  minutes: 5,
-                  includeObsoleteMetrics: false,
-                  processRateMinutes: 1
-                }.to_json)
+                "body: #{json_body}")
 
     assert_usage('create')
     assert_abort_on_missing_creds("create #{id} ts(series)")

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

@@ -12,7 +12,7 @@ S_OPTIONS = { '<id>': 'abc123' }.freeze
 
 # Test base class for display methods
 #
-class WavefrontDisplayBaseTest < MiniTest::Test
+class WavefrontDisplayBaseTest < Minitest::Test
   attr_reader :wf, :wff
 
   def setup