@durable-streams/server-conformance-tests 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 durable-stream
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-BCwAaXi7.cjs

@@ -0,0 +1,31 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/cli.cjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+"use strict";
+const require_chunk = require('./chunk-BCwAaXi7.cjs');
+const node_child_process = require_chunk.__toESM(require("node:child_process"));
+const node_fs = require_chunk.__toESM(require("node:fs"));
+const node_path = require_chunk.__toESM(require("node:path"));
+const node_url = require_chunk.__toESM(require("node:url"));
+
+//#region src/cli.ts
+const __dirname$1 = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+function printUsage() {
+	console.log(`
+Durable Streams Conformance Test Runner
+
+Usage:
+  npx @durable-streams/server-conformance-tests --run <url>
+  npx @durable-streams/server-conformance-tests --watch <path> [path...] <url>
+
+Options:
+  --run              Run tests once and exit (for CI)
+  --watch <paths>    Watch source paths and rerun tests on changes (for development)
+  --help, -h         Show this help message
+
+Arguments:
+  <url>              Base URL of the Durable Streams server to test against
+
+Examples:
+  # Run tests once in CI
+  npx @durable-streams/server-conformance-tests --run http://localhost:4473
+
+  # Watch src directory and rerun tests on changes
+  npx @durable-streams/server-conformance-tests --watch src http://localhost:4473
+
+  # Watch multiple directories
+  npx @durable-streams/server-conformance-tests --watch src lib http://localhost:4473
+`);
+}
+function parseArgs(args) {
+	const result = {
+		mode: `run`,
+		watchPaths: [],
+		baseUrl: ``,
+		help: false
+	};
+	let i = 0;
+	while (i < args.length) {
+		const arg = args[i];
+		if (arg === `--help` || arg === `-h`) {
+			result.help = true;
+			return result;
+		}
+		if (arg === `--run`) {
+			result.mode = `run`;
+			i++;
+			continue;
+		}
+		if (arg === `--watch`) {
+			result.mode = `watch`;
+			i++;
+			while (i < args.length - 1) {
+				const next = args[i];
+				if (next.startsWith(`--`) || next.startsWith(`-`)) break;
+				result.watchPaths.push(next);
+				i++;
+			}
+			continue;
+		}
+		if (!arg.startsWith(`-`)) result.baseUrl = arg;
+		i++;
+	}
+	return result;
+}
+function validateArgs(args) {
+	if (!args.baseUrl) return `Error: Base URL is required`;
+	try {
+		new URL(args.baseUrl);
+	} catch {
+		return `Error: Invalid URL "${args.baseUrl}"`;
+	}
+	if (args.mode === `watch` && args.watchPaths.length === 0) return `Error: --watch requires at least one path to watch`;
+	return null;
+}
+function getTestRunnerPath() {
+	const runnerInDist = (0, node_path.join)(__dirname$1, `test-runner.js`);
+	const runnerInSrc = (0, node_path.join)(__dirname$1, `test-runner.ts`);
+	if ((0, node_fs.existsSync)(runnerInDist)) return runnerInDist;
+	return runnerInSrc;
+}
+function runTests(baseUrl) {
+	return new Promise((resolvePromise) => {
+		const runnerPath = getTestRunnerPath();
+		const vitestBin = (0, node_path.join)(__dirname$1, `..`, `node_modules`, `.bin`, `vitest`);
+		const vitestBinAlt = (0, node_path.join)(__dirname$1, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`);
+		let vitestPath = `vitest`;
+		if ((0, node_fs.existsSync)(vitestBin)) vitestPath = vitestBin;
+		else if ((0, node_fs.existsSync)(vitestBinAlt)) vitestPath = vitestBinAlt;
+		const args = [
+			`run`,
+			runnerPath,
+			`--no-coverage`,
+			`--reporter=default`,
+			`--passWithNoTests=false`
+		];
+		const child = (0, node_child_process.spawn)(vitestPath, args, {
+			stdio: `inherit`,
+			env: {
+				...process.env,
+				CONFORMANCE_TEST_URL: baseUrl,
+				FORCE_COLOR: `1`
+			},
+			shell: true
+		});
+		child.on(`close`, (code) => {
+			resolvePromise(code ?? 1);
+		});
+		child.on(`error`, (err) => {
+			console.error(`Failed to run tests: ${err.message}`);
+			resolvePromise(1);
+		});
+	});
+}
+async function runOnce(baseUrl) {
+	console.log(`Running conformance tests against ${baseUrl}\n`);
+	const exitCode = await runTests(baseUrl);
+	process.exit(exitCode);
+}
+async function runWatch(baseUrl, watchPaths) {
+	let runningProcess = null;
+	let debounceTimer = null;
+	const DEBOUNCE_MS = 300;
+	const spawnTests = () => {
+		const runnerPath = getTestRunnerPath();
+		const vitestBin = (0, node_path.join)(__dirname$1, `..`, `node_modules`, `.bin`, `vitest`);
+		const vitestBinAlt = (0, node_path.join)(__dirname$1, `..`, `..`, `..`, `node_modules`, `.bin`, `vitest`);
+		let vitestPath = `vitest`;
+		if ((0, node_fs.existsSync)(vitestBin)) vitestPath = vitestBin;
+		else if ((0, node_fs.existsSync)(vitestBinAlt)) vitestPath = vitestBinAlt;
+		const args = [
+			`run`,
+			runnerPath,
+			`--no-coverage`,
+			`--reporter=default`,
+			`--passWithNoTests=false`
+		];
+		return (0, node_child_process.spawn)(vitestPath, args, {
+			stdio: `inherit`,
+			env: {
+				...process.env,
+				CONFORMANCE_TEST_URL: baseUrl,
+				FORCE_COLOR: `1`
+			},
+			shell: true
+		});
+	};
+	const runTestsDebounced = () => {
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			if (runningProcess) {
+				runningProcess.kill(`SIGTERM`);
+				runningProcess = null;
+			}
+			console.clear();
+			console.log(`Running conformance tests against ${baseUrl}\n`);
+			runningProcess = spawnTests();
+			runningProcess.on(`close`, (code) => {
+				if (code === 0) console.log(`\nAll tests passed`);
+				else console.log(`\nTests failed (exit code: ${code})`);
+				console.log(`\nWatching for changes in: ${watchPaths.join(`, `)}`);
+				console.log(`Press Ctrl+C to exit\n`);
+				runningProcess = null;
+			});
+		}, DEBOUNCE_MS);
+	};
+	const watchers = [];
+	for (const watchPath of watchPaths) {
+		const absPath = (0, node_path.resolve)(process.cwd(), watchPath);
+		try {
+			const watcher = (0, node_fs.watch)(absPath, { recursive: true }, (eventType, filename) => {
+				if (filename && !filename.includes(`node_modules`)) {
+					console.log(`\nChange detected: ${filename}`);
+					runTestsDebounced();
+				}
+			});
+			watchers.push(watcher);
+			console.log(`Watching: ${absPath}`);
+		} catch (err) {
+			console.error(`Warning: Could not watch "${watchPath}": ${err.message}`);
+		}
+	}
+	if (watchers.length === 0) {
+		console.error(`Error: No valid paths to watch`);
+		process.exit(1);
+	}
+	process.on(`SIGINT`, () => {
+		console.log(`\n\nStopping watch mode...`);
+		watchers.forEach((w) => w.close());
+		if (runningProcess) runningProcess.kill(`SIGTERM`);
+		process.exit(0);
+	});
+	runTestsDebounced();
+	await new Promise(() => {});
+}
+async function main() {
+	const args = parseArgs(process.argv.slice(2));
+	if (args.help) {
+		printUsage();
+		process.exit(0);
+	}
+	const error = validateArgs(args);
+	if (error) {
+		console.error(error);
+		console.error(`\nRun with --help for usage information`);
+		process.exit(1);
+	}
+	if (args.mode === `watch`) await runWatch(args.baseUrl, args.watchPaths);
+	else await runOnce(args.baseUrl);
+}
+main().catch((err) => {
+	console.error(`Fatal error: ${err.message}`);
+	process.exit(1);
+});
+
+//#endregion

package/dist/cli.d.cts

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

package/dist/index.cjs

@@ -0,0 +1,3 @@
+const require_src = require('./src-mPjxiipV.cjs');
+
+exports.runConformanceTests = require_src.runConformanceTests

package/dist/index.d.cts

@@ -0,0 +1,10 @@
+//#region src/index.d.ts
+interface ConformanceTestOptions {
+  /** Base URL of the server to test */
+  baseUrl: string;
+}
+/**
+* Run the full conformance test suite against a server
+*/
+declare function runConformanceTests(options: ConformanceTestOptions): void; //#endregion
+export { ConformanceTestOptions, runConformanceTests };