Detect open handles with done callbacks

e2e/__tests__/detectOpenHandles.ts

@@ -123,3 +123,25 @@ it('prints out info about open handlers from inside tests', async () => {
 
   expect(wrap(textAfterTest)).toMatchSnapshot();
 });
+
+it('prints out info about open handlers from tests with a `done` callback', async () => {
+  const {stderr} = runJest('detect-open-handles', [
+    'in-done-function',
+    '--detectOpenHandles',
+    '--forceExit',
+  ]);
+  const textAfterTest = getTextAfterTest(stderr);
+
+  expect(textAfterTest).toContain('TCPSERVERWRAP');
+});
+
+it('prints out info about open handlers from lifecycle functions with a `done` callback', async () => {
+  const {stderr} = runJest('detect-open-handles', [
+    'in-done-lifecycle',
+    '--detectOpenHandles',
+    '--forceExit',
+  ]);
+  const textAfterTest = getTextAfterTest(stderr);
+
+  expect(textAfterTest).toContain('TCPSERVERWRAP');
+});

e2e/detect-open-handles/__tests__/in-done-function.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const http = require('http');
+
+test('something', done => {
+  const server = http.createServer((_, response) => response.end('ok'));
+  server.listen(0, () => {
+    expect(true).toBe(true);
+    done();
+  });
+});

e2e/detect-open-handles/__tests__/in-done-lifecycle.js

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const http = require('http');
+
+beforeAll(done => {
+  const server = http.createServer((_, response) => response.end('ok'));
+  server.listen(0, () => {
+    done();
+  });
+});
+
+test('something', () => {
+  expect(true).toBe(true);
+});

packages/jest-core/src/__tests__/collectHandles.test.js

@@ -6,6 +6,7 @@
  *
  */
 
+import http from 'http';
 import {PerformanceObserver} from 'perf_hooks';
 import collectHandles from '../collectHandles';
 
@@ -33,4 +34,20 @@ describe('collectHandles', () => {
     expect(openHandles).toHaveLength(0);
     obs.disconnect();
   });
+
+  it('should collect handles opened in test functions with `done` callbacks', done => {
+    const handleCollector = collectHandles();
+    const server = http.createServer((_, response) => response.end('ok'));
+    server.listen(0, () => {
+      // Collect results while server is still open.
+      const openHandles = handleCollector();
+
+      server.close(() => {
+        expect(openHandles).toContainEqual(
+          expect.objectContaining({message: 'TCPSERVERWRAP'}),
+        );
+        done();
+      });
+    });
+  });
 });

packages/jest-jasmine2/src/jasmineAsyncInstall.ts

@@ -42,13 +42,22 @@ function promisifyLifeCycleFunction(
     if (!fn) {
       // @ts-expect-error: missing fn arg is handled by originalFn
       return originalFn.call(env);
+    } else if (typeof fn !== 'function') {
+      // Pass non-functions to Jest, which throws a nice error.
+      return originalFn.call(env, fn, timeout);
     }
 
-    const hasDoneCallback = typeof fn === 'function' && fn.length > 0;
+    const hasDoneCallback = fn.length > 0;
 
     if (hasDoneCallback) {
-      // Jasmine will handle it
-      return originalFn.call(env, fn, timeout);
+      // Give the function a name so it can be detected in call stacks, but
+      // otherwise Jasmine will handle it.
+      // @ts-expect-error: Support possible extra args at runtime
+      const asyncJestLifecycleWithCallback = function (this: any, ...args) {
+        // @ts-expect-error: Support possible extra args at runtime
+        return fn.apply(this, args);
+      };
+      return originalFn.call(env, asyncJestLifecycleWithCallback, timeout);
     }
 
     const extraError = new Error();
@@ -104,12 +113,22 @@ function promisifyIt(
       const spec = originalFn.call(env, specName);
       spec.pend('not implemented');
       return spec;
+    } else if (typeof fn !== 'function') {
+      // Pass non-functions to Jest, which throws a nice error.
+      return originalFn.call(env, specName, fn, timeout);
     }
 
     const hasDoneCallback = fn.length > 0;
 
     if (hasDoneCallback) {
-      return originalFn.call(env, specName, fn, timeout);
+      // Give the function a name so it can be detected in call stacks, but
+      // otherwise Jasmine will handle it.
+      // @ts-expect-error: Support possible extra args at runtime
+      const asyncJestTestWithCallback = function (this: any, ...args) {
+        // @ts-expect-error: Support possible extra args at runtime
+        return fn.apply(this, args);
+      };
+      return originalFn.call(env, specName, asyncJestTestWithCallback, timeout);
     }
 
     const extraError = new Error();