Basic operation question

[rlefever]

In attempting to unit test a function in a controller, the model call doesn't see the connection. Mongodb-memory-server report started and connected. I read somewhere that the database is not actually created until data is inserted. I was unable to find and example either in the docs nor google. How can I seed the db (if needed) and what to call to mock it (if needed).

I did see this issue, but I think I am a couple of steps away from knowing how to 'write a script'.

When I put a try/catch around the call in the controller I am receiving is: "Error: MongoNotConnectedError: Client must be connected before running operations"

Controller function I am trying to test

import { myModel } from '../models/myModel.js';
export const getAll = async (req, res, next) => {
	const record_set = await myModel.find();

	res.status(400).json({
		status: 'success',
		length: record_set.length,
		data: record_set
	});
};

Unit Test File

import assert from 'node:assert/strict';
import { describe, it, mock } from 'node:test';
import mockHttp from 'node-mocks-http';
import { getAll } from '../../src/controllers/myController.js';
import { myModel } from '../../src/models/myModel.js';
import { MongoMemoryServer } from 'mongodb-memory-server';
import { mongoose } from 'mongoose';

const req = mockHttp.createRequest({
	method: 'GET',
	headers: {
		accept: 'application/json'
	},
	params: {},
	query: {},
	body: {}
});
const res = {
	send: () => { console.log('sent') },
	status: function(objCodeNum) {
		this.statusCode = objCodeNum;
		console.log('this.statusCode', this.statusCode);
		return this;
	},
	json: function(objData) {
		// serialize & store
		this.body = JSON.stringify(objData);
		console.log('this.body: ', this.body);
		return this;
	}
}
const next = mock.fn();

const statusSpy = mock.method(res, 'status');
const jsonSpy = mock.method(res, 'json');

const mongod = new MongoMemoryServer({
	instance: {
		dbName: 'test',
		port: 3000
	}
});

await mongod.start();
const mongoUri = mongod.getUri();
console.log(`mongoServer started ${mongoUri}`);
const dbconn = await mongoose.connect(mongoUri, { dbName: 'testing' });
console.log('Database connection:',
	dbconn.connection.host + ':' +
	dbconn.connection.port + '/' +
	dbconn.connection.name
);
// mongoServer started mongodb://127.0.0.1:3000/
// Database connection: 127.0.0.1:3000/testing

// const inserted = dbconn.mquery.utils.create({ data });
// console.log(inserted); // returns undefined
// also tried
// const obj = new myModel({ data });
// await obj.save()
//	.then(() => console.log('Record inserted'))
//	.catch((err) => console.log(err));
// returned: MongoNotConnectedError: Client must be connected before running operations
// await in front of obj.save() cleared this error

describe('Testing use of In Memory Server MongoMemoryServer', () => {
	describe('Given function with  awaited find', () => {
		it('should return empty record set & complete', async () => {
                        // Not sure if I need to do this
                        // definately don't know how
			// mock.method(
			// 	classCodeModel,
			// 	'find',
			// 	() => dbconn.???????.find()
			// );

			assert.deepStrictEqual(statusSpy.mock.calls.length, 0, 'Status has been called already');
			assert.deepStrictEqual(jsonSpy.mock.calls.length, 0, 'Json has been called already');

			await getAll(req, res, next)

			assert.deepStrictEqual(statusSpy.mock.calls.length, 1, 'Status has been Not called');
			assert.deepStrictEqual(jsonSpy.mock.calls.length, 1, 'Json has Not been called');

			assert.deepStrictEqual(res.statusCode, 400)
			assert.deepStrictEqual(res.body, '{"status":"success","length":0,"data":[]}');

			statusSpy.mock.resetCalls();
			jsonSpy.mock.resetCalls();
		});
	});
});
await mongoose.disconnect();
console.log('Mongoose Disconnected');
await mongod.stop();
console.log('mongoServer Stopped');

I feel like I am missing something fundamental but cannot figure out what. All suggestions and assistance appreciated.

[hasezoey]

// const inserted = dbconn.mquery.utils.create({ data });

i recommend to not use mquery directly; in this case you likely want to either use the model directly or use the underlying mongodb client via dbconn.connection.db

// returned: MongoNotConnectedError: Client must be connected before running operations

without knowing the model, i dont know if i can help further - it may be that the model is registered on another mongoose instance or connection than the one connected

// Not sure if I need to do this
// definately don't know how

are you trying to mock the function for the Controller function? mongoose is not easily mocked, so it is recommended to either:

• use a database like normal usage (i think this is called "e2e testing")
• use database abstraction (or also known as "database layer"), where you can mock the database layer functions instead of the individual queries

[rlefever]

I am trying to mock the Model call in the controller (if it is needed/required).

I was hoping to use the in-memory server as a local server for testing. I thought that was mocking the database-layer. Is that not how this should work? When that failed, I tried mocking the myModel.find method but cannot figure out why both methods are failing.

The Model simply imports Schema and model from mongoose, creates a schema, and exports the model.

My E2E testing works, but Unit Testing fails.

I tried dbconn.connection.db.find() for the mock, but it returned 'db.connection.db.find is not a function'.

A console.log of the dbconn returns a Mongoose object and mquery was the only place I found create. Like wise Query.base is the only place I see 'find'.

Thank you for the help.

[hasezoey]

I thought that was mocking the database-layer. Is that not how this should work?

mongodb-memory-server is not a mock, it is a mongodb binary server manager (download & run & stop)

The Model simply imports Schema and model from mongoose, creates a schema, and exports the model.

still would need to see the model file (or more specifically the model = mongoose.model line)

also make sure there is only one mongoose installed (try yarn why mongoose or npm ls mongoose)

I tried dbconn.connection.db.find() for the mock, but it returned 'db.connection.db.find is not a function'.

dbconn.connection.db is a MongoClient Database class, you will have to get a collection first via db.collection('your collection name')

A console.log of the dbconn returns a Mongoose object and mquery was the only place I found create. Like wise Query.base is the only place I see 'find'.

mongoose has multiple finds, there are:

• one on a query object
• one on mquery the query builder
• one on each model

and each is a independent function from each other (at least in terms for mocking), in your case you would need to mock the function find on yourModel (like in jest jest.spyOn(yourModel, 'find'), because jest is the only thing i know to mock), though i dont recommend it because it is a query builder and has implicit other calls that would also need to be mocked or implemented on your mock, so i would recommend to do a database abstraction layer and mock that instead.
for example, a SomeModel.find() returns a Query(builder) instance, which can be augmented further (like .where()) or called via .exec() or if a await is in-front of the operation like await SomeModel.find() it will implicitly call the .then function on the Query which in turn calls .exec.

so instead of keeping all that in-mind, i recommend to abstract it like

// dbAbstraction.js

export async function findRecords(query) {
  return YourModel.find(query).exec();
}

// consumingFn.js

import { findRecords } from './dbAbstraction.js';

export const getAll = async (req, res, next) => {
	const record_set = await findRecords();

	res.status(400).json({
		status: 'success',
		length: record_set.length,
		data: record_set
	});
};

then you only need to mock findRecords and dont have to care about the implementation of the query anymore or order and so can freely modify it like adding a .where() or other query helpers without messing up the mock