wavefront-sdk 5.4.1 → 6.0.0

data/spec/support/mocket.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-# A mock socket
+# A mock socket. Stubs TCP sockets and UNIX domain sockets.
 #
 class Mocket
   def puts(socket); end
 
+  def write(socket); end
+
   def close; end
 
   def ok?

data/spec/test_mixins/general.rb

@@ -77,7 +77,7 @@ module WavefrontTest
 
     def test_update_keys
       assert_instance_of Array, wf.update_keys
-      assert(wf.update_keys.all? { |k| k.is_a?(Symbol) })
+      assert(wf.update_keys.all?(Symbol))
     end
   end
 

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

@@ -7,8 +7,8 @@ require_relative '../../../lib/wavefront-sdk/core/exception'
 require_relative '../../../lib/wavefront-sdk/core/response'
 
 GOOD_RESP = '{"status":{"result":"OK","message":"","code":200},' \
-             '"response":{"items":[{"name":"test agent"}],"offset":0,' \
-             '"limit":100,"totalItems":3,"moreItems":false}}'
+            '"response":{"items":[{"name":"test agent"}],"offset":0,' \
+            '"limit":100,"totalItems":3,"moreItems":false}}'
 
 BAD_RESP = "error='not_found'
 message='resource cannot be found'

data/spec/wavefront-sdk/event_spec.rb

@@ -43,12 +43,58 @@ class WavefrontEventTest < WavefrontTestBase
     assert_raises(ArgumentError) { wf.close }
   end
 
+  def test_alert_firing_details
+    assert_gets("/api/v2/event/#{id}/alertFiringDetails") do
+      wf.alert_firing_details(id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidEventId) do
+      wf.alert_firing_details(invalid_id)
+    end
+  end
+
+  def test_alert_queries_slug
+    assert_gets("/api/v2/event/#{id}/alertQueriesSlug") do
+      wf.alert_queries_slug(id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidEventId) do
+      wf.alert_queries_slug(invalid_id)
+    end
+  end
+
+  def test_events
+    assert_gets(
+      "/api/v2/event/#{id}/events?isOverlapped=false&renderingMethod=HOST"
+    ) do
+      wf.events(id)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidEventId) do
+      wf.events(invalid_id)
+    end
+  end
+
+  def test_alert_firings
+    assert_gets("/api/v2/event/alertFirings?alertId=#{alert_id}&asc=true") do
+      wf.alert_firings(alert_id, asc: true)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidAlertId) do
+      wf.alert_firings(invalid_id)
+    end
+  end
+
   private
 
   def id
     '1481553823153:testev'
   end
 
+  def alert_id
+    '1481553823153'
+  end
+
   def invalid_id
     'nonsense'
   end

data/spec/wavefront-sdk/metric_helper_spec.rb

@@ -4,6 +4,8 @@
 require 'minitest/autorun'
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/metric_helper'
+require_relative '../support/mocket'
+require_relative '../support/bad_mocket'
 
 ND_CREDS = { proxy: 'wavefront' }.freeze
 WH_TAGS  = { t1: 'v1', t2: 'v2' }.freeze
@@ -115,12 +117,12 @@ class WavefrontMetricHelperTest < MiniTest::Test
     out = wfd.dists_to_wf(input)
     assert_instance_of(Array, out)
     assert_equal(3, out.size)
-    assert_equal(1, out.select do |o|
+    assert_equal(1, out.count do |o|
                       o[:value] == [[2, 10.0], [1, 11.0],
                                     [1, 12.0]]
-                    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)
+    assert_equal(1, out.count { |o| o[:tags] == WH_TAGS })
+    assert_equal(3, out.count { |o| o[:path] == 'test.dist1' })
   end
 
   def test_flush_gauges

data/spec/wavefront-sdk/metricspolicy_spec.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../spec_helper'
+require_relative '../test_mixins/general'
+
+# Unit tests for MetricsPolicy class
+#
+class WavefrontMetricsPolicyTest < WavefrontTestBase
+  def test_describe
+    assert_gets('/api/v2/metricspolicy') { wf.describe }
+
+    assert_gets('/api/v2/metricspolicy/history/5') { wf.describe(5) }
+
+    assert_raises(Wavefront::Exception::InvalidVersion) do
+      wf.describe('v5')
+    end
+  end
+
+  def test_history
+    assert_gets('/api/v2/metricspolicy?offset=10&limit=100') do
+      wf.history(10)
+    end
+
+    assert_gets('/api/v2/metricspolicy?offset=12&limit=34') do
+      wf.history(12, 34)
+    end
+  end
+
+  def test_revert
+    assert_posts('/api/v2/metricspolicy/revert/5') do
+      wf.revert(5)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidVersion) do
+      wf.revert('v5')
+    end
+  end
+
+  def test_update
+    assert_puts('/api/v2/metricspolicy', payload.to_json) do
+      wf.update(payload)
+    end
+  end
+
+  private
+
+  def api_class
+    'metricspolicy'
+  end
+
+  def id
+    'a7d2e651-cec1-4154-a5e8-1946f57ef5b3'
+  end
+
+  def invalid_id
+    '+-+-+-+'
+  end
+
+  def payload
+    {
+      policyRules: [
+        {
+          name: 'Policy rule1 name',
+          description: 'Policy rule1 description',
+          prefixes: ['revenue.*'],
+          tags: [
+            {
+              key: 'sensitive',
+              value: 'false'
+            },
+            {
+              key: 'source',
+              value: 'app1'
+            }
+          ],
+          tagsAnded: 'true',
+          accessType: 'ALLOW',
+          accounts: %w[accountId1 accountId2],
+          userGroups: ['userGroupId1'],
+          roles: ['roleId']
+        },
+        {
+          name: 'Policy rule2 name',
+          description: 'Policy rule2 description',
+          prefixes: ['revenue.*'],
+          accessType: 'BLOCK',
+          accounts: ['accountId3'],
+          userGroups: ['userGroupId1']
+        }
+      ]
+    }
+  end
+end

data/spec/wavefront-sdk/spy_spec.rb

@@ -38,6 +38,33 @@ class WavefrontSpyTest < MiniTest::Test
     end
   end
 
+  def test_deltas
+    capture_io do
+      assert_gets('/api/spy/deltas?sampling=0.01') { wf.deltas }
+      assert_gets('/api/spy/deltas?sampling=0.05') { wf.deltas(0.05) }
+
+      assert_gets('/api/spy/deltas?sampling=0.05&counter=my_prefix') do
+        wf.deltas(0.05, prefix: 'my_prefix')
+      end
+
+      assert_gets(
+        '/api/spy/deltas?sampling=0.05&counter=my_prefix&host=h1'
+      ) do
+        wf.deltas(0.05, prefix: 'my_prefix', host: 'h1')
+      end
+
+      assert_gets('/api/spy/deltas?sampling=0.02&counter=my_prefix&' \
+                  'counterTagKey=the_tag') do
+        wf.deltas(0.02, prefix: 'my_prefix', tag_key: 'the_tag')
+      end
+
+      assert_gets('/api/spy/deltas?sampling=0.02&counter=my_prefix&' \
+                  'counterTagKey=tag1&counterTagKey=tag2') do
+        wf.deltas(0.02, prefix: 'my_prefix', tag_key: %w[tag1 tag2])
+      end
+    end
+  end
+
   def test_histograms
     capture_io do
       assert_gets('/api/spy/histograms?sampling=0.01') { wf.histograms }

data/spec/wavefront-sdk/validators_spec.rb

@@ -84,7 +84,7 @@ class WavefrontValidatorsTest < MiniTest::Test
             { tag1: 'val 1', tag2: 'val 2' },
             { TAG1: 'val 1', tag2: 'val 2' },
             { 'TAG-1': 'val 1', tag2: 'val 2' },
-            { 'TAG_1': 'val 1', tag_2: 'val 2' },
+            { TAG_1: 'val 1', tag_2: 'val 2' },
             { 'TAG.1': 'val 1', tag_2: 'val 2' },
             { 'TAG-1': 'val 1', tag2: 'val 2' },
             { tag1: '(>_<)', tag2: '^_^' }]
@@ -417,4 +417,14 @@ class WavefrontValidatorsTest < MiniTest::Test
     bad = %w[h5Z9dkr46jbvLtJ HqOM4mru5svd3uFp3 c!lBx!LC*NxLKdx*]
     good_and_bad('wf_aws_external_id?', 'InvalidAwsExternalId', good, bad)
   end
+
+  def test_wf_metricspolicy_id
+    good = %w[2bfdcac7-1c9c-4c4b-9b56-c41c22c586dc
+              a7d2e651-cec1-4154-a5e8-1946f57ef5b3
+              fca312fb-5ff4-420d-862d-5d6d99ed6bcf
+              3a1957e0-459e-49e5-9209-3888a4e8ac5b]
+
+    bad = %w[fa312fb-5ff4-420d-862d-5d6d99ed6bcf thing 123]
+    good_and_bad('wf_metricspolicy_id?', 'InvalidMetricsPolicyId', good, bad)
+  end
 end

data/spec/wavefront-sdk/write_spec.rb

@@ -27,7 +27,7 @@ class WavefrontWriteTest < MiniTest::Test
     refute(wf.opts[:noop])
     assert(wf_noop.opts[:noop])
     assert_equal(wf_tags.opts[:tags], TAGS)
-    assert_instance_of(Wavefront::Writer::Socket, wf.writer)
+    assert_instance_of(Wavefront::Writer::Proxy, wf.writer)
   end
 
   def test_composite_response

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

@@ -42,5 +42,9 @@ class WavefrontWriterApiTest < MiniTest::Test
     assert_raises(Wavefront::Exception::CredentialError) do
       Wavefront::Write.new({ token: 'abcdef' }, writer: :api)
     end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ token: 'abcdef', endpoint: nil }, writer: :api)
+    end
   end
 end

data/spec/wavefront-sdk/writers/core_spec.rb

@@ -6,9 +6,7 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/writers/core'
 require_relative '../resources/dummy_points'
 
-# rubocop:disable Style/MutableConstant
-WBWT_CREDS = { endpoint: 'stub.wavefront.com', token: 'tkn' }
-# rubocop:enable Style/MutableConstant
+WBWT_CREDS = { endpoint: 'stub.wavefront.com', token: 'tkn' }.freeze
 
 # Fake class for testing
 #

data/spec/wavefront-sdk/writers/http_spec.rb

@@ -6,6 +6,7 @@ require_relative '../resources/dummy_points'
 require_relative '../../../lib/wavefront-sdk/write'
 
 BODY = 'test.metric 123456 1469987572 source=testhost t1="v1" t2="v2"'
+WH_CREDS = { proxy: 'wavefront-proxy' }.freeze
 
 # Test HTTP transport
 #
@@ -20,27 +21,6 @@ class WavefrontWriterSocketTest < MiniTest::Test
     assert_instance_of(Wavefront::Writer::Http, wf.writer)
   end
 
-  def test_validate_credentials
-    assert Wavefront::Write.new({ proxy: 'wavefront' }, writer: :http)
-    assert_instance_of(Wavefront::Write, wf)
-
-    assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new(CREDS, writer: :http)
-    end
-
-    assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({}, writer: :http)
-    end
-
-    assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({ endpoint: 'wavefront.com' }, writer: :http)
-    end
-
-    assert_raises(Wavefront::Exception::CredentialError) do
-      Wavefront::Write.new({ token: 'abcdef' }, writer: :http)
-    end
-  end
-
   def test_write_2878
     wf1 = Wavefront::Write.new({ proxy: 'wavefront' }, writer: :http)
 
@@ -67,4 +47,27 @@ class WavefrontWriterSocketTest < MiniTest::Test
     assert_requested(:post, 'http://wavefront:1234', headers: POST_HEADERS)
     WebMock.reset!
   end
+
+  def test_validate_credentials
+    assert(Wavefront::Write.new(WH_CREDS, writer: :http))
+
+    assert_instance_of(Wavefront::Write,
+                       Wavefront::Write.new(WH_CREDS, writer: :http))
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({}, writer: :http)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ endpoint: 'wavefront.com' }, writer: :http)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ token: 'abcdef' }, writer: :http)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ proxy: nil }, writer: :http)
+    end
+  end
 end

data/spec/wavefront-sdk/writers/proxy_spec.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'webmock/minitest'
+require 'spy'
+require 'spy/integration'
+require 'socket'
+require 'logger'
+require_relative '../resources/dummy_points'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/write'
+require_relative '../../../spec/support/mocket'
+
+WS_CREDS = { proxy: 'wavefront-proxy' }.freeze
+
+# The Proxy class writes to a proxy TCP socket
+#
+class WavefrontWriterSocketTest < MiniTest::Test
+  attr_reader :wf, :wf_noop
+
+  def setup
+    @wf = Wavefront::Write.new(WS_CREDS, writer: :proxy)
+    @wf_noop = Wavefront::Write.new(WS_CREDS, writer: :proxy, noop: true)
+  end
+
+  def test_writer_class
+    assert_instance_of(Wavefront::Writer::Proxy, wf.writer)
+  end
+
+  def test_write_openclose
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf.write(POINT)
+    assert mocket_spy.has_been_called?
+  end
+
+  def test_write_noop
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf_noop.open
+    wf_noop.write(POINT, false)
+    refute mocket_spy.has_been_called?
+  end
+
+  def test_write_noop_openclose
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf_noop.write(POINT)
+    refute mocket_spy.has_been_called?
+  end
+
+  def test_write
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf.open
+    wf.write(POINT, false)
+    assert mocket_spy.has_been_called?
+  end
+
+  def test_write_array
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf.open
+    wf.write(POINT_A, false)
+    assert mocket_spy.has_been_called?
+  end
+
+  def test_noop_send_point
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf_noop.open
+    wf_noop.send_point(POINT_L)
+    refute mocket_spy.has_been_called?
+  end
+
+  def test_open
+    tcp_spy = Spy.on(TCPSocket, :new)
+    wf.open
+    assert tcp_spy.has_been_called?
+    assert_equal(['wavefront-proxy', 2878], tcp_spy.calls.first.args)
+  end
+
+  def test_noop_open
+    tcp_spy = Spy.on(TCPSocket, :new)
+    log_spy = Spy.on(wf_noop.logger, :log)
+    wf_noop.open
+    refute tcp_spy.has_been_called?
+    assert_equal(['No-op requested. Not opening connection to proxy.'],
+                 log_spy.calls.last.args)
+    assert_equal(1, log_spy.calls.size)
+  end
+
+  def test_noop_close
+    tcp_spy = Spy.on(TCPSocket, :new)
+    log_spy = Spy.on(wf_noop.logger, :log)
+    wf_noop.close
+    refute tcp_spy.has_been_called?
+    refute log_spy.has_been_called?
+  end
+
+  def test_validate_credentials
+    assert(Wavefront::Write.new(WS_CREDS, writer: :proxy))
+
+    assert_instance_of(Wavefront::Write,
+                       Wavefront::Write.new(WS_CREDS, writer: :proxy))
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({}, writer: :proxy)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ endpoint: 'wavefront.com' }, writer: :proxy)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ token: 'abcdef' }, writer: :proxy)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ proxy: nil }, writer: :proxy)
+    end
+  end
+end