@ricsam/quickjs-test-environment 0.0.1 → 0.2.0

package/README.md

@@ -1,45 +1,75 @@
 # @ricsam/quickjs-test-environment
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/quickjs-test-environment`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+Test primitives for running tests in sandboxed QuickJS. Provides a Bun/Jest/Vitest-compatible API with handler-based result streaming.
+
+```typescript
+import { setupTestEnvironment } from "@ricsam/quickjs-test-environment";
+
+const handle = setupTestEnvironment(context, {
+  onTestPass: (test) => console.log(`✓ ${test.fullName}`),
+  onTestFail: (test) => console.log(`✗ ${test.fullName}: ${test.error?.message}`),
+  onRunComplete: (results) => {
+    console.log(`\n${results.passed}/${results.total} tests passed`);
+  },
+});
+```
+
+**Injected Globals:**
+- `describe`, `it`, `test` (with `.skip`, `.only`, `.todo` modifiers)
+- `beforeAll`, `afterAll`, `beforeEach`, `afterEach`
+- `expect` with matchers (`toBe`, `toEqual`, `toThrow`, etc.) and modifiers (`.not`, `.resolves`, `.rejects`)
+
+**Usage in QuickJS:**
+
+```javascript
+describe("Math operations", () => {
+  beforeEach(() => {
+    // setup before each test
+  });
+
+  it("should add numbers", () => {
+    expect(1 + 1).toBe(2);
+  });
+
+  it("should multiply numbers", async () => {
+    await Promise.resolve();
+    expect(2 * 3).toEqual(6);
+  });
+
+  describe("edge cases", () => {
+    it.skip("should handle infinity", () => {
+      expect(1 / 0).toBe(Infinity);
+    });
+  });
+});
+```
+
+**Running tests from host:**
+
+```typescript
+// Load untrusted test code
+context.evalCode(userProvidedTestCode);
+
+// Check test count
+console.log(`Found ${handle.getTestCount()} tests`);
+
+// Run all registered tests
+const results = await handle.run();
+console.log(`${results.passed}/${results.total} passed`);
+
+// Reset for re-running (optional)
+handle.reset();
+
+handle.dispose();
+```
+
+**Event Handlers:**
+
+| Handler | Description |
+|---------|-------------|
+| `onSuiteStart` | Called when a describe block begins |
+| `onSuiteEnd` | Called when a describe block completes |
+| `onTestStart` | Called before each test runs |
+| `onTestPass` | Called when a test passes |
+| `onTestFail` | Called when a test fails |
+| `onRunComplete` | Called after all tests complete |

package/dist/cjs/index.cjs

@@ -0,0 +1,39 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/test-environment/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  setupTestEnvironment: () => import_setup.setupTestEnvironment
+});
+module.exports = __toCommonJS(exports_src);
+var import_setup = require("./setup.ts");
+})
+
+//# debugId=42D879EBF19B460064756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export { setupTestEnvironment } from \"./setup.ts\";\n\nexport type {\n  SetupTestOptions,\n  TestEnvironmentHandle,\n  SuiteInfo,\n  SuiteResult,\n  TestInfo,\n  TestResult,\n  TestError,\n  RunResults,\n} from \"./types.ts\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAqC,IAArC;",
+  "debugId": "42D879EBF19B460064756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-test-environment",
+  "version": "0.2.0",
+  "type": "commonjs"
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,8 @@
+// @bun
+// packages/test-environment/src/index.ts
+import { setupTestEnvironment } from "./setup.ts";
+export {
+  setupTestEnvironment
+};
+
+//# debugId=BFD175E53A6D950064756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "export { setupTestEnvironment } from \"./setup.ts\";\n\nexport type {\n  SetupTestOptions,\n  TestEnvironmentHandle,\n  SuiteInfo,\n  SuiteResult,\n  TestInfo,\n  TestResult,\n  TestError,\n  RunResults,\n} from \"./types.ts\";\n"
+  ],
+  "mappings": ";;AAAA;",
+  "debugId": "BFD175E53A6D950064756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-test-environment",
+  "version": "0.2.0",
+  "type": "module"
+}

package/dist/types/handle.d.ts

@@ -0,0 +1,2 @@
+import type { TestEnvironmentHandle, TestState } from "./types.ts";
+export declare function createTestEnvironmentHandle(state: TestState): TestEnvironmentHandle;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { setupTestEnvironment } from "./setup.ts";
+export type { SetupTestOptions, TestEnvironmentHandle, SuiteInfo, SuiteResult, TestInfo, TestResult, TestError, RunResults, } from "./types.ts";

package/dist/types/setup.d.ts

@@ -0,0 +1,3 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { SetupTestOptions, TestEnvironmentHandle } from "./types.ts";
+export declare function setupTestEnvironment(context: QuickJSContext, options?: SetupTestOptions): TestEnvironmentHandle;

package/dist/types/types.d.ts

@@ -0,0 +1,93 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+import type { StateMap, CoreHandle } from "@ricsam/quickjs-core";
+export interface SetupTestOptions {
+    onSuiteStart?: (suite: SuiteInfo) => void;
+    onSuiteEnd?: (suite: SuiteResult) => void;
+    onTestStart?: (test: TestInfo) => void;
+    onTestPass?: (test: TestResult) => void;
+    onTestFail?: (test: TestResult) => void;
+    onRunComplete?: (results: RunResults) => void;
+    stateMap?: StateMap;
+    coreHandle?: CoreHandle;
+}
+export interface TestEnvironmentHandle {
+    readonly stateMap: StateMap;
+    run(): Promise<RunResults>;
+    hasTests(): boolean;
+    getTestCount(): number;
+    reset(): void;
+    dispose(): void;
+}
+export interface SuiteInfo {
+    name: string;
+    path: string[];
+    fullName: string;
+}
+export interface SuiteResult extends SuiteInfo {
+    passed: number;
+    failed: number;
+    skipped: number;
+    duration: number;
+}
+export interface TestInfo {
+    name: string;
+    suite: string[];
+    fullName: string;
+}
+export interface TestResult extends TestInfo {
+    status: "pass" | "fail" | "skip" | "todo";
+    duration: number;
+    error?: TestError;
+}
+export interface TestError {
+    message: string;
+    stack?: string;
+    expected?: unknown;
+    actual?: unknown;
+    matcherName?: string;
+}
+export interface RunResults {
+    passed: number;
+    failed: number;
+    skipped: number;
+    todo: number;
+    total: number;
+    duration: number;
+    suites: SuiteResult[];
+    tests: TestResult[];
+    success: boolean;
+}
+export interface TestState {
+    context: QuickJSContext;
+    stateMap: StateMap;
+    handlers: {
+        onSuiteStart?: (suite: SuiteInfo) => void;
+        onSuiteEnd?: (suite: SuiteResult) => void;
+        onTestStart?: (test: TestInfo) => void;
+        onTestPass?: (test: TestResult) => void;
+        onTestFail?: (test: TestResult) => void;
+        onRunComplete?: (results: RunResults) => void;
+    };
+    suites: RegisteredSuite[];
+    currentSuite: RegisteredSuite | null;
+}
+export interface RegisteredSuite {
+    id: string;
+    name: string;
+    path: string[];
+    tests: RegisteredTest[];
+    beforeAll: QuickJSHandle[];
+    afterAll: QuickJSHandle[];
+    beforeEach: QuickJSHandle[];
+    afterEach: QuickJSHandle[];
+    children: RegisteredSuite[];
+    parent: RegisteredSuite | null;
+    modifier: "none" | "skip" | "only" | "todo";
+}
+export interface RegisteredTest {
+    id: string;
+    name: string;
+    fn: QuickJSHandle;
+    suite: RegisteredSuite;
+    modifier: "none" | "skip" | "only" | "todo";
+}

package/package.json

@@ -1,10 +1,53 @@
 {
   "name": "@ricsam/quickjs-test-environment",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/quickjs-test-environment",
+  "version": "0.2.0",
+  "description": "Test environment for QuickJS with Bun/Jest/Vitest-compatible primitives",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    }
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "quickjs-emscripten": ">=0.31.0"
+  },
+  "dependencies": {
+    "@ricsam/quickjs-core": "^0.2.0"
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-qjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-qjs/issues"
+  },
+  "homepage": "https://github.com/ricsam/richie-qjs#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "quickjs",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "wasm",
+    "emscripten"
+  ],
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}