wavefront-sdk 4.0.0 → 5.2.1

data/lib/wavefront-sdk/validators.rb

@@ -48,8 +48,8 @@ module Wavefront
     #
     def wf_metric_name?(metric)
       if metric.is_a?(String) && metric.size < 1024 &&
-         (metric.match(/^#{DELTA}?[\w\-\.]+$/) ||
-          metric.match(%r{^\"#{DELTA}?[\w\-\.\/,]+\"$}))
+         (metric.match(/^#{DELTA}?[\w\-.]+$/) ||
+          metric.match(%r{^"#{DELTA}?[\w\-./,]+"$}))
         return true
       end
 
@@ -81,7 +81,7 @@ module Wavefront
       # commas in tags and descriptions. This might be too restrictive,
       # but if it is, this is the only place we need to change it.
       #
-      if str.is_a?(String) && str.size < 1024 && str =~ /^[\-\w \.,]*$/
+      if str.is_a?(String) && str.size < 1024 && str =~ /^[\-\w .,]*$/
         return true
       end
 
@@ -139,7 +139,7 @@ module Wavefront
     #
     def wf_tag?(*tags)
       Array(*tags).each do |tag|
-        unless tag.is_a?(String) && tag.size < 255 && tag =~ /^[\w:\-\.]+$/
+        unless tag.is_a?(String) && tag.size < 255 && tag =~ /^[\w:\-.]+$/
           raise Wavefront::Exception::InvalidTag, tag
         end
       end
@@ -196,7 +196,7 @@ module Wavefront
     #
     def wf_point_tag?(key, val)
       if key && val && (key.size + val.size < 254) &&
-         key =~ /^[\w\-\.:]+$/ && val !~ /\\$/
+         key =~ /^[\w\-.:]+$/ && val !~ /\\$/
         return
       end
 
@@ -391,7 +391,7 @@ module Wavefront
     #   is not valid
     #
     def wf_source_id?(source)
-      if source.is_a?(String) && source.match(/^[\w\.\-]+$/) &&
+      if source.is_a?(String) && source.match(/^[\w.\-]+$/) &&
          source.size < 1024
         return true
       end
@@ -566,7 +566,7 @@ module Wavefront
         return true
       end
 
-      raise Wavefront::Exception::InvalidPermission, id, id
+      raise Wavefront::Exception::InvalidPermission, id
     end
 
     # Ensure the given argument is a valid ingestion policy ID
@@ -615,6 +615,30 @@ module Wavefront
 
       raise Wavefront::Exception::InvalidSamplingValue, value
     end
+
+    # Ensure the given argument is a valid Wavefront role ID
+    # @param id [String] the role ID to validate
+    # @return true if the role ID is valid
+    # @raise Wavefront::Exception::InvalidRoleId if the role ID is not valid
+    #
+    def wf_role_id?(id)
+      return true if uuid?(id)
+
+      raise Wavefront::Exception::InvalidRoleId, id
+    end
+
+    # Ensure the given argument is a valid AWS external ID, used in the AWS
+    # cloud integration.
+    # @param id [String] the external ID to validate
+    # @return true if the external ID is valid
+    # @raise Wavefront::Exception::InvalidAwsExternalId if the external ID is
+    # not valid
+    #
+    def wf_aws_external_id?(id)
+      return true if id.is_a?(String) && id =~ /^[a-z0-9A-Z]{16}$/
+
+      raise Wavefront::Exception::InvalidAwsExternalId, id
+    end
   end
   # rubocop:enable Metrics/ModuleLength
 end

data/lib/wavefront-sdk/writers/core.rb

@@ -138,8 +138,8 @@ module Wavefront
       end
 
       def log_invalid_point(rawpoint, exception)
-        logger.log('Invalid point, skipping.', :info)
-        logger.log(exception.class, :info)
+        logger.log('Invalid point, skipping.', :warn)
+        logger.log(exception.class, :warn)
         logger.log(format('Invalid point: %<rawpoint>s (%<message>s)',
                           rawpoint: rawpoint,
                           message: exception.to_s), :debug)

data/spec/.rubocop.yml

@@ -1,13 +1,23 @@
-# Offense count: 64
+AllCops:
+  NewCops: enable
+
 Metrics/AbcSize:
   Max: 64
 
-# Offense count: 5
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
   Max: 400
 
-# Offense count: 46
 # Configuration parameters: CountComments, ExcludedMethods.
 Metrics/MethodLength:
   Max: 39
+
+# Is nothing sacred?
+Layout/LineLength:
+  Max: 80
+
+Style/StringConcatenation:
+  Enabled: false
+
+Style/OptionalBooleanParameter:
+  Enabled: false

data/spec/support/minitest_assertions.rb

@@ -95,18 +95,12 @@ module Minitest
     end
 
     def header_lookup(type)
-      ctype = case type
-              when :plain
-                'text/plain'
-              when :json
-                'application/json'
-              when :octet
-                'application/octet-stream'
-              when :form
-                'application/x-www-form-urlencoded'
-              end
+      ctypes = { plain: 'text/plain',
+                 json: 'application/json',
+                 octet: 'application/octet-stream',
+                 form: 'application/x-www-form-urlencoded' }
 
-      { 'Content-Type': ctype, Accept: 'application/json' }
+      { 'Content-Type': ctypes[type], Accept: 'application/json' }
     end
   end
 end

data/spec/wavefront-sdk/account_spec.rb

@@ -11,6 +11,18 @@ class WavefrontAccountTest < WavefrontTestBase
   include WavefrontTest::Delete
   include WavefrontTest::Describe
 
+  def test_add_roles
+    assert_posts("/api/v2/account/#{id}/addRoles", roles.to_json) do
+      wf.add_roles(id, roles)
+    end
+
+    assert_invalid_id { wf.add_roles(invalid_id, roles) }
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.add_roles(id, invalid_role)
+    end
+  end
+
   def test_add_user_groups
     assert_posts("/api/v2/account/#{id}/addUserGroups", groups.to_json) do
       wf.add_user_groups(id, groups)
@@ -37,6 +49,22 @@ class WavefrontAccountTest < WavefrontTestBase
     assert_posts("/api/v2/account/grant/#{permission}", id_list.to_json) do
       wf.grant(id_list, permission)
     end
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.remove_roles(id, invalid_role)
+    end
+  end
+
+  def test_remove_roles
+    assert_posts("/api/v2/account/#{id}/removeRoles", roles.to_json) do
+      wf.remove_roles(id, roles)
+    end
+
+    assert_invalid_id { wf.remove_roles(invalid_id, roles) }
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.remove_roles(id, invalid_role)
+    end
   end
 
   def test_remove_user_groups
@@ -45,12 +73,22 @@ class WavefrontAccountTest < WavefrontTestBase
     end
 
     assert_invalid_id { wf.remove_user_groups(invalid_id, groups) }
+
+    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
+      wf.remove_user_groups(id, invalid_group)
+    end
   end
 
   def test_revoke_from_single_user
     assert_posts("/api/v2/account/#{id}/revoke/#{permission}") do
       wf.revoke(id, permission)
     end
+
+    assert_invalid_id { wf.revoke(invalid_id, permission) }
+
+    assert_raises(Wavefront::Exception::InvalidPermission) do
+      wf.revoke(id, invalid_permission)
+    end
   end
 
   def test_revoke_from_multiple_users
@@ -82,7 +120,7 @@ class WavefrontAccountTest < WavefrontTestBase
   end
 
   def test_remove_ingestion_policy
-    assert_posts('/api/v2/account/removeingestionpolicy',
+    assert_posts('/api/v2/account/removeingestionpolicies',
                  { ingestionPolicyId: policy_id,
                    accounts: id_list }.to_json) do
       wf.remove_ingestion_policy(policy_id, id_list)
@@ -95,6 +133,52 @@ class WavefrontAccountTest < WavefrontTestBase
     assert_invalid_id { wf.add_ingestion_policy(policy_id, [invalid_id]) }
   end
 
+  def test_user_list
+    assert_gets('/api/v2/account/user?offset=0&limit=100') do
+      wf.user_list
+    end
+
+    assert_gets('/api/v2/account/user?offset=10&limit=50') do
+      wf.user_list(10, 50)
+    end
+  end
+
+  def test_user_describe
+    assert_gets("/api/v2/account/user/#{id}") { wf.user_describe(id) }
+
+    assert_raises(Wavefront::Exception::InvalidUserId) do
+      wf.user_describe(invalid_id)
+    end
+
+    assert_raises(ArgumentError) { wf.user_describe }
+  end
+
+  def test_user_create
+    assert_posts('/api/v2/account/user', payload.to_json) do
+      wf.user_create(payload)
+    end
+
+    assert_raises(ArgumentError) { wf.user_create }
+    assert_raises(ArgumentError) { wf.user_create('test') }
+  end
+
+  def test_user_invite
+    assert_posts('/api/v2/account/user/invite', [payload].to_json) do
+      wf.user_invite([payload])
+    end
+
+    assert_raises(ArgumentError) { wf.user_invite }
+    assert_raises(ArgumentError) { wf.user_invite('test') }
+  end
+
+  def test_validate_accounts
+    assert_posts('/api/v2/account/validateAccounts', id_list.to_json) do
+      wf.validate_accounts(id_list)
+    end
+
+    assert_raises(ArgumentError) { wf.validate_accounts }
+  end
+
   private
 
   def api_class
@@ -114,10 +198,27 @@ class WavefrontAccountTest < WavefrontTestBase
        2659191e-aad4-4302-a94e-9667e1517127]
   end
 
+  def roles
+    %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db1234
+       2659191e-aad4-4302-a94e-9667e1515678]
+  end
+
+  def invalid_role
+    %w[bad_role]
+  end
+
+  def invalid_group
+    %w[bad_group]
+  end
+
   def id_list
     %w[sa:test user@example.com]
   end
 
+  def invalid_permission
+    'some_nonsense_permission_i_made_up'
+  end
+
   def permission
     'agent_management'
   end
@@ -129,4 +230,9 @@ class WavefrontAccountTest < WavefrontTestBase
   def invalid_policy_id
     'badpolicy'
   end
+
+  def payload
+    { emailAddress: id,
+      groups: %w[browse] }
+  end
 end

data/spec/wavefront-sdk/cloudintegration_spec.rb

@@ -37,6 +37,36 @@ class WavefrontCloudIntegrationTest < WavefrontTestBase
     assert_raises(ArgumentError) { wf.disable }
   end
 
+  def test_create_aws_external_id
+    assert_posts('/api/v2/cloudintegration/awsExternalId', nil, :json) do
+      wf.create_aws_external_id
+    end
+  end
+
+  def test_delete_aws_external_id
+    assert_deletes("/api/v2/cloudintegration/awsExternalId/#{external_id}") do
+      wf.delete_aws_external_id(external_id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidAwsExternalId) do
+      wf.delete_aws_external_id(invalid_external_id)
+    end
+
+    assert_raises(ArgumentError) { wf.delete_aws_external_id }
+  end
+
+  def test_confirm_aws_external_id
+    assert_gets("/api/v2/cloudintegration/awsExternalId/#{external_id}") do
+      wf.confirm_aws_external_id(external_id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidAwsExternalId) do
+      wf.confirm_aws_external_id(invalid_external_id)
+    end
+
+    assert_raises(ArgumentError) { wf.confirm_aws_external_id }
+  end
+
   private
 
   def id
@@ -62,4 +92,12 @@ class WavefrontCloudIntegrationTest < WavefrontTestBase
   def api_class
     'cloudintegration'
   end
+
+  def external_id
+    'HqOM4mru5svd3uFp'
+  end
+
+  def invalid_external_id
+    '__nonsense__'
+  end
 end

data/spec/wavefront-sdk/core/logger_spec.rb

@@ -41,21 +41,21 @@ class WavefrontLoggerTest < MiniTest::Test
   end
 
   def test_log_logger_debug
-    l = Wavefront::Logger.new(logger: Logger.new(STDOUT))
+    l = Wavefront::Logger.new(logger: Logger.new($stdout))
     out, err = capture_subprocess_io { l.log('my message', :debug) }
     assert_match(/DEBUG -- : my message$/, out)
     assert_empty(err)
   end
 
   def test_log_logger_info
-    l = Wavefront::Logger.new(logger: Logger.new(STDOUT))
+    l = Wavefront::Logger.new(logger: Logger.new($stdout))
     out, err = capture_subprocess_io { l.log('my message', :info) }
     assert_match(/INFO -- : my message$/, out)
     assert_empty(err)
   end
 
   def test_log_logger_error
-    l = Wavefront::Logger.new(logger: Logger.new(STDOUT))
+    l = Wavefront::Logger.new(logger: Logger.new($stdout))
     out, err = capture_subprocess_io { l.log('my message', :error) }
     assert_match(/ERROR -- : my message$/, out)
     assert_empty(err)

data/spec/wavefront-sdk/credentials_spec.rb

@@ -60,9 +60,11 @@ end
 # Test individual methods. We must override the constructor to do
 # this.
 #
+# rubocop:disable Lint/MissingSuper
 class Giblets < Wavefront::Credentials
   def initialize; end
 end
+# rubocop:enable Lint/MissingSuper
 
 # And here are the tests
 #
@@ -153,10 +155,9 @@ class GibletsTest < MiniTest::Test
   end
 
   def test_load_from_file
-    assert_equal({},
-                 wf.load_from_file(
-                   [Pathname.new('/no/file/1'), Pathname.new('/no/file/2')]
-                 ))
+    assert_raises(Wavefront::Exception::InvalidConfigFile) do
+      wf.load_from_file([Pathname.new('/nofile/1'), Pathname.new('/nofile/2')])
+    end
 
     assert_equal({ file: CONF1 }, wf.load_from_file([CONF1], 'noprofile'))
 

data/spec/wavefront-sdk/metric_helper_spec.rb

@@ -118,7 +118,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
     assert_equal(1, out.select do |o|
                       o[:value] == [[2, 10.0], [1, 11.0],
                                     [1, 12.0]]
-                    end .size)
+                    end.size)
     assert_equal(1, out.select { |o| o[:tags] == WH_TAGS }.size)
     assert_equal(3, out.select { |o| o[:path] == 'test.dist1' }.size)
   end

data/spec/wavefront-sdk/role_spec.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+require_relative '../test_mixins/general'
+
+# Unit tests for Wavefront::Role
+#
+class WavefrontRoleTest < WavefrontTestBase
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::List
+  include WavefrontTest::Update
+
+  def test_add_assignees
+    assert_posts("/api/v2/role/#{id}/addAssignees", assignees.to_json) do
+      wf.add_assignees(id, assignees)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.add_assignees(invalid_id, assignees)
+    end
+  end
+
+  def test_remove_assignees
+    assert_posts("/api/v2/role/#{id}/removeAssignees", assignees.to_json) do
+      wf.remove_assignees(id, assignees)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.remove_assignees(invalid_id, assignees)
+    end
+  end
+
+  def test_grant
+    assert_posts("/api/v2/role/grant/#{permission}", roles.to_json) do
+      wf.grant(permission, roles)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.grant(permission, [invalid_id])
+    end
+
+    assert_raises(Wavefront::Exception::InvalidPermission) do
+      wf.grant('made_up_permission', roles)
+    end
+  end
+
+  def test_revoke
+    assert_posts("/api/v2/role/revoke/#{permission}", roles.to_json) do
+      wf.revoke(permission, roles)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidRoleId) do
+      wf.revoke(permission, [invalid_id])
+    end
+
+    assert_raises(Wavefront::Exception::InvalidPermission) do
+      wf.revoke('made_up_permission', roles)
+    end
+  end
+
+  private
+
+  def api_class
+    :role
+  end
+
+  def id
+    'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672'
+  end
+
+  def roles
+    %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+       2659191e-aad4-4302-a94e-9667e1517127]
+  end
+
+  def assignees
+    roles.push('sa::test')
+  end
+
+  def invalid_id
+    '__BAD_ID__'
+  end
+
+  def payload
+    { name: 'test role',
+      permissions: %w[alerts_management events_management],
+      description: 'dummy role for unit tests' }
+  end
+
+  def permission
+    'alerts_management'
+  end
+end