wavefront-cli 4.2.1 → 4.3.0

data/spec/support/command_base.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require_relative '../support/minitest_assertions'
+require_relative '../test_mixins/general'
+require_relative '../../lib/wavefront-cli/controller'
+
+# An abstract class which facilitates "end-to-end" testing of
+# commands.
+#
+class EndToEndTest < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    before_setup if respond_to?(:before_setup)
+    @wf = WavefrontCliController
+  end
+
+  def api_path
+    cmd_word
+  end
+
+  def search_api_path
+    api_path
+  end
+
+  def cmd_class
+    Object.const_get("WavefrontCli::#{sdk_class_name}")
+  end
+
+  def cmd_instance
+    cmd_class.new({})
+  end
+
+  def sdk_class_name
+    api_path.capitalize
+  end
+
+  # Fields which must not be in import objects
+  #
+  def blocked_import_fields
+    %i[id]
+  end
+
+  # the key to use when testing the 'set' command. The value is
+  # always 'new_value'
+  #
+  def set_key
+    'name'
+  end
+
+  def friendly_name
+    cmd_word
+  end
+
+  def wall_time
+    half_an_hour_ago = TEE_ZERO - (30 * 60)
+    start_time = Time.at(half_an_hour_ago.to_i - half_an_hour_ago.sec)
+    [start_time, Time.at(start_time + (10 * 60))]
+  end
+
+  def epoch_time
+    wall_time.map { |t| parse_time(t, true) }
+  end
+
+  def start_and_end_opts
+    format('-s %<start_time>s -e %<end_time>s',
+           start_time: wall_time[0].strftime('%H:%M'),
+           end_time: wall_time[1].strftime('%H:%M'))
+  end
+
+  # Set this to true for things that use cursors rather than offsets
+  #
+  def cannot_handle_offsets
+    false
+  end
+
+  def dummy_response
+    { status: { result: 'OK', message: '', code: 200 },
+      items: [] }.to_json
+  end
+end

data/spec/support/minitest_assertions.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require 'spy'
+require 'webmock/minitest'
+require_relative '../constants'
+
+# rubocop:disable Metrics/ModuleLength
+module Minitest
+  #
+  # Custom assertions to facilitate CLI command testing
+  #
+  module Assertions
+    def assert_gets(api_path, headers, response, &block)
+      stub = stub_request(:get, api_path)
+             .with(headers: headers)
+             .to_return(body: response, status: 200)
+      yield block
+      assert_requested(stub)
+    end
+
+    def assert_gets_with_params(api_path, params, headers, response, &block)
+      stub = stub_request(:get, api_path)
+             .with(query: hash_including(params),
+                   headers: headers)
+             .to_return(body: response, status: 200)
+      yield block
+      assert_requested(stub)
+    end
+
+    def assert_posts(api_path, headers, payload, response, &block)
+      stub = stub_request(:post, api_path)
+             .with(body: payload, headers: headers)
+             .to_return(body: response, status: 200)
+      yield block
+      assert_requested(stub)
+    end
+
+    def assert_puts(api_path, headers, _payload, response, &block)
+      stub = stub_request(:put, api_path)
+             .with(headers: headers)
+             .to_return(body: response, status: 200)
+      yield block
+      assert_requested(stub)
+    end
+
+    def assert_deletes(api_path, headers, response, &block)
+      stub = stub_request(:delete, api_path)
+             .with(headers: headers)
+             .to_return(body: response, status: 200)
+      yield block
+      assert_requested(stub)
+    end
+
+    # Don't bother testing permutations for this
+    #
+    def assert_invalid_id(command)
+      out, err = capture_io do
+        assert_raises(SystemExit) { wf.new("#{cmd_word} #{command}".split) }
+      end
+
+      assert_empty(out)
+      assert_match(/is not a valid \w+ ID.$/, err)
+    end
+
+    def assert_usage(command)
+      out, err = capture_io do
+        assert_raises(SystemExit) { wf.new("#{cmd_word} #{command}".split) }
+      end
+
+      assert_empty(out)
+      assert_match(/^Usage:\n  wf #{cmd_word}/, err)
+    end
+
+    def assert_abort_on_missing_creds(command)
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          wf.new("#{cmd_word} #{command} --config /nofile".split)
+        end
+      end
+
+      assert_empty(out)
+      assert_equal("Configuration file '/nofile' not found.\n", err)
+    end
+
+    def assert_exits_with(message, command)
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          wf.new("#{cmd_word} #{command} --config #{CF}".split)
+        end
+      end
+
+      assert_empty(out)
+      assert_equal(message, err.strip)
+    end
+
+    def assert_cannot_noop(command)
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          wf.new("#{cmd_word} #{command} --noop --config #{CF}".split)
+        end
+      end
+
+      assert_empty(out)
+      assert_equal('Multiple API call operations cannot be ' \
+                   "performed as no-ops.\n", err)
+    end
+
+    def assert_repeated_output(msg)
+      begin
+        out, err = capture_io do
+          yield
+        end
+      rescue SystemExit => e
+        puts e.backtrace
+        p e
+      end
+
+      assert_empty(err)
+      out.each_line { |l| assert_equal(msg, l.rstrip) }
+    end
+
+    def assert_cmd_gets(command, api_path, response = dummy_response)
+      all_permutations do |p|
+        assert_gets(full_uri(p[:endpoint], api_path),
+                    mk_headers(p[:token]), response) do
+          wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
+        end
+      end
+    end
+
+    def full_uri(host, api_path)
+      if api_path.is_a?(Regexp)
+        %r{^https://#{host}#{api_path.source}$}
+      else
+        "https://#{host}#{api_path}"
+      end
+    end
+
+    def assert_cmd_gets_with_params(command, api_path, params,
+                                    response = dummy_response)
+      all_permutations do |p|
+        assert_gets_with_params("https://#{p[:endpoint]}#{api_path}",
+                                params,
+                                mk_headers(p[:token]),
+                                response) do
+          wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
+        end
+      end
+    end
+
+    def assert_cmd_posts(command, api_path, payload = 'null',
+                         response = dummy_response)
+      all_permutations do |p|
+        assert_posts("https://#{p[:endpoint]}#{api_path}",
+                     mk_headers(p[:token]), payload, response) do
+          wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
+        end
+      end
+    end
+
+    def assert_cmd_puts(command, api_path, payload, response = dummy_response)
+      all_permutations do |p|
+        assert_puts("https://#{p[:endpoint]}#{api_path}",
+                    mk_headers(p[:token]), payload, response) do
+          wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
+        end
+      end
+    end
+
+    def assert_cmd_deletes(command, api_path, response = dummy_response)
+      permutations.each do |p|
+        assert_deletes("https://#{p[:endpoint]}#{api_path}",
+                       mk_headers(p[:token]), response) do
+          wf.new("#{cmd_word} #{command} #{p[:cmdline]}".split)
+        end
+      end
+    end
+
+    def assert_noop(command, *expected)
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          wf.new("#{cmd_word} #{command} -c #{CF} --noop".split)
+        end
+      end
+
+      out.strip.split("\n").each.with_index do |l, i|
+        assert_equal("SDK INFO: #{expected[i]}", l)
+      end
+
+      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.
+    #
+    def all_permutations
+      perms = permutations
+      perms = [perms[2]]
+
+      perms.each do |p|
+        yield(p)
+        WebMock.reset!
+      end
+    end
+
+    # Helper to avoid dealing with our display methods
+    #
+    def quietly
+      d = Spy.on_instance_method(cmd_class, :display)
+      yield
+      assert d.has_been_called?
+      d.unhook
+    end
+
+    private
+
+    def mk_headers(token = nil)
+      { 'Accept': /.*/,
+        'Accept-Encoding': /.*/,
+        'Authorization': 'Bearer ' + (token || '0123456789-ABCDEF'),
+        'User-Agent': "wavefront-cli-#{WF_CLI_VERSION}" }
+    end
+
+    # Every command we simulate running is done under the following
+    # permutations
+    #
+    def permutations
+      [{ cmdline: "-t #{TOKEN} -E #{ENDPOINT}",
+         token: TOKEN,
+         endpoint: ENDPOINT },
+
+       { cmdline: "-c #{CF}",
+         token: CF_VAL['default']['token'],
+         endpoint: CF_VAL['default']['endpoint'] },
+
+       { cmdline: "-c #{CF} -P other",
+         token: CF_VAL['other']['token'],
+         endpoint: CF_VAL['other']['endpoint'] },
+
+       { cmdline: "-c #{CF} --profile other -t #{TOKEN}",
+         token: TOKEN,
+         endpoint: CF_VAL['other']['endpoint'] },
+
+       { cmdline: "--config #{CF} -E #{ENDPOINT}",
+         token: CF_VAL['default']['token'],
+         endpoint: ENDPOINT }]
+    end
+
+    # Drop this into bodies when you need to check a non-specific
+    # timestamp is there
+    #
+    def a_timestamp
+      proc { |t| t.to_s =~ /^\d{10}$/ }
+    end
+
+    def a_ms_timestamp
+      proc { |t| t.to_s =~ /^\d{13}$/ }
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/spec/support/output_tester.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../constants'
+
+# We keep a bunch of Wavefront API responses as text files alongside
+# canned responses in various formats. This class groups helpers for
+# consuming those files.
+#
+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

data/spec/support/supported_commands.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../constants'
+
+class SupportedCommands
+  attr_reader :cmd_dir
+
+  def initialize
+    @cmd_dir = ROOT + 'lib' + 'wavefront-cli' + 'commands'
+  end
+
+  def all
+    files = cmd_dir.children.select do |f|
+      f.extname == '.rb' && f.basename.to_s != 'base.rb'
+    end
+
+    files.map { |f| f.basename.to_s.chomp('.rb') }
+  end
+end

data/spec/test_mixins/acl.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+module WavefrontCliTest
+  #
+  # Include this module to get full ACL tests
+  #
+  module Acl
+    def test_acl
+      assert_repeated_output('No data.') do
+        assert_cmd_gets("acls #{id}", "/api/v2/#{api_path}/acl?id=#{id}")
+      end
+
+      assert_noop("acls #{id}",
+                  'uri: GET https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/acl")
+
+      assert_invalid_id("acls #{invalid_id}")
+      assert_usage('acls')
+      assert_abort_on_missing_creds("acls #{id}")
+    end
+
+    def test_acl_clear
+      acl_stub = stub_do_acls
+      id_stub = stub_everyone_id
+
+      quietly do
+        assert_cmd_puts("acl clear #{id}",
+                        "/api/v2/#{api_path}/acl/set",
+                        [{ entityId: id,
+                           viewAcl: [],
+                           modifyAcl: [everyone_id] }].to_json)
+      end
+
+      assert_cannot_noop("acl clear #{id}")
+
+      assert_invalid_id("acl clear #{invalid_id}")
+      assert_usage('acl clear')
+      assert_abort_on_missing_creds("acl clear #{id}")
+      acl_stub.unhook
+      id_stub.unhook
+    end
+
+    def test_acl_grant_view_to_users
+      stub = stub_do_acls
+
+      quietly do
+        assert_cmd_posts("acl grant view on #{id} to #{user_acl_names}",
+                         "/api/v2/#{api_path}/acl/add",
+                         acl_body(id, user_acls, []))
+      end
+
+      assert_noop("acl grant view on #{id} to #{user_acl_names}",
+                  'uri: POST https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/acl/add",
+                  "body: #{acl_body(id, user_acls, [])}")
+
+      assert_invalid_id("acl grant view on #{invalid_id} to user")
+      assert_usage("acl grant view on #{id}")
+      assert_abort_on_missing_creds(
+        "acl grant view on #{invalid_id} to user"
+      )
+      stub.unhook
+    end
+
+    def test_acl_grant_modify_to_group
+      stub = stub_do_acls
+
+      quietly do
+        assert_cmd_posts("acl grant modify on #{id} to #{group_acls.first}",
+                         "/api/v2/#{api_path}/acl/add",
+                         acl_body(id, [], group_acls))
+      end
+
+      assert_noop("acl grant modify on #{id} to #{group_acls.first}",
+                  'uri: POST https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/acl/add",
+                  "body: #{acl_body(id, [], group_acls)}")
+
+      assert_invalid_id("acl grant modify on #{invalid_id} to user")
+      assert_usage("acl grant modify on #{id}")
+      assert_abort_on_missing_creds(
+        "acl grant modify on #{invalid_id} to user"
+      )
+      stub.unhook
+    end
+
+    def test_acl_revoke_view_from_group
+      stub = stub_do_acls
+
+      quietly do
+        assert_cmd_posts("acl revoke view on #{id} from #{group_acls.first}",
+                         "/api/v2/#{api_path}/acl/remove",
+                         acl_body(id, group_acls, []))
+      end
+
+      assert_noop("acl revoke view on #{id} from #{group_acls.first}",
+                  'uri: POST https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/acl/remove",
+                  "body: #{acl_body(id, group_acls, [])}")
+
+      assert_invalid_id("acl revoke view on #{invalid_id} from user")
+      assert_usage("acl revoke view on #{id}")
+      assert_abort_on_missing_creds(
+        "acl revoke view on #{invalid_id} from user"
+      )
+      stub.unhook
+    end
+
+    def test_acl_revoke_modify_from_user
+      stub = stub_do_acls
+
+      quietly do
+        assert_cmd_posts("acl revoke modify on #{id} from #{user_acls.first}",
+                         "/api/v2/#{api_path}/acl/remove",
+                         acl_body(id, [], user_acls.take(1)))
+      end
+
+      assert_noop("acl revoke modify on #{id} from #{user_acls.first}",
+                  'uri: POST https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/acl/remove",
+                  "body: #{acl_body(id, [], user_acls.take(1))}")
+
+      assert_invalid_id("acl revoke modify on #{invalid_id} from user")
+      assert_usage("acl revoke modify on #{id}")
+      assert_abort_on_missing_creds(
+        "acl revoke modify on #{invalid_id} from user"
+      )
+      stub.unhook
+    end
+
+    private
+
+    def stub_everyone_id
+      Spy.on_instance_method(cmd_class, :everyone_id)
+         .and_return(everyone_id)
+    end
+
+    def stub_do_acls
+      Spy.on_instance_method(cmd_class, :do_acls).and_return('')
+    end
+
+    def everyone_id
+      'abcd-1234'
+    end
+
+    def user_acls
+      %w[someone@example.com other@elsewhere.com]
+    end
+
+    def user_acl_names
+      user_acls.join(' ')
+    end
+
+    # @return [Array[String]] list of group IDs for ACL testing
+    #
+    def group_acls
+      %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672]
+    end
+
+    # @return [String] JSON representation of an ACL request
+    #   payload
+    #
+    def acl_body(id, view = [], modify = [])
+      [{ entityId: id, viewAcl: view, modifyAcl: modify }].to_json
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength