Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Parallelize client scope tests for the admin console #43675

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
+217 −340
Open

Parallelize client scope tests for the admin console #43675

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
284 changes: 134 additions & 150 deletions js/apps/admin-ui/test/client-scope/main.spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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,
Expand All @@ -21,7 +21,6 @@ import {
fillClientScopeData,
getTableAssignedTypeColumn,
getTableProtocolColumn,
goToCreateItem,
selectChangeType,
selectClientScopeFilter,
selectSecondaryFilterAssignedType,
Expand All @@ -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);
});
});
Loading
Loading