wavefront-sdk 0.0.1

data/spec/wavefront-sdk/maintenancewindow_spec.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+WINDOW = '1493324005091'.freeze
+WINDOW_BODY = {
+  reason:   'testing SDK',
+  title:    'test window',
+  start:    Time.now.to_i,
+  end:      Time.now.to_i + 600,
+  tags:     %w(testtag1 testtag2),
+  hostTags: %w(hosttag1 hosttag2)
+}.freeze
+
+# Unit tests for MaintenanceWindow class
+#
+class WavefrontMaintenanceWindowTest < 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, WINDOW, WINDOW)
+    should_be_invalid(:describe, 'abcdefg')
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_create
+    should_work(:create, WINDOW_BODY, '', :post,
+                JSON_POST_HEADERS, WINDOW_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, WINDOW, WINDOW, :delete)
+    should_be_invalid(:delete, 'abcdefg')
+    assert_raises(ArgumentError) { wf.delete }
+  end
+
+  def test_update
+    should_work(:update, [WINDOW, WINDOW_BODY], WINDOW, :put,
+                JSON_POST_HEADERS, WINDOW_BODY.to_json)
+    should_be_invalid(:update, ['abcde', WINDOW_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+end

data/spec/wavefront-sdk/message_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+MESSAGE = 'message_id'.freeze # don't know what these look like yet
+
+# Unit tests for Message class
+#
+class WavefrontMessageTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100&unreadOnly=true')
+    should_work(:list, [12, 34, false], '?offset=12&limit=34&unreadOnly=false')
+  end
+
+  def test_read
+    should_work(:read, MESSAGE, "#{MESSAGE}/read", :post, POST_HEADERS)
+    should_be_invalid(:read, 'bad id')
+  end
+end

data/spec/wavefront-sdk/metric_spec.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+# Unit tests for Metric class
+#
+class WavefrontMetricTest < WavefrontTestBase
+  def api_base
+    'chart/metric'
+  end
+
+  def test_detail
+    should_work(:detail, 'metric.1', 'detail?m=metric.1')
+    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'],
+                'detail?m=metric.1&h=host1&h=host2&c=abc')
+    assert_raises(ArgumentError) { wf.detail }
+    assert_raises(ArgumentError) { wf.detail('m1', 'm2') }
+  end
+end

data/spec/wavefront-sdk/mixins_spec.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/mixins'
+
+# Test SDK mixins
+#
+class WavefrontMixinsTest < MiniTest::Test
+  include Wavefront::Mixins
+
+  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_equal parse_time('2016-07-28'), 1_469_664_000
+    assert_instance_of Fixnum, parse_time(Time.now)
+    assert_instance_of Fixnum, 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(DateTime.now)
+    assert_instance_of Fixnum, parse_time(DateTime.now, true)
+    assert_raises(Wavefront::Exception::InvalidTimestamp) do
+      parse_time('nonsense')
+    end
+  end
+end

data/spec/wavefront-sdk/proxy_spec.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+PROXY = 'fd248f53-378e-4fbe-bbd3-efabace8d724'.freeze
+
+# Unit tests for proxy class
+#
+class WavefrontProxyTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_describe
+    should_work(:describe, PROXY, PROXY)
+    should_be_invalid(:describe)
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_delete
+    should_work(:delete, PROXY, PROXY, :delete)
+    should_be_invalid('delete')
+  end
+
+  def test_rename
+    should_work(:rename, [PROXY, 'newname'],
+                [PROXY, { name: 'newname' }.to_json], :put,
+                JSON_POST_HEADERS)
+    assert_raises(ArgumentError) { wf.rename }
+    assert_raises(ArgumentError) { wf.rename('abc123') }
+    assert_raises(Wavefront::Exception::InvalidProxyId) do
+      wf.rename('abc', 'name')
+    end
+  end
+
+  def test_undelete
+    should_work(:undelete, PROXY, ["#{PROXY}/undelete", nil],
+                :post, POST_HEADERS)
+    should_be_invalid('undelete')
+  end
+end

data/spec/wavefront-sdk/query_spec.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'date'
+require_relative '../spec_helper'
+
+SERIES = 'test.metric'.freeze
+T = Time.now.freeze
+T_MS = T.to_datetime.strftime('%Q').freeze
+TE = (T + 10).freeze
+TE_MS = TE.to_datetime.strftime('%Q')
+Q = "ts(\"#{SERIES}\")".freeze
+QE = URI.encode(Q).freeze
+
+# Unit tests for Query class
+#
+class WavefrontQueryTest < WavefrontTestBase
+  def api_base
+    'chart'
+  end
+
+  def test_query
+    should_work(:query, [Q, 'd', T_MS], "api?q=#{QE}&g=d&s=#{T_MS}")
+    should_work(:query, [Q, 'h', T], "api?q=#{QE}&g=h&s=#{T_MS}")
+    should_work(:query, [Q, 'm', T, TE],
+                "api?q=#{QE}&g=m&s=#{T_MS}&e=#{TE_MS}")
+    should_work(:query, [Q, 'h', T, nil, {}], "api?q=#{Q}&g=h&s=#{T_MS}")
+    should_work(:query, [Q, 'h', T, nil, { strict: true,
+                                           summarization: 'MAX' }],
+                "api?q=#{QE}&g=h&s=#{T_MS}&strict=true&summarization=MAX")
+
+    assert_raises(ArgumentError) { wf.query }
+
+    assert_raises(Wavefront::Exception::InvalidGranularity) do
+      wf.query('ts("m")', 'x')
+    end
+
+    assert_raises(Wavefront::Exception::InvalidTimestamp) do
+      wf.query('ts("m")', 'd')
+    end
+  end
+
+  def test_raw
+    should_work(:raw, [SERIES, 'src'], "raw?metric=#{SERIES}&source=src")
+    should_work(:raw, [SERIES, 'src', T],
+                "raw?metric=#{SERIES}&source=src&startTime=#{T_MS}")
+    should_work(:raw, [SERIES, 'src', T, TE],
+                "raw?metric=#{SERIES}&source=src&startTime=#{T_MS}" \
+                "&endTime=#{TE_MS}")
+    assert_raises(ArgumentError) { wf.raw }
+  end
+end

data/spec/wavefront-sdk/resources/test.conf

@@ -0,0 +1,10 @@
+[default]
+token = 12345678-abcd-1234-abcd-123456789012
+endpoint = default.wavefront.com
+proxy = wavefront.localnet
+sourceformat = raw
+
+[other]
+token = abcdefab-0123-abcd-0123-abcdefabcdef
+endpoint = other.wavefront.com
+proxy = otherwf.localnet

data/spec/wavefront-sdk/response_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+#
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/exception'
+require_relative '../../lib/wavefront-sdk/response'
+
+WF_JSON = '{"status":{"result":"OK","message":"","code":200},' \
+          '"response":{"items":[{"name":"test agent"}],"offset":0,' \
+          '"limit":100,"totalItems":3,"moreItems":false}}'
+
+# Unit tests for Response class
+
+class WavefrontResponseTest < MiniTest::Test
+
+  def test_initialize_good_data
+    wf = Wavefront::Response::Base.new(WF_JSON, 200)
+    assert_instance_of(Wavefront::Response::Base, wf)
+    assert_respond_to(wf, :status)
+    assert_respond_to(wf, :response)
+    assert_respond_to(wf.response, :items)
+    refute_respond_to(wf, :to_a)
+    [:code, :message, :result].each { |m| assert_respond_to(wf.status, m) }
+    assert_equal(wf.status.code, 200)
+    assert_instance_of(Array, wf.response.items)
+  end
+
+  def test_initialize_bad_data
+    assert_raises(Wavefront::Exception::InvalidResponse) do
+      Wavefront::Response::Base.new('merp', 200)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidResponse) do
+      Wavefront::Response::Base.new(
+        '{"status":{"result":"OK","message":"","code":200}', 200)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidResponse) do
+      Wavefront::Response::Base.new(
+        '{"status":{"result":"OK","message":"","code":200}', 200)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidResponse) do
+      Wavefront::Response::Base.new(
+        '{"response":{"items":[{"name":"test agent"}],"offset":0 }', 200)
+    end
+  end
+end

data/spec/wavefront-sdk/savedsearch_spec.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+SAVED_SEARCH = 'e2hLH2FR'.freeze
+SAVED_SEARCH_BODY = {
+  query: {
+    foo: '{"searchTerms":[{"type":"freetext","value":"foo"}]}'
+  },
+  entityType: 'DASHBOARD'
+}.freeze
+
+# Unit tests for SavedSearch class
+#
+class WavefrontSavedSearchTest < WavefrontTestBase
+  def test_list
+    should_work(:list, [], '?offset=0&limit=100')
+    should_work(:list, 10, '?offset=10&limit=100')
+    should_work(:list, [20, 250], '?offset=20&limit=250')
+  end
+
+  def test_create
+    should_work(:create, SAVED_SEARCH_BODY, '', :post, JSON_POST_HEADERS,
+                SAVED_SEARCH_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, SAVED_SEARCH, SAVED_SEARCH, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_describe
+    should_work(:describe, SAVED_SEARCH, SAVED_SEARCH)
+    should_be_invalid(:describe)
+  end
+
+  def test_update
+    should_work(:update, [SAVED_SEARCH, SAVED_SEARCH_BODY],
+                SAVED_SEARCH, :put, JSON_POST_HEADERS,
+                SAVED_SEARCH_BODY.to_json)
+    should_be_invalid(:update, ['abcde', SAVED_SEARCH_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_entity
+    %w(ALERT EVENT MAINTENANCE_WINDOW DASHBOARD SOURCE AGENT).each do |e|
+      should_work(:entity, e, "type/#{e}?offset=0&limit=100")
+      should_work(:entity, [e, 20], "type/#{e}?offset=20&limit=100")
+      should_work(:entity, [e, 20, 50], "type/#{e}?offset=20&limit=50")
+    end
+  end
+end

data/spec/wavefront-sdk/search_spec.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+SEARCH_BODY = {
+  limit: 10,
+  offset: 0,
+  query: [{ key:            'name',
+            value:          'Wavefront',
+            matchingMethod: 'CONTAINS' }],
+  sort: { field:     'string',
+          ascending: true }
+}.freeze
+
+# Unit tests for Search class
+#
+class WavefrontSearchTest < WavefrontTestBase
+  def test_search
+    should_work(:search, ['agent', SEARCH_BODY], 'agent', :post,
+                JSON_POST_HEADERS, SEARCH_BODY.to_json)
+    should_work(:search, ['agent', SEARCH_BODY, true], 'agent/deleted',
+                :post, JSON_POST_HEADERS, SEARCH_BODY.to_json)
+    assert_raises(ArgumentError) { wf.search }
+    assert_raises(ArgumentError) { wf.search('ALERT', 'junk') }
+  end
+
+  def test_facet_search
+    should_work(:facet_search, ['agent', SEARCH_BODY],
+                'agent/facets', :post, JSON_POST_HEADERS,
+                SEARCH_BODY.to_json)
+
+    should_work(:facet_search, ['agent', SEARCH_BODY, true],
+                'agent/deleted/facets', :post, JSON_POST_HEADERS,
+                SEARCH_BODY.to_json)
+
+    should_work(:facet_search, ['agent', SEARCH_BODY, false, 'Tags'],
+                'agent/Tags', :post, JSON_POST_HEADERS,
+                SEARCH_BODY.to_json)
+
+    should_work(:facet_search, ['agent', SEARCH_BODY, true, 'Tags'],
+                'agent/deleted/Tags', :post, JSON_POST_HEADERS,
+                SEARCH_BODY.to_json)
+
+    assert_raises(ArgumentError) { wf.facet_search }
+    assert_raises(ArgumentError) { wf.facet_search('ALERT', 'junk') }
+  end
+end

data/spec/wavefront-sdk/source_spec.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+SOURCE = '74a247a9-f67c-43ad-911f-fabafa9dc2f3joyent'
+SOURCE_BODY = {
+  sourceName: 'source.name',
+  tags: {
+    sourceTag1: true
+  },
+  description: 'Source Description'
+}.freeze
+
+# Unit tests for Source class
+#
+class WavefrontSourceTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_create
+    should_work(:create, SOURCE_BODY, '', :post,
+                JSON_POST_HEADERS, SOURCE_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_describe
+    should_work(:describe, SOURCE, SOURCE)
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_delete
+    should_work(:delete, SOURCE, SOURCE, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_update
+    should_work(:update, [SOURCE, SOURCE_BODY], SOURCE, :put,
+                JSON_POST_HEADERS, SOURCE_BODY.to_json)
+    should_be_invalid(:update, ['!invalid source!', SOURCE_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_tags
+    tag_tester(SOURCE)
+  end
+end

data/spec/wavefront-sdk/user_spec.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+USER = 'user@example.com'.freeze
+GROUP = 'agent_management'.freeze
+
+USER_BODY = {
+  emailAddress: USER,
+  groups:       %w(browse)
+}.freeze
+
+# Unit tests for User class
+#
+class WavefrontUserTest < WavefrontTestBase
+  def test_list
+    should_work(:list, nil, '')
+  end
+
+  def test_describe
+    should_work(:describe, USER, USER)
+    should_be_invalid(:describe, 'abcdefg')
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_create
+    should_work(:create, [USER_BODY, true], '?sendEmail=true', :post,
+                JSON_POST_HEADERS, USER_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, USER, USER, :delete)
+    should_be_invalid(:delete, 'abcdefg')
+    assert_raises(ArgumentError) { wf.delete }
+  end
+
+  def test_grant
+    should_work(:grant, [USER, GROUP], 'user%40example.com/grant',
+                :post, JSON_POST_HEADERS.merge(
+                  {'Content-Type': 'application/x-www-form-urlencoded'}),
+                "group=#{GROUP}")
+    should_be_invalid(:grant, ['abcde', GROUP])
+    assert_raises(ArgumentError) { wf.grant }
+  end
+
+  def test_revoke
+    should_work(:revoke, [USER, GROUP], 'user%40example.com/revoke',
+                :post, JSON_POST_HEADERS.merge(
+                  {'Content-Type': 'application/x-www-form-urlencoded'}),
+                "group=#{GROUP}")
+    should_be_invalid(:revoke, ['abcde', GROUP])
+    assert_raises(ArgumentError) { wf.revoke }
+  end
+end