@riebeckite/test 0.0.35 → 0.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/test",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -23,12 +23,6 @@
       "import": "./dist/fixtures.js",
       "source": "./fixtures.ts",
       "default": "./dist/fixtures.js"
-    },
-    "./plugin-contract": {
-      "types": "./dist/plugin-contract.d.ts",
-      "import": "./dist/plugin-contract.js",
-      "source": "./plugin-contract.ts",
-      "default": "./dist/plugin-contract.js"
     }
   },
   "files": [

package/dist/plugin-contract.d.ts

@@ -1,39 +0,0 @@
-export type PluginContractLevel = "basic" | "integration" | "full";
-export type PluginContractStatus = "PASS" | "FAIL" | "SKIP" | "UNSUPPORTED" | "UNVERIFIED";
-export type PluginContractCapability = "package" | "plugin" | "markdown" | "client" | "publication";
-export type PluginContractResult = {
-    readonly contract: string;
-    readonly status: PluginContractStatus;
-    readonly expected: string;
-    readonly actual: string;
-    readonly guidance?: string;
-    readonly executed: boolean;
-};
-export type PluginContractFixtureCommand = {
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd?: string;
-    readonly browser?: boolean;
-};
-export type PluginContractFixture = {
-    readonly packageName: string;
-    readonly packageDirectory: string;
-    readonly integration: PluginContractFixtureCommand;
-    readonly full?: PluginContractFixtureCommand;
-};
-export type PluginContractReport = {
-    readonly packagePath: string;
-    readonly packageName: string;
-    readonly level: PluginContractLevel;
-    readonly capabilities: readonly PluginContractCapability[];
-    readonly results: readonly PluginContractResult[];
-    readonly passed: boolean;
-    readonly complete: boolean;
-};
-export type VerifyPluginContractOptions = {
-    readonly level?: PluginContractLevel;
-    readonly capabilities?: readonly PluginContractCapability[];
-    readonly fixtures?: readonly PluginContractFixture[];
-};
-export declare function verifyPluginContract(packagePath: string, options?: VerifyPluginContractOptions): PluginContractReport;
-export declare function formatPluginContractReport(report: PluginContractReport): string;

package/dist/plugin-contract.js

@@ -1,413 +0,0 @@
-// plugin-contract.ts
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-// e2e/process.ts
-import { spawn, spawnSync } from "node:child_process";
-var MAX_BUFFER = 128 * 1024 * 1024;
-function quote(value) {
-  const text = String(value);
-  return /[\s"]/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
-}
-function failureDetail(stdout, stderr) {
-  return `--- stdout ---
-${stdout}
---- stderr ---
-${stderr}`;
-}
-function run(command, args, options = {}) {
-  const line = [command, ...args].map(quote).join(" ");
-  const result = spawnSync(line, {
-    shell: true,
-    cwd: options.cwd ?? process.cwd(),
-    env: { ...process.env, ...options.env },
-    encoding: "utf8",
-    maxBuffer: MAX_BUFFER
-  });
-  if (result.error) {
-    throw new Error(`Failed to run: ${line}
-${result.error.message}`);
-  }
-  const stdout = result.stdout ?? "";
-  const stderr = result.stderr ?? "";
-  if (result.status !== 0 && !options.allowFailure) {
-    throw new Error(
-      `Command failed (exit ${result.status}): ${line}
-` + failureDetail(stdout, stderr)
-    );
-  }
-  return { status: result.status, stdout, stderr };
-}
-
-// plugin-contract.ts
-function verifyPluginContract(packagePath, options = {}) {
-  const level = options.level ?? "basic";
-  const root = fs.realpathSync(packagePath);
-  const manifestPath = path.join(root, "package.json");
-  const manifest = JSON.parse(
-    fs.readFileSync(manifestPath, "utf8")
-  );
-  const packageName = typeof manifest.name === "string" ? manifest.name : "(unnamed package)";
-  const capabilities = options.capabilities ?? inferCapabilities(manifest);
-  const fixture = findTrustedFixture(root, manifest, options.fixtures ?? []);
-  const results = [
-    ...verifyManifest(root, manifest),
-    ...verifyDeclaredCapabilities(
-      manifest,
-      capabilities,
-      level,
-      fixture !== null
-    ),
-    ...verifyFixture(manifest, fixture, options.fixtures ?? [], level),
-    ...level === "full" ? verifyPackedManifest(root, manifest) : []
-  ];
-  const passed = results.every((result) => result.status !== "FAIL");
-  return {
-    packagePath: root,
-    packageName,
-    level,
-    capabilities,
-    results,
-    passed,
-    complete: passed && results.every(
-      (result) => result.status !== "UNVERIFIED" && result.status !== "UNSUPPORTED"
-    )
-  };
-}
-function formatPluginContractReport(report) {
-  const executed = report.results.filter((result) => result.executed).length;
-  const failed = report.results.filter(
-    (result) => result.status === "FAIL"
-  ).length;
-  const lines = [
-    `Plugin Contract Lab: ${report.packageName}`,
-    `level: ${report.level}; capabilities: ${report.capabilities.join(", ")}`,
-    `executed: ${executed}; not executed: ${report.results.length - executed}; failed: ${failed}`
-  ];
-  for (const result of report.results) {
-    lines.push(
-      `${result.status.padEnd(11)} ${result.contract}${result.executed ? "" : " (not executed)"}: expected ${result.expected}; actual ${result.actual}`
-    );
-    if (result.guidance) lines.push(`             ${result.guidance}`);
-  }
-  lines.push(
-    report.passed ? report.complete ? "Verification completed without contract failures." : "Verification incomplete: some requested contracts were not executed." : "Verification failed. Fix the failed contracts and rerun the same command."
-  );
-  return lines.join("\n");
-}
-function inferCapabilities(manifest) {
-  const exports = exportEntries(manifest.exports);
-  return [
-    "package",
-    ...exports.has("./client") || exports.has("./style.css") ? ["client"] : []
-  ];
-}
-function verifyManifest(root, manifest) {
-  const results = [];
-  const exports = exportEntries(manifest.exports);
-  if (typeof manifest.name !== "string" || manifest.name.length === 0) {
-    results.push(
-      fail(
-        "package.name",
-        "a non-empty npm package name",
-        String(manifest.name)
-      )
-    );
-  }
-  if (!exports.has(".")) {
-    results.push(fail("package.exports", 'a root "." export', "missing"));
-    return results;
-  }
-  for (const [subpath, target] of exports) {
-    const importPath = targetPath(target, "import");
-    const typesPath = targetPath(target, "types");
-    if (importPath === void 0 && !subpath.endsWith(".css")) {
-      results.push(fail(`exports.${subpath}`, "an import target", "missing"));
-      continue;
-    }
-    for (const [kind, relative] of [
-      ["import", importPath],
-      ["types", typesPath]
-    ]) {
-      if (relative === void 0) continue;
-      const targetPathname = path.resolve(root, relative);
-      if (!isInside(root, targetPathname) || !fs.existsSync(targetPathname)) {
-        results.push(
-          fail(
-            `exports.${subpath}.${kind}`,
-            `an existing file inside the package`,
-            relative
-          )
-        );
-      }
-    }
-  }
-  if (typeof manifest.types === "string" && !fs.existsSync(path.join(root, manifest.types))) {
-    results.push(
-      fail("package.types", "an existing declaration file", manifest.types)
-    );
-  }
-  if (results.length === 0) {
-    results.push(
-      pass(
-        "package.exports",
-        "published exports and types exist",
-        "all declared targets exist"
-      )
-    );
-  }
-  return results;
-}
-function verifyDeclaredCapabilities(manifest, capabilities, level, hasTrustedFixture) {
-  const exports = exportEntries(manifest.exports);
-  const results = [];
-  if (capabilities.includes("client")) {
-    results.push(
-      exports.has("./client") ? pass("client.entry", "a public ./client export", "declared") : fail("client.entry", "a public ./client export", "missing")
-    );
-    results.push(
-      exports.has("./style.css") ? pass("client.css", "a public ./style.css export", "declared") : fail("client.css", "a public ./style.css export", "missing")
-    );
-  }
-  for (const capability of capabilities) {
-    if (capability === "package" || capability === "client") continue;
-    results.push({
-      contract: `${capability}.runtime`,
-      status: level === "basic" ? "SKIP" : "UNVERIFIED",
-      expected: "an explicit fixture supplied by the plugin author",
-      actual: hasTrustedFixture ? "trusted fixture registered; capability-specific coverage is not declared" : "no fixture declaration",
-      guidance: "Add a focused plugin test or run the site integration that exercises this capability.",
-      executed: false
-    });
-  }
-  if (level !== "basic" && !capabilities.includes("plugin") && !hasTrustedFixture) {
-    results.push({
-      contract: "plugin.runtime",
-      status: "UNSUPPORTED",
-      expected: "a plugin factory fixture",
-      actual: "package metadata cannot safely execute arbitrary plugin code",
-      guidance: "Register a repository-owned fixture; the verifier does not sandbox third-party code.",
-      executed: false
-    });
-  }
-  return results;
-}
-function findTrustedFixture(root, manifest, fixtures) {
-  if (typeof manifest.name !== "string") return null;
-  return fixtures.find(
-    (fixture) => fixture.packageName === manifest.name && isSameDirectory(root, fixture.packageDirectory)
-  ) ?? null;
-}
-function verifyFixture(manifest, fixture, fixtures, level) {
-  if (level === "basic") return [];
-  const packageName = typeof manifest.name === "string" ? manifest.name : "(unnamed package)";
-  if (!fixture) {
-    const registeredByName = fixtures.some(
-      (candidate) => candidate.packageName === packageName
-    );
-    return [
-      {
-        contract: "fixture.registry",
-        status: "UNVERIFIED",
-        expected: `a trusted fixture registered for ${packageName} at this exact directory`,
-        actual: registeredByName ? "a fixture is registered for a different package directory" : "no trusted fixture is registered",
-        guidance: "The verifier runs only repository-owned fixtures registered for the exact package name and directory. No plugin code was executed.",
-        executed: false
-      }
-    ];
-  }
-  const fullCommand = level === "full" ? fixture.full : void 0;
-  const useFull = fullCommand !== void 0;
-  const command = fullCommand ?? fixture.integration;
-  const contract = useFull ? "fixture.full" : "fixture.integration";
-  const executed = executeFixtureCommand(contract, command);
-  const results = [executed];
-  if (level !== "full") return results;
-  if (!useFull) {
-    results.push({
-      contract: "fixture.browser",
-      status: "UNVERIFIED",
-      expected: "a browser fixture command",
-      actual: "no full fixture is registered",
-      guidance: "Register a full fixture that runs browser assertions; integration output does not prove browser behavior.",
-      executed: false
-    });
-    return results;
-  }
-  if (!command.browser) {
-    results.push({
-      contract: "fixture.browser",
-      status: "UNVERIFIED",
-      expected: "a fixture command that runs a real browser",
-      actual: "the full fixture is not marked as a browser fixture",
-      guidance: "Mark the command as a browser fixture only when it launches a browser. A passing build is not browser verification.",
-      executed: false
-    });
-    return results;
-  }
-  results.push(
-    executed.status === "PASS" ? pass(
-      "fixture.browser",
-      "trusted fixture browser assertions pass",
-      "fixture ran browser assertions and exited 0"
-    ) : {
-      contract: "fixture.browser",
-      status: "FAIL",
-      expected: "trusted fixture browser assertions pass",
-      actual: "the full fixture command failed",
-      guidance: "Inspect the fixture output. Browser behavior is not verified while the command fails.",
-      executed: true
-    }
-  );
-  return results;
-}
-function executeFixtureCommand(contract, command) {
-  try {
-    const result = run(command.command, command.args, {
-      cwd: command.cwd,
-      allowFailure: true
-    });
-    const output = [result.stdout, result.stderr].map((text) => text.trim()).filter(Boolean).join("\n");
-    const commandLine = [command.command, ...command.args].join(" ");
-    if (result.status === 0) {
-      return pass(
-        contract,
-        `${commandLine} exits 0`,
-        "trusted fixture command completed"
-      );
-    }
-    return {
-      contract,
-      status: "FAIL",
-      expected: `${commandLine} exits 0`,
-      actual: `exit ${result.status}${output ? `
-${tail(output, 40)}` : ""}`,
-      guidance: "Inspect the fixture output and rerun the same command.",
-      executed: true
-    };
-  } catch (error) {
-    return {
-      contract,
-      status: "FAIL",
-      expected: `${[command.command, ...command.args].join(" ")} exits 0`,
-      actual: error instanceof Error ? error.message : String(error),
-      guidance: "The trusted fixture could not start. Check the command and its working directory.",
-      executed: false
-    };
-  }
-}
-function tail(text, lines) {
-  return text.split(/\r?\n/).slice(-lines).join("\n");
-}
-function isSameDirectory(left, right) {
-  try {
-    return fs.realpathSync(left) === fs.realpathSync(right);
-  } catch {
-    return false;
-  }
-}
-function verifyPackedManifest(root, manifest) {
-  const temp = fs.mkdtempSync(
-    path.join(os.tmpdir(), "riebeckite-plugin-contract-")
-  );
-  try {
-    const packed = run(
-      "pnpm",
-      [
-        "--config.ignore-scripts=true",
-        "--config.ignore-pnpmfile=true",
-        "pack",
-        "--pack-destination",
-        temp
-      ],
-      {
-        cwd: root,
-        allowFailure: true
-      }
-    );
-    if (packed.status !== 0) {
-      return [
-        fail(
-          "package.pack",
-          "pnpm pack succeeds",
-          packed.stderr.trim() || packed.stdout.trim() || "pnpm pack failed"
-        )
-      ];
-    }
-    const tarball = fs.readdirSync(temp).find((name) => name.endsWith(".tgz"));
-    if (!tarball)
-      return [fail("package.pack", "a .tgz tarball", "none produced")];
-    const listed = run("tar", ["-tzf", path.join(temp, tarball)], {
-      allowFailure: true
-    });
-    if (listed.status !== 0)
-      return [
-        fail("package.tarball", "a readable tarball", listed.stderr.trim())
-      ];
-    const files = new Set(listed.stdout.split(/\r?\n/));
-    const missing = ["package/package.json", "package/dist/"].filter(
-      (entry) => ![...files].some((file) => file === entry || file.startsWith(entry))
-    );
-    const lifecycleScripts = declaredPackScripts(manifest);
-    return missing.length === 0 ? [
-      pass(
-        "package.tarball",
-        "package.json and dist/ in npm pack output",
-        `present; lifecycle scripts disabled; pnpmfile disabled${lifecycleScripts.length > 0 ? ` (${lifecycleScripts.join(", ")} declared)` : ""}`
-      )
-    ] : [
-      fail(
-        "package.tarball",
-        "package.json and dist/ in npm pack output",
-        `missing ${missing.join(", ")}`
-      )
-    ];
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-}
-function declaredPackScripts(manifest) {
-  if (typeof manifest.scripts !== "object" || manifest.scripts === null || Array.isArray(manifest.scripts))
-    return [];
-  const scripts = manifest.scripts;
-  return ["prepack", "prepare", "postpack"].filter(
-    (name) => typeof scripts[name] === "string"
-  );
-}
-function exportEntries(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return /* @__PURE__ */ new Map();
-  return new Map(
-    Object.entries(value).filter(
-      ([key]) => key === "." || key.startsWith("./")
-    )
-  );
-}
-function targetPath(target, condition) {
-  if (typeof target === "string")
-    return condition === "import" ? target : void 0;
-  const value = target[condition];
-  return typeof value === "string" ? value : void 0;
-}
-function isInside(root, target) {
-  const relative = path.relative(root, target);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
-}
-function pass(contract, expected, actual) {
-  return { contract, status: "PASS", expected, actual, executed: true };
-}
-function fail(contract, expected, actual) {
-  return {
-    contract,
-    status: "FAIL",
-    expected,
-    actual,
-    guidance: "Correct the package contract and rerun the command.",
-    executed: true
-  };
-}
-export {
-  formatPluginContractReport,
-  verifyPluginContract
-};