Client : E2E Tests : Created User Accounts edit tests

Author: Rad14nt

client/tests/e2e/1-user-account/3.1-update-edit.spec.ts

@@ -0,0 +1,126 @@
+import { expect, Page, test, TestInfo } from "@playwright/test";
+import { loginAsServerAdmin } from "../utils/authenticate";
+import { addBrowserSuffixToText } from "../utils/helpers";
+import { PlaywrightUserAccountsPage } from "./models/playwright-user-accounts-page";
+
+test.describe("1.3.1 User Accounts - UPDATE Edit", () => {
+    let userAccountsPage: PlaywrightUserAccountsPage;
+
+    async function openEditUserForTest(
+        page: Page,
+        testInfo: TestInfo,
+        baseUuid: string,
+        baseLastName: string,
+    ) {
+        const suffix = testInfo.project.name.toLowerCase();
+        const uuid = addBrowserSuffixToText(baseUuid, testInfo);
+        const lastName = addBrowserSuffixToText(baseLastName, testInfo);
+
+        await userAccountsPage.search(lastName, page);
+        const userAccountPage = await userAccountsPage.clickEditIcon(uuid);
+
+        await userAccountPage.expectVisible();
+        await userAccountPage.expectStillOnEditPage(uuid);
+
+        await userAccountPage.expectFormLoaded({
+            name: "Institutional",
+            surname: lastName,
+            email: `inst-admin-${baseLastName}-${suffix}@nomail.nomail`,
+        });
+
+        return { userAccountPage, uuid, lastName };
+    }
+
+    test.beforeEach(async ({ page }) => {
+        await loginAsServerAdmin(page);
+
+        userAccountsPage = new PlaywrightUserAccountsPage(page);
+        await userAccountsPage.goto();
+        await userAccountsPage.expectVisible();
+    });
+
+    test("A Success", async ({ page }, testInfo) => {
+        const { userAccountPage } = await openEditUserForTest(
+            page,
+            testInfo,
+            "seb-user-account-edit-a",
+            "testedit-a",
+        );
+
+        const unique = `e2e-1.3.A-${Date.now()}`;
+
+        await userAccountPage.fillEditForm({
+            name: `${unique}-Name`,
+            surname: `${unique}-Surname`,
+            username: `${unique}-Username`,
+            email: `${unique}@email.com`,
+            pickFirstTimezone: true,
+            roleName: "Exam Administrator",
+        });
+
+        await userAccountPage.toggleStatusChip();
+
+        await expect(userAccountPage.saveChangesButton).toBeEnabled();
+
+        await userAccountPage.expectEditRequestSucceeded(async () => {
+            await userAccountPage.submitSaveChanges();
+        });
+
+        await userAccountPage.expectRedirectToUserAccounts();
+    });
+
+    test("B Validation Failure", async ({ page }, testInfo) => {
+        const REQUIRED = "This field is required";
+
+        const { userAccountPage, uuid } = await openEditUserForTest(
+            page,
+            testInfo,
+            "seb-user-account-edit-b",
+            "testedit-b",
+        );
+
+        await userAccountPage.fillEditForm({
+            name: "",
+            surname: "",
+            username: "",
+        });
+
+        await userAccountPage.expectNoEditRequest(async () => {
+            await userAccountPage.submitSaveChanges();
+        });
+
+        await userAccountPage.expectRequiredFieldErrors({
+            name: REQUIRED,
+            surname: REQUIRED,
+            username: REQUIRED,
+        });
+
+        await userAccountPage.expectStillOnEditPage(uuid);
+    });
+
+    test("C Server Error - duplicate username", async ({ page }, testInfo) => {
+        const { userAccountPage, uuid } = await openEditUserForTest(
+            page,
+            testInfo,
+            "seb-user-account-edit-c",
+            "testedit-c",
+        );
+
+        await userAccountPage.fillEditForm({
+            username: "createtests",
+        });
+
+        await userAccountPage.expectEditRequestFailed({
+            action: async () => {
+                await userAccountPage.submitSaveChanges();
+            },
+        });
+
+        await userAccountPage.expectErrorToast([
+            "Field validation error",
+            "Username is already being used.",
+        ]);
+
+        await userAccountPage.expectStillOnEditPage(uuid);
+    });
+});

client/tests/e2e/1-user-account/models/playwright-user-account-page.ts

@@ -273,6 +273,21 @@ export class PlaywrightUserAccountPage {
         if (params.email !== undefined) await this.fillEmail(params.email);
     }
 
+    async expectFormLoaded(expected: {
+        name: string;
+        surname: string;
+        email: string;
+    }) {
+        await expect(this.name).toHaveValue(expected.name, { timeout: 10_000 });
+        await expect(this.surname).toHaveValue(expected.surname, {
+            timeout: 10_000,
+        });
+
+        await expect(this.email).toHaveValue(expected.email, {
+            timeout: 10_000,
+        });
+    }
+
     // ------------------------
     // Validation assertions
     // ------------------------
@@ -282,9 +297,13 @@ export class PlaywrightUserAccountPage {
     }
 
     async expectFieldError(testId: string, text: string) {
-        await expect(this.fieldError(testId, text)).toHaveCount(1, {
-            timeout: 5_000,
-        });
+        await expect(
+            this.page
+                .getByTestId(testId)
+                .locator(".v-messages__message")
+                .filter({ hasText: text })
+                .first(),
+        ).toBeVisible({ timeout: 5_000 });
     }
 
     async expectRequiredFieldErrors(errors: {
@@ -394,6 +413,23 @@ export class PlaywrightUserAccountPage {
         });
     }
 
+    async expectEditRequestFailed(params: {
+        action: () => Promise<void>;
+        expectedStatus?: number;
+        expectedStatuses?: number[];
+    }) {
+        const expectedStatuses = params.expectedStatuses ?? [
+            params.expectedStatus ?? 400,
+        ];
+
+        const resp = await this.captureEditResponse(params.action);
+
+        expect(expectedStatuses).toContain(resp.status());
+        expect(resp.ok()).toBeFalsy();
+
+        return resp;
+    }
+
     async expectStatusToggleRequestSucceeded(action: () => Promise<void>) {
         await expectRequestSucceeded({
             page: this.page,

client/tests/e2e/1-user-account/models/playwright-user-accounts-page.ts

@@ -191,9 +191,11 @@ export class PlaywrightUserAccountsPage {
         await this.cancelButton.click();
     }
 
-    async search(value: string) {
+    async search(value: string, page: Page) {
+        await page.waitForTimeout(500);
         await this.fillSearch(value);
         await this.searchByButton();
+        await page.waitForTimeout(500);
     }
 
     statusChipFilter(status: "Active" | "Inactive"): Locator {