fix assertion

Author: terion-labs

tests/integration/assertions/browser.test.ts

@@ -266,17 +266,93 @@ describe("browser assertion helpers", () => {
       }
     } as unknown as Page;
 
-    const selector = await __browserTestHooks.waitForPasswordInputAfterUsernameSubmit(
+    const result = await __browserTestHooks.waitForPasswordInputAfterUsernameSubmit(
       page,
       '[data-testid="username-text-input"]',
       "agent@example.test",
       "app.example.test"
     );
 
-    expect(selector).toBe('[data-testid="password-text-input"]');
+    expect(result).toEqual({ state: "password", selector: '[data-testid="password-text-input"]' });
     expect(currentUrl).toContain("/ui/v2/login/password");
     expect(passwordVisible).toBe(true);
     expect(submits).toBe(1);
     expect(evaluatedAt).toEqual(["http://issuer.example.test/ui/v2/login/loginname?requestId=oidc_123"]);
   });
+
+  test("does not treat the target app password field as a ZITADEL password step", async () => {
+    const page = {
+      url: () => "https://app.example.test/",
+      locator: (selector: string) => ({
+        first() {
+          return this;
+        },
+        isVisible: async () => selector === 'input[type="password"]',
+        innerText: async () => "Ubuntu 24.04.3 LTS\nUser name\nPassword\nLog in"
+      }),
+      waitForTimeout: async () => undefined
+    } as unknown as Page;
+
+    const result = await __browserTestHooks.waitForPasswordInputAfterUsernameSubmit(
+      page,
+      '[data-testid="username-text-input"]',
+      "agent@example.test",
+      "app.example.test"
+    );
+
+    expect(result).toEqual({ state: "target" });
+  });
+
+  test("does not click a stale ZITADEL submit button after password Enter reaches the target", async () => {
+    let currentUrl = "https://issuer.example.test/ui/v2/login/password?requestId=oidc_123";
+    let clickedStaleSubmit = false;
+    const passwordInput = {
+      first() {
+        return this;
+      },
+      focus: async () => undefined,
+      press: async () => {
+        currentUrl = "https://app.example.test/";
+      },
+      isVisible: async () => currentUrl.includes("/ui/v2/login/password"),
+      isDisabled: async () => false
+    };
+    const submitButton = {
+      first() {
+        return this;
+      },
+      isVisible: async () => false,
+      isDisabled: async () => false,
+      click: async () => {
+        clickedStaleSubmit = true;
+      }
+    };
+    const page = {
+      url: () => currentUrl,
+      locator: (selector: string) => {
+        if (selector === '[data-testid="password-text-input"]') {
+          return passwordInput;
+        }
+        if (selector === '[data-testid="submit-button"]') {
+          return submitButton;
+        }
+        return {
+          first() {
+            return this;
+          },
+          isVisible: async () => false,
+          isDisabled: async () => false,
+          click: async () => {
+            clickedStaleSubmit = true;
+          }
+        };
+      },
+      waitForTimeout: async () => undefined
+    } as unknown as Page;
+
+    await __browserTestHooks.submitIdentityForm(page, '[data-testid="password-text-input"]', ['[data-testid="submit-button"]']);
+
+    expect(currentUrl).toBe("https://app.example.test/");
+    expect(clickedStaleSubmit).toBe(false);
+  });
 });

tests/integration/assertions/browser.ts

@@ -5,6 +5,7 @@ import type { OidcTestUser } from "../types";
 
 type LoginExpectation = "allow" | "deny";
 type BrowserArtifactKind = "success" | "failure";
+type PasswordWaitResult = { state: "password"; selector: string } | { state: "target" };
 
 type LoginOptions = {
   outputDir: string;
@@ -84,27 +85,33 @@ const CONSENT_SUBMIT_SELECTORS = ["Allow", "Authorize", "Approve", "Accept", "Co
   `input[type="button"][value="${label}"]`
 ]);
 
-async function waitForPasswordInputAfterUsernameSubmit(page: Page, usernameSelector: string, userEmail: string, targetHost: string): Promise<string> {
+async function waitForPasswordInputAfterUsernameSubmit(page: Page, usernameSelector: string, userEmail: string, targetHost: string): Promise<PasswordWaitResult> {
   const deadline = Date.now() + BROWSER_WAIT_TIMEOUT_MS;
   let lastResubmit = 0;
   let lastBody = "";
 
   while (Date.now() < deadline) {
-    if (isPasswordLoginStep(page.url())) {
+    const currentUrl = page.url();
+    if (isTargetApplicationPage(currentUrl, targetHost)) {
+      return { state: "target" };
+    }
+
+    if (isPasswordLoginStep(currentUrl)) {
       const selector = await visiblePasswordInputSelector(page, 5000);
       if (selector) {
-        return selector;
+        return { state: "password", selector };
       }
     }
 
-    for (const selector of PASSWORD_INPUT_SELECTORS) {
-      const locator = page.locator(selector).first();
-      if (await locatorVisible(locator)) {
-        return selector;
+    if (isIdentityLoginInputPage(currentUrl, targetHost)) {
+      for (const selector of PASSWORD_INPUT_SELECTORS) {
+        const locator = page.locator(selector).first();
+        if (await locatorVisible(locator)) {
+          return { state: "password", selector };
+        }
       }
     }
 
-    const currentUrl = page.url();
     lastBody = (await maybeWithTimeout(page.locator("body").innerText({ timeout: 1000 }).catch(() => ""), 2000)) ?? "";
     const normalizedBody = lastBody.toLowerCase();
     if (
@@ -221,6 +228,7 @@ async function resubmitUsernameIfStillOnUsernameStep(page: Page, userEmail: stri
 
 export const __browserTestHooks = {
   resubmitUsernameIfStillOnUsernameStep,
+  submitIdentityForm,
   waitForPasswordInputAfterUsernameSubmit
 };
 
@@ -270,8 +278,13 @@ async function clickFirstVisible(page: Page, selectors: string[]): Promise<boole
       (await locatorVisible(locator)) &&
       !(await locatorDisabled(locator))
     ) {
-      await locator.click({ noWaitAfter: true, timeout: BROWSER_CLICK_TIMEOUT_MS });
-      return true;
+      const clicked = await maybeWithTimeout(
+        locator.click({ noWaitAfter: true, timeout: BROWSER_CLICK_TIMEOUT_MS }).then(() => true).catch(() => false),
+        BROWSER_CLICK_TIMEOUT_MS + 1000
+      );
+      if (clicked) {
+        return true;
+      }
     }
   }
   return false;
@@ -649,7 +662,7 @@ async function submitIdentityForm(page: Page, inputSelector: string, buttonSelec
   }
 
   if (await waitForEnabledWithin(page, buttonSelectors, 1000)) {
-    await submitForm(page, buttonSelectors);
+    await clickFirstVisible(page, buttonSelectors).catch(() => false);
     await page.waitForTimeout(750);
     if (await identitySubmissionAdvanced(page, beforeUrl, inputSelector)) {
       return;
@@ -1187,11 +1200,17 @@ async function loginThroughZitadelWithContext(
         await submitIdentityForm(page, emailSelector, USERNAME_SUBMIT_SELECTORS);
 
         stage = "waiting for password input after username submit";
-        const passwordSelector = await waitForPasswordInputAfterUsernameSubmit(page, emailSelector, user.email, targetHost);
+        const passwordWait = await waitForPasswordInputAfterUsernameSubmit(page, emailSelector, user.email, targetHost);
+        if (passwordWait.state === "target") {
+          stage = `waiting for ${expected} return to target host`;
+          await waitForReturnToTargetHost(page, targetHost, user.email, expected);
+          stage = "capturing success page";
+          return await finishBrowserLogin(page, screenshotPath, options);
+        }
         stage = "entering password";
-        await typeInto(page, passwordSelector, user.password);
+        await typeInto(page, passwordWait.selector, user.password);
         stage = "submitting password";
-        await submitIdentityForm(page, passwordSelector, PASSWORD_SUBMIT_SELECTORS);
+        await submitIdentityForm(page, passwordWait.selector, PASSWORD_SUBMIT_SELECTORS);
 
         stage = `waiting for ${expected} return to target host`;
         await waitForReturnToTargetHost(page, targetHost, user.email, expected);