auth0 4.4.0 → 5.1.2

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

@@ -1,112 +1,166 @@
 require 'spec_helper'
+
 describe Auth0::Api::V2::Clients do
-  let(:client) { Auth0Client.new(v2_creds) }
-  let(:existing_client) do
-    sleep 1
-    client.create_client("existing#{entity_suffix}")
-  end
-  let(:client_name) { "ClientV2#{entity_suffix}" }
+  attr_reader :client, :test_client_name, :test_client
 
-  it do
-    sleep 1
-    expect(client.clients).to_not be_empty
+  before(:all) do
+    @client ||= Auth0Client.new(v2_creds)
+    @test_client_name = "TestClient-#{entity_suffix}"
+
+    VCR.use_cassette('Auth0_Api_V2_Clients/create_test_client') do
+      @test_client ||= client.create_client(
+        test_client_name,
+        custom_login_page_on: false,
+        description: 'Client description'
+      )
+    end
   end
 
-  describe '.clients' do
+  describe '.create_client', vcr: true do
+    it 'should raise an error with a missing client_id' do
+      expect do
+        client.create_client('', custom_login_page_on: false)
+      end.to raise_error Auth0::MissingParameter
+    end
+
+    it 'should create a new client with the specified attributes' do
+      expect(test_client).to(
+        include(
+          'name' => test_client_name,
+          'custom_login_page_on' => false,
+          'description' => 'Client description'
+        )
+      )
+    end
+  end
+  
+  describe '.clients', vcr: true do
     let(:clients) do
-      sleep 1
       client.clients
     end
 
-    it do
-      sleep 1
+    it 'should get at least one client' do
       expect(clients.size).to be > 0
     end
 
     context '#filters' do
-      it do
-        sleep 1
-        expect(client.clients(fields: [:name, :callbacks].join(',')).first).to(include('name', 'callbacks'))
+      it 'should include the specified fields' do
+        expect(client.clients(
+          fields: [:name, :callbacks].join(',')
+        ).first).to(include('name', 'callbacks'))
+      end
+
+      it 'should exclude fields not specified' do
+        expect(client.clients(
+          fields: [:callbacks].join(',')).first
+        ).to_not(include('name'))
       end
-      it do
-        sleep 1
-        expect(client.clients(fields: [:callbacks].join(',')).first).to_not(include('name'))
+
+      it 'should exclude the specified fields' do
+        expect(client.clients(
+          fields: [:callbacks].join(','),
+          include_fields: false
+        ).first).to_not(include('callbacks'))
       end
-      it do
-        sleep 1
-        expect(client.clients(fields: [:callbacks].join(','), include_fields: false).first).to_not(include('callbacks'))
+
+      it 'should paginate results' do
+        results = client.clients(
+          fields: :name,
+          page: 0,
+          per_page: 1
+        )
+        expect(results.first).to equal(results.last)
       end
     end
   end
 
-  describe '.client' do
-    it do
-      sleep 1
-      expect(client.client(existing_client['client_id'])).to include('client_id' => existing_client['client_id'])
+  describe '.client', vcr: true do
+
+    it 'should raise an error with a missing client_id' do
+      expect do
+        client.client('')
+      end.to raise_error Auth0::MissingClientId
+    end
+
+    it 'should get the test client' do
+      expect(
+        client.client(test_client['client_id'])
+      ).to include('client_id' => test_client['client_id'])
     end
-    it do
-      sleep 1
+
+    it 'should raise an error when passing an empty client_id' do
       expect { client.client '' }.to raise_error(Auth0::MissingClientId)
     end
 
     context '#filters' do
       let(:client_include) do
-        sleep 1
-        client.client(existing_client['client_id'], fields: [:name, :client_secret, :jwt_configuration].join(','))
+        client.client(
+          test_client['client_id'],
+          fields: [:name, :client_secret, :jwt_configuration].join(',')
+        )
       end
+
       let(:client_not_include) do
-        sleep 1
-        client.client(existing_client['client_id'], fields: :jwt_configuration, include_fields: false)
+        client.client(
+          test_client['client_id'],
+          fields: :jwt_configuration,
+          include_fields: false
+        )
       end
 
-      it do
-        sleep 1
-        expect(client_include).to(include('name', 'client_secret', 'jwt_configuration'))
+      it 'should include the specified fields' do
+        expect(
+          client_include
+        ).to(include('name', 'client_secret', 'jwt_configuration'))
       end
 
-      it do
-        sleep 1
+      it 'should exclude and include fields properly' do
         expect(client_not_include).to(include('name', 'client_secret'))
         expect(client_not_include).to_not(include('jwt_configuration'))
       end
     end
   end
 
-  describe '.create_client' do
-    it do
-      sleep 1
-      expect(client.create_client(client_name, custom_login_page_on: false)).to(
-        include('name' => client_name, 'custom_login_page_on' => false)
-      )
+  describe '.patch_client', vcr: true do
+    it 'should raise an error with a missing client_id' do
+      expect do
+        client.patch_client('', custom_login_page_on: false)
+      end.to raise_error Auth0::MissingClientId
+    end
+
+    it 'should raise an error with a missing client_id' do
+      expect do
+        client.patch_client('__test_client_id__', '')
+      end.to raise_error Auth0::MissingParameter
     end
-    it { expect { client.create_client('', custom_login_page_on: false) }.to raise_error(Auth0::MissingParameter) }
-  end
 
-  describe '.patch_client' do
-    it do
-      sleep 1
+    it 'should update the client with the correct attributes' do
       expect(
         client.patch_client(
-          existing_client['client_id'],
+          test_client['client_id'],
           custom_login_page_on: false,
           sso: true
         )
-      ).to(include('custom_login_page_on' => false, 'sso' => true))
-    end
-    it do
-      sleep 1
-      expect { client.patch_client('', custom_login_page_on: false) }.to raise_error(Auth0::MissingClientId)
+      ).to(
+        include(
+          'custom_login_page_on' => false,
+          'sso' => true
+        )
+      )
     end
   end
 
-  describe '.delete_rule' do
-    it do
-      sleep 1
-      expect { client.delete_client(existing_client['client_id']) }.to_not raise_error
+  describe '.delete_client', vcr: true do
+    it 'should raise an error with an empty client_id' do
+      expect do
+        client.delete_client ''
+      end.to raise_error Auth0::MissingClientId
     end
-    it do
-      sleep 1
-      expect { client.delete_client '' }.to raise_error(Auth0::MissingClientId)
+
+    it 'should delete the test client without an error' do
+      expect do
+        client.delete_client(test_client['client_id'])
+      end.to_not raise_error
     end
   end
 end

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

@@ -1,145 +1,159 @@
 require 'spec_helper'
 describe Auth0::Api::V2::Connections do
-  attr_reader :client, :connection, :strategy, :name, :enabled_clients, :options
+  attr_reader :client,
+              :test_user_name, :test_user_email,
+              :test_con_name, :test_con_strategy, :test_conn
 
   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
+    @client ||= Auth0Client.new(v2_creds)
+    @test_user_name = "#{entity_suffix}-username"
+    @test_user_email = "#{entity_suffix}-#{test_user_name}@auth0.com"
+    @test_con_name = "TestConnection-#{entity_suffix}"
+    @test_con_strategy = 'auth0'
 
-  describe '.connections' do
-    let(:connections) do
-      sleep 1
-      client.connections
+    VCR.use_cassette(
+      'Auth0_Api_V2_Connections/create_test_connection'
+    ) do
+      @test_conn ||= client.create_connection(
+        name: test_con_name,
+        strategy: test_con_strategy
+      )
     end
 
-    it do
-      sleep 1
-      expect(connections.size).to be > 0
+    VCR.use_cassette(
+      'Auth0_Api_V2_Connections/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
-    it do
-      sleep 1
-      expect(connections.find { |con| con['name'] == name }).to_not be_empty
+  end
+
+  describe '.create_connection', vcr: true do
+    let(:subject) { test_conn }
+
+    it 'should return specific fields upon creation' do
+      should include('id', 'name', 'options', 'strategy')
     end
 
-    context '#filters' do
-      it do
-        sleep 1
-        expect(client.connections(strategy: strategy).size).to be > 0
-      end
-      it do
-        sleep 1
-        expect(client.connections(strategy: strategy, fields: [:name].join(',')).first).to include('name')
-      end
-      it do
-        sleep 1
-        expect(client.connections(strategy: strategy, fields: [:name].join(','), include_fields: false).first).to_not(
-          include('name')
-        )
-      end
+    it 'should return the data sent' do
+      should include(
+               'name' => test_conn['name'],
+               'strategy' => test_con_strategy,
+               )
     end
   end
 
-  describe '.connection' do
+  describe '.connection', vcr: true do
     let(:subject) do
-      sleep 1
-      client.connection(connection['id'])
+      client.connection(test_conn['id'])
     end
 
-    it do
-      sleep 1
-      should include('name' => connection['name'])
+    it 'should find the correct connection' do
+      should include('name' => test_conn['name'])
     end
 
     context '#filters' do
-      it do
-        sleep 1
-        expect(client.connection(connection['id'], fields: [:name, :id].join(','))).to include('id', 'name')
+      it 'should include the fields indicated' do
+        expect(
+          client.connection(
+            test_conn['id'],
+            fields: [:name, :id].join(',')
+          )
+        ).to include('id', 'name')
       end
-      it do
-        sleep 1
-        expect(client.connection(connection['id'], fields: [:name, :id].join(','), include_fields: false)).to_not(
+
+      it 'should exclude the fields indicated' do
+        expect(
+          client.connection(
+            test_conn['id'],
+            fields: [:name, :id].join(','),
+            include_fields: false
+          )
+        ).to_not(
           include('id', 'name')
         )
       end
     end
   end
 
-  describe '.create_connection' do
-    let(:subject) { connection }
-
-    it do
-      sleep 1
-      should include('id', 'name')
-    end
-    it do
-      sleep 1
-      should include('name' => connection['name'])
+  describe '.connections', vcr: true do
+    let(:connections) do
+      client.connections
     end
-  end
 
-  describe '.delete_connection' do
-    it do
-      sleep 1
-      expect { client.delete_connection connection['id'] }.to_not raise_error
+    it 'should not be empty' do
+      expect(connections.size).to be > 0
     end
-  end
 
-  describe '.update_connection' do
-    let!(:connection_to_update) do
-      sleep 1
-      client.create_connection(name: "#{SecureRandom.uuid[0..25]}#{entity_suffix}",
-                               strategy: strategy,
-                               options: options,
-                               enabled_clients: enabled_clients)
+    it 'should include the previously created connection' do
+      expect(
+        connections.find do |con|
+          con['name'] == test_con_name
+        end
+      ).to_not be_empty
     end
-    new_name = SecureRandom.uuid[0..25]
-    let(:options) { { username: new_name } }
-    it do
-      sleep 1
-      expect(client.update_connection(connection_to_update['id'], 'options' => options)['options']).to include(
-        'username' => new_name
-      )
+
+    context '#filters' do
+      it 'should include previously-created connection when filtered' do
+        expect(
+          client.connections(strategy: test_con_strategy).size
+        ).to be > 0
+      end
+
+      it 'should should include the fields indicated from filtered results' do
+        expect(
+          client.connections(
+            strategy: test_con_strategy,
+            fields: [:name].join(',')
+          ).first
+        ).to include('name')
+      end
+
+      it 'should should exclude the fields indicated from filtered results' do
+        expect(
+          client.connections(
+            strategy: test_con_strategy,
+            fields: [:name].join(','),
+            include_fields: false
+          ).first).to_not include('name')
+      end
     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
-      sleep 1
-      client.create_user(username,  email: email,
-                                    password: password,
-                                    email_verified: false,
-                                    connection: Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                    app_metadata: {})
-    end
+  describe '.delete_connection_user', vcr: true do
     let(:connection) do
-      sleep 1
-      client.connections.find { |connection| connection['name'] == Auth0::Api::AuthenticationEndpoints::UP_AUTH }
+      client.connections.find do |connection|
+        connection['name'] == Auth0::Api::AuthenticationEndpoints::UP_AUTH
+      end
     end
 
-    it do
-      sleep 1
-      expect(client.delete_connection_user(connection['id'], email)).to be_empty
+    it 'should delete the user created' do
+      expect(
+        client.delete_connection_user(connection['id'], test_user_email)
+      ).to be_empty
     end
   end
 
-  after(:all) do
-    client
-      .connections
-      .select { |connection| connection['name'].include?(entity_suffix) }
-      .each { |connection|
-        sleep 1
-        client.delete_connection(connection['id'])
-      }
+  describe '.update_connection', vcr: true do
+    it 'should update the connection' do
+      new_options = test_conn['options']
+      new_options['passwordPolicy'] = 'excellent'
+      expect(
+        client.update_connection(
+          test_conn['id'],
+          options: new_options
+        )['options']['passwordPolicy']
+      ).to eq 'excellent'
+    end
+  end
+
+  describe '.delete_connection', vcr: true do
+    it 'should delete the connection' do
+      expect { client.delete_connection test_conn['id'] }.to_not raise_error
+    end
   end
 end

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

@@ -1,85 +1,128 @@
 require 'spec_helper'
 require 'base64'
 describe Auth0::Api::V2::DeviceCredentials do
-  attr_reader :user, :client, :basic_client, :existing_device_credentials
+  attr_reader :test_user, :client, :basic_client, :test_credential
 
   before(:all) do
     @client = Auth0Client.new(v2_creds)
-    username = Faker::Internet.user_name
-    email = "#{entity_suffix}#{Faker::Internet.safe_email(username)}"
+    test_user_name = "#{entity_suffix}-username"
+    email = "#{entity_suffix}-#{test_user_name}@auth0.com"
     password = Faker::Internet.password
-    sleep 1
-    @user = client.create_user(username,  'email' => email,
-                                          'password' => password,
-                                          'email_verified' => true,
-                                          'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                          'app_metadata' => {})
-
-    basic_creds = { connection_id: Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                    user: email,
-                    password: password,
-                    authorization: 'Basic' }
+
+    VCR.use_cassette('Auth0_Api_V2_DeviceCredentials/create_test_user') do
+      @test_user = client.create_user(
+        test_user_name,
+        'email' => email,
+        'password' => password,
+        'email_verified' => true,
+        'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH
+      )
+    end
+
+
+    basic_creds = {
+      connection_id: Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+      user: email,
+      password: password,
+      authorization: 'Basic'
+    }
 
     @basic_client = Auth0Client.new(v2_creds.merge(basic_creds))
-    sleep 1
-    @existing_device_credentials = basic_client.create_device_credential(
-      "#{user['name']}_phone_1",
-      'dmFsdWU=',
-      '68753A44-4D6F-1226-9C60-0050E4C00067',
-      ENV['CLIENT_ID']
-    )
+
+    VCR.use_cassette('Auth0_Api_V2_DeviceCredentials/create_test_credential') do
+      @test_credential = basic_client.create_device_credential(
+        "#{test_user['name']}_phone_1",
+        'dmFsdWU=',
+        '68753A44-4D6F-1226-9C60-0050E4C00067',
+        v2_creds[:client_id]
+      )
+    end
+
   end
 
   after(:all) do
-    sleep 1
-    client.delete_user(user['user_id'])
+    VCR.use_cassette('Auth0_Api_V2_DeviceCredentials/delete_test_user') do
+      client.delete_user(test_user['user_id'])
+    end
+
+    VCR.use_cassette('Auth0_Api_V2_DeviceCredentials/delete_test_credential') do
+      client.delete_device_credential(test_credential['id'])
+    end
   end
 
-  describe '.device_credentials' do
-    let(:device_credentials) do
-      sleep 1
-      basic_client.device_credentials(ENV['CLIENT_ID'])
+  describe '.create_device_credential', vcr: true do
+    it 'should create the test credentials' do
+      expect(test_credential).to(
+        include('id' => test_credential['id'])
+      )
     end
-    it do
-      sleep 1
-      expect(device_credentials.size).to be > 0
+
+    it 'should raise an error if the device_name is empty' do
+      expect do
+        basic_client.create_device_credential(
+          '', 'value', 'device_id', 'client_id'
+        )
+      end.to raise_error Auth0::InvalidParameter
     end
-    it do
-      sleep 1
-      expect(device_credentials.find { |cred| cred['id'] == existing_device_credentials['id'] }).to_not be_empty
+
+    it 'should raise an error if the value is empty' do
+      expect do
+        basic_client.create_device_credential(
+          'device_name', '', 'device_id', 'client_id'
+        )
+      end.to raise_error Auth0::InvalidParameter
     end
-    context '#filter_by_type' do
-      let(:filtered_device_credentials) { basic_client.device_credentials(ENV['CLIENT_ID'], type: 'refresh_token') }
-      it do
-        sleep 1
-        expect(filtered_device_credentials.find do |cred|
-                 cred['id'] == existing_device_credentials['id']
-               end).to eq nil
-      end
+
+    it 'should raise an error if the device_id is empty' do
+      expect do
+        basic_client.create_device_credential(
+          'device_name', 'value', '', 'client_id'
+        )
+      end.to raise_error Auth0::InvalidParameter
+    end
+
+    it 'should raise an error if the client_id is empty' do
+      expect do
+        basic_client.create_device_credential(
+          'device_name', 'value', 'device_id', ''
+        )
+      end.to raise_error Auth0::InvalidParameter
     end
   end
 
-  describe '.create_device_credential' do
-    let!(:new_credentials) do
-      sleep 1
-      basic_client.create_device_credential(
-        "#{user['name']}_phone_2",
-        'dmFsdWU=',
-        '68753A44-4D6F-1226-9C60-0050E4C00067',
-        ENV['CLIENT_ID']
-      )
+  describe '.device_credentials', vcr: true do
+    let(:device_credentials) do
+      basic_client.device_credentials(v2_creds[:client_id])
     end
-    it do
-      sleep 1
-      expect(basic_client.device_credentials(ENV['CLIENT_ID'])
-        .find { |cred| cred['id'] == new_credentials['id'] }).to_not be_empty
+
+    it 'should have at least 1 entry' do
+      expect(device_credentials.size).to be > 0
+    end
+
+    it 'should include the test credential' do
+      expect(
+        device_credentials.find do |cred|
+          cred['id'] == test_credential['id']
+        end).to_not be_empty
+    end
+
+    context '#filter_by_type' do
+      it 'should exclude the test credential' do
+        expect(
+          basic_client.device_credentials(
+            v2_creds[:client_id],
+            type: 'refresh_token'
+          )
+        ).to be_empty
+      end
     end
   end
 
-  describe '.delete_device_credential' do
-    it do
-      sleep 1
-      expect { basic_client.delete_device_credential(existing_device_credentials['id']) }.to_not raise_error
+  describe '.delete_device_credential', vcr: true do
+    it 'should delete the test credential without an error' do
+      expect do
+        basic_client.delete_device_credential(test_credential['id'])
+      end.to_not raise_error
     end
   end
 end