wavefront-sdk 0.0.1

data/spec/wavefront-sdk/validators_spec.rb

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require 'minitest/autorun'
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/validators'
+
+class WavefrontValidatorsTest < MiniTest::Test
+  include Wavefront::Validators
+
+  def good_and_bad(method, exception, good, bad)
+    ex = Object.const_get("Wavefront::Exception::#{exception}")
+
+    good.each { |m| assert send(method, m) }
+    bad.each { |m| assert_raises(ex) { send(method, m) } }
+  end
+
+  def test_wf_metric_name?
+    good = ['a.l33t.metric_path-passes', 'NO.NEED.TO.SHOUT',
+             '"slash/allowed_in_quotes"', '"comma,allowed_in_quotes"']
+    bad  = ['metric.is.(>_<)', { key: 'val' }, 'no/slash', 'no,comma', []]
+    good_and_bad('wf_metric_name?', 'InvalidMetricName', good, bad)
+  end
+
+  def test_wf_string?
+    good = ['string', 'valid string', 'valid, valid string.',
+             'valid-string', ' VALID_string']
+    bad  = ['a' * 1024, '(>_<)', { key: 'val' }, [], 123456]
+    good_and_bad('wf_string?', 'InvalidString', good, bad)
+  end
+
+  def test_wf_name?
+    good = %w(name name123)
+    bad  = ['a' * 1024, '(>_<)', { key: 'val' }, [], 123456, '']
+    good_and_bad('wf_name?', 'InvalidName', good, bad)
+  end
+
+  def test_wf_source_id?
+    good = ['validsource1', 'valid-source', 'valid_source',
+             'valid.source', 'Valid_Source', 'a' * 1023, '123456']
+    bad  = ['a' * 1024, '(>_<)', { key: 'val' }, [], 123456]
+    good_and_bad('wf_source_id?', 'InvalidSourceId', good, bad)
+  end
+
+  def test_wf_value?
+    good = [0, 123, -10, 1.23456789, 1.23e04]
+    bad = ['1', 'abc', '0', {}, []]
+    good_and_bad('wf_value?', 'InvalidMetricValue', good, bad)
+  end
+
+  def test_wf_ts?
+    good = [Time.now, Date.today, DateTime.now]
+    bad  = ['2017-03-25 23:52:22 +0000', 1490485946,
+            '#<Date: 2017-03-25 ((2457838j,0s,0n),+0s,2299161j)>']
+    good_and_bad('wf_ts?', 'InvalidTimestamp', good, bad)
+  end
+
+  def test_wf_ms_ts?
+    good = [Time.now.to_i * 1000]
+    bad  = ['2017-03-25 23:52:22 +0000']
+    good_and_bad('wf_ms_ts?', 'InvalidTimestamp', good, bad)
+  end
+
+  def test_wf_epoch?
+    good = [Time.now.to_i]
+    bad  = ['2017-03-25 23:52:22 +0000']
+    good_and_bad('wf_epoch?', 'InvalidTimestamp', good, bad)
+  end
+
+  def test_wf_tag?
+    good = ['abc', 'abc123', '__tag__', 'my:tag', ['abc', 'abc123']]
+    bad = ['^^^', Time.now, 'bad tag', ['abc', '!BAD!']]
+    good_and_bad('wf_tag?', 'InvalidTag', good, bad)
+  end
+
+  def test_wf_point_tags?
+    good = [{},
+            {tag1: 'val1', tag2: 'val2'},
+            {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', tag2: 'val 2'},
+            {tag1: '(>_<)', tag2: '^_^'}]
+    bad  = ['key=value',
+            {'tag 1': 'val1', 'tag 2': 'val2'},
+            {'TAG*1': 'val 1', tag_2: 'val 2'},
+            {'(>_<)': 'val1', '^_^': 'val2'},
+            {tag1: 'v' * 255},
+            {'k' * 255 => 'val1'},
+            {'k' * 130 => 'v' * 130}]
+    good_and_bad('wf_point_tags?', 'InvalidTag', good, bad)
+  end
+
+  def test_wf_proxy_id?
+    good = %w(fd248f53-378e-4fbe-bbd3-efabace8d724
+              917102d1-a10e-497b-ba63-95058f98d4fb)
+    bad = %w(proxy 17102d1-a10e-497b-ba63-95058f98d4fb)
+    good_and_bad('wf_proxy_id?', 'InvalidProxyId', good, bad)
+  end
+
+  def test_wf_cloudintegration_id?
+    good = %w(3b56f61d-ba79-47f6-905c-d75a0f613d10
+              71e435ca-3d8c-43ab-bc1e-d072a335cbe6)
+    bad = %w(proxy 71e43dca-3d8c-41ab-bc1e-d072a335Xbe6)
+    good_and_bad('wf_cloudintegration_id?', 'InvalidCloudIntegrationId',
+                 good, bad)
+  end
+
+  def test_wf_alert_id?
+    good = [1481553823153, '1481553823153']
+    bad = [481553823153, '481553823153', [], {}, 'alert']
+    good_and_bad('wf_alert_id?', 'InvalidAlertId', good, bad)
+  end
+
+  def test_wf_dashboard_id?
+    good = %w(my_dash my-dashboard S3 123)
+    bad = ['a' * 260, 'A Dashboard Name', 'and_1_more!', {}, [], 1234]
+    good_and_bad('wf_dashboard_id?', 'InvalidDashboardId', good, bad)
+  end
+
+  def test_wf_event_id?
+    good = %w(1493370839062:test1)
+    bad = %w(1493370839062 1493370839062:test!)
+    good_and_bad('wf_event_id?', 'InvalidEventId', good, bad)
+  end
+
+  def test_wf_version?
+    good = [1, 2, 3, 4, '10']
+    bad = [-1, 'ab', [1]]
+    good_and_bad('wf_version?', 'InvalidVersion', good, bad)
+  end
+
+  def test_wf_link_id?
+    good = %w(lq6rPlSg2CFMSrg6)
+    bad = %w(lq%rPlSg2CFMSrg6, lq6rPlSg2CFMSrg)
+    good_and_bad('wf_link_id?', 'InvalidExternalLinkId', good, bad)
+  end
+
+  def test_wf_link_template?
+    good = %w(http://link.xyz https://link.xyz/{{holder}})
+    bad = %w(link.xyz https:/link.xyz/{{holder}})
+    good_and_bad('wf_link_template?', 'InvalidLinkTemplate', good, bad)
+  end
+
+  def test_wf_maintenance_window_id?
+    good = ['1493324005091', 1493324005091, Time.now.to_i * 1000]
+    bad = [149332400509, '14933240050', Time.now, [], 'abcdef']
+    good_and_bad('wf_maintenance_window_id?', 'InvalidMaintenanceWindowId',
+                 good, bad)
+  end
+
+  def test_wf_alert_severity?
+    good = %w(INFO SMOKE WARN SEVERE)
+    bad = %w(any THING else)
+    good_and_bad('wf_alert_severity?', 'InvalidAlertSeverity', good, bad)
+  end
+
+  def test_wf_granularity?
+    good = ['d', 'h', 'm', 's', :d, :h, :m, :s]
+    bad = [1, 'a', 'day', :hour]
+    good_and_bad('wf_granularity?', 'InvalidGranularity', good, bad)
+  end
+
+  def test_wf_savedsearch_id?
+    good = %w(e2hLH2FR)
+    bad = %w(e2hLH2F e2hLH2FRz)
+    good_and_bad('wf_savedsearch_id?', 'InvalidSavedSearchId', good, bad)
+  end
+
+  def test_wf_savedsearch_entity?
+    good = %w(EVENT MAINTENANCE_WINDOW DASHBOARD ALERT)
+    bad = %w(1 a day hour)
+    good_and_bad('wf_savedsearch_entity?',
+                 'InvalidSavedSearchEntity', good, bad)
+  end
+
+  def test_wf_user_id?
+    good = %w(Some.User@example.com general99+specific@somewhere.net someone@somewhere.com)
+    bad = %w(word Name)
+    good_and_bad('wf_user_id?', 'InvalidUserId', good, bad)
+  end
+
+  def test_wf_webhook_id?
+    good = %w(4OfsEM8RcvkM7nwG)
+    bad = %w(4OfsEM8RcvkM7n 4OfsEM8Rcvk-7nw)
+    good_and_bad('wf_webhook_id?', 'InvalidWebhookId', good, bad)
+  end
+
+  def test_wf_point?
+    good = { path: 'test.metric', value: 123456, ts: Time.now.to_i,
+             source: 'testhost', tags: { t1: 'v 1', t2: 'v2' } }
+
+    assert(wf_point?(good))
+
+    %w(tags source ts).each do |t|
+      p = good.dup
+      p.delete(t)
+      assert(wf_point?(p))
+    end
+
+    bad = good.dup
+    bad[:path] = '!n\/@1!d_metric'
+
+    assert_raises(Wavefront::Exception::InvalidMetricName) do
+      wf_point?(bad)
+    end
+
+    bad = good.dup
+    bad[:value] = 'abc'
+
+    assert_raises(Wavefront::Exception::InvalidMetricValue) do
+      wf_point?(bad)
+    end
+
+    bad = good.dup
+    bad[:ts] = 'abc'
+
+    assert_raises(Wavefront::Exception::InvalidTimestamp) do
+      wf_point?(bad)
+    end
+
+    bad = good.dup
+    bad[:source] = '<------>'
+
+    assert_raises(Wavefront::Exception::InvalidSourceId) do
+      wf_point?(bad)
+    end
+
+    bad = good.dup
+    bad[:tags] = {'<------>': 45}
+
+    assert_raises(Wavefront::Exception::InvalidTag) do
+      wf_point?(bad)
+    end
+  end
+end

data/spec/wavefront-sdk/webhook_spec.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+WEBHOOK = '9095WaGklE8Gy3M1'.freeze
+
+WEBHOOK_BODY = {
+  description:       'WebHook Description',
+  template:          'POST Body -- Mustache syntax',
+  title:             'WebHook Title',
+  triggers:          %w(ALERT_OPENED),
+  recipient:         'http://example.com',
+  customHttpHeaders: {},
+  contentType:       'text/plain'
+}.freeze
+
+# Unit tests for Webhook class
+#
+class WavefrontWebhookTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+    should_work(:list, [20, 30], '?offset=20&limit=30')
+  end
+
+  def test_describe
+    should_work(:describe, WEBHOOK, WEBHOOK)
+    should_be_invalid(:describe, 'abcdefg')
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_create
+    should_work(:create, WEBHOOK_BODY, '', :post,
+                JSON_POST_HEADERS, WEBHOOK_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, WEBHOOK, WEBHOOK, :delete)
+    should_be_invalid(:delete, 'abcdefg')
+    assert_raises(ArgumentError) { wf.delete }
+  end
+
+  def test_update
+    should_work(:update, [WEBHOOK, WEBHOOK_BODY], WEBHOOK, :put,
+                JSON_POST_HEADERS, WEBHOOK_BODY.to_json)
+    should_be_invalid(:update, ['abcde', WEBHOOK_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+end

data/spec/wavefront-sdk/write_spec.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+
+require_relative '../../lib/wavefront-sdk/write.rb'
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'spy'
+require 'spy/integration'
+require 'socket'
+
+W_CREDS = { proxy: 'wavefront', port: 2878 }.freeze
+
+TAGS = { gt1: 'gv1', gt2: 'gv2' }.freeze
+
+POINT =  { path:   'test.metric',
+           value:  123_456,
+           ts:     1_469_987_572,
+           source: 'testhost',
+           tags:   { t1: 'v1', t2: 'v2' } }.freeze
+
+POINT_L = 'test.metric 123456 1469987572 source=testhost t1="v1" t2="v2"'.freeze
+
+POINT_A = [
+  POINT, POINT.dup.update(ts: 1_469_987_588, value: 54_321)
+].freeze
+
+# This class is sufficiently different to the API calling classes
+# that it doesn't use spec helper or inherit anything.
+#
+class WavefrontWriteTest < MiniTest::Test
+  attr_reader :wf, :wf_noop, :wf_tags
+
+  def setup
+    @wf = Wavefront::Write.new(W_CREDS)
+    @wf_noop = Wavefront::Write.new(W_CREDS, noop: true)
+    @wf_tags = Wavefront::Write.new(W_CREDS, tags: TAGS)
+  end
+
+  def test_initialize
+    refute(wf.opts[:tags])
+    refute(wf.opts[:verbose])
+    refute(wf.opts[:debug])
+    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)
+  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_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')
+
+    [: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_to_wf_tag
+    assert_equal({}.to_wf_tag, '')
+    assert_equal(TAGS.to_wf_tag, 'gt1="gv1" gt2="gv2"')
+  end
+
+  def test_send_point
+    mocket = Mocket.new
+    Spy.on(TCPSocket, :new).and_return(mocket)
+    mocket_spy = Spy.on(mocket, :puts)
+    wf.open
+    wf.send_point(POINT_L)
+    assert mocket_spy.has_been_called_with?(POINT_L)
+  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(tcp_spy.calls.first.args, ['wavefront', 2878])
+  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(s); end
+
+  def close; end
+end