auth0 4.7.0 → 4.12.0

data/spec/lib/auth0/api/v2/jobs_spec.rb

@@ -13,14 +13,46 @@ describe Auth0::Api::V2::Jobs do
     end
     it { expect { @instance.get_job('') }.to raise_error('Must specify a job id') }
   end
+  context '.get_job_errors' do
+    it { expect(@instance).to respond_to(:get_job_errors) }
+    it 'expect client to send get to /api/v2/jobs/3/errors' do
+      expect(@instance).to receive(:get).with('/api/v2/jobs/3/errors')
+      expect { @instance.get_job_errors(3) }.not_to raise_error
+    end
+    it { expect { @instance.get_job_errors('') }.to raise_error('Must specify a job id') }
+  end
   context '.import_users' do
     it { expect(@instance).to respond_to(:import_users) }
     it 'expect client to send post to /api/v2/jobs/users-imports' do
       expect(@instance).to receive(:post_file).with(
-        '/api/v2/jobs/users-imports', users: 'file', connection_id: 'connnection_id'
+        '/api/v2/jobs/users-imports',
+        users: 'file',
+        connection_id: 'connnection_id',
+        upsert: false,
+        external_id: nil,
+        send_completion_email: true
       )
       expect { @instance.import_users('file', 'connnection_id') }.not_to raise_error
     end
+    it 'expect client to send post to /api/v2/jobs/users-imports with options' do
+      expect(@instance).to receive(:post_file).with(
+        '/api/v2/jobs/users-imports',
+        users: 'file',
+        connection_id: 'connnection_id',
+        upsert: true,
+        external_id: 'external_1',
+        send_completion_email: false
+      )
+      expect do
+        @instance.import_users(
+          'file',
+          'connnection_id',
+          upsert: true,
+          external_id: 'external_1',
+          send_completion_email: false
+        )
+      end.not_to raise_error
+    end
     it { expect { @instance.import_users('', 'connnection_id') }.to raise_error('Must specify a valid file') }
     it { expect { @instance.import_users('users', '') }.to raise_error('Must specify a connection_id') }
   end

data/spec/lib/auth0/api/v2/roles_spec.rb

@@ -0,0 +1,362 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Roles do
+  before :all do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Auth0::Api::V2::Roles)
+    @instance = dummy_instance
+  end
+
+  context '.get_roles' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:get_roles)
+    end
+
+    it 'is expected to have a roles alias' do
+      expect(@instance).to respond_to(:roles)
+    end
+
+    it 'is expected to get Roles with default parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/roles',
+        per_page: nil,
+        page: nil,
+        include_totals: nil,
+        name_filter: nil
+      )
+      expect { @instance.get_roles }.not_to raise_error
+    end
+
+    it 'is expected to get Roles with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/roles',
+        per_page: 10,
+        page: 3,
+        include_totals: true,
+        name_filter: 'test'
+      )
+      expect do
+        @instance.get_roles(per_page: 10, page: 3, include_totals: true, name_filter: 'test')
+      end.not_to raise_error
+    end
+  end
+
+  context '.get_role' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:get_role)
+    end
+
+    it 'is expected to have a role alias' do
+      expect(@instance).to respond_to(:role)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:get)
+      expect do
+        @instance.get_role('')
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to get a Role by ID' do
+      expect(@instance).to receive(:get).with('/api/v2/roles/ROLE_ID')
+      expect { @instance.get_role('ROLE_ID') }.not_to raise_error
+    end
+  end
+
+  context '.create_role' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:create_role)
+    end
+
+    it 'is expected to raise an exception if an empty Role name is passed' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.create_role('')
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to post a new Role' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/roles',
+        name: 'ROLE_NAME',
+        description: 'ROLE_DESCRIPTION'
+      )
+      expect do
+        @instance.create_role(
+          'ROLE_NAME',
+          description: 'ROLE_DESCRIPTION'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.update_role' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:update_role)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:patch)
+      expect do
+        @instance.update_role('')
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to post an updated Role' do
+      expect(@instance).to receive(:patch).with(
+        '/api/v2/roles/ROLE_ID',
+        name: 'ROLE_NAME',
+        description: 'ROLE_DESCRIPTION'
+      )
+      expect do
+        @instance.update_role(
+          'ROLE_ID',
+          name: 'ROLE_NAME',
+          description: 'ROLE_DESCRIPTION'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_role' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:delete_role)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:delete)
+      expect do
+        @instance.delete_role('')
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to delete a Role' do
+      expect(@instance).to receive(:delete).with('/api/v2/roles/ROLE_ID')
+      expect { @instance.delete_role('ROLE_ID') }.not_to raise_error
+    end
+  end
+
+  context '.get_users' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:get_role_users)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:get)
+      expect do
+        @instance.get_role_users('')
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to get Users for a Role with default parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/roles/ROLE_ID/users',
+        per_page: nil,
+        page: nil,
+        include_totals: nil
+      )
+      expect { @instance.get_role_users('ROLE_ID') }.not_to raise_error
+    end
+
+    it 'is expected to get Users for a Role with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/roles/ROLE_ID/users',
+        per_page: 30,
+        page: 4,
+        include_totals: true
+      )
+      expect do
+        @instance.get_role_users('ROLE_ID', per_page: 30, page: 4, include_totals: true)
+      end.not_to raise_error
+    end
+  end
+
+  context '.add_users' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:add_role_users)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_users('', [])
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to raise an exception if an array is not passed for Users' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_users('ROLE_ID', 'USERS')
+      end.to raise_exception Auth0::InvalidParameter
+    end
+
+    it 'is expected to raise an exception if no User IDs are passed' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_users('ROLE_ID', [])
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to add Users to a Role' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/roles/ROLE_ID/users',
+        users: %w[test|user-01 test|user-02]
+      )
+      expect do
+        @instance.add_role_users('ROLE_ID', %w[test|user-01 test|user-02])
+      end.not_to raise_error
+    end
+  end
+
+  context '.get_permissions' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:get_role_permissions)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:get)
+      expect do
+        @instance.get_role_permissions('')
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to get Roles with default parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/roles/ROLE_ID/permissions',
+        per_page: nil,
+        page: nil,
+        include_totals: nil
+      )
+      expect { @instance.get_role_permissions('ROLE_ID') }.not_to raise_error
+    end
+
+    it 'is expected to get Roles with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/roles/ROLE_ID/permissions',
+        per_page: 15,
+        page: 5,
+        include_totals: true
+      )
+      expect do
+        @instance.get_role_permissions('ROLE_ID', per_page: 15, page: 5, include_totals: true)
+      end.not_to raise_error
+    end
+  end
+
+  context '.add_permissions' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:add_role_permissions)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_permissions('', [])
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to raise an exception if an array is not passed for permissions' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_permissions('ROLE_ID', 'PERMISSIONS')
+      end.to raise_exception Auth0::InvalidParameter
+    end
+
+    it 'is expected to raise an exception if an empty permissions array is passed' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_permissions('ROLE_ID', [])
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to raise an exception if the permissions array does not contain Permission structs' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.add_role_permissions('ROLE_ID', [1, 2, 3])
+      end.to raise_exception Auth0::InvalidParameter
+    end
+
+    it 'is expected to add permissions to a Role' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/roles/ROLE_ID/permissions',
+        permissions: [
+          {
+            permission_name: 'permission-name-1',
+            resource_server_identifier: 'server-id-1'
+          },
+          {
+            permission_name: 'permission-name-2',
+            resource_server_identifier: 'server-id-2'
+          }
+        ]
+      )
+      expect do
+        @instance.add_role_permissions(
+          'ROLE_ID',
+          [
+            Permission.new('permission-name-1', 'server-id-1'),
+            Permission.new('permission-name-2', 'server-id-2')
+          ]
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.remove_permissions' do
+    it 'is expected to exist' do
+      expect(@instance).to respond_to(:remove_role_permissions)
+    end
+
+    it 'is expected to raise an exception if an empty Role ID is passed' do
+      expect(@instance).not_to receive(:delete_with_body)
+      expect do
+        @instance.remove_role_permissions('', [])
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to raise an exception if an array is not passed for permissions' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.remove_role_permissions('ROLE_ID', 'PERMISSIONS')
+      end.to raise_exception Auth0::InvalidParameter
+    end
+
+    it 'is expected to raise an exception if an empty permissions array is passed' do
+      expect(@instance).not_to receive(:delete_with_body)
+      expect do
+        @instance.remove_role_permissions('ROLE_ID', [])
+      end.to raise_exception Auth0::MissingParameter
+    end
+
+    it 'is expected to raise an exception if the permissions array does not contain Permission structs' do
+      expect(@instance).not_to receive(:post)
+      expect do
+        @instance.remove_role_permissions('ROLE_ID', [1, 2, 3])
+      end.to raise_exception Auth0::InvalidParameter
+    end
+
+    it 'is expected to remove permissions from a Role' do
+      expect(@instance).to receive(:delete_with_body).with(
+        '/api/v2/roles/ROLE_ID/permissions',
+        permissions: [
+          {
+            permission_name: 'permission-name-3',
+            resource_server_identifier: 'server-id-3'
+          },
+          {
+            permission_name: 'permission-name-4',
+            resource_server_identifier: 'server-id-4'
+          }
+        ]
+      )
+      expect do
+        @instance.remove_role_permissions(
+          'ROLE_ID',
+          [
+            Permission.new('permission-name-3', 'server-id-3'),
+            Permission.new('permission-name-4', 'server-id-4')
+          ]
+        )
+      end.not_to raise_error
+    end
+  end
+end

data/spec/lib/auth0/api/v2/users_spec.rb

@@ -7,10 +7,15 @@ describe Auth0::Api::V2::Users do
   end
 
   context '.users' do
-    it { expect(@instance).to respond_to(:users) }
-    it { expect(@instance).to respond_to(:get_users) }
+    it 'is expected to respond to a users method' do
+      expect(@instance).to respond_to(:users)
+    end
+
+    it 'is expected to respond to a get_users method' do
+      expect(@instance).to respond_to(:get_users)
+    end
 
-    it 'is expected to call /api/v2/users' do
+    it 'is expected to get /api/v2/users' do
       expect(@instance).to receive(:get).with(
         '/api/v2/users',
         per_page: nil,
@@ -26,35 +31,57 @@ describe Auth0::Api::V2::Users do
       expect { @instance.users }.not_to raise_error
     end
 
-    it 'is expected to call /api/v2/users with a search engine' do
+    it 'is expected to get /api/v2/users with custom parameters' do
       expect(@instance).to receive(:get).with(
         '/api/v2/users',
-        per_page: nil,
-        page: nil,
-        include_totals: nil,
+        per_page: 10,
+        page: 1,
+        include_totals: true,
         sort: nil,
-        connection: nil,
-        fields: nil,
+        connection: 'auth0',
+        fields: 'name,email',
         include_fields: nil,
         q: nil,
         search_engine: 'v3'
       )
-      expect { @instance.users(search_engine: 'v3') }.not_to raise_error
+      expect do
+        @instance.users(
+          search_engine: 'v3',
+          per_page: 10,
+          page: 1,
+          include_totals: true,
+          connection: 'auth0',
+          fields: 'name,email'
+        )
+      end.not_to raise_error
     end
   end
 
   context '.user' do
-    it { expect(@instance).to respond_to(:user) }
+    it 'is expected to respond to a user method' do
+      expect(@instance).to respond_to(:user)
+    end
+
     it 'is expected to call get request to /api/v2/users/USER_ID' do
-      expect(@instance).to receive(:get).with('/api/v2/users/USER_ID', fields: nil, include_fields: true)
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID',
+        fields: nil,
+        include_fields: true
+      )
       expect { @instance.user('USER_ID') }.not_to raise_error
     end
-    it { expect { @instance.user('') }.to raise_error 'Must supply a valid user_id' }
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.user(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
   end
 
   context '.create_user' do
-    it { expect(@instance).to respond_to(:create_user) }
-    it 'is expected to call post to /api/v2/users' do
+    it 'is expected to respond to a create_user method' do
+      expect(@instance).to respond_to(:create_user)
+    end
+
+    it 'is expected to post to /api/v2/users' do
       expect(@instance).to receive(:post).with(
         '/api/v2/users',
         email: 'test@test.com',
@@ -62,107 +89,163 @@ describe Auth0::Api::V2::Users do
         connection: 'conn',
         name: 'name'
       )
-      @instance.create_user(
-        'name',
-        email: 'test@test.com',
-        password: 'password',
-        connection: 'conn'
-      )
+      expect do
+        @instance.create_user(
+          'name',
+          email: 'test@test.com',
+          password: 'password',
+          connection: 'conn'
+        )
+      end.not_to raise_error
     end
   end
 
   context '.delete_users' do
-    it { expect(@instance).to respond_to :delete_users }
+    it 'is expected to respond to a delete_users method' do
+      expect(@instance).to respond_to :delete_users
+    end
+
     it 'is expected to call delete to /api/v2/users' do
       expect(@instance).to receive(:delete).with('/api/v2/users')
-      @instance.delete_users
+      expect { @instance.delete_users }.not_to raise_error
     end
   end
 
   context '.delete_user' do
-    it { expect(@instance).to respond_to(:delete_user) }
-    it 'is expected to call delete to /api/v2/users/userId' do
-      expect(@instance).to receive(:delete).with('/api/v2/users/userId')
-      @instance.delete_user('userId')
+    it 'is expected to respond to a delete_user method' do
+      expect(@instance).to respond_to(:delete_user)
     end
 
-    it 'is expected not to call delete to /api/v2/users if user_id is blank' do
+    it 'is expected to delete /api/v2/users/USER_ID' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/USER_ID')
+      @instance.delete_user('USER_ID')
+    end
+
+    it 'is expected not to delete /api/v2/users if user_id is blank' do
       expect(@instance).not_to receive(:delete)
-      expect { @instance.delete_user('') }.to raise_exception(
+      expect { @instance.delete_user(nil) }.to raise_exception(
         Auth0::MissingUserId
       )
     end
   end
 
   context '.delete_user_provider' do
-    it { expect(@instance).to respond_to(:delete_user_provider) }
-    it 'is expected to call delete to /api/v2/users/userId/multifactor/provider' do
-      expect(@instance).to receive(:delete).with('/api/v2/users/userId/multifactor/provider')
-      @instance.delete_user_provider('userId', 'provider')
+    it 'is expected to respond to a delete_user_provider method' do
+      expect(@instance).to respond_to(:delete_user_provider)
+    end
+
+    it 'is expected to delete /api/v2/users/userId/multifactor/provider' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/USER_ID/multifactor/PROVIDER_NAME')
+      @instance.delete_user_provider('USER_ID', 'PROVIDER_NAME')
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.delete_user_provider(nil, 'PROVIDER_NAME') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception when the provider name is empty' do
+      expect { @instance.delete_user_provider('USER_ID', nil) }.to raise_error 'Must supply a valid provider name'
     end
   end
 
   context '.patch_user' do
-    it { expect(@instance).to respond_to(:patch_user) }
-    it 'is expected to call patch to /api/v2/users/userID' do
+    it 'is expected to respond to a patch_user method' do
+      expect(@instance).to respond_to(:patch_user)
+    end
+
+    it 'is expected to respond to a update_user method' do
+      expect(@instance).to respond_to(:update_user)
+    end
+
+    it 'is expected to patch /api/v2/users/USER_ID' do
       expect(@instance).to receive(:patch).with(
-        '/api/v2/users/UserID',
+        '/api/v2/users/USER_ID',
         email: 'test@test.com',
         password: 'password',
         connection: 'conn',
         name: 'name'
       )
       @instance.patch_user(
-        'UserID',
+        'USER_ID',
         email: 'test@test.com',
         password: 'password',
         connection: 'conn',
         name: 'name'
       )
     end
-    it { expect { @instance.patch_user('', 'body') }.to raise_error 'Must supply a valid user_id' }
-    it { expect { @instance.patch_user('UserId', '') }.to raise_error 'Must supply a valid body' }
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.patch_user(nil, 'BODY') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an error when the body is empty' do
+      expect { @instance.patch_user('USER_ID', nil) }.to raise_error 'Must supply a valid body'
+    end
   end
 
   context '.link_user_account' do
-    it { expect(@instance).to respond_to(:link_user_account) }
-    it 'is expected to call post to /api/v2/users/UserId/identities' do
-      expect(@instance).to receive(:post).with('/api/v2/users/UserID/identities', body: 'json body')
-      @instance.link_user_account('UserID', body: 'json body')
+    it 'is expected to respond to a link_user_account method' do
+      expect(@instance).to respond_to(:link_user_account)
     end
-    it { expect { @instance.link_user_account('', 'body') }.to raise_error 'Must supply a valid user_id' }
-    it { expect { @instance.link_user_account('UserId', '') }.to raise_error 'Must supply a valid body' }
-  end
 
-  context '.unlink_users_account' do
-    it { expect(@instance).to respond_to(:unlink_users_account) }
-    it 'is expected to call delete to /api/v2/users/UserId/identities' do
-      expect(@instance).to receive(:delete).with('/api/v2/users/UserID/identities/provider_name/Secondary_User_ID')
-      @instance.unlink_users_account('UserID', 'provider_name', 'Secondary_User_ID')
+    it 'is expected to post to /api/v2/users/UserId/identities' do
+      expect(@instance).to receive(:post).with('/api/v2/users/USER_ID/identities', body: 'json body')
+      @instance.link_user_account('USER_ID', body: 'json body')
     end
-    it { expect { @instance.unlink_users_account('', 'pro', 'SUserID') }.to raise_error 'Must supply a valid user_id' }
-    it { expect { @instance.unlink_users_account('UID', nil, 'SUID') }.to raise_error 'Must supply a valid provider' }
-    it do
-      expect { @instance.unlink_users_account('UID', 'pro', nil) }.to raise_error 'Must supply a valid secondary user_id'
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.link_user_account(nil, 'BODY') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an error when the body is empty' do
+      expect { @instance.link_user_account('USER_ID', nil) }.to raise_error 'Must supply a valid body'
     end
   end
 
-  context '.delete_user_provider' do
-    it { expect(@instance).to respond_to(:delete_user_provider) }
-    it 'is expected to call delete to /api/v2/users/User_ID/multifactor/provider_name' do
-      expect(@instance).to receive(:delete).with('/api/v2/users/User_ID/multifactor/provider_name')
-      @instance.delete_user_provider('User_ID', 'provider_name')
+  context '.unlink_user_account' do
+    it 'is expected to respond to a unlink_user_account method' do
+      expect(@instance).to respond_to(:unlink_user_account)
+    end
+    it 'is expected to respond to a unlink_users_account alias' do
+      expect(@instance).to respond_to(:unlink_users_account)
+    end
+
+    it 'is expected to delete /api/v2/users/UserId/identities' do
+      expect(@instance).to receive(:delete).with('/api/v2/users/USER_ID_1/identities/PROVIDER_NAME/USER_ID_2')
+      @instance.unlink_users_account('USER_ID_1', 'PROVIDER_NAME', 'USER_ID_2')
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect do
+        @instance.unlink_users_account(nil, 'PROVIDER_NAME', 'USER_ID_2')
+      end.to raise_error 'Must supply a valid user_id'
+    end
+
+    it 'is expected to raise an exception when the provider is empty' do
+      expect do
+        @instance.unlink_users_account('USER_ID_1', nil, 'USER_ID_2')
+      end.to raise_error 'Must supply a valid provider'
+    end
+
+    it 'is expected to raise an exception when the secondary user ID is empty' do
+      expect do
+        @instance.unlink_users_account('USER_ID_1', 'PROVIDER_NAME', nil)
+      end.to raise_error 'Must supply a valid secondary user_id'
     end
-    it { expect { @instance.delete_user_provider(nil, 'test') }.to raise_error 'Must supply a valid user_id' }
   end
 
   context '.user_logs' do
-    it { expect(@instance).to respond_to(:user_logs) }
-    it { expect(@instance).to respond_to(:get_user_log_events) }
-    it 'is expected to call /api/v2/USER_ID/logs' do
+    it 'is expected to respond to a user_logs method' do
+      expect(@instance).to respond_to(:user_logs)
+    end
+
+    it 'is expected to respond to a get_user_log_events method' do
+      expect(@instance).to respond_to(:get_user_log_events)
+    end
+
+    it 'is expected to get /api/v2/USER_ID/logs' do
       expect(@instance).to receive(:get).with(
         '/api/v2/users/USER_ID/logs',
-        user_id: 'USER_ID',
         per_page: nil,
         page: nil,
         include_totals: nil,
@@ -170,16 +253,273 @@ describe Auth0::Api::V2::Users do
       )
       expect { @instance.user_logs('USER_ID') }.not_to raise_error
     end
-    it { expect { @instance.user_logs('') }.to raise_error 'Must supply a valid user_id' }
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.user_logs(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
     it 'is expected to raise an error when per_page is higher than 100' do
       expect { @instance.user_logs('USER_ID', per_page: rand(101..2000)) }.to raise_error(
         'The total amount of entries per page should be less than 100'
       )
     end
+
     it 'is expected to raise an error when sort does not match pattern' do
       expect { @instance.user_logs('USER_ID', sort: 'no match') }.to raise_error(
         'Sort does not match pattern ^(([a-zA-Z0-9_\\.]+))\\:(1|-1)$'
       )
     end
   end
+
+  context '.get_roles' do
+    it 'is expected to respond to a get_roles method' do
+      expect(@instance).to respond_to(:get_user_roles)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.get_user_roles(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to get roles with default parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID/roles',
+        per_page: nil,
+        page: nil,
+        include_totals: nil
+      )
+      expect { @instance.get_user_roles('USER_ID') }.not_to raise_error
+    end
+
+    it 'is expected to get roles with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/users/USER_ID/roles',
+        per_page: 20,
+        page: 2,
+        include_totals: true
+      )
+      expect do
+        @instance.get_user_roles('USER_ID', per_page: 20, page: 2, include_totals: true)
+      end.not_to raise_error
+    end
+  end
+
+  context '.remove_user_roles' do
+    it 'is expected to respond to a remove_user_roles method' do
+      expect(@instance).to respond_to(:remove_user_roles)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.remove_user_roles(nil, 'ROLES') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception when the roles are not an array' do
+      expect { @instance.remove_user_roles('USER_ID', 'ROLES') }.to raise_exception(Auth0::InvalidParameter)
+    end
+
+    it 'is expected to raise an exception when the roles are empty' do
+      expect { @instance.remove_user_roles('USER_ID', []) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to raise an exception when the roles are empty' do
+      expect { @instance.remove_user_roles('USER_ID', [1, 2]) }.to raise_exception(Auth0::InvalidParameter)
+    end
+
+    it 'is expected to remove roles' do
+      expect(@instance).to receive(:delete_with_body).with(
+        '/api/v2/users/USER_ID/roles',
+        roles: %w[test-role-01 test-role-02]
+      )
+      expect do
+        @instance.remove_user_roles('USER_ID', %w[test-role-01 test-role-02])
+      end.not_to raise_error
+    end
+  end
+
+  context '.add_roles' do
+    it 'is expected to respond to a add_roles method' do
+      expect(@instance).to respond_to(:add_user_roles)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.add_user_roles(nil, 'ROLES') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.add_user_roles('USER_ID', 'ROLES') }.to raise_exception(Auth0::InvalidParameter)
+    end
+
+    it 'is expected to raise an exception when the roles are empty' do
+      expect { @instance.add_user_roles('USER_ID', [3, 4]) }.to raise_exception(Auth0::InvalidParameter)
+    end
+
+    it 'is expected to add roles' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/users/USER_ID/roles',
+        roles: %w[test-role-03 test-role-04]
+      )
+      expect do
+        @instance.add_user_roles('USER_ID', %w[test-role-03 test-role-04])
+      end.not_to raise_error
+    end
+  end
+
+  context '.get_enrollments' do
+    it 'is expected to respond to a get_enrollments method' do
+      expect(@instance).to respond_to(:get_enrollments)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.get_enrollments(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to get enrollments' do
+      expect(@instance).to receive(:get).with('/api/v2/users/USER_ID/enrollments')
+      expect do
+        @instance.get_enrollments('USER_ID')
+      end.not_to raise_error
+    end
+  end
+
+  context '.get_permissions' do
+    it 'is expected to respond to a get_permissions method' do
+      expect(@instance).to respond_to(:get_user_permissions)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.get_user_permissions(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to get permissions' do
+      expect(@instance).to receive(:get).with('/api/v2/users/USER_ID/permissions')
+      expect do
+        @instance.get_user_permissions('USER_ID')
+      end.not_to raise_error
+    end
+  end
+
+  context '.remove_permissions' do
+    it 'is expected to respond to a remove_permissions method' do
+      expect(@instance).to respond_to(:remove_user_permissions)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.remove_user_permissions(nil, 'PERMISSIONS') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception when the permissions are empty' do
+      expect { @instance.remove_user_permissions('USER_ID', []) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to raise an exception when the array does not consist of Permissions' do
+      expect do
+        @instance.remove_user_permissions('USER_ID', %w[permission-01 permission02])
+      end.to raise_exception(Auth0::InvalidParameter)
+    end
+
+    it 'is expected to remove permissions' do
+      expect(@instance).to receive(:delete_with_body).with(
+        '/api/v2/users/USER_ID/permissions',
+        permissions: [
+          {
+            permission_name: 'permission-name-1',
+            resource_server_identifier: 'server-id-1'
+          },
+          {
+            permission_name: 'permission-name-2',
+            resource_server_identifier: 'server-id-2'
+          }
+        ]
+      )
+      expect do
+        @instance.remove_user_permissions(
+          'USER_ID',
+          [
+            Permission.new('permission-name-1', 'server-id-1'),
+            Permission.new('permission-name-2', 'server-id-2')
+          ]
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.add_permissions' do
+    it 'is expected to respond to a add_permissions method' do
+      expect(@instance).to respond_to(:add_user_permissions)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.add_user_permissions(nil, 'PERMISSIONS') }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to raise an exception when the permissions are empty' do
+      expect { @instance.add_user_permissions('USER_ID', []) }.to raise_exception(Auth0::MissingParameter)
+    end
+
+    it 'is expected to raise an exception when the permissions are not Permission structs' do
+      expect do
+        @instance.add_user_permissions('USER_ID', %w[permission-01 permission02])
+      end.to raise_exception(Auth0::InvalidParameter)
+    end
+
+    it 'is expected to add permissions' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/users/USER_ID/permissions',
+        permissions: [
+          {
+            permission_name: 'permission-name-1',
+            resource_server_identifier: 'server-id-1'
+          },
+          {
+            permission_name: 'permission-name-2',
+            resource_server_identifier: 'server-id-2'
+          }
+        ]
+      )
+      expect do
+        @instance.add_user_permissions(
+          'USER_ID',
+          [
+            Permission.new('permission-name-1', 'server-id-1'),
+            Permission.new('permission-name-2', 'server-id-2')
+          ]
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.generate_recovery_code' do
+    it 'is expected to respond to a generate_recovery_code method' do
+      expect(@instance).to respond_to(:generate_recovery_code)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.generate_recovery_code(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to get generate a recovery code' do
+      expect(@instance).to receive(:post).with('/api/v2/users/USER_ID/recovery-code-generation')
+      expect do
+        @instance.generate_recovery_code('USER_ID')
+      end.not_to raise_error
+    end
+  end
+
+  context '.invalidate_browsers' do
+    it 'is expected to respond to a invalidate_browsers method' do
+      expect(@instance).to respond_to(:invalidate_browsers)
+    end
+
+    it 'is expected to raise an exception when the user ID is empty' do
+      expect { @instance.invalidate_browsers(nil) }.to raise_exception(Auth0::MissingUserId)
+    end
+
+    it 'is expected to invalidate remembered browsers' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/users/USER_ID/multifactor/actions/invalidate-remember-browser'
+      )
+      expect do
+        @instance.invalidate_browsers('USER_ID')
+      end.not_to raise_error
+    end
+  end
 end