pomwright 1.5.1 → 2.0.0

package/intTestV2/tests/locatorRegistry/add/add.spec.ts

@@ -1,159 +0,0 @@
-import { expect, test } from "@fixtures-v2/testApp.fixtures";
-import type { Page } from "@playwright/test";
-import { LocatorRegistryInternal } from "../../../../srcV2/locators";
-
-const createTestRegistry = <Paths extends string>(page: Page) => new LocatorRegistryInternal<Paths>(page);
-
-test("add regex-driven getBy* registrations to registry", async ({ page }) => {
-	type LocatorSchemaPaths =
-		| "regex.text"
-		| "regex.label"
-		| "regex.placeholder"
-		| "regex.altText"
-		| "regex.title"
-		| "regex.reuse.text"
-		| "regex.reusePath.text";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("regex.text").getByText(/Welcome/i);
-	registry.add("regex.label").getByLabel(/Username/i);
-	registry.add("regex.placeholder").getByPlaceholder(/Enter your name/i);
-	registry.add("regex.altText").getByAltText(/Sample Image/i);
-	registry.add("regex.title").getByTitle(/Home Page/i);
-
-	const reusableText = registry.createReusable.getByText(/Seeded/i);
-	registry.add("regex.reuse.text", { reuse: reusableText }).getByText({ exact: true });
-	registry.add("regex.reusePath.text", { reuse: "regex.text" });
-
-	expect(registry.get("regex.text")).toEqual({
-		definition: { text: /Welcome/i, type: "text" },
-		locatorSchemaPath: "regex.text",
-		steps: [],
-	});
-	expect(registry.get("regex.label")).toEqual({
-		definition: { text: /Username/i, type: "label" },
-		locatorSchemaPath: "regex.label",
-		steps: [],
-	});
-	expect(registry.get("regex.placeholder")).toEqual({
-		definition: { text: /Enter your name/i, type: "placeholder" },
-		locatorSchemaPath: "regex.placeholder",
-		steps: [],
-	});
-	expect(registry.get("regex.altText")).toEqual({
-		definition: { text: /Sample Image/i, type: "altText" },
-		locatorSchemaPath: "regex.altText",
-		steps: [],
-	});
-	expect(registry.get("regex.title")).toEqual({
-		definition: { text: /Home Page/i, type: "title" },
-		locatorSchemaPath: "regex.title",
-		steps: [],
-	});
-	expect(registry.get("regex.reuse.text")).toEqual({
-		definition: { text: /Seeded/i, options: { exact: true }, type: "text" },
-		locatorSchemaPath: "regex.reuse.text",
-		steps: [],
-	});
-	expect(registry.get("regex.reusePath.text")).toEqual({
-		definition: { text: /Welcome/i, type: "text" },
-		locatorSchemaPath: "regex.reusePath.text",
-		steps: [],
-	});
-});
-
-test("add prevents multiple locator type definitions", async ({ page }) => {
-	type LocatorSchemaPaths = "heading";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	const builder = registry.add("heading").getByRole("heading", { level: 2 });
-
-	expect((builder as { getByText?: unknown }).getByText).toBeUndefined();
-
-	builder.filter({ hasText: "Heading" }).nth(0);
-});
-
-test("add typing narrows locator methods after a definition is chosen", async ({ page }) => {
-	type LocatorSchemaPaths = "heading";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-	const postDefinition = registry.add("heading").getByRole("heading", { level: 2 });
-
-	// @ts-expect-error additional locator methods are not exposed after a definition is set
-	const _invalidLocatorMethod = postDefinition.getByText;
-
-	postDefinition.filter({ hasText: "Heading" }).nth(0);
-});
-
-test("A LocatorSchemaPath can only be added once", async ({ page }) => {
-	type LocatorSchemaPaths = "body";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("body").locator("body");
-
-	const errMsg = /A locator schema with the path "body" already exists*/;
-
-	expect(() => registry.add("body").locator("someone elses body")).toThrowError(errMsg);
-});
-
-test("add getByRole overloads accept optional options and support chained steps", async ({ page }) => {
-	type LocalPath = "root" | "root.options" | "root.minimal";
-	const registry = new LocatorRegistryInternal<LocalPath>(page);
-
-	registry.add("root").locator("body");
-
-	registry.add("root.options").getByRole("button", { name: "opts" }).filter({ hasText: "filtered" }).nth("last");
-	registry.add("root.minimal").getByRole("button");
-
-	expect(registry.get("root.options")).toEqual({
-		locatorSchemaPath: "root.options",
-		definition: { type: "role", role: "button", options: { name: "opts" } },
-		steps: [
-			{ kind: "filter", filter: { hasText: "filtered" } },
-			{ kind: "index", index: "last" },
-		],
-	});
-
-	expect(registry.get("root.minimal")).toEqual({
-		locatorSchemaPath: "root.minimal",
-		definition: { type: "role", role: "button" },
-		steps: [],
-	});
-});
-
-test("add overloads support other strategies with options and chained steps", async ({ page }) => {
-	type LocalPath = "root.text" | "root.locator" | "root.frame";
-
-	const registry = new LocatorRegistryInternal<LocalPath>(page);
-
-	registry.add("root.text").getByText("needle", { exact: true }).filter({ hasText: "filtered" }).nth(0);
-	registry.add("root.locator").locator(".selector", { hasText: "opt" }).filter({ hasText: "filtered" }).nth(0);
-	registry.add("root.frame").frameLocator("iframe[name=child]");
-
-	expect(registry.get("root.text")).toEqual({
-		locatorSchemaPath: "root.text",
-		definition: { type: "text", text: "needle", options: { exact: true } },
-		steps: [
-			{ kind: "filter", filter: { hasText: "filtered" } },
-			{ kind: "index", index: 0 },
-		],
-	});
-
-	expect(registry.get("root.locator")).toEqual({
-		locatorSchemaPath: "root.locator",
-		definition: { type: "locator", selector: ".selector", options: { hasText: "opt" } },
-		steps: [
-			{ kind: "filter", filter: { hasText: "filtered" } },
-			{ kind: "index", index: 0 },
-		],
-	});
-
-	expect(registry.get("root.frame")).toEqual({
-		locatorSchemaPath: "root.frame",
-		definition: { type: "frameLocator", selector: "iframe[name=child]" },
-		steps: [],
-	});
-});

package/intTestV2/tests/locatorRegistry/filter.cycle.spec.ts

@@ -1,39 +0,0 @@
-import { expect, test } from "@fixtures-v2/testApp.fixtures";
-import type { Page } from "@playwright/test";
-import { LocatorRegistryInternal } from "../../../srcV2/locators";
-
-const createTestRegistry = <Paths extends string>(page: Page) => new LocatorRegistryInternal<Paths>(page);
-
-test("filter cycle detection throws on direct self-reference", async ({ page }) => {
-	type LocatorSchemaPaths = "main.h1";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("main.h1").getByRole("heading", { level: 1 }).filter({ has: "main.h1" });
-
-	expect(() => registry.getLocator("main.h1")).toThrow(/resolving "main\.h1": "main\.h1"/);
-});
-
-test("filter cycle detection throws on indirect reference loops", async ({ page }) => {
-	type LocatorSchemaPaths = "a" | "b";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("a").getByRole("button").filter({ has: "b" });
-	registry.add("b").getByRole("button").filter({ has: "a" });
-
-	expect(() => registry.getLocator("a")).toThrow(/resolving "a": "b"/);
-});
-
-test("filter cycle detection allows repeated non-cyclic references", async ({ page }) => {
-	type LocatorSchemaPaths = "a" | "a.b" | "shared.heading";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("shared.heading").getByRole("heading", { level: 2 });
-	registry.add("a").getByRole("button").filter({ has: "shared.heading" });
-	registry.add("a.b").getByRole("button").filter({ has: "shared.heading" });
-
-	expect(() => registry.getLocator("a")).not.toThrow();
-	expect(() => registry.getLocator("a.b")).not.toThrow();
-});

package/intTestV2/tests/locatorRegistry/getLocator/getLocator.spec.ts

@@ -1,253 +0,0 @@
-import { expect, test } from "@fixtures-v2/testApp.fixtures";
-import type { Page } from "@playwright/test";
-import { LocatorRegistryInternal } from "../../../../srcV2/locators";
-
-const createTestRegistry = <Paths extends string>(page: Page) => new LocatorRegistryInternal<Paths>(page);
-
-test("getLocator resolves the terminal locator when ancestor paths are registered", async ({ page }) => {
-	type LocatorSchemaPaths =
-		| "topMenu"
-		| "topMenu.notifications"
-		| "topMenu.notifications.dropdown"
-		| "topMenu.notifications.dropdown.item";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("topMenu").locator(".w3-top");
-	registry.add("topMenu.notifications").locator(".w3-dropdown-hover");
-	registry.add("topMenu.notifications.dropdown").locator(".w3-dropdown-content");
-	registry.add("topMenu.notifications.dropdown.item").locator(".w3-bar-item");
-
-	const locator = registry.getLocator("topMenu.notifications.dropdown.item");
-	const chained = page
-		.locator(".w3-top")
-		.locator(".w3-dropdown-hover")
-		.locator(".w3-dropdown-content")
-		.locator(".w3-bar-item");
-
-	expect(`${locator}`).toEqual("locator('.w3-bar-item')");
-	expect(`${locator}`).not.toEqual(`${chained}`);
-});
-
-test("getLocator uses terminal steps while ignoring ancestor filters", async ({ page }) => {
-	type LocatorSchemaPaths = "panel" | "panel.row" | "panel.row.button";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("panel").locator("section.panel").filter({ hasText: "panel" }).nth(2);
-	registry.add("panel.row").locator("div.row").filter({ hasText: "row" });
-	registry.add("panel.row.button").getByRole("button", { name: "Save" }).filter({ hasText: "terminal" });
-
-	const locator = registry.getLocator("panel.row.button");
-
-	expect(`${locator}`).toEqual("getByRole('button', { name: 'Save' }).filter({ hasText: 'terminal' })");
-});
-
-test("getLocator returns a fresh locator each time", async ({ page }) => {
-	type LocatorSchemaPaths = "button";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("button").getByRole("button", { name: "Submit" });
-
-	const first = registry.getLocator("button");
-	const second = registry.getLocator("button");
-
-	expect(first).not.toBe(second);
-	expect(`${first}`).toEqual(`${second}`);
-});
-
-test.describe("getLocator applies terminal filters for registered definitions", () => {
-	const cases = [
-		{
-			label: "role",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByRole("button").filter({ hasText: "filtered" }),
-			expected: "getByRole('button').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "text",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByText("text").filter({ hasText: "filtered" }),
-			expected: "getByText('text').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "label",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByLabel("label").filter({ hasText: "filtered" }),
-			expected: "getByLabel('label').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "placeholder",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByPlaceholder("placeholder").filter({ hasText: "filtered" }),
-			expected: "getByPlaceholder('placeholder').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "altText",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByAltText("altText").filter({ hasText: "filtered" }),
-			expected: "getByAltText('altText').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "title",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByTitle("title").filter({ hasText: "filtered" }),
-			expected: "getByTitle('title').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "locator",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").locator("locator").filter({ hasText: "filtered" }),
-			expected: "locator('locator').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "testId",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getByTestId("testId").filter({ hasText: "filtered" }),
-			expected: "getByTestId('testId').filter({ hasText: 'filtered' })",
-		},
-		{
-			label: "id",
-			build: (registry: LocatorRegistryInternal<"terminal">) =>
-				registry.add("terminal").getById("unique-id").filter({ hasText: "filtered" }),
-			expected: "locator('#unique-id').filter({ hasText: 'filtered' })",
-		},
-	];
-
-	for (const { label, build, expected } of cases) {
-		test(`definition ${label}: applies terminal filters`, async ({ page }) => {
-			const registry = createTestRegistry<"terminal">(page);
-
-			build(registry);
-
-			const locator = registry.getLocator("terminal");
-			expect(`${locator}`).toEqual(expected);
-		});
-	}
-});
-
-test("getLocator returns frame locators without chaining ancestor filters", async ({ page }) => {
-	type LocatorSchemaPaths = "frame";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("frame").frameLocator('iframe[title="name"]');
-
-	const locator = registry.getLocator("frame");
-	const manual = page.frameLocator('iframe[title="name"]').owner();
-
-	expect(`${locator}`).toEqual(`${manual}`);
-});
-
-test("getLocator ignores filter options when all values are undefined", async ({ page }) => {
-	type LocatorSchemaPaths = "fictional.filter@optionsUndefined";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry
-		.add("fictional.filter@optionsUndefined")
-		.getByRole("button")
-		.filter({ has: undefined, hasNot: undefined, hasText: undefined, hasNotText: undefined });
-
-	const locator = registry.getLocator("fictional.filter@optionsUndefined");
-
-	expect(`${locator}`).toEqual("getByRole('button')");
-});
-
-test("getLocator applies terminal indices", async ({ page }) => {
-	type LocatorSchemaPaths =
-		| "fictional.filter@hasNotText"
-		| "fictional.filter@hasNotText.filter@hasText"
-		| "fictional.filter@hasNotText.filter@hasText.filter@hasNotText"
-		| "fictional.filter@hasNotText.filter@hasText.filter@hasNotText.filter@hasText";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("fictional.filter@hasNotText").getByRole("button").filter({ hasNotText: "hasNotText" }).nth(2);
-	registry.add("fictional.filter@hasNotText.filter@hasText").getByRole("button").filter({ hasText: "hasText" });
-	registry
-		.add("fictional.filter@hasNotText.filter@hasText.filter@hasNotText")
-		.getByRole("button")
-		.filter({ hasNotText: "hasNotText" });
-	registry
-		.add("fictional.filter@hasNotText.filter@hasText.filter@hasNotText.filter@hasText")
-		.getByRole("button")
-		.filter({ hasText: "hasText" })
-		.nth(2);
-
-	const locator = registry.getLocator("fictional.filter@hasNotText.filter@hasText.filter@hasNotText.filter@hasText");
-
-	expect(`${locator}`).toEqual("getByRole('button').filter({ hasText: 'hasText' }).nth(2)");
-});
-
-test("getLocator honors terminal filter and index ordering", async ({ page }) => {
-	type LocatorSchemaPaths = "fictional.filter@hasText";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry
-		.add("fictional.filter@hasText")
-		.getByRole("button")
-		.filter({ hasText: "hasText" })
-		.filter({ hasText: "extra" })
-		.nth(1)
-		.filter({ hasNotText: "tail" });
-
-	const locator = registry.getLocator("fictional.filter@hasText");
-
-	expect(`${locator}`).toEqual(
-		"getByRole('button').filter({ hasText: 'hasText' }).filter({ hasText: 'extra' }).nth(1).filter({ hasNotText: 'tail' })",
-	);
-});
-
-test("getLocator supports explicit last() selection for the terminal path", async ({ page }) => {
-	type LocatorSchemaPaths = "fictional.filter@hasText";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("fictional.filter@hasText").getByRole("button").filter({ hasText: "hasText" }).nth("last");
-
-	const locator = registry.getLocator("fictional.filter@hasText");
-
-	expect(`${locator}`).toEqual("getByRole('button').filter({ hasText: 'hasText' }).last()");
-});
-
-test('getLocator accepts "first" and "last" selections for terminal indices', async ({ page }) => {
-	type LocatorSchemaPaths = "fictional.filter@hasText";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-	registry.add("fictional.filter@hasText").getByRole("button").filter({ hasText: "hasText" }).nth("first");
-
-	const first = registry.getLocator("fictional.filter@hasText");
-	expect(`${first}`).toContain("first()");
-
-	const secondRegistry = createTestRegistry<LocatorSchemaPaths>(page);
-	secondRegistry.add("fictional.filter@hasText").getByRole("button").filter({ hasText: "hasText" }).nth("last");
-
-	const last = secondRegistry.getLocator("fictional.filter@hasText");
-	expect(`${last}`).toContain("last()");
-});
-
-test("getLocator rejects missing terminal paths", async ({ page }) => {
-	type LocatorSchemaPaths = "fictional.filter@hasText";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-	registry.add("fictional.filter@hasText").getByRole("button");
-
-	// @ts-expect-error Testing invalid argument
-	expect(() => registry.getLocator("fictional")).toThrow('No locator schema registered for path "fictional".');
-});
-
-test("getLocator rejects partially matching paths", async ({ page }) => {
-	type LocatorSchemaPaths = "fictional.filter@hasNotText.filter@hasText.filter@hasNotText.filter@hasText";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("fictional.filter@hasNotText.filter@hasText.filter@hasNotText.filter@hasText").getByRole("button");
-
-	// @ts-expect-error Testing invalid argument
-	expect(() => registry.getLocator("fictional.filter@has")).toThrow(
-		'No locator schema registered for path "fictional.filter@has".',
-	);
-});

package/intTestV2/tests/locatorRegistry/getLocatorSchema/getLocatorSchema.clearSteps.spec.ts

@@ -1,105 +0,0 @@
-import { expect, test } from "@fixtures-v2/testApp.fixtures";
-
-const terminalPath = "body.section.button" as const;
-
-test("clearSteps clears existing filters for a sub-path", async ({ testFilters }) => {
-	const schema = testFilters.getLocatorSchema("fictional.filter@hasText");
-
-	const original = schema.getNestedLocator();
-	expect(`${original}`).toEqual("getByRole('button').filter({ hasText: 'hasText' })");
-
-	const noFilters = schema.clearSteps("fictional.filter@hasText").getNestedLocator();
-	expect(`${noFilters}`).toEqual("getByRole('button')");
-});
-
-test("clearSteps allows re-adding filters after clearing filters added through filter", async ({ testFilters }) => {
-	const original = testFilters.getNestedLocator("fictional.filter@hasText");
-	expect(`${original}`).toEqual("getByRole('button').filter({ hasText: 'hasText' })");
-
-	const locator = testFilters
-		.getLocatorSchema("fictional.filter@hasText")
-		.filter("fictional.filter@hasText", { hasText: "this filter will be removed" })
-		.clearSteps("fictional.filter@hasText")
-		.filter("fictional.filter@hasText", { hasText: /Re-added/i })
-		.getNestedLocator();
-
-	expect(`${locator}`).toEqual("getByRole('button').filter({ hasText: /Re-added/i })");
-});
-
-test("clearSteps does not remove filters defined via locator options", async ({ testFilters }) => {
-	const locator = testFilters
-		.getLocatorSchema("body.section@playground")
-		.clearSteps("body.section@playground")
-		.getNestedLocator();
-
-	expect(`${locator}`).toEqual("locator('body').locator('section').filter({ hasText: /Playground/i })");
-});
-
-test("filter resolves path string and locator references after clearing steps", async ({ testFilters }) => {
-	const locator = testFilters
-		.getLocatorSchema("fictional.filter@hasNotText")
-		.clearSteps("fictional.filter@hasNotText")
-		.filter("fictional.filter@hasNotText", { has: "body.section.heading" })
-		.filter("fictional.filter@hasNotText", { hasNot: testFilters.page.locator(".missing") })
-		.getNestedLocator();
-
-	expect(`${locator}`).toEqual(
-		"getByRole('button').filter({ has: getByRole('heading', { level: 2 }) }).filter({ hasNot: locator('.missing') })",
-	);
-});
-
-test("nth defaults to the terminal path when subPath is omitted", async ({ testFilters }) => {
-	const explicit = testFilters.getLocatorSchema(terminalPath).nth(terminalPath, 0).getNestedLocator();
-	const implicit = testFilters.getLocatorSchema(terminalPath).nth(0).getNestedLocator();
-
-	expect(`${explicit}`).toEqual("locator('body').locator('section').getByRole('button').first()");
-	expect(`${implicit}`).toEqual(`${explicit}`);
-});
-
-test("filter defaults to the terminal path when subPath is omitted", async ({ testFilters }) => {
-	const explicit = testFilters
-		.getLocatorSchema(terminalPath)
-		.filter(terminalPath, { hasText: /click/i })
-		.getNestedLocator();
-	const implicit = testFilters.getLocatorSchema(terminalPath).filter({ hasText: /click/i }).getNestedLocator();
-
-	expect(`${explicit}`).toEqual("locator('body').locator('section').getByRole('button').filter({ hasText: /click/i })");
-	expect(`${implicit}`).toEqual(`${explicit}`);
-});
-
-test("clearSteps defaults to the terminal path when subPath is omitted", async ({ testFilters }) => {
-	const locator = testFilters
-		.getLocatorSchema(terminalPath)
-		.filter({ hasText: /click/i })
-		.nth(1)
-		.clearSteps()
-		.getNestedLocator();
-
-	expect(`${locator}`).toEqual("locator('body').locator('section').getByRole('button')");
-});
-
-test("update defaults to the terminal path when subPath is omitted", async ({ testFilters }) => {
-	const updated = testFilters.getLocatorSchema(terminalPath).update().getByRole({ name: "Reset Color" }).getLocator();
-
-	expect(`${updated}`).toEqual("getByRole('button', { name: 'Reset Color' })");
-});
-
-test("replace defaults to the terminal path when subPath is omitted", async ({ testFilters }) => {
-	const locator = testFilters
-		.getLocatorSchema(terminalPath)
-		.replace()
-		.locator("button.replace", { hasText: /Replace/ })
-		.getNestedLocator();
-
-	expect(`${locator}`).toEqual(
-		"locator('body').locator('section').locator('button.replace').filter({ hasText: /Replace/ })",
-	);
-});
-
-test("remove defaults to the terminal path when subPath is omitted", async ({ testFilters }) => {
-	const builder = testFilters.getLocatorSchema(terminalPath).remove();
-
-	await expect(async () => builder.getNestedLocator()).rejects.toThrow(
-		'No locator schema registered for path "body.section.button".',
-	);
-});

package/intTestV2/tests/locatorRegistry/getLocatorSchema/getLocatorSchema.describe.spec.ts

@@ -1,23 +0,0 @@
-import { expect, test } from "@fixtures-v2/testApp.fixtures";
-import type { Page } from "@playwright/test";
-import { LocatorRegistryInternal } from "../../../../srcV2/locators";
-
-const createTestRegistry = <Paths extends string>(page: Page) => new LocatorRegistryInternal<Paths>(page);
-
-test("describe on locator schema builder overrides the resolved description only", async ({ page }) => {
-	type LocatorSchemaPaths = "panel";
-
-	const registry = createTestRegistry<LocatorSchemaPaths>(page);
-
-	registry.add("panel").locator("section.panel").describe("Original panel");
-
-	const locator = registry.getLocatorSchema("panel").describe("Override panel").getLocator();
-
-	expect(locator.description()).toEqual("Override panel");
-	expect(registry.get("panel")).toEqual({
-		description: "Original panel",
-		definition: { selector: "section.panel", type: "locator" },
-		locatorSchemaPath: "panel",
-		steps: [],
-	});
-});