wavefront-sdk 3.6.1 → 5.0.1

data/lib/wavefront-sdk/write.rb

@@ -107,12 +107,14 @@ module Wavefront
     end
 
     # Compound the responses of all chunked writes into one. It will
-    # be 'ok' only if *everything* passed.
+    # be 'ok' only if *everything* passed. Returns 400 as the HTTP code on
+    # error, regardless of what actual errors occurred.
     # @param responses [Array[Wavefront::Response]]
     # @return Wavefront::Response
     #
     def composite_response(responses)
-      result = responses.all?(&:ok?) ? 'OK' : 'ERROR'
+      result, code = response_results(responses)
+
       summary = { sent: 0, rejected: 0, unsent: 0 }
 
       %i[sent rejected unsent].each do |k|
@@ -120,11 +122,19 @@ module Wavefront
       end
 
       Wavefront::Response.new(
-        { status: { result: result, message: nil, code: nil },
+        { status: { result: result, message: nil, code: code },
           response: summary.to_h }.to_json, nil
       )
     end
 
+    def response_results(responses)
+      if responses.all?(&:ok?)
+        ['OK', 200]
+      else
+        ['ERROR', 400]
+      end
+    end
+
     def manage_conn
       opts[:noauto] ? false : true
     end

data/spec/.rubocop.yml

@@ -5,9 +5,50 @@ Metrics/AbcSize:
 # Offense count: 5
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 300
+  Max: 400
 
 # Offense count: 46
 # Configuration parameters: CountComments, ExcludedMethods.
 Metrics/MethodLength:
   Max: 39
+
+# New cops
+#
+Lint/RaiseException:
+  Enabled: true
+Lint/StructNewOverride:
+  Enabled: true
+Style/ExponentialNotation:
+  Enabled: true
+Style/HashEachMethods:
+  Enabled: true
+Style/HashTransformKeys:
+  Enabled: true
+Style/HashTransformValues:
+  Enabled: true
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+Style/SlicingWithRange:
+  Enabled: true
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: true
+Lint/MixedRegexpCaptureTypes:
+  Enabled: true
+Style/RedundantRegexpCharacterClass:
+  Enabled: true
+Style/RedundantRegexpEscape:
+  Enabled: true
+Style/AccessorGrouping:
+  Enabled: true
+Style/BisectedAttrAccessor:
+  Enabled: true
+Style/RedundantAssignment:
+  Enabled: true
+Style/RedundantFetchBlock:
+  Enabled: true
+
+# Is nothing sacred?
+Layout/LineLength:
+  Max: 80

data/spec/spec_helper.rb

@@ -23,6 +23,10 @@ class WavefrontTestBase < MiniTest::Test
     "../lib/wavefront-sdk/#{class_basename.downcase}"
   end
 
+  def dummy_response
+    DUMMY_RESPONSE
+  end
+
   private
 
   def setup

data/spec/support/minitest_assertions.rb

@@ -20,7 +20,7 @@ module Minitest
       headers = DEFAULT_HEADERS
       stub_request(:get, uri(api_path))
         .with(headers: headers)
-        .to_return(body: DUMMY_RESPONSE, status: 200)
+        .to_return(body: dummy_response, status: 200)
       yield block
       assert_requested(:get, uri(api_path), headers: headers)
       WebMock.reset!
@@ -39,7 +39,7 @@ module Minitest
       payload = 'null' if payload.nil?
       stub_request(:post, uri(api_path))
         .with(body: payload, headers: headers)
-        .to_return(body: DUMMY_RESPONSE, status: 200)
+        .to_return(body: dummy_response, status: 200)
       yield block
       assert_requested(:post, uri(api_path), headers: headers)
       WebMock.reset!
@@ -58,7 +58,7 @@ module Minitest
       payload = 'null' if payload.nil?
       stub_request(:put, uri(api_path))
         .with(body: payload, headers: headers)
-        .to_return(body: DUMMY_RESPONSE, status: 200)
+        .to_return(body: dummy_response, status: 200)
       yield block
       assert_requested(:put, uri(api_path), headers: headers)
       WebMock.reset!
@@ -72,7 +72,7 @@ module Minitest
       headers = DEFAULT_HEADERS
       stub_request(:delete, uri(api_path))
         .with(headers: headers)
-        .to_return(body: DUMMY_RESPONSE, status: 200)
+        .to_return(body: dummy_response, status: 200)
       yield block
       assert_requested(:delete, uri(api_path), headers: headers)
       WebMock.reset!

data/spec/wavefront-sdk/account_spec.rb

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+require_relative '../test_mixins/general'
+
+# Unit tests for Account class
+#
+class WavefrontAccountTest < WavefrontTestBase
+  include WavefrontTest::List
+  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)
+    end
+
+    assert_invalid_id { wf.add_user_groups(invalid_id, groups) }
+  end
+
+  def test_business_functions
+    assert_gets("/api/v2/account/#{id}/businessFunctions") do
+      wf.business_functions(id)
+    end
+
+    assert_raises(ArgumentError) { wf.business_functions }
+  end
+
+  def test_grant_to_single_user
+    assert_posts("/api/v2/account/#{id}/grant/#{permission}") do
+      wf.grant(id, permission)
+    end
+  end
+
+  def test_grant_to_multiple_users
+    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
+    assert_posts("/api/v2/account/#{id}/removeUserGroups", groups.to_json) do
+      wf.remove_user_groups(id, groups)
+    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
+    assert_posts("/api/v2/account/revoke/#{permission}", id_list.to_json) do
+      wf.revoke(id_list, permission)
+    end
+  end
+
+  def test_delete_accounts
+    assert_posts('/api/v2/account/deleteAccounts', id_list.to_json) do
+      wf.delete_accounts(id_list)
+    end
+
+    assert_invalid_id { wf.delete_accounts([invalid_id]) }
+  end
+
+  def test_add_ingestion_policy
+    assert_posts('/api/v2/account/addingestionpolicy',
+                 { ingestionPolicyId: policy_id,
+                   accounts: id_list }.to_json) do
+      wf.add_ingestion_policy(policy_id, id_list)
+    end
+
+    assert_raises Wavefront::Exception::InvalidIngestionPolicyId do
+      wf.add_ingestion_policy(invalid_policy_id, id_list)
+    end
+
+    assert_invalid_id { wf.add_ingestion_policy(policy_id, [invalid_id]) }
+  end
+
+  def test_remove_ingestion_policy
+    assert_posts('/api/v2/account/removeingestionpolicies',
+                 { ingestionPolicyId: policy_id,
+                   accounts: id_list }.to_json) do
+      wf.remove_ingestion_policy(policy_id, id_list)
+    end
+
+    assert_raises Wavefront::Exception::InvalidIngestionPolicyId do
+      wf.add_ingestion_policy(invalid_policy_id, id_list)
+    end
+
+    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
+    'account'
+  end
+
+  def id
+    'sa::tester'
+  end
+
+  def invalid_id
+    'bad_id' * 1000
+  end
+
+  def groups
+    %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+       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
+
+  def policy_id
+    'testpolicy-1579537565010'
+  end
+
+  def invalid_policy_id
+    'badpolicy'
+  end
+
+  def payload
+    { emailAddress: id,
+      groups: %w[browse] }
+  end
+end

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

@@ -37,6 +37,49 @@ class WavefrontApiCallerTest < MiniTest::Test
     assert_requested(:get, uri, headers: headers)
   end
 
+  def test_get_flat_params
+    query = { rkey: %w[val1 val2 val3], ukey: 36 }
+    uri = "#{uri_base}/path?rkey=val1&rkey=val2&rkey=val3&ukey=36"
+    stub_request(:get, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+    wf.get_flat_params('/path', query)
+    assert_requested(:get, uri, headers: headers)
+  end
+
+  def test_get_stream
+    uri = "#{uri_base}/path?key1=val1"
+    stub_request(:get, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+    out, err = capture_io { wf.get_stream('/path', key1: 'val1') }
+    assert_requested(:get, uri, headers: headers)
+    assert_equal(out.strip, DUMMY_RESPONSE)
+    assert_empty(err)
+  end
+
+  def test_get_stream_array_params
+    uri = "#{uri_base}/path?key=val1&key=val2"
+    stub_request(:get, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+    out, err = capture_io { wf.get_stream('/path', key: %w[val1 val2]) }
+    assert_requested(:get, uri, headers: headers)
+    assert_equal(out.strip, DUMMY_RESPONSE)
+    assert_empty(err)
+  end
+
+  def test_get_stream_timestamp
+    uri = "#{uri_base}/path?key1=val1"
+    stub_request(:get, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+
+    out, err = capture_io do
+      wf.get_stream('/path',
+                    { key1: 'val1' },
+                    timestamp_chunks: true)
+    end
+
+    assert_requested(:get, uri, headers: headers)
+    out_lines = out.split("\n")
+    assert_match(/^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d \+\d{4}$/, out_lines[0])
+    assert_equal(out_lines[1], DUMMY_RESPONSE)
+    assert_empty(err)
+  end
+
   def test_post
     uri = "#{uri_base}/path"
     obj = { key: 'value' }

data/spec/wavefront-sdk/ingestionpolicy_spec.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+require_relative '../test_mixins/general'
+
+# Unit tests for IngestionPolicy class
+#
+class WavefrontIngestionPolicyTest < WavefrontTestBase
+  include WavefrontTest::List
+  include WavefrontTest::Describe
+  include WavefrontTest::Update
+  include WavefrontTest::Delete
+
+  private
+
+  def payload
+    { sampledUserAccounts: ['string'],
+      userAccountCount: 0,
+      sampledServiceAccounts: [
+        'string'
+      ],
+      serviceAccountCount: 0,
+      name: 'string',
+      id: 'string',
+      description: 'string',
+      customer: 'string',
+      lastUpdatedMs: 0,
+      lastUpdatedAccountId: 'string' }
+  end
+
+  def api_class
+    'usage/ingestionpolicy'
+  end
+
+  def id
+    'test-ingestion-policy-1579538401492'
+  end
+
+  def invalid_id
+    'bad_id'
+  end
+end