@cloudflare/vitest-plugin 0.0.0 → 1.1.0

package/README.md

@@ -0,0 +1,12 @@
+# `@cloudflare/vitest-plugin`
+
+The Workers Vitest integration allows you to write Vitest tests that run inside the Workers runtime.
+Refer to the [documentation](https://developers.cloudflare.com/workers/testing/vitest-integration/) and [examples](https://github.com/cloudflare/workers-sdk/tree/main/fixtures/vitest-plugin-examples/) for more information.
+
+- ✅ Supports both **unit tests** and **integration tests**
+- 📚 Provides direct access to Workers runtime APIs and bindings
+- 📦 Implements isolated per-test storage
+- 🔥 Runs tests fully-locally using [Miniflare](https://miniflare.dev/)
+- ⚡️ Leverages Vitest's hot-module reloading for near instant reruns
+- ↩️ Provides a declarative interface for mocking outbound requests
+- 🧩 Supports projects with multiple Workers

package/dist/pool/chunk-Q72B4Q5Z-izl5Qmnx.mjs

@@ -0,0 +1,70 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create$1 = Object.create;
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames$1 = Object.getOwnPropertyNames;
+var __getProtoOf$1 = Object.getPrototypeOf;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __commonJS$1 = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames$1(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps$1 = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames$1(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp$1.call(to, key) && key !== except) __defProp$1(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc$1(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(__getProtoOf$1(mod)) : {}, __copyProps$1(isNodeMode || !mod || !mod.__esModule ? __defProp$1(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require$1 = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../workers-utils/dist/chunk-Q72B4Q5Z.mjs
+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 __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __require = /* @__PURE__ */ ((x) => typeof __require$1 !== "undefined" ? __require$1 : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof __require$1 !== "undefined" ? __require$1 : a)[b] }) : x)(function(x) {
+	if (typeof __require$1 !== "undefined") return __require$1.apply(this, arguments);
+	throw Error("Dynamic require of \"" + x + "\" is not supported");
+});
+var __commonJS = (cb, mod) => function __require2() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[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
+export { __toESM as a, __toESM$1 as c, __require as i, __export as n, __commonJS$1 as o, __name as r, __require$1 as s, __commonJS as t };
+//# sourceMappingURL=chunk-Q72B4Q5Z-izl5Qmnx.mjs.map

package/dist/pool/chunk-Q72B4Q5Z-izl5Qmnx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-Q72B4Q5Z-izl5Qmnx.mjs","names":[],"sources":["../../../workers-utils/dist/chunk-Q72B4Q5Z.mjs"],"sourcesContent":["var __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\nvar __require = /* @__PURE__ */ ((x) => typeof require !== \"undefined\" ? require : typeof Proxy !== \"undefined\" ? new Proxy(x, {\n  get: (a, b) => (typeof require !== \"undefined\" ? require : a)[b]\n}) : x)(function(x) {\n  if (typeof require !== \"undefined\") return require.apply(this, arguments);\n  throw Error('Dynamic require of \"' + x + '\" is not supported');\n});\nvar __commonJS = (cb, mod) => function __require2() {\n  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n};\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n  // If the importer is in node compatibility mode or this is not an ESM\n  // file that has been converted to a CommonJS file using a Babel-\n  // compatible transform (i.e. \"__esModule\" has not been set), then set\n  // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n  isNodeMode || !mod || !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n  mod\n));\n\nexport { __commonJS, __export, __name, __require, __toESM };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAI,WAAW,OAAO;AACtB,IAAI,YAAY,OAAO;AACvB,IAAI,mBAAmB,OAAO;AAC9B,IAAI,oBAAoB,OAAO;AAC/B,IAAI,eAAe,OAAO;AAC1B,IAAI,eAAe,OAAO,UAAU;AACpC,IAAI,UAAU,QAAQ,UAAU,UAAU,QAAQ,QAAQ;CAAE;CAAO,cAAc;CAAM,CAAC;AACxF,IAAI,YAA4B,kBAAE,MAAM,uBAAmB,4BAAwB,OAAO,UAAU,cAAc,IAAI,MAAM,GAAG,EAC7H,MAAM,GAAG,OAAO,uBAAmB,4BAAwB,GAAG,IAC/D,CAAC,GAAG,GAAG,SAAS,GAAG;AAClB,KAAI,uBAAmB,YAAa,oBAAe,MAAM,MAAM,UAAU;AACzE,OAAM,MAAM,0BAAyB,IAAI,sBAAqB;EAC9D;AACF,IAAI,cAAc,IAAI,QAAQ,SAAS,aAAa;AAClD,QAAO,QAAQ,GAAG,GAAG,kBAAkB,GAAG,CAAC,MAAM,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,IAAI,EAAE,IAAI;;AAE7F,IAAI,YAAY,QAAQ,QAAQ;AAC9B,MAAK,IAAI,QAAQ,IACf,WAAU,QAAQ,MAAM;EAAE,KAAK,IAAI;EAAO,YAAY;EAAM,CAAC;;AAEjE,IAAI,eAAe,IAAI,MAAM,QAAQ,SAAS;AAC5C,KAAI,QAAQ,OAAO,SAAS,YAAY,OAAO,SAAS,YACtD;OAAK,IAAI,OAAO,kBAAkB,KAAK,CACrC,KAAI,CAAC,aAAa,KAAK,IAAI,IAAI,IAAI,QAAQ,OACzC,WAAU,IAAI,KAAK;GAAE,WAAW,KAAK;GAAM,YAAY,EAAE,OAAO,iBAAiB,MAAM,IAAI,KAAK,KAAK;GAAY,CAAC;;AAExH,QAAO;;AAET,IAAI,WAAW,KAAK,YAAY,YAAY,SAAS,OAAO,OAAO,SAAS,aAAa,IAAI,CAAC,GAAG,EAAE,EAAE,YAKnG,cAAc,CAAC,OAAO,CAAC,IAAI,aAAa,UAAU,QAAQ,WAAW;CAAE,OAAO;CAAK,YAAY;CAAM,CAAC,GAAG,QACzG,IACD"}

package/dist/pool/index.d.mts

@@ -0,0 +1,130 @@
+import * as miniflare0 from "miniflare";
+import { LegacyWorkerOptions, Miniflare, Request, Response, V4ModuleRule } from "miniflare";
+import { z } from "zod";
+import { PoolRunnerInitializer, TestProject, Vite, Vitest } from "vitest/node";
+import { ProvidedContext } from "vitest";
+
+//#region src/pool/config.d.ts
+declare const WorkersPoolOptionsSchema: z.ZodObject<{
+  main: z.ZodOptional<z.ZodString>;
+  remoteBindings: z.ZodDefault<z.ZodBoolean>;
+  verbose: z.ZodOptional<z.ZodBoolean>;
+  additionalExports: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"WorkerEntrypoint">, z.ZodLiteral<"DurableObject">, z.ZodLiteral<"WorkflowEntrypoint">]>>>;
+  miniflare: z.ZodOptional<z.ZodObject<{
+    workers: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+  }, z.core.$loose>>;
+  wrangler: z.ZodOptional<z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+    environment: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  experimental: z.ZodOptional<z.ZodObject<{
+    newConfig: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+      configPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type CompatibleWorkerOptions = LegacyWorkerOptions & {
+  /** @deprecated Use `cacheAPI` instead. */
+  cache?: LegacyWorkerOptions["cacheAPI"];
+};
+type SourcelessWorkerOptions = Omit<CompatibleWorkerOptions, "script" | "scriptPath" | "modules" | "modulesRoot"> & {
+  modulesRules?: V4ModuleRule[];
+};
+type WorkersPoolOptions = z.input<typeof WorkersPoolOptionsSchema> & {
+  miniflare?: SourcelessWorkerOptions & {
+    workers?: CompatibleWorkerOptions[];
+  };
+};
+type WorkersPoolOptionsWithDefines = WorkersPoolOptions & {
+  defines?: Record<string, string>;
+  moduleRules?: V4ModuleRule[];
+  /**
+   * Details of the configuration file these options were resolved from. Set
+   * while parsing; not a user-facing option. Undefined when the project
+   * configures the Worker entirely through `miniflare` options.
+   */
+  resolvedConfig?: {
+    /** Absolute path of the configuration file. */
+    path: string;
+    /**
+     * Whether that file is a `cloudflare.config.ts` rather than a Wrangler
+     * configuration file. Determines how config fields are named in errors.
+     */
+    newConfig: boolean;
+    /**
+     * The Worker name declared in the configuration file, before any
+     * environment name is appended. Self-referential service, tail and
+     * Workflow bindings are written against this name.
+     */
+    workerName: string | undefined;
+  };
+};
+//#endregion
+//#region src/pool/plugin.d.ts
+type ProvidedContextKeys = keyof ProvidedContext & string;
+declare const explicitInjectTypeArgumentRequired: unique symbol;
+type ExplicitInjectTypeArgumentRequired = {
+  readonly [explicitInjectTypeArgumentRequired]: never;
+};
+type WorkerPoolOptionsContextInject = [ProvidedContextKeys] extends [never] ? <T = unknown>(key: string) => T : {
+  <K extends ProvidedContextKeys>(key: K): ProvidedContext[K];
+  <T = ExplicitInjectTypeArgumentRequired>(key: string & (T extends ExplicitInjectTypeArgumentRequired ? never : unknown)): T;
+};
+interface WorkerPoolOptionsContext {
+  /**
+   * Access values provided by `globalSetup()` (e.g. ports of servers started
+   * during setup) for use in Miniflare options (e.g. bindings, upstream,
+   * hyperdrives, ...).
+   *
+   * Known `ProvidedContext` keys preserve Vitest's inference and key checking
+   * when the consuming project's augmentation is visible. Use an explicit type
+   * argument for keys provided at runtime but not declared in `ProvidedContext`.
+   * If pnpm resolves a separate Vitest copy and the keys collapse to `never`,
+   * fall back to the wider inject signature instead.
+   */
+  inject: WorkerPoolOptionsContextInject;
+}
+declare function cloudflareTest(options: WorkersPoolOptions | ((ctx: WorkerPoolOptionsContext) => Promise<WorkersPoolOptions> | WorkersPoolOptions)): Vite.Plugin;
+//#endregion
+//#region src/pool/pool.d.ts
+declare function cloudflarePool(poolOptions: WorkersPoolOptions | ((ctx: WorkerPoolOptionsContext) => Promise<WorkersPoolOptions> | WorkersPoolOptions)): PoolRunnerInitializer;
+//#endregion
+//#region src/shared/d1.d.ts
+type D1Migration = {
+  name: string;
+  queries: string[];
+};
+//#endregion
+//#region src/pool/d1.d.ts
+/**
+ * Reads all migrations in `migrationsPath`, ordered by migration number.
+ * Each migration will have its contents split into an array of SQL queries.
+ */
+declare function readD1Migrations(migrationsPath: string): Promise<D1Migration[]>;
+//#endregion
+//#region src/pool/pages.d.ts
+declare function poolWorkerStarted(): void;
+declare function poolWorkerStopped(): boolean;
+declare function buildPagesASSETSBinding(assetsPath: string): Promise<(request: Request) => Promise<Response>>;
+//#endregion
+//#region src/pool/index.d.ts
+declare function structuredSerializableStringify(value: unknown): string;
+declare function structuredSerializableParse(value: string): unknown;
+declare function getRunnerName(project: TestProject, testFile?: string): string;
+interface DurableObjectDesignator {
+  className: string;
+  scriptName?: string;
+  unsafeUniqueKey?: string;
+}
+/**
+ * Returns a map of Durable Objects bindings' bound names to the designators of
+ * the objects they point to.
+ */
+declare function getDurableObjectDesignators(options: WorkersPoolOptions): Map<string, DurableObjectDesignator>;
+declare function getProjectMiniflare(ctx: Vitest, project: TestProject, poolOptions: WorkersPoolOptionsWithDefines, main: string | undefined): Promise<Miniflare>;
+declare function maybeGetResolvedMainPath(project: TestProject, options: WorkersPoolOptionsWithDefines): string | undefined;
+declare function connectToMiniflareSocket(mf: Miniflare, workerName: string): Promise<miniflare0.WebSocket>;
+declare function assertCompatibleVitestVersion(ctx: Vitest): void;
+//#endregion
+export { type D1Migration, assertCompatibleVitestVersion, buildPagesASSETSBinding, cloudflarePool, cloudflareTest, connectToMiniflareSocket, getDurableObjectDesignators, getProjectMiniflare, getRunnerName, maybeGetResolvedMainPath, poolWorkerStarted, poolWorkerStopped, readD1Migrations, structuredSerializableParse, structuredSerializableStringify };
+//# sourceMappingURL=index.d.mts.map