wavefront-cli 4.2.1 → 4.3.0

data/spec/test_mixins/delete.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'delete' commands.
+  #
+  module Delete
+    def test_delete
+      assert_repeated_output("Deleted #{friendly_name} '#{id}'.") do
+        assert_cmd_deletes("delete #{id}", "/api/v2/#{api_path}/#{id}")
+      end
+
+      assert_invalid_id("delete #{invalid_id}")
+      assert_usage('delete')
+
+      assert_noop(
+        "delete #{id}",
+        'uri: DELETE https://default.wavefront.com/api/v2/' \
+        "#{api_path}/#{id}"
+      )
+
+      assert_abort_on_missing_creds("delete #{id}")
+    end
+  end
+end

data/spec/test_mixins/deleteundelete.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'delete' and 'undelete' commands
+  #
+  module DeleteUndelete
+    def test_soft_delete
+      all_permutations { |p| soft_delete(p) }
+      assert_cannot_noop("delete #{id}")
+      assert_invalid_id("delete #{invalid_id}")
+      assert_usage('delete')
+    end
+
+    def test_hard_delete
+      all_permutations { |p| hard_delete(p) }
+    end
+
+    def test_undelete
+      out, err = capture_io do
+        assert_cmd_posts("undelete #{id}",
+                         "/api/v2/#{api_path}/#{id}/undelete", 'null')
+      end
+
+      assert_empty(err)
+      assert_equal("Undeleted #{friendly_name} '#{id}'.",
+                   out.lines.first.rstrip)
+
+      assert_invalid_id("undelete #{invalid_id}")
+      assert_usage('undelete')
+      assert_abort_on_missing_creds("undelete #{id}")
+
+      assert_noop(
+        "undelete #{id}",
+        'uri: POST https://default.wavefront.com/api/v2/' \
+        "#{api_path}/#{id}/undelete",
+        'body: null'
+      )
+
+      assert_invalid_id("undelete #{invalid_id}")
+      assert_usage('undelete')
+    end
+
+    private
+
+    def soft_delete(perm)
+      stub_request(:get,
+                   "https://#{perm[:endpoint]}/api/v2/#{api_path}/#{id}")
+        .with(headers: mk_headers(perm[:token]))
+        .to_return(object_exists_response)
+
+      stub_request(:delete,
+                   "https://#{perm[:endpoint]}/api/v2/#{api_path}/#{id}")
+        .with(headers: mk_headers(perm[:token]))
+        .to_return(status: 200)
+
+      out, err = capture_io do
+        wf.new("#{cmd_word} delete #{id} #{perm[:cmdline]}".split)
+      end
+
+      assert_empty(err)
+      assert_equal("Soft deleting #{friendly_name} '#{id}'\n" \
+                   "Deleted #{friendly_name} '#{id}'.",
+                   out.rstrip)
+
+      assert_requested(
+        :get,
+        "https://#{perm[:endpoint]}/api/v2/#{api_path}/#{id}"
+      )
+    end
+
+    def hard_delete(perm)
+      stub_request(:get,
+                   "https://#{perm[:endpoint]}/api/v2/#{api_path}/#{id}")
+        .with(headers: mk_headers(perm[:token]))
+        .to_return(object_deleted_response)
+
+      stub_request(:delete,
+                   "https://#{perm[:endpoint]}/api/v2/#{api_path}/#{id}")
+        .with(headers: mk_headers(perm[:token]))
+        .to_return(status: 200)
+
+      out, err = capture_io do
+        wf.new("#{cmd_word} delete #{id} #{perm[:cmdline]}".split)
+      end
+
+      assert_empty(err)
+      assert_equal("Permanently deleting #{friendly_name} '#{id}'\n" \
+                   "Deleted #{friendly_name} '#{id}'.",
+                   out.rstrip)
+
+      assert_requested(
+        :get,
+        "https://#{perm[:endpoint]}/api/v2/#{api_path}/#{id}"
+      )
+    end
+
+    def object_exists_response
+      { status: 200, headers: {} }
+    end
+
+    def object_deleted_response
+      { status: 404, headers: {} }
+    end
+  end
+end

data/spec/test_mixins/describe.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'describe' commands
+  #
+  module Describe
+    def test_describe
+      quietly do
+        assert_cmd_gets("describe #{id}", "/api/v2/#{api_path}/#{id}")
+      end
+
+      assert_invalid_id("describe #{invalid_id}")
+      assert_usage('describe')
+
+      assert_noop(
+        "describe #{id}",
+        "uri: GET https://default.wavefront.com/api/v2/#{api_path}/#{id}"
+      )
+
+      assert_abort_on_missing_creds("describe #{id}")
+    end
+  end
+end

data/spec/test_mixins/dump.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'dump' commands
+  #
+  module Dump
+    def test_dump_human
+      assert_exits_with(
+        "Dump format must be 'json' or 'yaml'. (Tried 'human')",
+        'dump --format=human'
+      )
+    end
+
+    def test_dump_json
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          assert_cmd_gets('dump --format=json',
+                          "/api/v2/#{api_path}?limit=999&offset=0")
+        end
+        Spy.teardown
+      end
+
+      assert_cannot_noop('dump --format=json')
+      assert_empty(err)
+      assert_equal([].to_s, out.rstrip)
+    end
+
+    def test_dump_yaml
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          assert_cmd_gets('dump --format=yaml',
+                          "/api/v2/#{api_path}?limit=999&offset=0")
+        end
+        Spy.teardown
+      end
+
+      assert_cannot_noop('dump --format=yaml')
+      assert_empty(err)
+      assert_equal('--- []', out.rstrip)
+    end
+  end
+end

data/spec/test_mixins/general.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'delete'
+require_relative 'deleteundelete'
+require_relative 'describe'
+require_relative 'dump'
+require_relative 'history'
+require_relative 'import'
+require_relative 'list'
+require_relative 'search'
+require_relative 'set'

data/spec/test_mixins/history.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Include this module to get history and describe -v tests
+  #
+  module History
+    def test_describe_v
+      quietly do
+        assert_cmd_gets("describe -v 7 #{id}",
+                        "/api/v2/#{api_path}/#{id}/history/7")
+      end
+
+      assert_noop("describe --version 10 #{id}",
+                  'uri: GET https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/#{id}/history/10")
+      assert_usage('describe -v 6')
+      assert_usage("describe -v #{id}")
+      assert_abort_on_missing_creds("describe -v 2 #{id}")
+    end
+
+    def test_history
+      assert_repeated_output('No data.') do
+        assert_cmd_gets("history #{id}",
+                        "/api/v2/#{api_path}/#{id}/history")
+      end
+
+      assert_noop("history #{id}",
+                  'uri: GET https://default.wavefront.com/api/v2/' \
+                  "#{api_path}/#{id}/history")
+      assert_usage('history')
+      assert_abort_on_missing_creds("history #{id}")
+    end
+  end
+end

data/spec/test_mixins/import.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'import' commands
+  #
+  module Import
+    def test_import
+      Spy.teardown
+
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          assert_cmd_posts("import #{import_file}",
+                           "/api/v2/#{api_path}",
+                           import_data)
+          Spy.teardown
+        end
+      end
+
+      assert_empty(err)
+      assert_equal('IMPORTED', out.strip)
+
+      assert_exits_with('File not found.', 'import /no/such/file')
+      assert_usage('import')
+      assert_abort_on_missing_creds("import #{import_file}")
+    end
+
+    def test_import_update
+      Spy.teardown
+
+      out, err = capture_io do
+        assert_raises(SystemExit) do
+          assert_cmd_puts("import -u #{update_file}",
+                          "/api/v2/#{api_path}/1556812163465",
+                          update_data)
+          Spy.teardown
+        end
+      end
+
+      assert_empty(err)
+      assert_equal('1556812163465   IMPORTED', out.strip)
+
+      assert_exits_with('File not found.', 'import /no/such/file')
+      assert_usage('import -u')
+      assert_abort_on_missing_creds("import -u #{import_file}")
+    end
+
+    def test_import_fields
+      x = cmd_instance.import_to_create(cmd_instance.load_file(import_file))
+      assert_instance_of(Hash, x)
+      import_fields.each { |f| assert_includes(x.keys, f) }
+      blocked_import_fields.each { |f| refute_includes(x.keys, f) }
+    end
+
+    private
+
+    def import_file
+      RES_DIR + 'imports' + "#{api_path}.json"
+    end
+
+    def update_file
+      RES_DIR + 'updates' + "#{api_path}.json"
+    end
+  end
+end

data/spec/test_mixins/list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'list' commands
+  #
+  module List
+    def test_list
+      quietly do
+        assert_cmd_gets('list',
+                        "/api/v2/#{api_path}?limit=100&offset=0")
+        assert_cmd_gets('list -o 5 --limit 10',
+                        "/api/v2/#{api_path}?limit=10&offset=5")
+        assert_cmd_gets('list -L 50',
+                        "/api/v2/#{api_path}?limit=50&offset=0")
+        assert_cmd_gets('list --offset 60',
+                        "/api/v2/#{api_path}?limit=100&offset=60")
+      end
+
+      assert_noop(
+        'list -o 5',
+        "uri: GET https://default.wavefront.com/api/v2/#{api_path}",
+        'params: {:offset=>"5", :limit=>100}'
+      )
+
+      assert_abort_on_missing_creds('list')
+    end
+  end
+end

data/spec/test_mixins/search.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module WavefrontCliTest
+  #
+  # Mixin to test standard 'search' commands
+  #
+  module Search
+    def test_search_equals
+      assert_repeated_output('No matches.') do
+        assert_cmd_posts("search id=#{id}",
+                         "/api/v2/search/#{search_api_path}",
+                         limit: 10,
+                         offset: 0,
+                         query: [{ key: 'id',
+                                   value: id,
+                                   matchingMethod: 'EXACT',
+                                   negated: false }],
+                         sort: { field: 'id', ascending: true })
+      end
+
+      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
+      )
+      assert_abort_on_missing_creds("search id=#{id}")
+      assert_usage('search')
+    end
+
+    def test_search_equals_with_limits
+      return if cannot_handle_offsets
+
+      assert_repeated_output('No matches.') do
+        assert_cmd_posts("search id=#{id} -L 5 --offset 15",
+                         "/api/v2/search/#{search_api_path}",
+                         limit: '5',
+                         offset: '15',
+                         query: [{ key: 'id',
+                                   value: id,
+                                   matchingMethod: 'EXACT',
+                                   negated: false }],
+                         sort: { field: 'id', ascending: true })
+      end
+
+      assert_abort_on_missing_creds("search id=#{id} -L 5 --offset 15")
+    end
+
+    def test_search_does_not_begin_with
+      assert_repeated_output('No matches.') do
+        assert_cmd_posts("search id=#{id} thing!^word --all",
+                         "/api/v2/search/#{search_api_path}",
+                         limit: 999,
+                         offset: 0,
+                         query: [{ key: 'id',
+                                   value: id,
+                                   matchingMethod: 'EXACT',
+                                   negated: false },
+                                 { key: 'thing',
+                                   value: 'word',
+                                   matchingMethod: 'STARTSWITH',
+                                   negated: true }],
+                         sort: { field: 'id', ascending: true })
+      end
+
+      assert_abort_on_missing_creds("search id=#{id} thing!^word --all")
+    end
+
+    def test_search_contains_with_limits
+      assert_repeated_output('No matches.') do
+        assert_cmd_posts('search id!~avoid -L 2',
+                         "/api/v2/search/#{search_api_path}",
+                         limit: '2',
+                         offset: 0,
+                         query: [{ key: 'id',
+                                   value: 'avoid',
+                                   matchingMethod: 'CONTAINS',
+                                   negated: true }],
+                         sort: { field: 'id', ascending: true })
+      end
+
+      assert_abort_on_missing_creds('search id!~avoid -L 2')
+    end
+
+    def test_search_incorrect_usage
+      assert_exits_with(
+        'Searches require a key, a value, and a match operator.',
+        'search value -D'
+      )
+    end
+  end
+end