wavefront-sdk 3.3.2 → 3.3.3

data/spec/wavefront-sdk/user_spec.rb

@@ -1,123 +1,150 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-USER = 'user@example.com'.freeze
-BAD_USER = ('user' * 500).freeze
-PERMISSION = 'agent_management'.freeze
-
-USER_BODY = { emailAddress: USER, groups: %w[browse] }.freeze
-
-USERGROUP_LIST = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
-                    2659191e-aad4-4302-a94e-9667e1517127].freeze
-
-USER_LIST = %w[user@example.com other@elsewhere.com].freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for User class
 #
 class WavefrontUserTest < WavefrontTestBase
+  attr_reader :users, :groups, :permission
+
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::Update
+
   def test_list
-    should_work(:list, nil, '')
+    assert_gets('/api/v2/user') { wf.list }
   end
 
   def test_create
-    should_work(:create, [USER_BODY, true], '?sendEmail=true', :post,
-                JSON_POST_HEADERS, USER_BODY.to_json)
-    assert_raises(ArgumentError) { wf.create }
-    assert_raises(ArgumentError) { wf.create('test') }
-  end
-
-  def test_delete
-    should_work(:delete, USER, USER, :delete)
-    should_be_invalid(:delete, BAD_USER)
-    assert_raises(ArgumentError) { wf.delete }
-  end
+    assert_posts('/api/v2/user?sendEmail=true', payload) do
+      wf.create(payload, true)
+    end
 
-  def test_describe
-    should_work(:describe, USER, USER)
-    should_be_invalid(:describe, BAD_USER)
-    assert_raises(ArgumentError) { wf.describe }
-  end
+    assert_posts('/api/v2/user?sendEmail=false', payload) do
+      wf.create(payload)
+    end
 
-  def test_update
-    should_work(:update, [USER, USER_BODY, false], USER, :put,
-                JSON_POST_HEADERS, USER_BODY.to_json)
-    should_be_invalid(:update, [BAD_USER, USER_BODY])
-    assert_raises(ArgumentError) { wf.update }
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
   end
 
   def test_add_groups_to_user
-    should_work(:add_groups_to_user, [USER, USERGROUP_LIST],
-                [USER, :addUserGroups].uri_concat, :post,
-                JSON_POST_HEADERS, USERGROUP_LIST.to_json)
-
-    assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.add_groups_to_user(BAD_USER, USERGROUP_LIST)
+    assert_posts("/api/v2/user/#{id}/addUserGroups", groups.to_json) do
+      wf.add_groups_to_user(id, groups)
     end
+
+    assert_invalid_id { wf.add_groups_to_user(invalid_id, groups) }
   end
 
   def test_remove_groups_from_user
-    should_work(:remove_groups_from_user, [USER, USERGROUP_LIST],
-                [USER, :removeUserGroups].uri_concat, :post,
-                JSON_POST_HEADERS, USERGROUP_LIST.to_json)
-
-    assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.remove_groups_from_user(BAD_USER, USERGROUP_LIST)
+    assert_posts("/api/v2/user/#{id}/removeUserGroups", groups.to_json) do
+      wf.remove_groups_from_user(id, groups)
     end
+
+    assert_invalid_id { wf.remove_groups_from_user(invalid_id, groups) }
   end
 
   def test_grant
-    should_work(:grant, [USER, PERMISSION], 'user%40example.com/grant',
-                :post, JSON_POST_HEADERS.merge(
-                         'Content-Type': 'application/x-www-form-urlencoded'
-                ),
-                "group=#{PERMISSION}")
-    should_be_invalid(:grant, [BAD_USER, PERMISSION])
+    assert_posts("/api/v2/user/#{id}/grant", { group: permission },
+                 :form) do
+      wf.grant(id, permission)
+    end
+
+    assert_invalid_id { wf.grant(invalid_id, permission) }
     assert_raises(ArgumentError) { wf.grant }
   end
 
   def test_revoke
-    should_work(:revoke, [USER, PERMISSION], 'user%40example.com/revoke',
-                :post, JSON_POST_HEADERS.merge(
-                         'Content-Type': 'application/x-www-form-urlencoded'
-                ),
-                "group=#{PERMISSION}")
-    should_be_invalid(:revoke, [BAD_USER, PERMISSION])
+    assert_posts("/api/v2/user/#{id}/revoke", { group: permission },
+                 :form) do
+      wf.revoke(id, permission)
+    end
+
+    assert_invalid_id { wf.revoke(invalid_id, permission) }
     assert_raises(ArgumentError) { wf.revoke }
   end
 
   def test_delete_users
-    should_work(:delete_users, [[USER, 'other@example.com']],
-                'deleteUsers', :post, JSON_POST_HEADERS,
-                [USER, 'other@example.com'].to_json)
-
-    assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.delete_users([BAD_USER])
+    assert_posts('/api/v2/user/deleteUsers', users.to_json) do
+      wf.delete_users(users)
     end
 
-    assert_raises(ArgumentError) { wf.delete_users('a@b.com') }
+    assert_invalid_id { wf.delete_users([invalid_id]) }
+    assert_raises(ArgumentError) { wf.delete_users(id) }
   end
 
   def test_grant_permission
-    should_work(:grant_permission, [PERMISSION, USER_LIST],
-                [:grant, PERMISSION].uri_concat, :post,
-                JSON_POST_HEADERS, USER_LIST.to_json)
-    should_be_invalid(:grant, [BAD_USER, PERMISSION])
+    assert_posts("/api/v2/user/grant/#{permission}", users.to_json) do
+      wf.grant_permission(permission, users)
+    end
+
+    assert_invalid_id { wf.grant_permission(permission, [invalid_id]) }
     assert_raises(ArgumentError) { wf.grant }
   end
 
   def test_revoke_permission
-    should_work(:revoke_permission, [PERMISSION, USER_LIST],
-                [:revoke, PERMISSION].uri_concat, :post,
-                JSON_POST_HEADERS, USER_LIST.to_json)
-    should_be_invalid(:revoke, [BAD_USER, PERMISSION])
+    assert_posts("/api/v2/user/revoke/#{permission}", users.to_json) do
+      wf.revoke_permission(permission, users)
+    end
+
+    assert_invalid_id { wf.revoke_permission(permission, [invalid_id]) }
     assert_raises(ArgumentError) { wf.grant }
   end
 
   def test_invite
-    should_work(:invite, [[USER_BODY]], 'invite', :post,
-                JSON_POST_HEADERS, [USER_BODY].to_json)
+    assert_posts('/api/v2/user/invite', [payload].to_json) do
+      wf.invite([payload])
+    end
+
     assert_raises(ArgumentError) { wf.invite }
     assert_raises(ArgumentError) { wf.invite('test') }
   end
+
+  def test_response_shim
+    (RESOURCE_DIR + 'user_responses').each_child do |input|
+      # Ugly hack for the 202 in the 'create' file
+      status = input.basename.to_s == 'create.json' ? 202 : 200
+      shimmed = wf.response_shim(IO.read(input), status)
+      assert_instance_of(String, shimmed)
+
+      ret_obj = JSON.parse(shimmed, symbolize_names: true)
+      assert_instance_of(Hash, ret_obj)
+      assert_equal(%i[response status], ret_obj.keys.sort)
+
+      ret_status = ret_obj[:status]
+      assert_instance_of(Hash, ret_status)
+      assert_equal(%i[result message code], ret_status.keys)
+
+      ret_resp = ret_obj[:response]
+      assert_instance_of(Hash, ret_resp)
+      assert ret_resp.key?(:items)
+      assert_instance_of(Array, ret_resp[:items])
+    end
+  end
+
+  def setup_fixtures
+    @users = %w[user@example.com other@elsewhere.com]
+    @groups = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+                 2659191e-aad4-4302-a94e-9667e1517127]
+    @permission = 'agent_management'
+  end
+
+  private
+
+  def api_class
+    'user'
+  end
+
+  def id
+    'user@example.com'
+  end
+
+  def invalid_id
+    'user' * 500
+  end
+
+  def payload
+    { emailAddress: id, groups: %w[browse] }
+  end
 end

data/spec/wavefront-sdk/usergroup_spec.rb

@@ -1,98 +1,87 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-G_USERGROUP_ID = 'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672'.freeze
-G_BAD_USERGROUP_ID = 'some_rubbish'.freeze
-
-G_USERGROUP_BODY = { name:        'test group',
-                     permissions: %w[alerts_management
-                                     dashboard_management
-                                     events_management] }.freeze
-
-G_USER_LIST = %w[someone@somewhere.com other@elsewhere.net].freeze
-G_BAD_USER_LIST = ['bad' * 500, ''].freeze
-
-G_PERMISSION = 'alerts_management'.freeze
-
-G_GROUP_LIST = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
-                  2659191e-aad4-4302-a94e-9667e1517127].freeze
-
-G_BAD_GROUP_LIST = %w[some-nonsense more-nonsense].freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for WavefrontUserGroup
 #
 class WavefrontUserGroupTest < WavefrontTestBase
-  def test_list
-    should_work(:list, 10, '?offset=10&limit=100')
-  end
+  attr_reader :users, :groups, :permission, :invalid_groups, :invalid_users
 
-  def test_create
-    should_work(:create, G_USERGROUP_BODY, '', :post,
-                JSON_POST_HEADERS, G_USERGROUP_BODY.to_json)
-    assert_raises(ArgumentError) { wf.create }
-    assert_raises(ArgumentError) { wf.create('test') }
-  end
-
-  def test_delete
-    should_work(:delete, G_USERGROUP_ID, G_USERGROUP_ID, :delete)
-    should_be_invalid(:delete)
-  end
-
-  def test_describe
-    should_work(:describe, G_USERGROUP_ID, G_USERGROUP_ID)
-    assert_raises(ArgumentError) { wf.describe }
-  end
-
-  def test_update
-    should_work(:update, [G_USERGROUP_ID, G_USERGROUP_BODY, false],
-                G_USERGROUP_ID, :put, JSON_POST_HEADERS,
-                G_USERGROUP_BODY.to_json)
-    should_be_invalid(:update, ['!some rubbish!', G_USERGROUP_BODY])
-    assert_raises(ArgumentError) { wf.update }
-  end
+  include WavefrontTest::Create
+  include WavefrontTest::Delete
+  include WavefrontTest::Describe
+  include WavefrontTest::List
+  include WavefrontTest::Update
 
   def test_add_users_to_group
-    should_work(:add_users_to_group, [G_USERGROUP_ID, G_USER_LIST],
-                [G_USERGROUP_ID, :addUsers].uri_concat, :post)
+    assert_posts("/api/v2/usergroup/#{id}/addUsers", users.to_json) do
+      wf.add_users_to_group(id, users)
+    end
 
     assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.add_users_to_group(G_USERGROUP_ID, G_BAD_USER_LIST)
+      wf.add_users_to_group(id, invalid_users)
     end
 
-    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.add_users_to_group(G_BAD_USERGROUP_ID, G_USER_LIST)
-    end
+    assert_invalid_id { wf.add_users_to_group(invalid_id, users) }
   end
 
   def test_remove_users_from_group
-    should_work(:remove_users_from_group, [G_USERGROUP_ID, G_USER_LIST],
-                [G_USERGROUP_ID, :removeUsers].uri_concat, :post)
+    assert_posts("/api/v2/usergroup/#{id}/removeUsers", users.to_json) do
+      wf.remove_users_from_group(id, users)
+    end
 
     assert_raises(Wavefront::Exception::InvalidUserId) do
-      wf.remove_users_from_group(G_USERGROUP_ID, G_BAD_USER_LIST)
+      wf.remove_users_from_group(id, invalid_users)
     end
 
-    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.remove_users_from_group(G_BAD_USERGROUP_ID, G_USER_LIST)
-    end
+    assert_invalid_id { wf.remove_users_from_group(invalid_id, users) }
   end
 
   def test_grant
-    should_work(:grant, [G_PERMISSION, G_GROUP_LIST],
-                [:grant, G_PERMISSION].uri_concat, :post)
-
-    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.grant(G_PERMISSION, G_BAD_GROUP_LIST)
+    assert_posts("/api/v2/usergroup/grant/#{permission}",
+                 groups.to_json) do
+      wf.grant(permission, groups)
     end
+
+    assert_invalid_id { wf.grant(permission, invalid_groups) }
   end
 
   def test_revoke
-    should_work(:revoke, [G_PERMISSION, G_GROUP_LIST],
-                [:revoke, G_PERMISSION].uri_concat, :post)
-
-    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
-      wf.revoke(G_PERMISSION, G_BAD_GROUP_LIST)
+    assert_posts("/api/v2/usergroup/revoke/#{permission}",
+                 groups.to_json) do
+      wf.revoke(permission, groups)
     end
+
+    assert_invalid_id { wf.revoke(permission, invalid_groups) }
+  end
+
+  def setup_fixtures
+    @permission = 'alerts_management'
+    @invalid_groups = %w[some-nonsense more-nonsense]
+    @groups = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+                 2659191e-aad4-4302-a94e-9667e1517127]
+    @users = %w[someone@somewhere.com other@elsewhere.net]
+    @invalid_users = ['bad' * 500, '']
+  end
+
+  private
+
+  def api_class
+    'usergroup'
+  end
+
+  def id
+    'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672'
+  end
+
+  def invalid_id
+    'this is not what you call a group'
+  end
+
+  def payload
+    { name:        'test group',
+      permissions: %w[alerts_management dashboard_management
+                      events_management] }
   end
 end

data/spec/wavefront-sdk/webhook_spec.rb

@@ -1,50 +1,38 @@
 #!/usr/bin/env ruby
 
 require_relative '../spec_helper'
-
-WEBHOOK = '9095WaGklE8Gy3M1'.freeze
-
-WEBHOOK_BODY = {
-  description:       'WebHook Description',
-  template:          'POST Body -- Mustache syntax',
-  title:             'WebHook Title',
-  triggers:          %w[ALERT_OPENED],
-  recipient:         'http://example.com',
-  customHttpHeaders: {},
-  contentType:       'text/plain'
-}.freeze
+require_relative '../test_mixins/general'
 
 # Unit tests for Webhook class
 #
 class WavefrontWebhookTest < 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
+
+  private
 
-  def test_describe
-    should_work(:describe, WEBHOOK, WEBHOOK)
-    should_be_invalid(:describe, 'abcdefg')
-    assert_raises(ArgumentError) { wf.describe }
+  def api_class
+    'webhook'
   end
 
-  def test_create
-    should_work(:create, WEBHOOK_BODY, '', :post,
-                JSON_POST_HEADERS, WEBHOOK_BODY.to_json)
-    assert_raises(ArgumentError) { wf.create }
-    assert_raises(ArgumentError) { wf.create('test') }
+  def id
+    '9095WaGklE8Gy3M1'
   end
 
-  def test_delete
-    should_work(:delete, WEBHOOK, WEBHOOK, :delete)
-    should_be_invalid(:delete, 'abcdefg')
-    assert_raises(ArgumentError) { wf.delete }
+  def invalid_id
+    '+-+-+-+'
   end
 
-  def test_update
-    should_work(:update, [WEBHOOK, WEBHOOK_BODY, false], WEBHOOK, :put,
-                JSON_POST_HEADERS, WEBHOOK_BODY.to_json)
-    should_be_invalid(:update, ['abcde', WEBHOOK_BODY])
-    assert_raises(ArgumentError) { wf.update }
+  def payload
+    { description:       'WebHook Description',
+      template:          'POST Body -- Mustache syntax',
+      title:             'WebHook Title',
+      triggers:          %w[ALERT_OPENED],
+      recipient:         'http://example.com',
+      customHttpHeaders: {},
+      contentType:       'text/plain' }
   end
 end