auth0 5.18.1 → 5.19.0

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

@@ -1,88 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::Prompts do
-  before :all do
-    dummy_instance = DummyClass.new
-    dummy_instance.extend(Auth0::Api::V2::Prompts)
-    @instance = dummy_instance
-  end
-
-  context '.prompts' do
-    it 'is expected to respond to a prompts method' do
-      expect(@instance).to respond_to(:prompts)
-    end
-
-    it 'is expected to respond to a get_prompts method' do
-      expect(@instance).to respond_to(:get_prompts)
-    end
-
-    it 'is expected to get /api/v2/prompts' do
-      expect(@instance).to receive(:get).with('/api/v2/prompts')
-
-      expect { @instance.prompts }.not_to raise_error
-    end
-  end
-
-  context '.update_prompts' do
-    it 'is expected to respond to an update_prompts method' do
-      expect(@instance).to respond_to(:update_prompts)
-    end
-
-    it 'is expected to respond to a patch_prompts method' do
-      expect(@instance).to respond_to(:patch_prompts)
-    end
-
-    it 'is expected to call patch /api/v2/prompts' do
-      expect(@instance).to receive(:patch).with('/api/v2/prompts', { universal_login_experience: 'new' })
-
-      expect { @instance.update_prompts(universal_login_experience: 'new') }.not_to raise_error
-    end
-  end
-
-  context '.custom_text' do
-    it 'is expected to respond to a custom_text method' do
-      expect(@instance).to respond_to(:custom_text)
-    end
-
-    it 'is expected to respond to a get_custom_text method' do
-      expect(@instance).to respond_to(:get_custom_text)
-    end
-
-    it 'is expected to get /api/v2/prompts/PROMPT_NAME/language/LANGUAGE' do
-      expect(@instance).to receive(:get).with('/api/v2/prompts/PROMPT_NAME/custom-text/LANGUAGE')
-
-      expect { @instance.custom_text('PROMPT_NAME', 'LANGUAGE') }.not_to raise_error
-    end
-
-    it 'is expected to raise an exception when the prompt is empty' do
-      expect { @instance.custom_text(nil, 'language') }.to raise_exception(Auth0::InvalidParameter)
-    end
-
-    it 'is expected to raise an exception when the language is empty' do
-      expect { @instance.custom_text('prompt_name', nil) }.to raise_exception(Auth0::InvalidParameter)
-    end
-  end
-
-  context '.update_custom_text' do
-    it 'is expected to respond to an update_custom_text method' do
-      expect(@instance).to respond_to(:update_custom_text)
-    end
-
-    it 'is expected to respond to a put_custom_text method' do
-      expect(@instance).to respond_to(:put_custom_text)
-    end
-
-    it 'is expected to call put /api/v2/prompts/PROMPT_NAME/language/LANGUAGE' do
-      expect(@instance).to receive(:put).with('/api/v2/prompts/PROMPT_NAME/custom-text/LANGUAGE', 'BODY')
-
-      expect { @instance.update_custom_text('PROMPT_NAME', 'LANGUAGE', 'BODY') }.not_to raise_error
-    end
-
-    it 'is expected to raise an exception when the prompt is empty' do
-      expect { @instance.update_custom_text(nil,'language', 'BODY') }.to raise_exception(Auth0::InvalidParameter)
-    end
-
-    it 'is expected to raise an exception when the language is empty' do
-      expect { @instance.update_custom_text('prompt_name', nil, 'BODY') }.to raise_exception(Auth0::InvalidParameter)
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Auth0::Api::V2::RefreshTokens do
-  before :all do
-    dummy_instance = DummyClass.new
-    dummy_instance.extend(Auth0::Api::V2::RefreshTokens)
-    @instance = dummy_instance
-  end
-
-  describe '.refresh_token' do
-    it 'is expected to respond to a refresh_token method' do
-      expect(@instance).to respond_to(:refresh_token)
-    end
-
-    it 'is expected to GET a refresh_token' do
-      expect(@instance).to receive(:get).with(
-        '/api/v2/refresh-tokens/REFRESH_TOKEN_ID'
-      )
-
-      expect do
-        @instance.refresh_token('REFRESH_TOKEN_ID')
-      end.not_to raise_error
-    end
-
-    it 'is expected to raise an exception when the id is empty' do
-      expect { @instance.refresh_token(nil) }.to raise_error('Must supply a valid id')
-    end
-  end
-
-  describe '.delete_refresh_token' do
-    it 'is expected to respond to a delete_refresh_token method' do
-      expect(@instance).to respond_to(:delete_refresh_token)
-    end
-
-    it 'is expected to DELETE a refresh_token' do
-      expect(@instance).to receive(:delete).with(
-        '/api/v2/refresh-tokens/REFRESH_TOKEN_ID'
-      )
-
-      expect do
-        @instance.delete_refresh_token('REFRESH_TOKEN_ID')
-      end.not_to raise_error
-    end
-
-    it 'is expected to raise an exception when the id is empty' do
-      expect { @instance.delete_refresh_token(nil) }.to raise_error('Must supply a valid id')
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::ResourceServers do
-  before :all do
-    dummy_instance = DummyClass.new
-    dummy_instance.extend(Auth0::Api::V2::ResourceServers)
-    dummy_instance.extend(Auth0::Mixins::Initializer)
-    @instance = dummy_instance
-  end
-
-  context '.resource_servers' do
-    it { expect(@instance).to respond_to(:resource_servers) }
-    it { expect(@instance).to respond_to(:get_resource_servers) }
-    it 'is expected to call get /api/v2/resource-servers' do
-      expect(@instance).to receive(:get).with(
-        '/api/v2/resource-servers', {
-        page: nil,
-        per_page: nil,
-      })
-      expect { @instance.resource_servers }.not_to raise_error
-    end
-  end
-
-  context '.resource_server' do
-    it { expect(@instance).to respond_to(:resource_server) }
-    it 'is expected to call get /api/v2/resource-servers/test' do
-      expect(@instance).to receive(:get).with('/api/v2/resource-servers/test')
-      expect { @instance.resource_server('test') }.not_to raise_error
-    end
-    it 'expect to raise an error when calling with empty resource server id' do
-      expect { @instance.resource_server(nil) }.to raise_error 'Must supply a valid resource server id'
-    end
-  end
-
-  context '.create_resource_server' do
-    it { expect(@instance).to respond_to(:create_resource_server) }
-    it 'is expected to call post /api/v2/resource-servers' do
-      expect(@instance).to receive(:post).with(
-        '/api/v2/resource-servers', {
-        identifier: 'test',
-        name: 'name',
-        signing_alg: 'signing_alg',
-        signing_secret: 'signing_secret',
-        token_lifetime: 'token_lifetime',
-        scopes: 'scopes'
-      })
-
-      @instance.create_resource_server('test', name: 'name',
-                                               signing_alg: 'signing_alg',
-                                               signing_secret: 'signing_secret',
-                                               token_lifetime: 'token_lifetime',
-                                               scopes: 'scopes')
-    end
-    it 'expect to raise an error when calling with empty identifier' do
-      expect { @instance.create_resource_server(nil) }.to raise_error 'Must supply a valid resource server id'
-    end
-    it 'expect to raise an error when name contains < or > characters' do
-      expect { @instance.create_resource_server('test', name: '<') }.to raise_error(
-        'Name must contain at least one character. Does not allow "<" or ">"'
-      )
-      expect { @instance.create_resource_server('test', name: '>') }.to raise_error(
-        'Name must contain at least one character. Does not allow "<" or ">"'
-      )
-    end
-  end
-
-  context '.delete_resource_server' do
-    it { expect(@instance).to respond_to(:delete_resource_server) }
-    it 'is expected to call delete /api/v2/resource-server/test' do
-      expect(@instance).to receive(:delete).with('/api/v2/resource-servers/test')
-      expect { @instance.delete_resource_server('test') }.not_to raise_error
-    end
-    it 'expect to raise an error when calling with empty resource server identifier' do
-      expect { @instance.delete_resource_server(nil) }.to raise_error 'Must supply a valid resource server id'
-    end
-  end
-
-  context '.patch_resource_server' do
-    it { expect(@instance).to respond_to(:patch_resource_server) }
-    it 'is expected to send patch to /api/v2/resource_servers/1' do
-      expect(@instance).to receive(:patch).with('/api/v2/resource-servers/1', { fields: 'fields' })
-      expect { @instance.patch_resource_server('1', fields: 'fields') }.not_to raise_error
-    end
-    it { expect { @instance.patch_resource_server('', nil) }.to raise_error Auth0::InvalidParameter }
-    it { expect { @instance.patch_resource_server('some', nil) }.to raise_error Auth0::InvalidParameter }
-  end
-end

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

@@ -1,366 +0,0 @@
-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,
-        from: nil,
-        take: 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,
-        from: 'org_id',
-        take: 50,
-        include_totals: true
-      })
-      expect do
-        @instance.get_role_users('ROLE_ID', per_page: 30, page: 4, from: 'org_id', take: 50, 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',
-          [
-            Auth0::Permission.new('permission-name-1', 'server-id-1'),
-            Auth0::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',
-          [
-            Auth0::Permission.new('permission-name-3', 'server-id-3'),
-            Auth0::Permission.new('permission-name-4', 'server-id-4')
-          ]
-        )
-      end.not_to raise_error
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::Rules do
-  before :all do
-    dummy_instance = DummyClass.new
-    dummy_instance.extend(Auth0::Api::V2::Rules)
-    dummy_instance.extend(Auth0::Mixins::Initializer)
-    @instance = dummy_instance
-  end
-
-  context '.rules' do
-    it { expect(@instance).to respond_to(:rules) }
-
-    it 'is expected to call get /api/v2/rules' do
-      expect(@instance).to receive(:get).with(
-        '/api/v2/rules', {
-        enabled: nil,
-        fields: nil,
-        include_fields: nil,
-        stage: nil,
-        page: nil,
-        per_page: nil
-      })
-      expect { @instance.rules }.not_to raise_error
-    end
-
-    it 'is expected to call get /api/v2/rules with pagination' do
-      expect(@instance).to receive(:get).with(
-        '/api/v2/rules', {
-        enabled: nil,
-        fields: nil,
-        include_fields: nil,
-        stage: nil,
-        page: 1,
-        per_page: 2
-      })
-      expect {
-        @instance.rules(page: 1, per_page: 2)
-      }.not_to raise_error
-    end
-  end
-
-  context '.rule' do
-    it { expect(@instance).to respond_to(:rule) }
-    it 'is expected to call get /api/v2/rules/test' do
-      expect(@instance).to receive(:get).with(
-        '/api/v2/rules/test', { fields: nil, include_fields: nil }
-      )
-      expect { @instance.rule('test') }.not_to raise_error
-    end
-    it 'expect to raise an error when calling with empty rule id' do
-      expect { @instance.rule(nil) }.to raise_error 'Must supply a valid rule id'
-    end
-  end
-
-  context '.create_rule' do
-    it { expect(@instance).to respond_to(:create_rule) }
-    it 'is expected to call post /api/v2/rules' do
-      expect(@instance).to receive(:post).with(
-        '/api/v2/rules',
-        { name: 'test', script: 'script', order: 'order', enabled: false, stage: 'login_success' }
-      )
-      expect { @instance.create_rule('test', 'script', 'order', false) }.not_to raise_error
-    end
-    it 'expect to raise an error when calling with empty name' do
-      expect { @instance.create_rule(nil, 'script') }.to raise_error 'Must supply a valid name'
-    end
-    it 'expect to raise an error when calling with empty script' do
-      expect { @instance.create_rule('test', nil) }.to raise_error 'Must supply a valid script'
-    end
-  end
-  context '.update_rule' do
-    it { expect(@instance).to respond_to(:update_rule) }
-    it 'is expected to call put /api/v2/rules/test' do
-      expect(@instance).to receive(:patch).with(
-        '/api/v2/rules/test', { script: 'script', order: 'order', enabled: true, stage: 'some_stage' }
-      )
-      expect do
-        @instance.update_rule('test', script: 'script', order: 'order', enabled: true, stage: 'some_stage')
-      end.not_to raise_error
-    end
-    it 'expect to raise an error when calling with empty rule id' do
-      expect { @instance.update_rule(nil, 'test') }.to raise_error 'Must supply a valid rule id'
-    end
-  end
-  context '.delete_rule' do
-    it { expect(@instance).to respond_to(:delete_rule) }
-    it 'is expected to call delete /api/v2/rules/test' do
-      expect(@instance).to receive(:delete).with('/api/v2/rules/test')
-      expect { @instance.delete_rule('test') }.not_to raise_error
-    end
-    it 'expect to raise an error when calling with empty rule id' do
-      expect { @instance.delete_rule(nil) }.to raise_error 'Must supply a valid rule id'
-    end
-  end
-end