Merge pull request #416 from ForgeRock/SDKS-4330-sdk-oidc-tests

test(sdk-oidc): add tests to oidc effects package

Author: ancheetah

.changeset/icy-olives-make.md

@@ -0,0 +1,6 @@
+---
+'@forgerock/sdk-oidc': minor
+---
+
+- Adds tests for OIDC effects package
+- Exposes `getStorageKey` utility

packages/sdk-effects/oidc/src/index.ts

@@ -1,2 +1,8 @@
-export * from './lib//authorize.effects.js';
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+export * from './lib/authorize.effects.js';
 export * from './lib/state-pkce.effects.js';

packages/sdk-effects/oidc/src/lib/authorize.test.ts

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import type { GenerateAndStoreAuthUrlValues } from '@forgerock/sdk-types';
+import { describe, expect, it, beforeEach } from 'vitest';
+import { createAuthorizeUrl } from './authorize.effects.js';
+import { getStorageKey } from './state-pkce.effects.js';
+
+const mockSessionStorage = (() => {
+  let store: { [key: string]: string } = {};
+  return {
+    getItem: (key: string) => store[key] || null,
+    setItem: (key: string, value: string) => {
+      store[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      store = {};
+    },
+    length: 0,
+    key: (index: number) => Object.keys(store)[index] || null,
+  };
+})();
+
+describe('createAuthorizeUrl', () => {
+  beforeEach(() => {
+    if (typeof sessionStorage === 'undefined') {
+      global.sessionStorage = mockSessionStorage;
+    }
+    sessionStorage.clear();
+  });
+
+  const mockOptions: GenerateAndStoreAuthUrlValues = {
+    clientId: 'test-client',
+    redirectUri: 'http://localhost:8080',
+    scope: 'openid profile',
+    responseType: 'code',
+  };
+  const baseUrl = 'https://auth.example.com/authorize';
+
+  it('should create a valid authorization URL with all required parameters', async () => {
+    const url = await createAuthorizeUrl(baseUrl, mockOptions);
+    const parsedUrl = new URL(url);
+
+    // Check the base URL
+    expect(parsedUrl.origin + parsedUrl.pathname).toBe(baseUrl);
+
+    const params = Object.fromEntries(parsedUrl.searchParams.entries());
+    expect(params).toMatchObject({
+      client_id: mockOptions.clientId,
+      redirect_uri: mockOptions.redirectUri,
+      response_type: mockOptions.responseType,
+      scope: mockOptions.scope,
+      code_challenge_method: 'S256',
+    });
+    expect(params.prompt).toBeFalsy();
+    expect(params.response_mode).toBeFalsy();
+
+    // Verify presence of dynamically generated values
+    expect(params.state).toBeDefined();
+    expect(params.code_challenge).toBeDefined();
+  });
+
+  it('should include optional parameters when provided', async () => {
+    const prompt = 'login';
+    const responseMode = 'pi.flow';
+    const optionsWithOptionals: GenerateAndStoreAuthUrlValues = {
+      ...mockOptions,
+      prompt,
+      responseMode,
+    };
+
+    const url = await createAuthorizeUrl(baseUrl, optionsWithOptionals);
+    const params = new URL(url).searchParams;
+
+    expect(params.get('prompt')).toBe(prompt);
+    expect(params.get('response_mode')).toBe(responseMode);
+  });
+
+  it('should store the authorize options in session storage', async () => {
+    await createAuthorizeUrl(baseUrl, mockOptions);
+    const storageKey = getStorageKey(mockOptions.clientId);
+    const storedData = sessionStorage.getItem(storageKey);
+
+    const parsedOptions = JSON.parse(storedData as string);
+    const serverUrl = new URL(baseUrl).origin;
+
+    expect(storedData).toBeDefined();
+    expect(parsedOptions).toMatchObject({
+      ...mockOptions,
+      serverConfig: { baseUrl: serverUrl },
+    });
+    expect(parsedOptions).toHaveProperty('state');
+    expect(parsedOptions).toHaveProperty('verifier');
+  });
+});

packages/sdk-effects/oidc/src/lib/index.ts

@@ -7,9 +7,12 @@
 
 import { createVerifier, createState } from '@forgerock/sdk-utilities';
 
-import type { GetAuthorizationUrlOptions } from '@forgerock/sdk-types';
+import type {
+  GenerateAndStoreAuthUrlValues,
+  GetAuthorizationUrlOptions,
+} from '@forgerock/sdk-types';
 
-function getStorageKey(clientId: string, prefix?: string) {
+export function getStorageKey(clientId: string, prefix?: string) {
   return `${prefix || 'FR-SDK'}-authflow-${clientId}`;
 }
 
@@ -19,11 +22,6 @@ function getStorageKey(clientId: string, prefix?: string) {
  * @param {GenerateAndStoreAuthUrlValues} options - Options for generating PKCE values
  * @returns { state: string, verifier: string, GetAuthorizationUrlOptions }
  */
-interface GenerateAndStoreAuthUrlValues extends GetAuthorizationUrlOptions {
-  login?: 'redirect' | 'embedded';
-  clientId: string;
-  prefix?: string;
-}
 
 export function generateAndStoreAuthUrlValues(
   options: GenerateAndStoreAuthUrlValues,

packages/sdk-effects/oidc/src/lib/state-pkce.effects.ts

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2025 Ping Identity Corporation. All rights reserved.
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { describe, expect, it, beforeEach } from 'vitest';
+import {
+  generateAndStoreAuthUrlValues,
+  getStorageKey,
+  getStoredAuthUrlValues,
+} from './state-pkce.effects.js';
+import type { GenerateAndStoreAuthUrlValues } from '@forgerock/sdk-types';
+
+const mockSessionStorage = (() => {
+  let store: { [key: string]: string } = {};
+  return {
+    getItem: (key: string) => store[key] || null,
+    setItem: (key: string, value: string) => {
+      store[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      store = {};
+    },
+    length: 0,
+    key: (index: number) => Object.keys(store)[index] || null,
+  };
+})();
+
+describe('PKCE', () => {
+  beforeEach(() => {
+    if (typeof sessionStorage === 'undefined') {
+      global.sessionStorage = mockSessionStorage;
+    }
+
+    sessionStorage.clear();
+  });
+
+  const mockOptions: GenerateAndStoreAuthUrlValues = {
+    clientId: 'test-client',
+    redirectUri: 'http://localhost:8080',
+    scope: 'openid profile',
+    responseType: 'code',
+  };
+
+  describe('getStorageKey', () => {
+    const clientId = 'test-client-id';
+
+    it('should generate storage key with default prefix', () => {
+      const key = getStorageKey(clientId);
+      expect(key).toBe('FR-SDK-authflow-test-client-id');
+    });
+
+    it('should generate storage key with custom prefix', () => {
+      const customPrefix = 'CUSTOM';
+      const key = getStorageKey(clientId, customPrefix);
+      expect(key).toBe('CUSTOM-authflow-test-client-id');
+    });
+  });
+
+  describe('generateAndStoreAuthUrlValues', () => {
+    it('should generate PKCE values', () => {
+      const [options] = generateAndStoreAuthUrlValues(mockOptions);
+
+      expect(options).toBeDefined();
+      expect(options).toHaveProperty('state');
+      expect(options).toHaveProperty('verifier');
+    });
+
+    it('should store options in sessionStorage when storage function is called', () => {
+      const [options, storeAuthUrl] = generateAndStoreAuthUrlValues(mockOptions);
+      storeAuthUrl();
+
+      const storageKey = getStorageKey(mockOptions.clientId, mockOptions.prefix);
+      const storedValue = sessionStorage.getItem(storageKey);
+      expect(storedValue).toBeDefined();
+
+      const parsedValue = JSON.parse(storedValue as string);
+      expect(parsedValue).toEqual(options);
+    });
+  });
+
+  describe('getStoredAuthUrlValues', () => {
+    it('should retrieve and parse stored values', () => {
+      const [options, storeAuthUrl] = generateAndStoreAuthUrlValues(mockOptions);
+      storeAuthUrl();
+
+      const storedValues = getStoredAuthUrlValues(mockOptions.clientId, mockOptions.prefix);
+      expect(storedValues).toEqual(options);
+    });
+
+    it('should remove values from storage after retrieval', () => {
+      const [, storeAuthUrl] = generateAndStoreAuthUrlValues(mockOptions);
+      storeAuthUrl();
+
+      const storageKey = getStorageKey(mockOptions.clientId, mockOptions.prefix);
+
+      // Verify value exists before retrieval
+      expect(sessionStorage.getItem(storageKey)).toBeDefined();
+
+      // Retrieve values
+      getStoredAuthUrlValues(mockOptions.clientId, mockOptions.prefix);
+
+      // Verify value was removed
+      expect(sessionStorage.getItem(storageKey)).toBeNull();
+    });
+
+    it('should throw error when stored values cannot be parsed', () => {
+      const storageKey = getStorageKey(mockOptions.clientId, mockOptions.prefix);
+      sessionStorage.setItem(storageKey, 'invalid json');
+
+      expect(() => getStoredAuthUrlValues(mockOptions.clientId, mockOptions.prefix)).toThrow(
+        'Stored values for Auth URL could not be parsed',
+      );
+    });
+  });
+});