wavefront-sdk 2.4.0 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae4a49d72cb51beb4506cf0ea7049cc992e59d7699c37e7e59be1312c7b8d3b0
-  data.tar.gz: 8f0c3227f635bf86bdb1eca4e0091d9fb31abf0a99ada3cfcacd57e20a90655c
+  metadata.gz: b70702ec3f4199746297f9cae5d0f3d2c5158761d6cef25b662964731200c194
+  data.tar.gz: a4a43f7af561ee87f9e1479e98441d5db7a9a319ed5e26fcaf61bfb461c888e5
 SHA512:
-  metadata.gz: dd4638fdafec9d0bc5afc327451f81a5d1dd8ef36409f4249e868e948ceb836528bed3bfa369f568dc0b959817a44c83aa5340eee20145d4347ac0a61a1d7904
-  data.tar.gz: c1b87ee6385563a046e6d76c9e914ff5f4b635c4cdcf9179f84f44c1db6f87967028df4fdfb40ba25a0dca745f83a1bd43c229e91ae6893e170eba7c66b34dbc
+  metadata.gz: 202a64ad28993dbc87e1e5aa3533d2f28634febf7986ef4b0e46c884d9ccd662e31870a563d4950ef930d937ac25ca2611005ff5ff2e9c045b4c850ab519eb18
+  data.tar.gz: 4d5f91ce8d84fca57067278619723777f219ec2129b1c04e8d93bcf8db96d8175ecc386b7f078450c76fa701fbf069fdd2a7a95d313acb5e03b119cb4dfbae2e

data/HISTORY.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 2.5.0 (21/02/2019)
+* New `Wavefront::UserGroup` class, for new API `UserGroup` feature.
+* Extended `Wavefront::User` to cover new API methods.
+
 ## 2.4.0 (28/01/2019)
 * New `Wavefront::MetricHelper` class creates and in-memory buffer
   to which you can instantaneously add metrics, flushing it to

data/lib/wavefront-sdk/alert.rb

@@ -17,7 +17,7 @@ module Wavefront
     #
     # @param offset [Int] alert at which the list begins
     # @param limit [Int] the number of alerts to return
-    # @return [Hash]
+    # @return [Wavefront::Response]
     #
     def list(offset = 0, limit = 100)
       api.get('', offset: offset, limit: limit)

data/lib/wavefront-sdk/core/exception.rb

@@ -40,6 +40,7 @@ module Wavefront
     class InvalidTimeUnit < RuntimeError; end
     class InvalidTimestamp < RuntimeError; end
     class InvalidUserId < RuntimeError; end
+    class InvalidUserGroupId < RuntimeError; end
     class InvalidVersion < RuntimeError; end
     class InvalidWebhookId < RuntimeError; end
     class NotImplemented < RuntimeError; end

data/lib/wavefront-sdk/defs/version.rb

@@ -1 +1 @@
-WF_SDK_VERSION = '2.4.0'.freeze
+WF_SDK_VERSION = '2.5.0'.freeze

data/lib/wavefront-sdk/support/user_mixins.rb

@@ -0,0 +1,24 @@
+module Wavefront
+  #
+  # Things needed by User and UserGroup classes
+  #
+  module UserMixins
+    # Validate a list of users.
+    # @param list [Array[String]] list of user IDs
+    # @raise Wavefront::Exception::InvalidUser
+    #
+    def validate_user_list(list)
+      raise ArgumentError unless list.is_a?(Array)
+      list.each { |id| wf_user_id?(id) }
+    end
+
+    # Validate a list of user groups
+    # @param list [Array[String]] list of user group IDs
+    # @raise Wavefront::Exception::InvalidUserGroup
+    #
+    def validate_usergroup_list(list)
+      raise ArgumentError unless list.is_a?(Array)
+      list.each { |id| wf_usergroup_id?(id) }
+    end
+  end
+end

data/lib/wavefront-sdk/user.rb

@@ -1,10 +1,13 @@
 require_relative 'core/api'
+require_relative 'support/user_mixins'
 
 module Wavefront
   #
   # Manage and query Wavefront users
   #
   class User < CoreApi
+    include Wavefront::UserMixins
+
     # GET /api/v2/user
     # Get all users.
     #
@@ -26,7 +29,7 @@ module Wavefront
     end
 
     # DELETE /api/v2/user/id
-    # Delete a specific user.
+    # Delete a specific user. See also #delete_users.
     #
     # @param id [String] ID of the user
     # @return [Wavefront::Response]
@@ -47,23 +50,72 @@ module Wavefront
       api.get(id)
     end
 
+    # PUT /api/v2/user/id
+    # Update a specific user definition.
+    #
+    # @param id [String] a Wavefront user ID
+    # @param body [Hash] key-value hash of the parameters you wish
+    #   to change
+    # @param modify [true, false] if true, use {#describe()} to get
+    #   a hash describing the existing object, and modify that with
+    #   the new body. If false, pass the new body straight through.
+    # @return [Wavefront::Response]
+
+    def update(id, body, modify = true)
+      wf_user_id?(id)
+      raise ArgumentError unless body.is_a?(Hash)
+
+      return api.put(id, body, 'application/json') unless modify
+
+      api.put(id, hash_for_update(describe(id).response, body),
+              'application/json')
+    end
+
+    # POST /api/v2/user/{id}/addUserGroups
+    # Adds specific user groups to the user
+    #
+    # @param id [String] ID of the user
+    # @param group_list [Array[String]] list of groups to add
+    # @return [Wavefront::Response]
+    #
+    def add_groups_to_user(id, group_list = [])
+      wf_user_id?(id)
+      validate_usergroup_list(group_list)
+      api.post([id, 'addUserGroups'].uri_concat, group_list,
+               'application/json')
+    end
+
+    # POST /api/v2/user/{id}/removeUserGroups
+    # Removes specific user groups from the user
+    # @param id [String] ID of the user
+    # @param group_list [Array[String]] list of groups to remove
+    # @return [Wavefront::Response]
+    #
+    def remove_groups_from_user(id, group_list = [])
+      wf_user_id?(id)
+      validate_usergroup_list(group_list)
+      api.post([id, 'removeUserGroups'].uri_concat, group_list,
+               'application/json')
+    end
+
     # PUT /api/v2/user/id/grant
     # Grants a specific user permission.
     #
     # @param id [String] ID of the user
-    # @param group [String] group to add user to. We do not validate
-    #   this so that changes to the API do not mandate changes to
-    #   the SDK. At the time of writing, valid values are browse,
+    # @param pgroup [String] permission group to grant to user. We
+    #   do not validate this so that changes to the API do not mandate
+    #   changes to the SDK. At the time of writing, valid values are
+    #   browse,
     #   agent_management, alerts_management, dashboard_management,
     #   embedded_charts, events_management,
     #   external_links_management, host_tag_management,
     #   metrics_management, user_management,
     # @return [Wavefront::Response]
     #
-    def grant(id, group)
+    def grant(id, pgroup)
       wf_user_id?(id)
-      raise ArgumentError unless group.is_a?(String)
-      api.post([id, 'grant'].uri_concat, "group=#{group}",
+      raise ArgumentError unless pgroup.is_a?(String)
+      api.post([id, 'grant'].uri_concat, "group=#{pgroup}",
                'application/x-www-form-urlencoded')
     end
 
@@ -71,33 +123,91 @@ module Wavefront
     # Revokes a specific user permission.
     #
     # @param id [String] ID of the user
-    # @param group [String] group to add user to. We do not validate
-    #   this so that changes to the API do not mandate changes to
-    #   the SDK. See #update for valid values.
+    # @param pgroup [String] permission group to revoke from the
+    #   user. We do not validate this so that changes to the API do
+    #   not mandate changes to the SDK. See #update for valid values.
     # @return [Wavefront::Response]
     #
-    def revoke(id, group)
+    def revoke(id, pgroup)
       wf_user_id?(id)
-      raise ArgumentError unless group.is_a?(String)
-      api.post([id, 'revoke'].uri_concat, "group=#{group}",
+      raise ArgumentError unless pgroup.is_a?(String)
+      api.post([id, 'revoke'].uri_concat, "group=#{pgroup}",
                'application/x-www-form-urlencoded')
     end
 
+    # POST /api/v2/user/deleteUsers
+    # Deletes multiple users
+    #
+    # Yep, a POST that DELETEs. Not to be confused with DELETE. I
+    # don't make the API, I just cover it.
+    # @param user_list [Array[String]] list of user IDs
+    # @return [Wavefront::Response]
+    #
+    def delete_users(user_list)
+      raise ArgumentError unless user_list.is_a?(Array)
+      validate_user_list(user_list)
+      api.post('deleteUsers', user_list, 'application/json')
+    end
+
+    # POST /api/v2/user/grant/{permission}
+    # Grants a specific user permission to multiple users
+    # See #grant for possible permissions. This method operates on
+    # multiple users.
+    # @param permission [String] permission to grant
+    # @param user_list [Array[String]] users who should receive the
+    #   permission
+    # @return [Wavefront::Response]
+    #
+    def grant_permission(permission, user_list)
+      raise ArgumentError unless user_list.is_a?(Array)
+      validate_user_list(user_list)
+      api.post(['grant', permission].uri_concat, user_list,
+               'application/json')
+    end
+
+    # POST /api/v2/user/revoke/{permission}
+    # Revokes a specific user permission from multiple users
+    # See #grant for possible permissions. This method operates on
+    # multiple users.
+    # @param permission [String] permission to revoke
+    # @param user_list [Array[String]] users who should lose the
+    #   permission
+    # @return [Wavefront::Response]
+    #
+    def revoke_permission(permission, user_list)
+      raise ArgumentError unless user_list.is_a?(Array)
+      validate_user_list(user_list)
+      api.post(['revoke', permission].uri_concat, user_list,
+               'application/json')
+    end
+
+    # POST /api/v2/user/invite
+    # Invite users with given user groups and permissions.
+    # @param body [Array[Hash]] array of hashes describing a user.
+    #   See API docs for more details.
+    # @return [Wavefront::Response]
+    #
+    def invite(body)
+      raise ArgumentError unless body.is_a?(Array)
+      raise ArgumentError unless body.first.is_a?(Hash)
+      api.post('invite', body, 'application/json')
+    end
+
     # Fake a response which looks like we get from all the other
     # paths. I'm expecting the user response model to be made
     # consistent with others in the future.
     #
     def response_shim(body, status)
-      items = JSON.parse(body)
+      items = JSON.parse(body, symbolize_names: true)
 
       { response: { items:      items,
                     offset:     0,
                     limit:      items.size,
                     totalItems: items.size,
                     modeItems:  false },
-        status:   { result:  status == 200 ? 'OK' : 'ERROR',
-                    message: '',
-                    code:    status } }.to_json
+        status:   { result:     status == 200 ? 'OK' : 'ERROR',
+                    message:    extract_api_message(status, items),
+                    code:       status } }.to_json
     end
 
     # the user API class does not support pagination. Be up-front
@@ -106,5 +216,12 @@ module Wavefront
     def everything
       raise NoMethodError
     end
+
+    private
+
+    def extract_api_message(status, items)
+      return '' if status < 300
+      items.fetch(:message, 'no message from API')
+    end
   end
 end

data/lib/wavefront-sdk/usergroup.rb

@@ -0,0 +1,134 @@
+require_relative 'core/api'
+require_relative 'support/user_mixins'
+
+module Wavefront
+  #
+  # Manage and query Wavefront user groups
+  #
+  class UserGroup < CoreApi
+    include Wavefront::UserMixins
+
+    def update_keys
+      %i[id name]
+    end
+
+    # GET /api/v2/usergroup
+    # Get all user groups for a customer
+    # @param offset [Int] alert at which the list begins
+    # @param limit [Int] the number of alerts to return
+    # @return [Wavefront::Response]
+    #
+    def list(offset = 0, limit = 100)
+      api.get('', offset: offset, limit: limit)
+    end
+
+    # POST /api/v2/usergroup
+    # Create a specific user group
+    #
+    # @param body [Hash] a hash of parameters describing the group.
+    #   Please refer to the Wavefront Swagger docs for key:value
+    #   information
+    # @return [Wavefront::Response]
+    #
+    def create(body)
+      raise ArgumentError unless body.is_a?(Hash)
+      api.post('', body, 'application/json')
+    end
+
+    # DELETE /api/v2/usergroup/{id}
+    # Delete a specific user group
+    #
+    # @param id [String] ID of the user group
+    # @return [Wavefront::Response]
+    #
+    def delete(id)
+      wf_usergroup_id?(id)
+      api.delete(id)
+    end
+
+    # GET /api/v2/usergroup/{id}
+    # Get a specific user group
+    #
+    # @param id [String] ID of the user group
+    # @return [Wavefront::Response]
+    #
+    def describe(id)
+      wf_usergroup_id?(id)
+      api.get(id)
+    end
+
+    # PUT /api/v2/usergroup/{id}
+    # Update a specific user group
+    #
+    # @param id [String] a Wavefront usergroup ID
+    # @param body [Hash] key-value hash of the parameters you wish
+    #   to change
+    # @param modify [true, false] if true, use {#describe()} to get
+    #   a hash describing the existing object, and modify that with
+    #   the new body. If false, pass the new body straight through.
+    # @return [Wavefront::Response]
+
+    def update(id, body, modify = true)
+      wf_usergroup_id?(id)
+      raise ArgumentError unless body.is_a?(Hash)
+
+      return api.put(id, body, 'application/json') unless modify
+
+      api.put(id, hash_for_update(describe(id).response, body),
+              'application/json')
+    end
+
+    # POST /api/v2/usergroup/{id}/addUsers
+    # Add multiple users to a specific user group
+    #
+    # @param id [String] ID of the user group
+    # @param user_list [Array[String]] list of users to add
+    # @return [Wavefront::Response]
+    #
+    def add_users_to_group(id, user_list = [])
+      wf_usergroup_id?(id)
+      validate_user_list(user_list)
+      api.post([id, 'addUsers'].uri_concat, user_list, 'application/json')
+    end
+
+    # POST /api/v2/usergroup/{id}/removeUsers
+    # Remove multiple users from a specific user group
+    #
+    # @param id [String] ID of the user group
+    # @param user_list [Array[String]] list of users to remove
+    # @return [Wavefront::Response]
+    #
+    def remove_users_from_group(id, user_list = [])
+      wf_usergroup_id?(id)
+      validate_user_list(user_list)
+      api.post([id, 'removeUsers'].uri_concat, user_list,
+               'application/json')
+    end
+
+    # POST /api/v2/usergroup/grant/{permission}
+    # Grants a single permission to user group(s)
+    #
+    # @param perm [String] permission to grant
+    # @param group_list [Array[String]] list of groups who should
+    #   receive permission
+    # @return [Wavefront::Response]
+    #
+    def grant(perm, group_list = [])
+      validate_usergroup_list(group_list)
+      api.post(['grant', perm].uri_concat, group_list, 'application/json')
+    end
+
+    # POST /api/v2/usergroup/revoke/{permission}
+    # Revokes a single permission from user group(s)
+    #
+    # @param perm [String] permission to revoke
+    # @param group_list [Array[String]] list of groups who should
+    #   lose permission
+    # @return [Wavefront::Response]
+    #
+    def revoke(perm, group_list = [])
+      validate_usergroup_list(group_list)
+      api.post(['revoke', perm].uri_concat, group_list, 'application/json')
+    end
+  end
+end

data/lib/wavefront-sdk/validators.rb

@@ -12,6 +12,16 @@ module Wavefront
   #
   # rubocop:disable Metrics/ModuleLength
   module Validators
+    # Is the given string a UUID? These are used for various item
+    # IDs.
+    #
+    # @param id [String]
+    # @return [Bool]
+    #
+    def uuid?(str)
+      str.is_a?(String) && str =~ /([a-f\d]{8}(-[a-f\d]{4}){3}-[a-f\d]{12})/
+    end
+
     # Ensure the given argument is a valid external link template
     #
     # @return true if it is valid
@@ -192,12 +202,7 @@ module Wavefront
     #   is not valid
     #
     def wf_proxy_id?(id)
-      if id.is_a?(String) && id.match(
-        /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
-      )
-        return true
-      end
-
+      return true if uuid?(id)
       raise Wavefront::Exception::InvalidProxyId
     end
 
@@ -225,12 +230,7 @@ module Wavefront
     #   integration ID is not valid
     #
     def wf_cloudintegration_id?(id)
-      if id.is_a?(String) && id.match(
-        /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
-      )
-        return true
-      end
-
+      return true if uuid?(id)
       raise Wavefront::Exception::InvalidCloudIntegrationId
     end
 
@@ -394,6 +394,17 @@ module Wavefront
       raise Wavefront::Exception::InvalidUserId
     end
 
+    # Ensure the given argument is a valid user group.
+    #
+    # @param gid [String] user group identiier
+    # @return true if valid
+    # @raise Wavefront::Exceptions::InvalidUserGroupId if not valid
+    #
+    def wf_usergroup_id?(gid)
+      return true if uuid?(gid)
+      raise Wavefront::Exception::InvalidUserGroupId
+    end
+
     # Ensure the given argument is a valid webhook ID.
     #
     # @param id [String] webhook ID

data/spec/wavefront-sdk/derivedmetric_spec.rb

@@ -12,7 +12,7 @@ DERIVED_METRIC_BODY = {
   processRateMinutes: 1
 }.freeze
 
-# Unit tests for dashboard class
+# Unit tests for derived metric class
 #
 class WavefrontDerivedMetricTest < WavefrontTestBase
   def test_list

data/spec/wavefront-sdk/support/user_mixins_spec.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require_relative '../../spec_helper'
+require_relative '../../../lib/wavefront-sdk/support/user_mixins'
+require_relative '../../../lib/wavefront-sdk/validators'
+require_relative '../../../lib/wavefront-sdk/core/exception'
+
+# Test user mixins
+#
+class WavefrontUserMixinsTest < MiniTest::Test
+  include Wavefront::UserMixins
+  include Wavefront::Validators
+
+  def test_validate_user_list
+    assert validate_user_list(%w[u1@d1.net u2@d2.org u3@d3.com])
+
+    assert_raises(Wavefront::Exception::InvalidUserId) do
+      validate_user_list(%w[u1d1.net u2@d2.org u3@d3.com])
+    end
+
+    assert_raises(Wavefront::Exception::InvalidUserId) do
+      validate_user_list(%w[u1@d1.net org u3@d3.com])
+    end
+
+    assert_raises(ArgumentError) { validate_user_list('u1@d1.net') }
+  end
+
+  def validate_usergroup_list
+    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
+      validate_user_list(%w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+                            bad_id
+                            2659191e-aad4-4302-a94e-9667e1517127])
+    end
+
+    assert_raises(ArgumentError) do
+      validate_usergroup_list('f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672')
+    end
+  end
+end

data/spec/wavefront-sdk/user_spec.rb

@@ -3,12 +3,14 @@
 require_relative '../spec_helper'
 
 USER = 'user@example.com'.freeze
-GROUP = 'agent_management'.freeze
+PERMISSION = 'agent_management'.freeze
 
-USER_BODY = {
-  emailAddress: USER,
-  groups:       %w[browse]
-}.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
 
 # Unit tests for User class
 #
@@ -17,12 +19,6 @@ class WavefrontUserTest < WavefrontTestBase
     should_work(:list, nil, '')
   end
 
-  def test_describe
-    should_work(:describe, USER, USER)
-    should_be_invalid(:describe, 'abcdefg')
-    assert_raises(ArgumentError) { wf.describe }
-  end
-
   def test_create
     should_work(:create, [USER_BODY, true], '?sendEmail=true', :post,
                 JSON_POST_HEADERS, USER_BODY.to_json)
@@ -36,23 +32,91 @@ class WavefrontUserTest < WavefrontTestBase
     assert_raises(ArgumentError) { wf.delete }
   end
 
+  def test_describe
+    should_work(:describe, USER, USER)
+    should_be_invalid(:describe, 'abcdefg')
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_update
+    should_work(:update, [USER, USER_BODY, false], USER, :put,
+                JSON_POST_HEADERS, USER_BODY.to_json)
+    should_be_invalid(:update, ['!invalid uid!', USER_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  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('invalid address', USERGROUP_LIST)
+    end
+  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('invalid address', USERGROUP_LIST)
+    end
+  end
+
   def test_grant
-    should_work(:grant, [USER, GROUP], 'user%40example.com/grant',
+    should_work(:grant, [USER, PERMISSION], 'user%40example.com/grant',
                 :post, JSON_POST_HEADERS.merge(
                          'Content-Type': 'application/x-www-form-urlencoded'
                 ),
-                "group=#{GROUP}")
-    should_be_invalid(:grant, ['abcde', GROUP])
+                "group=#{PERMISSION}")
+    should_be_invalid(:grant, ['abcde', PERMISSION])
     assert_raises(ArgumentError) { wf.grant }
   end
 
   def test_revoke
-    should_work(:revoke, [USER, GROUP], 'user%40example.com/revoke',
+    should_work(:revoke, [USER, PERMISSION], 'user%40example.com/revoke',
                 :post, JSON_POST_HEADERS.merge(
                          'Content-Type': 'application/x-www-form-urlencoded'
                 ),
-                "group=#{GROUP}")
-    should_be_invalid(:revoke, ['abcde', GROUP])
+                "group=#{PERMISSION}")
+    should_be_invalid(:revoke, ['abcde', 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(['invalid address'])
+    end
+
+    assert_raises(ArgumentError) { wf.delete_users('a@b.com') }
+  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, ['abcde', PERMISSION])
+    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, ['abcde', PERMISSION])
+    assert_raises(ArgumentError) { wf.grant }
+  end
+
+  def test_invite
+    should_work(:invite, [[USER_BODY]], 'invite', :post,
+                JSON_POST_HEADERS, [USER_BODY].to_json)
+    assert_raises(ArgumentError) { wf.invite }
+    assert_raises(ArgumentError) { wf.invite('test') }
+  end
 end

data/spec/wavefront-sdk/usergroup_spec.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+require_relative '../spec_helper'
+
+USERGROUP_ID = 'f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672'.freeze
+BAD_USERGROUP_ID = 'some_rubbish'.freeze
+
+USERGROUP_BODY = { name:        'test group',
+                   permissions: %w[alerts_management
+                                   dashboard_management
+                                   events_management] }.freeze
+
+USER_LIST = %w[someone@somewhere.com other@elsewhere.net].freeze
+BAD_USER_LIST = %w[badusername very!bad!username].freeze
+
+PERMISSION = 'alerts_management'.freeze
+
+GROUP_LIST = %w[f8dc0c14-91a0-4ca9-8a2a-7d47f4db4672
+                2659191e-aad4-4302-a94e-9667e1517127].freeze
+
+BAD_GROUP_LIST = %w[some-nonsense more-nonsense].freeze
+
+# Unit tests for WavefrontUserGroup
+#
+class WavefrontUserGroupTest < WavefrontTestBase
+  def test_list
+    should_work(:list, 10, '?offset=10&limit=100')
+  end
+
+  def test_create
+    should_work(:create, USERGROUP_BODY, '', :post,
+                JSON_POST_HEADERS, USERGROUP_BODY.to_json)
+    assert_raises(ArgumentError) { wf.create }
+    assert_raises(ArgumentError) { wf.create('test') }
+  end
+
+  def test_delete
+    should_work(:delete, USERGROUP_ID, USERGROUP_ID, :delete)
+    should_be_invalid(:delete)
+  end
+
+  def test_describe
+    should_work(:describe, USERGROUP_ID, USERGROUP_ID)
+    assert_raises(ArgumentError) { wf.describe }
+  end
+
+  def test_update
+    should_work(:update, [USERGROUP_ID, USERGROUP_BODY, false],
+                USERGROUP_ID, :put, JSON_POST_HEADERS,
+                USERGROUP_BODY.to_json)
+    should_be_invalid(:update, ['!some rubbish!', USERGROUP_BODY])
+    assert_raises(ArgumentError) { wf.update }
+  end
+
+  def test_add_users_to_group
+    should_work(:add_users_to_group, [USERGROUP_ID, USER_LIST],
+                [USERGROUP_ID, :addUsers].uri_concat, :post)
+
+    assert_raises(Wavefront::Exception::InvalidUserId) do
+      wf.add_users_to_group(USERGROUP_ID, BAD_USER_LIST)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
+      wf.add_users_to_group(BAD_USERGROUP_ID, USER_LIST)
+    end
+  end
+
+  def test_remove_users_from_group
+    should_work(:remove_users_from_group, [USERGROUP_ID, USER_LIST],
+                [USERGROUP_ID, :removeUsers].uri_concat, :post)
+
+    assert_raises(Wavefront::Exception::InvalidUserId) do
+      wf.remove_users_from_group(USERGROUP_ID, BAD_USER_LIST)
+    end
+
+    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
+      wf.remove_users_from_group(BAD_USERGROUP_ID, USER_LIST)
+    end
+  end
+
+  def test_grant
+    should_work(:grant, [PERMISSION, GROUP_LIST],
+                [:grant, PERMISSION].uri_concat, :post)
+
+    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
+      wf.grant(PERMISSION, BAD_GROUP_LIST)
+    end
+  end
+
+  def test_revoke
+    should_work(:revoke, [PERMISSION, GROUP_LIST],
+                [:revoke, PERMISSION].uri_concat, :post)
+
+    assert_raises(Wavefront::Exception::InvalidUserGroupId) do
+      wf.revoke(PERMISSION, BAD_GROUP_LIST)
+    end
+  end
+end

data/spec/wavefront-sdk/validators_spec.rb

@@ -207,6 +207,14 @@ class WavefrontValidatorsTest < MiniTest::Test
     good_and_bad('wf_user_id?', 'InvalidUserId', good, bad)
   end
 
+  def test_wf_usergroup_id?
+    good = %w[2f17beb4-51b1-4362-b19f-098e3e4ab44d
+              42622766-52c2-4a8b-8070-b6f4623028c1]
+    bad = %w[word Name 42622766-52c2-4a8b-8070-b6f4623028c
+             z2622766-52c2-4a8b-8070-b6f4623028c1]
+    good_and_bad('wf_usergroup_id?', 'InvalidUserGroupId', good, bad)
+  end
+
   def test_wf_webhook_id?
     good = %w[4OfsEM8RcvkM7nwG]
     bad = %w[4OfsEM8RcvkM7n 4OfsEM8Rcvk-7nw]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wavefront-sdk
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.0
 platform: ruby
 authors:
 - Robert Fisher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-28 00:00:00.000000000 Z
+date: 2019-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -230,8 +230,10 @@ files:
 - lib/wavefront-sdk/stdlib/string.rb
 - lib/wavefront-sdk/support/mixins.rb
 - lib/wavefront-sdk/support/parse_time.rb
+- lib/wavefront-sdk/support/user_mixins.rb
 - lib/wavefront-sdk/types/status.rb
 - lib/wavefront-sdk/user.rb
+- lib/wavefront-sdk/usergroup.rb
 - lib/wavefront-sdk/validators.rb
 - lib/wavefront-sdk/webhook.rb
 - lib/wavefront-sdk/write.rb
@@ -278,7 +280,9 @@ files:
 - spec/wavefront-sdk/stdlib/string_spec.rb
 - spec/wavefront-sdk/support/mixins_spec.rb
 - spec/wavefront-sdk/support/parse_time_spec.rb
+- spec/wavefront-sdk/support/user_mixins_spec.rb
 - spec/wavefront-sdk/user_spec.rb
+- spec/wavefront-sdk/usergroup_spec.rb
 - spec/wavefront-sdk/validators_spec.rb
 - spec/wavefront-sdk/webhook_spec.rb
 - spec/wavefront-sdk/write_spec.rb
@@ -348,7 +352,9 @@ test_files:
 - spec/wavefront-sdk/stdlib/string_spec.rb
 - spec/wavefront-sdk/support/mixins_spec.rb
 - spec/wavefront-sdk/support/parse_time_spec.rb
+- spec/wavefront-sdk/support/user_mixins_spec.rb
 - spec/wavefront-sdk/user_spec.rb
+- spec/wavefront-sdk/usergroup_spec.rb
 - spec/wavefront-sdk/validators_spec.rb
 - spec/wavefront-sdk/webhook_spec.rb
 - spec/wavefront-sdk/write_spec.rb