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

package/build/services/TestGenerationService.test.d.ts

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

package/build/services/TestGenerationService.test.js

@@ -1,578 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import { TestType } from "../types/TestTypes.js";
-import { AUTH_PLACEHOLDER_TOKEN } from "../types/TestTypes.js";
-import fs from "fs";
-import os from "os";
-import path from "path";
-// Mock @skyramp/skyramp before importing TestGenerationService to avoid
-// pulling in playwright (dynamic imports fail on Node 18 in CI). Under native
-// ESM, jest.mock is not hoisted — use unstable_mockModule + dynamic import.
-jest.unstable_mockModule("@skyramp/skyramp", () => ({
-    SkyrampClient: jest.fn().mockImplementation(() => ({})),
-}));
-const { TestGenerationService, deriveEffectiveFramework } = await import("./TestGenerationService.js");
-const { SkyrampClient } = await import("@skyramp/skyramp");
-class StubService extends TestGenerationService {
-    buildGenerationOptions() {
-        return {};
-    }
-    getTestType() {
-        return TestType.SMOKE;
-    }
-    validate(params) {
-        return this.validateInputs(params);
-    }
-}
-const BASE = {
-    outputDir: "/tmp/tests",
-    force: true,
-};
-function validateOutput(framework, output) {
-    const svc = new StubService();
-    return svc.validate({ ...BASE, framework, output });
-}
-function playwrightError(result) {
-    for (const c of result.content) {
-        if (c.type === "text" && c.text.includes("Playwright")) {
-            return c.text;
-        }
-    }
-    return undefined;
-}
-describe("TestGenerationService — Playwright filename validation", () => {
-    it.each([
-        "my_test.spec.ts",
-        "my_test.test.ts",
-        "my_test.spec.js",
-        "my_test.test.js",
-    ])("accepts valid Playwright filename: %s", (filename) => {
-        const result = validateOutput("playwright", filename);
-        expect(playwrightError(result)).toBeUndefined();
-    });
-    it.each([
-        "my_test.ts",
-        "my_test.py",
-        "my_test.java",
-        "tests",
-        "my_test.js",
-    ])("rejects invalid Playwright filename: %s", (filename) => {
-        const result = validateOutput("playwright", filename);
-        expect(playwrightError(result)).toBeDefined();
-        expect(playwrightError(result)).toContain("Playwright requires");
-    });
-    it("suggests .spec.ts replacement for .ts file", () => {
-        const err = playwrightError(validateOutput("playwright", "crud_items.ts"));
-        expect(err).toContain("crud_items.spec.ts");
-    });
-    it("suggests .spec.ts replacement for .js file", () => {
-        const err = playwrightError(validateOutput("playwright", "crud_items.js"));
-        expect(err).toContain("crud_items.spec.ts");
-    });
-    it("appends .spec.ts for non-JS extension (e.g. .java)", () => {
-        const err = playwrightError(validateOutput("playwright", "my_test.java"));
-        expect(err).toContain("my_test.java.spec.ts");
-    });
-    it("appends .spec.ts for extensionless filename", () => {
-        const err = playwrightError(validateOutput("playwright", "tests"));
-        expect(err).toContain("tests.spec.ts");
-    });
-    it("skips validation when output is empty string", () => {
-        expect(playwrightError(validateOutput("playwright", ""))).toBeUndefined();
-    });
-    it("skips validation for non-playwright frameworks", () => {
-        expect(playwrightError(validateOutput("pytest", "my_test.py"))).toBeUndefined();
-    });
-    it("is case-insensitive on framework name", () => {
-        expect(playwrightError(validateOutput("Playwright", "bad.ts"))).toBeDefined();
-    });
-});
-describe("TestGenerationService — language/output extension consistency (SKYR-3899)", () => {
-    function validateLangOutput(language, framework, output) {
-        const svc = new StubService();
-        return svc.validate({ ...BASE, language, framework, output });
-    }
-    function errorText(result) {
-        for (const c of result.content) {
-            if (c.type === "text")
-                return c.text;
-        }
-        return undefined;
-    }
-    it("rejects TypeScript output written to a .py file with no explicit framework (the reported bug)", () => {
-        // language typescript + no framework derives to playwright, so ui_test.py is
-        // rejected instead of emitting TypeScript into a Python file.
-        const result = validateLangOutput("typescript", "", "ui_test.py");
-        expect(result.isError).toBe(true);
-        expect(errorText(result)).toContain("Playwright requires");
-    });
-    it("accepts a TypeScript UI test named *.spec.ts with no explicit framework", () => {
-        const result = validateLangOutput("typescript", "", "ui_test.spec.ts");
-        expect(result.isError).toBe(false);
-    });
-    it("rejects a Python-language test written to a .ts file", () => {
-        const result = validateLangOutput("python", "", "my_test.ts");
-        expect(result.isError).toBe(true);
-        expect(errorText(result)).toContain('language "python" requires a .py');
-        expect(errorText(result)).toContain("my_test.py");
-    });
-    it("accepts a Python-language test written to a .py file", () => {
-        const result = validateLangOutput("python", "", "my_test.py");
-        expect(result.isError).toBe(false);
-    });
-    it("rejects a mismatched extension even when a non-playwright framework is explicit", () => {
-        const result = validateLangOutput("typescript", "pytest", "foo.py");
-        expect(result.isError).toBe(true);
-        expect(errorText(result)).toContain('language "typescript" requires a .ts');
-    });
-    it("accepts a Python Playwright test (pytest-playwright) written to a .py file", () => {
-        // Playwright supports Python via pytest-playwright — language: "python" +
-        // framework: "playwright" must validate against .py, not the js/ts spec rule.
-        const result = validateLangOutput("python", "playwright", "test_login.py");
-        expect(result.isError).toBe(false);
-    });
-    it("rejects a Python Playwright test written to a .spec.ts file", () => {
-        const result = validateLangOutput("python", "playwright", "foo.spec.ts");
-        expect(result.isError).toBe(true);
-        expect(errorText(result)).toContain('language "python" requires a .py');
-    });
-});
-describe("deriveEffectiveFramework — validation/generation share one derivation (SKYR-3899)", () => {
-    it("derives playwright for ts/js when framework is undefined", () => {
-        expect(deriveEffectiveFramework("typescript", undefined)).toBe("playwright");
-        expect(deriveEffectiveFramework("javascript", undefined)).toBe("playwright");
-    });
-    it("treats a blank/whitespace framework as unset (no drift vs undefined)", () => {
-        // The empty-string edge the two call sites used to disagree on: validation
-        // derived playwright while generation kept "". Both now agree.
-        expect(deriveEffectiveFramework("typescript", "")).toBe("playwright");
-        expect(deriveEffectiveFramework("typescript", "   ")).toBe("playwright");
-    });
-    it("keeps an explicit framework and defaults non-js/ts to empty", () => {
-        expect(deriveEffectiveFramework("typescript", "pytest")).toBe("pytest");
-        expect(deriveEffectiveFramework("python", undefined)).toBe("");
-    });
-});
-describe("TestGenerationService — authType/authScheme not passed to library", () => {
-    let mockGenerateRestTest;
-    beforeEach(() => {
-        mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        SkyrampClient.mockImplementation(() => ({
-            generateRestTest: mockGenerateRestTest,
-        }));
-    });
-    it("maps authScheme to authType for the npm client", async () => {
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            authHeader: "Authorization",
-            authScheme: "Token",
-            authType: "Token",
-            outputDir: "/tmp/tests",
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        expect(callArgs.authType).toBe("Token");
-        expect(callArgs.authScheme).toBeUndefined();
-        // authHeader is cleared for Authorization when authType is set (CLI conflict fix)
-        expect(callArgs.authHeader).toBeUndefined();
-    });
-    it("passes authHeader through to library without modification", async () => {
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            authHeader: "X-Api-Key",
-            outputDir: "/tmp/tests",
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        expect(callArgs.authHeader).toBe("X-Api-Key");
-        expect(callArgs.authType).toBeUndefined();
-        expect(callArgs.authScheme).toBeUndefined();
-    });
-});
-describe("TestGenerationService — extractAuthFromTrace", () => {
-    let tmpDir;
-    beforeEach(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    function writeTrace(requests) {
-        const filePath = path.join(tmpDir, "trace.json");
-        fs.writeFileSync(filePath, JSON.stringify(requests), "utf8");
-        return filePath;
-    }
-    function extract(filePath, include, exclude) {
-        const svc = new StubService();
-        return svc.extractAuthFromTrace(filePath, include, exclude);
-    }
-    it("extracts Authorization + Bearer scheme from trace", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Authorization: [`Bearer ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-        });
-    });
-    it("extracts Authorization + Token scheme from trace", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Authorization: [`Token ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Token",
-        });
-    });
-    it("extracts X-Api-Key with empty scheme from trace", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    "X-Api-Key": [AUTH_PLACEHOLDER_TOKEN],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "X-Api-Key",
-            authScheme: "",
-        });
-    });
-    it("returns null when no auth header in trace", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                },
-            },
-        ]);
-        expect(extract(fp)).toBeNull();
-    });
-    it("returns null for invalid JSON", () => {
-        const fp = path.join(tmpDir, "bad.json");
-        fs.writeFileSync(fp, "not json", "utf8");
-        expect(extract(fp)).toBeNull();
-    });
-    it("returns null for non-existent file", () => {
-        expect(extract("/tmp/does-not-exist-xyz.json")).toBeNull();
-    });
-    it("skips Pragma header (standard HTTP/1.0 caching header, not auth)", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Cache-Control": ["no-cache"],
-                    Pragma: ["no-cache"],
-                    "User-Agent": ["Mozilla/5.0"],
-                },
-            },
-        ]);
-        expect(extract(fp)).toBeNull();
-    });
-    it("skips Pragma and finds real auth header behind it", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Cache-Control": ["no-cache"],
-                    Pragma: ["no-cache"],
-                    "User-Agent": ["Mozilla/5.0"],
-                    Authorization: [`Bearer ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-        });
-    });
-    it("uses include filter to skip noise and find auth on matching requests", () => {
-        const fp = writeTrace([
-            {
-                // requests[0]: unrelated traffic (e.g. Google time sync) with no auth
-                Destination: "clients2.google.com",
-                Path: "/time/1/current",
-                RequestHeaders: {
-                    "Cache-Control": ["no-cache"],
-                    "User-Agent": ["Mozilla/5.0"],
-                },
-            },
-            {
-                // requests[1]: actual API request matching include filter
-                Destination: "demoshop.skyramp.dev",
-                Path: "/api/v1/products",
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Authorization: [`Bearer ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp, ["demoshop.skyramp.dev/api/*"])).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-        });
-    });
-    it("uses exclude filter to skip noise and find auth on remaining requests", () => {
-        const fp = writeTrace([
-            {
-                Destination: "clients2.google.com",
-                Path: "/time/1/current",
-                RequestHeaders: {
-                    "Cache-Control": ["no-cache"],
-                    "User-Agent": ["Mozilla/5.0"],
-                },
-            },
-            {
-                Destination: "demoshop.skyramp.dev",
-                Path: "/api/v1/products",
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Authorization: [`Bearer ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp, undefined, ["clients2.google.com/*"])).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-        });
-    });
-    it("prefers Authorization over Cookie even when Cookie appears first", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Cookie: ["cf_clearance=abc123; _dd_s=xyz"],
-                    Authorization: [`Bearer ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-        });
-    });
-    it("falls back to known auth header (X-Api-Key) when no Authorization present", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    "Sec-Fetch-Mode": ["cors"],
-                    "X-Api-Key": ["my-secret-key"],
-                    Traceparent: ["00-abc-def-01"],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "X-Api-Key",
-            authScheme: "",
-        });
-    });
-    it("skips standard headers like Accept", () => {
-        const fp = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Accept: ["application/json"],
-                    Authorization: [`Token ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        expect(extract(fp)).toEqual({
-            authHeader: "Authorization",
-            authScheme: "Token",
-        });
-    });
-});
-describe("TestGenerationService — trace-based auth in executeGeneration", () => {
-    let mockGenerateRestTest;
-    let tmpDir;
-    beforeEach(() => {
-        mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        SkyrampClient.mockImplementation(() => ({
-            generateRestTest: mockGenerateRestTest,
-        }));
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-test-"));
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    function writeTrace(requests) {
-        const filePath = path.join(tmpDir, "trace.json");
-        fs.writeFileSync(filePath, JSON.stringify(requests), "utf8");
-        return filePath;
-    }
-    it("populates authScheme from trace when not provided (clears Authorization authHeader)", async () => {
-        const traceFile = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Authorization: [`Token ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            traceFilePath: traceFile,
-            authHeader: "",
-            authScheme: "",
-            outputDir: "/tmp/tests",
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        // authHeader is cleared for Authorization when authType is set (CLI conflict fix)
-        expect(callArgs.authHeader).toBeUndefined();
-        expect(callArgs.authType).toBe("Token");
-        expect(callArgs.authScheme).toBeUndefined();
-    });
-    it("populates X-Api-Key from trace with empty authScheme", async () => {
-        const traceFile = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    "X-Api-Key": [AUTH_PLACEHOLDER_TOKEN],
-                },
-            },
-        ]);
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            traceFilePath: traceFile,
-            authHeader: "",
-            authScheme: "",
-            outputDir: "/tmp/tests",
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        expect(callArgs.authHeader).toBe("X-Api-Key");
-        expect(callArgs.authType).toBe("");
-        expect(callArgs.authScheme).toBeUndefined();
-    });
-    it("overrides conflicting authScheme with trace value and clears Authorization authHeader", async () => {
-        const traceFile = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                    Authorization: [`Token ${AUTH_PLACEHOLDER_TOKEN}`],
-                },
-            },
-        ]);
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            traceFilePath: traceFile,
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-            outputDir: "/tmp/tests",
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        // authHeader is cleared for Authorization when authType is set (CLI conflict fix)
-        expect(callArgs.authHeader).toBeUndefined();
-        expect(callArgs.authType).toBe("Token");
-        expect(callArgs.authScheme).toBeUndefined();
-    });
-    it("does not override auth when trace has no auth header (clears Authorization authHeader)", async () => {
-        const traceFile = writeTrace([
-            {
-                RequestHeaders: {
-                    "Content-Type": ["application/json"],
-                },
-            },
-        ]);
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            traceFilePath: traceFile,
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-            outputDir: "/tmp/tests",
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        // authHeader is cleared for Authorization when authType is set (CLI conflict fix)
-        expect(callArgs.authHeader).toBeUndefined();
-        expect(callArgs.authType).toBe("Bearer");
-        expect(callArgs.authScheme).toBeUndefined();
-    });
-});
-describe("TestGenerationService — workspace skipTLSVerify auto-resolve (SKYR-3961)", () => {
-    let mockGenerateRestTest;
-    let wsDir;
-    beforeEach(() => {
-        mockGenerateRestTest = jest.fn().mockResolvedValue("Test generation success");
-        SkyrampClient.mockImplementation(() => ({
-            generateRestTest: mockGenerateRestTest,
-        }));
-        wsDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-ws-"));
-    });
-    afterEach(() => {
-        fs.rmSync(wsDir, { recursive: true, force: true });
-    });
-    function writeWorkspace(api) {
-        const dir = path.join(wsDir, ".skyramp");
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(path.join(dir, "workspace.yml"), [
-            "workspace:",
-            "  repoName: org/sut",
-            "services:",
-            "  - serviceName: sut",
-            "    api:",
-            ...Object.entries(api).map(([k, v]) => `      ${k}: ${v}`),
-        ].join("\n"), "utf8");
-    }
-    it("sets insecure from workspace when the caller did not request it", async () => {
-        writeWorkspace({ baseUrl: "https://127.0.0.1:45643", skipTLSVerify: true });
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            authHeader: "",
-            authScheme: "",
-            outputDir: wsDir,
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        // generateInsecure is the key SkyrampClient reads (buildBaseGenerationOptions
-        // maps the tool param `insecure` onto it).
-        expect(callArgs.generateInsecure).toBe(true);
-    });
-    it("leaves insecure unset when the workspace does not declare it", async () => {
-        writeWorkspace({ baseUrl: "https://127.0.0.1:45643" });
-        const svc = new StubService();
-        svc.buildGenerationOptions = () => ({
-            authHeader: "",
-            authScheme: "",
-            outputDir: wsDir,
-            language: "python",
-            framework: "pytest",
-        });
-        svc.handleApiAnalysis = async () => null;
-        await svc.generateTest({ ...BASE });
-        const callArgs = mockGenerateRestTest.mock.calls[0][0];
-        expect(callArgs.generateInsecure).not.toBe(true);
-    });
-});

package/build/tool-phase-coverage.test.d.ts

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

package/build/tool-phase-coverage.test.js

@@ -1,49 +0,0 @@
-import { TOOL_PHASE_MAP, TOOLS_WITHOUT_PHASE } from "./tool-phases.js";
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-function findAllToolNames() {
-    const toolNames = [];
-    function walk(dir) {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-                continue;
-            }
-            if (!entry.name.endsWith(".ts"))
-                continue;
-            const content = fs.readFileSync(full, "utf-8");
-            const matches = content.matchAll(/const TOOL_NAME\s*=\s*["']([^"']+)["']/g);
-            for (const m of matches)
-                toolNames.push(m[1]);
-        }
-    }
-    walk(path.resolve(__dirname, "./tools"));
-    return toolNames;
-}
-describe("tool-phase-coverage", () => {
-    it("every registered tool has a phase or is explicitly excluded", () => {
-        const allTools = findAllToolNames();
-        expect(allTools.length).toBeGreaterThan(0);
-        const missing = allTools.filter(name => !(name in TOOL_PHASE_MAP) && !TOOLS_WITHOUT_PHASE.has(name));
-        if (missing.length > 0) {
-            throw new Error(`These tools are not in TOOL_PHASE_MAP or TOOLS_WITHOUT_PHASE in src/tool-phases.ts:\n` +
-                missing.map(n => `  - ${n}`).join("\n") +
-                `\nAdd them to the appropriate export in src/tool-phases.ts`);
-        }
-    });
-    it("TOOL_PHASE_MAP contains only valid phases", () => {
-        const validPhases = new Set(["analyzing", "generating", "executing", "maintaining", "reporting"]);
-        for (const [tool, mapping] of Object.entries(TOOL_PHASE_MAP)) {
-            if (typeof mapping === "string") {
-                expect(validPhases.has(mapping)).toBe(true);
-            }
-            else {
-                expect(validPhases.has(mapping.before)).toBe(true);
-                expect(validPhases.has(mapping.after)).toBe(true);
-            }
-        }
-    });
-});

package/build/tools/code-refactor/codeReuseTool.test.d.ts

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