How to mock mongoose?

Mocking Mongoose in unit tests is crucial because it helps isolate external dependencies (such as databases), ensuring that our tests are reliable and run efficiently. In Node.js, we commonly use libraries to facilitate mocking operations, such as sinon, jest, or proxyquire.

Here is one method to mock Mongoose using jest:

First, we need to install jest and mongodb-memory-server, which creates an in-memory MongoDB instance, allowing us to perform tests without affecting the real database.

bash
npm install --save-dev jest mongodb-memory-server

Next, we can set up an in-memory database in our test file and use jest to mock the Mongoose module.

Assuming we have a user model and corresponding service layer code, we need to test the functionality of the service layer:

javascript
// user.service.js
const User = require('./user.model');

async function createUser(username, email) {
    const user = new User({ username, email });
    return user.save();
}

module.exports = { createUser };

Next, the model file:

javascript
// user.model.js
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    username: String,
    email: String
});

const User = mongoose.model('User', userSchema);

module.exports = User;

Now, we set up our test file:

javascript
// user.service.test.js
const mongoose = require('mongoose');
const { MongoMemoryServer } = require('mongodb-memory-server');
const User = require('./user.model');
const userService = require('./user.service');

jest.mock('./user.model');

describe('UserService', () => {
    let mongoServer;

    beforeAll(async () => {
        mongoServer = await MongoMemoryServer.create();
        const mongoUri = mongoServer.getUri();
        await mongoose.connect(mongoUri);
    });

    afterAll(async () => {
        await mongoose.disconnect();
        await mongoServer.stop();
    });

    it('should create a new user', async () => {
        const mockUser = { _id: '1', username: 'testuser', email: 'test@example.com' };
        User.mockImplementation(() => ({
            save: jest.fn().mockResolvedValue(mockUser)
        }));
        
        const user = await userService.createUser('testuser', 'test@example.com');
        
        expect(user).toHaveProperty('_id', '1');
        expect(user).toHaveProperty('username', 'testuser');
        expect(user).toHaveProperty('email', 'test@example.com');
    });
});

In this test, we use jest.mock() to mock the User model. This way, when userService.createUser calls new User() and save, it uses the mock implementation we provided instead of actual database operations.

This approach enables efficient and effective unit testing of the service layer code without interacting with the real database environment.