wavefront-sdk 0.0.1

data/spec/wavefront-sdk/alert_spec.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+ALERT = '1481553823153'.freeze
+ALERT_BODY = {
+  name:               'SDK test alert',
+  target:             'user@example.com',
+  condition:          'ts("app.errors") > 0',
+  displayExpression:  'ts("app.errors")',
+  minutes:             5,
+  resolveAfterMinutes: 5,
+  severity:            'INFO'
+}.freeze
+
+# Unit tests for Alert class
+#
+class WavefrontAlertTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_describe
+    should_work(:describe, ALERT, ALERT)
+    assert_raises(ArgumentError) { wf.describe }
+    should_be_invalid(:describe)
+  end
+
+  def test_create
+    should_work(:create, ALERT_BODY, '', :post, JSON_POST_HEADERS,
+                ALERT_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_describe_v
+    should_work(:describe, [ALERT, 4], "#{ALERT}/history/4")
+  end
+
+  def test_delete
+    should_work(:delete, ALERT, ALERT, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_history
+    should_work(:history, ALERT, "#{ALERT}/history")
+    should_be_invalid(:history)
+  end
+
+  def test_snooze
+    should_work(:snooze, ALERT, "#{ALERT}/snooze", :post, POST_HEADERS)
+    should_work(:snooze, [ALERT, 3600], "#{ALERT}/snooze?seconds=3600",
+                :post, POST_HEADERS)
+    should_be_invalid(:snooze)
+  end
+
+  def test_update
+    should_work(:update, [ALERT, ALERT_BODY], ALERT, :put,
+                JSON_POST_HEADERS, ALERT_BODY.to_json)
+    should_be_invalid(:update, ['abcde', ALERT_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_tags
+    tag_tester(ALERT)
+  end
+
+  def test_undelete
+    should_work(:undelete, ALERT, ["#{ALERT}/undelete", nil], :post,
+                POST_HEADERS)
+    should_be_invalid(:undelete)
+  end
+
+  def test_unsnooze
+    should_work(:unsnooze, ALERT, ["#{ALERT}/unsnooze", nil], :post,
+                POST_HEADERS)
+    should_be_invalid(:unsnooze)
+  end
+
+  def test_summary
+    should_work(:summary, nil, 'summary')
+  end
+end

data/spec/wavefront-sdk/base_spec.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/base'
+
+#
+# Test SDK base class
+#
+class WavefrontBaseTest < MiniTest::Test
+  attr_reader :wf, :wf_noop, :uri_base, :headers
+
+  def setup
+    @wf = Wavefront::Base.new(CREDS)
+    @wf_noop = Wavefront::Base.new(CREDS, noop: true)
+    @uri_base = "https://#{CREDS[:endpoint]}/api/v2/base"
+    @headers = { 'Authorization' => "Bearer #{CREDS[:token]}" }
+    @update_keys = []
+  end
+
+  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
+    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 ['', '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 ['/a', '/b c'].uri_concat, '/a/b c'
+  end
+
+  def test_api_get
+    uri = "#{uri_base}/path?key1=val1"
+    stub_request(:get, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+    wf.api_get('/path', key1: 'val1')
+    assert_requested(:get, uri, headers: headers)
+  end
+
+  def test_api_post
+    uri = "#{uri_base}/path"
+    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',
+                                 headers: headers.merge(POST_HEADERS))
+    wf.api_post('/path', obj)
+    assert_requested(:post, uri, body: obj.to_json,
+                                 headers: headers.merge(POST_HEADERS))
+  end
+
+  def test_api_put
+    uri = "#{uri_base}/path"
+    stub_request(:put, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+    wf.api_put('/path', 'body')
+    assert_requested(:put, uri, body: 'body'.to_json,
+                                headers: headers.merge(JSON_POST_HEADERS))
+  end
+
+  def test_api_delete
+    uri = "#{uri_base}/path"
+    stub_request(:delete, uri).to_return(body: DUMMY_RESPONSE, status: 200)
+    wf.api_delete('/path')
+    assert_requested(:delete, uri, headers: headers)
+  end
+
+  def test_api_noop
+    uri = "#{uri_base}/path"
+
+    %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)
+    end
+  end
+
+  def test_hash_for_update
+    wf.instance_variable_set('@update_keys',  [:k1, :k2])
+    body = { k1: 'ov1', k2: 'ov2', k3: 'ov3'}
+    upd = { k2: 'nv1' }
+
+    assert_equal(wf.hash_for_update(body, upd), { k1: 'ov1', k2: 'nv1'})
+  end
+end

data/spec/wavefront-sdk/cloudintegration_spec.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+CLOUD = '3b56f61d-1a79-46f6-905c-d75a0f613d10'.freeze
+CLOUD_BODY = {
+  name: 'SDK test Cloudwatch Integration',
+  service: 'CLOUDWATCH',
+  cloudWatch: {
+    baseCredentials: {
+      roleArn:    'arn:aws:iam::<accountid>:role/<rolename>',
+      externalId: 'wave123'
+    }
+  },
+  metricFilterRegex: '^aws.(sqs|ec2|ebs|elb).*$'
+}.freeze
+
+# Unit tests for CloudIntegration class
+#
+class WavefrontCloudIntegrationTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_create
+    should_work(:create, CLOUD_BODY, '', :post, JSON_POST_HEADERS,
+                CLOUD_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, CLOUD, CLOUD, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_describe
+    should_work(:describe, CLOUD, CLOUD)
+    should_be_invalid(:describe)
+  end
+
+  def test_update
+    should_work(:update, [CLOUD, CLOUD_BODY], CLOUD, :put,
+                JSON_POST_HEADERS, CLOUD_BODY.to_json)
+    should_be_invalid(:update, ['abcde', CLOUD_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_undelete
+    should_work(:undelete, CLOUD, ["#{CLOUD}/undelete", nil], :post,
+                POST_HEADERS)
+    should_be_invalid(:undelete)
+  end
+end

data/spec/wavefront-sdk/credentials_spec.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require_relative '../spec_helper'
+require_relative '../../lib/wavefront-sdk/credentials'
+
+CONF = Pathname.new(__FILE__).dirname.realpath + 'resources' + 'test.conf'
+
+# Test SDK base class
+#
+class WavefrontCredentialsTest < MiniTest::Test
+  attr_reader :wf, :wf_noop, :uri_base, :headers
+
+  def test_initialize_1
+    ENV.delete('WAVEFRONT_ENDPOINT')
+    ENV.delete('WAVEFRONT_TOKEN')
+    c = Wavefront::Credentials.new(file: CONF)
+    assert_instance_of(Wavefront::Credentials, c)
+    assert_instance_of(Hash, c.creds)
+    assert_instance_of(Hash, c.proxy)
+    assert_instance_of(Hash, c.config)
+
+    assert_equal(c.creds.keys, [:token, :endpoint])
+    assert_equal(c.creds[:token], '12345678-abcd-1234-abcd-123456789012')
+    assert_equal(c.creds[:endpoint], 'default.wavefront.com')
+  end
+
+  def test_initialize_env_token
+    ENV.delete('WAVEFRONT_ENDPOINT')
+    ENV['WAVEFRONT_TOKEN'] = 'abcdefgh'
+    c = Wavefront::Credentials.new(file: CONF)
+    assert_instance_of(Wavefront::Credentials, c)
+    assert_instance_of(Hash, c.creds)
+    assert_instance_of(Hash, c.proxy)
+    assert_instance_of(Hash, c.config)
+
+    assert_equal(c.creds.keys, [:token, :endpoint])
+    assert_equal(c.creds[:token], 'abcdefgh')
+    assert_equal(c.creds[:endpoint], 'default.wavefront.com')
+  end
+
+  def test_initialize_env_endpoint
+    ENV.delete('WAVEFRONT_TOKEN')
+    ENV['WAVEFRONT_ENDPOINT'] = 'endpoint.wavefront.com'
+    c = Wavefront::Credentials.new(file: CONF)
+    assert_instance_of(Wavefront::Credentials, c)
+    assert_instance_of(Hash, c.creds)
+    assert_instance_of(Hash, c.proxy)
+    assert_instance_of(Hash, c.config)
+
+    assert_equal(c.creds.keys, [:token, :endpoint])
+    assert_equal(c.creds[:token], '12345678-abcd-1234-abcd-123456789012')
+    assert_equal(c.creds[:endpoint], 'endpoint.wavefront.com')
+  end
+end

data/spec/wavefront-sdk/dashboard_spec.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+DASHBOARD = 'test_dashboard'.freeze
+DASHBOARD_BODY = {
+  name: 'SDK Dashboard test',
+  id: 'sdk-test',
+  description: 'dummy test dashboard',
+  sections: [
+    name: 'Section 1',
+    rows: [
+      { charts: [
+        name: 'S1 Chart1',
+        description: 'chart',
+        sources: [
+          { name: 'S1 C1 Source 1',
+            query: 'ts("some.series")' }
+        ]
+      ] }
+    ]
+  ]
+}.freeze
+
+# Unit tests for dashboard class
+#
+class WavefrontDashboardTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_create
+    should_work(:create, DASHBOARD_BODY, '', :post,
+                JSON_POST_HEADERS, DASHBOARD_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_describe
+    should_work(:describe, DASHBOARD, DASHBOARD)
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_describe_v
+    should_work(:describe, [DASHBOARD, 4], "#{DASHBOARD}/history/4")
+  end
+
+  def test_delete
+    should_work(:delete, DASHBOARD, DASHBOARD, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_history
+    should_work(:history, DASHBOARD, "#{DASHBOARD}/history")
+    should_be_invalid(:history)
+  end
+
+  def test_update
+    should_work(:update, [DASHBOARD, DASHBOARD_BODY], DASHBOARD, :put,
+                JSON_POST_HEADERS, DASHBOARD_BODY.to_json)
+    should_be_invalid(:update, ['!invalid dash!', DASHBOARD_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_tags
+    tag_tester(DASHBOARD)
+  end
+
+  def test_undelete
+    should_work(:undelete, DASHBOARD, ["#{DASHBOARD}/undelete",
+                                       nil], :post, POST_HEADERS)
+    should_be_invalid(:undelete)
+  end
+end

data/spec/wavefront-sdk/event_spec.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+EVENT = '1481553823153:testev'.freeze
+EVENT_BODY = {
+  name:        'test_event',
+  annotations: {
+    severity: 'info',
+    type:     'SDK test event',
+    details:  'an imaginary event to test the SDK'
+  },
+  hosts:       %w(host1 host2),
+  startTime:   1493385089000,
+  endTime:     1493385345678,
+  tags:        %w(tag1 tag2),
+  isEphemeral: false
+}.freeze
+
+# Unit tests for event class
+#
+class WavefrontEventTest < WavefrontTestBase
+  def test_list
+
+    t1 = Time.now - 600
+    t2 = Time.now
+    tms1 = t1.to_datetime.strftime('%Q')
+    tms2 = t2.to_datetime.strftime('%Q')
+
+    assert_raises(ArgumentError) {  wf.list }
+    assert_raises(ArgumentError) {  wf.list(tms1) }
+
+    should_work(:list, [t1, t2],
+                "?earliestStartTimeEpochMillis=#{tms1}" \
+                "&latestStartTimeEpochMillis=#{tms2}" \
+                '&limit=100')
+
+    should_work(:list, [tms1, tms2],
+                "?earliestStartTimeEpochMillis=#{tms1}" \
+                "&latestStartTimeEpochMillis=#{tms2}" \
+                '&limit=100')
+
+    assert_raises(Wavefront::Exception::InvalidTimestamp) do
+      wf.list(t1, 'abc')
+    end
+  end
+
+  def test_create
+    should_work(:create, EVENT_BODY, '', :post,
+                JSON_POST_HEADERS, EVENT_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_describe
+    should_work(:describe, EVENT, EVENT)
+    should_be_invalid(:describe, 'abcdefg')
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_close
+    should_work(:close, EVENT, "#{EVENT}/close", :post, POST_HEADERS)
+    should_be_invalid(:close, 'abcdefg')
+    assert_raises(ArgumentError) { wf.close }
+  end
+
+  def test_update
+    should_work(:update, [EVENT, EVENT_BODY, false], EVENT, :put,
+                JSON_POST_HEADERS, EVENT_BODY.to_json)
+    #should_be_invalid(:update, ['abcde', EVENT_BODY])
+    #assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_delete
+    should_work(:delete, EVENT, EVENT, :delete)
+    should_be_invalid(:delete, 'abcdefg')
+    assert_raises(ArgumentError) { wf.delete }
+  end
+
+  def test_tags
+    tag_tester(EVENT)
+  end
+end

data/spec/wavefront-sdk/externallink_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+EXTERNAL_LINK = 'lq6rPlSg2CFMSrg6'.freeze
+EXTERNAL_LINK_BODY = {
+  name:        'test link',
+  template:    'https://example.com/link/{{value}}',
+  description: 'an imaginary link for unit testing purposes'
+}
+
+EXTERNAL_LINK_BODY_2 = {
+  name:        'test link',
+  template:    'https://example.com/link/{{value}}'
+}
+
+# Unit tests for ExternalLink class
+#
+class WavefrontExternalLinkTest < WavefrontTestBase
+  def api_base
+    'extlink'
+  end
+
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_describe
+    should_work(:describe, EXTERNAL_LINK, EXTERNAL_LINK)
+    should_be_invalid(:describe, 'abcdefg')
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_create
+    should_work(:create, EXTERNAL_LINK_BODY, '', :post,
+                JSON_POST_HEADERS, EXTERNAL_LINK_BODY.to_json)
+
+    should_work(:create, EXTERNAL_LINK_BODY_2, '', :post,
+                JSON_POST_HEADERS, EXTERNAL_LINK_BODY_2
+                .merge!(description: '').to_json)
+
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, EXTERNAL_LINK, EXTERNAL_LINK, :delete)
+    should_be_invalid(:delete, 'abcdefg')
+    assert_raises(ArgumentError) { wf.delete }
+  end
+
+  def test_update
+    should_work(:update, [EXTERNAL_LINK, EXTERNAL_LINK_BODY],
+                EXTERNAL_LINK, :put, JSON_POST_HEADERS,
+                EXTERNAL_LINK_BODY.to_json)
+
+    should_work(:update, [EXTERNAL_LINK, EXTERNAL_LINK_BODY_2],
+                EXTERNAL_LINK, :put, JSON_POST_HEADERS,
+                EXTERNAL_LINK_BODY_2.to_json)
+
+    should_be_invalid(:update, ['abcde', EXTERNAL_LINK_BODY])
+    assert_raises(ArgumentError) { wf.update }
+    assert_raises(ArgumentError) { wf.update(EXTERNAL_LINK) }
+  end
+end