wavefront-cli 4.2.1 → 4.3.0

data/spec/wavefront-cli/source_spec.rb

@@ -1,26 +1,123 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-id = '74a247a9-f67c-43ad-911f-fabafa9dc2f3joyent'
-bad_id = '(>_<)'
-word = 'source'
-
-require_relative '../spec_helper'
-require_relative "../../lib/wavefront-cli/#{word}"
-
-describe "#{word} command" do
-  missing_creds(word, ['list', "describe #{id}", "clear #{id}"])
-  cmd_to_call(word, 'list', path: "/api/v2/#{word}")
-  cmd_to_call(word, 'list -L 50', path: "/api/v2/#{word}?limit=50")
-  cmd_to_call(word, 'list -L 100 -o mysource',
-              path: "/api/v2/#{word}?cursor=mysource&limit=100")
-  cmd_to_call(word, "describe #{id}", path: "/api/v2/#{word}/#{id}")
-  cmd_to_call(word, "clear #{id}",
-              method: :delete, path: "/api/v2/#{word}/#{id}")
-  invalid_ids(word, ["describe #{bad_id}", "clear #{bad_id}"])
-  tag_tests(word, id, bad_id)
-  cmd_noop(word, 'list',
-           ['GET https://metrics.wavefront.com/api/v2/source'])
-  cmd_noop(word, 'describe src',
-           ['GET https://metrics.wavefront.com/api/v2/source/src'])
-  search_tests(word, id)
+require_relative '../support/command_base'
+require_relative '../test_mixins/tag'
+require_relative '../../lib/wavefront-cli/source'
+
+# Ensure 'source' commands produce the correct API calls.
+#
+class SourceEndToEndTest < EndToEndTest
+  include WavefrontCliTest::Describe
+  include WavefrontCliTest::Search
+  include WavefrontCliTest::Tag
+
+  def test_list
+    quietly { assert_cmd_gets('list', '/api/v2/source') }
+    assert_noop('list',
+                'uri: GET https://default.wavefront.com/api/v2/source')
+    assert_abort_on_missing_creds('list')
+  end
+
+  def test_list_with_limit
+    quietly { assert_cmd_gets('list -L 10', '/api/v2/source?limit=10') }
+
+    assert_noop('list -L 10',
+                'uri: GET https://default.wavefront.com/api/v2/source',
+                'params: {:limit=>"10"}')
+  end
+
+  def test_list_with_cursor
+    quietly do
+      assert_cmd_gets('list --cursor box', '/api/v2/source?cursor=box')
+    end
+
+    assert_usage('list --offset 3')
+  end
+
+  def test_description_set
+    quietly do
+      assert_cmd_posts("description set #{id} tester",
+                       "/api/v2/source/#{id}/description",
+                       'tester')
+    end
+
+    assert_noop("description set #{id} tester",
+                'uri: POST https://default.wavefront.com/api/v2/source' \
+                "/#{id}/description",
+                'body: tester')
+
+    assert_invalid_id("description set #{invalid_id} tester")
+    assert_usage('description')
+    assert_usage('description set')
+    assert_usage("description set #{id}")
+    assert_abort_on_missing_creds("description set #{id} tester")
+  end
+
+  def test_description_clear
+    quietly do
+      assert_cmd_deletes("description clear #{id}",
+                         "/api/v2/source/#{id}/description")
+    end
+
+    assert_noop("description clear #{id}",
+                'uri: DELETE https://default.wavefront.com/api/v2/source' \
+                "/#{id}/description")
+
+    assert_invalid_id("description clear #{invalid_id}")
+    assert_usage('description')
+    assert_usage('description clear')
+    assert_abort_on_missing_creds("description clear #{id}")
+  end
+
+  def test_clear
+    quietly do
+      assert_cmd_deletes("clear #{id}", "/api/v2/source/#{id}")
+    end
+
+    assert_noop("clear #{id}",
+                'uri: DELETE https://default.wavefront.com/api/v2/source' \
+                "/#{id}")
+
+    assert_invalid_id("clear #{invalid_id}")
+    assert_abort_on_missing_creds("clear #{id}")
+    assert_usage('clear')
+  end
+
+  # We tell the search mixin not to test with limits, so we'll have
+  # to test a cursor ourselves.
+  #
+  def test_search_equals_with_cursor
+    assert_repeated_output('No matches.') do
+      assert_cmd_posts("search id=#{id} -L 5 --cursor box",
+                       "/api/v2/search/#{api_path}",
+                       limit: '5',
+                       cursor: 'box',
+                       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 --cursor box")
+  end
+
+  private
+
+  def id
+    '74a247a9-f67c-43ad-911f-fabafa9dc2f3joyent'
+  end
+
+  def invalid_id
+    '(>_<)'
+  end
+
+  def cmd_word
+    'source'
+  end
+
+  def cannot_handle_offsets
+    true
+  end
 end

data/spec/wavefront-cli/stdlib/array_spec.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require_relative '../../spec_helper'
+require 'minitest/autorun'
 require_relative '../../../lib/wavefront-cli/stdlib/array'
 
 # Test extensions to stlib Array

data/spec/wavefront-cli/stdlib/string_spec.rb

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require_relative '../../spec_helper'
+require 'minitest/autorun'
+require_relative '../../constants'
 require_relative '../../../lib/wavefront-cli/stdlib/string'
 require_relative '../../../lib/wavefront-cli/commands/base'
 
@@ -22,14 +24,15 @@ class StringTest < MiniTest::Test
   end
 
   def test_opt_fold
-    assert_equal('short string'.opt_fold, "  short string\n")
+    assert_equal('short string'.opt_fold, '  short string')
 
     str = '-o, --option PARAMETER a rather pointless option with a ' \
           'needlessly wordy description string'
     pad = "\n" + ' ' * 12
     assert_equal("  -o, --option PARAMETER a#{pad}rather pointless" \
                  "#{pad}option with a#{pad}needlessly wordy#{pad}" \
-                 "description#{pad}string\n", str.opt_fold(30, 10))
+                 "description#{pad}string",
+                 str.opt_fold(30, 10))
   end
 
   def test_fold_options
@@ -38,12 +41,12 @@ class StringTest < MiniTest::Test
 
     assert_equal(str.opt_fold,
                  '  -l, --longoption    a long option with a quite ' \
-                 "long description which\n            needs folding\n")
+                 "long description which\n            needs folding")
     assert_equal(str.opt_fold(50),
                  "  -l, --longoption    a long option with a\n     " \
                  "       quite long description which needs\n      " \
-                 "      folding\n")
-    assert_equal(str.opt_fold(100), "  #{str}\n")
+                 '      folding')
+    assert_equal(str.opt_fold(100), "  #{str}")
   end
 
   def test_to_seconds

data/spec/wavefront-cli/user_spec.rb

@@ -1,111 +1,281 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-id = 'someone@somewhere.com'
-bad_id = 'b' * 600
-word = 'user'
-gid1 = '2659191e-aad4-4302-a94e-9667e1517127'
-gid2 = 'abcdef12-1234-abcd-1234-abcdef012345'
-priv = 'alerts_management'
-
-require_relative '../spec_helper'
-require_relative "../../lib/wavefront-cli/#{word}"
-
-describe "#{word} command" do
-  hdrs = JSON_POST_HEADERS.merge(
-    'Content-Type': 'application/x-www-form-urlencoded'
-  )
-
-  missing_creds(word, ['list',
-                       "describe #{id}",
-                       "delete #{id}",
-                       "create #{id}",
-                       "invite #{id}",
-                       "set key=val #{id}",
-                       'import file',
-                       "groups #{id}",
-                       "join #{id} #{gid1}",
-                       "leave #{id} #{gid1}",
-                       "grant #{priv} to #{id}",
-                       "revoke #{priv} from #{id}"])
-
-  cmd_to_call(word, 'list', path: "/api/v2/#{word}")
-
-  cmd_to_call(word, "describe #{id}", path: "/api/v2/#{word}/#{id}")
-
-  cmd_to_call(word, "create #{id}",
-              method: :post,
-              path:   "/api/v2/#{word}?sendEmail=false",
-              body:   { emailAddress: id,
-                        groups:       [],
-                        userGroups:   [] }.to_json)
-
-  cmd_to_call(word, "create -e #{id} -m #{priv}",
-              method: :post,
-              path:   "/api/v2/#{word}?sendEmail=true",
-              body:   { emailAddress: id,
-                        groups:       [priv],
-                        userGroups:   [] }.to_json)
-
-  cmd_to_call(word, "create #{id} -g #{gid1} -g #{gid2}",
-              method: :post,
-              path:   "/api/v2/#{word}?sendEmail=false",
-              body:   { emailAddress: id,
-                        groups:       [],
-                        userGroups:   [gid1, gid2] }.to_json)
-
-  cmd_to_call(word, "invite -m #{priv} -g #{gid2} #{id}",
-              method: :post,
-              path:   "/api/v2/#{word}/invite",
-              body:   [{ emailAddress: id,
-                         groups:       [priv],
-                         userGroups:   [gid2] }].to_json)
-
-  cmd_to_call(word, "delete #{id}",
-              method: :post,
-              path:   "/api/v2/#{word}/deleteUsers",
-              body:   [id].to_json)
-
-  cmd_to_call(word, "groups #{id}", path: "/api/v2/#{word}/#{id}")
-
-  cmd_to_call(word, "join #{id} #{gid1}",
-              method: :post,
-              path:   "/api/v2/#{word}/#{id}/addUserGroups",
-              body:   [gid1].to_json)
-
-  cmd_to_call(word, "leave #{id} #{gid2} #{gid1}",
-              method: :post,
-              path:   "/api/v2/#{word}/#{id}/removeUserGroups",
-              body:   [gid2, gid1].to_json)
-
-  cmd_to_call(word, "grant agent_management to #{id}",
-              method: :post,
-              path: "/api/v2/#{word}/#{id}/grant",
-              body:   'group=agent_management',
-              headers: hdrs)
-
-  cmd_to_call(word, "revoke agent_management from #{id}",
-              method: :post,
-              path: "/api/v2/#{word}/#{id}/revoke",
-              body:   'group=agent_management',
-              headers: hdrs)
-
-  search_tests(word, id)
-
-  invalid_ids(word, ["describe #{bad_id}",
-                     "delete #{bad_id}",
-                     "delete #{id} #{bad_id}",
-                     "delete #{bad_id}",
-                     "invite #{bad_id}",
-                     "create -e #{bad_id}",
-                     "groups #{bad_id}",
-                     "join #{bad_id} #{gid1}",
-                     "leave #{bad_id} #{gid1}",
-                     "grant #{priv} to #{bad_id}",
-                     "revoke #{priv} from #{bad_id}"])
-
-  cmd_noop(word, 'list',
-           ["GET https://metrics.wavefront.com/api/v2/#{word}"])
-  cmd_noop(word, 'describe rob@a.com',
-           ["GET https://metrics.wavefront.com/api/v2/#{word}/rob@a.com"])
-  test_list_output(word)
+require_relative '../support/command_base'
+require_relative '../../lib/wavefront-cli/user'
+
+# Ensure 'user' commands produce the correct API calls.
+#
+class UserEndToEndTest < EndToEndTest
+  include WavefrontCliTest::Search
+  include WavefrontCliTest::Describe
+
+  def test_list
+    quietly do
+      assert_cmd_gets('list', '/api/v2/user')
+    end
+    assert_noop('list',
+                'uri: GET https://default.wavefront.com/api/v2/user')
+    assert_abort_on_missing_creds('list')
+  end
+
+  def test_create
+    out, err = capture_io do
+      assert_cmd_posts(
+        "create #{id}", '/api/v2/user?sendEmail=false',
+        {  emailAddress: id,
+           groups: [],
+           userGroups: [] },
+        { status: { result: 'OK', message: '', code: 200 },
+          response: { identifier: 'test1@sysdef.xyz',
+                      customer: 'sysdef',
+                      groups: [],
+                      userGroups:
+        [{ id: '2659191e-aad4-4302-a94e-9667e1517127',
+           name: 'Everyone',
+           permissions: [],
+           customer: 'sysdef',
+           properties:
+           { nameEditable: false,
+             permissionsEditable: true,
+             usersEditable: false },
+           description: 'System group which contains all users' }] } }.to_json
+      )
+    end
+
+    assert_empty err
+    out = out.split("\n")
+    assert_equal("Created user 'test1@sysdef.xyz'.", out[0])
+    assert_equal('Permission groups', out[1])
+    assert_equal('  <none>', out[2])
+    assert_equal('User groups', out[3])
+    assert_match(/^  Everyone \([0-9a-f\-]{36}\)$/, out.last)
+  end
+
+  def test_create_with_email_invite
+    out, err = capture_io do
+      assert_cmd_posts(
+        "create -e #{id}", '/api/v2/user?sendEmail=true',
+        {  emailAddress: id,
+           groups: [],
+           userGroups: [] },
+        { status: { result: 'OK', message: '', code: 200 },
+          response: { identifier: 'test1@sysdef.xyz',
+                      customer: 'sysdef',
+                      groups: [],
+                      userGroups:
+        [{ id: '2659191e-aad4-4302-a94e-9667e1517127',
+           name: 'Everyone',
+           permissions: [],
+           customer: 'sysdef',
+           properties:
+           { nameEditable: false,
+             permissionsEditable: true,
+             usersEditable: false },
+           description: 'System group which contains all users' }] } }.to_json
+      )
+    end
+
+    assert_empty err
+    out = out.split("\n")
+    assert_equal("Created user 'test1@sysdef.xyz'.", out[0])
+    assert_equal('Permission groups', out[1])
+    assert_equal('  <none>', out[2])
+    assert_equal('User groups', out[3])
+    assert_match(/^  Everyone \([0-9a-f\-]{36}\)$/, out.last)
+  end
+
+  def test_create_with_groups
+    out, err = capture_io do
+      assert_cmd_posts(
+        "create -g #{groups[0]} -g #{groups[1]} #{id}",
+        '/api/v2/user?sendEmail=false',
+        {  emailAddress: id,
+           groups: [],
+           userGroups: groups },
+        { status: { result: 'OK', message: '', code: 200 },
+          response: { identifier: 'test1@sysdef.xyz',
+                      customer: 'sysdef',
+                      groups: [],
+                      userGroups:
+        [{ id: '2659191e-aad4-4302-a94e-9667e1517127',
+           name: 'Everyone',
+           permissions: [],
+           customer: 'sysdef',
+           properties:
+           { nameEditable: false,
+             permissionsEditable: true,
+             usersEditable: false },
+           description: 'System group which contains all users' }] } }.to_json
+      )
+    end
+
+    assert_empty err
+    out = out.split("\n")
+    assert_equal("Created user 'test1@sysdef.xyz'.", out[0])
+    assert_equal('Permission groups', out[1])
+    assert_equal('  <none>', out[2])
+    assert_equal('User groups', out[3])
+    assert_match(/^  Everyone \([0-9a-f\-]{36}\)$/, out.last)
+  end
+
+  def test_invite
+    assert_repeated_output("Sent invitation to '#{id}'.") do
+      assert_cmd_posts("invite -m #{privilege} -g #{groups[1]} #{id}",
+                       '/api/v2/user/invite',
+                       [{ emailAddress: id,
+                          groups: [privilege],
+                          userGroups: [groups[1]] }].to_json)
+    end
+
+    assert_invalid_id("invite -m #{privilege} #{invalid_id}")
+    assert_abort_on_missing_creds("invite -m #{privilege} #{id}")
+    assert_usage('invite')
+  end
+
+  def test_delete
+    assert_repeated_output("Deleted '#{id}'.") do
+      assert_cmd_posts("delete #{id}",
+                       '/api/v2/user/deleteUsers',
+                       [id].to_json)
+    end
+
+    assert_invalid_id("delete #{invalid_id}")
+    assert_abort_on_missing_creds("delete #{id}")
+    assert_usage('delete')
+  end
+
+  def test_groups
+    assert_repeated_output('a7d26e51-cce1-4515-5ae8-1946f57ef5b3 (Everyone)') do
+      assert_cmd_gets("groups #{id}", "/api/v2/user/#{id}",
+                      [{ identifier: 'someone@example.com',
+                         userGroups:
+     [{ id: 'a7d26e51-cce1-4515-5ae8-1946f57ef5b3',
+        name: 'Everyone',
+        description: 'System group which contains all users' }] }].to_json)
+    end
+
+    assert_invalid_id("groups #{invalid_id}")
+    assert_abort_on_missing_creds("groups #{id}")
+    assert_usage('groups')
+  end
+
+  def test_privileges
+    quietly do
+      assert_cmd_gets("privileges #{id}", "/api/v2/user/#{id}")
+    end
+
+    assert_invalid_id("privileges #{invalid_id}")
+    assert_usage('privileges')
+
+    assert_noop(
+      "privileges #{id}",
+      "uri: GET https://default.wavefront.com/api/v2/user/#{id}"
+    )
+
+    assert_abort_on_missing_creds("privileges #{id}")
+  end
+
+  def test_join
+    assert_repeated_output("Added '#{id}' to '#{groups[0]}'.") do
+      assert_cmd_posts("join #{id} #{groups[0]}",
+                       "/api/v2/user/#{id}/addUserGroups",
+                       [groups[0]].to_json)
+    end
+  end
+
+  def test_leave
+    assert_repeated_output(
+      "Removed '#{id}' from '#{groups[0]}', '#{groups[1]}'."
+    ) do
+      assert_cmd_posts("leave #{id} #{groups[0]} #{groups[1]}",
+                       "/api/v2/user/#{id}/removeUserGroups",
+                       groups.to_json)
+    end
+
+    assert_invalid_id("leave #{invalid_id} #{groups[0]} #{groups[1]}")
+    assert_abort_on_missing_creds("leave #{id} #{groups[0]} #{groups[1]}")
+    assert_usage('leave')
+  end
+
+  def test_grant
+    assert_repeated_output("Granted '#{privilege}' to '#{id}'.") do
+      assert_cmd_posts("grant #{privilege} to #{id}",
+                       "/api/v2/user/#{id}/grant",
+                       group: privilege)
+    end
+
+    assert_invalid_id("grant #{privilege} to #{invalid_id}")
+    assert_abort_on_missing_creds("grant #{privilege} to #{id}")
+    assert_usage("grant #{privilege}")
+  end
+
+  def test_revoke
+    assert_repeated_output("Revoked '#{privilege}' from '#{id}'.") do
+      assert_cmd_posts("revoke #{privilege} from #{id}",
+                       "/api/v2/user/#{id}/revoke",
+                       group: privilege)
+    end
+
+    assert_invalid_id("revoke #{privilege} from #{invalid_id}")
+    assert_abort_on_missing_creds("revoke #{privilege} from #{id}")
+    assert_usage("revoke #{privilege} #{id}")
+  end
+
+  # We have to override most of the dump tests because of the
+  # fudgery that goes on in the user API class.
+  #
+  def test_dump_json
+    out, err = capture_io do
+      assert_raises(SystemExit) do
+        assert_cmd_gets('dump --format=json', '/api/v2/user', list_response)
+      end
+      Spy.teardown
+    end
+
+    assert_empty(err)
+    assert_equal('[{"items":[{"identifier":"user1@example.com"},' \
+                 '{"identifier":"user2@example.com"}]}]', out.strip)
+  end
+
+  def test_dump_yaml
+    out, err = capture_io do
+      assert_raises(SystemExit) do
+        assert_cmd_gets('dump --format=yaml', '/api/v2/user', list_response)
+      end
+      Spy.teardown
+    end
+
+    assert_empty(err)
+    assert_equal("---\n- items:\n  - identifier: user1@example.com\n  " \
+                 '- identifier: user2@example.com', out.strip)
+  end
+
+  private
+
+  def id
+    'someonesomewhere.com'
+  end
+
+  def invalid_id
+    'bad' * 200
+  end
+
+  def cmd_word
+    'user'
+  end
+
+  def groups
+    %w[2659191e-aad4-4302-a94e-9667e1517127
+       abcdef12-1234-abcd-1234-abcdef012345]
+  end
+
+  def list_response
+    { items: [{ identifier: 'user1@example.com' },
+              { identifier: 'user2@example.com' }] }.to_json
+  end
+
+  def privilege
+    'alerts_management'
+  end
 end