@microsoft/fast-test-harness 0.1.0 → 0.3.0

package/dist/esm/build/generate-templates.test.js

@@ -1,231 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { installDomShim } from "@microsoft/fast-test-harness/build/dom-shim.js";
-import { convertTemplate, generateFTemplates, } from "@microsoft/fast-test-harness/build/generate-templates.js";
-import { generateWebuiTemplates } from "@microsoft/fast-test-harness/build/generate-webui-templates.js";
-test.describe("convertTemplate", async () => {
-    // Install the DOM shim before any tests — convertTemplate needs fast-html
-    // syntax constants which require a DOM environment, and FAST Element needs
-    // basic DOM globals to initialize.
-    installDomShim();
-    // Dynamic import after the DOM shim is installed so FAST Element can
-    // access `document`, `CSSStyleSheet`, etc.
-    const { html, ref, slotted, children } = await import("@microsoft/fast-element");
-    test("should wrap a static template in f-template tags", () => {
-        const template = html `<template><div>hello</div></template>`;
-        const result = convertTemplate(template, "fast-test");
-        assert.ok(result);
-        assert.ok(result.includes('<f-template name="fast-test"'));
-        assert.ok(result.includes("shadowrootmode"));
-        assert.ok(result.includes("<div>hello</div>"));
-        assert.ok(result.includes("{{styles}}"));
-    });
-    test("should return null-safe for empty factories", () => {
-        const template = html `<template><span></span></template>`;
-        const result = convertTemplate(template, "fast-empty");
-        assert.ok(result);
-        assert.ok(result.includes("<span></span>"));
-    });
-    test("should inject {{styles}} after the opening template tag", () => {
-        const template = html `<template><p>content</p></template>`;
-        const result = convertTemplate(template, "fast-styles");
-        assert.ok(result);
-        const templateIdx = result.indexOf("<template>");
-        const stylesIdx = result.indexOf("{{styles}}");
-        assert.ok(stylesIdx > templateIdx, "{{styles}} should appear after <template>");
-    });
-    test("should convert RefDirective factories to f-ref attributes", () => {
-        const template = html `<template><div ${ref("myRef")}></div></template>`;
-        const result = convertTemplate(template, "fast-ref");
-        assert.ok(result);
-        assert.ok(result.includes('f-ref="{myRef}"'), `got: ${result}`);
-    });
-    test("should convert SlottedDirective factories to f-slotted attributes", () => {
-        const template = html `<template><slot ${slotted("slottedItems")}></slot></template>`;
-        const result = convertTemplate(template, "fast-slotted");
-        assert.ok(result);
-        assert.ok(result.includes("f-slotted="), `got: ${result}`);
-        assert.ok(result.includes("slottedItems"), `got: ${result}`);
-    });
-    test("should convert value bindings to {{expression}}", () => {
-        const template = html `<template><span>${x => x.label}</span></template>`;
-        const result = convertTemplate(template, "fast-binding");
-        assert.ok(result);
-        assert.ok(result.includes("{{label}}"), `got: ${result}`);
-    });
-    test("should convert boolean bindings to ?attr expressions", () => {
-        const template = html `<template><button ?disabled="${x => x.disabled}"></button></template>`;
-        const result = convertTemplate(template, "fast-bool");
-        assert.ok(result);
-        assert.ok(result.includes('?disabled="{{disabled}}"'), `got: ${result}`);
-    });
-    test("should inline static sub-templates", () => {
-        const template = html `<template><div>${() => "<svg>icon</svg>"}</div></template>`;
-        const result = convertTemplate(template, "fast-inline");
-        assert.ok(result);
-        assert.ok(result.includes("<svg>icon</svg>"), `got: ${result}`);
-    });
-    test("should convert ChildrenDirective factories to f-children attributes", () => {
-        const template = html `<template><div ${children("childItems")}></div></template>`;
-        const result = convertTemplate(template, "fast-children");
-        assert.ok(result);
-        assert.ok(result.includes("f-children="), `got: ${result}`);
-        assert.ok(result.includes("childItems"), `got: ${result}`);
-    });
-    test("should convert event bindings to @event expressions", () => {
-        const template = html `<template><button @click="${(x, c) => x.handleClick(c.event)}"></button></template>`;
-        const result = convertTemplate(template, "fast-event");
-        assert.ok(result);
-        assert.ok(result.includes("@click="), `got: ${result}`);
-        assert.ok(result.includes("handleClick"), `got: ${result}`);
-    });
-    test("should convert property bindings to :prop expressions", () => {
-        const template = html `<template><input :value="${x => x.currentValue}" /></template>`;
-        const result = convertTemplate(template, "fast-prop");
-        assert.ok(result);
-        assert.ok(result.includes(":value="), `got: ${result}`);
-        assert.ok(result.includes("currentValue"), `got: ${result}`);
-    });
-    test("should handle multiple factories in a single template", () => {
-        const template = html `<template><span>${x => x.label}</span><button ?disabled="${x => x.disabled}"></button></template>`;
-        const result = convertTemplate(template, "fast-multi");
-        assert.ok(result);
-        assert.ok(result.includes("{{label}}"), `got: ${result}`);
-        assert.ok(result.includes('?disabled="{{disabled}}"'), `got: ${result}`);
-    });
-    test("should inline a static sub-template ViewTemplate", () => {
-        const icon = html `<svg>icon</svg>`;
-        const template = html `<template><div>${() => icon}</div></template>`;
-        const result = convertTemplate(template, "fast-sub");
-        assert.ok(result);
-        assert.ok(result.includes("<svg>icon</svg>"), `got: ${result}`);
-    });
-});
-test.describe("generateFTemplates", () => {
-    let tempDir;
-    test.beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), "fast-ftemplates-"));
-    });
-    test.afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    test("should generate an f-template HTML file from a template module", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "badge.template.js"), `export const template = {
-                html: "<template><slot></slot></template>",
-                factories: {}
-            };`);
-        await generateFTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const html = await readFile(join(distDir, "badge.template.html"), "utf8");
-        assert.ok(html.includes('<f-template name="mai-badge"'));
-        assert.ok(html.includes("<slot></slot>"));
-        assert.ok(html.includes("{{styles}}"));
-    });
-    test("should write to outDir when specified", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "card.template.js"), `export const template = {
-                html: "<template><div>card</div></template>",
-                factories: {}
-            };`);
-        await generateFTemplates({ cwd: tempDir, outDir: "out", tagPrefix: "fast" });
-        const html = await readFile(join(tempDir, "out", "card.template.html"), "utf8");
-        assert.ok(html.includes('<f-template name="fast-card"'));
-    });
-    test("should skip modules without a template export", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "empty.template.js"), `export const styles = ":host {}";`);
-        await generateFTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        try {
-            await readFile(join(distDir, "empty.template.html"), "utf8");
-            assert.fail("Should not have created an HTML file");
-        }
-        catch (err) {
-            assert.strictEqual(err.code, "ENOENT");
-        }
-    });
-    test("should apply a format function", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "text.template.js"), `export const template = {
-                html: "<template><span>text</span></template>",
-                factories: {}
-            };`);
-        await generateFTemplates({
-            cwd: tempDir,
-            tagPrefix: "fast",
-            format: html => `<!-- formatted -->\n${html}`,
-        });
-        const html = await readFile(join(distDir, "text.template.html"), "utf8");
-        assert.ok(html.startsWith("<!-- formatted -->"));
-    });
-});
-test.describe("generateWebuiTemplates", () => {
-    let tempDir;
-    test.beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), "fast-webui-"));
-    });
-    test.afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    test("should generate a webui template without f-template wrapper", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "badge.template.js"), `export const template = {
-                html: "<template><slot></slot></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const html = await readFile(join(distDir, "badge.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-        assert.ok(html.includes("<slot></slot>"));
-        assert.ok(!html.includes("<f-template"), "should not have f-template wrapper");
-        assert.ok(!html.includes("{{styles}}"), "should not have styles marker");
-    });
-    test("should write to outDir when specified", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "card.template.js"), `export const template = {
-                html: "<template><div>card</div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({
-            cwd: tempDir,
-            outDir: "out",
-            tagPrefix: "fast",
-        });
-        const html = await readFile(join(tempDir, "out", "card.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-    });
-    test("should add shadowrootdelegatesfocus from definition-async", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "input.template.js"), `export const template = {
-                html: "<template><input /></template>",
-                factories: {}
-            };`);
-        await writeFile(join(distDir, "input.definition-async.js"), `export const definition = {
-                name: "fast-input",
-                shadowOptions: { delegatesFocus: true },
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "input.template-webui.html"), "utf8");
-        assert.ok(html.includes("shadowrootdelegatesfocus"), `should include delegatesFocus, got: ${html}`);
-    });
-    test("should not add shadowrootdelegatesfocus when absent", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "div.template.js"), `export const template = {
-                html: "<template><div>hello</div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "div.template-webui.html"), "utf8");
-        assert.ok(!html.includes("shadowrootdelegatesfocus"));
-    });
-});

package/dist/esm/build/generate-webui-templates.test.js

@@ -1,179 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { generateWebuiTemplates } from "@microsoft/fast-test-harness/build/generate-webui-templates.js";
-test.describe("generateWebuiTemplates", () => {
-    let tempDir;
-    test.beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), "fast-webui-templ-"));
-    });
-    test.afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    test("should generate a webui template without f-template wrapper", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "badge.template.js"), `export const template = {
-                html: "<template><slot></slot></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const html = await readFile(join(distDir, "badge.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-        assert.ok(html.includes("<slot></slot>"));
-        assert.ok(!html.includes("<f-template"), "should not have f-template wrapper");
-        assert.ok(!html.includes("{{styles}}"), "should not have styles marker");
-    });
-    test("should write to outDir when specified", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "card.template.js"), `export const template = {
-                html: "<template><div>card</div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({
-            cwd: tempDir,
-            outDir: "out",
-            tagPrefix: "fast",
-        });
-        const html = await readFile(join(tempDir, "out", "card.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-    });
-    test("should skip modules without a template export", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "empty.template.js"), `export const styles = ":host {}";`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        try {
-            await readFile(join(distDir, "empty.template-webui.html"), "utf8");
-            assert.fail("Should not have created an HTML file");
-        }
-        catch (err) {
-            assert.strictEqual(err.code, "ENOENT");
-        }
-    });
-    test("should apply a format function", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "text.template.js"), `export const template = {
-                html: "<template><span>text</span></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({
-            cwd: tempDir,
-            tagPrefix: "fast",
-            format: html => `<!-- webui-formatted -->\n${html}`,
-        });
-        const html = await readFile(join(distDir, "text.template-webui.html"), "utf8");
-        assert.ok(html.startsWith("<!-- webui-formatted -->"));
-    });
-    test("should add shadowrootdelegatesfocus from definition-async", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "input.template.js"), `export const template = {
-                html: "<template><input /></template>",
-                factories: {}
-            };`);
-        await writeFile(join(distDir, "input.definition-async.js"), `export const definition = {
-                name: "fast-input",
-                shadowOptions: { delegatesFocus: true },
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "input.template-webui.html"), "utf8");
-        assert.ok(html.includes("shadowrootdelegatesfocus"), `should include delegatesFocus, got: ${html}`);
-    });
-    test("should not add shadowrootdelegatesfocus when absent", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "div.template.js"), `export const template = {
-                html: "<template><div>hello</div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "div.template-webui.html"), "utf8");
-        assert.ok(!html.includes("shadowrootdelegatesfocus"));
-    });
-    test("should strip the {{styles}} marker from output", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        // The template contains nested content that would produce a styles marker
-        // during f-template generation (convertTemplate injects it).
-        await writeFile(join(distDir, "label.template.js"), `export const template = {
-                html: "<template><label>Name</label></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const html = await readFile(join(distDir, "label.template-webui.html"), "utf8");
-        assert.ok(!html.includes("{{styles}}"), `should not contain styles marker: ${html}`);
-        assert.ok(!html.includes("{%styles%}"), `should not contain alt styles marker: ${html}`);
-    });
-    test("should handle modules with a default export", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "icon.template.js"), `const template = {
-                html: "<template><svg></svg></template>",
-                factories: {}
-            };
-            export default template;`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "fast" });
-        const html = await readFile(join(distDir, "icon.template-webui.html"), "utf8");
-        assert.ok(html.includes('<template shadowrootmode="open">'));
-        assert.ok(html.includes("<svg></svg>"));
-    });
-    test("should handle multiple template modules in one pass", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "button.template.js"), `export const template = {
-                html: "<template><button><slot></slot></button></template>",
-                factories: {}
-            };`);
-        await writeFile(join(distDir, "badge.template.js"), `export const template = {
-                html: "<template><span><slot></slot></span></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({ cwd: tempDir, tagPrefix: "mai" });
-        const buttonHtml = await readFile(join(distDir, "button.template-webui.html"), "utf8");
-        const badgeHtml = await readFile(join(distDir, "badge.template-webui.html"), "utf8");
-        assert.ok(buttonHtml.includes("<button>"));
-        assert.ok(badgeHtml.includes("<span>"));
-    });
-    test("should gracefully handle a format function that throws", async () => {
-        const distDir = join(tempDir, "dist");
-        await mkdir(distDir, { recursive: true });
-        await writeFile(join(distDir, "broken.template.js"), `export const template = {
-                html: "<template><div>ok</div></template>",
-                factories: {}
-            };`);
-        // Should not throw — just warn and skip formatting.
-        await generateWebuiTemplates({
-            cwd: tempDir,
-            tagPrefix: "fast",
-            format: () => {
-                throw new Error("format boom");
-            },
-        });
-        const html = await readFile(join(distDir, "broken.template-webui.html"), "utf8");
-        // The file should still be written (unformatted).
-        assert.ok(html.includes("<div>ok</div>"));
-    });
-    test("should use a custom glob pattern", async () => {
-        const distDir = join(tempDir, "dist");
-        const sub = join(distDir, "components");
-        await mkdir(sub, { recursive: true });
-        // Use the standard .template.js suffix so basename extraction works
-        await writeFile(join(sub, "alert.template.js"), `export const template = {
-                html: "<template><div role='alert'></div></template>",
-                factories: {}
-            };`);
-        await generateWebuiTemplates({
-            cwd: tempDir,
-            tagPrefix: "fast",
-            pattern: "components/*.template.js",
-        });
-        const html = await readFile(join(sub, "alert.template-webui.html"), "utf8");
-        assert.ok(html.includes("role="), `got: ${html}`);
-        assert.ok(html.includes("alert"), `got: ${html}`);
-    });
-});

package/dist/esm/fixtures/csr-fixture.pw.spec.js

@@ -1,137 +0,0 @@
-import { expect, test } from "@microsoft/fast-test-harness";
-test.describe("CSR: setTemplate", () => {
-    test.use({ tagName: "test-widget" });
-    test("should render the element with default options", async ({ fastPage }) => {
-        await fastPage.setTemplate();
-        await expect(fastPage.element).toHaveCount(1);
-    });
-    test("should render with innerHTML", async ({ fastPage }) => {
-        await fastPage.setTemplate({ innerHTML: "<span>child</span>" });
-        await expect(fastPage.element).toHaveCount(1);
-        await expect(fastPage.element).toContainText("child");
-    });
-    test("should render with attributes", async ({ fastPage }) => {
-        await fastPage.setTemplate({
-            attributes: { label: "Hello", size: "large" },
-        });
-        await expect(fastPage.element).toHaveAttribute("label", "Hello");
-        await expect(fastPage.element).toHaveAttribute("size", "large");
-    });
-    test("should render with boolean attribute", async ({ fastPage }) => {
-        await fastPage.setTemplate({ attributes: { disabled: true } });
-        await expect(fastPage.element).toHaveAttribute("disabled");
-    });
-    test("should render with a raw HTML string", async ({ fastPage }) => {
-        await fastPage.setTemplate(`<test-widget label="raw">raw content</test-widget>`);
-        await expect(fastPage.element).toHaveAttribute("label", "raw");
-        await expect(fastPage.element).toContainText("raw content");
-    });
-    test("should replace the previous template on subsequent calls", async ({ fastPage, }) => {
-        await fastPage.setTemplate({ attributes: { label: "first" } });
-        await expect(fastPage.element).toHaveAttribute("label", "first");
-        await fastPage.setTemplate({ attributes: { label: "second" } });
-        await expect(fastPage.element).toHaveAttribute("label", "second");
-        await expect(fastPage.element).toHaveCount(1);
-    });
-});
-test.describe("CSR: updateTemplate", () => {
-    test.use({ tagName: "test-widget" });
-    test("should update attributes on an existing element", async ({ fastPage }) => {
-        await fastPage.setTemplate({ attributes: { label: "before" } });
-        await expect(fastPage.element).toHaveAttribute("label", "before");
-        await fastPage.updateTemplate("test-widget", {
-            attributes: { label: "after" },
-        });
-        await expect(fastPage.element).toHaveAttribute("label", "after");
-    });
-    test("should remove an attribute when set to false", async ({ fastPage }) => {
-        await fastPage.setTemplate({ attributes: { disabled: true } });
-        await expect(fastPage.element).toHaveAttribute("disabled");
-        await fastPage.updateTemplate("test-widget", {
-            attributes: { disabled: false },
-        });
-        await expect(fastPage.element).not.toHaveAttribute("disabled");
-    });
-    test("should update innerHTML", async ({ fastPage }) => {
-        await fastPage.setTemplate({ innerHTML: "original" });
-        await fastPage.updateTemplate("test-widget", {
-            innerHTML: "updated",
-        });
-        await expect(fastPage.element).toContainText("updated");
-    });
-    test("should accept a Locator", async ({ fastPage }) => {
-        await fastPage.setTemplate({ attributes: { label: "loc" } });
-        await fastPage.updateTemplate(fastPage.element, {
-            attributes: { label: "via-locator" },
-        });
-        await expect(fastPage.element).toHaveAttribute("label", "via-locator");
-    });
-});
-test.describe("CSR: applyTokens", () => {
-    test.use({ tagName: "test-widget" });
-    test("should set CSS custom properties on the body", async ({ fastPage }) => {
-        await fastPage.setTemplate();
-        await fastPage.applyTokens({
-            "color-primary": "#0078d4",
-            "spacing-m": "8px",
-        });
-        const value = await fastPage.page.evaluate(() => document.body.style.getPropertyValue("--color-primary"));
-        expect(value).toBe("#0078d4");
-    });
-});
-test.describe("CSR: waitForCustomElement", () => {
-    test.use({ tagName: "test-widget" });
-    test("should resolve for a registered element", async ({ fastPage }) => {
-        await fastPage.setTemplate();
-        await fastPage.waitForCustomElement("test-widget");
-    });
-});
-test.describe("CSR: toHaveCustomState", () => {
-    test.use({ tagName: "test-widget" });
-    test("should pass when element has the custom state", async ({ fastPage }) => {
-        await fastPage.setTemplate({ attributes: { disabled: true } });
-        await expect(fastPage.element).toHaveCustomState("disabled");
-    });
-    test("should fail (negated) when element does not have the state", async ({ fastPage, }) => {
-        await fastPage.setTemplate();
-        await expect(fastPage.element).not.toHaveCustomState("disabled");
-    });
-});
-test.describe("CSR: element locator", () => {
-    test.use({ tagName: "test-widget" });
-    test("should locate the element by tag name", async ({ fastPage }) => {
-        await fastPage.setTemplate();
-        await expect(fastPage.element).toHaveCount(1);
-    });
-});
-test.describe("CSR: addStyleTag", () => {
-    test.use({ tagName: "test-widget" });
-    test("should add a style tag with content", async ({ fastPage }) => {
-        await fastPage.setTemplate();
-        await fastPage.addStyleTag({
-            content: "test-widget { border: 1px solid red; }",
-        });
-        const hasBorder = await fastPage.page.evaluate(() => {
-            const styles = document.querySelectorAll("style");
-            return Array.from(styles).some(s => s.textContent?.includes("border: 1px solid red"));
-        });
-        expect(hasBorder).toBe(true);
-    });
-});
-test.describe("CSR: multiple elements", () => {
-    test.use({ tagName: "test-widget" });
-    test("should handle templates with multiple instances", async ({ fastPage }) => {
-        await fastPage.setTemplate(`
-            <test-widget label="first">one</test-widget>
-            <test-widget label="second">two</test-widget>
-        `);
-        await expect(fastPage.element).toHaveCount(2);
-    });
-});
-test.describe("CSR: waitFor", () => {
-    test.use({ tagName: "test-widget", waitFor: ["test-widget"] });
-    test("should wait for additional elements specified in waitFor", async ({ fastPage, }) => {
-        await fastPage.setTemplate();
-        await expect(fastPage.element).toHaveCount(1);
-    });
-});