1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-11-29 16:30:56 -05:00
denoland-deno/tests/unit_node/async_hooks_test.ts
Divy Srivastava d283a53655
fix(node): implement ALS enterWith (#22740)
Fixes https://github.com/denoland/deno/issues/18127
https://github.com/denoland/deno/issues/17248

SvelteKit works now!
```
$ deno run -A npm:create-svelte@latest my-app

create-svelte version 6.0.9

┌  Welcome to SvelteKit!
│
◇  Which Svelte app template?
│  SvelteKit demo app
│
◇  Add type checking with TypeScript?
│  Yes, using JavaScript with JSDoc comments
│
◇  Select additional options (use arrow keys/space bar)
│  none
│
└  Your project is ready!

✔ Type-checked JavaScript
  https://www.typescriptlang.org/tsconfig#checkJs

Install community-maintained integrations:
  https://github.com/svelte-add/svelte-add

Next steps:
  1: cd my-app
  2: npm install
  3: git init && git add -A && git commit -m "Initial commit" (optional)
  4: npm run dev -- --open

To close the dev server, hit Ctrl-C

Stuck? Visit us at https://svelte.dev/chat

$ cd my-app/
$ deno task dev
Task dev vite dev

  VITE v5.1.4  ready in 1632 ms

  ➜  Local:   http://localhost:5173/
  ➜  Network: use --host to expose
  ➜  press h + enter to show help
```
2024-03-06 12:05:57 +00:00

96 lines
2.6 KiB
TypeScript

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
import { assert, assertEquals } from "@std/assert/mod.ts";
Deno.test(async function foo() {
const asyncLocalStorage = new AsyncLocalStorage();
const out: string[] = [];
function logWithId(msg: string) {
const id = asyncLocalStorage.getStore();
out.push(`${id !== undefined ? id : "-"}: ${msg}`);
}
async function exec() {
logWithId("start");
await new Promise((resolve) => setTimeout(resolve, 100));
logWithId("finish");
}
for (const foo of [1, 2, 3]) {
asyncLocalStorage.run(foo, exec);
}
await new Promise((resolve) => setTimeout(resolve, 500));
assertEquals(out, [
"1: start",
"2: start",
"3: start",
"1: finish",
"2: finish",
"3: finish",
]);
});
Deno.test(async function bar() {
let differentScopeDone = false;
const als = new AsyncLocalStorage();
const ac = new AbortController();
const server = Deno.serve({
signal: ac.signal,
port: 4000,
}, () => {
const differentScope = als.run(123, () =>
AsyncResource.bind(() => {
differentScopeDone = true;
}));
return als.run("Hello World", async () => {
// differentScope is attached to a different async context, so
// it will see a different value for als.getStore() (123)
setTimeout(differentScope, 5);
// Some simulated async delay.
await new Promise((res) => setTimeout(res, 10));
return new Response(als.getStore() as string); // "Hello World"
});
});
const res = await fetch("http://localhost:4000");
assertEquals(await res.text(), "Hello World");
ac.abort();
await server.finished;
assert(differentScopeDone);
});
Deno.test(async function nested() {
const als = new AsyncLocalStorage();
const deferred = Promise.withResolvers();
const deferred1 = Promise.withResolvers();
als.run(null, () => {
als.run({ x: 1 }, () => {
deferred.resolve(als.getStore());
});
deferred1.resolve(als.getStore());
});
assertEquals(await deferred.promise, { x: 1 });
assertEquals(await deferred1.promise, null);
});
Deno.test(async function enterWith() {
const als = new AsyncLocalStorage();
const deferred = Promise.withResolvers();
const deferred1 = Promise.withResolvers();
als.run(null, () => {
als.run({ x: 1 }, () => {
als.enterWith({ x: 2 });
deferred.resolve(als.getStore());
});
deferred1.resolve(als.getStore());
});
assertEquals(await deferred.promise, { x: 2 });
assertEquals(await deferred1.promise, { x: 1 });
});