wavefront-sdk 3.3.2 → 3.3.3

data/spec/wavefront-sdk/proxy_spec.rb

@@ -1,41 +1,36 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-PROXY = 'fd248f53-378e-4fbe-bbd3-efabace8d724'.freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for proxy class
 #
 class WavefrontProxyTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
+  include WavefrontTest::DeleteUndelete
+  include WavefrontTest::Describe
+  include WavefrontTest::List
+
+  def test_rename
+    assert_puts("/api/v2/proxy/#{id}", name: 'newname') do
+      wf.rename(id, 'newname')
+    end
 
-  def test_describe
-    should_work(:describe, PROXY, PROXY)
-    should_be_invalid(:describe)
-    assert_raises(ArgumentError) { wf.describe }
+    assert_invalid_id { wf.rename(invalid_id, 'newname') }
+    assert_raises(ArgumentError) { wf.rename(id) }
+    assert_raises(ArgumentError) { wf.rename }
   end
 
-  def test_delete
-    should_work(:delete, PROXY, PROXY, :delete)
-    should_be_invalid('delete')
+  private
+
+  def api_class
+    'proxy'
   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
+  def id
+    'fd248f53-378e-4fbe-bbd3-efabace8d724'
   end
 
-  def test_undelete
-    should_work(:undelete, PROXY, ["#{PROXY}/undelete", nil],
-                :post, POST_HEADERS)
-    should_be_invalid('undelete')
+  def invalid_id
+    'my awesome stupid proxy id'
   end
 end

data/spec/wavefront-sdk/query_spec.rb

@@ -4,30 +4,47 @@ require 'cgi'
 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 = CGI.escape(Q).freeze
-
 # Unit tests for Query class
 #
 class WavefrontQueryTest < WavefrontTestBase
-  def api_base
-    'chart'
+  attr_reader :series, :t_start, :t_start_in_ms, :t_end, :t_end_in_ms,
+              :query, :escaped_query
+
+  def setup_fixtures
+    @series = 'test.metric'
+    @t_start = Time.now
+    @t_start_in_ms = t_start.to_datetime.strftime('%Q')
+    @t_end = t_start + 10
+    @t_end_in_ms = t_end.to_datetime.strftime('%Q')
+    @query = "ts(\"#{series}\")"
+    @escaped_query = CGI.escape(query)
   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_gets("/api/v2/chart/api?q=#{escaped_query}&g=d&" \
+                "s=#{t_start_in_ms}") do
+      wf.query(query, 'd', t_start_in_ms)
+    end
+
+    assert_gets("/api/v2/chart/api?q=#{escaped_query}&g=h&" \
+                "s=#{t_start_in_ms}") do
+      wf.query(query, 'h', t_start)
+    end
+
+    assert_gets("/api/v2/chart/api?q=#{escaped_query}&g=m&" \
+                "s=#{t_start_in_ms}&e=#{t_end_in_ms}") do
+      wf.query(query, 'm', t_start, t_end)
+    end
+
+    assert_gets("/api/v2/chart/api?q=#{query}&g=h&s=#{t_start_in_ms}") do
+      wf.query(query, 'h', t_start, nil, {})
+    end
+
+    assert_gets("/api/v2/chart/api?q=#{escaped_query}&g=h&" \
+                "s=#{t_start_in_ms}&strict=true&summarization=MAX") do
+      wf.query(query, 'h', t_start, nil, strict: true,
+                                         summarization: 'MAX')
+    end
 
     assert_raises(ArgumentError) { wf.query }
 
@@ -41,12 +58,21 @@ class WavefrontQueryTest < WavefrontTestBase
   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_gets("/api/v2/chart/raw?metric=#{series}&source=src") do
+      wf.raw(series, 'src')
+    end
+
+    assert_gets("/api/v2/chart/raw?metric=#{series}&source=src&" \
+                "startTime=#{t_start_in_ms}") do
+      wf.raw(series, 'src', t_start)
+    end
+
+    assert_gets("/api/v2/chart/raw?metric=#{series}&source=src&" \
+                "startTime=#{t_start_in_ms}" \
+                "&endTime=#{t_end_in_ms}") do
+      wf.raw(series, 'src', t_start, t_end)
+    end
+
     assert_raises(ArgumentError) { wf.raw }
   end
 end

data/spec/wavefront-sdk/report_spec.rb

@@ -8,12 +8,9 @@ REPORT_HEADERS = POST_HEADERS.merge('Content-Type': 'application/octet-stream')
 # Unit tests for Report class
 #
 class WavefrontReportTest < WavefrontTestBase
-  def uri_base
-    "https://#{CREDS[:endpoint]}/report"
-  end
-
   def test_write
-    should_work(:write, POINT, ['?f=wavefront', nil],
-                :post, REPORT_HEADERS, POINT_L)
+    assert_posts('/report?f=wavefront', POINT_L, :octet) do
+      wf.write(POINT)
+    end
   end
 end

data/spec/wavefront-sdk/resources/user_responses/add_user_groups.json

@@ -0,0 +1 @@
+{"identifier":"slackboy@gmail.com","customer":"sysdef","lastSuccessfulLogin":1535977667674,"groups":["host_tag_management","dashboard_management","embedded_charts","metrics_management","agent_management","events_management","external_links_management","alerts_management","ingestion","user_management","application_management"],"userGroups":[{"id":"2659191e-aad4-4302-a94e-9667e1517127","name":"Everyone","permissions":[],"customer":"sysdef","properties":{"nameEditable":false,"permissionsEditable":true,"usersEditable":false},"description":"System group which contains all users"},{"id":"6fd972d9-9a20-4872-acf9-4ef34797f14e","name":"grp1","permissions":["host_tag_management","alerts_management"],"customer":"sysdef"}]}

data/spec/wavefront-sdk/resources/user_responses/create.json

@@ -0,0 +1,28 @@
+{
+  "status": {
+    "result": "OK",
+    "message": "Invalid user groups found and ignored [8b23136b-ecd2-4cb5-8c92-62477dcc4090]",
+    "code": 202
+  },
+  "response": {
+    "identifier": "user@example.com",
+    "customer": "sysdef",
+    "groups": [
+      "user_management"
+    ],
+    "userGroups": [
+      {
+        "id": "2659191e-aad4-4302-a94e-9667e1517127",
+        "name": "Everyone",
+        "permissions": [],
+        "customer": "sysdef",
+        "properties": {
+          "nameEditable": false,
+          "permissionsEditable": true,
+          "usersEditable": false
+        },
+        "description": "System group which contains all users"
+      }
+    ]
+  }
+}

data/spec/wavefront-sdk/resources/user_responses/delete_multiple.json

@@ -0,0 +1 @@
+{"status":{"result":"OK","message":"","code":200},"response":["user@example.com"]}

data/spec/wavefront-sdk/resources/user_responses/describe.json

@@ -0,0 +1 @@
+{"identifier":"user1@merp.com","customer":"sysdef","groups":[],"userGroups":[{"id":"2659191e-aad4-4302-a94e-9667e1517127","name":"Everyone","permissions":[],"customer":"sysdef","properties":{"nameEditable":false,"permissionsEditable":true,"usersEditable":false},"description":"System group which contains all users"}]}

data/spec/wavefront-sdk/resources/user_responses/grant.json

@@ -0,0 +1 @@
+{"identifier":"user1@merp.com","customer":"sysdef","groups":["host_tag_management"],"userGroups":[{"id":"2659191e-aad4-4302-a94e-9667e1517127","name":"Everyone","permissions":[],"customer":"sysdef","properties":{"nameEditable":false,"permissionsEditable":true,"usersEditable":false},"description":"System group which contains all users"}]}

data/spec/wavefront-sdk/resources/user_responses/list.json

@@ -0,0 +1 @@
+[{"identifier":"dev+sysdef@wavefront.com","customer":"sysdef","lastSuccessfulLogin":1549996596333,"groups":["agent_management","alerts_management","dashboard_management","ingestion","events_management","host_tag_management","user_management","embedded_charts","metrics_management","application_management","external_links_management"]},{"identifier":"rob.fisher@hivehome.com","customer":"sysdef","lastSuccessfulLogin":1560162693875,"groups":["user_management","alerts_management"]},{"identifier":"rob@sysdef.xyz","customer":"sysdef","lastSuccessfulLogin":1567547135169,"groups":["agent_management","host_tag_management","events_management","alerts_management","dashboard_management","metrics_management","embedded_charts","ingestion","user_management","application_management","external_links_management"]},{"identifier":"sam@outsidethe.net","customer":"sysdef","lastSuccessfulLogin":1558370774253,"groups":[]},{"identifier":"services@id264.net","customer":"sysdef","groups":[]},{"identifier":"slackboy@gmail.com","customer":"sysdef","lastSuccessfulLogin":1535977667674,"groups":["host_tag_management","dashboard_management","embedded_charts","metrics_management","agent_management","events_management","external_links_management","alerts_management","ingestion","user_management","application_management"]},{"identifier":"test1@sysdef.xyz","customer":"sysdef","groups":[]},{"identifier":"test@sysdef.xyz","customer":"sysdef","groups":[]},{"identifier":"user1@merp.com","customer":"sysdef","groups":[]}]

data/spec/wavefront-sdk/savedsearch_spec.rb

@@ -1,54 +1,60 @@
 #!/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
+require_relative '../test_mixins/general'
 
 # 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')
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::List
+  include WavefrontTest::Update
+
+  def test_update
+    assert_puts("/api/v2/savedsearch/#{id}", payload) do
+      wf.update(id, payload)
+    end
+
+    assert_invalid_id { wf.update(invalid_id, payload) }
+    assert_raises(ArgumentError) { wf.update }
   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') }
+  def test_entity
+    %w[ALERT EVENT MAINTENANCE_WINDOW DASHBOARD SOURCE AGENT].each do |e|
+      assert_gets("/api/v2/savedsearch/type/#{e}?offset=0&limit=100") do
+        wf.entity(e)
+      end
+
+      assert_gets("/api/v2/savedsearch/type/#{e}?offset=20&limit=100") do
+        wf.entity(e, 20)
+      end
+
+      assert_gets("/api/v2/savedsearch/type/#{e}?offset=10&limit=50") do
+        wf.entity(e, 10, 50)
+      end
+    end
   end
 
-  def test_delete
-    should_work(:delete, SAVED_SEARCH, SAVED_SEARCH, :delete)
-    should_be_invalid(:delete)
+  private
+
+  def api_class
+    'savedsearch'
   end
 
-  def test_describe
-    should_work(:describe, SAVED_SEARCH, SAVED_SEARCH)
-    should_be_invalid(:describe)
+  def id
+    'e2hLH2FR'
   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 }
+  def invalid_id
+    'some bad id or other'
   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
+  def payload
+    { query: {
+      foo: '{"searchTerms":[{"type":"freetext","value":"foo"}]}'
+    },
+      entityType: 'DASHBOARD' }
   end
 end

data/spec/wavefront-sdk/search_spec.rb

@@ -2,44 +2,38 @@
 
 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(:raw_search, ['agent', SEARCH_BODY], 'agent', :post,
-                JSON_POST_HEADERS, SEARCH_BODY.to_json)
-    should_work(:raw_search, ['agent', SEARCH_BODY, true], 'agent/deleted',
-                :post, JSON_POST_HEADERS, SEARCH_BODY.to_json)
-    assert_raises(ArgumentError) { wf.raw_search }
+  def test_raw_search
+    assert_posts('/api/v2/search/agent', payload) do
+      wf.raw_search('agent', payload)
+    end
+
+    assert_posts('/api/v2/search/agent/deleted', payload) do
+      wf.raw_search('agent', payload, true)
+    end
+
     assert_raises(ArgumentError) { wf.raw_search('ALERT', 'junk') }
+    assert_raises(ArgumentError) { wf.raw_search }
   end
 
-  def test_facet_search
-    should_work(:raw_facet_search, ['agent', SEARCH_BODY],
-                'agent/facets', :post, JSON_POST_HEADERS,
-                SEARCH_BODY.to_json)
+  def test_raw_facet_search
+    assert_posts('/api/v2/search/agent/facets', payload) do
+      wf.raw_facet_search('agent', payload)
+    end
 
-    should_work(:raw_facet_search, ['agent', SEARCH_BODY, true],
-                'agent/deleted/facets', :post, JSON_POST_HEADERS,
-                SEARCH_BODY.to_json)
+    assert_posts('/api/v2/search/agent/deleted/facets', payload) do
+      wf.raw_facet_search('agent', payload, true)
+    end
 
-    should_work(:raw_facet_search, ['agent', SEARCH_BODY, false, 'Tags'],
-                'agent/Tags', :post, JSON_POST_HEADERS,
-                SEARCH_BODY.to_json)
+    assert_posts('/api/v2/search/agent/Tags', payload) do
+      wf.raw_facet_search('agent', payload, false, 'Tags')
+    end
 
-    should_work(:raw_facet_search, ['agent', SEARCH_BODY, true, 'Tags'],
-                'agent/deleted/Tags', :post, JSON_POST_HEADERS,
-                SEARCH_BODY.to_json)
+    assert_posts('/api/v2/search/agent/deleted/Tags', payload) do
+      wf.raw_facet_search('agent', payload, true, 'Tags')
+    end
 
     assert_raises(ArgumentError) { wf.raw_facet_search }
     assert_raises(ArgumentError) { wf.raw_facet_search('ALERT', 'junk') }
@@ -72,4 +66,16 @@ class WavefrontSearchTest < WavefrontTestBase
     r4 = wf.body(q, sort_field: :mykey)
     assert_equal({ field: :mykey, ascending: true }, r4[:sort])
   end
+
+  private
+
+  def payload
+    { limit: 10,
+      offset: 0,
+      query: [{ key:            'name',
+                value:          'Wavefront',
+                matchingMethod: 'CONTAINS' }],
+      sort: { field:     'string',
+              ascending: true } }
+  end
 end

data/spec/wavefront-sdk/settings_spec.rb

@@ -2,30 +2,36 @@
 
 require_relative '../spec_helper'
 
-SETTINGS_BODY = { showQuerybuilderByDefault: true,
-                  hideTSWhenQuerybuilderShown: true }.freeze
-
 # Unit tests for Settings class
 #
 class WavefrontSettingsTest < WavefrontTestBase
-  def api_base
-    'customer'
-  end
-
   def test_permissions
-    should_work(:permissions, nil, 'permissions')
+    assert_gets('/api/v2/customer/permissions') do
+      wf.permissions
+    end
   end
 
   def test_preferences
-    should_work(:preferences, nil, 'preferences')
+    assert_gets('/api/v2/customer/preferences') do
+      wf.preferences
+    end
   end
 
   def test_update_preferences
-    should_work(:update_preferences, SETTINGS_BODY, 'preferences',
-                :post, JSON_POST_HEADERS, SETTINGS_BODY.to_json)
+    assert_posts('/api/v2/customer/preferences', payload) do
+      wf.update_preferences(payload)
+    end
   end
 
   def test_default_user_groups
-    should_work(:default_user_groups, nil, 'preferences/defaultUserGroups')
+    assert_gets('/api/v2/customer/preferences/defaultUserGroups') do
+      wf.default_user_groups
+    end
+  end
+
+  private
+
+  def payload
+    { showQuerybuilderByDefault: true, hideTSWhenQuerybuilderShown: true }
   end
 end

data/spec/wavefront-sdk/source_spec.rb

@@ -1,51 +1,48 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-SOURCE = '74a247a9-f67c-43ad-911f-fabafa9dc2f3joyent'.freeze
-SOURCE_BODY = {
-  sourceName: 'source.name',
-  tags: {
-    sourceTag1: true
-  },
-  description: 'Source Description'
-}.freeze
+require_relative '../test_mixins/general'
+require_relative '../test_mixins/tag'
 
 # Unit tests for Source class
 #
 class WavefrontSourceTest < WavefrontTestBase
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::Tag
+  include WavefrontTest::Update
+
   def test_list
-    should_work(:list, [], '')
-    should_work(:list, 10, '?limit=10')
-    should_work(:list, [10, 'mysource'], '?limit=10&cursor=mysource')
-    should_work(:list, [nil, 'mysource'], '?cursor=mysource')
-  end
+    assert_gets('/api/v2/source') { wf.list }
+    assert_gets('/api/v2/source?limit=10') { wf.list(10) }
 
-  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') }
+    assert_gets('/api/v2/source?limit=10&cursor=mysource') do
+      wf.list(10, 'mysource')
+    end
+
+    assert_gets('/api/v2/source?cursor=mysource') do
+      wf.list(nil, 'mysource')
+    end
   end
 
-  def test_describe
-    should_work(:describe, SOURCE, SOURCE)
-    assert_raises(ArgumentError) { wf.describe }
+  private
+
+  def api_class
+    'source'
   end
 
-  def test_delete
-    should_work(:delete, SOURCE, SOURCE, :delete)
-    should_be_invalid(:delete)
+  def id
+    '74a247a9-f67c-43ad-911f-fabafa9dc2f3joyent'
   end
 
-  def test_update
-    should_work(:update, [SOURCE, SOURCE_BODY, false], SOURCE, :put,
-                JSON_POST_HEADERS, SOURCE_BODY.to_json)
-    should_be_invalid(:update, ['!invalid source!', SOURCE_BODY])
-    assert_raises(ArgumentError) { wf.update }
+  def invalid_id
+    '(>_<)'
   end
 
-  def test_tags
-    tag_tester(SOURCE)
+  def payload
+    { sourceName:  'source.name',
+      tags:        { sourceTag1: true },
+      description: 'Source Description' }
   end
 end