wavefront-sdk 1.2.1 → 1.3.0

data/spec/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  TargetRubyVersion: 2.2
+#
 #
 # Allow long blocks of tests
 #

data/spec/spec_helper.rb

@@ -1,6 +1,11 @@
 #
 # Stuff needed by multiple tests
 #
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
 require 'minitest/autorun'
 require 'webmock/minitest'
 
@@ -10,17 +15,18 @@ CREDS = {
 }
 
 POST_HEADERS = {
-  :'Content-Type' => 'text/plain', :Accept => 'application/json'
+  'Content-Type': 'text/plain', Accept: 'application/json'
 }.freeze
 
 JSON_POST_HEADERS = {
-  :'Content-Type' => 'application/json', :Accept => 'application/json'
+  'Content-Type': 'application/json', Accept: 'application/json'
 }.freeze
 
 DUMMY_RESPONSE = '{"status":{"result":"OK","message":"","code":200},' \
                  '"response":{"items":[{"name":"test data"}],"offset":0,' \
-                 '"limit":100,"totalItems":3,"moreItems":false}}'
+                 '"limit":100,"totalItems":3,"moreItems":false}}'.freeze
 
+# Common testing code
 class WavefrontTestBase < MiniTest::Test
   attr_reader :wf, :wf_noop, :uri_base, :headers
 
@@ -60,21 +66,22 @@ class WavefrontTestBase < MiniTest::Test
   # @body [String] a JSON object you expect to be sent as part of
   #   the request
   #
-  #
+  # rubocop:disable Metrics/PerceivedComplexity
+  # rubocop:disable Metrics/ParameterLists
   def should_work(method, args, path, call = :get, more_headers = {},
                   body = nil, id = nil)
     path = Array(path)
-    uri = target_uri(path.first).sub(/\/$/, '')
+    uri = target_uri(path.first).sub(%r{/$}, '')
 
     headers = { 'Accept':          /.*/,
                 'Accept-Encoding': /.*/,
                 'Authorization':  'Bearer 0123456789-ABCDEF',
-                'User-Agent':     "wavefront-sdk #{WF_SDK_VERSION}"
-                }.merge(more_headers)
+                'User-Agent':     "wavefront-sdk #{WF_SDK_VERSION}" }
+              .merge(more_headers)
 
     if body
-      stub_request(call, uri).with(body: body, headers:headers)
-        .to_return(body: DUMMY_RESPONSE, status: 200)
+      stub_request(call, uri).with(body: body, headers: headers)
+                             .to_return(body: DUMMY_RESPONSE, status: 200)
     else
       stub_request(call, uri).to_return(body: DUMMY_RESPONSE, status: 200)
     end
@@ -85,12 +92,10 @@ class WavefrontTestBase < MiniTest::Test
       else
         wf.send(method, args)
       end
+    elsif id
+      wf.send(method, id, *args)
     else
-      if id
-        wf.send(method, id, *args)
-      else
-        wf.send(method, *args)
-      end
+      wf.send(method, *args)
     end
 
     assert_requested(call, uri, headers: headers)
@@ -99,7 +104,7 @@ class WavefrontTestBase < MiniTest::Test
 
   def standard_exception
     Object.const_get('Wavefront::Exception')
-      .const_get("Invalid#{class_basename}Id")
+          .const_get("Invalid#{class_basename}Id")
   end
 
   def should_be_invalid(method, args = '!!invalid_val!!')
@@ -118,8 +123,8 @@ class WavefrontTestBase < MiniTest::Test
     #
     should_work('tag_set', [id, 'tag'],
                 ["#{id}/tag", ['tag'].to_json], :post, JSON_POST_HEADERS)
-    should_work('tag_set', [id, %w(tag1 tag2)],
-                ["#{id}/tag", %w(tag1 tag2).to_json], :post,
+    should_work('tag_set', [id, %w[tag1 tag2]],
+                ["#{id}/tag", %w[tag1 tag2].to_json], :post,
                 JSON_POST_HEADERS)
     should_fail_tags('tag_set', id)
 
@@ -146,8 +151,9 @@ class WavefrontTestBase < MiniTest::Test
   end
 end
 
+# Extensions to stdlib
+#
 class Hash
-
   # A quick way to deep-copy a hash.
   #
   def dup

data/spec/wavefront-sdk/alert_spec.rb

@@ -20,6 +20,11 @@ class WavefrontAlertTest < WavefrontTestBase
     should_work(:list, 10, '?offset=10&limit=100')
   end
 
+  def test_update_keys
+    assert_instance_of(Array, wf.update_keys)
+    wf.update_keys.each { |k| assert_instance_of(Symbol, k) }
+  end
+
   def test_describe
     should_work(:describe, ALERT, ALERT)
     assert_raises(ArgumentError) { wf.describe }

data/spec/wavefront-sdk/base_spec.rb

@@ -20,17 +20,17 @@ class WavefrontBaseTest < 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(1469711187), 1469711187000
+    assert_equal wf.time_to_ms(1_469_711_187), 1_469_711_187_000
     refute wf.time_to_ms([])
     refute wf.time_to_ms('1469711187')
   end
 
   def test_uri_concat
-    assert_equal %w(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).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 %w[/a /b/ /c].uri_concat, '/a/b/c'
     assert_equal ['/a', '/b c'].uri_concat, '/a/b c'
   end
 
@@ -43,7 +43,7 @@ class WavefrontBaseTest < MiniTest::Test
 
   def test_api_post
     uri = "#{uri_base}/path"
-    obj = {key: 'value'}
+    obj = { key: 'value' }
     stub_request(:post, uri).to_return(body: DUMMY_RESPONSE, status: 200)
     wf.api_post('/path', 'string')
     assert_requested(:post, uri, body: 'string',
@@ -71,7 +71,7 @@ class WavefrontBaseTest < MiniTest::Test
   def test_api_noop
     uri = "#{uri_base}/path"
 
-    %w(get post put delete).each do |call|
+    %w[get post put delete].each do |call|
       stub_request(call.to_sym, uri)
       wf_noop.send("api_#{call}", '/path')
       refute_requested(call.to_sym, uri)
@@ -79,10 +79,10 @@ class WavefrontBaseTest < MiniTest::Test
   end
 
   def test_hash_for_update
-    wf.instance_variable_set('@update_keys',  [:k1, :k2])
-    body = { k1: 'ov1', k2: 'ov2', k3: 'ov3'}
+    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(wf.hash_for_update(body, upd), k1: 'ov1', k2: 'nv1')
   end
 end

data/spec/wavefront-sdk/credentials_spec.rb

@@ -5,8 +5,9 @@ require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/credentials'
 
 CONF = Pathname.new(__FILE__).dirname.realpath + 'resources' + 'test.conf'
+CONF2 = Pathname.new(__FILE__).dirname.realpath + 'resources' + 'test2.conf'
 
-# Test SDK base class
+# Test SDK base class end-to-end
 #
 class WavefrontCredentialsTest < MiniTest::Test
   attr_reader :wf, :wf_noop, :uri_base, :headers
@@ -20,7 +21,7 @@ class WavefrontCredentialsTest < MiniTest::Test
     assert_instance_of(Map, c.proxy)
     assert_instance_of(Map, c.config)
 
-    assert_equal(c.creds.keys, %w(token endpoint))
+    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')
   end
@@ -34,7 +35,7 @@ class WavefrontCredentialsTest < MiniTest::Test
     assert_instance_of(Map, c.proxy)
     assert_instance_of(Map, c.config)
 
-    assert_equal(c.creds.keys, %w(token endpoint))
+    assert_equal(c.creds.keys, %w[token endpoint])
     assert_equal(c.creds[:token], 'abcdefgh')
     assert_equal(c.creds[:endpoint], 'default.wavefront.com')
   end
@@ -48,8 +49,126 @@ class WavefrontCredentialsTest < MiniTest::Test
     assert_instance_of(Map, c.proxy)
     assert_instance_of(Map, c.config)
 
-    assert_equal(c.creds.keys, %w(token endpoint))
+    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')
   end
+
+end
+
+# Test individual methods. We must override the constructor to do
+# this.
+#
+class Giblets < Wavefront::Credentials
+  def initialize; end
+end
+
+class GibletsTest < MiniTest::Test
+  attr_reader :wf, :raw
+
+  def setup
+    @wf = Giblets.new
+    @raw = { endpoint: 'raw_ep', token: 'raw_tok', proxy: 'raw_proxy' }
+    clear_env_vars
+  end
+
+  def clear_env_vars
+    %w[WAVEFRONT_ENDPOINT WAVEFRONT_TOKEN WAVEFRONT_PROXY].each do |ev|
+      ENV.delete(ev)
+    end
+  end
+
+  def test_env_override_noenvs
+    assert_equal(wf.env_override(raw), 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' })
+  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' })
+  end
+
+  def test_env_override_env_proxy
+    ENV['WAVEFRONT_PROXY'] = 'env_proxy'
+    x = wf.env_override(raw)
+
+    assert_instance_of(Hash, x)
+    assert_equal(x, { endpoint: 'raw_ep', token: 'raw_tok', proxy:
+                      'env_proxy' })
+  end
+
+  def test_populate
+    wf.populate(raw)
+    config = wf.instance_variable_get('@config')
+    creds = wf.instance_variable_get('@creds')
+    proxy = wf.instance_variable_get('@proxy')
+
+    assert_instance_of(Map, config)
+    assert_equal(config.proxy, 'raw_proxy')
+    assert_equal(config.endpoint, 'raw_ep')
+
+    assert_instance_of(Map, creds)
+    assert_equal(creds.endpoint, 'raw_ep')
+    assert_equal(creds.token, 'raw_tok')
+    refute creds[:proxy]
+
+    assert_instance_of(Map, proxy)
+    assert_equal(config.proxy, 'raw_proxy')
+    refute proxy[:endpoint]
+  end
+
+  def test_cred_files_no_opts
+    x = wf.cred_files
+    assert_instance_of(Array, x)
+    assert_equal(x.length, 2)
+    x.each { |p| assert_instance_of(Pathname, p) }
+    assert_includes(x, Pathname.new('/etc/wavefront/credentials'))
+    assert_includes(x, Pathname.new(ENV['HOME']) + '.wavefront')
+  end
+
+  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')))
+  end
+
+  def test_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([CONF], 'noprofile'),
+                 { file: CONF })
+
+    x = wf.load_from_file([CONF2, CONF], 'default')
+    assert_instance_of(Hash, x)
+    assert_equal(x.keys.size, 5)
+    assert_equal(x[:proxy], 'wavefront.localnet')
+
+    %i[token endpoint proxy sourceformat file].each do |k|
+      assert_includes(x.keys, k)
+    end
+
+    y = wf.load_from_file([CONF2, CONF], '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')
+
+    z = wf.load_from_file([CONF, 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')
+  end
 end

data/spec/wavefront-sdk/event_spec.rb

@@ -10,10 +10,10 @@ EVENT_BODY = {
     type:     'SDK test event',
     details:  'an imaginary event to test the SDK'
   },
-  hosts:       %w(host1 host2),
-  startTime:   1493385089000,
-  endTime:     1493385345678,
-  tags:        %w(tag1 tag2),
+  hosts:       %w[host1 host2],
+  startTime:   1_493_385_089_000,
+  endTime:     1_493_385_345_678,
+  tags:        %w[tag1 tag2],
   isEphemeral: false
 }.freeze
 
@@ -21,7 +21,6 @@ EVENT_BODY = {
 #
 class WavefrontEventTest < WavefrontTestBase
   def test_list
-
     t1 = Time.now - 600
     t2 = Time.now
     tms1 = t1.to_datetime.strftime('%Q')

data/spec/wavefront-sdk/externallink_spec.rb

@@ -7,7 +7,7 @@ EXTERNAL_LINK_BODY = {
   name:        'test link',
   template:    'https://example.com/link/{{value}}',
   description: 'an imaginary link for unit testing purposes'
-}
+}.freeze
 
 EXTERNAL_LINK_BODY_2 = {
   name:        'test link',

data/spec/wavefront-sdk/maintenancewindow_spec.rb

@@ -8,8 +8,8 @@ WINDOW_BODY = {
   title:    'test window',
   start:    Time.now.to_i,
   end:      Time.now.to_i + 600,
-  tags:     %w(testtag1 testtag2),
-  hostTags: %w(hosttag1 hosttag2)
+  tags:     %w[testtag1 testtag2],
+  hostTags: %w[hosttag1 hosttag2]
 }.freeze
 
 # Unit tests for MaintenanceWindow class

data/spec/wavefront-sdk/metric_spec.rb

@@ -11,9 +11,9 @@ class WavefrontMetricTest < WavefrontTestBase
 
   def test_detail
     should_work(:detail, 'metric.1', 'detail?m=metric.1')
-    should_work(:detail, ['metric.1', %w(host1 host2)],
+    should_work(:detail, ['metric.1', %w[host1 host2]],
                 'detail?m=metric.1&h=host1&h=host2')
-    should_work(:detail, ['metric.1', %w(host1 host2), 'abc'],
+    should_work(:detail, ['metric.1', %w[host1 host2], 'abc'],
                 'detail?m=metric.1&h=host1&h=host2&c=abc')
     assert_raises(ArgumentError) { wf.detail }
     assert_raises(ArgumentError) { wf.detail('m1', 'm2') }

data/spec/wavefront-sdk/mixins_spec.rb

@@ -57,7 +57,7 @@ class WavefrontMixinsTest < MiniTest::Test
   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'), 10000
+    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

data/spec/wavefront-sdk/parse_time_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/parse_time'
+
+TSS = 1517151869
+TSM = 1517151869523
+
+# Test parse_time class
+#
+class WavefrontParseTimeTest < MiniTest::Test
+  attr_reader :pts, :ptm
+
+  def setup
+    @pts = Wavefront::ParseTime.new(TSS, false)
+    @ptm = Wavefront::ParseTime.new(TSM, true)
+  end
+
+  def test_parse_time_Fixnum
+    assert_equal(pts.parse_time_Fixnum, TSS)
+    assert_equal(ptm.parse_time_Fixnum, TSM)
+  end
+
+  def test_parse_time_Integer
+    assert_equal(pts.parse_time_Integer, TSS)
+    assert_equal(ptm.parse_time_Integer, TSM)
+  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!)
+  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!)
+  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!)
+  end
+
+  def test_parse!
+    assert_instance_of(Fixnum, pts.parse!)
+    assert_instance_of(Fixnum, ptm.parse!)
+  end
+end