wavefront-sdk 3.3.2 → 3.3.3

data/spec/wavefront-sdk/event_spec.rb

@@ -1,25 +1,18 @@
 #!/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:   1_493_385_089_000,
-  endTime:     1_493_385_345_678,
-  tags:        %w[tag1 tag2],
-  isEphemeral: false
-}.freeze
+require_relative '../test_mixins/general'
+require_relative '../test_mixins/tag'
 
 # Unit tests for event class
 #
 class WavefrontEventTest < WavefrontTestBase
+  include WavefrontTest::Tag
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::Update
+
   def test_list
     t1 = Time.now - 600
     t2 = Time.now
@@ -28,54 +21,52 @@ class WavefrontEventTest < WavefrontTestBase
 
     assert_raises(ArgumentError) { wf.list }
 
-    should_work(:list, [t1, t2],
-                "?earliestStartTimeEpochMillis=#{tms1}" \
-                "&latestStartTimeEpochMillis=#{tms2}" \
-                '&limit=100')
+    time_qs = ["earliestStartTimeEpochMillis=#{tms1}",
+               "latestStartTimeEpochMillis=#{tms2}",
+               'limit=100'].join('&')
 
-    should_work(:list, [tms1, tms2],
-                "?earliestStartTimeEpochMillis=#{tms1}" \
-                "&latestStartTimeEpochMillis=#{tms2}" \
-                '&limit=100')
+    assert_gets("/api/v2/event?#{time_qs}") { wf.list(t1, t2) }
+    assert_gets("/api/v2/event?#{time_qs}") { wf.list(tms1, tms2) }
 
     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_close
+    assert_posts("/api/v2/event/#{id}/close") do
+      wf.close(id)
+    end
 
-  def test_describe
-    should_work(:describe, EVENT, EVENT)
-    should_be_invalid(:describe, 'abcdefg')
-    assert_raises(ArgumentError) { wf.describe }
+    assert_invalid_id { wf.close(invalid_id) }
+    assert_raises(ArgumentError) { wf.close }
   end
 
-  def test_close
-    should_work(:close, EVENT, "#{EVENT}/close", :post, POST_HEADERS)
-    should_be_invalid(:close, 'abcdefg')
-    assert_raises(ArgumentError) { wf.close }
+  private
+
+  def id
+    '1481553823153:testev'
   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 }
+  def invalid_id
+    'nonsense'
   end
 
-  def test_delete
-    should_work(:delete, EVENT, EVENT, :delete)
-    should_be_invalid(:delete, 'abcdefg')
-    assert_raises(ArgumentError) { wf.delete }
+  def api_class
+    'event'
   end
 
-  def test_tags
-    tag_tester(EVENT)
+  def payload
+    { name:        'test_event',
+      annotations: {
+        severity: 'info',
+        type:     'SDK test event',
+        details:  'an imaginary event to test the SDK'
+      },
+      hosts:       %w[host1 host2],
+      startTime:   1_493_385_089_000,
+      endTime:     1_493_385_345_678,
+      tags:        %w[tag1 tag2],
+      isEphemeral: false }
   end
 end

data/spec/wavefront-sdk/externallink_spec.rb

@@ -1,67 +1,36 @@
 #!/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'
-}.freeze
-
-# rubocop:disable Style/MutableConstant
-EXTERNAL_LINK_BODY_2 = {
-  name:        'test link',
-  template:    'https://example.com/link/{{value}}'
-}
-# rubocop:enable Style/MutableConstant
+require_relative '../test_mixins/general'
 
 # Unit tests for ExternalLink class
 #
 class WavefrontExternalLinkTest < WavefrontTestBase
-  def api_base
-    'extlink'
-  end
+  include WavefrontTest::List
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::Update
 
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
+  private
 
-  def test_describe
-    should_work(:describe, EXTERNAL_LINK, EXTERNAL_LINK)
-    should_be_invalid(:describe, 'abcdefg')
-    assert_raises(ArgumentError) { wf.describe }
+  def id
+    'lq6rPlSg2CFMSrg6'
   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') }
+  def invalid_id
+    '__rubbish_id__'
   end
 
-  def test_delete
-    should_work(:delete, EXTERNAL_LINK, EXTERNAL_LINK, :delete)
-    should_be_invalid(:delete, 'abcdefg')
-    assert_raises(ArgumentError) { wf.delete }
+  def payload
+    [{ name:        'test link',
+       template:    'https://example.com/link/{{value}}',
+       description: 'an imaginary link for unit testing purposes' },
+     { name:        'test link',
+       template:    'https://example.com/link/{{value}}' }]
   end
 
-  def test_update
-    should_work(:update, [EXTERNAL_LINK, EXTERNAL_LINK_BODY, false],
-                EXTERNAL_LINK, :put, JSON_POST_HEADERS,
-                EXTERNAL_LINK_BODY.to_json)
-
-    should_work(:update, [EXTERNAL_LINK, EXTERNAL_LINK_BODY_2, false],
-                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) }
+  def api_class
+    'extlink'
   end
 end

data/spec/wavefront-sdk/integration_spec.rb

@@ -1,67 +1,62 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-INTEGRATION = 'tester'.freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for Integration class
 #
 class WavefrontIntegrationTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
-
-  def test_install
-    should_work(:install, INTEGRATION, ["#{INTEGRATION}/install", nil],
-                :post, POST_HEADERS)
-    should_be_invalid(:install)
-    assert_raises(ArgumentError) { wf.install }
-  end
+  include WavefrontTest::Describe
+  include WavefrontTest::InstallUninstall
+  include WavefrontTest::List
 
   def test_install_all_alerts
-    should_work(:install_all_alerts, INTEGRATION,
-                ["#{INTEGRATION}/install-all-alerts", nil],
-                :post, POST_HEADERS)
-    should_be_invalid(:install_all_alerts)
-    assert_raises(ArgumentError) { wf.install_all_alerts }
-  end
+    assert_posts("/api/v2/integration/#{id}/install-all-alerts") do
+      wf.install_all_alerts(id)
+    end
 
-  def test_uninstall
-    should_work(:uninstall, INTEGRATION, ["#{INTEGRATION}/uninstall", nil],
-                :post, POST_HEADERS)
-    should_be_invalid(:uninstall)
-    assert_raises(ArgumentError) { wf.uninstall }
+    assert_invalid_id { wf.install_all_alerts(invalid_id) }
+    assert_raises(ArgumentError) { wf.install_all_alerts }
   end
 
   def test_uninstall_all_alerts
-    should_work(:uninstall_all_alerts, INTEGRATION,
-                ["#{INTEGRATION}/uninstall-all-alerts", nil],
-                :post, POST_HEADERS)
-    should_be_invalid(:uninstall_all_alerts)
-    assert_raises(ArgumentError) { wf.uninstall_all_alerts }
-  end
+    assert_posts("/api/v2/integration/#{id}/uninstall-all-alerts") do
+      wf.uninstall_all_alerts(id)
+    end
 
-  def test_describe
-    should_work(:describe, INTEGRATION, INTEGRATION)
-    should_be_invalid(:describe)
-    assert_raises(ArgumentError) { wf.describe }
+    assert_invalid_id { wf.uninstall_all_alerts(invalid_id) }
+    assert_raises(ArgumentError) { wf.uninstall_all_alerts }
   end
 
   def test_status
-    should_work(:status, INTEGRATION, "#{INTEGRATION}/status")
-    should_be_invalid(:status)
+    assert_gets("/api/v2/integration/#{id}/status") { wf.status(id) }
+    assert_invalid_id { wf.status(invalid_id) }
     assert_raises(ArgumentError) { wf.status }
   end
 
   def test_installed
-    should_work(:installed, nil, 'installed')
+    assert_gets('/api/v2/integration/installed') { wf.installed }
   end
 
   def test_manifests
-    should_work(:manifests, nil, 'manifests')
+    assert_gets('/api/v2/integration/manifests') { wf.manifests }
   end
 
   def test_statuses
-    should_work(:statuses, nil, 'status')
+    assert_gets('/api/v2/integration/status') { wf.statuses }
+  end
+
+  private
+
+  def api_class
+    'integration'
+  end
+
+  def id
+    'tester'
+  end
+
+  def invalid_id
+    'very bad id'
   end
 end

data/spec/wavefront-sdk/maintenancewindow_spec.rb

@@ -1,48 +1,33 @@
 #!/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
+require_relative '../test_mixins/general'
 
 # 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
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::List
+  include WavefrontTest::Update
 
-  def test_describe
-    should_work(:describe, WINDOW, WINDOW)
-    should_be_invalid(:describe, 'abcdefg')
-    assert_raises(ArgumentError) { wf.describe }
-  end
+  private
 
-  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') }
+  def api_class
+    'maintenancewindow'
   end
 
-  def test_delete
-    should_work(:delete, WINDOW, WINDOW, :delete)
-    should_be_invalid(:delete, 'abcdefg')
-    assert_raises(ArgumentError) { wf.delete }
+  def id
+    '1493324005091'
   end
 
-  def test_update
-    should_work(:update, [WINDOW, WINDOW_BODY, false], WINDOW, :put,
-                JSON_POST_HEADERS, WINDOW_BODY.to_json)
-    should_be_invalid(:update, ['abcde', WINDOW_BODY])
-    assert_raises(ArgumentError) { wf.update }
+  def payload
+    { 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] }
   end
 end

data/spec/wavefront-sdk/message_spec.rb

@@ -8,12 +8,27 @@ MESSAGE = 'CLUSTER::IHjNaHM9'.freeze
 #
 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')
+    assert_gets('/api/v2/message?offset=10&limit=100&unreadOnly=true') do
+      wf.list(10)
+    end
+
+    assert_gets('/api/v2/message?offset=12&limit=34&unreadOnly=false') do
+      wf.list(12, 34, false)
+    end
   end
 
   def test_read
-    should_work(:read, MESSAGE, "#{MESSAGE}/read", :post, POST_HEADERS)
-    should_be_invalid(:read, 'bad id')
+    assert_posts("/api/v2/message/#{id}/read") { wf.read(id) }
+    assert_invalid_id { wf.read(invalid_id) }
+  end
+
+  private
+
+  def id
+    'CLUSTER::IHjNaHM9'
+  end
+
+  def invalid_id
+    '__!!__'
   end
 end

data/spec/wavefront-sdk/metric_spec.rb

@@ -5,16 +5,20 @@ 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_gets('/api/v2/chart/metric/detail?m=test.metric') do
+      wf.detail('test.metric')
+    end
+
+    assert_gets('/api/v2/chart/metric/detail?m=path&h=host1&h=host2') do
+      wf.detail('path', %w[host1 host2])
+    end
+
+    assert_gets('/api/v2/chart/metric/detail?m=test.metric&' \
+                'h=host1&h=host2&c=abc') do
+      wf.detail('test.metric', %w[host1 host2], 'abc')
+    end
+
     assert_raises(ArgumentError) { wf.detail }
     assert_raises(ArgumentError) { wf.detail('m1', 'm2') }
   end

data/spec/wavefront-sdk/notificant_spec.rb

@@ -1,30 +1,31 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-NOTIFICANT = '8Bl5l7wxtdGindxk'.freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for notificant class
 #
 class WavefrontNotificantTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
+  include WavefrontTest::List
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+
+  def test_test
+    assert_posts("/api/v2/notificant/test/#{id}") { wf.test(id) }
+    assert_invalid_id { wf.test(invalid_id) }
   end
 
-  def test_describe
-    should_work(:describe, NOTIFICANT, NOTIFICANT)
-    should_be_invalid(:describe)
-    assert_raises(ArgumentError) { wf.describe }
+  private
+
+  def api_class
+    'notificant'
   end
 
-  def test_delete
-    should_work(:delete, NOTIFICANT, NOTIFICANT, :delete)
-    should_be_invalid('delete')
+  def id
+    '8Bl5l7wxtdGindxk'
   end
 
-  def test_test
-    should_work(:test, NOTIFICANT, ["test/#{NOTIFICANT}", nil],
-                :post, POST_HEADERS)
-    should_be_invalid('test')
+  def invalid_id
+    '---rubbish---'
   end
 end