wavefront-cli 6.0.0 → 8.0.1

data/lib/wavefront-cli/role.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'role' API.
+  #
+  class Role < WavefrontCli::Base
+    alias do_permissions do_describe
+
+    def do_create
+      wf.create({ name: options[:'<name>'],
+                  description: options[:description],
+                  permissions: options[:permission] }.compact)
+    end
+
+    def do_accounts
+      things_with_role(:account, options[:'<id>'])
+    end
+
+    def do_groups
+      things_with_role(:usergroup, options[:'<id>'])
+    end
+
+    def do_give_to
+      wf.add_assignees(options[:'<id>'], options[:'<member>'])
+    end
+
+    def do_take_from
+      wf.remove_assignees(options[:'<id>'], options[:'<member>'])
+    end
+
+    def do_grant
+      wf.grant(options[:'<permission>'], Array(options[:'<id>']))
+    end
+
+    def do_revoke
+      wf.revoke(options[:'<permission>'], Array(options[:'<id>']))
+    end
+
+    private
+
+    # Search for objects of the given type with the given role
+    #
+    def things_with_role(thing, role)
+      require 'wavefront-sdk/search'
+      wfs = Wavefront::Search.new(mk_creds, mk_opts)
+      wfs.search(thing,
+                 conds_to_query(["roles~#{role}"]),
+                 limit: :all, sort_field: :id)
+    end
+  end
+end

data/lib/wavefront-cli/serviceaccount.rb

@@ -173,20 +173,14 @@ module WavefrontCli
 
     def validate_groups
       options[:group].each { |g| wf_usergroup_id?(g) }
-    rescue Wavefront::Exception::InvalidUserGroupId => e
-      raise e, 'Invalid usergroup ID'
     end
 
     def validate_tokens
       options[:usertoken].each { |t| wf_apitoken_id?(t) }
-    rescue Wavefront::Exception::InvalidApiTokenId => e
-      raise e, 'Invalid API token'
     end
 
     def validate_perms
       options[:permission].each { |p| wf_permission?(p) }
-    rescue Wavefront::Exception::InvalidPermission => e
-      raise e, 'Invalid permission'
     end
 
     def descriptive_name

data/lib/wavefront-cli/spy.rb

@@ -42,14 +42,6 @@ module WavefrontCli
 
     private
 
-    def require_sdk_class
-      require 'wavefront-sdk/unstable/spy'
-    end
-
-    def _sdk_class
-      'Wavefront::Unstable::Spy'
-    end
-
     def rate
       return 0.01 unless options[:rate]
 

data/lib/wavefront-cli/usergroup.rb

@@ -12,27 +12,27 @@ module WavefrontCli
     end
 
     alias do_users do_describe
+    alias do_roles do_describe
     alias do_permissions do_describe
 
     def do_create
-      wf.create(name: options[:'<name>'],
-                permissions: options[:permission])
+      wf.create(name: options[:'<name>'], roleIDs: options[:roleid])
     end
 
-    def do_add_user
+    def do_add_to
       wf.add_users_to_group(options[:'<id>'], options[:'<user>'])
     end
 
-    def do_remove_user
+    def do_remove_from
       wf.remove_users_from_group(options[:'<id>'], options[:'<user>'])
     end
 
-    def do_grant
-      wf.grant(options[:'<permission>'], Array(options[:'<id>']))
+    def do_add_role
+      wf.add_roles_to_group(options[:'<id>'], options[:'<role>'])
     end
 
-    def do_revoke
-      wf.revoke(options[:'<permission>'], Array(options[:'<id>']))
+    def do_remove_role
+      wf.remove_roles_from_group(options[:'<id>'], options[:'<role>'])
     end
 
     def import_to_create(raw)

data/lib/wavefront-cli/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WF_CLI_VERSION = '6.0.0'
+WF_CLI_VERSION = '8.0.1'

data/lib/wavefront-cli/write.rb

@@ -9,15 +9,16 @@ module WavefrontCli
   #
   class Write < Base
     attr_reader :fmt
+
     include Wavefront::Mixins
     SPLIT_PATTERN = /\s(?=(?:[^"]|"[^"]*")*$)/.freeze
 
     # rubocop:disable Metrics/AbcSize
-    def do_point
+    def do_point(value = options[:'<value>'])
       tags = tags_to_hash(options[:tag])
 
       p = { path: options[:'<metric>'],
-            value: options[:'<value>'].delete('\\').to_f }
+            value: sane_value(value) }
 
       p[:tags] = tags unless tags.empty?
       p[:source] = options[:host] if options[:host]
@@ -36,6 +37,31 @@ module WavefrontCli
       send_point(make_distribution_point(tags_to_hash(options[:tag])))
     end
 
+    def do_noise
+      loop do
+        do_point(random_value(options[:min] || -10, options[:max] || 10))
+        sleep(sleep_time)
+      end
+    end
+
+    def random_value(min, max)
+      return min if min == max
+
+      rand(max.to_f - min.to_f) + min.to_f
+    end
+
+    def sane_value(value)
+      return value if value.is_a?(Numeric)
+
+      raise WavefrontCli::Exception::InvalidValue unless value.is_a?(String)
+
+      value.delete('\\').to_f
+    end
+
+    def sleep_time
+      options[:interval] ? options[:interval].to_f : 1
+    end
+
     # rubocop:disable Metrics/AbcSize
     def make_distribution_point(tags)
       { path: options[:'<metric>'],
@@ -141,12 +167,10 @@ module WavefrontCli
     #
     def process_input_file(data)
       data.each_with_object([]) do |l, a|
-        begin
-          a.<< process_line(l)
-        rescue WavefrontCli::Exception::UnparseableInput => e
-          puts "Bad input. #{e.message}."
-          next
-        end
+        a.<< process_line(l)
+      rescue WavefrontCli::Exception::UnparseableInput => e
+        puts "Bad input. #{e.message}."
+        next
       end
     end
 
@@ -167,7 +191,7 @@ module WavefrontCli
     #
     def read_stdin
       open_connection
-      STDIN.each_line { |l| call_write(process_line(l.strip), false) }
+      $stdin.each_line { |l| call_write(process_line(l.strip), false) }
       close_connection
     rescue SystemExit, Interrupt
       puts 'ctrl-c. Exiting.'
@@ -270,7 +294,6 @@ module WavefrontCli
     # @raise WavefrontCli::Exception::UnparseableInput if the line
     #   doesn't look right
     #
-    # rubocop:disable Metrics/CyclomaticComplexity
     # rubocop:disable Metrics/MethodLength
     # rubocop:disable Metrics/AbcSize
     def process_line(line)
@@ -293,7 +316,6 @@ module WavefrontCli
     end
     # rubocop:enable Metrics/AbcSize
     # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/CyclomaticComplexity
 
     # We can get tags from the file, from the -T option, or both.
     # Merge them, making the -T win if there is a collision.

data/spec/.rubocop.yml

@@ -1,4 +1,7 @@
 ---
+AllCops:
+  NewCops: enable
+
 Metrics/MethodLength:
   Max: 30
 
@@ -8,9 +11,13 @@ Metrics/AbcSize:
 Metrics/ClassLength:
   Max: 300
 
-Style/HashEachMethods:
-    Enabled: true
-Style/HashTransformKeys:
-    Enabled: true
-Style/HashTransformValues:
-    Enabled: true
+# Is nothing sacred?
+Layout/LineLength:
+  Max: 80
+
+Style/IfUnlessModifier:
+  Enabled: false # because it wants to make lines >80 chars
+Style/StringConcatenation:
+  Enabled: false
+Style/OptionalBooleanParameter:
+  Enabled: false

data/spec/support/minitest_assertions.rb

@@ -105,11 +105,9 @@ module Minitest
                    "performed as no-ops.\n", err)
     end
 
-    def assert_repeated_output(msg)
+    def assert_repeated_output(msg, &block)
       begin
-        out, err = capture_io do
-          yield
-        end
+        out, err = capture_io(&block)
       rescue SystemExit => e
         puts e.backtrace
         p e

data/spec/test_mixins/delete.rb

@@ -15,8 +15,7 @@ module WavefrontCliTest
 
       assert_noop(
         "delete #{id}",
-        'uri: DELETE https://default.wavefront.com/api/v2/' \
-        "#{api_path}/#{id}"
+        "uri: DELETE https://default.wavefront.com/api/v2/#{api_path}/#{id}"
       )
 
       assert_abort_on_missing_creds("delete #{id}")

data/spec/wavefront-cli/account_spec.rb

@@ -0,0 +1,303 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../support/command_base'
+require_relative '../../lib/wavefront-cli/account'
+
+# Ensure 'account' commands produce the correct API calls.
+#
+class AccountEndToEndTest < EndToEndTest
+  include WavefrontCliTest::List
+  include WavefrontCliTest::Delete
+  include WavefrontCliTest::Describe
+  include WavefrontCliTest::Search
+
+  def test_role_add_to
+    quietly do
+      assert_cmd_posts("role add to #{id} #{roles.join(' ')}",
+                       "/api/v2/account/#{id}/addRoles",
+                       roles.to_json)
+    end
+
+    assert_invalid_id("role add to #{invalid_id} #{roles.first}")
+    assert_invalid_id("role add to #{id} #{invalid_role}")
+    assert_abort_on_missing_creds("role add to #{id} #{roles.last}")
+    assert_usage("role add to #{roles.first}")
+  end
+
+  def test_role_remove_from
+    quietly do
+      assert_cmd_posts("role remove from #{id} #{roles.join(' ')}",
+                       "/api/v2/account/#{id}/removeRoles",
+                       roles.to_json)
+    end
+
+    assert_invalid_id("role remove from #{invalid_id} #{roles.first}")
+    assert_abort_on_missing_creds("role remove from #{id} #{roles.last}")
+    assert_usage("role remove from #{roles.first}")
+  end
+
+  def test_add_group_to
+    assert_repeated_output("Added '#{id}' to '#{groups.first}'.") do
+      assert_cmd_posts("group add to #{id} #{groups.first}",
+                       "/api/v2/account/#{id}/addUserGroups",
+                       [groups.first].to_json)
+    end
+
+    assert_invalid_id("group add to #{id} #{invalid_group}")
+    assert_invalid_id("group add to #{invalid_id} #{groups.first}")
+    assert_abort_on_missing_creds("group add to #{id} #{groups.last}")
+    assert_usage("group add to #{groups.first}")
+  end
+
+  def test_remove_group_from
+    assert_repeated_output("Removed '#{id}' from '#{groups.first}', " \
+                           "'#{groups.last}'.") do
+      assert_cmd_posts("group remove from #{id} #{groups.join(' ')}",
+                       "/api/v2/account/#{id}/removeUserGroups",
+                       groups.to_json)
+    end
+
+    assert_invalid_id("group remove from #{id} #{invalid_group}")
+    assert_invalid_id("group remove from #{invalid_id} #{groups.first}")
+    assert_abort_on_missing_creds("group remove from #{id} #{groups.last}")
+    assert_usage("group remove from #{groups.first}")
+  end
+
+  def test_business_functions
+    quietly do
+      assert_cmd_gets("business functions #{id}",
+                      "/api/v2/account/#{id}/businessFunctions")
+    end
+
+    assert_noop("business functions #{id}",
+                'uri: GET https://default.wavefront.com/api/v2/account/' \
+                "#{id}/businessFunctions")
+    assert_invalid_id("business functions #{invalid_id}")
+    assert_abort_on_missing_creds("business functions #{id}")
+    assert_usage('business functions')
+  end
+
+  def test_grant_to
+    assert_repeated_output("Granted '#{permission}' to '#{id}'.") do
+      assert_cmd_posts("grant #{permission} to #{id}",
+                       "/api/v2/account/grant/#{permission}",
+                       [id].to_json)
+    end
+
+    assert_invalid_id("grant #{permission} to #{invalid_id}")
+    assert_abort_on_missing_creds("grant #{permission} to #{id}")
+    assert_usage("grant #{permission}")
+  end
+
+  def test_revoke_from
+    assert_repeated_output("Revoked '#{permission}' from '#{id}'.") do
+      assert_cmd_posts("revoke #{permission} from #{id}",
+                       "/api/v2/account/revoke/#{permission}",
+                       [id].to_json)
+    end
+
+    out, err = capture_io do
+      assert_raises(SystemExit) do
+        wf.new("account revoke #{invalid_permission} from #{id}".split)
+      end
+    end
+
+    assert_empty out
+    assert_equal("'made_up_permission' is not a valid Wavefront permission.",
+                 err.strip)
+
+    assert_invalid_id("revoke #{permission} from #{invalid_id}")
+    assert_abort_on_missing_creds("revoke #{permission} from #{id}")
+    assert_usage("revoke #{permission}")
+  end
+
+  def test_roles
+    assert_repeated_output("'#{id}' has no roles.") do
+      assert_cmd_gets("roles #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_abort_on_missing_creds("roles #{id}")
+    assert_invalid_id("roles #{invalid_id}")
+    assert_usage('roles')
+  end
+
+  def test_add_ingestionpolicy_to
+    assert_repeated_output("Added '#{policy}' to '#{id}'.") do
+      assert_cmd_posts("ingestionpolicy add to #{id} #{policy}",
+                       '/api/v2/account/addingestionpolicy',
+                       { ingestionPolicyId: policy,
+                         accounts: [id] }.to_json)
+    end
+
+    assert_invalid_id("ingestionpolicy add to #{invalid_id} #{policy}")
+    assert_invalid_id("ingestionpolicy add to #{id} #{invalid_policy}")
+    assert_abort_on_missing_creds("ingestionpolicy add to #{id} #{policy}")
+    assert_usage("ingestionpolicy add to #{policy}")
+  end
+
+  def test_remove_ingestionpolicy_remove
+    assert_repeated_output("Removed '#{policy}' from '#{id}'.") do
+      assert_cmd_posts("ingestionpolicy remove from #{id} #{policy}",
+                       '/api/v2/account/removeingestionpolicies',
+                       { ingestionPolicyId: policy,
+                         accounts: [id] }.to_json)
+    end
+
+    assert_invalid_id("ingestionpolicy remove from #{invalid_id} #{policy}")
+    assert_invalid_id("ingestionpolicy remove from #{id} #{invalid_policy}")
+    assert_abort_on_missing_creds("ingestionpolicy remove from #{id} #{policy}")
+    assert_usage("ingestionpolicy remove from #{policy}")
+  end
+
+  def test_ingestionpolicy
+    assert_repeated_output("'#{id}' has no ingestion policy.") do
+      assert_cmd_gets("ingestionpolicy #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_abort_on_missing_creds("ingestionpolicy #{id}")
+    assert_invalid_id("ingestionpolicy #{invalid_id}")
+    assert_usage('ingestionpolicy')
+  end
+
+  def test_groups
+    assert_repeated_output("'#{id}' does not belong to any groups.") do
+      assert_cmd_gets("groups #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_invalid_id("groups #{invalid_id}")
+    assert_abort_on_missing_creds("groups #{id}")
+    assert_usage('groups')
+  end
+
+  def test_permissions
+    assert_repeated_output("'#{id}' does not have any permissions " \
+                           'directly attached.') do
+      assert_cmd_gets("permissions #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_abort_on_missing_creds("permissions #{id}")
+    assert_invalid_id("permissions #{invalid_id}")
+    assert_usage('permissions')
+  end
+
+  def test_invite_with_group
+    expected_body = [{ emailAddress: id,
+                       userGroups: [groups.first],
+                       groups: [] }].to_json
+
+    assert_repeated_output("Sent invitation to '#{id}'.") do
+      assert_cmd_posts("invite user -g #{groups.first} #{id}",
+                       '/api/v2/account/user/invite',
+                       expected_body)
+    end
+
+    assert_noop("invite user -g #{groups.first} #{id}",
+                'uri: POST https://default.wavefront.com/api/v2/account/user' \
+                '/invite',
+                "body: #{expected_body}")
+    assert_invalid_id("invite user -g #{groups.first} #{invalid_id}")
+    assert_abort_on_missing_creds("invite user -g #{groups.first} #{id}")
+    assert_usage('invite user')
+  end
+
+  def test_invite_with_role_and_policy
+    expected_body = [{ emailAddress: id,
+                       roles: roles,
+                       ingestionPolicyId: policy,
+                       groups: [] }].to_json
+
+    assert_repeated_output("Sent invitation to '#{id}'.") do
+      assert_cmd_posts(
+        "invite user -r #{roles.join(' -r ')} -i #{policy} #{id}",
+        '/api/v2/account/user/invite',
+        expected_body
+      )
+    end
+
+    assert_noop("invite user -r #{roles.join(' -r ')} -i #{policy} #{id}",
+                'uri: POST https://default.wavefront.com/api/v2/account/user' \
+                '/invite',
+                "body: #{expected_body}")
+    assert_invalid_id("invite user -m #{permission} #{invalid_id}")
+    assert_abort_on_missing_creds("invite user -m #{permission} #{id}")
+    assert_usage('invite user')
+  end
+
+  def test_validate
+    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'))
+    end
+
+    assert_noop(cmd,
+                'uri: POST https://default.wavefront.com/api/v2/account' \
+                '/validateAccounts',
+                "body: #{user_list.to_json}")
+    assert_abort_on_missing_creds(cmd)
+    assert_usage('validate')
+  end
+
+  private
+
+  def id
+    'someone@example.com'
+  end
+
+  def invalid_id
+    'bad' * 200
+  end
+
+  def cmd_word
+    'account'
+  end
+
+  def groups
+    %w[2659191e-aad4-4302-a94e-9667e1517127
+       abcdef12-1234-abcd-1234-abcdef012345]
+  end
+
+  def invalid_group
+    '__bad_group__'
+  end
+
+  def roles
+    %w[87654321-aad4-4302-a94e-9667e1517127
+       12345678-1234-abcd-1234-abcdef012345]
+  end
+
+  def invalid_role
+    '__bad_role__'
+  end
+
+  def list_response
+    { items: [{ identifier: 'user1@example.com' },
+              { identifier: 'user2@example.com' }] }.to_json
+  end
+
+  def permission
+    'alerts_management'
+  end
+
+  def invalid_permission
+    'made_up_permission'
+  end
+
+  def user_list
+    %w[someone@example.com
+       sa:testsysacct
+       no-such-thing]
+  end
+
+  def policy
+    'test-policy-1579802191234'
+  end
+
+  def invalid_policy
+    '__some_nonsense_or_other__'
+  end
+end