This snippet of code helped me resolve my issue:

beforeAll(done => {
  done()
})

afterAll(done => {
  // Ensuring proper closure of the DB connection for successful Jest exit.
  mongoose.connection.close()
  done()
})

This line has been included in the package.json file.

It was successful for me.

jest --runInBand --detectOpenHandles --forceExit

My situation involved a unique issue where I needed to close the connection to the server itself while testing routes using supertest.

afterAll(done => {
    server.close();
    done();
});

To handle this, you can start the server in a beforeAll block and then close it in an after all block:

beforeAll(() => {
   server = app.listen(someRandomNumberHere); // Using a random number helps avoid conflicts when running tests in parallel
})

afterAll(() => {
   server.close()
})

In case you need more clarity, here are some additional details:

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});
module.exports = app;

To boot up your application, import it in your index.js or equivalent file like this:

const app = require('./app'); // Assuming app.js is in the same directory

If you encounter a different scenario, this issue may provide some insights for you.

Inserting

jest.useFakeTimers();

at the start of my test suite resolved the issue.

It could be related to timers set within components that are part of the rendering process (such as throttled buttons, mocks, etc.).

In my setup, I make sure to separate the app.listen() function from the main app logic in Express. This way, the main app file can simply end with an export statement.

// app.js
module.exports = app;

Then, I create a separate file specifically for listening to the port.

// server.js
const app = require('./app')
app.listen(...)

If you only import the main app file (such as app.js) in your tests, it should work without any additional configuration. Just remember to adjust the starting point of your Express app to use server.js instead.

Encountering a similar problem, I made an adjustment in my package.json file by including the line

"test": "jest --detectOpenHandles"

and executing npm test --detectOpenHandles. To my relief, the error message did not appear this time. It may be worth giving this approach a try.

I found a solution that worked perfectly for my issue.

const mongoose = require('mongoose');
    afterAll(async(done) => {
  // Making sure to close the DB connection so Jest can exit successfully.
  try {
    await mongoose.connection.close();
    done()
  } catch (error) {
    console.log(error);
    done()
  }
  // done()
})

Feel free to give this a shot

"experiment": "jest --runInBand --force-exit"

When working with Firebase, the cleanup() function had to be invoked

import {
    assertFails,
    assertSucceeds,
    initializeTestEnvironment,
    RulesTestEnvironment,
} from "@firebase/rules-unit-testing";
import { doc, setDoc } from "firebase/firestore";

it('adds a new user document in firebase', async () => {
    const testEnv = await initializeTestEnvironment({
        projectId: "appname-test",
        firestore: {
            host: 'localhost',
            port: 8088
        }
    });

    const alice = testEnv.authenticatedContext("alice");

    await assertSucceeds(setDoc(doc(alice.firestore(), "users", "alice"), {
        fname: "Alice",
        lname: "Wonderland",
        dob: "18/01/1999",
        email: "<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="72131e1b111732170a131f021e175c111d1f">[email protected]</a>"
    }));

    return await testEnv.cleanup();
});

When working with NestJs applications, you may encounter a scenario like this:

app = moduleFixture.createNestApplication();
await app.init();

To properly handle this in your test file, simply include the following:

afterAll(done => {
    app.close()
    done()
})

If you prefer using async functions, you can also do it this way:

afterAll(async() => {
    await app.close()
})

New 2023 One-Liner with a Clean and Simple Design

This one-liner was inspired by Saleh's answer, but it eliminates the need to use "done."

To complete your test file, simply add the following code snippet at the end:

afterAll(() => mongoose.connection.close())

The issue typically arises when there are pending asynchronous operations that have not completed before jest attempts to exit.

In app.js, export the app and server:

const express = require('express');
const app = express();

const server = app.listen(3000, () => {
  console.log('App is listening on port 3000');
});

module.exports = { app, server };

In test.js:

const request = require('supertest');
const { app, server } = require('../app');

describe('Monitoring Routes', () => {

    afterAll(() => {
        server.close();
    });

    it('should return status 200 for /path1/path2', async () => {
        const response = await request(app).get('/path1/path2');
        expect(response.status).toBe(200);
    });
});

I encountered a similar issue while using the pg module in my NodeJS Express application. I thought I'd share this for others who are using the same technology stack, in case it could be of assistance to them.

Essentially, when using supertest, it creates a server connection that may result in the TCPSERVERWRAP error if not properly closed. This closure is necessary after each test, regardless of whether async/await or the jest done callback is used. Additionally, the database connection needs to be closed as well, which I achieved by mocking it.

I was able to resolve the error by closing the server connection and mocking the pg module together.

products.tests.ts

import request from 'supertest'
import { Pool } from 'pg'
import app from '../app'
import type { Server } from 'http'

jest.mock('pg')

const { ROUTE_VERSION = '/v1' } = process.env
const route = (path: string) => [ROUTE_VERSION, path].join('')
const pool = new Pool()
let server: Server

beforeEach(() => {
   server = app.listen(4000)
})

afterEach(() => {
   server.close()
})

describe('GET /products', () => {
   it('returns array of products', async () => {
      await request(server)
         .get(route('/products'))
         .expect(200)
         .expect((res) => {
            expect(pool.query).toBeCalledTimes(1)
            expect(res.body).toBeInstanceOf(Array)
            expect(res.body).not.toHaveLength(0)
         })
   })
})

UPDATE: It is important to use beforeEach and afterEach to close the server after EACH test, otherwise, it will remain open.

UPDATE 2: Ensure to utilize async/await when working with request to wait for its completion, as it is asynchronous and will not finish unless awaited.

I encountered a similar issue when I forgot to close the database connection after running all the test cases. To resolve this, you can modify jest.config.js and create a new file in the root directory that will handle closing the database connection globally.

In your jest.config.js file, include the following in the module.exports:

module.exports = {
   setupFilesAfterEnv: ['<rootDir>/src/runAfterAllTests.ts'],
}

Next, add runAfterAllTests.ts to the src folder.

Inside runAfterAllTests.ts, write code to globally close the db connection. If using mongodb, it could look something like this:

import { client } from './database/connect';

global.afterAll(async () => {
  await client.close();
});

Implementing this solution will ensure that the database connection is properly closed after all tests, resolving the issue.

One issue I encountered was forgetting to properly close the Sequelize ORM at the end of testing within the afterAll function callback.

Here is the snippet of the code causing the problem:

afterAll((done) => {
    MatrixTableHeaderCol.destroy({
        where: {},
        force: true
    }).then(() => {
        done();
    });
});

If you are encountering issues while working with Firebase, make sure to remember to include a call to testEnv.cleanup()

let testEnv;

beforeAll(async () => {
  // To avoid expected rules rejections from Firestore SDK, set the log level to "error". Unexpected rejections will still cause errors.
  setLogLevel("error");
  testEnv = await initializeTestEnvironment({
    projectId: projectId,
    firestore: {
      rules: readFileSync("firestore.rules", "utf8"),
      host: "127.0.0.1",
      port: 8080,
    },
  });
});


afterAll(async () => {
    await testEnv.cleanup();
})

Dealing with a similar issue, I encountered the problem while using knex.js. To resolve it, I made some adjustments in my code. In the index.ts file, I included:

const PORT = process.env.PORT || 3000;
if (process.env.NODE_ENV !== "test") {
  app.listen(PORT, () => console.log(`Listening on port ${PORT}`));
}

Subsequently, in my .test.ts file, right before initiating the test, I implemented the following changes:

import request from "supertest";
import app from "@/index";
import { Server } from "http";
import db from "../../db";

let server: Server;

beforeAll((done) => {
  server = app.listen(process.env.PORT || 3000, () => {
    done();
  });
});

afterAll((done) => {
  db.destroy(); // This action facilitates closing the db connection
  server.close(done);
});

The 'db' variable corresponds to the configuration of knex.js.