MongoDb ServerSelectionError Is Thrown Randomly

[henrychris]

I'm using @testcontainers/mongodb v11.5.1 in Node with mongodb v8.0.12. Starting November 10th, my integration tests began failing randomly with connection errors.

Error Messages

Tests fail intermittently with one of these errors:

MongoServerSelectionError: connect ECONNREFUSED 127.0.0.1:27017
    at Timeout._onTimeout (node_modules/mongodb/src/sdam/topology.ts:591:30)

MongooseError: Operation `users.insertOne()` buffering timed out after 10000ms

Test Setup

Jest Configuration (jest.config.ts):

import type { Config } from "jest";

const commonConfig = {
    testEnvironment: "node" as const,
    moduleNameMapper: {
        "^src/(.*)$": "<rootDir>/src/$1",
    },
    transform: {
        '^.+\\.(t|j)sx?$': '@swc/jest',
    },
    testTimeout: 60000,
};

const config: Config = {
    globalSetup: "<rootDir>/tests/globalSetup.ts",
    globalTeardown: "<rootDir>/tests/globalTeardown.ts",
    projects: [
        {
            displayName: "integration",
            ...commonConfig,
            testMatch: ["<rootDir>/tests/integration/**/*.integration.test.ts"],
            setupFilesAfterEnv: ["<rootDir>/tests/integration/integrationSetup.ts"],
            testTimeout: 15000,
        },
    ],
};

export default config;

Global Setup (globalSetup.ts):

import { MongoDBContainer } from "@testcontainers/mongodb";
import type { StartedMongoDBContainer } from "@testcontainers/mongodb";

declare global {
  var __MONGO_CONTAINER__: StartedMongoDBContainer | undefined;
}

export default async function globalSetup() {
  const mongoContainer = await new MongoDBContainer("mongo:8.0.12").start();
  global.__MONGO_CONTAINER__ = mongoContainer;
  process.env.MONGO_CONTAINER_URI = mongoContainer.getConnectionString();
}

Integration Setup (integrationSetup.ts):

beforeAll(async () => {
  const baseMongoUri = process.env.MONGO_CONTAINER_URI;
  if (!baseMongoUri) {
    throw new Error("MongoDB container URI not found");
  }
  
  // each worker has a separate database within the container
  const workerId = process.env.JEST_WORKER_ID || "1";
  const dbName = `test-db-${workerId}`;
  const mongoUri = `${baseMongoUri}/${dbName}`;
  process.env.MONGODB_URI = mongoUri;
  
  await mongoose.connect(mongoUri, { directConnection: true });
}, 60000);

afterAll(async () => {
  if (mongoose.connection.readyState === 1) {
    await mongoose.connection.db.dropDatabase();
    await mongoose.disconnect();
  }
});

afterEach(async () => {
  if (mongoose.connection.readyState === 1 && mongoose.connection.db) {
    const collections = await mongoose.connection.db.collections();
    for (const collection of collections) {
      await collection.deleteMany({});
    }
  }
});

Environment Configuration (env.ts):

import zennv from "zennv";
import dotenv from "dotenv";
import z from "zod";

// Load appropriate .env file based on NODE_ENV
// zennv uses dotenv under the hood, so we can load it here
// to ensure the environment variables are available before zennv processes them.
// https://github.com/tomanagle/zennv

// Only load dotenv if it hasn't been loaded already
if (!process.env.DOTENV_LOADED) {
  if (process.env.NODE_ENV === "test") {
    dotenv.config({ path: ".env.test", override: false });
  } else {
    dotenv.config({ override: false });
  }
  process.env.DOTENV_LOADED = "true";
}

export const env = zennv({
  dotenv: false,
  schema: z.object({
    MONGODB_URI: z.string().default("mongodb://localhost:27017"),
  }),
});

An Example Test

describe("Vendor Integration Tests", () => {
  let app: FastifyInstance;
  let client: TestClient;
  let testUser: UserDocument;
  let testStore: StoreDocument;
  let testLocation: LocationDocument;

  const baseVendorData = {
    name: "Test Vendor",
    website: "https://test-vendor.com",
    address: "123 Test Street",
    phone: "555-0123",
  };

  beforeAll(async () => {
    app = await buildApp(true);
    await app.ready();
    client = new TestClient(app);
  });

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

  beforeEach(async () => {
    testUser = await User.create({
      email: "[email protected]",
      firstName: "Test",
      lastName: "User",
      role: UserRoles.OWNER,
      userIsVerified: true,
      password: "test-password",
      subscription: {
        isActive: true,
      },
    });

    testStore = await Store.create({
      name: "Test Store",
      ownerId: testUser._id,
      createdBy: testUser._id,
      phone: "08099999999",
    });

    await User.findByIdAndUpdate(testUser._id, {
      store: testStore._id,
    });

    testLocation = await Location.create({
      name: "Test Location",
      store: testStore._id,
    });

    client.setAuth(
      generateTestToken(testUser),
      testStore._id.toString(),
      testLocation._id.toString(),
    );
  });

  describe("POST /vendors", () => {
    it("should create a new vendor successfully", async () => {
      // Arrange
      // authentication is already set up in beforeEach

      // Act
      const { response, body } = await createVendor(client, baseVendorData);

      // Assert
      expect(response.statusCode).toBe(201);
      expect(body.status).toBe("success");
      expect(body.data).toBeTruthy();
      expect(body.data?.name).toBe(baseVendorData.name);

      // Verify vendor was saved to database
      const savedVendor = await VendorModel.findById(body.data?._id);
      expect(savedVendor).toBeTruthy();
      expect(savedVendor?.location).toBeTruthy();
      expect(savedVendor?.name).toBe(baseVendorData.name);
      expect(savedVendor?.website).toBe(baseVendorData.website);
      expect(savedVendor?.address).toBe(baseVendorData.address);
      expect(savedVendor?.phone).toBe(baseVendorData.phone);
      expect(savedVendor?.store.toString()).toBe(testStore._id.toString());
      expect(savedVendor?.location?.toString()).toBe(
        testLocation._id.toString(),
      );
      expect(savedVendor!.createdBy.toString()).toBe(testUser._id.toString());
    });
  });

});

async function createVendor(
  client: TestClient,
  data: CreateVendorBody,
): Promise<{
  response: LightMyRequestResponse;
  body: ApiResponse<VendorResponse>;
}> {
  const response = await client.post(VENDOR_ENDPOINT, data);
  const body = JSON.parse(response.body);
  return { response, body };
}

What I've Tried

1. Moved database connection to app startup: Modified app startup so databasePlugin is called when the tests startup. I also updated the function to read directly from process.env.MONGODB_URI instead of the cached env object, bypassing potential race conditions with environment variable loading. integrationSetup.ts no longer connects to the database. Tests still failed randomly.

2. Removed default MongoDB URI: Removed the default value from env.ts and changed .env.test to use a different port (20017) to verify if the default/test config was being used incorrectly. The error still shows 127.0.0.1:27017, so this wasn't the issue.

I'm not sure what could be the cause, or what to investigate next.

[cristianrgreco]

Hi @henrychris, considering version 11.5.1 was released 3 months ago, and you say that things suddenly started failing 3 days ago, it suggests an issue with your project/environment, not Testcontainers.

If you are getting ECONNREFUSED errors, it suggests the MongoDB container either isn't running or is running but not yet ready to accept connections. You should debug to see what state your container is in at the time your test fails.

[henrychris]

yeah, it now appears to be an issue with my environment. The container is ready & accepting connections. Sorry about that.