Test step unexpectedly fails due to “leaking async ops“

[jaydenseric]

With this test.mjs module:

import puppeteer from "https://deno.land/x/puppeteer@14.1.1/mod.ts";

Deno.test("A", async (t) => {
  const browser = await puppeteer.launch();

  try {
    await t.step("B", async () => {});
  } finally {
    await browser.close();
  }
});

With this command:

deno test --allow-all

The tests fail with an error:

running 1 test from ./test.mjs
A ...
  B ... FAILED (2ms)
    error: AssertionError: Test case is leaking async ops.
    
     - 1 async operation to sleep for a duration was started before this test, but was completed during the test. Async operations should not complete in a test if they were not started in that test.
                This is often caused by not cancelling a `setTimeout` or `setInterval` call.
    
    To get more details where ops were leaked, run again with --trace-ops flag.
        await t.step("B", async () => {});
        ^
        at assert (deno:ext/web/00_infra.js:294:13)
        at asyncOpSanitizer (deno:runtime/js/40_testing.js:223:13)
        at async resourceSanitizer (deno:runtime/js/40_testing.js:368:7)
        at async exitSanitizer (deno:runtime/js/40_testing.js:425:9)
        at async TestContext.step (deno:runtime/js/40_testing.js:1328:13)
        at async file://[redacted]/test.mjs:7:5
A ... FAILED (341ms)

 ERRORS 

A => ./test.mjs:3:6
error: Error: 1 test step failed.
    at runTest (deno:runtime/js/40_testing.js:835:11)
    at async Object.runTests (deno:runtime/js/40_testing.js:1084:22)

 FAILURES 

A => ./test.mjs:3:6

FAILED | 0 passed | 1 failed (1 step) (397ms)

error: Test failed

With the test step commented out:

import puppeteer from "https://deno.land/x/puppeteer@14.1.1/mod.ts";

Deno.test("A", async (t) => {
  const browser = await puppeteer.launch();

  try {
    // await t.step("B", async () => {});
  } finally {
    await browser.close();
  }
});

The tests pass without error:

running 1 test from ./test.mjs
A ... ok (307ms)

ok | 1 passed | 0 failed (366ms)

[jaydenseric]

GitHub automatically closed this issue based on the unfortunate phrasing of the commit message.

[izznat]

Have you read https://deno.land/manual@v1.25.1/testing/sanitizers?

I experienced the same issue before while testing with database connection, even after I manually close the connection after all steps is completed as you did above. Turns out I need to disable sanitizeResources and sanitizeOps on parent Deno.test.

This might solve your issue.

[lambdalisue]

I faced the same problem with Deno v1.29.1.

In my case, I was able to solve it by putting a zero await before the first t.step().

await new Promise((resolve) => setTimeout(resolve, 0));
await t.step("step1", () => {
  countAsync("C");
});

Note that this method is based on a comment I found in 40_testing.js.

deno/cli/js/40_testing.js

Lines 39 to 54 in 2fab458

	// Even if every resource is closed by the end of a test, there can be a delay
	// until the pending ops have all finished. This function returns a promise
	// that resolves when it's (probably) fine to run the op sanitizer.
	//
	// This is implemented by adding a macrotask callback that runs after the
	// timer macrotasks, so we can guarantee that a currently running interval
	// will have an associated op. An additional `setTimeout` of 0 is needed
	// before that, though, in order to give time for worker message ops to finish
	// (since timeouts of 0 don't queue tasks in the timer queue immediately).
	function opSanitizerDelay() {
	return new Promise((resolve) => {
	setTimeout(() => {
	ArrayPrototypePush(opSanitizerDelayResolveQueue, resolve);
	}, 0);
	});
	}

deno/cli/js/40_testing.js

Lines 149 to 153 in 2fab458

	// Defer until next event loop turn - that way timeouts and intervals
	// cleared can actually be removed from resource table, otherwise
	// false positives may occur (https://github.com/denoland/deno/issues/4591)
	await opSanitizerDelay();
	await opSanitizerDelay();

So I think we can solve this problem by putting a similar await process before the line below

deno/cli/js/40_testing.js

Line 144 in 2fab458

const pre = core.metrics();

What do you think?

[YuriyTigiev]

I have similar problem and work around from Chat GPT

The error you are encountering, "Leaking async ops", is likely due to the fact that the logging module is performing asynchronous file operations (such as writing to a file) which are not being awaited or completed before the test ends. This can cause issues with Deno's test runner, which expects all asynchronous operations started during a test to also be completed during the same test.

One way to address this issue is to ensure that the logging module completes all its asynchronous operations before the test ends. This can be done by flushing the logs or waiting for the file operations to complete.

However, since you are using Deno's standard logging module, which does not provide a built-in way to flush logs, you can use a workaround by wrapping your tests in a function that waits for a short period of time before and after running the tests. This will give the logging module time to complete its asynchronous operations.

Here's an example of how you can modify your test file:

// ohlcv_db_test.ts
import { assertEquals } from "./deps.ts";
import { OhlcvDb } from "./ohlcv_db.ts";
import { loadConfig, Config } from "./config.ts";

let testConfig: Config;

async function runTest(testName: string, testFn: () => Promise<void>) {
  await new Promise(resolve => setTimeout(resolve, 100)); // Wait before running the test
  await testFn();
  await new Promise(resolve => setTimeout(resolve, 100)); // Wait after running the test
}

Deno.test("Load Config", async () => {
  await runTest("Load Config", async () => {
    testConfig = await loadConfig("test", "./"); // replace with your test environment and path
    assertEquals(typeof testConfig.POSTGRES_HOST, "string");
  });
});

Deno.test("Should connect to the database", async () => {
  await runTest("Should connect to the database", async () => {
    const ohlcvDb = new OhlcvDb(testConfig);
    await ohlcvDb.connect();
    assertEquals(ohlcvDb.client !== null, true);
    await ohlcvDb.close();
  });
});

Deno.test("Should close the database connection", async () => {
  await runTest("Should close the database connection", async () => {
    const ohlcvDb = new OhlcvDb(testConfig);
    await ohlcvDb.connect();
    await ohlcvDb.close();
    assertEquals(ohlcvDb.client, null);
  });
});

This approach introduces a small delay before and after each test, which can help ensure that asynchronous operations have time to complete. However, it's a workaround and not a perfect solution. Ideally, the logging module should provide a way to flush logs or wait for file operations to complete.

[zbynekwinkler]

I faced the same problem with Deno v1.29.1.

I can confirm the problem is still current in v1.35.3.

In my case, I was able to solve it by putting a zero await before the first t.step().

Adding await new Promise((resolve) => setTimeout(resolve, 0)); before the first step does indeed help in the example mentioned at the beginning of this issue. Thanks for that. Without it, none of my more complicated test were working. I wonder how anyone gets anything done with this problem unfixed wrt testing.

[sdeese]

Just in case someone comes here with the same problem, i was able to fix my same issue with the following:

Deno.test({ name: "Test to see if pupeteer can connect to a pre-launched Chrome instance in dev mode", async fn() { const b = await connectToBrowser(); assertExists(b); await b?.disconnect(); }, sanitizeResources: false, });

It was the sanitize that fixed it. Please see : https://deno.land/manual@v1.25.1/testing/sanitizers

[ahuigo]

@zwn Have you upgraded deno?
It works well for me (deno 1.38.3 / macosx 12 m1)