@presolve/testing 0.1.0-alpha.8 → 0.2.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@presolve/testing",
-  "version": "0.1.0-alpha.8",
+  "version": "0.2.0-beta.1",
   "description": "Testing helpers for Presolve compiler products.",
   "license": "MIT OR Apache-2.0",
   "type": "module",
@@ -11,11 +11,14 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "alpha"
+    "tag": "beta"
   },
   "exports": {
     ".": "./src/index.js"
   },
+  "dependencies": {
+    "@presolve/vite": "0.2.0-beta.1"
+  },
   "scripts": {
     "test": "node test/smoke.mjs"
   }

package/src/index.js

@@ -1,3 +1,7 @@
+import { createPresolveVitePlugin } from "@presolve/vite";
+
+export const PRESOLVE_TEST_INTEGRATION_SCHEMA_VERSION = 1;
+
 /** Compares caller-owned canonical byte sequences without interpretation. */
 export function equalCanonicalBytes(expected, actual) {
   if (!(expected instanceof Uint8Array) || !(actual instanceof Uint8Array)) return false;
@@ -10,3 +14,76 @@ export function declaredTest({ name, command, lane }) {
   if (!name || !command || !lane) throw new TypeError("declared test requires name, command, and lane");
   return Object.freeze({ name, command, lane });
 }
+
+/**
+ * Creates the Vitest-facing Vite configuration for an already-published
+ * compiler product. The plugin remains the sole manifest validator; this
+ * package neither parses source nor evaluates compiler diagnostics.
+ */
+export function createPresolveVitestConfig({ compilerProduct, readArtifact, fixtures = [] } = {}) {
+  return createTestIntegration({
+    runner: "vitest",
+    compilerProduct,
+    readArtifact,
+    fixtures,
+  });
+}
+
+/**
+ * Creates Playwright project metadata for an already-published application.
+ * The returned Vite plugin is for the caller's dev-server setup; Playwright
+ * receives only a validated origin and compiler publication identity.
+ */
+export function createPresolvePlaywrightProject({
+  compilerProduct,
+  readArtifact,
+  baseURL,
+  fixtures = [],
+} = {}) {
+  const integration = createTestIntegration({
+    runner: "playwright",
+    compilerProduct,
+    readArtifact,
+    fixtures,
+  });
+  if (typeof baseURL !== "string" || !isHttpOrigin(baseURL)) {
+    throw new TypeError("Presolve Playwright integration requires an absolute HTTP(S) origin baseURL");
+  }
+  return Object.freeze({
+    ...integration,
+    use: Object.freeze({ baseURL: new URL(baseURL).origin }),
+  });
+}
+
+function createTestIntegration({ runner, compilerProduct, readArtifact, fixtures }) {
+  if (!Array.isArray(fixtures)) {
+    throw new TypeError("Presolve test integration fixtures must be an array");
+  }
+  const vitePlugin = createPresolveVitePlugin({ compilerProduct, readArtifact });
+  return Object.freeze({
+    schemaVersion: PRESOLVE_TEST_INTEGRATION_SCHEMA_VERSION,
+    runner,
+    compiler: vitePlugin.api,
+    fixtures: Object.freeze(fixtures.map(normalizeFixture)),
+    vite: Object.freeze({ plugins: Object.freeze([vitePlugin]) }),
+  });
+}
+
+function normalizeFixture(fixture) {
+  if (!fixture || typeof fixture !== "object" || Array.isArray(fixture)
+    || typeof fixture.name !== "string" || !fixture.name
+    || typeof fixture.route !== "string" || !fixture.route.startsWith("/")) {
+    throw new TypeError("Presolve test fixtures require a non-empty name and absolute route");
+  }
+  return Object.freeze({ name: fixture.name, route: fixture.route });
+}
+
+function isHttpOrigin(value) {
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:")
+      && url.pathname === "/" && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}

package/test/smoke.mjs

@@ -1,6 +1,45 @@
-import { declaredTest, equalCanonicalBytes } from "../src/index.js";
+import { createHash } from "node:crypto";
+import {
+  createPresolvePlaywrightProject,
+  createPresolveVitestConfig,
+  declaredTest,
+  equalCanonicalBytes,
+} from "../src/index.js";
 
 if (!equalCanonicalBytes(new Uint8Array([1, 2]), new Uint8Array([1, 2]))) throw new Error("equal bytes must compare");
 if (equalCanonicalBytes(new Uint8Array([1]), new Uint8Array([2]))) throw new Error("different bytes must not compare");
 const test = declaredTest({ name: "compiler", command: "cargo test -p presolve-compiler --lib", lane: "deterministic" });
 if (test.lane !== "deterministic" || !Object.isFrozen(test)) throw new Error("declared test metadata must be immutable");
+
+const runtime = "export const runtime = 1;\n";
+const vitest = createPresolveVitestConfig({
+  compilerProduct: {
+    manifest: {
+      schema_version: 1,
+      compiler_contract: "presolve-application-publication:1",
+      workspace_snapshot_id: "testing-fixture",
+      artifacts: [{ path: "runtime.js", digest: createHash("sha256").update(runtime).digest("hex") }],
+    },
+  },
+  readArtifact: () => runtime,
+  fixtures: [{ name: "home", route: "/" }],
+});
+if (vitest.runner !== "vitest" || vitest.vite.plugins.length !== 1 || vitest.fixtures[0].route !== "/") {
+  throw new Error("Vitest integration must preserve the compiler Vite plugin and declared route fixture");
+}
+const playwright = createPresolvePlaywrightProject({
+  compilerProduct: {
+    manifest: {
+      schema_version: 1,
+      compiler_contract: "presolve-application-publication:1",
+      workspace_snapshot_id: "testing-fixture",
+      artifacts: [{ path: "runtime.js", digest: createHash("sha256").update(runtime).digest("hex") }],
+    },
+  },
+  readArtifact: () => runtime,
+  baseURL: "http://127.0.0.1:4173/",
+  fixtures: [{ name: "home", route: "/" }],
+});
+if (playwright.runner !== "playwright" || playwright.use.baseURL !== "http://127.0.0.1:4173") {
+  throw new Error("Playwright integration must retain the caller-owned test origin");
+}