wavefront-sdk 3.3.2 → 3.3.3

data/spec/support/mocket.rb

@@ -0,0 +1,19 @@
+# A mock socket
+#
+class Mocket
+  def puts(socket); end
+
+  def close; end
+
+  def ok?
+    true
+  end
+
+  def response
+    { sent: 1, rejected: 0, unsent: 0 }
+  end
+
+  def status
+    { result: 'OK', message: nil, code: nil }
+  end
+end

data/spec/test_mixins/acl.rb

@@ -0,0 +1,78 @@
+module WavefrontTest
+  #
+  # require and include this module to get ACL tests
+  #
+  module Acl
+    def test_acls
+      assert_gets("/api/v2/#{api_class}/acl?id=#{id}&id=#{id.reverse}") do
+        wf.acls([id, id.reverse])
+      end
+    end
+
+    def test_acl_add
+      assert_posts("/api/v2/#{api_class}/acl/add",
+                   acl_body(id, user_acls, group_acls)) do
+        wf.acl_add(id, user_acls, group_acls)
+      end
+
+      assert_posts("/api/v2/#{api_class}/acl/add",
+                   acl_body(id, user_acls)) do
+        wf.acl_add(id, user_acls)
+      end
+
+      assert_raises(ArgumentError) { wf.acl_add(id, user_acls.first) }
+      assert_raises(ArgumentError) do
+        wf.acl_add(id, user_acls, group_acls.first)
+      end
+    end
+
+    def test_acl_delete
+      assert_posts("/api/v2/#{api_class}/acl/remove",
+                   acl_body(id, user_acls, group_acls)) do
+        wf.acl_delete(id, user_acls, group_acls)
+      end
+
+      assert_posts("/api/v2/#{api_class}/acl/remove",
+                   acl_body(id, user_acls)) do
+        wf.acl_delete(id, user_acls)
+      end
+
+      assert_raises(ArgumentError) { wf.acl_delete(id, U_ACL_1) }
+    end
+
+    def test_acl_set
+      assert_puts("/api/v2/#{api_class}/acl/set",
+                  acl_body(id, user_acls, group_acls)) do
+        wf.acl_set(id, user_acls, group_acls)
+      end
+
+      assert_puts("/api/v2/#{api_class}/acl/set",
+                  acl_body(id, user_acls)) do
+        wf.acl_set(id, user_acls)
+      end
+
+      assert_raises(ArgumentError) { wf.acl_set(id, U_ACL_1) }
+    end
+
+    private
+
+    # @return [Array[String]] list of user IDs for ACL testing
+    #
+    def user_acls
+      %w[someone@example.com other@elsewhere.com]
+    end
+
+    # @return [Array[String]] list of group IDs for ACL testing
+    #
+    def group_acls
+      %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672]
+    end
+
+    # @return [String] JSON representation of an ACL request
+    #   payload
+    #
+    def acl_body(id, view = [], modify = [])
+      [{ entityId: id, viewAcl: view, modifyAcl: modify }].to_json
+    end
+  end
+end

data/spec/test_mixins/general.rb

@@ -0,0 +1,120 @@
+module WavefrontTest
+  module List
+    def test_list
+      assert_gets("/api/v2/#{api_class}?offset=0&limit=100") do
+        wf.list
+      end
+
+      assert_gets("/api/v2/#{api_class}?offset=10&limit=100") do
+        wf.list(10)
+      end
+    end
+
+    def test_list_all
+      assert_gets("/api/v2/#{api_class}?limit=999&offset=0") do
+        wf.list(0, :all)
+      end
+
+      assert_gets("/api/v2/#{api_class}?limit=20&offset=0") do
+        wf.list(20, :all)
+      end
+    end
+  end
+
+  module Create
+    def test_create
+      [payload].flatten.each do |p|
+        assert_posts("/api/v2/#{api_class}", p) { wf.create(p) }
+        assert_raises(ArgumentError) { wf.create }
+        assert_raises(ArgumentError) { wf.create('test') }
+      end
+    end
+  end
+
+  module Describe
+    def test_describe
+      assert_gets("/api/v2/#{api_class}/#{id}") { wf.describe(id) }
+      assert_invalid_id { wf.describe(invalid_id) }
+      assert_raises(ArgumentError) { wf.describe }
+    end
+  end
+
+  module Delete
+    def test_delete
+      assert_deletes("/api/v2/#{api_class}/#{id}") { wf.delete(id) }
+      assert_invalid_id { wf.delete(invalid_id) }
+      assert_raises(ArgumentError) { wf.delete }
+    end
+  end
+
+  module DeleteUndelete
+    include Delete
+
+    def test_undelete
+      assert_posts("/api/v2/#{api_class}/#{id}/undelete") do
+        wf.undelete(id)
+      end
+
+      assert_invalid_id { wf.undelete(invalid_id) }
+      assert_raises(ArgumentError) { wf.undelete }
+    end
+  end
+
+  module Update
+    def test_update
+      [payload].flatten.each do |p|
+        assert_puts("/api/v2/#{api_class}/#{id}", p) do
+          wf.update(id, p, false)
+        end
+
+        assert_invalid_id { wf.update(invalid_id, p) }
+        assert_raises(ArgumentError) { wf.update }
+      end
+    end
+  end
+
+  module Clone
+    def test_clone
+      assert_posts("/api/v2/#{api_class}/#{id}/clone",
+                   id: id, name: nil, v: nil) do
+        wf.clone(id)
+      end
+
+      assert_posts("/api/v2/#{api_class}/#{id}/clone",
+                   id: id, name: nil, v: 4) do
+        wf.clone(id, 4)
+      end
+
+      assert_raises(ArgumentError) { wf.clone }
+    end
+  end
+
+  module InstallUninstall
+    def test_install
+      assert_posts("/api/v2/#{api_class}/#{id}/install") { wf.install(id) }
+      assert_invalid_id { wf.install(invalid_id) }
+    end
+
+    def test_uninstall
+      assert_posts("/api/v2/#{api_class}/#{id}/uninstall") do
+        wf.uninstall(id)
+      end
+
+      assert_invalid_id { wf.uninstall(invalid_id) }
+    end
+  end
+
+  module History
+    def test_describe_v
+      assert_gets("/api/v2/#{api_class}/#{id}/history/4") do
+        wf.describe(id, 4)
+      end
+    end
+
+    def test_history
+      assert_gets("/api/v2/#{api_class}/#{id}/history") { wf.history(id) }
+      assert_invalid_id { wf.history(invalid_id) }
+      assert_raises(ArgumentError) { wf.history }
+    end
+  end
+end

data/spec/test_mixins/tag.rb

@@ -0,0 +1,55 @@
+module WavefrontTest
+  #
+  # require and include this module to get tag tests
+  #
+  module Tag
+    def test_tags
+      assert_gets("/api/v2/#{api_class}/#{id}/tag") { wf.tags(id) }
+      assert_invalid_id { wf.tags(invalid_id) }
+    end
+
+    def test_tag_set
+      assert_posts("/api/v2/#{api_class}/#{id}/tag", '["mytag"]') do
+        wf.tag_set(id, 'mytag')
+      end
+
+      assert_posts("/api/v2/#{api_class}/#{id}/tag", '["tag1","tag2"]') do
+        wf.tag_set(id, %w[tag1 tag2])
+      end
+
+      assert_invalid_id { wf.tag_set(invalid_id, 'valid_tag') }
+
+      assert_raises(Wavefront::Exception::InvalidString) do
+        wf.tag_set(id, '<!!!>')
+      end
+    end
+
+    def test_tag_add
+      #
+      # We have to use a literal 'null' to trick assert_puts into
+      # checking for the right content-type
+      #
+      assert_puts("/api/v2/#{api_class}/#{id}/tag/mytag", 'null') do
+        wf.tag_add(id, 'mytag')
+      end
+
+      assert_invalid_id { wf.tag_add(invalid_id, 'valid_tag') }
+
+      assert_raises(Wavefront::Exception::InvalidString) do
+        wf.tag_add(id, '<!!!>')
+      end
+    end
+
+    def test_tag_delete
+      assert_deletes("/api/v2/#{api_class}/#{id}/tag/mytag") do
+        wf.tag_delete(id, 'mytag')
+      end
+
+      assert_invalid_id { wf.tag_delete(invalid_id, 'valid_tag') }
+
+      assert_raises(Wavefront::Exception::InvalidString) do
+        wf.tag_delete(id, '<!!!>')
+      end
+    end
+  end
+end

data/spec/test_mixins/update_keys.rb

@@ -0,0 +1,11 @@
+module WavefrontTest
+  #
+  # include this into any class which has update keys
+  #
+  module UpdateKeys
+    def test_update_keys
+      assert_instance_of Array, wf.update_keys
+      assert(wf.update_keys.all? { |k| k.is_a?(Symbol) })
+    end
+  end
+end

data/spec/wavefront-sdk/alert_spec.rb

@@ -1,191 +1,143 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-require 'spy/integration'
-
-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
-
-def search_body(val)
-  { limit: 999,
-    offset: 0,
-    query: [
-      { key: 'status',
-        value: val,
-        matchingMethod: 'EXACT' }
-    ],
-    sort: { field: 'status', ascending: true } }
-end
+require_relative '../test_mixins/acl'
+require_relative '../test_mixins/tag'
+require_relative '../test_mixins/update_keys'
+require_relative '../test_mixins/general'
 
 # Unit tests for Alert class
 #
 class WavefrontAlertTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
-
-  def test_list_all
-    should_work(:list, [0, :all], '?limit=999&offset=0')
-    should_work(:list, [20, :all], '?limit=20&offset=0')
-  end
-
-  def test_update_keys
-    assert_instance_of(Array, wf.update_keys)
-    wf.update_keys.each { |k| assert_instance_of(Symbol, k) }
-  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_clone
-    should_work(:clone, [ALERT], [ALERT, :clone].uri_concat,
-                :post, JSON_POST_HEADERS,
-                { id: ALERT, name: nil, v: nil }.to_json)
-    should_work(:clone, [ALERT, 4], [ALERT, :clone].uri_concat,
-                :post, JSON_POST_HEADERS,
-                { id: ALERT, name: nil, v: 4 }.to_json)
-    assert_raises(ArgumentError) { wf.clone }
-  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_install
-    should_work(:install, ALERT, "#{ALERT}/install", :post)
-    should_be_invalid(:install)
-  end
+  include WavefrontTest::Acl
+  include WavefrontTest::Clone
+  include WavefrontTest::Create
+  include WavefrontTest::DeleteUndelete
+  include WavefrontTest::Describe
+  include WavefrontTest::History
+  include WavefrontTest::InstallUninstall
+  include WavefrontTest::List
+  include WavefrontTest::Tag
+  include WavefrontTest::Update
+  include WavefrontTest::UpdateKeys
 
   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
+    assert_posts("/api/v2/alert/#{id}/snooze") { wf.snooze(id) }
 
-  def test_update
-    should_work(:update, [ALERT, ALERT_BODY, false], ALERT, :put,
-                JSON_POST_HEADERS, ALERT_BODY)
-    should_be_invalid(:update, ['abcde', ALERT_BODY])
-    assert_raises(ArgumentError) { wf.update }
-  end
-
-  def test_tags
-    tag_tester(ALERT)
-  end
+    assert_posts("/api/v2/alert/#{id}/snooze?seconds=3600") do
+      wf.snooze(id, 3600)
+    end
 
-  def test_acls
-    acl_tester(ALERT)
-  end
-
-  def test_undelete
-    should_work(:undelete, ALERT, ["#{ALERT}/undelete", nil], :post,
-                POST_HEADERS)
-    should_be_invalid(:undelete)
-  end
-
-  def test_uninstall
-    should_work(:uninstall, ALERT, "#{ALERT}/uninstall", :post)
-    should_be_invalid(:uninstall)
+    assert_invalid_id { wf.snooze(invalid_id) }
   end
 
   def test_unsnooze
-    should_work(:unsnooze, ALERT, ["#{ALERT}/unsnooze", nil], :post,
-                POST_HEADERS)
-    should_be_invalid(:unsnooze)
+    assert_posts("/api/v2/alert/#{id}/unsnooze") { wf.unsnooze(id) }
+    assert_invalid_id { wf.unsnooze(invalid_id) }
   end
 
   def test_summary
-    should_work(:summary, nil, 'summary')
+    assert_gets('/api/v2/alert/summary') { wf.summary }
   end
 
   def test_alerts_in_state
-    should_work(:alerts_in_state, 'some_state', '/api/v2/search/alert',
-                :post, {}, search_body('some_state'))
+    assert_posts('/api/v2/search/alert', search_payload('state')) do
+      wf.alerts_in_state('state')
+    end
   end
 
   def test_firing
-    should_work(:firing, nil, '/api/v2/search/alert', :post, {},
-                search_body('firing'))
+    assert_posts('/api/v2/search/alert', search_payload('firing')) do
+      wf.firing
+    end
   end
 
   def test_active
-    should_work(:firing, nil, '/api/v2/search/alert', :post, {},
-                search_body('firing'))
+    assert_posts('/api/v2/search/alert', search_payload('firing')) do
+      wf.active
+    end
   end
 
   def test_affected_by_maintenance
-    should_work(:affected_by_maintenance, nil, '/api/v2/search/alert',
-                :post, {}, search_body('in_maintenance'))
+    assert_posts('/api/v2/search/alert',
+                 search_payload('in_maintenance')) do
+      wf.affected_by_maintenance
+    end
   end
 
   def test_invalid
-    should_work(:invalid, nil, '/api/v2/search/alert', :post, {},
-                search_body('invalid'))
-  end
-
-  def test_in_maintenance
-    should_work(:affected_by_maintenance, nil, '/api/v2/search/alert',
-                :post, {}, search_body('in_maintenance'))
+    assert_posts('/api/v2/search/alert', search_payload('invalid')) do
+      wf.invalid
+    end
   end
 
   def test_none
-    should_work(:none, nil, '/api/v2/search/alert', :post, {},
-                search_body('none'))
+    assert_posts('/api/v2/search/alert', search_payload('none')) do
+      wf.none
+    end
   end
 
   def test_checking
-    should_work(:checking, nil, '/api/v2/search/alert', :post, {},
-                search_body('checking'))
+    assert_posts('/api/v2/search/alert', search_payload('checking')) do
+      wf.checking
+    end
   end
 
   def test_trash
-    should_work(:trash, nil, '/api/v2/search/alert', :post, {},
-                search_body('trash'))
+    assert_posts('/api/v2/search/alert', search_payload('trash')) do
+      wf.trash
+    end
   end
 
   def test_no_data
-    should_work(:no_data, nil, '/api/v2/search/alert',
-                :post, {}, search_body('no_data'))
+    assert_posts('/api/v2/search/alert', search_payload('no_data')) do
+      wf.no_data
+    end
   end
 
   def test_snoozed
-    should_work(:snoozed, nil, '/api/v2/search/alert',
-                :post, {}, search_body('snoozed'))
+    assert_posts('/api/v2/search/alert', search_payload('snoozed')) do
+      wf.snoozed
+    end
   end
 
   # Not a full test, because it's a recursive API call. Just test
   # the first API call is made correctly.
   #
   def test_all
-    should_work(:all, nil, '?offset=0&limit=999')
+    assert_gets("/api/v2/#{api_class}?offset=0&limit=999") { wf.all }
+  end
+
+  private
+
+  # used by the things we #include
+  #
+  def api_class
+    'alert'
+  end
+
+  def id
+    '1481553823153'
+  end
+
+  def invalid_id
+    'invalid_alert'
+  end
+
+  def payload
+    { name:               'SDK test alert',
+      target:             'user@example.com',
+      condition:          'ts("app.errors") > 0',
+      displayExpression:  'ts("app.errors")',
+      minutes:             5,
+      resolveAfterMinutes: 5,
+      severity:            'INFO' }
+  end
+
+  def search_payload(value)
+    { limit:  999,
+      offset: 0,
+      query:  [{ key: 'status', value: value, matchingMethod: 'EXACT' }],
+      sort:   { field: 'status', ascending: true } }
   end
 end