auth0 4.4.0 → 5.1.2

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

@@ -1,121 +1,116 @@
 require 'spec_helper'
 describe Auth0::Api::V2::Emails do
+  attr_reader :client
+
   before(:all) do
-    client = Auth0Client.new(v2_creds)
+    @client = Auth0Client.new(v2_creds)
+
     begin
-      sleep 1
-      client.delete_provider
-    rescue
+      VCR.use_cassette(
+        'Auth0_Api_V2_Emails/delete_existing_provider'
+      ) do
+        client.delete_provider
+      end
+    rescue Auth0::NotFound
       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(:credentials) { {api_key: 'api_key'} }
+
+  let(:settings) do
+    {
+      first_setting: 'first_setting_set',
+      second_setting: 'second_setting_set'
+    }
+  end
+
   let(:body) do
-    { 'name' => name,
-      'enabled' => enabled,
-      'credentials' => credentials,
-      'settings' => settings }
+    {
+      name: name,
+      enabled: enabled,
+      credentials: credentials,
+      settings: settings
+    }
   end
 
-  describe '.configure_provider' do
-    let!(:email_provider) do
-      sleep 1
+  describe '.configure_provider', vcr: true do
+    it 'should configure a new email provider' do
       begin
-        client.configure_provider(body)
-      rescue
-        puts 'email provider is already configured'
-      end
-    end
-    it do
-      if email_provider
-        sleep 1
-        expect(email_provider).to include(
-          'name' => name, 'enabled' => enabled, 'credentials' => credentials, 'settings' => settings
-        )
+        expect(
+          JSON.parse(JSON[client.configure_provider(body)], symbolize_names: true)
+        ).to include(body)
+      rescue Auth0::Unsupported
+        puts 'Email provider is already configured'
       end
     end
   end
 
-  describe '.get_provider' do
-    let(:provider) do
-      sleep 1
+  describe '.get_provider', vcr: true do
+    it 'should get the existing email provider' do
       begin
-        client.get_provider
-      rescue
-        'no email provider'
-      end
-    end
-
-    it do
-      if provider
-        sleep 1
-        expect(provider.size).to be > 0
+        expect(client.get_provider.size).to be > 0
+      rescue Auth0::NotFound
+        'No email provider configured'
       end
     end
 
     context '#filters' do
-      it do
+      it 'should get the existing email provider with specific fields' do
         begin
-          sleep 1
           expect(
-              client.get_provider(fields: [:name, :enabled, :credentials].join(','), include_fields: true)
-          ).to(
-              include('name', 'enabled', 'credentials')
-          )
-        rescue
-          'no email provider'
+              client.get_provider(
+                fields: [:name, :enabled, :credentials].join(','),
+                include_fields: true
+              )
+          ).to include('name', 'enabled', 'credentials')
+        rescue Auth0::NotFound
+          'No email provider configured'
         end
       end
-      it do
+
+      it 'should get the existing email provider without specific fields' do
         begin
-          sleep 1
           expect(
-              client.get_provider(fields: [:enabled].join(','), include_fields: false).first
-          ).to_not(include('enabled'))
-        rescue
-          'no email provider'
+              client.get_provider(
+                fields: [:enabled].join(','),
+                include_fields: false
+              ).first
+          ).to_not include('enabled')
+        rescue Auth0::NotFound
+          'No email provider configured'
         end
       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
+  describe '.update_provider', vcr: true do
     let(:update_body) do
-      { 'name' => update_name,
-        'settings' => update_settings }
+      {
+        name: 'sendgrid',
+        settings: {
+          first_up_setting: 'first_up_setting_set',
+          second_up_setting: 'second_up_setting_set'
+        }.merge(settings),
+        credentials: credentials
+      }
     end
-    it do
-      begin
-        sleep 1
-        expect(
-          client.update_provider(update_body)
-        ).to(
-          include(
-            'name' => update_name, 'enabled' => enabled, 'credentials' => credentials, 'settings' => update_settings
-          )
-        )
-      rescue
-        puts 'email provider is not configured'
-      end
+
+    it 'should update the existing email provider' do
+      expect(
+        JSON.parse(JSON[client.update_provider(update_body)], symbolize_names: true)
+      ).to include(update_body)
     end
   end
 
-  describe '.delete_provider' do
-    it do
-      sleep 1
+  describe '.delete_provider', vcr: true do
+    it 'should delete the existing email provider without an error' do
       expect { client.delete_provider }.to_not raise_error
     end
-    it do
-      sleep 1
+
+    it 'should throw an error trying to get the email provider' do
       expect { client.get_provider }.to raise_error(Auth0::NotFound)
     end
   end

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

@@ -1,71 +1,124 @@
 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)}" }
+  UP_AUTH = Auth0::Api::AuthenticationEndpoints::UP_AUTH
 
-    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
+  let(:client) { Auth0Client.new(v2_creds) }
+  let(:username) { Faker::Internet.user_name }
+  let(:email) { "#{entity_suffix}#{Faker::Internet.safe_email(name: username)}" }
+  let(:connection_id) do
+    VCR.use_cassette('Auth0_Api_V2_Jobs/search_for_connection_id') do
+      client.connections.find do |connection|
+        connection['name'].include?(UP_AUTH)
+      end['id']
+    end
+  end
+
+  describe '.import_users and .get_job', vcr: true do
+    let(:file_name) { 'spec/fixtures/api-jobs-spec-import-users.json' }
+    let(:file_content) do
+      [{
+        email: email,
+        email_verified: false,
+        app_metadata: { roles: ['admin'] },
+        user_metadata: { theme: 'light' }
+      }].to_json
+    end
+    let(:import_file) do
+      File.open(file_name, 'w+') { |f| f.write(file_content) }
+      File.new(file_name, 'rb')
+    end
+    let(:imported_users) { client.import_users(import_file, connection_id) }
+    let(:import_job_id) { imported_users['id'] }
+
+    it 'should create an import users job successfully' do
+      expect(imported_users).to include(
+        'connection' => UP_AUTH,
+        'type' => 'users_import'
+      )
+    end
+
+    it 'should get the import users job' do
+      expect(client.get_job(import_job_id)).to include(
+        'connection' => UP_AUTH,
+        'type' => 'users_import',
+        'id' => import_job_id
+      )
+    end
+
+    after do
+      File.delete(file_name)
+    end
+  end
+
+  describe '.export_users and .get_job', vcr: true do
+    let(:exported_users) { client.export_users(connection_id: connection_id) }
+    let(:export_job_id) { exported_users['id'] }
+
+    it 'should create an export users job successfully' do
+      expect(exported_users).to include(
+        'connection' => UP_AUTH,
+        'type' => 'users_export'
+      )
     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['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
+    it 'should get the export users job' do
+      expect(client.get_job(export_job_id)).to include(
+        'connection' => UP_AUTH,
+        'type' => 'users_export',
+        'id' => export_job_id
+      )
     end
+  end
+
+  describe '.send_verification_email and .get_job', vcr: true do
+    let(:user) do
+      client.create_user(
+        username,
+        'email' => email,
+        'password' => Faker::Internet.password,
+        'connection' => UP_AUTH
+      )
+    end
+    let(:email_verification_job) { client.send_verification_email(user['user_id']) }
+    let(:email_job_id) { email_verification_job['id'] }
+
+    it 'should create a new verification_email job' do
+      expect(
+        email_verification_job
+      ).to include('status' => 'pending', 'type' => 'verification_email')
+    end
+
+    it 'should get the completed verification_email' do
+      expect(client.get_job(email_job_id)).to include(
+        'type' => 'verification_email',
+        'id' => email_job_id
+      )
+    end
+
+    it 'should reject an invalid client_id' do
+      expect do
+        client.send_verification_email(user['user_id'], Random.new(32).to_s)
+      end.to raise_error Auth0::BadRequest
+    end
+
+    it 'should raise an error if the user id is empty' do
+      expect do
+        client.send_verification_email( '' )
+      end.to raise_error Auth0::InvalidParameter, 'Must specify a user id'
+    end
+
+    it 'should raise an error if the identity supplied is not a Hash' do
+      expect do
+        client.send_verification_email( 'user_id', identity: 'not a hash')
+      end.to raise_error Auth0::InvalidParameter, 'Identity must be a hash send an email verification'
+    end
+  end
 
-    after(:all) do
+  after(:all) do
+    VCR.use_cassette('Auth0_Api_V2_Jobs/delete_imported_user') 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)
+      delete_user = new_client.get_users(q: "email:#{entity_suffix}*").first
+      new_client.delete_user(delete_user['user_id']) unless delete_user.nil?
     end
   end
 end

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

@@ -1,83 +1,91 @@
 require 'spec_helper'
 
 describe Auth0::Api::V2::Logs do
-  attr_reader :client, :user
+  attr_reader :client, :test_user
 
   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
-    sleep 1
-    @user = client.create_user(username,  'email' => email,
-                                          'password' => password,
-                                          'email_verified' => false,
-                                          'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                          'app_metadata' => {})
+    test_user_name = "#{entity_suffix}-username"
+
+    VCR.use_cassette('Auth0_Api_V2_Logs/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
-    sleep 1
-    client.delete_user(user['user_id'])
+    VCR.use_cassette('Auth0_Api_V2_Logs/delete_test_user') do
+      client.delete_user(test_user['user_id'])
+    end
   end
 
-  describe '.logs' do
+  describe '.logs', vcr: true do
     let(:logs) do
-      sleep 1
       client.logs
     end
 
     context '#filters' do
-      it do
-        sleep 1
+      it 'should have one log entry' do
         expect(client.logs(per_page: 1).size).to be 1
       end
-      it do
-        sleep 1
+
+      it 'should include the specified fields' do
         expect(
-          client.logs(per_page: 1, fields: [:date, :description, :type].join(','), include_fields: true).first
+          client.logs(
+            per_page: 1,
+            fields: [:date, :description, :type].join(','),
+            include_fields: true
+          ).first
         ).to(include('date', 'description', 'type'))
       end
-      it do
-        sleep 1
-        expect(client.logs(per_page: 1, fields: [:date].join(',')).first).to_not include('type', 'description')
+
+      it 'should exclude fields not specified' do
+        expect(
+          client.logs(
+            per_page: 1,
+            fields: [:date].join(',')
+          ).first
+        ).to_not include('type', 'description')
       end
-      it do
-        sleep 1
+
+      it 'should exclude the specified fields' do
         expect(
-          client.logs(per_page: 1, fields: [:date].join(','), include_fields: false).first
+          client.logs(
+            per_page: 1,
+            fields: [:date].join(','),
+            include_fields: false
+          ).first
         ).to include('type', 'description')
       end
     end
 
     context '#from' do
-      it do
-        sleep 1
+      it 'should take one log entry' do
         expect(client.logs(from: logs.last['_id'], take: 1).size).to be 1
       end
     end
   end
 
-  describe '.log' do
+  describe '.log', vcr: true do
     let(:first_log) do
-      sleep 1
       client.logs.first
     end
+
     let(:log) do
-      sleep 1
       client.log(first_log['_id'])
     end
-    it do
-      sleep 1
+
+    it 'should not be empty' do
       expect(log).to_not be_empty
     end
-    it do
-      sleep 1
+
+    it 'should match the created log entry' do
       expect(log['_id']).to eq(first_log['_id'])
     end
-    it do
-      sleep 1
-      expect(log['date']).to eq(first_log['date'])
-    end
   end
 end