Commit c76255a2 authored by ChanHaeng Lee's avatar ChanHaeng Lee
Browse files

Replace `Deno.test` to `node:test`

parent 41026bbe

packages/cfworkers/package.json

+2 −1
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ 
  "scripts": {

    "build": "tsdown",

    "prepack": "tsdown",

    "prepublish": "tsdown"

    "prepublish": "tsdown",

    "test": "deno task codegen && tsdown && cd dist/ && node --test"

  }

}

packages/cfworkers/src/mod.test.ts

+35 −31
Original line number Diff line number Diff line
@@ -2,43 +2,47 @@ import type { 
  KVNamespace,

  Queue,

} from "@cloudflare/workers-types/experimental";

import { assertEquals } from "@std/assert";

import { delay } from "es-toolkit";

import { deepStrictEqual, strictEqual } from "node:assert/strict";

import { describe, test } from "node:test";

import { WorkersKvStore, WorkersMessageQueue } from "./mod.ts";



Deno.test({

  name: "WorkersKvStore",

  ignore: !("navigator" in globalThis &&

describe("WorkersKvStore", {

  skip: !("navigator" in globalThis &&

    navigator.userAgent === "Cloudflare-Workers"),

  async fn(t) {

}, () => {

  test("set() & get()", async (t) => {

    const { env } = t as unknown as {

      env: Record<string, KVNamespace<string>>;

    };

    const store = new WorkersKvStore(env.KV1);



    await t.step("set() & get()", async () => {

    await store.set(["foo", "bar"], { foo: 1, bar: 2 });

      assertEquals(await store.get(["foo", "bar"]), { foo: 1, bar: 2 });

      assertEquals(await store.get(["foo"]), undefined);

    deepStrictEqual(await store.get(["foo", "bar"]), { foo: 1, bar: 2 });

    strictEqual(await store.get(["foo"]), undefined);



    await store.set(["foo", "baz"], "baz", {

      ttl: Temporal.Duration.from({ seconds: 0 }),

    });

      assertEquals(await store.get(["foo", "baz"]), undefined);

    strictEqual(await store.get(["foo", "baz"]), undefined);

  });



    await t.step("delete()", async () => {

  test("delete()", async (t) => {

    const { env } = t as unknown as {

      env: Record<string, KVNamespace<string>>;

    };

    const store = new WorkersKvStore(env.KV1);



    await store.delete(["foo", "bar"]);

      assertEquals(await store.get(["foo", "bar"]), undefined);

    strictEqual(await store.get(["foo", "bar"]), undefined);

  });

  },

});



Deno.test({

  name: "WorkersMessageQueue",

  ignore: !("navigator" in globalThis &&

describe("WorkersMessageQueue", {

  skip: !("navigator" in globalThis &&

    navigator.userAgent === "Cloudflare-Workers"),

  async fn(t) {

}, () => {

  test("message queue operations", async (t) => {

    const { env, messageBatches } = t as unknown as {

      env: Record<string, Queue>;

      messageBatches: MessageBatch[];
@@ -46,22 +50,22 @@ Deno.test({ 
    const queue = new WorkersMessageQueue(env.Q1);

    await queue.enqueue({ foo: 1, bar: 2 });

    await waitFor(() => messageBatches.length > 0, 5000);

    assertEquals(messageBatches.length, 1);

    assertEquals(messageBatches[0].queue, "Q1");

    assertEquals(messageBatches[0].messages.length, 1);

    assertEquals(messageBatches[0].messages[0].body, { foo: 1, bar: 2 });

    strictEqual(messageBatches.length, 1);

    strictEqual(messageBatches[0].queue, "Q1");

    strictEqual(messageBatches[0].messages.length, 1);

    deepStrictEqual(messageBatches[0].messages[0].body, { foo: 1, bar: 2 });



    await queue.enqueue(

      { baz: 3, qux: 4 },

      { delay: Temporal.Duration.from({ seconds: 3 }) },

    );

    await delay(2000);

    assertEquals(messageBatches.length, 1);

    strictEqual(messageBatches.length, 1);

    await waitFor(() => messageBatches.length > 1, 6000);

    assertEquals(messageBatches[1].queue, "Q1");

    assertEquals(messageBatches[1].messages.length, 1);

    assertEquals(messageBatches[1].messages[0].body, { baz: 3, qux: 4 });

  },

    strictEqual(messageBatches[1].queue, "Q1");

    strictEqual(messageBatches[1].messages.length, 1);

    deepStrictEqual(messageBatches[1].messages[0].body, { baz: 3, qux: 4 });

  });

});



async function waitFor(

packages/hono/package.json

+2 −1
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ 
  "scripts": {

    "build": "tsdown",

    "prepack": "tsdown",

    "prepublish": "tsdown"

    "prepublish": "tsdown",

    "test": "deno task codegen && tsdown && cd dist/ && node --test"

  }

}

packages/hono/src/mod.test.ts

+31 −24
Original line number Diff line number Diff line 
import { assertEquals } from "@std/assert";

import { strictEqual } from "node:assert/strict";

import { describe, test } from "node:test";

import { type ContextDataFactory, federation } from "./mod.ts";



interface MockHonoContext {
@@ -9,38 +10,38 @@ interface MockHonoContext { 
}



interface MockFederation<T> {

  fetch(request: Request, options: any): Promise<Response>;

  fetch(request: Request, options: unknown): Promise<Response>;

}



Deno.test("federation middleware", async (t) => {

  await t.step("creates middleware function", () => {

describe("federation middleware", () => {

  test("creates middleware function", () => {

    const mockFederation: MockFederation<undefined> = {

      fetch: async () => new Response("OK"),

      fetch: () => Promise.resolve(new Response("OK")),

    };



    const contextDataFactory: ContextDataFactory<undefined, MockHonoContext> =

      () => undefined;



    const middleware = federation(mockFederation as any, contextDataFactory);

    assertEquals(typeof middleware, "function");

    const middleware = federation(mockFederation as never, contextDataFactory);

    strictEqual(typeof middleware, "function");

  });



  await t.step("calls federation.fetch with correct parameters", async () => {

  test("calls federation.fetch with correct parameters", async () => {

    let capturedRequest: Request | undefined;

    let capturedOptions: any;

    let capturedOptions: unknown;



    const mockFederation: MockFederation<string> = {

      fetch: async (request, options) => {

      fetch: (request, options) => {

        capturedRequest = request;

        capturedOptions = options;

        return new Response("Federation response");

        return Promise.resolve(new Response("Federation response"));

      },

    };



    const contextDataFactory: ContextDataFactory<string, MockHonoContext> =

      () => "test-context";



    const middleware = federation(mockFederation as any, contextDataFactory);

    const middleware = federation(mockFederation as never, contextDataFactory);



    const mockRequest = new Request("https://example.com/test");

    const mockContext: MockHonoContext = {
@@ -48,20 +49,23 @@ Deno.test("federation middleware", async (t) => { 
      res: new Response("Hono response"),

    };



    const result = await middleware(mockContext, async () => {});

    const result = await middleware(mockContext, () => Promise.resolve());



    assertEquals(capturedRequest, mockRequest);

    assertEquals(capturedOptions.contextData, "test-context");

    assertEquals(result?.status, 200);

    strictEqual(capturedRequest, mockRequest);

    strictEqual(

      (capturedOptions as { contextData: string }).contextData,

      "test-context",

    );

    strictEqual(result?.status, 200);

  });



  await t.step("handles async context data factory", async () => {

    let capturedContextData: any;

  test("handles async context data factory", async () => {

    let capturedContextData: unknown;



    const mockFederation: MockFederation<string> = {

      fetch: async (request, options) => {

        capturedContextData = options.contextData;

        return new Response("OK");

      fetch: (_request, options) => {

        capturedContextData = (options as { contextData: string }).contextData;

        return Promise.resolve(new Response("OK"));

      },

    };
@@ -71,7 +75,7 @@ Deno.test("federation middleware", async (t) => { 
        return "async-context";

      };



    const middleware = federation(mockFederation as any, contextDataFactory);

    const middleware = federation(mockFederation as never, contextDataFactory);



    const mockRequest = new Request("https://example.com/test");

    const mockContext: MockHonoContext = {
@@ -79,8 +83,11 @@ Deno.test("federation middleware", async (t) => { 
      res: new Response("Hono response"),

    };



    await middleware(mockContext, async () => {});

    await middleware(mockContext, () => Promise.resolve());



    assertEquals(capturedContextData, "async-context");

    strictEqual(

      (capturedContextData as { contextData: string }).contextData,

      "async-context",

    );

  });

});

packages/sveltekit/package.json

+2 −1
Original line number Diff line number Diff line
@@ -62,6 +62,7 @@ 
  "scripts": {

    "build": "tsdown",

    "prepack": "tsdown",

    "prepublish": "tsdown"

    "prepublish": "tsdown",

    "test": "deno task codegen && tsdown && cd dist/ && node --test"

  }

}