update to vitest v4

Author: Techatrix

.github/workflows/main.yml

@@ -15,6 +15,7 @@ jobs:
           cache: "npm"
 
       - run: npm ci
+      - run: npm run cf-typegen
       - run: npm run typecheck
       - run: npm run lint
       - run: npm run format:check

.github/workflows/push.yml

@@ -21,4 +21,3 @@ jobs:
           apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
           accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
           environment: production
-          wranglerVersion: "4.14.1"

.gitignore

@@ -1,3 +1,4 @@
 node_modules/
 .wrangler/
 coverage/
+worker-configuration.d.ts

README.md

@@ -482,6 +482,7 @@ Artifacts that target windows must be `.zip` files. All other non windows target
 git clone https://github.com/zigtools/release-worker
 cd release-worker
 npm install
+npm run cf-typegen
 npx wrangler d1 execute staging-db-backend --local --file=./migrations/0000_initial.sql
 npm run dev
 ```

package-lock.json

@@ -6,26 +6,25 @@
     "deploy": "wrangler deploy",
     "dev": "wrangler dev",
     "start": "wrangler dev",
+    "cf-typegen": "wrangler types --strict-vars=false",
+    "typecheck": "wrangler types --strict-vars=false --check && tsc",
     "test": "vitest",
-    "cf-typegen": "wrangler types --include-runtime=false --strict-vars=false",
     "coverage": "vitest run --coverage",
-    "typecheck": "tsc",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint"
   },
   "devDependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.12.0",
-    "@cloudflare/workers-types": "^4.20250430.0",
+    "@cloudflare/vitest-pool-workers": "^0.13.0",
     "@eslint/js": "^9.8.0",
     "@types/eslint__js": "^8.42.3",
     "@types/node": "^22.15.3",
-    "@vitest/coverage-istanbul": "~3.2.0",
+    "@vitest/coverage-istanbul": "^4.1.0",
     "eslint": "^9.8.0",
     "prettier": "^3.2.5",
     "typescript": "^5.4.5",
     "typescript-eslint": "^8.10.0",
-    "vitest": "~3.2.0",
+    "vitest": "^4.1.0",
     "wrangler": "^4.59.3"
   }
 }

package.json

@@ -1,6 +1,3 @@
-declare module "cloudflare:test" {
-  interface ProvidedEnv extends Env {
-    ZIGTOOLS_DB: D1Database;
-    TEST_MIGRATIONS: D1Migration[]; // Defined in `vitest.config.ts`
-  }
+declare module "cloudflare:workers" {
+  interface ProvidedEnv extends Env {}
 }

test/env.d.ts

@@ -1,8 +1,11 @@
-import { SELF } from "cloudflare:test";
+import { env, exports } from "cloudflare:workers";
 import { test, expect } from "vitest";
 
 test("unknown URL path", async () => {
-  const response = await SELF.fetch("https://example.com/unknown", {});
+  const response = await exports.default.fetch(
+    "https://example.com/unknown",
+    {},
+  );
   expect(response.status).toBe(404);
   expect(Object.fromEntries(response.headers.entries())).toStrictEqual({
     "access-control-allow-origin": "*",
@@ -11,7 +14,7 @@ test("unknown URL path", async () => {
 });
 
 test("standard OPTIONS request", async () => {
-  const response = await SELF.fetch("https://example.com", {
+  const response = await exports.default.fetch("https://example.com", {
     method: "OPTIONS",
   });
   expect(response.status).toBe(200);
@@ -21,7 +24,7 @@ test("standard OPTIONS request", async () => {
 });
 
 test("CORS OPTIONS request", async () => {
-  const response = await SELF.fetch("https://example.com", {
+  const response = await exports.default.fetch("https://example.com", {
     method: "OPTIONS",
     headers: {
       Origin: "https://foo.example",

test/index.test.ts

@@ -1,4 +1,8 @@
-import { createExecutionContext, env, SELF } from "cloudflare:test";
+import { env, exports } from "cloudflare:workers";
+import {
+  createExecutionContext,
+  waitOnExecutionContext,
+} from "cloudflare:test";
 import assert from "node:assert";
 import { vi, describe, test, expect, beforeEach, afterEach } from "vitest";
 import {
@@ -27,7 +31,7 @@ async function searchZLSRelease(
 
 async function sendPublishForm(body: PublishRequest): Promise<Response> {
   assert(typeof env.API_TOKEN === "string" && env.API_TOKEN);
-  return await SELF.fetch(
+  return await exports.default.fetch(
     new Request("https://example.com/v1/zls/publish", {
       body: JSON.stringify(body),
       method: "POST",
@@ -121,8 +125,14 @@ function getSampleArtifacts(version: string): Record<string, ArtifactMetadata> {
 }
 
 describe("/v1/zls/publish", () => {
+  afterEach(async () => {
+    await env.ZIGTOOLS_DB.exec("DELETE FROM ZLSReleases");
+  });
+
   test("expect POST method", async () => {
-    const response = await SELF.fetch("https://example.com/v1/zls/publish");
+    const response = await exports.default.fetch(
+      "https://example.com/v1/zls/publish",
+    );
     expect(await response.text()).toBe("method must be 'POST'");
     expect(response.status).toBe(405);
   });
@@ -146,103 +156,127 @@ describe("/v1/zls/publish", () => {
 
   describe("check authorization", () => {
     test("missing Authorization header", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        method: "POST",
-      });
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          method: "POST",
+        },
+      );
 
       expect(await response.text()).toBe("Authorization failed");
       expect(response.status).toBe(401);
     });
 
     test("invalid Authorization header", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: null,
-        method: "POST",
-        headers: {
-          Authorization: "invalid",
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: null,
+          method: "POST",
+          headers: {
+            Authorization: "invalid",
+          },
         },
-      });
+      );
       expect(await response.text()).toContain(
         "Unexpected Authorization header",
       );
       expect(response.status).toBe(400);
     });
 
     test("non Basic Authorization header", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: null,
-        method: "POST",
-        headers: {
-          Authorization: "Bearer foo",
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: null,
+          method: "POST",
+          headers: {
+            Authorization: "Bearer foo",
+          },
         },
-      });
+      );
       expect(await response.text()).toBe(
         "Expected 'Basic' authentication scheme!",
       );
       expect(response.status).toBe(400);
     });
 
     test("invalid Basic Authorization header", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: null,
-        method: "POST",
-        headers: {
-          Authorization: "Basic :",
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: null,
+          method: "POST",
+          headers: {
+            Authorization: "Basic :",
+          },
         },
-      });
+      );
       expect(await response.text()).toContain(
         "Unexpected Authorization header",
       );
       expect(response.status).toBe(401);
     });
 
     test("wrong username", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: null,
-        method: "POST",
-        headers: {
-          Authorization: `Basic ${Buffer.from(`wrong:${env.API_TOKEN}`).toString("base64")}`,
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: null,
+          method: "POST",
+          headers: {
+            Authorization: `Basic ${Buffer.from(`wrong:${env.API_TOKEN}`).toString("base64")}`,
+          },
         },
-      });
+      );
       expect(await response.text()).toBe("Authorization failed");
       expect(response.status).toBe(401);
     });
 
     test("wrong password", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: null,
-        method: "POST",
-        headers: {
-          Authorization: `Basic ${Buffer.from("admin:wrong").toString("base64")}`,
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: null,
+          method: "POST",
+          headers: {
+            Authorization: `Basic ${Buffer.from("admin:wrong").toString("base64")}`,
+          },
         },
-      });
+      );
       expect(await response.text()).toBe("Authorization failed");
       expect(response.status).toBe(401);
     });
   });
 
   describe("validate request body", () => {
     test("body is not a json", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: null,
-        method: "POST",
-        headers: {
-          Authorization: `Basic ${Buffer.from(`admin:${env.API_TOKEN}`).toString("base64")}`,
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: null,
+          method: "POST",
+          headers: {
+            Authorization: `Basic ${Buffer.from(`admin:${env.API_TOKEN}`).toString("base64")}`,
+          },
         },
-      });
+      );
       expect(await response.text()).toBe(`Unexpected end of JSON input`);
       expect(response.status).toBe(400);
     });
 
     test("body is not a JSON object", async () => {
-      const response = await SELF.fetch("https://example.com/v1/zls/publish", {
-        body: JSON.stringify(5),
-        method: "POST",
-        headers: {
-          "content-type": "application/json;charset=UTF-8",
-          Authorization: `Basic ${Buffer.from(`admin:${env.API_TOKEN}`).toString("base64")}`,
+      const response = await exports.default.fetch(
+        "https://example.com/v1/zls/publish",
+        {
+          body: JSON.stringify(5),
+          method: "POST",
+          headers: {
+            "content-type": "application/json;charset=UTF-8",
+            Authorization: `Basic ${Buffer.from(`admin:${env.API_TOKEN}`).toString("base64")}`,
+          },
         },
-      });
+      );
       expect(await response.text()).toBe(`request body is not a JSON object!`);
       expect(response.status).toBe(400);
     });