@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/utils/pom-verify/verify.test.js

@@ -1,374 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { verifyReuse } from "./verify.js";
-const OO = path.join(path.dirname(fileURLToPath(import.meta.url)), "__fixtures__", "oo-style");
-const AF = path.join(path.dirname(fileURLToPath(import.meta.url)), "__fixtures__", "af-style");
-/** Materializes a hermetic mkdtemp project (so `findRoot`/`globPomFiles` resolve deterministically
- * against just this tree, not the real monorepo checkout) and returns its root + a cleanup fn. */
-function makeProject(files) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), "pom-verify-"));
-    for (const [rel, content] of Object.entries(files)) {
-        const full = path.join(root, rel);
-        fs.mkdirSync(path.dirname(full), { recursive: true });
-        fs.writeFileSync(full, content);
-    }
-    return { root, cleanup: () => fs.rmSync(root, { recursive: true, force: true }) };
-}
-const read = (dir, name) => fs.readFileSync(path.join(dir, name), "utf8");
-describe("verifyReuse -- oo-style (page-manager convention)", () => {
-    it("passes a clean spec: real method via pm binding -> ok:true, checkedCalls>0", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "pages/page-manager.js": read(OO, "page-manager.js"),
-            "pages/loginPage.js": read(OO, "loginPage.js"),
-            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
-            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
-            "clean.spec.js": `
-        import { PageManager } from './pages/page-manager.js';
-        async function run() {
-          const pm = new PageManager(page);
-          await pm.loginPage.signInAs(user);
-        }
-        await run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "clean.spec.js"), "javascript");
-            expect(result.ok).toBe(true);
-            expect(result.violations).toEqual([]);
-            expect(result.checkedCalls).toBeGreaterThan(0);
-            expect(result.parseError).toBeUndefined();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it("flags a hallucinated member with the real member list", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
-            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
-            "violation.spec.js": `
-        import { WidgetsPage } from './pages/widgetsPage.js';
-        async function run() {
-          const widgets = new WidgetsPage(page);
-          await widgets.dragWidgetFake();
-        }
-        await run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "violation.spec.js"), "javascript");
-            expect(result.violations).toEqual([
-                {
-                    binding: "widgets",
-                    member: "dragWidgetFake",
-                    searched: [path.join(root, "pages", "widgetsPage.js"), path.join(root, "pages", "widgetHelpers.js")],
-                    availableMembers: expect.arrayContaining(["addBtn"]),
-                },
-            ]);
-            expect(result.ok).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- oo-style (CJS page-manager convention)", () => {
-    it("engages on a CJS PageManager (no `export` on the class, module.exports, a default import, an extensionless require) -- real call passes, checkedCalls>0", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{}`,
-            "pages/page-manager.js": read(OO, "page-manager-cjs.js"),
-            "pages/loginPage.js": read(OO, "loginPage.js"),
-            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
-            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
-            "cjs-clean.spec.js": `
-        const PageManager = require('./pages/page-manager.js');
-        async function run() {
-          const pm = new PageManager(page);
-          await pm.loginPage.signInAs(user);
-        }
-        run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "cjs-clean.spec.js"), "javascript");
-            expect(result.ok).toBe(true);
-            expect(result.violations).toEqual([]);
-            expect(result.checkedCalls).toBeGreaterThan(0);
-            expect(result.parseError).toBeUndefined();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it("flags a hallucinated method on a real pm member as a violation, with the real member list", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{}`,
-            "pages/page-manager.js": read(OO, "page-manager-cjs.js"),
-            "pages/loginPage.js": read(OO, "loginPage.js"),
-            "pages/widgetsPage.js": read(OO, "widgetsPage.js"),
-            "pages/widgetHelpers.js": read(OO, "widgetHelpers.js"),
-            "cjs-violation.spec.js": `
-        const PageManager = require('./pages/page-manager.js');
-        async function run() {
-          const pm = new PageManager(page);
-          await pm.widgetsPage.dragWidgetFake();
-        }
-        run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "cjs-violation.spec.js"), "javascript");
-            expect(result.violations).toEqual([
-                {
-                    binding: "pm.widgetsPage",
-                    member: "dragWidgetFake",
-                    searched: [path.join(root, "pages", "widgetsPage.js"), path.join(root, "pages", "widgetHelpers.js")],
-                    availableMembers: expect.arrayContaining(["addBtn"]),
-                },
-            ]);
-            expect(result.ok).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- af-style (tsconfig path-alias imports)", () => {
-    it("engages via a `@pageobjects/*` tsconfig alias -- real member passes, checkedCalls>0", async () => {
-        const { root, cleanup } = makeProject({
-            "tsconfig.json": read(AF, "alias.tsconfig.json"),
-            "src/pageobjects/asset-list-page.ts": read(AF, "pageobjects/asset-list-page.ts"),
-            "src/tests/alias.spec.ts": `
-        import { AssetListPage } from '@pageobjects/asset-list-page';
-        const list = new AssetListPage(page);
-        await list.clickSearch();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "src", "tests", "alias.spec.ts"), "typescript");
-            expect(result.ok).toBe(true);
-            expect(result.violations).toEqual([]);
-            expect(result.checkedCalls).toBeGreaterThan(0);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it("flags a hallucinated method reached via the alias import as a violation", async () => {
-        const { root, cleanup } = makeProject({
-            "tsconfig.json": read(AF, "alias.tsconfig.json"),
-            "src/pageobjects/asset-list-page.ts": read(AF, "pageobjects/asset-list-page.ts"),
-            "src/tests/alias-violation.spec.ts": `
-        import { AssetListPage } from '@pageobjects/asset-list-page';
-        const list = new AssetListPage(page);
-        await list.clickSearchFake();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "src", "tests", "alias-violation.spec.ts"), "typescript");
-            expect(result.violations).toEqual([
-                {
-                    binding: "list",
-                    member: "clickSearchFake",
-                    searched: [path.join(root, "src", "pageobjects", "asset-list-page.ts")],
-                    availableMembers: expect.arrayContaining(["clickSearch"]),
-                },
-            ]);
-            expect(result.ok).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- af-style (direct instantiation)", () => {
-    it("routes deep chains and unknown bindings to unverifiable, never violations", async () => {
-        const { root, cleanup } = makeProject({
-            "components/asset-list.page.ts": read(AF, "asset-list.page.ts"),
-            "components/workflow-footer.page.ts": read(AF, "workflow-footer.page.ts"),
-            "deep.spec.ts": `
-        import { AssetListPage } from './components/asset-list.page.js';
-        import { Unknown } from './components/unknown.js';
-        const list = new AssetListPage(page);
-        const thing = new Unknown();
-        await list.footer.okBtn.click();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "deep.spec.ts"), "typescript");
-            expect(result.violations).toEqual([]);
-            expect(result.unverifiable).toEqual(expect.arrayContaining(["list.footer.okBtn.click", "thing"]));
-            expect(result.ok).toBe(true);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it("verifies a direct-instantiation class's own member against the class file", async () => {
-        const { root, cleanup } = makeProject({
-            "components/report.iframe.page.ts": read(AF, "report.iframe.page.ts"),
-            "iframe.spec.ts": `
-        import { ReportIframePage } from './components/report.iframe.page.js';
-        const report = new ReportIframePage(frame);
-        expect(report.exportBtn).toBeVisible();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "iframe.spec.ts"), "typescript");
-            expect(result.violations).toEqual([]);
-            expect(result.ok).toBe(true);
-            expect(result.checkedCalls).toBeGreaterThan(0);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- free-function bindings", () => {
-    it("verifies a real free-function call (empty chain) against its source file -- ok:true, checkedCalls>0", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "pages/commonActions.js": read(OO, "commonActions.js"),
-            "clean-fn.spec.js": `
-        import { openNavFlyout } from './pages/commonActions.js';
-        async function run() {
-          await openNavFlyout(page);
-        }
-        await run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "clean-fn.spec.js"), "javascript");
-            expect(result.violations).toEqual([]);
-            expect(result.ok).toBe(true);
-            expect(result.checkedCalls).toBeGreaterThan(0);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it("flags a hallucinated free-function call instead of crashing on the empty chain", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "pages/commonActions.js": read(OO, "commonActions.js"),
-            "violation-fn.spec.js": `
-        import { fakeHelper } from './pages/commonActions.js';
-        async function run() {
-          await fakeHelper(page);
-        }
-        await run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "violation-fn.spec.js"), "javascript");
-            expect(result.violations).toEqual([
-                {
-                    binding: "fakeHelper",
-                    member: "fakeHelper",
-                    searched: [path.join(root, "pages", "commonActions.js")],
-                    availableMembers: expect.any(Array),
-                },
-            ]);
-            expect(result.ok).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- listMembers keyword noise", () => {
-    it("excludes control-flow keywords and constructor from availableMembers, but keeps real methods", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "pages/controlFlowPage.js": `
-        export class ControlFlowPage {
-          constructor(page) {
-            this.page = page;
-          }
-          realMethod() {
-            if (this.page) {
-            }
-            for (let i = 0; i < 1; i++) {
-            }
-            while (this.page) {
-            }
-            switch (this.page) {
-            }
-            try {
-            }
-            catch (e) {
-            }
-            return(this.page);
-          }
-        }
-      `,
-            "control-flow.spec.js": `
-        import { ControlFlowPage } from './pages/controlFlowPage.js';
-        async function run() {
-          const page = new ControlFlowPage(p);
-          await page.doesNotExist();
-        }
-        await run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "control-flow.spec.js"), "javascript");
-            expect(result.violations).toHaveLength(1);
-            const { availableMembers } = result.violations[0];
-            expect(availableMembers).toEqual(expect.arrayContaining(["realMethod"]));
-            for (const keyword of ["if", "for", "while", "switch", "catch", "return", "constructor"]) {
-                expect(availableMembers).not.toContain(keyword);
-            }
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- tsconfig paths with non-string values", () => {
-    it("skips a non-string paths target instead of throwing -- verification still runs", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "tsconfig.json": `{"compilerOptions":{"paths":{"@x/*":[42]}}}`,
-            "pages/commonActions.js": read(OO, "commonActions.js"),
-            "clean-fn.spec.js": `
-        import { openNavFlyout } from './pages/commonActions.js';
-        async function run() {
-          await openNavFlyout(page);
-        }
-        await run();
-      `,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "clean-fn.spec.js"), "javascript");
-            expect(result.parseError).toBeUndefined();
-            expect(result.violations).toEqual([]);
-            expect(result.ok).toBe(true);
-            expect(result.checkedCalls).toBeGreaterThan(0);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});
-describe("verifyReuse -- parse errors", () => {
-    it("reports a parse error for broken JS output", async () => {
-        const { root, cleanup } = makeProject({
-            "package.json": `{"type":"module"}`,
-            "broken.spec.js": `function broken( {\n`,
-        });
-        try {
-            const result = await verifyReuse(path.join(root, "broken.spec.js"), "javascript");
-            expect(result.ok).toBe(false);
-            expect(result.parseError).toBeDefined();
-            expect(result.parseError.length).toBeLessThanOrEqual(500);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/build/utils/pr-comment-parser.test.d.ts

@@ -1 +0,0 @@
-export {};