wavefront-sdk 1.6.2 → 2.0.0

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

@@ -2,8 +2,9 @@
 
 require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/stdlib/array'
-require 'spy/integration'
 
+# Test extensions to stdlib's Array class
+#
 class ArrayTest < MiniTest::Test
   def test_uri_concat
     assert_equal %w[a b].uri_concat, 'a/b'

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

@@ -2,7 +2,6 @@
 
 require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/stdlib/hash'
-require 'spy/integration'
 
 # Test extensions to stdlib hash class
 #
@@ -17,4 +16,10 @@ class HashTest < MiniTest::Test
     assert_equal('tag1="say \"hi\"" tag2="some stuff!"',
                  { tag1: 'say "hi"', tag2: 'some stuff!' }.to_wf_tag)
   end
+
+  def test_cleanse
+    assert_equal({ k1: 1, k3: 3 }, { k1: 1, k2: nil, k3: 3 }.cleanse)
+    assert_equal({ k1: 1, k2: 2, k3: 3 }, { k1: 1, k2: 2, k3: 3 }.cleanse)
+    assert_equal({}, { k1: nil, k2: false, k3: false }.cleanse)
+  end
 end

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

@@ -3,6 +3,8 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/wavefront-sdk/stdlib/string'
 
+# Test extensions to stdlib's String class
+#
 class StringTest < MiniTest::Test
   def test_tagescape
     assert_equal('value', 'value'.tagescape)

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require_relative '../spec_helper'
-require_relative '../../lib/wavefront-sdk/mixins'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/support/mixins'
 require 'spy/integration'
 
 # Test SDK mixins

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require_relative '../spec_helper'
-require_relative '../../lib/wavefront-sdk/parse_time'
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/support/parse_time'
 
 # rubocop:disable Style/NumericLiterals
 TSS = 1517151869

data/spec/wavefront-sdk/validators_spec.rb

@@ -3,7 +3,7 @@
 require 'date'
 require 'minitest/autorun'
 require_relative '../spec_helper'
-require_relative '../../lib/wavefront-sdk/constants'
+require_relative '../../lib/wavefront-sdk/defs/constants'
 require_relative '../../lib/wavefront-sdk/validators'
 
 # Validator tests, obviously. Happy now Rubocop?
@@ -261,6 +261,62 @@ class WavefrontValidatorsTest < MiniTest::Test
     end
   end
 
+  def test_wf_disitribution?
+    value = [[4, 10], [6, 11], [15, 1e5]]
+    good = { path: 'test.metric', value: value, ts: Time.now.to_i,
+             source: 'testhost', tags: { t1: 'v 1', t2: 'v2' } }
+
+    assert(wf_distribution?(good))
+
+    %w[tags source ts].each do |t|
+      p = good.dup
+      p.delete(t)
+      assert(wf_distribution?(p))
+    end
+
+    bad = good.dup
+    bad[:path] = '!n\/@1!d_metric'
+
+    assert_raises(Wavefront::Exception::InvalidMetricName) do
+      wf_distribution?(bad)
+    end
+
+    bad = good.dup
+    bad[:value] = [[1.2, 5]]
+
+    assert_raises(Wavefront::Exception::InvalidDistributionCount) do
+      wf_distribution?(bad)
+    end
+
+    bad = good.dup
+    bad[:value] = [[2, 'abc']]
+
+    assert_raises(Wavefront::Exception::InvalidMetricValue) do
+      wf_distribution?(bad)
+    end
+
+    bad = good.dup
+    bad[:ts] = 'abc'
+
+    assert_raises(Wavefront::Exception::InvalidTimestamp) do
+      wf_distribution?(bad)
+    end
+
+    bad = good.dup
+    bad[:source] = '<------>'
+
+    assert_raises(Wavefront::Exception::InvalidSourceId) do
+      wf_distribution?(bad)
+    end
+
+    bad = good.dup
+    bad[:tags] = { '<------>': 45 }
+
+    assert_raises(Wavefront::Exception::InvalidTag) do
+      wf_distribution?(bad)
+    end
+  end
+
   def test_notificant_id
     good = %w[CHTo47HvsPzSaGhh]
     bad = ['CTo47HvsPzSaGhh', [], {}, nil, 'bad id']
@@ -272,4 +328,11 @@ class WavefrontValidatorsTest < MiniTest::Test
     bad = ['CTo47HvsPzSaGhh', [], {}, nil, 'bad id']
     good_and_bad('wf_integration_id?', 'InvalidIntegrationId', good, bad)
   end
+
+  def test_distribution_interval
+    good = %i[m h d]
+    bad = ['m', [], {}, nil, 'bad id', :x, 'p']
+    good_and_bad('wf_distribution_interval?',
+                 'InvalidDistributionInterval', good, bad)
+  end
 end

data/spec/wavefront-sdk/write_spec.rb

@@ -1,12 +1,9 @@
 #!/usr/bin/env ruby
 
+require_relative '../spec_helper'
+require 'minitest/autorun'
 require_relative '../../lib/wavefront-sdk/write.rb'
 require_relative 'resources/dummy_points'
-require 'minitest/autorun'
-require 'webmock/minitest'
-require 'spy'
-require 'spy/integration'
-require 'socket'
 
 W_CREDS = { proxy: 'wavefront', port: 2878 }.freeze
 
@@ -29,88 +26,69 @@ class WavefrontWriteTest < MiniTest::Test
     refute(wf.opts[:noop])
     assert(wf_noop.opts[:noop])
     assert_equal(wf_tags.opts[:tags], TAGS)
-    assert_equal(wf.summary, sent: 0, rejected: 0, unsent: 0)
+    assert_instance_of(Wavefront::Writer::Socket, 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_paths_to_deltas
+    x = wf.paths_to_deltas(POINTS.dup)
+    assert_equal(x.size, 2)
 
-  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?
+    x.each do |p|
+      assert_instance_of(Hash, p)
+      assert(p[:path].start_with?(DELTA))
+    end
   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_point_array
+    p1 = POINT.dup
+    assert_equal(['test.metric', 123_456, 1_469_987_572, 'testhost',
+                  't1="v1" t2="v2"', nil], wf.point_array(p1))
 
-  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
+    p2 = POINT.dup.tap { |p| p.delete(:point) }
+    assert_raises(StandardError) { wf.point_arrayt(p2) }
 
-  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
+    p3 = POINT.dup.tap { |p| p.delete(:value) }
+    assert_raises(StandardError) { wf.point_arrayt(p3) }
 
-  def test_really_send_point
-    mocket = Mocket.new
-    Spy.on(TCPSocket, :new).and_return(mocket)
-    mocket_spy = Spy.on(mocket, :puts)
-    wf.open
-    wf.really_send_point(POINT_L)
-    assert mocket_spy.has_been_called_with?(POINT_L)
-  end
+    p4 = POINT.dup.tap { |p| p.delete(:ts) }
+    assert_equal(['test.metric', 123_456, nil, 'testhost',
+                  't1="v1" t2="v2"', nil], wf.point_array(p4))
 
-  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?
+    p5 = POINT.dup.tap { |p| p.delete(:tags) }
+    assert_equal(['test.metric', 123_456, 1_469_987_572, 'testhost',
+                  nil, nil], wf.point_array(p5))
   end
 
-  def test_open
-    tcp_spy = Spy.on(TCPSocket, :new)
-    wf.open
-    assert tcp_spy.has_been_called?
-    assert_equal(tcp_spy.calls.first.args, ['wavefront', 2878])
+  def test_hash_to_wf
+    assert_equal(wf.hash_to_wf(POINT),
+                 'test.metric 123456 1469987572 ' \
+                 'source=testhost t1="v1" t2="v2"')
+    assert_equal(wf_tags.hash_to_wf(POINT),
+                 'test.metric 123456 1469987572 ' \
+                 'source=testhost t1="v1" t2="v2" ' \
+                 'gt1="gv1" gt2="gv2"')
+
+    p1 = POINT.dup
+    p1.delete(:ts)
+    assert_equal(wf.hash_to_wf(p1),
+                 'test.metric 123456 source=testhost t1="v1" t2="v2"')
+
+    p2 = POINT.dup
+    p2.delete(:tags)
+    assert_equal(wf.hash_to_wf(p2),
+                 'test.metric 123456 1469987572 source=testhost')
+
+    %i[value path].each do |k|
+      p3 = POINT.dup
+      p3.delete(k)
+
+      assert_raises(Wavefront::Exception::InvalidPoint) do
+        wf.hash_to_wf(p3)
+      end
+
+      assert_raises(Wavefront::Exception::InvalidPoint) do
+        wf_tags.hash_to_wf(p3)
+      end
+    end
   end
-
-  def test_noop_open
-    tcp_spy = Spy.on(TCPSocket, :new)
-    wf_noop.open
-    refute tcp_spy.has_been_called?
-  end
-end
-
-# A mock socket
-#
-class Mocket
-  def puts(socket); end
-
-  def close; end
 end

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

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require_relative '../../spec_helper'
+require_relative '../resources/dummy_points'
+require_relative '../../../lib/wavefront-sdk/write'
+
+HEADERS = POST_HEADERS.merge('Content-Type': 'application/octet-stream')
+
+# The report class test will test that an API call is made. Here all
+# that's left to test is the #validate_credentials method.
+#
+class WavefrontWriterApiTest < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    @wf = Wavefront::Write.new(CREDS, writer: :api)
+  end
+
+  def test_writer_class
+    assert_instance_of(Wavefront::Writer::Api, wf.writer)
+  end
+
+  def test_validate_credentials
+    assert(Wavefront::Write.new(CREDS, writer: :api))
+
+    assert_instance_of(Wavefront::Write,
+                       Wavefront::Write.new(CREDS, writer: :api))
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({}, writer: :api)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ proxy: 'wavefront' }, writer: :api)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ endpoint: 'wavefront.com' }, writer: :api)
+    end
+
+    assert_raises(Wavefront::Exception::CredentialError) do
+      Wavefront::Write.new({ token: 'abcdef' }, writer: :api)
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+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
+
+class TestClassNoTags
+  def creds
+    WBWT_CREDS
+  end
+
+  def opts
+    {}
+  end
+
+  def logger
+    Logger.new(STDOUT)
+  end
+end
+
+# Test methods common to 'write' and 'report'
+#
+class WavefrontCoreWriteTest < MiniTest::Test
+  attr_reader :wf, :wf_tags
+
+  def setup
+    @wf = Wavefront::Writer::Core.new(TestClassNoTags.new)
+  end
+
+  def test_prefix_points
+    assert_equal(wf.prefix_points(%w[p1 p2 p3 p4]), %w[p1 p2 p3 p4])
+    assert_equal(wf.prefix_points([%w[p1 p2 p3 p4]]), %w[p1 p2 p3 p4])
+    assert_equal(wf.prefix_points('p1'), %w[p1])
+    assert_equal(wf.prefix_points([{ path: 'p1' },
+                                   { path: 'p2' },
+                                   { path: 'p3' }], 'prefix'),
+                 [{ path: 'prefix.p1' },
+                  { path: 'prefix.p2' },
+                  { path: 'prefix.p3' }])
+
+    assert_equal(wf.prefix_points({ path: 'p1' }, 'prefix'),
+                 [path: 'prefix.p1'])
+  end
+end

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

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require_relative '../../spec_helper'
+require_relative '../resources/dummy_points'
+require_relative '../../../lib/wavefront-sdk/write'
+
+BODY = 'test.metric 123456 1469987572 source=testhost t1="v1" t2="v2"'.freeze
+
+# Test HTTP transport
+#
+class WavefrontWriterSocketTest < MiniTest::Test
+  attr_reader :wf
+
+  def setup
+    @wf = Wavefront::Write.new({ proxy: 'wavefront' }, writer: :http)
+  end
+
+  def test_writer_class
+    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)
+
+    stub_request(:post, 'http://wavefront:2878')
+      .with(body: BODY, headers: POST_HEADERS)
+      .to_return(body: DUMMY_RESPONSE, status: 200)
+
+    wf1.write(POINT)
+
+    assert_requested(:post, 'http://wavefront:2878', headers: POST_HEADERS)
+    WebMock.reset!
+  end
+
+  def test_write_1234
+    wf1 = Wavefront::Write.new({ proxy: 'wavefront', port: 1234 },
+                               writer: :http)
+
+    stub_request(:post, 'http://wavefront:1234')
+      .with(body: BODY, headers: POST_HEADERS)
+      .to_return(body: DUMMY_RESPONSE, status: 200)
+
+    wf1.write(POINT)
+
+    assert_requested(:post, 'http://wavefront:1234', headers: POST_HEADERS)
+    WebMock.reset!
+  end
+end