auth0 4.17.0 → 5.20.0

data/spec/integration/lib/auth0/api/v2/api_roles_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-describe Auth0::Api::V2::Roles do
-  attr_reader :client, :test_user, :test_role_name, :test_permission, :test_api, :test_role
-
-  before(:all) do
-    @client ||= Auth0::Client.new(v2_creds)
-
-    @test_user_name = "#{entity_suffix}-username-for-roles"
-    @test_user_email = "#{entity_suffix}-#{@test_user_name}@auth0.com"
-
-    @test_api_name = "#{entity_suffix}-test-api-for-roles"
-
-    @test_role_name = "#{entity_suffix}-test-role"
-
-    @test_permission_name = "#{entity_suffix}-test-permission"
-    @test_permission = Permission.new(@test_permission_name, @test_api_name)
-
-    VCR.use_cassette('Auth0_Api_V2_Roles/create_test_user') do
-      @test_user ||= client.create_user(
-        @test_user_name,
-        email: @test_user_email,
-        password: Faker::Internet.password,
-        connection: Auth0::Api::AuthenticationEndpoints::UP_AUTH
-      )
-    end
-
-    VCR.use_cassette('Auth0_Api_V2_Roles/create_test_api') do
-      @test_api ||= client.create_resource_server(
-        @test_api_name,
-        name: @test_api_name,
-        scopes: [{ value: @test_permission_name }]
-      )
-    end
-
-    VCR.use_cassette('Auth0_Api_V2_Roles/create_test_role') do
-      @test_role ||= client.create_role(
-        @test_role_name,
-        description: 'Test role description'
-      )
-    end
-  end
-
-  after(:all) do
-    VCR.use_cassette('Auth0_Api_V2_Roles/delete_test_user') do
-      client.delete_user test_user['user_id']
-    end
-
-    VCR.use_cassette('Auth0_Api_V2_Roles/delete_test_api') do
-      client.delete_resource_server test_api['id']
-    end
-  end
-
-  describe '.create_role' do
-    it 'should create the Role successfully' do
-      expect(test_role).to include('id', 'name', 'description')
-      expect(test_role).to include(
-        'name' => @test_role_name,
-        'description' => 'Test role description'
-      )
-    end
-  end
-
-  describe '.get_role', vcr: true do
-    let(:test_get_role) { client.get_role test_role['id'] }
-
-    it 'should get the Role successfully' do
-      expect(test_get_role).to include('id', 'name', 'description')
-      expect(test_get_role).to include(
-        'id' => test_role['id'],
-        'name' => @test_role_name,
-        'description' => 'Test role description'
-      )
-    end
-  end
-
-  describe '.get_roles', vcr: true do
-    it 'should get the Role successfully' do
-      expect(client.get_roles.count).to be >= 1
-    end
-  end
-
-  describe '.update_role', vcr: true do
-    it 'should update the Role successfully' do
-      expect(
-        client.update_role(
-          test_role['id'],
-          name: 'New name',
-          description: 'New description'
-        )
-      ).to include(
-        'name' => 'New name',
-        'description' => 'New description'
-      )
-    end
-  end
-
-  describe '.add_role_users', vcr: true do
-    it 'should add a User to the Role successfully' do
-      expect { client.add_role_users test_role['id'], [test_user['user_id']] }.to_not raise_error
-    end
-  end
-
-  describe '.get_role_users', vcr: true do
-    let(:test_get_role_users) { client.get_role_users test_role['id'] }
-
-    it 'should get exactly 1 User' do
-      expect(test_get_role_users.count).to equal 1
-    end
-
-    it 'should get the added User from the Role successfully' do
-      expect(test_get_role_users[0]['user_id']).to eq(test_user['user_id'])
-    end
-  end
-
-  describe '.add_role_permissions', vcr: true do
-    it 'should add a Permission to the Role successfully' do
-      expect { client.add_role_permissions test_role['id'], [test_permission] }.to_not raise_error
-    end
-  end
-
-  describe '.get_role_permissions', vcr: true do
-    let(:test_get_role_permissions) { client.get_role_permissions test_role['id'] }
-
-    it 'should get exactly 1 Permission' do
-      expect(test_get_role_permissions.count).to equal 1
-    end
-
-    it 'should get the added Permission from the Role successfully' do
-      expect(test_get_role_permissions[0]['permission_name']).to eq("#{entity_suffix}-test-permission")
-    end
-  end
-
-  describe '.remove_role_permissions', vcr: true do
-    it 'should remove a Permission from the Role successfully' do
-      expect { client.remove_role_permissions test_role['id'], [test_permission] }.to_not raise_error
-    end
-  end
-
-  describe '.delete_role', vcr: true do
-    it 'should delete the Role successfully' do
-      expect { client.delete_role test_role['id'] }.to_not raise_error
-    end
-  end
-end

data/spec/integration/lib/auth0/api/v2/api_rules_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::Rules do
-  attr_reader :client, :test_script, :enabled_rule, :disabled_rule
-
-  before(:all) do
-    @client = Auth0Client.new(v2_creds)
-    @test_script = 'function (user, context, cb) { cb(null, user, context);}'
-
-    VCR.use_cassette('Auth0_Api_V2_Rules/create_test_enabled_rule') do
-      @enabled_rule = client.create_rule(
-        "#{entity_suffix} - ENABLED",
-        test_script
-      )
-    end
-
-    VCR.use_cassette('Auth0_Api_V2_Rules/create_test_disabled_rule') do
-      @disabled_rule = client.create_rule(
-        "#{entity_suffix} - DISABLED",
-        test_script,
-        nil,
-        false
-      )
-    end
-  end
-
-  after(:all) do
-    VCR.use_cassette('Auth0_Api_V2_Logs/delete_test_enabled_rule') do
-      client.delete_rule(disabled_rule['id'])
-    end
-    VCR.use_cassette('Auth0_Api_V2_Logs/delete_test_disabled_rule') do
-      client.delete_rule(disabled_rule['id'])
-    end
-  end
-
-  describe '.create_rule', vcr: true do
-    it 'should create the test enabled rule with the correct attributes' do
-      expect(enabled_rule).to(
-        include(
-          'name' => "#{entity_suffix} - ENABLED",
-          'stage' => 'login_success',
-          'script' => test_script,
-          'enabled' => true
-        )
-      )
-    end
-
-    it 'should create the test disabled rule with the correct attributes' do
-      expect(disabled_rule).to(
-        include(
-          'name' => "#{entity_suffix} - DISABLED",
-          'stage' => 'login_success',
-          'script' => test_script,
-          'enabled' => false
-        )
-      )
-    end
-
-    it 'should raise an error if the name is empty' do
-      expect do
-        client.create_rule('', 'SCRIPT')
-      end.to raise_error(Auth0::InvalidParameter)
-    end
-
-    it 'should raise an error if the name is empty' do
-      expect do
-        client.create_rule('NAME', '')
-      end.to raise_error(Auth0::InvalidParameter)
-    end
-  end
-
-  describe '.rules', vcr: true do
-    let(:rules) do
-      client.rules
-    end
-
-    it 'should return at least 1 rule' do
-      expect(rules.size).to be > 0
-    end
-
-    context '#filters' do
-      it 'should return at least 1 enabled rule' do
-        expect(client.rules(enabled: true).size).to be >= 1
-      end
-
-      it 'should return at least 1 disabled rule' do
-        expect(client.rules(enabled: false).size).to be >= 1
-      end
-
-      it 'should include the specified fields' do
-        expect(
-          client.rules(
-            fields: [:script, :order].join(',')
-          ).first
-        ).to(include('script', 'order'))
-      end
-
-      it 'should exclude fields not specified' do
-        expect(
-          client.rules(
-            fields: [:script].join(',')
-          ).first
-        ).to_not(include('order', 'name'))
-      end
-
-      it 'should return paginated results' do
-        rule_1 = client.rules(fields: :name, page: 0, per_page: 2)
-        rule_2 = client.rules(fields: :name, page: 1, per_page: 1)
-        expect(rule_1.last).to eq(rule_2.first)
-      end
-    end
-  end
-
-  describe '.rule', vcr: true do
-    it 'should get a specific rule' do
-      expect(client.rule(enabled_rule['id'])).to(
-        include(
-          'name' => enabled_rule['name'],
-          'script' => enabled_rule['script']
-        )
-      )
-    end
-
-    context '#filters' do
-      let(:rule_include) do
-        client.rule(
-          enabled_rule['id'],
-          fields: [:stage, :order, :script].join(',')
-        )
-      end
-
-      let(:rule_not_include) do
-        client.rule(
-          enabled_rule['id'],
-          fields: :stage,
-          include_fields: false
-        )
-      end
-
-      it 'should include the specified fields' do
-        expect(rule_include).to(include('stage', 'order', 'script'))
-      end
-
-      it 'should exclude the specified fields' do
-        expect(rule_not_include).to(include('order', 'script'))
-      end
-
-      it 'should exclude the fields not specified' do
-        expect(rule_not_include).to_not(include('stage'))
-      end
-    end
-  end
-
-  describe '.update_rule', vcr: true do
-    it 'should update the disabled rule to be enabled' do
-      expect(
-        client.update_rule(
-          disabled_rule['id'],
-          enabled: true
-        )
-      ).to(include('enabled' => true))
-    end
-  end
-
-  describe '.delete_rule', vcr: true do
-    it 'should raise an error if the rule ID is not passed' do
-      expect { client.delete_rule '' }.to raise_error(Auth0::InvalidParameter)
-    end
-
-    it 'should delete the test enabled rule without an error' do
-      expect { client.delete_rule(enabled_rule['id']) }.to_not raise_error
-    end
-
-    it 'should delete the test disabled rule without an error' do
-      expect { client.delete_rule(disabled_rule['id']) }.to_not raise_error
-    end
-  end
-end

data/spec/integration/lib/auth0/api/v2/api_stats_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::Stats do
-  let(:client) { Auth0Client.new(v2_creds) }
-
-  describe '.active_users', vcr: true do
-    it 'should have at least one active user' do
-      expect(Integer(client.active_users)).to be >= 0
-    end
-  end
-
-  # rubocop:disable Date
-  describe '.daily_stats', vcr: true do
-    it 'should have at least one stats entry for the timeframe' do
-      expect(
-        client.daily_stats(
-          Date.new(2017, 1, 1).strftime('%Y%m%d'),
-          Date.new(2018, 1, 1).strftime('%Y%m%d')
-        ).size
-      ).to be > 0
-    end
-  end
-end

data/spec/integration/lib/auth0/api/v2/api_tenants_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::Tenants do
-  attr_reader :client
-
-  before(:all) do
-    @client = Auth0Client.new(v2_creds)
-  end
-
-  let(:default_tenant_name) { 'Auth0' }
-
-  describe '.get_tenant_settings', vcr: true do
-    it 'should get the tenant settings' do
-      expect(
-        client.get_tenant_settings
-      ).to include(
-        'friendly_name' => default_tenant_name,
-        'support_email' => 'support@auth0.org'
-      )
-    end
-  end
-
-  describe '.get_tenant_settings with specific fields', vcr: true do
-    let(:tenant_setting_fields) do
-      client.get_tenant_settings(fields: 'support_email')
-    end
-
-    it 'should include the field requested' do
-      expect(
-        tenant_setting_fields
-      ).to include('support_email')
-    end
-
-    it 'should exclude a field not requested' do
-      expect(
-        tenant_setting_fields
-      ).to_not include('friendly_name')
-    end
-  end
-
-  describe '.update_tenant_settings', vcr: true do
-    let(:changed_tenant_name) { "#{default_tenant_name}-CHANGED" }
-
-    it 'should update the tenant settings with a new tenant name' do
-      expect(
-        client.update_tenant_settings(
-          { friendly_name: changed_tenant_name }
-        )['friendly_name']
-      ).to include(changed_tenant_name)
-    end
-
-    it 'should revert the tenant name' do
-      expect(
-        client.update_tenant_settings(
-          { friendly_name: default_tenant_name }
-        )['friendly_name']
-      ).to include(default_tenant_name)
-    end
-  end
-end

data/spec/integration/lib/auth0/api/v2/api_tickets_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::Tickets do
-  attr_reader :client, :test_user
-
-  before(:all) do
-    @client = Auth0Client.new(v2_creds)
-    test_user_name = "#{entity_suffix}-username"
-
-    VCR.use_cassette('Auth0_Api_V2_Tickets/create_test_user') do
-      @test_user = client.create_user(
-        test_user_name,
-        'email' => "#{entity_suffix}-#{test_user_name}@auth0.com",
-        'password' => Faker::Internet.password,
-        'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH
-      )
-    end
-  end
-
-  after(:all) do
-    VCR.use_cassette('Auth0_Api_V2_Tickets/delete_test_user') do
-      client.delete_user(test_user['user_id'])
-    end
-  end
-
-  describe '.post_email_verification', vcr: true do
-    it 'should create an email verification ticket' do
-      expect(
-        client.post_email_verification(
-          test_user['user_id'],
-          result_url: 'https://auth0.com/callback'
-        )
-      ).to include('ticket')
-    end
-
-    it 'should raise an error if the user id is empty' do
-      expect do
-        client.post_email_verification( '' )
-      end.to raise_error Auth0::InvalidParameter, 'Must supply a valid user id to post an email verification'
-    end
-
-    it 'should raise an error if the identity supplied is not a Hash' do
-      expect do
-        client.post_email_verification( '', identity: 'not a hash')
-      end.to raise_error Auth0::InvalidParameter, 'Must supply a valid user id to post an email verification'
-    end
-  end
-
-  describe '.post_password_change', vcr: true do
-    it 'should create a password change ticket' do
-      expect(
-        client.post_password_change(
-          new_password: 'secret',
-          user_id: test_user['user_id'],
-          result_url: 'https://auth0.com/callback'
-        )
-      ).to include('ticket')
-    end
-  end
-end

data/spec/integration/lib/auth0/api/v2/api_user_blocks_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-describe Auth0::Api::V2::UserBlocks do
-  attr_reader :client, :user, :email
-
-  skip 'User blocks examples are skipped since is #logins exceeds free tenant limits' do
-    before(:all) do
-      @client = Auth0Client.new(v2_creds)
-      username = Faker::Internet.user_name
-      @email = "#{entity_suffix}#{Faker::Internet.safe_email(username)}"
-      password = Faker::Internet.password
-      @user = client.create_user(username,  'email' => email,
-                                            'password' => password,
-                                            'email_verified' => true,
-                                            'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                            'app_metadata' => {})
-    end
-
-    after(:all) do
-      client.delete_user(user['user_id'])
-    end
-
-    describe '.user_blocks' do
-      let(:user_blocks) do
-        block_user(email)
-        client.user_blocks(email)
-      end
-      it { expect(user_blocks['blocked_for'].size).to be > 0 }
-      it { expect(user_blocks['blocked_for'].first['identifier']).to eq email }
-    end
-
-    describe '.user_blocks_by_id' do
-      let(:user_blocks) do
-        block_user(email)
-        client.user_blocks_by_id(user['user_id'])
-      end
-      it { expect(user_blocks['blocked_for'].size).to be > 0 }
-      it { expect(user_blocks['blocked_for'].first['identifier']).to eq email }
-    end
-
-    describe '.delete_user_blocks' do
-      let(:user_blocks) do
-        block_user(email)
-        client.delete_user_blocks(email)
-        client.user_blocks(email)
-      end
-      it { expect(user_blocks['blocked_for']).to eq [] }
-    end
-
-    describe '.delete_user_blocks_by_id' do
-      let(:user_blocks) do
-        block_user(email)
-        client.delete_user_blocks_by_id(user['user_id'])
-        client.user_blocks(email)
-      end
-      it { expect(user_blocks['blocked_for']).to eq [] }
-    end
-  end
-
-  private
-
-  def block_user(email)
-    100.times do
-      begin
-        client.login(email, 'invalid password')
-      rescue Auth0::Unauthorized
-        next
-      rescue Auth0::Unsupported => e
-        puts e.message
-        break
-      end
-    end
-  end
-end