wavefront-sdk 3.0.2 → 3.2.0

data/spec/wavefront-sdk/distribution_spec.rb

@@ -1,10 +1,8 @@
 #!/usr/bin/env ruby
 
-require 'minitest/autorun'
+require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/distribution'
 
-W_CREDS = { proxy: 'wavefront', port: 2878 }.freeze
-
 DIST = {
   interval: :m,
   path:     'test.distribution',

data/spec/wavefront-sdk/metric_helper_spec.rb

@@ -1,8 +1,6 @@
 #!/usr/bin/env ruby
 
 require 'minitest/autorun'
-require 'spy'
-require 'spy/integration'
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/metric_helper'
 
@@ -136,7 +134,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
 
     out = wf.flush_gauges(input)
     args = spy.calls.first.args.first
-    assert_instance_of(Mocket, out)
+    assert_instance_of(Wavefront::Response, out)
     assert spy.has_been_called?
     assert_equal(input, args)
     assert(args.any? { |a| a.key?(:tags) && a[:tags] == WH_TAGS })
@@ -150,7 +148,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
     mocket = BadMocket.new
     spy = Spy.on(wf.writer.writer, :write).and_return(mocket)
     out = wf.flush_gauges(input)
-    assert_instance_of(BadMocket, out)
+    assert_instance_of(Wavefront::Response, out)
     wf.gauge('m2.p', 9)
     wf.gauge('m3.p', 9)
     assert spy.has_been_called?
@@ -173,7 +171,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
     out = wf.flush_counters(input)
     args = spy.calls.first.args.first
 
-    assert_instance_of(Mocket, out)
+    assert_instance_of(Wavefront::Response, out)
     assert spy.has_been_called?
     assert_equal(3, args.size)
 
@@ -201,7 +199,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
     out = wf.flush_counters(input)
     args = spy.calls.first.args.first
 
-    assert_instance_of(BadMocket, out)
+    assert_instance_of(Wavefront::Response, out)
     assert spy.has_been_called?
     assert_equal(3, args.size)
 
@@ -232,7 +230,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
     out = wfd.flush_dists(input)
     args = spy.calls.first.args.first
 
-    assert_instance_of(Mocket, out)
+    assert_instance_of(Wavefront::Response, out)
     assert spy.has_been_called?
     assert_equal(3, args.size)
 
@@ -261,7 +259,7 @@ class WavefrontMetricHelperTest < MiniTest::Test
     out = wfd.flush_dists(input)
     args = spy.calls.first.args.first
 
-    assert_instance_of(BadMocket, out)
+    assert_instance_of(Wavefront::Response, out)
     assert spy.has_been_called?
     assert_equal(3, args.size)
     refute_empty(wfd.buf[:dists])

data/spec/wavefront-sdk/report_spec.rb

@@ -3,7 +3,7 @@
 require_relative '../spec_helper'
 require_relative 'resources/dummy_points'
 
-HEADERS = POST_HEADERS.merge('Content-Type': 'application/octet-stream')
+REPORT_HEADERS = POST_HEADERS.merge('Content-Type': 'application/octet-stream')
 
 # Unit tests for Report class
 #
@@ -14,6 +14,6 @@ class WavefrontReportTest < WavefrontTestBase
 
   def test_write
     should_work(:write, POINT, ['?f=wavefront', nil],
-                :post, HEADERS, POINT_L)
+                :post, REPORT_HEADERS, POINT_L)
   end
 end

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

@@ -7,11 +7,11 @@ require_relative '../../../lib/wavefront-sdk/stdlib/array'
 #
 class ArrayTest < MiniTest::Test
   def test_uri_concat
-    assert_equal %w[a b].uri_concat, 'a/b'
-    assert_equal ['', 'a', 'b'].uri_concat, '/a/b'
-    assert_equal %w[a /b].uri_concat, 'a/b'
-    assert_equal ['', 'a', 'b/'].uri_concat, '/a/b'
-    assert_equal %w[/a /b/ /c].uri_concat, '/a/b/c'
-    assert_equal ['/a', '/b c'].uri_concat, '/a/b c'
+    assert_equal('a/b', %w[a b].uri_concat)
+    assert_equal('/a/b', ['', 'a', 'b'].uri_concat)
+    assert_equal('a/b', %w[a /b].uri_concat)
+    assert_equal('/a/b', ['', 'a', 'b/'].uri_concat)
+    assert_equal('/a/b/c', %w[/a /b/ /c].uri_concat)
+    assert_equal('/a/b c', ['/a', '/b c'].uri_concat)
   end
 end

data/spec/wavefront-sdk/stdlib/hash_spec.rb

@@ -7,11 +7,11 @@ require_relative '../../../lib/wavefront-sdk/stdlib/hash'
 #
 class HashTest < MiniTest::Test
   def test_to_wf_tag
-    assert_equal({}.to_wf_tag, '')
-    assert_equal({ gt1: 'gv1', gt2: 'gv2' }.to_wf_tag,
-                 'gt1="gv1" gt2="gv2"')
-    assert_equal({ tag: 'value' }.to_wf_tag, 'tag="value"')
-    assert_equal({ tag: 'two words' }.to_wf_tag, 'tag="two words"')
+    assert_equal('', {}.to_wf_tag)
+    assert_equal('gt1="gv1" gt2="gv2"',
+                 { gt1: 'gv1', gt2: 'gv2' }.to_wf_tag)
+    assert_equal('tag="value"', { tag: 'value' }.to_wf_tag)
+    assert_equal('tag="two words"', { tag: 'two words' }.to_wf_tag)
     assert_equal('tag="say \"hi\""', { tag: 'say "hi"' }.to_wf_tag)
     assert_equal('tag1="say \"hi\"" tag2="some stuff!"',
                  { tag1: 'say "hi"', tag2: 'some stuff!' }.to_wf_tag)

data/spec/wavefront-sdk/support/mixins_spec.rb

@@ -9,18 +9,17 @@ require 'spy/integration'
 class WavefrontMixinsTest < MiniTest::Test
   include Wavefront::Mixins
 
-  # rubocop:disable Lint/UnifiedInteger
   def test_parse_time
     base_t = Time.now.to_i
-    assert_equal parse_time(1_469_711_187), 1_469_711_187
-    assert_equal parse_time('2016-07-28 14:25:36 +0100'), 1_469_712_336
-    assert_instance_of Fixnum, parse_time(Time.now)
-    assert_instance_of Fixnum, parse_time(Time.now, true)
+    assert_equal(1_469_711_187, parse_time(1_469_711_187))
+    assert_equal(1_469_712_336, parse_time('2016-07-28 14:25:36 +0100'))
+    assert_kind_of(Numeric, parse_time(Time.now))
+    assert_kind_of(Numeric, parse_time(Time.now, true))
     assert parse_time(Time.now) >= base_t
     assert parse_time(Time.now, true) >= base_t * 1000
     assert parse_time(Time.now, true) < base_t * 1001
-    assert_instance_of Fixnum, parse_time(Time.now)
-    assert_instance_of Fixnum, parse_time(Time.now, true)
+    assert_kind_of(Numeric, parse_time(Time.now))
+    assert_kind_of(Numeric, parse_time(Time.now, true))
     assert_raises(Wavefront::Exception::InvalidTimestamp) do
       parse_time('nonsense')
     end
@@ -32,7 +31,6 @@ class WavefrontMixinsTest < MiniTest::Test
 
     assert_equal trt_spy.calls.length, 2
   end
-  # rubocop:enable Lint/UnifiedInteger
 
   def test_relative_time
     base = Time.now
@@ -40,15 +38,15 @@ class WavefrontMixinsTest < MiniTest::Test
     ms_base = base.to_date
     mbi = ms_base.strftime('%Q').to_i
 
-    assert_equal relative_time('+60s', false, base), bi + 60
-    assert_equal relative_time('-60s', false, base), bi - 60
-    assert_equal relative_time('+.5m', false, base), bi + 30
-    assert_equal relative_time('-000.50m', false, base), bi - 30
+    assert_equal(bi + 60, relative_time('+60s', false, base))
+    assert_equal(bi - 60, relative_time('-60s', false, base))
+    assert_equal(bi + 30, relative_time('+.5m', false, base))
+    assert_equal(bi - 30, relative_time('-000.50m', false, base))
 
-    assert_equal relative_time('+60s', true, ms_base), mbi + 60 * 1000
-    assert_equal relative_time('-60s', true, ms_base), mbi - 60 * 1000
-    assert_equal relative_time('+.5m', true, ms_base), mbi + 30 * 1000
-    assert_equal relative_time('-000.50m', true, ms_base), mbi - 30 * 1000
+    assert_equal(mbi + 60_000, relative_time('+60s', true, ms_base))
+    assert_equal(mbi - 60_000, relative_time('-60s', true, ms_base))
+    assert_equal(mbi + 30_000, relative_time('+.5m', true, ms_base))
+    assert_equal(mbi - 30_000, relative_time('-000.50m', true, ms_base))
 
     assert_raises(Wavefront::Exception::InvalidRelativeTime) do
       relative_time('5m')
@@ -73,19 +71,19 @@ class WavefrontMixinsTest < MiniTest::Test
   end
 
   def test_parse_relative_time
-    assert_equal parse_relative_time('-5s'), -5
-    assert_equal parse_relative_time('-5s', true), -5000
-    assert_equal parse_relative_time('+10000s'), 10_000
-    assert_equal parse_relative_time('-5m'), -300
-    assert_equal parse_relative_time('-.5m'), -30
-    assert_equal parse_relative_time('-0.5m'), -30
-    assert_equal parse_relative_time('+5m'), 300
-    assert_equal parse_relative_time('+.5m'), 30
-    assert_equal parse_relative_time('+.50m'), 30
-    assert_equal parse_relative_time('+.50m', true), 30 * 1000
-    assert_equal parse_relative_time('+.50m'), 30
-    assert_equal parse_relative_time('+1.5d'), 60 * 60 * 24 * 1.5
-    assert_equal parse_relative_time('-1.5d'), 60 * 60 * 24 * -1.5
+    assert_equal(-5, parse_relative_time('-5s'))
+    assert_equal(-5000, parse_relative_time('-5s', true))
+    assert_equal(10_000, parse_relative_time('+10000s'))
+    assert_equal(-300, parse_relative_time('-5m'))
+    assert_equal(-30, parse_relative_time('-.5m'))
+    assert_equal(-30, parse_relative_time('-0.5m'))
+    assert_equal(300, parse_relative_time('+5m'))
+    assert_equal(30, parse_relative_time('+.5m'))
+    assert_equal(30, parse_relative_time('+.50m'))
+    assert_equal(30_000, parse_relative_time('+.50m', true))
+    assert_equal(30, parse_relative_time('+.50m'))
+    assert_equal(129_600, parse_relative_time('+1.5d'))
+    assert_equal(-129_600, parse_relative_time('-1.5d'))
 
     ['-1.5p', '1.5m', '+1.3.5s'].each do
       assert_raises Wavefront::Exception::InvalidRelativeTime do |t|
@@ -95,13 +93,13 @@ class WavefrontMixinsTest < MiniTest::Test
   end
 
   def test_time_multiplier
-    assert_equal time_multiplier(:s), 1
-    assert_equal time_multiplier('s'), 1
-    assert_equal time_multiplier(:m), 60
-    assert_equal time_multiplier(:h), 60 * 60
-    assert_equal time_multiplier(:d), 60 * 60 * 24
-    assert_equal time_multiplier(:w), 60 * 60 * 24 * 7
-    assert_equal time_multiplier(:y), 60 * 60 * 24 * 365
+    assert_equal(1, time_multiplier(:s))
+    assert_equal(1, time_multiplier('s'))
+    assert_equal(60, time_multiplier(:m))
+    assert_equal(3600, time_multiplier(:h))
+    assert_equal(86_400, time_multiplier(:d))
+    assert_equal(604_800, time_multiplier(:w))
+    assert_equal(31_536_000, time_multiplier(:y))
 
     assert_raises(Wavefront::Exception::InvalidTimeUnit) do
       time_multiplier(:p)

data/spec/wavefront-sdk/support/parse_time_spec.rb

@@ -3,14 +3,11 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/support/parse_time'
 
-# rubocop:disable Style/NumericLiterals
-TSS = 1517151869
-TSM = 1517151869523
-# rubocop:enable Style/NumericLiterals
+TSS = 1_517_151_869
+TSM = 1_517_151_869_523
 
-# Test parse_time class. Rubocop gets in the way a bit here.
+# Test parse_time class
 #
-# rubocop:disable Lint/UnifiedInteger
 # rubocop:disable Style/DateTime
 class WavefrontParseTimeTest < MiniTest::Test
   attr_reader :pts, :ptm
@@ -21,51 +18,50 @@ class WavefrontParseTimeTest < MiniTest::Test
   end
 
   def test_parse_time_fixnum
-    assert_equal(pts.parse_time_fixnum, TSS)
-    assert_equal(ptm.parse_time_fixnum, TSM)
+    assert_equal(TSS, pts.parse_time_fixnum)
+    assert_equal(TSM, ptm.parse_time_fixnum)
   end
 
   def test_parse_time_integer
-    assert_equal(pts.parse_time_integer, TSS)
-    assert_equal(ptm.parse_time_integer, TSM)
+    assert_equal(TSS, pts.parse_time_integer)
+    assert_equal(TSM, ptm.parse_time_integer)
   end
 
   def test_parse_time_string
     ptss = Wavefront::ParseTime.new(TSS.to_s, false)
     ptms = Wavefront::ParseTime.new(TSM.to_s, true)
-    assert_instance_of(Fixnum, ptss.parse_time_string, TSS)
-    assert_instance_of(Fixnum, ptms.parse_time_string, TSM)
-    assert_equal(ptss.parse_time_string, TSS)
-    assert_equal(ptms.parse_time_string, TSM)
-    assert_instance_of(Fixnum, ptss.parse!)
-    assert_instance_of(Fixnum, ptms.parse!)
+    assert_kind_of(Numeric, ptss.parse_time_string)
+    assert_kind_of(Numeric, ptms.parse_time_string)
+    assert_equal(TSS, ptss.parse_time_string)
+    assert_equal(TSM, ptms.parse_time_string)
+    assert_kind_of(Numeric, ptss.parse!)
+    assert_kind_of(Numeric, ptms.parse!)
   end
 
   def test_parse_time_time
     ptst = Wavefront::ParseTime.new(Time.at(TSS), false)
     ptmt = Wavefront::ParseTime.new(DateTime.strptime(TSM.to_s,
                                                       '%Q').to_time, true)
-    assert_equal(ptst.parse_time_time, TSS)
-    assert_equal(ptmt.parse_time_time, TSM)
-    assert_instance_of(Fixnum, ptst.parse!)
-    assert_instance_of(Fixnum, ptmt.parse!)
+    assert_equal(TSS, ptst.parse_time_time)
+    assert_equal(TSM, ptmt.parse_time_time)
+    assert_kind_of(Numeric, ptst.parse!)
+    assert_kind_of(Numeric, ptmt.parse!)
   end
 
   def test_parse_time_datetime
     ptsd = Wavefront::ParseTime.new(Time.at(TSS).to_datetime, false)
     ptmd = Wavefront::ParseTime.new(DateTime.strptime(TSM.to_s, '%Q'), true)
-    assert_instance_of(Fixnum, ptsd.parse_time_datetime, TSS)
-    assert_instance_of(Fixnum, ptmd.parse_time_datetime, TSM)
-    assert_equal(ptsd.parse_time_datetime, TSS)
-    assert_equal(ptmd.parse_time_datetime, TSM)
-    assert_instance_of(Fixnum, ptsd.parse!)
-    assert_instance_of(Fixnum, ptmd.parse!)
+    assert_kind_of(Numeric, ptsd.parse_time_datetime, TSS)
+    assert_kind_of(Numeric, ptmd.parse_time_datetime, TSM)
+    assert_equal(TSS, ptsd.parse_time_datetime)
+    assert_equal(TSM, ptmd.parse_time_datetime)
+    assert_kind_of(Numeric, ptsd.parse!)
+    assert_kind_of(Numeric, ptmd.parse!)
   end
 
   def test_parse!
-    assert_instance_of(Fixnum, pts.parse!)
-    assert_instance_of(Fixnum, ptm.parse!)
+    assert_kind_of(Numeric, pts.parse!)
+    assert_kind_of(Numeric, ptm.parse!)
   end
 end
-# rubocop:enable Lint/UnifiedInteger
 # rubocop:enable Style/DateTime

data/spec/wavefront-sdk/usergroup_spec.rb

@@ -2,23 +2,23 @@
 
 require_relative '../spec_helper'
 
-USERGROUP_ID = 'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672'.freeze
-BAD_USERGROUP_ID = 'some_rubbish'.freeze
+G_USERGROUP_ID = 'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672'.freeze
+G_BAD_USERGROUP_ID = 'some_rubbish'.freeze
 
-USERGROUP_BODY = { name:        'test group',
-                   permissions: %w[alerts_management
-                                   dashboard_management
-                                   events_management] }.freeze
+G_USERGROUP_BODY = { name:        'test group',
+                     permissions: %w[alerts_management
+                                     dashboard_management
+                                     events_management] }.freeze
 
-USER_LIST = %w[someone@somewhere.com other@elsewhere.net].freeze
-BAD_USER_LIST = ['bad' * 500, ''].freeze
+G_USER_LIST = %w[someone@somewhere.com other@elsewhere.net].freeze
+G_BAD_USER_LIST = ['bad' * 500, ''].freeze
 
-PERMISSION = 'alerts_management'.freeze
+G_PERMISSION = 'alerts_management'.freeze
 
-GROUP_LIST = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
-                2659191e-aad4-4302-a94e-9667e1517127].freeze
+G_GROUP_LIST = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+                  2659191e-aad4-4302-a94e-9667e1517127].freeze
 
-BAD_GROUP_LIST = %w[some-nonsense more-nonsense].freeze
+G_BAD_GROUP_LIST = %w[some-nonsense more-nonsense].freeze
 
 # Unit tests for WavefrontUserGroup
 #
@@ -28,71 +28,71 @@ class WavefrontUserGroupTest < WavefrontTestBase
   end
 
   def test_create
-    should_work(:create, USERGROUP_BODY, '', :post,
-                JSON_POST_HEADERS, USERGROUP_BODY.to_json)
+    should_work(:create, G_USERGROUP_BODY, '', :post,
+                JSON_POST_HEADERS, G_USERGROUP_BODY.to_json)
     assert_raises(ArgumentError) { wf.create }
     assert_raises(ArgumentError) { wf.create('test') }
   end
 
   def test_delete
-    should_work(:delete, USERGROUP_ID, USERGROUP_ID, :delete)
+    should_work(:delete, G_USERGROUP_ID, G_USERGROUP_ID, :delete)
     should_be_invalid(:delete)
   end
 
   def test_describe
-    should_work(:describe, USERGROUP_ID, USERGROUP_ID)
+    should_work(:describe, G_USERGROUP_ID, G_USERGROUP_ID)
     assert_raises(ArgumentError) { wf.describe }
   end
 
   def test_update
-    should_work(:update, [USERGROUP_ID, USERGROUP_BODY, false],
-                USERGROUP_ID, :put, JSON_POST_HEADERS,
-                USERGROUP_BODY.to_json)
-    should_be_invalid(:update, ['!some rubbish!', USERGROUP_BODY])
+    should_work(:update, [G_USERGROUP_ID, G_USERGROUP_BODY, false],
+                G_USERGROUP_ID, :put, JSON_POST_HEADERS,
+                G_USERGROUP_BODY.to_json)
+    should_be_invalid(:update, ['!some rubbish!', G_USERGROUP_BODY])
     assert_raises(ArgumentError) { wf.update }
   end
 
   def test_add_users_to_group
-    should_work(:add_users_to_group, [USERGROUP_ID, USER_LIST],
-                [USERGROUP_ID, :addUsers].uri_concat, :post)
+    should_work(:add_users_to_group, [G_USERGROUP_ID, G_USER_LIST],
+                [G_USERGROUP_ID, :addUsers].uri_concat, :post)
 
     assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.add_users_to_group(USERGROUP_ID, BAD_USER_LIST)
+      wf.add_users_to_group(G_USERGROUP_ID, G_BAD_USER_LIST)
     end
 
     assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.add_users_to_group(BAD_USERGROUP_ID, USER_LIST)
+      wf.add_users_to_group(G_BAD_USERGROUP_ID, G_USER_LIST)
     end
   end
 
   def test_remove_users_from_group
-    should_work(:remove_users_from_group, [USERGROUP_ID, USER_LIST],
-                [USERGROUP_ID, :removeUsers].uri_concat, :post)
+    should_work(:remove_users_from_group, [G_USERGROUP_ID, G_USER_LIST],
+                [G_USERGROUP_ID, :removeUsers].uri_concat, :post)
 
     assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.remove_users_from_group(USERGROUP_ID, BAD_USER_LIST)
+      wf.remove_users_from_group(G_USERGROUP_ID, G_BAD_USER_LIST)
     end
 
     assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.remove_users_from_group(BAD_USERGROUP_ID, USER_LIST)
+      wf.remove_users_from_group(G_BAD_USERGROUP_ID, G_USER_LIST)
     end
   end
 
   def test_grant
-    should_work(:grant, [PERMISSION, GROUP_LIST],
-                [:grant, PERMISSION].uri_concat, :post)
+    should_work(:grant, [G_PERMISSION, G_GROUP_LIST],
+                [:grant, G_PERMISSION].uri_concat, :post)
 
     assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.grant(PERMISSION, BAD_GROUP_LIST)
+      wf.grant(G_PERMISSION, G_BAD_GROUP_LIST)
     end
   end
 
   def test_revoke
-    should_work(:revoke, [PERMISSION, GROUP_LIST],
-                [:revoke, PERMISSION].uri_concat, :post)
+    should_work(:revoke, [G_PERMISSION, G_GROUP_LIST],
+                [:revoke, G_PERMISSION].uri_concat, :post)
 
     assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.revoke(PERMISSION, BAD_GROUP_LIST)
+      wf.revoke(G_PERMISSION, G_BAD_GROUP_LIST)
     end
   end
 end