descope 1.0.7 → 1.2.0

data/spec/lib.descope/api/v1/management/lists_spec.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::Lists do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::Lists)
+    @instance = dummy_instance
+  end
+
+  context '.create_list' do
+    it 'should respond to .create_list' do
+      expect(@instance).to respond_to :create_list
+    end
+
+    it 'is expected to create a new list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CREATE_PATH,
+        {
+          name: 'test-list',
+          type: 'ip',
+          description: 'test description',
+          data: { 'foo' => 'bar' }
+        }
+      )
+      expect do
+        @instance.create_list(
+          name: 'test-list',
+          type: 'ip',
+          description: 'test description',
+          data: { 'foo' => 'bar' }
+        )
+      end.not_to raise_error
+    end
+
+    it 'is expected to create a new list without optional fields' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CREATE_PATH,
+        { name: 'test-list', type: 'ip' }
+      )
+      expect do
+        @instance.create_list(name: 'test-list', type: 'ip')
+      end.not_to raise_error
+    end
+  end
+
+  context '.update_list' do
+    it 'should respond to .update_list' do
+      expect(@instance).to respond_to :update_list
+    end
+
+    it 'is expected to update an existing list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_UPDATE_PATH,
+        {
+          id: 'test-id',
+          name: 'test-list',
+          type: 'ip',
+          description: 'test description',
+          data: { 'foo' => 'bar' }
+        }
+      )
+      expect do
+        @instance.update_list(
+          id: 'test-id',
+          name: 'test-list',
+          type: 'ip',
+          description: 'test description',
+          data: { 'foo' => 'bar' }
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.delete_list' do
+    it 'should respond to .delete_list' do
+      expect(@instance).to respond_to :delete_list
+    end
+
+    it 'is expected to delete an existing list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_DELETE_PATH,
+        { id: 'test-id' }
+      )
+      expect do
+        @instance.delete_list(id: 'test-id')
+      end.not_to raise_error
+    end
+  end
+
+  context '.load_list' do
+    it 'should respond to .load_list' do
+      expect(@instance).to respond_to :load_list
+    end
+
+    it 'is expected to load a list by id' do
+      expect(@instance).to receive(:mgmt_get).with("#{LIST_LOAD_PATH}/test-id")
+      expect do
+        @instance.load_list(id: 'test-id')
+      end.not_to raise_error
+    end
+  end
+
+  context '.load_list_by_name' do
+    it 'should respond to .load_list_by_name' do
+      expect(@instance).to respond_to :load_list_by_name
+    end
+
+    it 'is expected to load a list by name' do
+      expect(@instance).to receive(:mgmt_get).with("#{LIST_LOAD_BY_NAME_PATH}/test-list")
+      expect do
+        @instance.load_list_by_name(name: 'test-list')
+      end.not_to raise_error
+    end
+  end
+
+  context '.load_all_lists' do
+    it 'should respond to .load_all_lists' do
+      expect(@instance).to respond_to :load_all_lists
+    end
+
+    it 'is expected to load all lists' do
+      expect(@instance).to receive(:mgmt_get).with(LIST_LOAD_ALL_PATH)
+      expect do
+        @instance.load_all_lists
+      end.not_to raise_error
+    end
+  end
+
+  context '.import_lists' do
+    it 'should respond to .import_lists' do
+      expect(@instance).to respond_to :import_lists
+    end
+
+    it 'is expected to import the given lists' do
+      lists = [{ name: 'test-list', type: 'ip' }]
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_IMPORT_PATH,
+        { lists: }
+      )
+      expect do
+        @instance.import_lists(lists:)
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_add_ips' do
+    it 'should respond to .list_add_ips' do
+      expect(@instance).to respond_to :list_add_ips
+    end
+
+    it 'is expected to add the given IPs to the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_ADD_IPS_PATH,
+        { id: 'test-id', ips: ['1.2.3.4'] }
+      )
+      expect do
+        @instance.list_add_ips(id: 'test-id', ips: ['1.2.3.4'])
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_remove_ips' do
+    it 'should respond to .list_remove_ips' do
+      expect(@instance).to respond_to :list_remove_ips
+    end
+
+    it 'is expected to remove the given IPs from the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_REMOVE_IPS_PATH,
+        { id: 'test-id', ips: ['1.2.3.4'] }
+      )
+      expect do
+        @instance.list_remove_ips(id: 'test-id', ips: ['1.2.3.4'])
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_check_ip' do
+    it 'should respond to .list_check_ip' do
+      expect(@instance).to respond_to :list_check_ip
+    end
+
+    it 'is expected to check whether the given IP exists in the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CHECK_IP_PATH,
+        { id: 'test-id', ip: '1.2.3.4' }
+      )
+      expect do
+        @instance.list_check_ip(id: 'test-id', ip: '1.2.3.4')
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_add_texts' do
+    it 'should respond to .list_add_texts' do
+      expect(@instance).to respond_to :list_add_texts
+    end
+
+    it 'is expected to add the given texts to the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_ADD_TEXTS_PATH,
+        { id: 'test-id', texts: ['some-text'] }
+      )
+      expect do
+        @instance.list_add_texts(id: 'test-id', texts: ['some-text'])
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_remove_texts' do
+    it 'should respond to .list_remove_texts' do
+      expect(@instance).to respond_to :list_remove_texts
+    end
+
+    it 'is expected to remove the given texts from the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_REMOVE_TEXTS_PATH,
+        { id: 'test-id', texts: ['some-text'] }
+      )
+      expect do
+        @instance.list_remove_texts(id: 'test-id', texts: ['some-text'])
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_check_text' do
+    it 'should respond to .list_check_text' do
+      expect(@instance).to respond_to :list_check_text
+    end
+
+    it 'is expected to check whether the given text exists in the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CHECK_TEXT_PATH,
+        { id: 'test-id', text: 'some-text' }
+      )
+      expect do
+        @instance.list_check_text(id: 'test-id', text: 'some-text')
+      end.not_to raise_error
+    end
+  end
+
+  context '.list_check_texts' do
+    it 'should respond to .list_check_texts' do
+      expect(@instance).to respond_to :list_check_texts
+    end
+
+    it 'is expected to check whether any of the given texts exist in the list by default' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CHECK_TEXT_PATH,
+        { id: 'test-id', texts: %w[text-1 text-2], matchAll: false }
+      )
+      expect do
+        @instance.list_check_texts(id: 'test-id', texts: %w[text-1 text-2])
+      end.not_to raise_error
+    end
+
+    it 'is expected to check whether all of the given texts exist in the list when match_all is set' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CHECK_TEXT_PATH,
+        { id: 'test-id', texts: %w[text-1 text-2], matchAll: true }
+      )
+      expect do
+        @instance.list_check_texts(id: 'test-id', texts: %w[text-1 text-2], match_all: true)
+      end.not_to raise_error
+    end
+  end
+
+  context '.clear_list' do
+    it 'should respond to .clear_list' do
+      expect(@instance).to respond_to :clear_list
+    end
+
+    it 'is expected to clear all entries from the list' do
+      expect(@instance).to receive(:mgmt_post).with(
+        LIST_CLEAR_PATH,
+        { id: 'test-id' }
+      )
+      expect do
+        @instance.clear_list(id: 'test-id')
+      end.not_to raise_error
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/management_key_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::ManagementKey do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::ManagementKey)
+    @instance = dummy_instance
+  end
+
+  context '.create_management_key' do
+    it 'should respond to .create_management_key' do
+      expect(@instance).to respond_to :create_management_key
+    end
+
+    it 'is expected to create a management key' do
+      expect(@instance).to receive(:mgmt_put).with(
+        MGMT_KEY_CREATE_PATH, {
+          name: 'test',
+          description: 'test key',
+          expiresIn: 0,
+          permittedIps: ['1.2.3.4'],
+          reBac: { 'k1': 'v1' }
+        }
+      )
+      expect do
+        @instance.create_management_key(
+          name: 'test',
+          description: 'test key',
+          expires_in: 0,
+          permitted_ips: ['1.2.3.4'],
+          re_bac: { 'k1': 'v1' }
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.update_management_key' do
+    it 'should respond to .update_management_key' do
+      expect(@instance).to respond_to :update_management_key
+    end
+
+    it 'is expected to update a management key' do
+      expect(@instance).to receive(:mgmt_patch).with(
+        MGMT_KEY_UPDATE_PATH, {
+          id: '123',
+          name: 'test1',
+          description: 'updated',
+          permittedIps: ['1.2.3.4'],
+          status: 'active'
+        }
+      )
+      expect do
+        @instance.update_management_key(
+          id: '123',
+          name: 'test1',
+          description: 'updated',
+          permitted_ips: ['1.2.3.4'],
+          status: 'active'
+        )
+      end.not_to raise_error
+    end
+  end
+
+  context '.get_management_key' do
+    it 'should respond to .get_management_key' do
+      expect(@instance).to respond_to :get_management_key
+    end
+
+    it 'is expected to get a management key' do
+      expect(@instance).to receive(:mgmt_get).with(
+        MGMT_KEY_GET_PATH, { id: '123' }
+      )
+      expect { @instance.get_management_key(id: '123') }.not_to raise_error
+    end
+  end
+
+  context '.delete_management_key' do
+    it 'should respond to .delete_management_key' do
+      expect(@instance).to respond_to :delete_management_key
+    end
+
+    it 'is expected to delete a management key' do
+      expect(@instance).to receive(:mgmt_post).with(
+        MGMT_KEY_DELETE_PATH, { ids: ['123'] }
+      )
+      expect { @instance.delete_management_key(id: '123') }.not_to raise_error
+    end
+  end
+
+  context '.search_management_keys' do
+    it 'should respond to .search_management_keys' do
+      expect(@instance).to respond_to :search_management_keys
+    end
+
+    it 'is expected to search management keys' do
+      expect(@instance).to receive(:mgmt_get).with(
+        MGMT_KEY_SEARCH_PATH, {
+          tenantIds: %w[123 456],
+          status: 'active'
+        }
+      )
+      expect do
+        @instance.search_management_keys(tenant_ids: %w[123 456], status: 'active')
+      end.not_to raise_error
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/outbound_app_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Descope::Api::V1::Management::OutboundApp do
+  before(:all) do
+    dummy_instance = DummyClass.new
+    dummy_instance.extend(Descope::Api::V1::Management::OutboundApp)
+    @instance = dummy_instance
+  end
+
+  describe '.fetch_outbound_app_user_token' do
+    let(:mock_response) do
+      {
+        'token' => {
+          'id' => 'token-123',
+          'appId' => 'app-123',
+          'userId' => 'user-123',
+          'tokenSub' => 'sub-123',
+          'accessToken' => 'access-token-value',
+          'accessTokenType' => 'Bearer',
+          'accessTokenExpiry' => '2025-12-31T23:59:59Z',
+          'hasRefreshToken' => true,
+          'refreshToken' => 'refresh-token-value',
+          'scopes' => %w[read write],
+          'tenantId' => 'tenant-123'
+        }
+      }
+    end
+
+    it 'responds to fetch_outbound_app_user_token' do
+      expect(@instance).to respond_to :fetch_outbound_app_user_token
+    end
+
+    it 'raises an error when app_id is empty' do
+      expect do
+        @instance.fetch_outbound_app_user_token(app_id: '', user_id: 'user-123')
+      end.to raise_error(Descope::ArgumentException, 'app_id cannot be empty')
+    end
+
+    it 'raises an error when app_id is nil' do
+      expect do
+        @instance.fetch_outbound_app_user_token(app_id: nil, user_id: 'user-123')
+      end.to raise_error(Descope::ArgumentException, 'app_id cannot be empty')
+    end
+
+    it 'raises an error when user_id is empty' do
+      expect do
+        @instance.fetch_outbound_app_user_token(app_id: 'app-123', user_id: '')
+      end.to raise_error(Descope::ArgumentException, 'Missing user id')
+    end
+
+    it 'raises an error when user_id is nil' do
+      expect do
+        @instance.fetch_outbound_app_user_token(app_id: 'app-123', user_id: nil)
+      end.to raise_error(Descope::ArgumentException, 'Missing user id')
+    end
+
+    it 'fetches token with required parameters only' do
+      expect(@instance).to receive(:mgmt_post).with(
+        '/v1/mgmt/outbound/app/user/token',
+        {
+          appId: 'app-123',
+          userId: 'user-123'
+        }
+      ).and_return(mock_response)
+
+      result = @instance.fetch_outbound_app_user_token(app_id: 'app-123', user_id: 'user-123')
+      expect(result['token']['accessToken']).to eq('access-token-value')
+    end
+
+    it 'fetches token with scopes' do
+      expect(@instance).to receive(:mgmt_post).with(
+        '/v1/mgmt/outbound/app/user/token',
+        {
+          appId: 'app-123',
+          userId: 'user-123',
+          scopes: %w[read write]
+        }
+      ).and_return(mock_response)
+
+      result = @instance.fetch_outbound_app_user_token(
+        app_id: 'app-123',
+        user_id: 'user-123',
+        scopes: %w[read write]
+      )
+      expect(result['token']['scopes']).to eq(%w[read write])
+    end
+
+    it 'fetches token with options' do
+      expect(@instance).to receive(:mgmt_post).with(
+        '/v1/mgmt/outbound/app/user/token',
+        {
+          appId: 'app-123',
+          userId: 'user-123',
+          options: {
+            withRefreshToken: true,
+            forceRefresh: true
+          }
+        }
+      ).and_return(mock_response)
+
+      result = @instance.fetch_outbound_app_user_token(
+        app_id: 'app-123',
+        user_id: 'user-123',
+        with_refresh_token: true,
+        force_refresh: true
+      )
+      expect(result['token']['hasRefreshToken']).to be(true)
+    end
+
+    it 'fetches token with tenant_id' do
+      expect(@instance).to receive(:mgmt_post).with(
+        '/v1/mgmt/outbound/app/user/token',
+        {
+          appId: 'app-123',
+          userId: 'user-123',
+          tenantId: 'tenant-123'
+        }
+      ).and_return(mock_response)
+
+      result = @instance.fetch_outbound_app_user_token(
+        app_id: 'app-123',
+        user_id: 'user-123',
+        tenant_id: 'tenant-123'
+      )
+      expect(result['token']['tenantId']).to eq('tenant-123')
+    end
+
+    it 'fetches token with all parameters' do
+      expect(@instance).to receive(:mgmt_post).with(
+        '/v1/mgmt/outbound/app/user/token',
+        {
+          appId: 'app-123',
+          userId: 'user-123',
+          scopes: %w[read write],
+          tenantId: 'tenant-123',
+          options: {
+            withRefreshToken: true,
+            forceRefresh: false
+          }
+        }
+      ).and_return(mock_response)
+
+      result = @instance.fetch_outbound_app_user_token(
+        app_id: 'app-123',
+        user_id: 'user-123',
+        scopes: %w[read write],
+        tenant_id: 'tenant-123',
+        with_refresh_token: true,
+        force_refresh: false
+      )
+      expect(result['token']['id']).to eq('token-123')
+    end
+  end
+
+  describe '.delete_outbound_app_user_tokens' do
+    it 'responds to delete_outbound_app_user_tokens' do
+      expect(@instance).to respond_to :delete_outbound_app_user_tokens
+    end
+
+    it 'raises an error when both app_id and user_id are empty' do
+      expect do
+        @instance.delete_outbound_app_user_tokens(app_id: '', user_id: '')
+      end.to raise_error(Descope::ArgumentException, 'At least one of app_id or user_id must be provided')
+    end
+
+    it 'raises an error when both app_id and user_id are nil' do
+      expect do
+        @instance.delete_outbound_app_user_tokens
+      end.to raise_error(Descope::ArgumentException, 'At least one of app_id or user_id must be provided')
+    end
+
+    it 'deletes tokens by app_id only' do
+      expect(@instance).to receive(:mgmt_delete).with(
+        '/v1/mgmt/outbound/user/tokens',
+        { appId: 'app-123' }
+      )
+
+      expect do
+        @instance.delete_outbound_app_user_tokens(app_id: 'app-123')
+      end.not_to raise_error
+    end
+
+    it 'deletes tokens by user_id only' do
+      expect(@instance).to receive(:mgmt_delete).with(
+        '/v1/mgmt/outbound/user/tokens',
+        { userId: 'user-123' }
+      )
+
+      expect do
+        @instance.delete_outbound_app_user_tokens(user_id: 'user-123')
+      end.not_to raise_error
+    end
+
+    it 'deletes tokens by both app_id and user_id' do
+      expect(@instance).to receive(:mgmt_delete).with(
+        '/v1/mgmt/outbound/user/tokens',
+        { appId: 'app-123', userId: 'user-123' }
+      )
+
+      expect do
+        @instance.delete_outbound_app_user_tokens(app_id: 'app-123', user_id: 'user-123')
+      end.not_to raise_error
+    end
+  end
+
+  describe '.delete_outbound_app_token_by_id' do
+    it 'responds to delete_outbound_app_token_by_id' do
+      expect(@instance).to respond_to :delete_outbound_app_token_by_id
+    end
+
+    it 'raises an error when token_id is empty' do
+      expect do
+        @instance.delete_outbound_app_token_by_id(token_id: '')
+      end.to raise_error(Descope::ArgumentException, 'token_id cannot be empty')
+    end
+
+    it 'raises an error when token_id is nil' do
+      expect do
+        @instance.delete_outbound_app_token_by_id(token_id: nil)
+      end.to raise_error(Descope::ArgumentException, 'token_id cannot be empty')
+    end
+
+    it 'deletes token by id' do
+      expect(@instance).to receive(:mgmt_delete).with(
+        '/v1/mgmt/outbound/token',
+        { id: 'token-123' }
+      )
+
+      expect do
+        @instance.delete_outbound_app_token_by_id(token_id: 'token-123')
+      end.not_to raise_error
+    end
+  end
+end

data/spec/lib.descope/api/v1/management/password_spec.rb

@@ -11,14 +11,14 @@ describe Descope::Api::V1::Management::Password do
 
   context '.get_password_settings' do
     it 'should get password settings' do
-      expect(@instance).to receive(:get).with('/v1/mgmt/password/settings', { tenantId: 'tenant_id' })
+      expect(@instance).to receive(:mgmt_get).with('/v1/mgmt/password/settings', { tenantId: 'tenant_id' })
       @instance.get_password_settings('tenant_id')
     end
   end
 
   context '.update_password_settings' do
     it 'should update password settings' do
-      expect(@instance).to receive(:post).with('/v1/mgmt/password/settings', { 'minLength' => 10 })
+      expect(@instance).to receive(:mgmt_post).with('/v1/mgmt/password/settings', { 'minLength' => 10 })
       @instance.update_password_settings({ min_length: 10 })
     end
   end

data/spec/lib.descope/api/v1/management/permission_spec.rb

@@ -15,7 +15,7 @@ describe Descope::Api::V1::Management::Permission do
     end
 
     it 'is expected to create a new permission' do
-      expect(@instance).to receive(:post).with(
+      expect(@instance).to receive(:mgmt_post).with(
         PERMISSION_CREATE_PATH, {
           name: 'test',
           description: 'test'
@@ -36,7 +36,7 @@ describe Descope::Api::V1::Management::Permission do
     end
 
     it 'is expected to update a permission' do
-      expect(@instance).to receive(:post).with(
+      expect(@instance).to receive(:mgmt_post).with(
         PERMISSION_UPDATE_PATH, {
           name: 'test',
           newName: 'production',
@@ -59,7 +59,7 @@ describe Descope::Api::V1::Management::Permission do
     end
 
     it 'is expected to delete a permission' do
-      expect(@instance).to receive(:post).with(
+      expect(@instance).to receive(:mgmt_post).with(
         PERMISSION_DELETE_PATH, { name: 'test' }
       )
       expect do
@@ -74,7 +74,7 @@ describe Descope::Api::V1::Management::Permission do
     end
 
     it 'is expected to delete a permission' do
-      expect(@instance).to receive(:get).with(PERMISSION_LOAD_ALL_PATH)
+      expect(@instance).to receive(:mgmt_get).with(PERMISSION_LOAD_ALL_PATH)
       expect { @instance.load_all_permissions }.not_to raise_error
     end
   end