auth0 4.4.0 → 5.1.2

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

@@ -1,45 +1,59 @@
 require 'spec_helper'
 describe Auth0::Api::V2::Tickets 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_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
-    sleep 1
-    client.delete_user(user['user_id'])
+    VCR.use_cassette('Auth0_Api_V2_Tickets/delete_test_user') do
+      client.delete_user(test_user['user_id'])
+    end
   end
 
-  describe '.post_email_verification' do
-    let(:email_verification) do
-      sleep 1
-      client.post_email_verification(user['user_id'], result_url: 'http://myapp.com/callback')
+  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 do
-      sleep 1
-      expect(email_verification).to include('ticket')
+
+    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
-  end
 
-  describe '.post_password_change' do
-    let(:password_change) do
-      sleep 1
-      client.post_password_change(new_password: 'secret', user_id: user['user_id'],
-                                  result_url: 'http://myapp.com/callback')
+    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
-    it do
-      sleep 1
-      expect(password_change).to include('ticket')
+  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

@@ -6,7 +6,7 @@ describe Auth0::Api::V2::UserBlocks do
     before(:all) do
       @client = Auth0Client.new(v2_creds)
       username = Faker::Internet.user_name
-      @email = "#{entity_suffix}#{Faker::Internet.safe_email(username)}"
+      @email = "#{entity_suffix}#{Faker::Internet.safe_email(name: username)}"
       password = Faker::Internet.password
       @user = client.create_user(username,  'email' => email,
                                             'password' => password,

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

@@ -1,168 +1,300 @@
 require 'spec_helper'
 describe Auth0::Api::V2::Users do
-  let(:client) { Auth0Client.new(v2_creds) }
-  let(:username) { Faker::Internet.user_name }
-  let(:email) { "#{entity_suffix}#{Faker::Internet.safe_email(username)}" }
-  let(:password) { Faker::Internet.password }
-  let(:user) do
-    sleep 1
-    client.create_user(username,  'email' => email,
-                                  'password' => password,
-                                  'email_verified' => false,
-                                  'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                  'app_metadata' => {})
-  end
-
-  describe '.users' do
+
+  attr_reader :client, :test_user_name, :test_user_email, :test_user, :test_user_secondary,
+              :test_role, :test_api_name, :test_permission_name, :test_permission
+
+  before(:all) do
+    @client ||= Auth0::Client.new(v2_creds)
+
+    @test_user_name = "#{entity_suffix}-username"
+    @test_user_email = "#{entity_suffix}-#{@test_user_name}@auth0.com"
+
+    @test_api_name = "#{entity_suffix}-test-api-for-users"
+    @test_api_scope = 'test:scope'
+
+    @test_permission_name = "#{entity_suffix}-test-permission-for-users"
+    @test_permission = ::Auth0::Permission.new("#{entity_suffix}-test-permission-for-users", @test_api_name)
+
+    VCR.use_cassette('Auth0_Api_V2_Users/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_Users/create_secondary_test_user') do
+      @test_user_secondary ||= client.create_user(
+        "#{test_user_name}-secondary",
+        email: "#{entity_suffix}-#{@test_user_name}-secondary@auth0.com",
+        password: Faker::Internet.password,
+        connection: Auth0::Api::AuthenticationEndpoints::UP_AUTH
+      )
+    end
+
+    VCR.use_cassette('Auth0_Api_V2_Users/create_test_api') do
+      @test_api ||= client.create_resource_server(
+        @test_api_name,
+        name: @test_api_name,
+        scopes: [{ value: @test_api_scope }]
+      )
+    end
+
+    VCR.use_cassette('Auth0_Api_V2_Users/create_test_role') do
+      @test_role ||= client.create_role(
+        "#{entity_suffix}-test-role-for-users",
+        description: 'Test role description'
+      )
+    end
+  end
+
+  after(:all) do
+    VCR.use_cassette('Auth0_Api_V2_Users/delete_test_api') do
+      client.delete_resource_server @test_api['id']
+    end
+
+    VCR.use_cassette('Auth0_Api_V2_Users/delete_test_role') do
+      client.delete_role @test_role['id']
+    end
+  end
+
+  describe '.create_user', vcr: true do
+    it 'should return the created user' do
+      expect(test_user).to include('user_id', 'email', 'email_verified', 'name')
+      expect(test_user).to include(
+        'email' => test_user_email,
+        'name' => test_user_name,
+        'email_verified' => false
+      )
+    end
+  end
+
+  describe '.users', vcr: true do
     let(:users) do
-      sleep 1
       client.users
     end
 
-    it do
-      sleep 1
+    it 'should have at least one user' do
       expect(users.size).to be > 0
     end
 
     context '#filters' do
-      it do
-        sleep 1
+      it 'should return the correct number of results when paginated' do
         expect(client.users(per_page: 1).size).to be 1
       end
-      it do
-        sleep 1
+
+      it 'should include the indicated fields when paginated' do
         expect(
-          client.users(per_page: 1, fields: [:picture, :email, :user_id].join(','), include_fields: true).first
+          client.users(
+            per_page: 1,
+            fields: [:picture, :email, :user_id].join(','),
+            include_fields: true
+          ).first
         ).to(include('email', 'user_id', 'picture'))
       end
-      it do
-        sleep 1
-        expect(client.users(per_page: 1, fields: [:email].join(',')).first).to_not include('user_id', 'picture')
+
+      it 'should not include other fields when paginated' do
+        expect(
+          client.users(
+            per_page: 1,
+            fields: [:email].join(',')
+          ).first
+        ).to_not include('user_id', 'picture')
       end
-      it do
-        sleep 1
+
+      it 'should exclude the indicated fields when paginated' do
         expect(
-          client.users(per_page: 1, fields: [:email].join(','), include_fields: false).first
+          client.users(
+            per_page: 1,
+            fields: [:email].join(','),
+            include_fields: false
+          ).first
         ).to include('user_id', 'picture')
       end
+
+      it 'is expected to find a user with a v2 search engine query' do
+        expect(
+          client.users(
+            per_page: 1,
+            fields: 'user_id',
+            q: "updated_at:{2016-01-01 TO *}",
+            search_engine: 'v2'
+          ).first
+        ).to include('user_id')
+      end
+
+      it 'is expected to find a user with a v3 search engine query' do
+        expect(
+          client.users(
+            per_page: 1,
+            fields: 'user_id',
+            q: "updated_at:[2016-01-01 TO *]",
+            search_engine: 'v3'
+          ).first
+        ).to include('user_id')
+      end
     end
   end
 
-  describe '.user' do
-    let(:subject) do
-      sleep 1
-      client.user(user['user_id'])
+  describe '.user', vcr: true do
+    it 'should retrieve the created user' do
+      expect(
+        client.user(test_user['user_id'])
+      ).to include(
+        'email' => test_user_email,
+        'name' => test_user_name
+      )
     end
 
-    it do
-      sleep 1
-      should include('email' => email, 'name' => username)
+    context '#filters' do
+      it 'should include the fields indicated' do
+        expect(
+          client.user(
+            test_user['user_id'],
+            fields: [:picture, :email, :user_id].join(','),
+            include_fields: true
+          )
+        ).to include('email', 'user_id', 'picture')
+      end
+
+      it 'should exclude the fields indicated' do
+        expect(
+          client.user(
+            test_user['user_id'],
+            fields: [:picture, :email, :user_id].join(','),
+            include_fields: false
+          )
+        ).not_to include('picture', 'email', 'user_id')
+      end
+
+      it 'should exclude fields not indicated' do
+        expect(
+          client.user(
+            test_user['user_id'],
+            fields: [:email].join(','))
+        ).to_not include('user_id', 'picture')
+      end
     end
-    it do
-      sleep 1
-      expect(
-        client.user(user['user_id'], fields: [:picture, :email, :user_id].join(','), include_fields: true)
-      ).to(include('email', 'user_id', 'picture'))
+  end
+
+  describe '.patch_user', vcr: true do
+    let(:patch_user_body) do
+      {
+        'email_verified' => true,
+        'user_metadata' => {
+          'addresses' => { 'home_address' => '742 Evergreen Terrace' }
+        }
+      }
     end
-    it do
-      sleep 1
+
+    it 'should patch the User successfully' do
       expect(
-        client.user(user['user_id'], fields: [:picture, :email, :user_id].join(','), include_fields: false)
-      ).not_to(include('email', 'user_id', 'picture'))
+        client.patch_user(test_user['user_id'], patch_user_body)
+      ).to include(patch_user_body)
     end
+  end
 
-    context '#filters' do
-      it do
-        sleep 1
-        expect(client.user(user['user_id'], fields: [:picture, :email, :user_id].join(','))).to(
-          include('email', 'user_id', 'picture')
-        )
-      end
-      it do
-        sleep 1
-        expect(client.user(user['user_id'], fields: [:email].join(','))).to_not include('user_id', 'picture')
-      end
+  describe '.delete_user_provider', vcr: true do
+    it 'should attempt to delete the MFA provider for the User' do
+      expect { client.delete_user_provider test_user['user_id'], 'google-authenticator' }.to_not raise_error
     end
   end
 
-  describe '.create_user' do
-    let(:subject) { user }
+  describe '.link_user_account', vcr: true do
+    let(:secondary_account_body) do
+      {
+        provider: 'auth0',
+        user_id: test_user_secondary['user_id']
+      }
+    end
 
-    it do
-      sleep 1
-      should include('user_id', 'identities')
+    it 'should link two Users successfully' do
+      expect { client.link_user_account test_user['user_id'], secondary_account_body }.to_not raise_error
     end
-    it do
-      sleep 1
-      expect(client.patch_user(user['user_id'], 'email_verified' => true)).to include('email_verified' => true)
+  end
+
+  describe '.unlink_user_account', vcr: true do
+    it 'should unlink two Users successfully' do
+      expect do
+        client.unlink_user_account test_user['user_id'], 'auth0', test_user_secondary['user_id']
+      end.to_not raise_error
     end
   end
 
-  describe '.delete_user' do
-    it do
-      sleep 1
-      expect { client.delete_user user['user_id'] }.to_not raise_error
+  describe '.user_logs', vcr: true do
+    it 'should get Logs for a User successfully' do
+      expect { client.user_logs( test_user['user_id'], per_page: 2 ) }.to_not raise_error
     end
-    it do
-      sleep 1
-      expect { client.delete_user '' }.to raise_error(Auth0::MissingUserId)
+  end
+
+  describe '.add_user_roles', vcr: true do
+    it 'should add a Role to a User successfully' do
+      expect { client.add_user_roles test_user['user_id'], [ test_role['id'] ] }.to_not raise_error
     end
   end
 
-  describe '.patch_user' do
-    it do
-      sleep 1
-      expect(client.patch_user(user['user_id'], 'email_verified' => true)).to(include('email_verified' => true))
+  describe '.get_user_roles', vcr: true do
+    it 'should get Roles for a User successfully' do
+      expect( client.get_user_roles(test_user['user_id']).first ).to include(
+        'id' => test_role['id']
+      )
     end
-    let(:body_path) do
-      {
-        'user_metadata' => {
-          'addresses' => { 'home_address' => '742 Evergreen Terrace' }
-        }
-      }
+  end
+
+  describe '.remove_user_roles', vcr: true do
+    it 'should remove a Role from a User successfully' do
+      expect { client.remove_user_roles test_user['user_id'], [ test_role['id'] ] }.to_not raise_error
     end
-    it do
-      sleep 1
-      expect(
-        client.patch_user(user['user_id'], body_path)
-      ).to(include('user_metadata' => { 'addresses' => { 'home_address' => '742 Evergreen Terrace' } }))
-    end
-  end
-
-  describe '.link_user_account and .unlink_users_account' do
-    let(:email_link) { "#{entity_suffix}#{Faker::Internet.safe_email(Faker::Internet.user_name)}" }
-    let!(:link_user) do
-      sleep 1
-      client.create_user(username,  'email' => email_link,
-                                    'password' => Faker::Internet.password,
-                                    'email_verified' => false,
-                                    'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                    'app_metadata' => {})
-    end
-    let(:email_primary) { "#{entity_suffix}#{Faker::Internet.safe_email(Faker::Internet.user_name)}" }
-    let!(:primary_user) do
-      sleep 1
-      client.create_user(username,  'email' => email_primary,
-                                    'password' => Faker::Internet.password,
-                                    'email_verified' => false,
-                                    'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                    'app_metadata' => {})
-    end
-
-    let(:body_link) { { 'provider' => 'auth0', 'user_id' => link_user['user_id'] } }
-    skip 'Link user account examples are skipped to avoid errors on users deletion' do
-      it do
-        expect(
-          client.link_user_account(primary_user['user_id'], body_link).first
-        ).to include('provider' => 'auth0', 'user_id' => primary_user['identities'].first['user_id'])
-      end
+  end
 
-      it do
-        expect(
-          client.unlink_users_account(primary_user['user_id'], 'auth0', link_user['user_id']).first
-        ).to include('provider' => 'auth0', 'user_id' => primary_user['identities'].first['user_id'])
-      end
+  describe '.get_enrollments', vcr: true do
+    it 'should get Enrollments for a User successfully' do
+      expect { client.get_enrollments test_user['user_id'] }.to_not raise_error
+    end
+  end
+
+  describe '.add_user_permissions', vcr: true do
+    it 'should add a Permissions for a User successfully' do
+      expect { client.add_user_permissions test_user['user_id'], [ test_permission ] }.to_not raise_error
+    end
+  end
+
+  describe '.get_user_permissions', vcr: true do
+    let(:test_get_user_permissions) do
+      client.get_user_permissions test_user['user_id']
+    end
+
+    it 'should get exactly 1 Permission for a User successfully' do
+      expect( test_get_user_permissions.count ).to eq 1
+    end
+
+    it 'should get the correct Permission for a User successfully' do
+      expect( test_get_user_permissions.first['permission_name'] ).to eq test_permission_name
+      expect( test_get_user_permissions.first['resource_server_name'] ).to eq test_api_name
+    end
+  end
+
+  describe '.remove_user_permissions', vcr: true do
+    it 'should remove a Permission from a User successfully' do
+      expect { client.remove_user_permissions test_user['user_id'], [ test_permission ] }.to_not raise_error
+    end
+  end
+
+  describe '.invalidate_browsers', vcr: true do
+    it 'should invalidate MFA browsers for the User successfully' do
+      expect { client.invalidate_browsers test_user['user_id'] }.to_not raise_error
     end
   end
 
+  describe '.delete_user', vcr: true do
+    it 'should delete the User successfully' do
+      expect { client.delete_user test_user['user_id'] }.to_not raise_error
+    end
+
+    it 'should delete the secondary User successfully' do
+      expect { client.delete_user test_user_secondary['user_id'] }.to_not raise_error
+    end
+  end
 end

data/spec/integration/lib/auth0/auth0_client_spec.rb

@@ -10,59 +10,61 @@ describe Auth0::Client do
     end
   end
 
-  it_should_behave_like 'invalid credentials', { namespace: 'samples.auth0.com' }, Auth0::InvalidCredentials
+  it_should_behave_like 'invalid credentials', {
+    namespace: 'samples.auth0.com'
+  }, Auth0::InvalidCredentials
+
   it_should_behave_like 'invalid credentials', {
     namespace: 'samples.auth0.com', client_id: 'client_id'
   }, Auth0::InvalidCredentials
+
   it_should_behave_like 'invalid credentials', {
     namespace: 'samples.auth0.com', client_secret: 'secret'
   }, Auth0::InvalidCredentials
+
   it_should_behave_like 'invalid credentials', {
     namespace: 'samples.auth0.com', api_version: 2
   }, Auth0::InvalidCredentials
-  it_should_behave_like 'invalid credentials', {}
-  it_should_behave_like 'invalid credentials', api_version: 2
-  it_should_behave_like 'invalid credentials', api_version: 1
+
+  it_should_behave_like 'invalid credentials', {}, Auth0::InvalidApiNamespace
+
+  it_should_behave_like 'invalid credentials', {
+    api_version: 2
+  }, Auth0::InvalidApiNamespace
+
+  it_should_behave_like 'invalid credentials', {
+    api_version: 1
+  }, Auth0::InvalidApiNamespace
+
   it_should_behave_like 'invalid credentials', {
     client_id: 'client_id', client_secret: 'secret'
   }, Auth0::InvalidApiNamespace
+
   it_should_behave_like 'invalid credentials', {
     api_version: 2, token: 'token'
   }, Auth0::InvalidApiNamespace
 
-  let(:valid_v1_credentials) do
-    { client_id: ENV['CLIENT_ID'],
-      client_secret: ENV['CLIENT_SECRET'],
-      domain: ENV['DOMAIN'],
-      api_version: 1 }
-  end
-  let(:token) { ENV['MASTER_JWT'] }
-  let(:v2_credentials) { { domain: ENV['DOMAIN'] } }
+  let(:v2_credentials) { { domain: 'test.auth0.com' } }
 
   shared_examples 'valid credentials' do
     it { expect { Auth0Client.new(credentials) }.to_not raise_error }
   end
 
-  it_should_behave_like 'invalid credentials' do
-    let(:credentials) { valid_v1_credentials }
-  end
   it_should_behave_like 'valid credentials' do
-    let(:credentials) { v2_credentials.merge(token: token) }
+    let(:credentials) { v2_credentials.merge(token: 'TEST_API_TOKEN') }
   end
+
   it_should_behave_like 'valid credentials' do
-    let(:credentials) { v2_credentials.merge(access_token: ENV['MASTER_JWT']) }
+    let(:credentials) { v2_credentials.merge(access_token: 'TEST_API_TOKEN') }
   end
 
   context 'client headers' do
     let(:client) { Auth0::Client.new(v2_credentials.merge(access_token: 'abc123', domain: 'myhost.auth0.com')) }
     let(:headers) { client.headers }
-
-    let(:base64_token) do
-      Base64.urlsafe_encode64('{"name":"ruby-auth0","version":"' + Auth0::VERSION + '"}')
-    end
+    let(:telemetry) { JSON.parse(Base64::urlsafe_decode64(headers['Auth0-Client'])) }
 
     it 'has the correct headers present' do
-      expect(headers.keys.sort).to eql(['Auth0-Client', 'Authorization', 'Content-Type', 'User-Agent'])
+      expect(headers.keys.sort).to eql(['Auth0-Client', 'Authorization', 'Content-Type'])
     end
 
     it 'uses the correct access token' do
@@ -73,12 +75,16 @@ describe Auth0::Client do
       expect(headers['Content-Type']).to eql 'application/json'
     end
 
-    it 'sets the ruby version' do
-      expect(headers['User-Agent']).to eql "Ruby/#{RUBY_VERSION}"
+    it 'should include the correct name in telemetry data' do
+      expect(telemetry['name']).to eq('ruby-auth0')
+    end
+
+    it 'should include the correct version in telemetry data' do
+      expect(telemetry['version']).to eq(Auth0::VERSION)
     end
 
-    it 'sets the client version' do
-      expect(headers['Auth0-Client']).to eql base64_token
+    it 'should include the correct env in telemetry data' do
+      expect(telemetry['env']['ruby']).to eq(RUBY_VERSION)
     end
   end
 end

data/spec/lib/auth0/api/v2/anomaly_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Anomaly do
+  before :all do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Auth0::Api::V2::Anomaly)
+    @instance = dummy_instance
+  end
+
+  context '.check_if_ip_is_blocked' do
+    it { expect(@instance).to respond_to(:check_if_ip_is_blocked) }
+    it 'expect client to send get to /api/v2/anomaly/blocks/ips/192.0.2.0' do
+      expect(@instance).to receive(:get).with('/api/v2/anomaly/blocks/ips/192.0.2.0')
+      expect { @instance.check_if_ip_is_blocked('192.0.2.0') }.not_to raise_error
+    end
+    it { expect { @instance.check_if_ip_is_blocked('') }.to raise_error('Must specify an IP') }
+  end
+
+  context '.remove_ip_block' do
+    it { expect(@instance).to respond_to(:remove_ip_block) }
+    it 'expect client to send delete to /api/v2/anomaly/blocks/ips/192.0.2.0' do
+      expect(@instance).to receive(:delete).with('/api/v2/anomaly/blocks/ips/192.0.2.0')
+      expect { @instance.remove_ip_block('192.0.2.0') }.not_to raise_error
+    end
+    it { expect { @instance.remove_ip_block('') }.to raise_error('Must specify an IP') }
+  end
+end