wavefront-sdk 3.3.2 → 3.3.3

data/spec/wavefront-sdk/apitoken_spec.rb

@@ -1,31 +1,44 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-API_TOKEN_ID = '17db4cc1-65f6-40a8-a1fa-6fcae460c4bd'.freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for API token class
 #
 class WavefrontApiTokenTest < WavefrontTestBase
+  include WavefrontTest::Delete
+
   def test_list
-    should_work(:list, [], '')
+    assert_gets('/api/v2/apitoken') { wf.list }
   end
 
   def test_create
-    should_work(:create, [], '', :post, JSON_POST_HEADERS, nil)
+    assert_posts('/api/v2/apitoken', 'null') { wf.create }
     assert_raises(ArgumentError) { wf.create('test') }
   end
 
-  def test_delete
-    should_work(:delete, API_TOKEN_ID, API_TOKEN_ID, :delete)
-    should_be_invalid(:delete)
-  end
-
   def test_rename
-    should_work(:rename, [API_TOKEN_ID, 'token name'],
-                API_TOKEN_ID, :put, JSON_POST_HEADERS,
-                { tokenID: API_TOKEN_ID, tokenName: 'token name' }.to_json)
-    should_be_invalid(:rename, ['!invalid token!', 'token name'])
+    assert_puts("/api/v2/apitoken/#{id}",
+                tokenID: id, tokenName: 'token name') do
+      wf.rename(id, 'token name')
+    end
+
+    assert_invalid_id { wf.rename(invalid_id, 'token name') }
     assert_raises(ArgumentError) { wf.rename }
+    assert_raises(ArgumentError) { wf.rename(id) }
+  end
+
+  private
+
+  def id
+    '17db4cc1-65f6-40a8-a1fa-6fcae460c4bd'
+  end
+
+  def invalid_id
+    '__rubbish__'
+  end
+
+  def api_class
+    'apitoken'
   end
 end

data/spec/wavefront-sdk/cloudintegration_spec.rb

@@ -1,66 +1,64 @@
 #!/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
+require_relative '../test_mixins/general'
 
 # Unit tests for CloudIntegration class
 #
 class WavefrontCloudIntegrationTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
+  include WavefrontTest::List
+  include WavefrontTest::Create
+  include WavefrontTest::Describe
+  include WavefrontTest::Update
+  include WavefrontTest::DeleteUndelete
+
+  def test_update
+    assert_puts("/api/v2/cloudintegration/#{id}", payload) do
+      wf.update(id, payload)
+    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') }
+    assert_invalid_id { wf.update(invalid_id, payload) }
+    assert_raises(ArgumentError) { wf.update }
   end
 
-  def test_delete
-    should_work(:delete, CLOUD, CLOUD, :delete)
-    should_be_invalid(:delete)
+  def test_enable
+    assert_posts("/api/v2/cloudintegration/#{id}/enable") { wf.enable(id) }
+    assert_invalid_id { wf.enable(invalid_id) }
+    assert_raises(ArgumentError) { wf.enable }
   end
 
-  def test_describe
-    should_work(:describe, CLOUD, CLOUD)
-    should_be_invalid(:describe)
+  def test_disable
+    assert_posts("/api/v2/cloudintegration/#{id}/disable") do
+      wf.disable(id)
+    end
+
+    assert_invalid_id { wf.disable(invalid_id) }
+    assert_raises(ArgumentError) { wf.disable }
   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 }
+  private
+
+  def id
+    '3b56f61d-1a79-46f6-905c-d75a0f613d10'
   end
 
-  def test_undelete
-    should_work(:undelete, CLOUD, ["#{CLOUD}/undelete", nil], :post,
-                POST_HEADERS)
-    should_be_invalid(:undelete)
+  def invalid_id
+    '__rubbish__'
   end
 
-  def test_disable
-    should_work(:disable, CLOUD, ["#{CLOUD}/disable", nil], :post,
-                POST_HEADERS)
-    should_be_invalid(:disable)
+  def payload
+    { name: 'SDK test Cloudwatch Integration',
+      service: 'CLOUDWATCH',
+      cloudWatch: {
+        baseCredentials: {
+          roleArn:    'arn:aws:iam::<accountid>:role/<rolename>',
+          externalId: 'wave123'
+        }
+      },
+      metricFilterRegex: '^aws.(sqs|ec2|ebs|elb).*$' }
   end
 
-  def test_enable
-    should_work(:enable, CLOUD, ["#{CLOUD}/enable", nil], :post,
-                POST_HEADERS)
-    should_be_invalid(:enable)
+  def api_class
+    'cloudintegration'
   end
 end

data/spec/wavefront-sdk/dashboard_spec.rb

@@ -1,95 +1,76 @@
 #!/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
+require_relative '../test_mixins/acl'
+require_relative '../test_mixins/tag'
+require_relative '../test_mixins/update_keys'
+require_relative '../test_mixins/general'
 
 # Unit tests for dashboard class
 #
 class WavefrontDashboardTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
+  include WavefrontTest::Acl
+  include WavefrontTest::Create
+  include WavefrontTest::DeleteUndelete
+  include WavefrontTest::Describe
+  include WavefrontTest::History
+  include WavefrontTest::List
+  include WavefrontTest::Tag
+  include WavefrontTest::Update
+  include WavefrontTest::UpdateKeys
 
-  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")
+  def test_favorite
+    assert_posts("/api/v2/dashboard/#{id}/favorite") { wf.favorite(id) }
+    assert_invalid_id { wf.favorite(invalid_id) }
+    assert_raises(ArgumentError) { wf.favorite }
+    assert_posts("/api/v2/dashboard/#{id}/favorite") { wf.favourite(id) }
+    assert_invalid_id { wf.favourite(invalid_id) }
+    assert_raises(ArgumentError) { wf.favourite }
   end
 
-  def test_delete
-    should_work(:delete, DASHBOARD, DASHBOARD, :delete)
-    should_be_invalid(:delete)
-  end
+  def test_unfavorite
+    assert_posts("/api/v2/dashboard/#{id}/unfavorite") { wf.unfavorite(id) }
+    assert_invalid_id { wf.unfavorite(invalid_id) }
+    assert_raises(ArgumentError) { wf.unfavorite }
 
-  def test_update
-    should_work(:update, [DASHBOARD, DASHBOARD_BODY, false],
-                DASHBOARD, :put, JSON_POST_HEADERS,
-                DASHBOARD_BODY.to_json)
-    should_be_invalid(:update, ['!invalid dash!', DASHBOARD_BODY])
-    assert_raises(ArgumentError) { wf.update }
-  end
+    assert_posts("/api/v2/dashboard/#{id}/unfavorite") do
+      wf.unfavourite(id)
+    end
 
-  def test_favorite
-    should_work(:favorite, DASHBOARD, ["#{DASHBOARD}/favorite",
-                                       nil], :post, POST_HEADERS)
-    should_work(:favourite, DASHBOARD, ["#{DASHBOARD}/favorite",
-                                        nil], :post, POST_HEADERS)
-    should_be_invalid(:favorite)
+    assert_invalid_id { wf.unfavourite(invalid_id) }
+    assert_raises(ArgumentError) { wf.unfavourite }
   end
 
-  def test_history
-    should_work(:history, DASHBOARD, "#{DASHBOARD}/history")
-    should_be_invalid(:history)
-  end
+  private
 
-  def test_tags
-    tag_tester(DASHBOARD)
+  def api_class
+    'dashboard'
   end
 
-  def test_acls
-    acl_tester(DASHBOARD)
+  def id
+    'test_dashboard'
   end
 
-  def test_undelete
-    should_work(:undelete, DASHBOARD, ["#{DASHBOARD}/undelete",
-                                       nil], :post, POST_HEADERS)
-    should_be_invalid(:undelete)
+  def invalid_id
+    'a bad dashboard name'
   end
 
-  def test_unfavorite
-    should_work(:unfavorite, DASHBOARD, ["#{DASHBOARD}/unfavorite",
-                                         nil], :post, POST_HEADERS)
-    should_work(:unfavourite, DASHBOARD, ["#{DASHBOARD}/unfavorite",
-                                          nil], :post, POST_HEADERS)
-    should_be_invalid(:unfavorite)
+  def payload
+    { 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")' }
+            ]
+          ] }
+        ]
+      ] }
   end
 end

data/spec/wavefront-sdk/derivedmetric_spec.rb

@@ -1,66 +1,40 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-DERIVED_METRIC = '1529926075038'.freeze
-DERIVED_METRIC_BODY = {
-  minutes: 5,
-  name: 'test_1',
-  query: 'aliasMetric(ts("test.metric"), "derived.test_1")',
-  tags: { customerTags: ['test'] },
-  includeObsoleteMetrics: false,
-  processRateMinutes: 1
-}.freeze
+require_relative '../test_mixins/general'
+require_relative '../test_mixins/tag'
 
 # Unit tests for derived metric class
 #
 class WavefrontDerivedMetricTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
+  include WavefrontTest::Create
+  include WavefrontTest::DeleteUndelete
+  include WavefrontTest::Describe
+  include WavefrontTest::History
+  include WavefrontTest::List
+  include WavefrontTest::Tag
+  include WavefrontTest::Update
 
-  def test_create
-    should_work(:create, DERIVED_METRIC_BODY, '', :post,
-                JSON_POST_HEADERS, DERIVED_METRIC_BODY.to_json)
-    assert_raises(ArgumentError) { wf.create }
-    assert_raises(ArgumentError) { wf.create('test') }
-  end
-
-  def test_describe
-    should_work(:describe, DERIVED_METRIC, DERIVED_METRIC)
-    assert_raises(ArgumentError) { wf.describe }
-  end
-
-  def test_describe_v
-    should_work(:describe, [DERIVED_METRIC, 4], "#{DERIVED_METRIC}/history/4")
-  end
-
-  def test_delete
-    should_work(:delete, DERIVED_METRIC, DERIVED_METRIC, :delete)
-    should_be_invalid(:delete)
-  end
+  private
 
-  def test_history
-    should_work(:history, DERIVED_METRIC, "#{DERIVED_METRIC}/history")
-    should_be_invalid(:history)
+  def id
+    '1529926075038'
   end
 
-  def test_update
-    should_work(:update, [DERIVED_METRIC, DERIVED_METRIC_BODY, false],
-                DERIVED_METRIC, :put, JSON_POST_HEADERS,
-                DERIVED_METRIC_BODY.to_json)
-    should_be_invalid(:update, ['!invalid derived metric!',
-                                DERIVED_METRIC_BODY])
-    assert_raises(ArgumentError) { wf.update }
+  def invalid_id
+    '! invalid derived metric !'
   end
 
-  def test_tags
-    tag_tester(DERIVED_METRIC)
+  def payload
+    { minutes: 5,
+      name: 'test_1',
+      query: 'aliasMetric(ts("test.metric"), "derived.test_1")',
+      tags: { customerTags: ['test'] },
+      includeObsoleteMetrics: false,
+      processRateMinutes: 1 }
   end
 
-  def test_undelete
-    should_work(:undelete, DERIVED_METRIC, ["#{DERIVED_METRIC}/undelete",
-                                            nil], :post, POST_HEADERS)
-    should_be_invalid(:undelete)
+  def api_class
+    'derivedmetric'
   end
 end

data/spec/wavefront-sdk/distribution_spec.rb

@@ -3,20 +3,11 @@
 require_relative '../spec_helper'
 require_relative '../../lib/wavefront-sdk/distribution'
 
-DIST = {
-  interval: :m,
-  path:     'test.distribution',
-  value:    [[5, 11], [15, 2.533], [8, -15], [12, 1e6]],
-  ts:       1_538_865_613,
-  source:   'minitest',
-  tags:     { tag1: 'val1', tag2: 'val2' }
-}.freeze
-
 # Most of the distribution methods are inherited from the Write
 # class so they aren't tested again here.
 #
 class WavefrontDistributionTest < MiniTest::Test
-  attr_reader :wf, :wf_noop, :wf_tags
+  attr_reader :wf
 
   def setup
     @wf = Wavefront::Distribution.new(W_CREDS)
@@ -39,19 +30,19 @@ class WavefrontDistributionTest < MiniTest::Test
   end
 
   def test_hash_to_wf
-    assert_equal(wf.hash_to_wf(DIST),
+    assert_equal(wf.hash_to_wf(distribution),
                  '!M 1538865613 #5 11 #15 2.533 #8 -15 #12 1000000.0 ' \
                  'test.distribution source=minitest ' \
                  'tag1="val1" tag2="val2"')
 
-    d2 = DIST.dup
+    d2 = distribution.dup
     d2[:tags] = {}
 
     assert_equal(wf.hash_to_wf(d2),
                  '!M 1538865613 #5 11 #15 2.533 #8 -15 #12 1000000.0 ' \
                  'test.distribution source=minitest')
 
-    d3 = DIST.dup
+    d3 = distribution.dup
     d3[:ts] = Time.at(1_538_865_613)
     d3 = d3.tap { |d| d.delete(:source) }
 
@@ -60,7 +51,7 @@ class WavefrontDistributionTest < MiniTest::Test
                  "test.distribution source=#{Socket.gethostname} " \
                  'tag1="val1" tag2="val2"')
 
-    bad_dist = DIST.dup
+    bad_dist = distribution.dup
     bad_dist.delete(:interval)
 
     assert_raises(Wavefront::Exception::InvalidDistribution) do
@@ -72,4 +63,13 @@ class WavefrontDistributionTest < MiniTest::Test
     assert_equal(wf.array2dist([[1, 4], [6, 5]]), '#1 4 #6 5')
     assert_equal(wf.array2dist([[12, 4.235]]), '#12 4.235')
   end
+
+  def distribution
+    { interval: :m,
+      path:     'test.distribution',
+      value:    [[5, 11], [15, 2.533], [8, -15], [12, 1e6]],
+      ts:       1_538_865_613,
+      source:   'minitest',
+      tags:     { tag1: 'val1', tag2: 'val2' } }
+  end
 end