auth0 4.4.0 → 5.1.2

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

@@ -1,60 +1,130 @@
 require 'spec_helper'
 describe Auth0::Api::V2::ResourceServers do
-  attr_reader :client, :resource_server
+  attr_reader :client, :test_server
 
   before(:all) do
     @client = Auth0Client.new(v2_creds)
-    identifier = SecureRandom.uuid
-    sleep 1
-    @resource_server = client.create_resource_server(identifier)
+
+    VCR.use_cassette('Auth0_Api_V2_ResourceServers/create_test_server') do
+      @test_server = client.create_resource_server(
+        'https://localhost.test/api/v1/',
+        'name' => "TestServer-#{entity_suffix}",
+        'signing_alg' => 'RS256',
+        'signing_secret' => 'jPd1d0TWbg7pN9iPcXdtYtEIIGAk5zhmCi',
+        'token_lifetime' => 123456
+      )
+    end
   end
 
   after(:all) do
-    sleep 1
-    client.delete_resource_server(resource_server['id'])
+    VCR.use_cassette('Auth0_Api_V2_ResourceServers/delete_test_server') do
+      client.delete_resource_server(test_server['id'])
+    end
+  end
+
+  describe '.resource_servers', vcr: true do
+    let(:resource_servers) do
+      client.resource_servers
+    end
+
+    it 'should return at least 1 result' do
+      expect(resource_servers.size).to be > 0
+    end
+
+    it 'should get the test server' do
+      expect(resource_servers).to include(test_server)
+    end
+
+    it 'should return the first page of one result' do
+      results = client.resource_servers(
+        page: 0,
+        per_page: 1
+      )
+      expect(results.first).to equal(results.last)
+    end
+  end
+
+  describe '.create_resource_server', vcr: true do
+    it 'should raise an error if the identifier is empty' do
+      expect do
+        client.create_resource_server('')
+      end.to raise_error Auth0::InvalidParameter
+    end
+
+    it 'should raise an error if the name includes an invalid char' do
+      expect do
+        client.create_resource_server(
+          'https://localhost.test/api/v2/',
+          name: '<ServerName'
+        )
+      end.to raise_error Auth0::InvalidParameter
+    end
+
+    it 'should raise an error if the name includes an invalid char' do
+      expect do
+        client.create_resource_server(
+          'https://localhost.test/api/v2/',
+          name: 'ServerName>'
+        )
+      end.to raise_error Auth0::InvalidParameter
+    end
+
+    it 'should create the test server' do
+      expect(test_server).to(
+        include(
+          'name' => test_server['name'],
+          'identifier' => test_server['identifier'],
+          'signing_alg' => test_server['signing_alg'],
+          'signing_secret' => test_server['signing_secret'],
+          'token_lifetime' => test_server['token_lifetime']
+        )
+      )
+    end
   end
 
-  describe '.resource_server' do
-    it do
-      sleep 1
-      expect(client.resource_server(resource_server['id'])).to(
-        include('identifier' => resource_server['identifier'], 'id' => resource_server['id'],
-                'signing_alg' => resource_server['signing_alg'],
-                'token_lifetime' => resource_server['token_lifetime'])
+  describe '.resource_server', vcr: true do
+    it 'should raise an error if the id is empty' do
+      expect do
+        client.resource_server('')
+      end.to raise_error Auth0::InvalidParameter
+    end
+
+    it 'should get the test server' do
+      expect(
+        client.resource_server(test_server['id'])
+      ).to(
+        include('identifier' => test_server['identifier'])
       )
     end
   end
 
-  describe '.create_resource_server' do
-    let(:name) { Faker::Lorem.word }
-    let(:identifier) { SecureRandom.uuid }
-    let(:signing_alg) { 'HS256' }
-    let(:signing_secret) { Faker::Lorem.characters(16) }
-    let(:token_lifetime) { rand(1000..3000) }
-    let!(:resource_server) do
-      sleep 1
-      client.create_resource_server(identifier, 'name' => name, 'signing_alg' => signing_alg,
-                                                'signing_secret' => signing_secret,
-                                                'token_lifetime' => token_lifetime)
-    end
-    it do
-      sleep 1
-      expect(resource_server).to include('name' => name, 'identifier' => identifier, 'signing_alg' => signing_alg,
-                                         'signing_secret' => signing_secret,
-                                         'token_lifetime' => token_lifetime)
-      sleep 1
-      expect { client.delete_resource_server(resource_server['id']) }.to_not raise_error
-    end
-    it do
-      sleep 1
-      expect { client.delete_resource_server(resource_server['id']) }.to_not raise_error
+  describe '.patch_resource_server', vcr: true do
+    it 'should update the resource server with the correct attributes' do
+      expect(
+        client.patch_resource_server(
+          test_server['id'],
+          token_lifetime: 654321,
+        )
+      ).to(
+        include(
+          'token_lifetime' => 654321,
+        )
+      )
     end
   end
 
-  describe '.delete_resource_server' do
-    it do
-      sleep 1
-      expect { client.delete_resource_server(resource_server['id']) }.to_not raise_error
+  describe '.delete_resource_server', vcr: true do
+    it 'should raise an error if the id is empty' do
+      expect do
+        client.delete_resource_server('')
+      end.to raise_error Auth0::InvalidParameter
+    end
+
+    it 'should delete the test server without an error' do
+      expect do
+        client.delete_resource_server(test_server['id'])
+      end.to_not raise_error
     end
   end
+
 end

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

@@ -0,0 +1,145 @@
+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 = ::Auth0::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,120 +1,177 @@
 require 'spec_helper'
 describe Auth0::Api::V2::Rules do
-  attr_reader :client, :enabled_rule, :disabled_rule
+  attr_reader :client, :test_script, :enabled_rule, :disabled_rule
 
   before(:all) do
     @client = Auth0Client.new(v2_creds)
-    suffix = "#{entity_suffix}#{Faker::Lorem.word}"
-    script = 'function (user, context, callback) { callback(null, user, context);}'
-    stage = 'login_success'
-    sleep 1
-    @enabled_rule = client.create_rule("Enabled Rule #{suffix}", script, nil, true, stage)
-    sleep 1
-    @disabled_rule = client.create_rule("Disabled Rule #{suffix}", script, nil, false, stage)
+    @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
-    rules = client.rules
-    rules.each do |rule|
-      sleep 1
-      client.delete_rule(rule['id'])
+    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 '.rules' do
+  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
-      sleep 1
       client.rules
     end
 
-    it do
-      sleep 1
+    it 'should return at least 1 rule' do
       expect(rules.size).to be > 0
     end
 
     context '#filters' do
-      it do
-        sleep 1
+      it 'should return at least 1 enabled rule' do
         expect(client.rules(enabled: true).size).to be >= 1
       end
 
-      it do
-        sleep 1
+      it 'should return at least 1 disabled rule' do
         expect(client.rules(enabled: false).size).to be >= 1
       end
 
-      it do
-        sleep 1
-        expect(client.rules(enabled: true, fields: [:script, :order].join(',')).first).to(include('script', 'order'))
+      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 do
-        sleep 1
-        expect(client.rules(enabled: true, fields: [:script].join(',')).first).to_not(include('order', 'name'))
+
+      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' do
-    it do
-      sleep 1
+  describe '.rule', vcr: true do
+    it 'should get a specific rule' do
       expect(client.rule(enabled_rule['id'])).to(
-        include('stage' => enabled_rule['stage'], 'order' => enabled_rule['order'], 'script' => enabled_rule['script'])
+        include(
+          'name' => enabled_rule['name'],
+          'script' => enabled_rule['script']
+        )
       )
     end
 
     context '#filters' do
       let(:rule_include) do
-        sleep 1
-        client.rule(enabled_rule['id'], fields: [:stage, :order, :script].join(','))
+        client.rule(
+          enabled_rule['id'],
+          fields: [:stage, :order, :script].join(',')
+        )
       end
+
       let(:rule_not_include) do
-        sleep 1
-        client.rule(enabled_rule['id'], fields: :stage, include_fields: false)
+        client.rule(
+          enabled_rule['id'],
+          fields: :stage,
+          include_fields: false
+        )
       end
 
-      it do
-        sleep 1
+      it 'should include the specified fields' do
         expect(rule_include).to(include('stage', 'order', 'script'))
       end
 
-      it do
-        sleep 1
+      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 '.create_rule' do
-    let(:name) { "#{Faker::Lorem.word}#{entity_suffix}" }
-    let(:stage) { 'login_success' }
-    let(:script) { 'function(test)' }
-    let(:enabled) { false }
-    let!(:rule) do
-      sleep 1
-      client.create_rule(name, script, nil, enabled, stage)
-    end
-    it do
-      sleep 1
-      expect(rule).to include('name' => name, 'stage' => stage, 'script' => script)
+  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' do
-    it do
-      sleep 1
-      expect { client.delete_rule(enabled_rule['id']) }.to_not raise_error
-    end
-    it do
-      sleep 1
+  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
-  end
 
-  describe '.update_rule' do
-    it do
-      sleep 1
-      expect(client.update_rule(disabled_rule['id'], enabled: true)).to(include('enabled' => true))
+    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

@@ -2,24 +2,21 @@ require 'spec_helper'
 describe Auth0::Api::V2::Stats do
   let(:client) { Auth0Client.new(v2_creds) }
 
-  describe '.active_users' do
-    it do
-      sleep 1
+  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' do
-    let(:from) { Date.today.prev_day.strftime('%Y%m%d') }
-    let(:to) { Date.today.strftime('%Y%m%d') }
-    let(:daily_stats) do
-      sleep 1
-      client.daily_stats(from, to)
-    end
-    it do
-      sleep 1
-      expect(daily_stats.size).to be > 0
+  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
+end

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

@@ -1,53 +1,59 @@
 require 'spec_helper'
 describe Auth0::Api::V2::Tenants do
-  attr_reader :client, :body
+  attr_reader :client
 
   before(:all) do
     @client = Auth0Client.new(v2_creds)
-    @body = {
-      'error_page' => {
-        'html' => '',
-        'show_log_link' => false,
-        'url' => 'https://mycompany.org/error'
-      },
-      'friendly_name' => 'My Company',
-      'picture_url' => 'https://mycompany.org/logo.png',
-      'support_email' => 'support@mycompany.org',
-      'support_url' => 'https://mycompany.org/support'
-    }
-
-    sleep 1
-    client.update_tenant_settings(body)
   end
 
-  describe '.get_tenant_settings' do
-    it do
-      sleep 1
-      expect(client.get_tenant_settings).to include(body)
+  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
-      sleep 1
-      client.get_tenant_settings(fields: 'picture_url')
+      client.get_tenant_settings(fields: 'support_email')
     end
-    it do
-      sleep 1
-      expect(tenant_setting_fields).to_not include('friendly_name' => 'My Company')
+
+    it 'should include the field requested' do
+      expect(
+        tenant_setting_fields
+      ).to include('support_email')
     end
-    it do
-      sleep 1
-      expect(tenant_setting_fields).to include('picture_url' => 'https://mycompany.org/logo.png')
+
+    it 'should exclude a field not requested' do
+      expect(
+        tenant_setting_fields
+      ).to_not include('friendly_name')
     end
   end
 
-  describe '.update_tenant_settings' do
-    let(:tenant_name) { Faker::Company.name }
-    let(:body_tenant) do
-      { 'friendly_name' => tenant_name }
+  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 do
-      sleep 1
-      expect(client.update_tenant_settings(body_tenant)['friendly_name']).to include(tenant_name)
+
+    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