auth0 3.6.1 → 4.0.0

data/spec/integration/lib/auth0/api/v1/api_users_spec.rb

@@ -1,59 +1,52 @@
-require "spec_helper"
+require 'spec_helper'
 describe Auth0::Api::V1::Users do
-
   let(:client) { Auth0Client.new(v1_creds) }
   let(:username) { Faker::Internet.user_name }
   let(:email) { "#{entity_suffix}#{Faker::Internet.safe_email(username)}" }
   let(:password) { Faker::Internet.password }
-  let(:connection) { "Username-Password-Authentication" }
-  let!(:user) { client.create_user(email, password, connection, {
-    "username" => username,
-    "email_verified" => false,
-  })}
-
-  describe '.users' do
+  let!(:user) do
+    client.create_user(email, password, Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+                       'username' => username, 'email_verified' => false)
+  end
 
-    let(:users) { client.users() }
+  skip 'Users examples are skipped' do
+    describe '.users' do
+      let(:users) { client.users }
 
-    it { expect(users.size).to be > 0 }
+      it { expect(users.size).to be > 0 }
 
-    context "#filters" do
-      it { expect(client.users("email: #{email}").size).to be 1 }
+      context '#filters' do
+        it { expect(client.users("email: #{email}").size).to be 1 }
+      end
     end
-
   end
 
   describe '.user' do
+    let(:subject) { client.user(user['user_id']) }
 
-    let(:subject) { client.user(user["user_id"]) }
-
-    it { should include("email" => email, "username" => username) }
-
+    it { should include('email' => email, 'username' => username) }
   end
 
   describe '.create_user' do
-
     let(:subject) { user }
 
-    it { should include("user_id", "identities") }
-    it { should include(      
-      "username" => username,
-      "email" => email,
-      "email_verified" => false,
-    )}
-
+    it { should include('user_id', 'identities') }
+    it do
+      should include(
+        'username' => username,
+        'email' => email,
+        'email_verified' => false
+      )
+    end
   end
 
   describe '.delete_user' do
+    it { expect { client.delete_user user['user_id'] }.to_not raise_error }
 
-    it { expect { client.delete_user user["user_id"] }.to_not raise_error }
-
-    it { expect { client.delete_user "" }.to raise_error(Auth0::MissingUserId) }
-
+    it { expect { client.delete_user '' }.to raise_error(Auth0::MissingUserId) }
   end
 
   describe '.patch_user_metadata' do
-    it { expect(client.patch_user_metadata(user["user_id"], {"custom_field" => "custom_value"})).to eq "OK" }
+    it { expect(client.patch_user_metadata(user['user_id'], 'custom_field' => 'custom_value')).to eq 'OK' }
   end
-
 end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Blacklists do
+  let(:client) { Auth0Client.new(v2_creds) }
+  let(:token) { 'faketoken' }
+
+  describe '.add_token_to_blacklist' do
+    it { expect(client.add_token_to_blacklist(token)).to be_nil }
+  end
+
+  describe '.blacklisted_tokens' do
+    let(:response) { { 'aud' => ENV['GLOBAL_CLIENT_ID'], 'jti' => token } }
+    it { expect(client.blacklisted_tokens).to include response }
+  end
+end

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

@@ -1,18 +1,73 @@
-require "spec_helper"
+require 'spec_helper'
 describe Auth0::Api::V2::Clients do
-
   let(:client) { Auth0Client.new(v2_creds) }
   let(:existing_client) { client.create_client("existing#{entity_suffix}") }
   let(:client_name) { "ClientV2#{entity_suffix}" }
 
   it { expect(client.clients).to_not be_empty }
 
-  it { expect(client.create_client(client_name, {custom_login_page_on: false})).to include("name" => client_name, "custom_login_page_on" => false) }
+  describe '.clients' do
+    let(:clients) { client.clients }
+
+    it { expect(clients.size).to be > 0 }
+
+    context '#filters' do
+      it do
+        expect(client.clients(fields: [:name, :callbacks].join(',')).first).to(include('name', 'callbacks'))
+      end
+      it do
+        expect(client.clients(fields: [:callbacks].join(',')).first).to_not(include('name'))
+      end
+      it do
+        expect(client.clients(fields: [:callbacks].join(','), include_fields: false).first).to_not(include('callbacks'))
+      end
+    end
+  end
+
+  describe '.client' do
+    it { expect(client.client(existing_client['client_id'])).to include('client_id' => existing_client['client_id']) }
+    it { expect { client.client '' }.to raise_error(Auth0::MissingClientId) }
+
+    context '#filters' do
+      let(:client_include) do
+        client.client(existing_client['client_id'], fields: [:name, :client_secret, :jwt_configuration].join(','))
+      end
+      let(:client_not_include) do
+        client.client(existing_client['client_id'], fields: :jwt_configuration, include_fields: false)
+      end
+
+      it do
+        expect(client_include).to(include('name', 'client_secret', 'jwt_configuration'))
+      end
 
-  it { expect(client.patch_client(existing_client["client_id"], {custom_login_page_on: false, sso: true})).to include("custom_login_page_on" => false, "sso" => true) }
+      it do
+        expect(client_not_include).to(include('name', 'client_secret'))
+        expect(client_not_include).to_not(include('jwt_configuration'))
+      end
+    end
+  end
 
-  it { expect { client.delete_client(existing_client["client_id"]) }.to_not raise_error }
+  describe '.create_client' do
+    it do
+      expect(client.create_client(client_name, custom_login_page_on: false)).to(
+        include('name' => client_name, 'custom_login_page_on' => false))
+    end
+    it { expect { client.create_client('', custom_login_page_on: false) }.to raise_error(Auth0::MissingParameter) }
+  end
 
-  it { expect(client.client(existing_client["client_id"])).to include("client_id" => existing_client["client_id"]) }
+  describe '.patch_client' do
+    it do
+      expect(
+        client.patch_client(
+          existing_client['client_id'],
+          custom_login_page_on: false,
+          sso: true)).to(include('custom_login_page_on' => false, 'sso' => true))
+    end
+    it { expect { client.patch_client('', custom_login_page_on: false) }.to raise_error(Auth0::MissingClientId) }
+  end
 
+  describe '.delete_rule' do
+    it { expect { client.delete_client(existing_client['client_id']) }.to_not raise_error }
+    it { expect { client.delete_client '' }.to raise_error(Auth0::MissingClientId) }
+  end
 end

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

@@ -1,71 +1,97 @@
-require "spec_helper"
+require 'spec_helper'
 describe Auth0::Api::V2::Connections do
-
-  let(:client) { Auth0Client.new(v2_creds) }
-
-  let(:name) { SecureRandom.uuid[0..25] }
-  let(:strategy) { 'google-oauth2' }
-  let(:options) { {} }
-  let(:enabled_clients) { [] }
-
-  let!(:connection) { client.create_connection({
-    name: name,
-    strategy: strategy,
-    options: options,
-    enabled_clients: enabled_clients,
-  })}
+  attr_reader :client, :connection, :strategy, :name, :enabled_clients, :options
+
+  before(:all) do
+    @client = Auth0Client.new(v2_creds)
+    @name = "#{SecureRandom.uuid[0..25]}#{entity_suffix}"
+    @strategy = 'google-oauth2'
+    @options = {}
+    @enabled_clients = []
+    @connection = client.create_connection(name: name,
+                                           strategy: strategy,
+                                           options: options,
+                                           enabled_clients: enabled_clients)
+  end
 
   describe '.connections' do
-
-    let(:connections) { client.connections() }
+    let(:connections) { client.connections }
 
     it { expect(connections.size).to be > 0 }
-    it { expect(connections.find {|con| con["name"] == name}).to_not be_nil }
+    it { expect(connections.find { |con| con['name'] == name }).to_not be_nil }
 
-    context "#filters" do
+    context '#filters' do
       it { expect(client.connections(strategy: strategy).size).to be > 0 }
-      it { expect(client.connections(strategy: strategy, fields: [:name].join(',')).first).to include("name") }
-      it { expect(client.connections(strategy: strategy, fields: [:name].join(','), include_fields: false).first).to_not include("name") }
+      it { expect(client.connections(strategy: strategy, fields: [:name].join(',')).first).to include('name') }
+      it do
+        expect(client.connections(strategy: strategy, fields: [:name].join(','), include_fields: false).first).to_not(
+          include('name'))
+      end
     end
-
   end
 
   describe '.connection' do
+    let(:subject) { client.connection(connection['id']) }
 
-    let(:subject) { client.connection(connection["id"]) }
+    it { should include('name' => connection['name']) }
 
-    it { should include("name" => connection['name']) }
-
-    context "#filters" do
-      it { expect(client.connection(connection["id"], fields: [:name, :id].join(','))).to include("id", "name") }
-      it { expect(client.connection(connection["id"], fields: [:name, :id].join(','), include_fields: false)).to_not include("id", "name") }
+    context '#filters' do
+      it { expect(client.connection(connection['id'], fields: [:name, :id].join(','))).to include('id', 'name') }
+      it do
+        expect(client.connection(connection['id'], fields: [:name, :id].join(','), include_fields: false)).to_not(
+          include('id', 'name'))
+      end
     end
-
   end
 
   describe '.create_connection' do
-
     let(:subject) { connection }
 
-    it { should include("id", "name") }
-    it { should include(
-      "name" => connection['name'],
-    )}
-
+    it { should include('id', 'name') }
+    it { should include('name' => connection['name']) }
   end
 
   describe '.delete_connection' do
-
-    it { expect { client.delete_connection connection["id"] }.to_not raise_error }
-
-    it { expect { client.delete_connection "" }.to raise_error(Auth0::MissingConnectionId) }
-
+    it { expect { client.delete_connection connection['id'] }.to_not raise_error }
   end
 
-
   describe '.update_connection' do
+    let!(:connection_to_update) do
+      client.create_connection(name: "#{SecureRandom.uuid[0..25]}#{entity_suffix}",
+                               strategy: strategy,
+                               options: options,
+                               enabled_clients: enabled_clients)
+    end
     new_name = SecureRandom.uuid[0..25]
-    it { expect(client.update_connection(connection["id"], {"name" => new_name})).to include("name" => new_name) }
+    let(:options) { { username: new_name } }
+    it do
+      expect(client.update_connection(connection_to_update['id'], 'options' => options)['options']).to include(
+        'username' => new_name)
+    end
   end
 
+  describe '.delete_connection_user' do
+    let(:username) { Faker::Internet.user_name }
+    let(:email) { "#{entity_suffix}#{Faker::Internet.safe_email(username)}" }
+    let(:password) { Faker::Internet.password }
+    let!(:user_to_delete) do
+      client.create_user(username,  email: email,
+                                    password: password,
+                                    email_verified: false,
+                                    connection: Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+                                    app_metadata: {})
+    end
+    let(:connection) do
+      client.connections.find { |connection| connection['name'] == Auth0::Api::AuthenticationEndpoints::UP_AUTH }
+    end
+
+    it { expect(client.delete_connection_user(connection['id'], email)).to be_nil }
+  end
+
+  after(:all) do
+    client
+      .connections
+      .select { |connection| connection['name'].include?(entity_suffix) }
+      .each { |connection| client.delete_connection(connection['id']) }
+  end
 end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Emails do
+  before(:all) do
+    client = Auth0Client.new(v2_creds)
+    begin
+      client.delete_provider
+    rescue
+      puts 'no email provider to delete'
+    end
+  end
+
+  let(:client) { Auth0Client.new(v2_creds) }
+  let(:name) { 'mandrill' }
+  let(:enabled) { true }
+  let(:credentials) { { 'api_key' => 'api_key' } }
+  let(:settings) { { 'first_setting' =>  'first_setting_set', 'second_setting' => 'second_setting_set' } }
+  let(:body) do
+    { 'name' => name,
+      'enabled' => enabled,
+      'credentials' => credentials,
+      'settings' => settings }
+  end
+
+  describe '.configure_provider' do
+    let!(:email_provider) { client.configure_provider(body) }
+    it do
+      expect(email_provider).to include(
+        'name' => name, 'enabled' => enabled, 'credentials' => credentials, 'settings' => settings)
+    end
+  end
+
+  describe '.get_provider' do
+    let(:provider) { client.get_provider }
+
+    it { expect(provider.size).to be > 0 }
+
+    context '#filters' do
+      it do
+        expect(
+          client.get_provider(fields: [:name, :enabled, :credentials].join(','), include_fields: true)).to(
+            include('name', 'enabled', 'credentials'))
+      end
+      it do
+        expect(
+          client.get_provider(fields: [:enabled].join(','), include_fields: false).first).to_not(include('enabled'))
+      end
+    end
+  end
+
+  describe '.update_provider' do
+    let(:update_name) { 'sendgrid' }
+    let(:update_settings) do
+      { 'first_up_setting' => 'first_up_setting_set', 'second_up_setting' => 'second_up_setting_set' }
+    end
+    let(:update_body) do
+      { 'name' => update_name,
+        'settings' => update_settings }
+    end
+    it do
+      expect(
+        client.update_provider(update_body)).to(
+          include(
+            'name' => update_name, 'enabled' => enabled, 'credentials' => credentials, 'settings' => update_settings))
+    end
+  end
+
+  describe '.delete_provider' do
+    it { expect { client.delete_provider }.to_not raise_error }
+    it { expect { client.get_provider }.to raise_error(Auth0::NotFound) }
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Jobs do
+  skip "Jobs examples are skipped to avoid Job's creation" do
+    let(:client) { Auth0Client.new(v2_creds) }
+    let(:username) { Faker::Internet.user_name }
+    let(:email) { "#{entity_suffix}#{Faker::Internet.safe_email(username)}" }
+
+    describe '.import_users and .get_job' do
+      let(:file_content) do
+        [{
+          'email' => email,
+          'email_verified' => false,
+          'app_metadata' => {
+            'roles' => ['admin'],
+            'plan' => 'premium'
+          },
+          'user_metadata' => {
+            'theme' => 'light'
+          }
+        }
+        ]
+      end
+      let(:users_file) do
+        File.new('temp.json', 'w+') { |f| f.write(file_content) }
+      end
+      let(:connection_id) do
+        client.connections
+          .find do |connection|
+            connection['name'].include?(Auth0::Api::AuthenticationEndpoints::UP_AUTH)
+          end['id']
+      end
+      let(:imported_users) { client.import_users(users_file, connection_id) }
+      it do
+        expect(imported_users).to include(
+          'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+          'status' => 'pending',
+          'type' => 'users_import')
+      end
+      let(:import_job_id) { imported_users['id'] }
+      it do
+        expect(client.get_job(import_job_id)).to include(
+          'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH, 'type' => 'users_import', 'id' => import_job_id)
+      end
+    end
+
+    describe '.send_verification_email and .get_job' do
+      let(:user) do
+        client.create_user(username,  'email' => email,
+                                      'password' => Faker::Internet.password,
+                                      'email_verified' => false,
+                                      'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+                                      'app_metadata' => {})
+      end
+      let(:email_verification_job) { client.send_verification_email(user_id: user['user_id']) }
+      it { expect(email_verification_job).to include('status' => 'pending', 'type' => 'verification_email') }
+      let(:email_job_id) { email_verification_job['id'] }
+      it do
+        expect(client.get_job(email_job_id)).to include(
+          'status' => 'completed', 'type' => 'verification_email', 'id' => email_job_id)
+      end
+    end
+
+    after(:all) do
+      new_client = Auth0Client.new(v2_creds)
+      delete_user_id = new_client.get_users(q: 'email:@example.com').first['user_id']
+      new_client.delete_user(delete_user_id)
+    end
+  end
+end