🏁 Add deno tests

Author: elbywan

.github/workflows/deno.yml

@@ -0,0 +1,24 @@
+name: Deno compatibility test
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - dev
+  workflow_dispatch:
+
+jobs:
+  deno-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: moonrepo/setup-toolchain@v0
+        with:
+          auto-install: true
+      - name: Install dependencies
+        run: npm ci
+      - name: Build
+        run: npm run build
+      - name: Test Deno compatibility
+        run: npm run test:deno

README.md

@@ -31,7 +31,7 @@
 - 💡 **Intuitive** - lean API, handles errors, headers and (de)serialization
 - 🧊 **Immutable** - every call creates a cloned instance that can then be reused safely
 - 🔌 **Modular** - plug addons to add new features, and middlewares to intercept requests
-- 🧩 **Isomorphic** - compatible with modern browsers and Node.js 22+
+- 🧩 **Isomorphic** - compatible with modern browsers, Node.js 22+ and Deno
 - 🦺 **Type safe** - strongly typed, written in TypeScript
 - ✅ **Proven** - fully covered by unit tests and widely used
 - 💓 **Maintained** - alive and well for many years
@@ -223,18 +223,17 @@ Node.js 22+ includes native fetch support and all required Web APIs (FormData, U
 
 ## Deno
 
-Works with [Deno](https://deno.land/) >=
-[0.41.0](https://github.com/denoland/deno/releases/tag/v0.41.0) out of the box.
+Works with [Deno](https://deno.land/) out of the box.
 
-Types should be imported from `/dist/types.d.ts`.
+```bash
+deno add npm:wretch
+```
 
-<!-- snippet:skip Deno specific-code -->
 ```ts
-// You can import wretch from any CDN that serve ESModules.
-import wretch from "https://cdn.skypack.dev/wretch";
+import wretch from "wretch";
 
-const text = await wretch("https://httpstat.us").get("/200").text();
-console.log(text); // -> 200 OK
+const text = await wretch("https://httpbun.org").get("/status/200").text();
+console.log(text); // -> { "code": 200, "description": "OK" }
 ```
 
 # Usage

package.json

@@ -120,6 +120,7 @@
     "test": "concurrently --success first -k 'npm run mock:wait && c8 node --import tsx --test \"test/node/**/*.spec.ts\"' 'npm run mock'",
     "test:browser": "concurrently --success first -k 'npm run mock:wait && web-test-runner' 'npm run mock'",
     "test:browser:watch": "concurrently --success first -k 'npm run mock:wait && web-test-runner --watch' 'npm run mock'",
+    "test:deno": "concurrently --success first -k 'npm run mock:wait && deno test --allow-net --allow-read --no-check --sloppy-imports --config test/deno/deno.json test/deno/wretch.spec.ts' 'npm run mock'",
     "test:snippets:generate": "node --import tsx scripts/generateSnippetTests.ts",
     "test:snippets": "npm run test:snippets:generate && node --experimental-vm-modules --import tsx --test test/generated/snippets.spec.ts",
     "test:snippets:skip-failing": "node --import tsx scripts/addSkipComments.ts",

test/deno/deno.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "lib": ["deno.ns", "deno.window"],
+    "strict": false
+  },
+  "imports": {
+    "@std/assert": "jsr:@std/assert@^1.0.15",
+    "@std/testing": "jsr:@std/testing@^1.0.16"
+  }
+}

test/deno/deno.lock

@@ -0,0 +1,65 @@
+import * as assertImport from "@std/assert"
+
+export const expect = (actual: any) => ({
+  toBe: (expected: unknown) => assertImport.assertEquals(actual, expected),
+  toEqual: (expected: unknown) => assertImport.assertEquals(actual, expected),
+  toBeNull: () => assertImport.assertEquals(actual, null),
+  toBeTruthy: () => assertImport.assert(actual),
+  toBeUndefined: () => assertImport.assertEquals(actual, undefined),
+  toBeGreaterThanOrEqual: (expected: any) => {
+    assertImport.assert(typeof actual === "number" && typeof expected === "number")
+    assertImport.assert(actual >= expected)
+  },
+  toStrictEqual: (expected: unknown) => assertImport.assertEquals(actual, expected),
+  toMatchObject: (expected: any) => {
+    for (const key in expected) {
+      const expectedValue = expected[key]
+      const actualValue = actual[key]
+
+      if (expectedValue instanceof Uint8Array) {
+        if (actualValue && actualValue.type === "Buffer" && Array.isArray(actualValue.data)) {
+          assertImport.assertEquals(actualValue.data, Array.from(expectedValue))
+        } else {
+          assertImport.assertEquals(Array.from(actualValue), Array.from(expectedValue))
+        }
+      } else if (typeof expectedValue === "object" && expectedValue !== null && !Array.isArray(expectedValue)) {
+        if (expectedValue.type === "Buffer" && expectedValue.data instanceof Uint8Array) {
+          assertImport.assertEquals(actualValue.type, "Buffer")
+          assertImport.assertEquals(actualValue.data, Array.from(expectedValue.data))
+        } else {
+          assertImport.assertEquals(actualValue, expectedValue)
+        }
+      } else {
+        assertImport.assertEquals(actualValue, expectedValue)
+      }
+    }
+  }
+})
+
+export const assert = {
+  ...assertImport,
+  rejects: async (
+    fn: () => Promise<unknown>,
+    validator?: (error: unknown) => boolean
+  ) => {
+    try {
+      await fn()
+      throw new Error("Expected promise to reject")
+    } catch (error) {
+      if (validator && !validator(error)) {
+        throw new Error("Validator returned false")
+      }
+    }
+  }
+}
+
+export const fs = {
+  openAsBlob: async (path: string) => {
+    const file = await Deno.open(path, { read: true })
+    const fileInfo = await file.stat()
+    const buffer = new Uint8Array(fileInfo.size)
+    await file.read(buffer)
+    file.close()
+    return new Blob([buffer])
+  }
+}

test/deno/helpers.ts

@@ -0,0 +1,27 @@
+import { describe, it, beforeEach } from "@std/testing/bdd"
+import { expect, assert, fs } from "./helpers.ts"
+import { createWretchTests, createMixTests } from "../shared/wretch.spec.ts"
+
+const duckImagePath = new URL("../assets/duck.jpg", import.meta.url).pathname
+const duckImage = await Deno.readFile(duckImagePath)
+
+createWretchTests({
+  describe: (name, fn) => describe(name, { sanitizeResources: false }, fn),
+  it: (name, fn) => it(name, { sanitizeResources: false }, fn),
+  beforeEach,
+  assert,
+  expect,
+  fs,
+  duckImage,
+  duckImagePath,
+})
+
+createMixTests({
+  describe,
+  it,
+  assert,
+  expect,
+  fs,
+  duckImage,
+  duckImagePath,
+})

test/deno/wretch.spec.ts

@@ -14,7 +14,7 @@ const duckImage = fs.readFileSync(duckImagePath)
 
 createWretchTests({
   describe,
-  it,
+  it: (name, fn) => it(name,{ timeout: 5000 }, fn),
   beforeEach,
   assert,
   expect,

test/node/wretch.spec.ts

@@ -20,6 +20,7 @@ const isSafari =
   navigator.userAgent.indexOf("Safari") >= 0 &&
   navigator.userAgent.indexOf("Chrome") < 0
 const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined"
+const isDeno = typeof globalThis.Deno !== "undefined"
 
 const allRoutes = <T>(
   obj: Wretch,
@@ -81,7 +82,6 @@ export function createWretchTests(ctx: TestContext): void {
     if (before) {
       before(async function () {
         this.timeout(5000)
-        await new Promise(resolve => setTimeout(resolve, 2000))
       })
     }
 
@@ -550,7 +550,7 @@ export function createWretchTests(ctx: TestContext): void {
     })
 
     it("should retrieve performance timings associated with a fetch request", async function () {
-      if (isSafari)
+      if (isSafari || isDeno)
         return
 
       const w = wretch()
@@ -565,11 +565,14 @@ export function createWretchTests(ctx: TestContext): void {
         }).res().catch(_ => "ignore")
       })
 
-      for (let i = 0; i < 5; i++) {
-        w.url(`${_URL}/fake/${i}`).get().perfs(timings => {
-          expect(timings.name).toBe(`${_URL}/fake/${i}`)
-        }).res().catch(() => "ignore")
-      }
+      await Promise.all(new Array(5).fill(0).map((_, i) =>
+        new Promise<void>(resolve => {
+          w.url(`${_URL}/fake/${i}`).get().perfs(timings => {
+            expect(timings.name).toBe(`${_URL}/fake/${i}`)
+            resolve()
+          }).res().catch(() => "ignore")
+        })
+      ))
     })
 
     it("should monitor download progress", async function () {
@@ -784,7 +787,7 @@ export function createWretchTests(ctx: TestContext): void {
     })
 
     it("should program resolvers", async function () {
-      if(isSafari)
+      if(isSafari || isDeno)
         return
 
       let check = 0