chore: initial-jc-tests

Author: ryanbas21

e2e/am-mock-api/src/app/routes.auth.js

@@ -50,6 +50,11 @@ import {
   newPiWellKnown,
 } from './responses.js';
 import initialRegResponse from './response.registration.js';
+import {
+  webAuthnRegistrationInit,
+  getRecoveryCodesDisplay,
+  authSuccess as webAuthnSuccess,
+} from './response.webauthn.js';
 import wait from './wait.js';
 
 console.log(`Your user password from 'env.config' file: ${USERS[0].pw}`);
@@ -93,6 +98,8 @@ export default function (app) {
         res.json(MetadataMarketPlaceInitialize);
       } else if (req.query.authIndexValue === 'AMSocialLogin') {
         res.json(idpChoiceCallback);
+      } else if (req.query.authIndexValue === 'TEST_WebAuthnWithRecoveryCodes') {
+        res.json(webAuthnRegistrationInit);
       } else if (req.query.authIndexValue === 'RecaptchaEnterprise') {
         res.json(initialBasicLogin);
       } else {
@@ -414,6 +421,28 @@ export default function (app) {
         // an additional auth callback would be sent, like OTP
         res.json(authFail);
       }
+    } else if (
+      req.query.authIndexValue === 'TEST_WebAuthnWithRecoveryCodes' ||
+      req.body.authId?.startsWith('webauthn-registration') ||
+      req.body.authId?.startsWith('recovery-codes')
+    ) {
+      // Handle WebAuthn registration with recovery codes journey
+      // Identify by authIndexValue (initial) or authId (subsequent)
+      const metadataCb = req.body.callbacks.find((cb) => cb.type === 'MetadataCallback');
+      const hiddenCb = req.body.callbacks.find((cb) => cb.type === 'HiddenValueCallback');
+      const confirmationCb = req.body.callbacks.find((cb) => cb.type === 'ConfirmationCallback');
+
+      if (metadataCb && hiddenCb && hiddenCb.input[0].value) {
+        // WebAuthn credential has been submitted, show recovery codes
+        res.json(getRecoveryCodesDisplay());
+      } else if (confirmationCb) {
+        // Recovery codes have been acknowledged, complete authentication
+        res.cookie('iPlanetDirectoryPro', 'mock-webauthn-session-' + Date.now(), { domain: 'localhost' });
+        res.json(webAuthnSuccess);
+      } else {
+        // Invalid state
+        res.status(401).json(authFail);
+      }
     }
   });
 

e2e/journey-app/components/ping-protect-evaluation.ts

@@ -5,7 +5,12 @@
  * of the MIT license. See the LICENSE file for details.
  */
 import type { PingOneProtectEvaluationCallback } from '@forgerock/journey-client/types';
+import { getProtectInstance } from './ping-protect-initialize.js';
 
+/**
+ * PingOne Protect Evaluation Component
+ * Automatically collects device and behavioral signals using the Protect SDK
+ */
 export default function pingProtectEvaluationComponent(
   journeyEl: HTMLDivElement,
   callback: PingOneProtectEvaluationCallback,
@@ -19,5 +24,49 @@ export default function pingProtectEvaluationComponent(
 
   journeyEl?.appendChild(message);
 
-  // TODO: Implement PingOne Protect module evaluation here
+  // Automatically trigger Protect data collection
+  setTimeout(async () => {
+    try {
+      // Get the protect instance created during initialization
+      const protectInstance = getProtectInstance();
+
+      if (!protectInstance) {
+        throw new Error('Protect instance not initialized. Initialize callback must be called first.');
+      }
+
+      console.log('Collecting Protect signals...');
+
+      // Collect device and behavioral data
+      const result = await protectInstance.getData();
+
+      // Check if result is an error object
+      if (typeof result !== 'string' && 'error' in result) {
+        console.error('Error collecting Protect data:', result.error);
+        callback.setClientError(result.error);
+        message.innerText = `Data collection failed: ${result.error}`;
+        message.style.color = 'red';
+        return;
+      }
+
+      // Set the collected data on the callback
+      console.log('Protect data collected successfully');
+      callback.setData(result);
+      message.innerText = 'Risk assessment completed successfully!';
+      message.style.color = 'green';
+
+      // Auto-submit the form after successful data collection
+      setTimeout(() => {
+        const submitButton = document.getElementById('submitButton') as HTMLButtonElement;
+        if (submitButton) {
+          submitButton.click();
+        }
+      }, 500);
+    } catch (error) {
+      console.error('Protect evaluation failed:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      callback.setClientError(errorMessage);
+      message.innerText = `Evaluation failed: ${errorMessage}`;
+      message.style.color = 'red';
+    }
+  }, 100);
 }

e2e/journey-app/components/ping-protect-initialize.ts

@@ -4,8 +4,24 @@
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
+import { protect } from '@forgerock/protect';
 import type { PingOneProtectInitializeCallback } from '@forgerock/journey-client/types';
 
+// Global storage for protect instance to be used by evaluation component
+let protectInstance: ReturnType<typeof protect> | null = null;
+
+/**
+ * Gets the stored protect instance
+ * @returns The protect instance or null if not initialized
+ */
+export function getProtectInstance() {
+  return protectInstance;
+}
+
+/**
+ * PingOne Protect Initialize Component
+ * Automatically initializes the Protect SDK using configuration from the callback
+ */
 export default function pingProtectInitializeComponent(
   journeyEl: HTMLDivElement,
   callback: PingOneProtectInitializeCallback,
@@ -19,5 +35,58 @@ export default function pingProtectInitializeComponent(
 
   journeyEl?.appendChild(message);
 
-  // TODO: Implement PingOne Protect module initialization here
+  // Automatically trigger Protect initialization
+  setTimeout(async () => {
+    try {
+      // Get configuration from callback
+      const config = callback.getConfig();
+      console.log('Protect callback config:', config);
+
+      if (!config?.envId) {
+        const error = 'Missing envId in Protect configuration';
+        console.error(error);
+        callback.setClientError(error);
+        message.innerText = `Initialization failed: ${error}`;
+        message.style.color = 'red';
+        return;
+      }
+
+      console.log('Initializing Protect with envId:', config.envId);
+
+      // Create and store protect instance
+      protectInstance = protect({ envId: config.envId });
+      console.log('Protect instance created');
+
+      // Initialize the Protect SDK
+      console.log('Calling protect.start()...');
+      const result = await protectInstance.start();
+      console.log('protect.start() result:', result);
+
+      if (result?.error) {
+        console.error('Error initializing Protect:', result.error);
+        callback.setClientError(result.error);
+        message.innerText = `Initialization failed: ${result.error}`;
+        message.style.color = 'red';
+        return;
+      }
+
+      console.log('Protect initialized successfully - no errors');
+      message.innerText = 'PingOne Protect initialized successfully!';
+      message.style.color = 'green';
+
+      // Auto-submit the form after successful initialization
+      setTimeout(() => {
+        const submitButton = document.getElementById('submitButton') as HTMLButtonElement;
+        if (submitButton) {
+          submitButton.click();
+        }
+      }, 500);
+    } catch (error) {
+      console.error('Protect initialization failed:', error);
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      callback.setClientError(errorMessage);
+      message.innerText = `Initialization failed: ${errorMessage}`;
+      message.style.color = 'red';
+    }
+  }, 100);
 }

e2e/journey-app/package.json

@@ -16,6 +16,7 @@
   "dependencies": {
     "@forgerock/journey-client": "workspace:*",
     "@forgerock/oidc-client": "workspace:*",
+    "@forgerock/protect": "workspace:*",
     "@forgerock/sdk-logger": "workspace:*"
   }
 }

e2e/journey-app/tsconfig.app.json

@@ -19,6 +19,9 @@
     {
       "path": "../../packages/oidc-client/tsconfig.lib.json"
     },
+    {
+      "path": "../../packages/protect/tsconfig.lib.json"
+    },
     {
       "path": "../../packages/journey-client/tsconfig.lib.json"
     }

e2e/journey-app/tsconfig.json

@@ -20,6 +20,9 @@
     {
       "path": "../../packages/oidc-client"
     },
+    {
+      "path": "../../packages/protect"
+    },
     {
       "path": "../../packages/journey-client"
     },

e2e/journey-suites/src/protect.test.ts

@@ -9,32 +9,79 @@ import { expect, test } from '@playwright/test';
 import { asyncEvents } from './utils/async-events.js';
 import { username, password } from './utils/demo-user.js';
 
-test.skip('Test happy paths on test page', async ({ page }) => {
-  const { clickButton, navigate } = asyncEvents(page);
-  await navigate('/?journey=TEST_Protect');
+test.describe('PingOne Protect Journey', () => {
+  test('should complete journey with Protect initialization and evaluation', async ({ page }) => {
+    const { clickButton } = asyncEvents(page);
 
-  const messageArray: string[] = [];
+    const messageArray: string[] = [];
 
-  // Listen for events on page
-  page.on('console', async (msg) => {
-    messageArray.push(msg.text());
-    return Promise.resolve(true);
-  });
+    // Listen for console messages
+    page.on('console', async (msg) => {
+      messageArray.push(msg.text());
+      return Promise.resolve(true);
+    });
+
+    // Navigate to PingOne Protect journey
+    // Use 'load' instead of 'networkidle' because Protect SDK makes continuous requests
+    await page.goto('/?journey=TEST_LoginPingProtect&clientId=basic', { waitUntil: 'load' });
+
+    // Step 1: Wait for Protect initialization to display and complete
+    await expect(page.getByText('Initializing PingOne Protect...')).toBeVisible({ timeout: 10000 });
+
+    // Wait for initialization success message
+    await expect(page.getByText('PingOne Protect initialized successfully!')).toBeVisible({
+      timeout: 15000,
+    });
+
+    // Submit the form to proceed to next step
+    await page.getByRole('button', { name: 'Submit' }).click();
+
+    // Wait for the journey to progress
+    await page.waitForTimeout(2000);
+
+    // Debug: Print console messages
+    console.log('Console messages so far:', messageArray);
+
+    // Step 2: Perform login with username and password
+    await expect(page.getByLabel('User Name')).toBeVisible({ timeout: 15000 });
+    await page.getByLabel('User Name').fill(username);
+    await page.getByLabel('Password').fill(password);
 
-  // Perform basic login
-  await page.getByLabel('User Name').fill(username);
-  await page.getByLabel('Password').fill(password);
-  await clickButton('Submit', '/authenticate');
+    // Wait a bit to ensure input events have been processed
+    await page.waitForTimeout(500);
 
-  await expect(page.getByText('Collecting protect data')).toBeVisible();
+    await clickButton('Submit', '/authenticate');
 
-  await expect(page.getByText('Complete')).toBeVisible();
+    // Step 3: Wait for Protect evaluation to display and complete
+    await expect(page.getByText('Evaluating risk assessment...')).toBeVisible({ timeout: 10000 });
 
-  // Perform logout
-  await clickButton('Logout', '/authenticate');
+    // Wait for evaluation success message
+    await expect(page.getByText('Risk assessment completed successfully!')).toBeVisible({
+      timeout: 15000,
+    });
 
-  // Test assertions
-  expect(messageArray.includes('Protect data collected successfully')).toBe(true);
-  expect(messageArray.includes('Journey completed successfully')).toBe(true);
-  expect(messageArray.includes('Logout successful')).toBe(true);
+    // Submit the form to complete the journey
+    await page.getByRole('button', { name: 'Submit' }).click();
+
+    // Wait for the journey to complete
+    await page.waitForTimeout(2000);
+
+    // Step 4: Verify journey completion
+    await expect(page.getByText('Complete')).toBeVisible({ timeout: 10000 });
+
+    // Verify session token is present
+    const sessionToken = await page.locator('#sessionToken').textContent();
+    expect(sessionToken).toBeTruthy();
+
+    // Step 5: Perform logout
+    await clickButton('Logout', '/authenticate');
+
+    // Verify we're back at the beginning
+    await expect(page.getByText('Initializing PingOne Protect...')).toBeVisible({ timeout: 10000 });
+
+    // Test console log assertions
+    expect(messageArray.some((msg) => msg.includes('Protect initialized successfully'))).toBe(true);
+    expect(messageArray.some((msg) => msg.includes('Protect data collected successfully'))).toBe(true);
+    expect(messageArray.some((msg) => msg.includes('Logout successful'))).toBe(true);
+  });
 });