auth0 5.5.0 → 5.6.0

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

@@ -8,11 +8,14 @@ describe Auth0::Api::V2::UserBlocks do
       username = Faker::Internet.user_name
       @email = "#{entity_suffix}#{Faker::Internet.safe_email(name: username)}"
       password = Faker::Internet.password
-      @user = client.create_user(username,  'email' => email,
-                                            'password' => password,
-                                            'email_verified' => true,
-                                            'connection' => Auth0::Api::AuthenticationEndpoints::UP_AUTH,
-                                            'app_metadata' => {})
+      @user = client.create_user(
+        Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+        name: username,
+        email: email,
+        email_verified: true,
+        app_metadata: {},
+        password: Faker::Internet.password
+      )
     end
 
     after(:all) do

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

@@ -18,19 +18,19 @@ describe Auth0::Api::V2::Users do
 
     VCR.use_cassette('Auth0_Api_V2_Users/create_test_user') do
       @test_user ||= client.create_user(
-        @test_user_name,
+        Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+        name: @test_user_name,
         email: @test_user_email,
-        password: Faker::Internet.password,
-        connection: Auth0::Api::AuthenticationEndpoints::UP_AUTH
+        password: Faker::Internet.password
       )
     end
 
     VCR.use_cassette('Auth0_Api_V2_Users/create_secondary_test_user') do
       @test_user_secondary ||= client.create_user(
-        "#{test_user_name}-secondary",
+        Auth0::Api::AuthenticationEndpoints::UP_AUTH,
+        name: "#{test_user_name}-secondary",
         email: "#{entity_suffix}-#{@test_user_name}-secondary@auth0.com",
-        password: Faker::Internet.password,
-        connection: Auth0::Api::AuthenticationEndpoints::UP_AUTH
+        password: Faker::Internet.password
       )
     end
 
@@ -255,33 +255,6 @@ describe Auth0::Api::V2::Users do
     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

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

@@ -0,0 +1,312 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Actions do
+  before :all do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Auth0::Api::V2::Actions)
+    @instance = dummy_instance
+  end
+
+  context '.actions' do
+    it 'is expected to respond to a actions method' do
+      expect(@instance).to respond_to(:actions)
+    end
+
+    it 'is expected to respond to a get_actions method' do
+      expect(@instance).to respond_to(:get_actions)
+    end
+
+    it 'is expected to get /api/v2/actions with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/actions',
+        trigger_id: 'post-login',
+        action_name: 'loginHandler',
+        deployed: true,
+        per_page: 10,
+        page: 1,
+        installed: true
+      )
+      expect do
+        @instance.actions(
+          'post-login',
+          'loginHandler',
+          deployed: true,
+          per_page: 10,
+          page: 1,
+          installed: true
+        )
+      end.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the trigger id is empty' do
+      expect { @instance.actions(nil, nil) }.to raise_exception(Auth0::MissingTriggerId)
+    end
+
+    it 'is expected to raise an exception when the action name is empty' do
+      expect { @instance.actions(1, nil) }.to raise_exception(Auth0::MissingActionName)
+    end
+  end
+
+  context '.action' do
+    it 'is expected to respond to a action method' do
+      expect(@instance).to respond_to(:action)
+      expect(@instance).to respond_to(:get_action)
+    end
+
+    it 'is expected to call get request to /api/v2/actions/actions/{id}' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/actions/123'
+      )
+      expect { @instance.action('123') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the action ID is empty' do
+      expect { @instance.action(nil) }.to raise_exception(Auth0::MissingActionId)
+    end
+  end
+
+  context '.create_action' do
+    it 'is expected to respond to a create_action method' do
+      expect(@instance).to respond_to(:create_action)
+    end
+
+    it 'is expected to post to /api/v2/actions' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/actions',
+          name: 'test_org'
+        )
+      expect do
+        @instance.create_action(
+          name: 'test_org'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_action' do
+    it 'is expected to respond to a delete_action method' do
+      expect(@instance).to respond_to :delete_action
+    end
+
+    it 'is expected to call delete to /api/v2/actions/actions/{id}' do
+      expect(@instance).to receive(:delete).with('/api/v2/actions/actions/123', { force: false })
+      expect { @instance.delete_action('123') }.not_to raise_error
+    end
+
+    it 'is expected not to delete /api/v2/actions if action_id is blank' do
+      expect(@instance).not_to receive(:delete)
+      expect { @instance.delete_action(nil) }.to raise_exception(
+        Auth0::MissingActionId
+      )
+    end
+  end
+
+  context '.patch_action' do
+    it 'is expected to respond to a patch_action method' do
+      expect(@instance).to respond_to(:patch_action)
+    end
+
+    it 'is expected to respond to a update_action method' do
+      expect(@instance).to respond_to(:update_action)
+    end
+
+    it 'is expected to patch /api/v2/actions/actions/{id}' do
+      expect(@instance).to receive(:patch).with(
+        '/api/v2/actions/actions/123',
+        { name: 'name' }
+      )
+
+      expect { @instance.patch_action('123', { name: 'name' }) }.not_to raise_error
+    end
+  end
+
+  context '.execution' do
+    it 'is expected to respond to a user method' do
+      expect(@instance).to respond_to(:execution)
+    end
+
+    it 'is expected to call get request to /api/v2/actions/executions/{id}' do
+      expect(@instance).to receive(:get).with('/api/v2/actions/executions/123')
+      expect { @instance.execution('123') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the execution ID is empty' do
+      expect { @instance.execution(nil) }.to raise_exception(Auth0::MissingExecutionId)
+    end
+  end
+
+  context '.actions_versions' do
+    it 'is expected to respond to a user method' do
+      expect(@instance).to respond_to(:actions_versions)
+    end
+
+    it 'is expected to call get request to /api/v2/actions/actions/{id}/versions' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/actions/123/versions',
+        per_page: nil,
+        page: nil
+      )
+      expect { @instance.actions_versions('123') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the action ID is empty' do
+      expect { @instance.actions_versions(nil) }.to raise_exception(Auth0::MissingActionId)
+    end
+
+    it 'is expected to get /api/v2/actions/actions/{id}/versions with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/actions/123/versions',
+        per_page: 10,
+        page: 1
+      )
+      expect do
+        @instance.actions_versions(
+          '123',
+          per_page: 10,
+          page: 1
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.trigger_bindings' do
+    it 'is expected to respond to a trigger_bindings method' do
+      expect(@instance).to respond_to(:trigger_bindings)
+      expect(@instance).to respond_to(:get_trigger_bindings)
+    end
+
+    it 'is expected to call get request to /api/v2/actions/triggers/{id}/bindings' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/triggers/123/bindings',
+        per_page: nil,
+        page: nil
+      )
+      expect { @instance.trigger_bindings('123') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the action_id ID is empty' do
+      expect { @instance.trigger_bindings(nil) }.to raise_exception(Auth0::MissingTriggerId)
+    end
+
+    it 'is expected to get /api/v2/actions/triggers/{id}/bindings with custom parameters' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/triggers/123/bindings',
+        per_page: 10,
+        page: 1
+      )
+      expect do
+        @instance.trigger_bindings(
+          '123',
+          per_page: 10,
+          page: 1
+        )
+      end.not_to raise_error
+    end
+  end
+
+
+  context '.patch_trigger_bindings' do
+    it 'is expected to respond to a patch_trigger_bindings method' do
+      expect(@instance).to respond_to(:patch_trigger_bindings)
+      expect(@instance).to respond_to(:update_trigger_bindings)
+    end
+
+    it 'is expected to patch /api/v2/actions/triggers/{id}/bindings' do
+      expect(@instance).to receive(:patch).with(
+        '/api/v2/actions/triggers/post-login/bindings',
+        { name: 'name' }
+      )
+      expect { @instance.patch_trigger_bindings('post-login', { :name => 'name' }) }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the trigger ID is empty' do
+      expect { @instance.patch_trigger_bindings(nil) }.to raise_exception(Auth0::MissingTriggerId)
+    end
+
+    it 'is expected to raise an exception when the body is empty' do
+      expect { @instance.patch_trigger_bindings('post-login') }.to raise_exception(Auth0::InvalidParameter)
+    end
+  end
+
+  context '.action_by_version' do
+    it 'is expected to respond to a action_by_version method' do
+      expect(@instance).to respond_to(:action_by_version)
+      expect(@instance).to respond_to(:get_action_by_version)
+    end
+
+    it 'is expected to call get request to /api/v2/actions/actions/{id}/versions/{version_id}' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/actions/actions/123/versions/v1'
+      )
+      expect { @instance.action_by_version('123', 'v1') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the action ID is empty' do
+      expect { @instance.action_by_version(nil, nil) }.to raise_exception(Auth0::MissingActionId)
+    end
+    
+    it 'is expected to raise an exception when the version ID is empty' do
+      expect { @instance.action_by_version('123', nil) }.to raise_exception(Auth0::MissingVersionId)
+    end
+  end
+
+  context '.deploy_action' do
+    it 'is expected to respond to a deploy_action method' do
+      expect(@instance).to respond_to(:deploy_action)
+    end
+
+    it 'is expected to call post request to /api/v2/actions/actions/{id}/deploy' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/actions/actions/123/deploy'
+      )
+      expect { @instance.deploy_action('123') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the action ID is empty' do
+      expect { @instance.deploy_action(nil) }.to raise_exception(Auth0::MissingActionId)
+    end
+  end
+
+  context '.test_action' do
+    it 'is expected to respond to a test_action method' do
+      expect(@instance).to respond_to(:test_action)
+    end
+
+    it 'is expected to raise an exception when the action ID is empty' do
+      expect { @instance.test_action(nil) }.to raise_exception(Auth0::MissingActionId)
+    end
+
+    it 'is expected to post to /api/v2/actions/{id}/test' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/actions/actions/123/test',
+          name: 'test_org'
+        )
+      expect do
+        @instance.test_action(
+          '123',
+          name: 'test_org'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.rollback_action' do
+    it 'is expected to respond to a rollback_action method' do
+      expect(@instance).to respond_to(:rollback_action)
+    end
+
+    it 'is expected to call post request to /api/v2/actions/actions/{id}/versions/{version_id}/deploy' do
+      expect(@instance).to receive(:post).with(
+        '/api/v2/actions/actions/123/versions/v1/deploy'
+      )
+      expect { @instance.rollback_action('123', 'v1') }.not_to raise_error
+    end
+
+    it 'is expected to raise an exception when the action ID is empty' do
+      expect { @instance.rollback_action(nil, nil) }.to raise_exception(Auth0::MissingActionId)
+    end
+    
+    it 'is expected to raise an exception when the version ID is empty' do
+      expect { @instance.rollback_action('123', nil) }.to raise_exception(Auth0::MissingVersionId)
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+require 'spec_helper'
+describe Auth0::Api::V2::Grants do
+  before :all do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Auth0::Api::V2::Grants)
+    @instance = dummy_instance
+  end
+
+  context '.grants' do
+    it { expect(@instance).to respond_to(:grants) }
+    it { expect(@instance).to respond_to(:get_all_grants) }
+
+    it 'is expected to get /api/v2/grants/' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/grants',
+        client_id: nil,
+        user_id: nil,
+        audience: nil,
+        page: nil,
+        per_page: nil,
+        include_totals: nil
+      )
+      expect { @instance.grants }.not_to raise_error
+    end
+
+    it 'is expected to send get /api/v2/grants/ with client_id and audience' do
+      audience = "https://samples.auth0.com/api/v2/"
+
+      expect(@instance).to receive(:get).with(
+        '/api/v2/grants',
+        client_id: '1',
+        user_id: nil,
+        audience: audience,
+        page: nil,
+        per_page: nil,
+        include_totals: nil
+      )
+      expect { @instance.grants(client_id: '1', audience: audience) }.not_to raise_error
+    end
+
+    it 'is expected to send get /api/v2/grants/ with client_id and user_id' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/grants',
+        client_id: '1',
+        user_id: '1',
+        audience: nil,
+        page: nil,
+        per_page: nil,
+        include_totals: nil
+      )
+      expect { @instance.grants(client_id: '1', user_id: '1') }.not_to raise_error
+    end
+
+    it 'is expected to send get /api/v2/grants/ with pagination' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/grants',
+        client_id: nil,
+        user_id: nil,
+        audience: nil,
+        page: 1,
+        per_page: 2,
+        include_totals: nil
+      )
+      expect { @instance.grants(page: 1, per_page: 2) }.not_to raise_error
+    end
+
+    it 'is expected to send get /api/v2/grants/ with include_totals' do
+      expect(@instance).to receive(:get).with(
+        '/api/v2/grants',
+        client_id: nil,
+        user_id: nil,
+        audience: nil,
+        page: 1,
+        per_page: 2,
+        include_totals: true
+      )
+      expect { @instance.grants(page: 1, per_page: 2, include_totals: true) }.not_to raise_error
+    end
+  end
+
+  context '.delete_grant' do
+    it { expect(@instance).to respond_to(:delete_grant) }
+    it 'is expected to send delete to /api/v2/grants/1?user_id=1' do
+      expect(@instance).to receive(:delete).with('/api/v2/grants/1?user_id=1')
+      expect { @instance.delete_grant('1', '1') }.not_to raise_error
+    end
+    it { expect { @instance.delete_grant('', '') }.to raise_error 'Must specify a grant id as id' }
+    it { expect { @instance.delete_grant('', '1') }.to raise_error 'Must specify a grant id as id' }
+    it { expect { @instance.delete_grant('1', '') }.to raise_error 'Must specify a user id' }
+  end
+end

data/spec/lib/auth0/client_spec.rb

@@ -134,7 +134,7 @@ describe Auth0::Client do
       it_should_behave_like 'Authentication API client'  
     end
 
-    context 'when try to get an API tokenwith organization' do
+    context 'when try to get an API token with organization' do
       before do
         stub_api_token_with_organization
       end
@@ -147,6 +147,7 @@ describe Auth0::Client do
           organization: organization
         )
       end
+
       it_should_behave_like 'v2 API client'
       it_should_behave_like 'Authentication API client'
     end
@@ -209,8 +210,7 @@ describe Auth0::Client do
           {
             grant_type: 'client_credentials',
             client_id: client_id,
-            client_secret: client_secret,
-            organization: organization
+            client_secret: client_secret
           }
         )
       )

data/spec/lib/auth0/mixins/httpproxy_spec.rb

@@ -492,4 +492,108 @@ describe Auth0::Mixins::HTTPProxy do
       end
     end
   end
+
+  context "Renewing tokens" do
+    before :each do
+      @token_instance = DummyClassForTokens.new(
+        client_id: 'test-client-id',
+        client_secret: 'test-client-secret',
+        domain: 'auth0.com')
+    end
+
+    %i(get delete).each do |http_method|
+      context "for #{http_method}" do
+        it 'should renew the token' do
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ) ).and_return(StubResponse.new({ 
+            "access_token" => "access_token", 
+            "expires_in" => 86400}, 
+            true, 
+            200))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { params: {}, "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+
+    %i(post put patch).each do |http_method|
+      context "for #{http_method}" do
+        it 'should renew the token' do
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ) ).and_return(StubResponse.new({ 
+            "access_token" => "access_token", 
+            "expires_in" => 86400}, 
+            true, 
+            200))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+  end
+
+  context "Using cached tokens" do
+    before :each do
+      @token_instance = DummyClassForTokens.new(
+        client_id: 'test-client-id',
+        client_secret: 'test-client-secret',
+        domain: 'auth0.com',
+        token: 'access_token',
+        token_expires_at: Time.now.to_i + 86400)
+    end
+
+    %i(get delete).each do |http_method|
+      context "for #{http_method}" do
+        it 'should use the cached token' do
+          expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { params: {}, "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+
+    %i(post put patch).each do |http_method|
+      context "for #{http_method}" do
+        it 'should use the cached token' do
+          expect(RestClient::Request).not_to receive(:execute).with(hash_including(
+            method: :post,
+            url: 'https://auth0.com/oauth/token',
+          ))
+
+          expect(RestClient::Request).to receive(:execute).with(hash_including(
+            method: http_method,
+            url: 'https://auth0.com/test',
+            headers: { "Authorization" => "Bearer access_token" }
+          )).and_return(StubResponse.new('Some random text here', true, 200))
+
+          expect { @token_instance.send(http_method, '/test') }.not_to raise_error
+        end
+      end
+    end
+  end
 end