wavefront-sdk 3.0.2 → 3.2.0

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ SimpleCov.start do
   add_filter '/spec/'
 end
 require 'minitest/autorun'
+require 'spy/integration'
 require 'webmock/minitest'
 
 # rubocop:disable Style/MutableConstant
@@ -14,6 +15,8 @@ CREDS = { endpoint: 'test.example.com',
           token:    '0123456789-ABCDEF' }
 # rubocop:enable Style/MutableConstant
 
+W_CREDS = { proxy: 'wavefront', port: 2878 }.freeze
+
 POST_HEADERS = {
   'Content-Type': 'text/plain', Accept: 'application/json'
 }.freeze
@@ -29,6 +32,11 @@ DUMMY_RESPONSE = '{"status":{"result":"OK","message":"","code":200},' \
 RESOURCE_DIR = (Pathname.new(__FILE__).dirname +
                 'wavefront-sdk' + 'resources').freeze
 
+U_ACL_1 = { name: 'someone@example.com', id: 'someone@example.com' }.freeze
+U_ACL_2 = { name: 'other@elsewhere.com', id: 'other@elsewhere.com' }.freeze
+GRP_ACL = { name: 'example group',
+            id:   'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672' }.freeze
+
 # Common testing code
 class WavefrontTestBase < MiniTest::Test
   attr_reader :wf, :wf_noop, :headers
@@ -160,6 +168,48 @@ class WavefrontTestBase < MiniTest::Test
       wf.send(method, id, '<!!!>')
     end
   end
+
+  def acl_tester(id)
+    id2 = id.reverse
+    should_work(:acls, [[id, id2]], "acl?id=#{id}&id=#{id2}")
+
+    should_work(:acl_add, [id, [U_ACL_1, U_ACL_2], [GRP_ACL]],
+                'acl/add', :post, {}, acl_body(id,
+                                               [U_ACL_1, U_ACL_2],
+                                               [GRP_ACL]))
+
+    should_work(:acl_add, [id, [U_ACL_1, U_ACL_2]],
+                'acl/add', :post, {}, acl_body(id,
+                                               [U_ACL_1, U_ACL_2]))
+    assert_raises(ArgumentError) { wf.acl_add(id, U_ACL_1) }
+    assert_raises(ArgumentError) { wf.acl_add(id, [U_ACL_1], GRP_ACL) }
+
+    should_work(:acl_delete, [id, [U_ACL_1, U_ACL_2], [GRP_ACL]],
+                'acl/remove', :post, {}, acl_body(id,
+                                                  [U_ACL_1, U_ACL_2],
+                                                  [GRP_ACL]))
+
+    should_work(:acl_delete, [id, [U_ACL_1, U_ACL_2]],
+                'acl/remove', :post, {}, acl_body(id,
+                                                  [U_ACL_1, U_ACL_2]))
+    assert_raises(ArgumentError) { wf.acl_delete(id, U_ACL_1) }
+
+    should_work(:acl_set, [id, [U_ACL_1, U_ACL_2], [GRP_ACL]],
+                'acl/set', :put, {}, acl_body(id,
+                                              [U_ACL_1, U_ACL_2],
+                                              [GRP_ACL]))
+
+    should_work(:acl_set, [id, [U_ACL_1, U_ACL_2]],
+                'acl/set', :put, {}, acl_body(id,
+                                              [U_ACL_1, U_ACL_2]))
+    assert_raises(ArgumentError) { wf.acl_set(id, U_ACL_1) }
+  end
+
+  # used by acl_tester
+  #
+  def acl_body(id, view = [], modify = [])
+    [{ entityId: id, viewAcl: view, modifyAcl: modify }].to_json
+  end
 end
 
 # Extensions to stdlib
@@ -182,6 +232,14 @@ class Mocket
   def ok?
     true
   end
+
+  def response
+    { sent: 1, rejected: 0, unsent: 0 }
+  end
+
+  def status
+    { result: 'OK', message: nil, code: nil }
+  end
 end
 
 # A mock socket which says things went wrong.
@@ -190,4 +248,12 @@ class BadMocket < Mocket
   def ok?
     false
   end
+
+  def status
+    { result: 'ERROR', message: nil, code: nil }
+  end
+
+  def response
+    { sent: 0, rejected: 1, unsent: 0 }
+  end
 end

data/spec/wavefront-sdk/alert_spec.rb

@@ -55,6 +55,16 @@ class WavefrontAlertTest < WavefrontTestBase
     assert_raises(ArgumentError) { wf.create('test') }
   end
 
+  def test_clone
+    should_work(:clone, [ALERT], [ALERT, :clone].uri_concat,
+                :post, JSON_POST_HEADERS,
+                { id: ALERT, name: nil, v: nil }.to_json)
+    should_work(:clone, [ALERT, 4], [ALERT, :clone].uri_concat,
+                :post, JSON_POST_HEADERS,
+                { id: ALERT, name: nil, v: 4 }.to_json)
+    assert_raises(ArgumentError) { wf.clone }
+  end
+
   def test_describe_v
     should_work(:describe, [ALERT, 4], "#{ALERT}/history/4")
   end
@@ -92,6 +102,10 @@ class WavefrontAlertTest < WavefrontTestBase
     tag_tester(ALERT)
   end
 
+  def test_acls
+    acl_tester(ALERT)
+  end
+
   def test_undelete
     should_work(:undelete, ALERT, ["#{ALERT}/undelete", nil], :post,
                 POST_HEADERS)

data/spec/wavefront-sdk/{support → api_mixins}/user_mixins_spec.rb

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 
 require_relative '../../spec_helper'
-require_relative '../../../lib/wavefront-sdk/support/user_mixins'
+require_relative '../../../lib/wavefront-sdk/api_mixins/user'
 require_relative '../../../lib/wavefront-sdk/validators'
 require_relative '../../../lib/wavefront-sdk/core/exception'
 
 # Test user mixins
 #
 class WavefrontUserMixinsTest < MiniTest::Test
-  include Wavefront::UserMixins
+  include Wavefront::Mixin::User
   include Wavefront::Validators
 
   def test_validate_user_list

data/spec/wavefront-sdk/apitoken_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+API_TOKEN_ID = '17db4cc1-65f6-40a8-a1fa-6fcae460c4bd'.freeze
+
+# Unit tests for API token class
+#
+class WavefrontApiTokenTest < WavefrontTestBase
+  def test_list
+    should_work(:list, [], '')
+  end
+
+  def test_create
+    should_work(:create, [], '', :post, JSON_POST_HEADERS, nil)
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, API_TOKEN_ID, API_TOKEN_ID, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_rename
+    should_work(:rename, [API_TOKEN_ID, 'token name'],
+                API_TOKEN_ID, :put, JSON_POST_HEADERS,
+                { tokenID: API_TOKEN_ID, tokenName: 'token name' }.to_json)
+    should_be_invalid(:rename, ['!invalid token!', 'token name'])
+    assert_raises(ArgumentError) { wf.rename }
+  end
+end

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

@@ -3,7 +3,6 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/core/api'
 
-#
 # Test SDK core API class
 #
 class WavefrontCoreApiTest < MiniTest::Test
@@ -15,8 +14,8 @@ class WavefrontCoreApiTest < MiniTest::Test
 
   def test_time_to_ms
     now_ms = Time.now.to_i * 1000
-    assert_equal wf.time_to_ms(now_ms), now_ms
-    assert_equal wf.time_to_ms(1_469_711_187), 1_469_711_187_000
+    assert_equal(now_ms, wf.time_to_ms(now_ms))
+    assert_equal(1_469_711_187_000, wf.time_to_ms(1_469_711_187))
     refute wf.time_to_ms([])
     refute wf.time_to_ms('1469711187')
   end
@@ -25,7 +24,6 @@ class WavefrontCoreApiTest < MiniTest::Test
     wf.instance_variable_set('@update_keys', %i[k1 k2])
     body = { k1: 'ov1', k2: 'ov2', k3: 'ov3' }
     upd = { k2: 'nv1' }
-
-    assert_equal(wf.hash_for_update(body, upd), k1: 'ov1', k2: 'nv1')
+    assert_equal({ k1: 'ov1', k2: 'nv1' }, wf.hash_for_update(body, upd))
   end
 end

data/spec/wavefront-sdk/credentials_spec.rb

@@ -4,8 +4,6 @@ require 'pathname'
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/credentials'
 
-p RESOURCE_DIR
-
 CONF1 = RESOURCE_DIR + 'test.conf'
 CONF2 = RESOURCE_DIR + 'test2.conf'
 
@@ -22,9 +20,9 @@ class WavefrontCredentialsTest < MiniTest::Test
     assert_instance_of(Map, c.config)
     assert_instance_of(Map, c.all)
 
-    assert_equal(c.creds.keys, %w[token endpoint])
-    assert_equal(c.creds[:token], '12345678-abcd-1234-abcd-123456789012')
-    assert_equal(c.creds[:endpoint], 'default.wavefront.com')
+    assert_equal(%w[token endpoint], c.creds.keys)
+    assert_equal('12345678-abcd-1234-abcd-123456789012', c.creds[:token])
+    assert_equal('default.wavefront.com', c.creds[:endpoint])
   end
 
   def test_initialize_env_token
@@ -37,9 +35,9 @@ class WavefrontCredentialsTest < MiniTest::Test
     assert_instance_of(Map, c.config)
     assert_instance_of(Map, c.all)
 
-    assert_equal(c.creds.keys, %w[token endpoint])
-    assert_equal(c.creds[:token], 'abcdefgh')
-    assert_equal(c.creds[:endpoint], 'default.wavefront.com')
+    assert_equal(%w[token endpoint], c.creds.keys)
+    assert_equal('abcdefgh', c.creds[:token])
+    assert_equal('default.wavefront.com', c.creds[:endpoint])
   end
 
   def test_initialize_env_endpoint
@@ -52,9 +50,9 @@ class WavefrontCredentialsTest < MiniTest::Test
     assert_instance_of(Map, c.config)
     assert_instance_of(Map, c.all)
 
-    assert_equal(c.creds.keys, %w[token endpoint])
-    assert_equal(c.creds[:token], '12345678-abcd-1234-abcd-123456789012')
-    assert_equal(c.creds[:endpoint], 'endpoint.wavefront.com')
+    assert_equal(%w[token endpoint], c.creds.keys)
+    assert_equal('12345678-abcd-1234-abcd-123456789012', c.creds[:token])
+    assert_equal('endpoint.wavefront.com', c.creds[:endpoint])
   end
 end
 
@@ -83,22 +81,26 @@ class GibletsTest < MiniTest::Test
   end
 
   def test_env_override_noenvs
-    assert_equal(wf.env_override(raw), raw)
+    assert_equal(raw, wf.env_override(raw))
   end
 
   def test_env_override_env_endpoint
     ENV['WAVEFRONT_ENDPOINT'] = 'env_ep'
 
-    assert_equal(wf.env_override(raw),
-                 endpoint: 'env_ep', token: 'raw_tok', proxy: 'raw_proxy')
+    assert_equal(
+      { endpoint: 'env_ep', token: 'raw_tok', proxy: 'raw_proxy' },
+      wf.env_override(raw)
+    )
   end
 
   def test_env_override_env_endpoint_and_token
     ENV['WAVEFRONT_ENDPOINT'] = 'env_ep'
     ENV['WAVEFRONT_TOKEN'] = 'env_tok'
 
-    assert_equal(wf.env_override(raw),
-                 endpoint: 'env_ep', token: 'env_tok', proxy: 'raw_proxy')
+    assert_equal(
+      { endpoint: 'env_ep', token: 'env_tok', proxy: 'raw_proxy' },
+      wf.env_override(raw)
+    )
   end
 
   def test_env_override_env_proxy
@@ -106,8 +108,10 @@ class GibletsTest < MiniTest::Test
     x = wf.env_override(raw)
 
     assert_instance_of(Hash, x)
-    assert_equal(x, endpoint: 'raw_ep', token: 'raw_tok', proxy:
-                      'env_proxy')
+    assert_equal(
+      { endpoint: 'raw_ep', token: 'raw_tok', proxy: 'env_proxy' },
+      x
+    )
   end
 
   def test_populate
@@ -117,23 +121,23 @@ class GibletsTest < MiniTest::Test
     proxy = wf.instance_variable_get('@proxy')
 
     assert_instance_of(Map, config)
-    assert_equal(config.proxy, 'raw_proxy')
-    assert_equal(config.endpoint, 'raw_ep')
+    assert_equal('raw_proxy', config.proxy)
+    assert_equal('raw_ep', config.endpoint)
 
     assert_instance_of(Map, creds)
-    assert_equal(creds.endpoint, 'raw_ep')
-    assert_equal(creds.token, 'raw_tok')
+    assert_equal('raw_ep', creds.endpoint)
+    assert_equal('raw_tok', creds.token)
     refute creds[:proxy]
 
     assert_instance_of(Map, proxy)
-    assert_equal(config.proxy, 'raw_proxy')
+    assert_equal('raw_proxy', config.proxy)
     refute proxy[:endpoint]
   end
 
   def test_cred_files_no_opts
     x = wf.cred_files
     assert_instance_of(Array, x)
-    assert_equal(x.length, 3)
+    assert_equal(3, x.length)
     x.each { |p| assert_instance_of(Pathname, p) }
     assert_includes(x, Pathname.new('/etc/wavefront/credentials'))
     assert_includes(x, Pathname.new(ENV['HOME']) + '.wavefront')
@@ -143,22 +147,22 @@ class GibletsTest < MiniTest::Test
   def test_cred_files_opts
     x = wf.cred_files(file: '/test/file')
     assert_instance_of(Array, x)
-    assert_equal(x.length, 1)
-    assert_equal(x, Array(Pathname.new('/test/file')))
+    assert_equal(1, x.length)
+    assert_equal(Array(Pathname.new('/test/file')), x)
   end
 
   def test_load_from_file
-    assert_equal(wf.load_from_file(
+    assert_equal({},
+                 wf.load_from_file(
                    [Pathname.new('/no/file/1'), Pathname.new('/no/file/2')]
-    ), {})
+                 ))
 
-    assert_equal(wf.load_from_file([CONF1], 'noprofile'),
-                 file: CONF1)
+    assert_equal({ file: CONF1 }, wf.load_from_file([CONF1], 'noprofile'))
 
     x = wf.load_from_file([CONF2, CONF1], 'default')
     assert_instance_of(Hash, x)
-    assert_equal(x.keys.size, 5)
-    assert_equal(x[:proxy], 'wavefront.localnet')
+    assert_equal(5, x.keys.size)
+    assert_equal('wavefront.localnet', x[:proxy])
 
     %i[token endpoint proxy sourceformat file].each do |k|
       assert_includes(x.keys, k)
@@ -167,15 +171,15 @@ class GibletsTest < MiniTest::Test
     y = wf.load_from_file([CONF2, CONF1], 'other')
     assert_instance_of(Hash, y)
     %i[token endpoint proxy file].each { |k| assert_includes(y.keys, k) }
-    assert_equal(y.keys.size, 4)
-    assert_equal(y[:proxy], 'otherwf.localnet')
+    assert_equal(4, y.keys.size)
+    assert_equal('otherwf.localnet', y[:proxy])
 
     z = wf.load_from_file([CONF1, CONF2], 'default')
     assert_instance_of(Hash, z)
     %i[token endpoint proxy file].each { |k| assert_includes(z.keys, k) }
-    assert_equal(z.keys.size, 4)
-    assert_equal(z[:proxy], 'wavefront.lab')
-    assert_equal(z[:endpoint], 'somewhere.wavefront.com')
+    assert_equal(4, z.keys.size)
+    assert_equal('wavefront.lab', z[:proxy])
+    assert_equal('somewhere.wavefront.com', z[:endpoint])
   end
 
   def test_load_profile

data/spec/wavefront-sdk/dashboard_spec.rb

@@ -22,11 +22,6 @@ DASHBOARD_BODY = {
   ]
 }.freeze
 
-U_ACL_1 = { name: 'someone@example.com', id: 'someone@example.com' }.freeze
-U_ACL_2 = { name: 'other@elsewhere.com', id: 'other@elsewhere.com' }.freeze
-GRP_ACL = { name: 'example group',
-            id:   'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672' }.freeze
-
 # Unit tests for dashboard class
 #
 class WavefrontDashboardTest < WavefrontTestBase
@@ -80,6 +75,10 @@ class WavefrontDashboardTest < WavefrontTestBase
     tag_tester(DASHBOARD)
   end
 
+  def test_acls
+    acl_tester(DASHBOARD)
+  end
+
   def test_undelete
     should_work(:undelete, DASHBOARD, ["#{DASHBOARD}/undelete",
                                        nil], :post, POST_HEADERS)
@@ -93,51 +92,4 @@ class WavefrontDashboardTest < WavefrontTestBase
                                           nil], :post, POST_HEADERS)
     should_be_invalid(:unfavorite)
   end
-
-  def test_acls
-    should_work(:acls, [%w[dash1 dash2]], 'acl?id=dash1&id=dash2')
-  end
-
-  def test_acl_add
-    should_work(:acl_add, [DASHBOARD, [U_ACL_1, U_ACL_2], [GRP_ACL]],
-                'acl/add', :post, {}, acl_body(DASHBOARD,
-                                               [U_ACL_1, U_ACL_2],
-                                               [GRP_ACL]))
-
-    should_work(:acl_add, [DASHBOARD, [U_ACL_1, U_ACL_2]],
-                'acl/add', :post, {}, acl_body(DASHBOARD,
-                                               [U_ACL_1, U_ACL_2]))
-    assert_raises(ArgumentError) { wf.acl_add(DASHBOARD, U_ACL_1) }
-    assert_raises(ArgumentError) do
-      wf.acl_add(DASHBOARD, [U_ACL_1], GRP_ACL)
-    end
-  end
-
-  def test_acl_remove
-    should_work(:acl_delete, [DASHBOARD, [U_ACL_1, U_ACL_2], [GRP_ACL]],
-                'acl/remove', :post, {}, acl_body(DASHBOARD,
-                                                  [U_ACL_1, U_ACL_2],
-                                                  [GRP_ACL]))
-
-    should_work(:acl_delete, [DASHBOARD, [U_ACL_1, U_ACL_2]],
-                'acl/remove', :post, {}, acl_body(DASHBOARD,
-                                                  [U_ACL_1, U_ACL_2]))
-    assert_raises(ArgumentError) { wf.acl_delete(DASHBOARD, U_ACL_1) }
-  end
-
-  def test_acl_set
-    should_work(:acl_set, [DASHBOARD, [U_ACL_1, U_ACL_2], [GRP_ACL]],
-                'acl/set', :put, {}, acl_body(DASHBOARD,
-                                              [U_ACL_1, U_ACL_2],
-                                              [GRP_ACL]))
-
-    should_work(:acl_set, [DASHBOARD, [U_ACL_1, U_ACL_2]],
-                'acl/set', :put, {}, acl_body(DASHBOARD,
-                                              [U_ACL_1, U_ACL_2]))
-    assert_raises(ArgumentError) { wf.acl_set(DASHBOARD, U_ACL_1) }
-  end
-
-  def acl_body(id, view = [], modify = [])
-    [{ entityId: id, viewAcl: view, modifyAcl: modify }].to_json
-  end
 end