Parallelize client scope tests for the admin console

Closes keycloak#43379

Signed-off-by: Jon Koops <[email protected]>

Author: jonkoops

js/apps/admin-ui/test/client-scope/main.spec.ts

@@ -1,11 +1,11 @@
 import { expect, test } from "@playwright/test";
-import { v4 as uuidv4 } from "uuid";
-import adminClient from "../utils/AdminClient.ts";
+import { toClientScopes } from "../../src/client-scopes/routes/ClientScopes.tsx";
+import { toNewClientScope } from "../../src/client-scopes/routes/NewClientScope.tsx";
+import { createTestBed } from "../support/testbed.ts";
 import { assertSaveButtonIsDisabled, clickSaveButton } from "../utils/form.ts";
-import { login } from "../utils/login.ts";
+import { login, navigateTo } from "../utils/login.ts";
 import { assertNotificationMessage } from "../utils/masthead.ts";
 import { confirmModal } from "../utils/modal.ts";
-import { goToClientScopes } from "../utils/sidebar.ts";
 import {
   assertRowExists,
   assertTableRowsLength,
@@ -21,7 +21,6 @@ import {
   fillClientScopeData,
   getTableAssignedTypeColumn,
   getTableProtocolColumn,
-  goToCreateItem,
   selectChangeType,
   selectClientScopeFilter,
   selectSecondaryFilterAssignedType,
@@ -42,193 +41,178 @@ const FilterProtocol = {
   OpenID: "OpenID Connect",
 };
 
-test.describe.serial("Client Scopes test", () => {
-  const clientScopeName = "client-scope-test";
-  const itemId = `client-scope-test-${uuidv4()}`;
-  const clientScope = {
-    name: clientScopeName,
-    description: "",
-    protocol: "openid-connect",
-    attributes: {
-      "include.in.token.scope": "true",
-      "display.on.consent.screen": "true",
-      "gui.order": "1",
-      "consent.screen.text": "",
-    },
-  };
-  const placeHolder = "Search for client scope";
-  const tableName = "Client scopes";
-
-  test.beforeAll(async () => {
-    for (let i = 0; i < 5; i++) {
-      clientScope.name = clientScopeName + i;
-      await adminClient.createClientScope(clientScope);
-    }
+const placeHolder = "Search for client scope";
+const tableName = "Client scopes";
+
+test.describe("Client scopes filtering", () => {
+  test("filters item by name", async ({ page }) => {
+    await using testBed = await createTestBed({
+      clientScopes: [{ name: "test-scope" }],
+    });
+
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
+
+    await searchItem(page, placeHolder, "test-scope");
+    await assertRowExists(page, "test-scope");
+    await assertTableRowsLength(page, tableName, 1);
   });
 
-  test.afterAll(async () => {
-    for (let i = 0; i < 5; i++) {
-      if (await adminClient.existsClientScope(clientScopeName + i)) {
-        await adminClient.deleteClientScope(clientScopeName + i);
-      }
-    }
+  test("filters items by assigned type 'default'", async ({ page }) => {
+    await using testBed = await createTestBed();
+
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
+
+    await selectClientScopeFilter(page, "Assigned type");
+    await selectSecondaryFilterAssignedType(page, FilterAssignedType.Default);
+
+    const assignedTypes = await getTableAssignedTypeColumn(page, tableName);
+
+    expect(assignedTypes).toContain(FilterAssignedType.Default);
+    expect(assignedTypes).not.toContain(FilterAssignedType.Optional);
+    expect(assignedTypes).not.toContain(FilterAssignedType.None);
   });
 
-  test.describe.serial("Client Scope filter list items", () => {
-    test.beforeEach(async ({ page }) => {
-      await login(page);
-      await goToClientScopes(page);
-    });
+  test("filters items by assigned type 'optional'", async ({ page }) => {
+    await using testBed = await createTestBed();
 
-    test("should filter item by name", async ({ page }) => {
-      const itemName = clientScopeName + "0";
-      await searchItem(page, placeHolder, itemName);
-      await assertRowExists(page, itemName);
-      await assertTableRowsLength(page, tableName, 1);
-    });
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
 
-    test("should filter items by Assigned type Default", async ({ page }) => {
-      await selectClientScopeFilter(page, "Assigned type");
-      await selectSecondaryFilterAssignedType(page, FilterAssignedType.Default);
+    await selectClientScopeFilter(page, "Assigned type");
+    await selectSecondaryFilterAssignedType(page, FilterAssignedType.Optional);
 
-      const assignedTypes = await getTableAssignedTypeColumn(page, tableName);
+    const assignedTypes = await getTableAssignedTypeColumn(page, tableName);
 
-      expect(assignedTypes).toContain(FilterAssignedType.Default);
-      expect(assignedTypes).not.toContain(FilterAssignedType.Optional);
-      expect(assignedTypes).not.toContain(FilterAssignedType.None);
-    });
+    expect(assignedTypes).not.toContain(FilterAssignedType.Default);
+    expect(assignedTypes).not.toContain(FilterAssignedType.None);
+    expect(assignedTypes).toContain(FilterAssignedType.Optional);
+  });
 
-    test("should filter items by Assigned type Optional", async ({ page }) => {
-      await selectClientScopeFilter(page, "Assigned type");
-      await selectSecondaryFilterAssignedType(
-        page,
-        FilterAssignedType.Optional,
-      );
+  test("filters items by assigned type 'all'", async ({ page }) => {
+    await using testBed = await createTestBed();
 
-      const assignedTypes = await getTableAssignedTypeColumn(page, tableName);
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
 
-      expect(assignedTypes).not.toContain(FilterAssignedType.Default);
-      expect(assignedTypes).not.toContain(FilterAssignedType.None);
-      expect(assignedTypes).toContain(FilterAssignedType.Optional);
-    });
+    await selectClientScopeFilter(page, "Assigned type");
+    await selectSecondaryFilterAssignedType(page, FilterAssignedType.AllTypes);
 
-    test("should filter items by Assigned type All", async ({ page }) => {
-      await selectClientScopeFilter(page, "Assigned type");
-      await selectSecondaryFilterAssignedType(
-        page,
-        FilterAssignedType.AllTypes,
-      );
+    const assignedTypes = await getTableAssignedTypeColumn(page, tableName);
 
-      const assignedTypes = await getTableAssignedTypeColumn(page, tableName);
+    expect(assignedTypes).toContain(FilterAssignedType.Default);
+    expect(assignedTypes).toContain(FilterAssignedType.Optional);
+  });
 
-      expect(assignedTypes).toContain(FilterAssignedType.Default);
-      expect(assignedTypes).toContain(FilterAssignedType.Optional);
-      expect(assignedTypes).toContain(FilterAssignedType.None);
-    });
+  test("filters items by protocol 'openid'", async ({ page }) => {
+    await using testBed = await createTestBed();
 
-    test("should filter items by Protocol OpenID", async ({ page }) => {
-      await selectClientScopeFilter(page, "Protocol");
-      await selectSecondaryFilterProtocol(page, FilterProtocol.OpenID);
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
 
-      const protocols = await getTableProtocolColumn(page, tableName);
+    await selectClientScopeFilter(page, "Protocol");
+    await selectSecondaryFilterProtocol(page, FilterProtocol.OpenID);
 
-      expect(protocols).not.toContain(FilterProtocol.SAML);
-      expect(protocols).toContain(FilterProtocol.OpenID);
-    });
+    const protocols = await getTableProtocolColumn(page, tableName);
 
-    test("should filter items by Protocol SAML", async ({ page }) => {
-      await selectClientScopeFilter(page, "Protocol");
-      await selectSecondaryFilterProtocol(page, FilterProtocol.SAML);
+    expect(protocols).not.toContain(FilterProtocol.SAML);
+    expect(protocols).toContain(FilterProtocol.OpenID);
+  });
 
-      const protocols = await getTableProtocolColumn(page, tableName);
+  test("filters items by protocol 'saml'", async ({ page }) => {
+    await using testBed = await createTestBed();
 
-      expect(protocols).toContain(FilterProtocol.SAML);
-      expect(protocols).not.toContain(FilterProtocol.OpenID);
-    });
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
 
-    test("should show items on next page are more than 11", async ({
-      page,
-    }) => {
-      await clickNextPageButton(page);
-      const rows = await getTableData(page, tableName);
-      expect(rows.length).toBeGreaterThan(1);
-    });
+    await selectClientScopeFilter(page, "Protocol");
+    await selectSecondaryFilterProtocol(page, FilterProtocol.SAML);
+
+    const protocols = await getTableProtocolColumn(page, tableName);
+
+    expect(protocols).toContain(FilterProtocol.SAML);
+    expect(protocols).not.toContain(FilterProtocol.OpenID);
   });
 
-  test.describe.serial("Client Scope modify list items", () => {
-    test.beforeEach(async ({ page }) => {
-      await login(page);
-      await goToClientScopes(page);
-    });
+  test("shows items on next page are more than 11", async ({ page }) => {
+    await using testBed = await createTestBed();
 
-    test("should modify selected item type to Default", async ({ page }) => {
-      const itemName = clientScopeName + "0";
-      await clickSelectRow(page, tableName, itemName);
-      await selectChangeType(page, FilterAssignedType.Default);
-      await assertNotificationMessage(page, "Scope mapping updated");
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
 
-      const rows = await getTableData(page, tableName);
-      const itemRow = rows.find((r) => r.includes(itemName));
-      expect(itemRow).toContain(FilterAssignedType.Default);
-    });
+    await clickNextPageButton(page);
+    const rows = await getTableData(page, tableName);
+    expect(rows.length).toBeGreaterThan(1);
   });
+});
 
-  test.describe.serial("Client Scope creation", () => {
-    test.beforeEach(async ({ page }) => {
-      await login(page);
-      await goToClientScopes(page);
+test.describe("Client scopes modification", () => {
+  test("modifies selected item type to 'default'", async ({ page }) => {
+    await using testBed = await createTestBed({
+      clientScopes: [{ name: "test-scope" }],
     });
 
-    test("should fail creating client scope", async ({ page }) => {
-      await goToCreateItem(page);
-      await assertSaveButtonIsDisabled(page);
+    await login(page, { to: toClientScopes({ realm: testBed.realm }) });
 
-      await fillClientScopeData(page, "address");
-      await page.getByTestId("save").click();
+    await clickSelectRow(page, tableName, "test-scope");
+    await selectChangeType(page, FilterAssignedType.Default);
+    await assertNotificationMessage(page, "Scope mapping updated");
 
-      await assertNotificationMessage(
-        page,
-        "Could not create client scope: 'Client Scope address already exists'",
-      );
+    const rows = await getTableData(page, tableName);
+    const itemRow = rows.find((r) => r.includes("test-scope"));
+    expect(itemRow).toContain(FilterAssignedType.Default);
+  });
+});
 
-      await fillClientScopeData(page, "");
-      await expect(page.getByTestId("save")).toBeDisabled();
-    });
+test.describe("Client scopes creation", () => {
+  test("fails creating client scope with an existing name", async ({
+    page,
+  }) => {
+    await using testBed = await createTestBed();
+
+    await login(page, { to: toNewClientScope({ realm: testBed.realm }) });
 
-    test("hides 'consent text' field when 'display consent' switch is disabled", async ({
+    await assertSaveButtonIsDisabled(page);
+
+    await fillClientScopeData(page, "address");
+    await page.getByTestId("save").click();
+
+    await assertNotificationMessage(
       page,
-    }) => {
-      await goToCreateItem(page);
+      "Could not create client scope: 'Client Scope address already exists'",
+    );
 
-      await assertSwitchDisplayOnConsentScreenIsChecked(page);
-      await assertConsentInputIsVisible(page);
+    await fillClientScopeData(page, "");
+    await expect(page.getByTestId("save")).toBeDisabled();
+  });
 
-      await switchOffDisplayOnConsentScreen(page);
+  test("hides 'consent text' field when 'display consent' switch is disabled", async ({
+    page,
+  }) => {
+    await using testBed = await createTestBed();
 
-      await assertConsentInputIsVisible(page, true);
-    });
+    await login(page, { to: toNewClientScope({ realm: testBed.realm }) });
 
-    test("Client scope CRUD test", async ({ page }) => {
-      await assertRowExists(page, itemId, false);
-      await goToCreateItem(page);
+    await assertSwitchDisplayOnConsentScreenIsChecked(page);
+    await assertConsentInputIsVisible(page);
 
-      await fillClientScopeData(page, itemId);
-      await clickSaveButton(page);
+    await switchOffDisplayOnConsentScreen(page);
 
-      await assertNotificationMessage(page, "Client scope created");
+    await assertConsentInputIsVisible(page, true);
+  });
 
-      await goToClientScopes(page);
+  test("creates and deletes a client scope", async ({ page }) => {
+    const itemId = "test-scope";
+    await using testBed = await createTestBed();
 
-      await searchItem(page, placeHolder, itemId);
-      await assertRowExists(page, itemId);
-      await clickRowKebabItem(page, itemId, "Delete");
+    await login(page, { to: toNewClientScope({ realm: testBed.realm }) });
+    await fillClientScopeData(page, itemId);
+    await clickSaveButton(page);
 
-      await confirmModal(page);
-      await assertNotificationMessage(
-        page,
-        "The client scope has been deleted",
-      );
-      await assertRowExists(page, itemId, false);
-    });
+    await assertNotificationMessage(page, "Client scope created");
+
+    await navigateTo(page, toClientScopes({ realm: testBed.realm }));
+
+    await searchItem(page, placeHolder, itemId);
+    await assertRowExists(page, itemId);
+    await clickRowKebabItem(page, itemId, "Delete");
+
+    await confirmModal(page);
+    await assertNotificationMessage(page, "The client scope has been deleted");
+    await assertRowExists(page, itemId, false);
   });
 });