wavefront-cli 4.2.1 → 4.3.0

data/spec/wavefront-cli/controller_spec.rb

@@ -1,11 +1,18 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require_relative '../spec_helper'
+require 'minitest/autorun'
+require_relative '../constants'
+require_relative '../support/supported_commands'
 require_relative '../../lib/wavefront-cli/controller'
 
 # Be sure the CLI behaves properly when people ask for help
 #
 class WavefrontCliHelpTest < MiniTest::Test
+  def test_development_mode
+    refute defined?(DEVELOPMENT) if ENV['CI']
+  end
+
   def test_no_args
     capture_io { WavefrontCliController.new([]) }
   rescue SystemExit => e
@@ -27,11 +34,14 @@ class WavefrontCliHelpTest < MiniTest::Test
   rescue SystemExit => e
     assert_equal(1, e.status)
     assert_match(/^Commands:$/, e.message)
-    CMDS.each { |cmd| assert_match(/^  #{cmd} /, e.message) }
+
+    SupportedCommands.new.all.each do |cmd|
+      assert_match(/^  #{cmd} /, e.message)
+    end
   end
 
   def test_command_help
-    CMDS.each do |cmd|
+    SupportedCommands.new.all.each do |cmd|
       begin
         capture_io { WavefrontCliController.new([cmd, '--help']) }
       rescue SystemExit => e

data/spec/wavefront-cli/dashboard_spec.rb

@@ -1,86 +1,135 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-id = 'test_dashboard'
-bad_id = '>_<'
-word = 'dashboard'
-
-require_relative '../spec_helper'
-require_relative "../../lib/wavefront-cli/#{word}"
-
-describe "#{word} command" do
-  missing_creds(word, ['list', "describe #{id}", "delete #{id}",
-                       "undelete #{id}", "history #{id}"])
-  list_tests(word)
-  noop_tests(word, id, true)
-  cmd_to_call(word, "describe #{id}", path: "/api/v2/#{word}/#{id}")
-  cmd_to_call(word, "describe -v 7 #{id}",
-              path: "/api/v2/#{word}/#{id}/history/7")
-  cmd_to_call(word, "history #{id}", path: "/api/v2/#{word}/#{id}/history")
-
-  it 'deletes with a check on inTrash' do
-    stub_request(:get,
-                 "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: {})
-    cmd_to_call(word, "delete #{id}",
-                method: :delete, path: "/api/v2/#{word}/#{id}")
+require_relative '../support/command_base'
+require_relative '../test_mixins/acl'
+require_relative '../test_mixins/tag'
+require_relative '../test_mixins/history'
+require_relative '../../lib/wavefront-cli/dashboard'
+
+# Ensure 'dashboard' commands produce the correct API calls.
+#
+class DashboardEndToEndTest < EndToEndTest
+  # include WavefrontCliTest::Import
+  include WavefrontCliTest::Set
+  include WavefrontCliTest::DeleteUndelete
+  include WavefrontCliTest::Dump
+  include WavefrontCliTest::List
+  include WavefrontCliTest::Describe
+  include WavefrontCliTest::Search
+  include WavefrontCliTest::Tag
+  include WavefrontCliTest::History
+  include WavefrontCliTest::Acl
+
+  def test_queries
+    quietly do
+      assert_cmd_gets('queries', '/api/v2/dashboard?limit=999&offset=0')
+    end
   end
 
-  cmd_to_call(word,
-              'favs',
-              method: :post,
-              path:   "/api/v2/search/#{word}",
-              body:   { limit:  999,
-                        offset: 0,
-                        query:  [{ key:             'favorite',
-                                   value:           'true',
+  def test_favs
+    assert_repeated_output('No favourites.') do
+      assert_cmd_posts('favs', '/api/v2/search/dashboard',
+                       { limit: 999,
+                         offset: 0,
+                         query: [{ key: 'favorite',
+                                   value: 'true',
                                    matchingMethod: 'EXACT',
-                                   negated:         false }],
-                        sort:   { field:     'id',
-                                  ascending: true } }.to_json)
-
-  spies = [{ class:  'WavefrontCli::Dashboard',
-             method: :do_favs,
-             return: nil }]
-
-  cmd_to_call(word,
-              "fav #{id}",
-              { method: :post,
-                path:   "/api/v2/#{word}/#{id}/favorite" },
-              nil,
-              spies)
-
-  cmd_to_call(word,
-              "unfav #{id}",
-              { method: :post,
-                path:   "/api/v2/#{word}/#{id}/unfavorite" },
-              nil,
-              spies)
-
-  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)
-  search_tests(word, id)
-  test_list_output(word)
-  acl_tests(word, id, bad_id)
-end
+                                   negated: false }],
+                         sort: { field: 'id',
+                                 ascending: true } }.to_json)
+    end
+  end
+
+  def test_fav
+    assert_repeated_output('No favourites.') do
+      all_permutations do |perm|
+        stub_request(:post, "https://#{perm[:endpoint]}/api/v2/search" \
+                     '/dashboard')
+          .with(body: { limit: 999,
+                        offset: 0,
+                        query: [{ key: 'favorite',
+                                  value: 'true',
+                                  matchingMethod: 'EXACT',
+                                  negated: false }],
+                        sort: { field: 'id', ascending: true } },
+                headers: mk_headers(perm[:token]))
+          .to_return(status: 200, body: '', headers: {})
+
+        stub_request(:post,
+                     "https://#{perm[:endpoint]}/api/v2/dashboard/" \
+                     'test_dashboard/favorite')
+          .with(body: 'null',
+                headers: mk_headers(perm[:token]))
+          .to_return(status: 200, body: '', headers: {})
+
+        wf.new("#{cmd_word} fav #{id} #{perm[:cmdline]}".split)
+      end
+    end
+
+    assert_abort_on_missing_creds("fav #{id}")
+    assert_invalid_id("fav #{invalid_id}")
+    assert_usage('fav')
+  end
+
+  def test_unfav
+    assert_repeated_output('No favourites.') do
+      all_permutations do |perm|
+        search_stub = unfav_search_stub(perm)
+        action_stub = unfav_action_stub(perm)
+        wf.new("#{cmd_word} unfav #{id} #{perm[:cmdline]}".split)
+        assert_requested(search_stub)
+        assert_requested(action_stub)
+      end
+    end
+
+    assert_abort_on_missing_creds("unfav #{id}")
+    assert_invalid_id("unfav #{invalid_id}")
+    assert_usage('unfav')
+  end
+
+  private
+
+  def unfav_search_stub(perm)
+    stub_request(:post, "https://#{perm[:endpoint]}/api/v2/search/dashboard")
+      .with(body: { limit: 999,
+                    offset: 0,
+                    query: [{ key: 'favorite',
+                              value: 'true',
+                              matchingMethod: 'EXACT',
+                              negated: false }],
+                    sort: { field: 'id', ascending: true } },
+            headers: mk_headers(perm[:token]))
+      .to_return(status: 200, body: '', headers: {})
+  end
+
+  def unfav_action_stub(perm)
+    stub_request(:post,
+                 "https://#{perm[:endpoint]}/api/v2/dashboard/test_dashboard" \
+                 '/unfavorite')
+      .with(body: 'null',
+            headers: mk_headers(perm[:token]))
+      .to_return(status: 200, body: '', headers: {})
+  end
+
+  def id
+    'test_dashboard'
+  end
 
-class TestAlertMethods < CliMethodTest
-  def cliclass
-    WavefrontCli::Dashboard
+  def invalid_id
+    '>_<'
   end
 
-  def test_import_method
-    import_tester(:dashboard,
-                  %i[description name parameters tags url creatorId
-                     sections parameterDetails displayDescription
-                     acl numCharts],
-                  %i[id])
+  def cmd_word
+    'dashboard'
   end
+
+  def import_fields
+    %i[description name parameters tags url creatorId sections
+       parameterDetails displayDescription acl numCharts]
+  end
+
+  def import_data; end
+
+  def update_data; end
 end

data/spec/wavefront-cli/derivedmetric_spec.rb

@@ -1,84 +1,100 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-word = 'derivedmetric'
+require_relative '../support/command_base'
+require_relative '../test_mixins/tag'
+require_relative '../test_mixins/history'
+require_relative '../../lib/wavefront-cli/derivedmetric'
 
-require_relative '../spec_helper'
-require_relative "../../lib/wavefront-cli/#{word}"
+# Ensure 'derivedmetric' commands produce the correct API calls.
+#
+class DerivedMetricEndToEndTest < EndToEndTest
+  include WavefrontCliTest::List
+  include WavefrontCliTest::Describe
+  include WavefrontCliTest::Dump
+  # include WavefrontCliTest::Import
+  include WavefrontCliTest::Set
+  include WavefrontCliTest::DeleteUndelete
+  include WavefrontCliTest::Search
+  include WavefrontCliTest::Tag
+  include WavefrontCliTest::History
 
-id     = '1529938767979'
-bad_id = '>_<'
+  def test_create_simple
+    quietly do
+      assert_cmd_posts('create mymetric ts(series)',
+                       '/api/v2/derivedmetric',
+                       minutes: 5,
+                       name: 'mymetric',
+                       includeObsoleteMetrics: false,
+                       processRateMinutes: 1,
+                       query: 'ts(series)')
+    end
 
-k = WavefrontCli::DerivedMetric
+    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)
 
-describe "#{word} command" do
-  missing_creds(word, ['list', "describe #{id}", "delete #{id}",
-                       "undelete #{id}", "history #{id}"])
-  list_tests(word, nil, k)
-  noop_tests(word, id, true, word, k)
-  search_tests(word, id, k)
-  cmd_to_call(word, "describe #{id}", { path: "/api/v2/#{word}/#{id}" }, k)
-  cmd_to_call(word, "describe -v 7 #{id}",
-              { path: "/api/v2/#{word}/#{id}/history/7" }, k)
-  cmd_to_call(word, "history #{id}",
-              { path: "/api/v2/#{word}/#{id}/history" }, k)
+    assert_usage('create')
+    assert_abort_on_missing_creds("create #{id} ts(series)")
+    # Names are free-text, so there aren't any invalid ID tests for this
+    # command.
+  end
 
-  it 'deletes with a check on inTrash' do
-    stub_request(:get,
-                 "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: {})
-    cmd_to_call(word, "delete #{id}",
-                { method: :delete, path: "/api/v2/#{word}/#{id}" }, k)
+  def create_with_options
+    quietly do
+      assert_cmd_posts('create -i 3 -r 7 -b mymetric ts(series)',
+                       '/api/v2/derivedmetric',
+                       minutes: 7,
+                       name: 'mymetric',
+                       includeObsoleteMetrics: true,
+                       processRateMinutes: 3,
+                       query: 'ts(series)')
+    end
   end
 
-  cmd_to_call(word, "undelete #{id}",
-              { method: :post, path: "/api/v2/#{word}/#{id}/undelete" }, k)
-  invalid_ids(word, ["describe #{bad_id}", "delete #{bad_id}",
-                     "undelete #{bad_id}"])
-  tag_tests(word, id, bad_id, nil, k)
+  def create_with_options_and_tags
+    quietly do
+      assert_cmd_posts('create -i 3 -T tag1 -T tag2 mymetric ts(series)',
+                       '/api/v2/derivedmetric',
+                       minutes: 5,
+                       name: 'mymetric',
+                       includeObsoleteMetrics: false,
+                       processRateMinutes: 3,
+                       tags: %w[tag1 tag2],
+                       query: 'ts(series)')
+    end
+  end
 
-  cmd_to_call(word, 'create test_dm ts(series)',
-              { method: :post, path: '/api/v2/derivedmetric',
-                body: { minutes:                5,
-                        name:                   'test_dm',
-                        includeObsoleteMetrics: false,
-                        processRateMinutes:     1,
-                        query:                  'ts(series)' },
-                headers: JSON_POST_HEADERS }, k)
+  private
 
-  cmd_to_call(word, 'create -i 3 -r 7 -b test_dm ts(series)',
-              { method: :post, path: '/api/v2/derivedmetric',
-                body: { minutes:                7,
-                        name:                   'test_dm',
-                        includeObsoleteMetrics: true,
-                        processRateMinutes:     3,
-                        query:                  'ts(series)' },
-                headers: JSON_POST_HEADERS }, k)
+  def id
+    '1529926075038'
+  end
 
-  cmd_to_call(word, 'create -i 3 -T tag1 -T tag2 test_dm ts(series)',
-              { method: :post, path: '/api/v2/derivedmetric',
-                body: { minutes:                5,
-                        name:                   'test_dm',
-                        includeObsoleteMetrics: false,
-                        processRateMinutes:     3,
-                        tags:                   %w[tag1 tag2],
-                        query:                  'ts(series)' },
-                headers: JSON_POST_HEADERS }, k)
-  test_list_output(word, k)
-end
+  def invalid_id
+    '__BAD__'
+  end
+
+  def cmd_word
+    'derivedmetric'
+  end
+
+  def sdk_class_name
+    'DerivedMetric'
+  end
 
-class TestDerivedMetricMethods < CliMethodTest
-  def test_import_method
-    import_tester(:derivedmetric,
-                  %i[tags minutes name query metricsUsed hostsUsed],
-                  %i[id])
+  def import_fields
+    %i[tags minutes name query metricsUsed hostsUsed]
   end
 
-  def cliclass
-    WavefrontCli::DerivedMetric
+  def friendly_name
+    'derived metric'
   end
 end

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

@@ -1,12 +1,11 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 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'
+require 'minitest/autorun'
+require 'spy/integration'
+require_relative '../../../lib/wavefront-cli/display/base'
 
 S_DATA = Map.new
 S_OPTIONS = { '<id>': 'abc123' }.freeze
@@ -175,10 +174,9 @@ class WavefrontDisplayBaseTest < MiniTest::Test
     assert_raises(ArgumentError) { wf.human_time(123) }
     assert_raises(ArgumentError) { wf.human_time(12_345_678_901_234) }
     assert_equal('2017-07-07 11:23:35', wf.human_time(1_499_426_615, true))
-    # rubocop:disable Style/DateTime
     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')))
-    # rubocop:enable Style/DateTime
+
     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(1_499_426_615_123,

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
+require 'minitest/autorun'
+require_relative '../../../support/output_tester'
 require_relative '../../../../lib/wavefront-cli/display/printer/long'
-require_relative '../spec_helper'
-require_relative '../../../spec_helper'
 
 # Test verbose printing stuff
 #
@@ -48,16 +49,16 @@ class TestWavefrontDisplayPrinterLong < MiniTest::Test
 
     pr = WavefrontDisplayPrinter::Long.new({}, nil, nil,
                                            indent: 4, padding: 3)
-    assert_equal({ indent:    4,
-                   padding:   3,
+    assert_equal({ indent: 4,
+                   padding: 3,
                    separator: true,
-                   none:      true }, pr.opts)
+                   none: true }, pr.opts)
 
     pr = WavefrontDisplayPrinter::Long.new({}, nil, nil, none: false)
-    assert_equal({ indent:    2,
-                   padding:   2,
+    assert_equal({ indent: 2,
+                   padding: 2,
                    separator: true,
-                   none:      false }, pr.opts)
+                   none: false }, pr.opts)
   end
 
   def test_longest_key_col
@@ -76,33 +77,36 @@ class TestWavefrontDisplayPrinterLong < MiniTest::Test
   end
 
   def test_to_s
-    assert_equal("today\n  weather   sunny\n  day       Tuesday",
+    assert_equal("today\n" \
+                 "  weather   sunny\n" \
+                 '  day       Tuesday',
                  WavefrontDisplayPrinter::Long.new(
                    today: { weather: 'sunny', day: :Tuesday }
                  ).to_s)
 
-    assert_equal("key1   val1\nkey2   val2",
+    assert_equal("key1   val1\n" \
+                 'key2   val2',
                  WavefrontDisplayPrinter::Long.new(
                    key1: 'val1', key2: 'val2'
                  ).to_s)
   end
 
   def test_end_to_end
-    input, expected = OUTPUT_TESTER.in_and_out('user-input.json',
-                                               'user-human-long')
+    input, expected = OutputTester.new.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')
+    input, expected = OutputTester.new.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_end_to_end_fold
-    input, expected = OUTPUT_TESTER.in_and_out('alert-input.json',
-                                               'alert-human-long')
+    input, expected = OutputTester.new.in_and_out('alert-input.json',
+                                                  'alert-human-long')
     output = WavefrontDisplayPrinter::Long.new(input).to_s
     assert_equal(expected, output + "\n")
   end