express-base-controller
Version:
a nodejs api controller
1,014 lines • 41.7 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const mongoose_1 = require("mongoose");
const node_mocks_http_1 = require("node-mocks-http");
const base_controller_1 = __importDefault(require("./base.controller"));
const mockFilters = ['propertyOne'];
class MockController extends base_controller_1.default {
constructor(_model) {
super(_model);
this.filters.push(...mockFilters);
}
}
const mockSchema = new mongoose_1.Schema({
property: String,
timestamps: {
created: {
at: {
type: Date,
default: Date.now,
},
by: String,
},
updated: {
at: {
type: Date,
default: Date.now,
},
by: String,
},
},
mark: {
deleted: Boolean,
},
});
describe('base.controller spec', () => {
let mockModel;
let controller;
const mockNext = jest.fn();
beforeEach(() => {
mockModel = (0, mongoose_1.model)('mockModel', mockSchema);
controller = new MockController(mockModel);
});
describe('parseSort()', () => {
it('should parse a sort string', () => {
const parsedSort = controller.parseSort('type');
expect(parsedSort).toEqual({ type: 1 });
});
it('should parse a sort object', () => {
const parsedSort = controller.parseSort('{"property": -1}');
expect(parsedSort).toEqual({ property: -1 });
});
it('should parse a sort object with string numbers', () => {
const parsedSort = controller.parseSort('{"property": "-1"}');
expect(parsedSort).toEqual({ property: -1 });
});
it('should parse a sort object with invalid numbers', () => {
const parsedSort = controller.parseSort('{"property": "sort"}');
expect(parsedSort).toEqual({ property: 1 });
});
it('should parse a sort object with multiple params', () => {
const mockSort = {
propertyOne: -1,
propertyTwo: 1,
};
const parsedSort = controller.parseSort(JSON.stringify(mockSort));
expect(parsedSort).toEqual(mockSort);
});
it('should not fail on invalid string', () => {
const mockSort = '\{"foo: 1';
const parsedSort = controller.parseSort(mockSort);
expect(parsedSort).toEqual({ '1': 1 });
});
});
describe('parseFilter()', () => {
it('should return empty object when no filter specified', () => {
const mockQuery = {
limit: 0,
offset: 0,
};
const filter = controller.parseFilter(mockQuery.filter);
expect(filter).toEqual({});
});
it('should parse filter for allowed properties', () => {
const mockQuery = {
limit: 0,
offset: 0,
filter: `{"${mockFilters[0]}": 'foo'}`,
};
const filter = controller.parseFilter(mockQuery.filter);
const expectedQuery = Object.assign(Object.assign({}, mockQuery), { filter: {
[mockFilters[0]]: 'foo',
} });
expect(filter).toEqual(expectedQuery.filter);
});
it('should not parse filter for not allowed properties', () => {
const mockQuery = {
limit: 0,
offset: 0,
filter: '{"bar": \'foo\'}',
};
const parsedFilter = controller.parseFilter(mockQuery.filter);
expect(parsedFilter).toEqual({});
});
it('should not fail for invalid string', () => {
const mockQuery = {
limit: 0,
offset: 0,
filter: '{"bar": \'foo',
};
const parsedFilter = controller.parseFilter(mockQuery.filter);
expect(parsedFilter).toEqual({});
});
});
describe('"parseDateRange() fills requests dataRange and stats"', () => {
it('should be possible to parse date ranges from given year and month param', () => {
const year = 2018;
const month = 12;
const mockRequest = (0, node_mocks_http_1.createRequest)({
params: {
year: year.toString(),
month: month.toString(),
},
});
const mockResponse = (0, node_mocks_http_1.createResponse)();
const from = new Date(year, month - 1, 1, 0, 0, 0);
const to = new Date(year, month, 1, 0, 0, 0);
const expectedDataRange = {
$and: [
{
date: {
$gte: from,
},
}, {
date: {
$lt: to,
},
},
],
};
controller.parseDateRange(mockRequest, mockResponse, mockNext, '', '');
expect(mockRequest.dateRange).toEqual(expectedDataRange);
expect(mockRequest.stats.range).toEqual({ from, to });
});
it('should be possible to parse date range from a year param', () => {
const year = 2018;
const mockRequest = (0, node_mocks_http_1.createRequest)({
params: {
year: year.toString(),
},
});
const mockResponse = (0, node_mocks_http_1.createResponse)();
const from = new Date(year, 0, 1, 0, 0, 0);
const to = new Date(year, 12, 1, 0, 0, 0);
const expectedDataRange = {
$and: [
{
date: {
$gte: from,
},
}, {
date: {
$lt: to,
},
},
],
};
controller.parseDateRange(mockRequest, mockResponse, mockNext, '', '');
expect(mockRequest.dateRange).toEqual(expectedDataRange);
expect(mockRequest.stats.range).toEqual({ from, to });
});
it('should not fail to parse date range from an invalid year param', () => {
const year = 'foo';
const mockRequest = (0, node_mocks_http_1.createRequest)({
params: {
year: year.toString(),
},
});
const mockResponse = (0, node_mocks_http_1.createResponse)();
controller.parseDateRange(mockRequest, mockResponse, mockNext, '', '');
expect(mockRequest.dateRange).toBeFalsy();
expect(mockRequest.stats).toBeFalsy();
});
it('should not fail to parse date range from a valid year but invalid month param', () => {
const year = 2019;
const month = 'foo';
const mockRequest = (0, node_mocks_http_1.createRequest)({
params: {
year: year.toString(),
month: month,
},
stats: {},
});
const mockResponse = (0, node_mocks_http_1.createResponse)();
const from = new Date(year, 0, 1, 0, 0, 0);
const to = new Date(year, 12, 1, 0, 0, 0);
const expectedDataRange = {
$and: [
{
date: {
$gte: from,
},
}, {
date: {
$lt: to,
},
},
],
};
controller.parseDateRange(mockRequest, mockResponse, mockNext, '', '');
expect(mockRequest.dateRange).toEqual(expectedDataRange);
expect(mockRequest.stats.range).toEqual({ from, to });
});
});
describe('"statistics()"', () => {
let mockRequest;
let mockResponse;
let error;
let statsResults;
let nrOfDocuments;
beforeEach(() => {
mockRequest = (0, node_mocks_http_1.createRequest)({});
mockResponse = (0, node_mocks_http_1.createResponse)();
error = null;
statsResults = {
statsOne: 0,
statsTwo: 300,
statsThree: -12,
};
nrOfDocuments = 111;
mockModel.statistics = jest.fn(() => {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(statsResults);
}
});
jest.fn((_query, callback) => callback(error, statsResults));
mockModel.countDocuments = jest.fn().mockImplementation(() => {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(nrOfDocuments);
}
});
});
it('should append statistics to request if model has statistics function', () => __awaiter(void 0, void 0, void 0, function* () {
yield controller.statistics(mockRequest, mockResponse, mockNext);
expect(mockRequest.stats[mockModel.collection.name]).toEqual(statsResults);
}));
it('should not recreate stats object if already exists', () => __awaiter(void 0, void 0, void 0, function* () {
mockRequest.stats = {
otherStats: 'something',
};
yield controller.statistics(mockRequest, mockResponse, mockNext);
expect(mockRequest.stats[mockModel.collection.name]).toEqual(statsResults);
}));
it('should respond with server error if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
id: 'error',
message: 'message',
};
statsResults = null;
yield controller.statistics(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(500);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
it('should append count of objects to request if model has no statistics function', () => __awaiter(void 0, void 0, void 0, function* () {
delete mockModel.statistics;
yield controller.statistics(mockRequest, mockResponse, mockNext);
expect(mockRequest.stats[mockModel.collection.name]).toEqual(nrOfDocuments);
}));
it('should add minimal stats and not create stats if stats already exists on req', () => __awaiter(void 0, void 0, void 0, function* () {
nrOfDocuments = 1000;
statsResults = null;
delete mockModel.statistics;
mockRequest.stats = {
otherStats: 'something',
};
yield controller.statistics(mockRequest, mockResponse, mockNext);
expect(mockRequest.stats[mockModel.collection.name]).toEqual(nrOfDocuments);
}));
it('should respond with server error if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
id: 'error',
message: 'message',
};
nrOfDocuments = null;
statsResults = null;
delete mockModel.statistics;
yield controller.statistics(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(500);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
afterEach(() => {
delete mockModel.statistics;
delete mockModel.countDocuments;
});
});
describe('"statsResponse()"', () => {
let mockRequest;
let mockResponse;
beforeEach(() => {
mockRequest = (0, node_mocks_http_1.createRequest)({});
mockResponse = (0, node_mocks_http_1.createResponse)();
});
it('should respond with stats', () => {
controller.statsResponse(mockRequest, mockResponse, mockNext);
expect(JSON.parse(mockResponse._getData())).toEqual({});
expect(mockResponse.statusCode).toBe(200);
});
it('should not recreate stats if exists', () => {
const stats = {
this: 'that',
};
mockRequest.stats = stats;
controller.statsResponse(mockRequest, mockResponse, mockNext);
expect(JSON.parse(mockResponse._getData())).toEqual(stats);
});
});
describe('"findById()"', () => {
let mockRequest;
let mockResponse;
let _model;
let error;
let populate;
beforeEach(() => {
mockRequest = (0, node_mocks_http_1.createRequest)({});
mockResponse = (0, node_mocks_http_1.createResponse)();
error = null;
_model = new mockModel();
mockModel.findById = jest.fn().mockImplementation((_id) => ({
populate: function (foreignProperties) {
foreignProperties
.forEach((foreignProperty) => {
const key = foreignProperty.path;
_model[key] = foreignProperty.select;
});
return this;
},
exec: jest.fn(() => {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(_model);
}
}),
}));
});
it('should append model to request if it has a valid id', () => __awaiter(void 0, void 0, void 0, function* () {
const id = new mongoose_1.Types.ObjectId();
_model = new mockModel({ id: id });
yield controller.findById(mockRequest, mockResponse, mockNext, id);
expect(mockRequest.model).toEqual(_model);
}));
it('should respond 500 if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
const id = new mongoose_1.Types.ObjectId();
_model = null;
error = {
id: 'serverError',
message: 'message',
};
yield controller.findById(mockRequest, mockResponse, mockNext, id);
expect(mockResponse.statusCode).toBe(500);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
it('should return 404 if model not found', () => __awaiter(void 0, void 0, void 0, function* () {
const id = new mongoose_1.Types.ObjectId();
const err = {
id: 'notFound',
message: `${mockModel.modelName} ${id} does not exist`,
errors: [],
fields: {},
};
_model = null;
yield controller.findById(mockRequest, mockResponse, mockNext, id);
expect(mockResponse.statusCode).toBe(404);
expect(JSON.parse(mockResponse._getData())).toEqual({ error: err });
}));
it('should return 400 if invalid model id', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
id: 'invalidId',
message: 'Invalid id',
errors: [],
fields: {},
};
_model = null;
yield controller.findById(mockRequest, mockResponse, mockNext, 'id');
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
it('should populate model with requested data', () => __awaiter(void 0, void 0, void 0, function* () {
const id = new mongoose_1.Types.ObjectId();
populate = {
path: 'foo',
select: 'bar baz',
};
_model = new mockModel({ id: id });
yield controller.findById(mockRequest, mockResponse, mockNext, id, '', [populate]);
expect(mockRequest.model).toHaveProperty(populate.path, populate.select);
}));
afterEach(() => {
delete mockModel.findById;
});
});
describe('"index()"', () => {
let mockRequest;
let mockResponse;
let error;
let data = [];
let query;
beforeEach(() => {
mockResponse = (0, node_mocks_http_1.createResponse)();
mockResponse.query = {};
error = null;
data = [new mockModel(), new mockModel()];
query = {
q: '',
offset: 0,
limit: 100,
populate: [],
select: null,
sort: null,
};
mockModel.find = jest.fn((q) => {
mockResponse.query.q = q;
const mockFind = {
limit: (limit) => {
mockResponse.query.limit = limit;
return mockFind;
},
skip: (skip) => {
mockResponse.query.offset = skip;
return mockFind;
},
sort: (sort) => {
mockResponse.query.sort = sort;
return mockFind;
},
select: (select) => {
mockResponse.query.select = select;
return mockFind;
},
populate: (populate) => {
mockResponse.query.populate = populate;
return mockFind;
},
exec: jest.fn().mockImplementation(() => {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(data);
}
}),
};
return mockFind;
});
});
it('should return a list of models', () => __awaiter(void 0, void 0, void 0, function* () {
mockRequest = (0, node_mocks_http_1.createRequest)({});
yield controller.index(mockRequest, mockResponse, mockNext);
expect(mockRequest.data).toEqual(data);
expect(mockResponse.query).toEqual(Object.assign(Object.assign({}, query), { q: {}, select: {} }));
}));
it('should allow to change query', () => __awaiter(void 0, void 0, void 0, function* () {
query.offset = '10';
query.limit = '10';
mockRequest = (0, node_mocks_http_1.createRequest)({
query,
});
yield controller.index(mockRequest, mockResponse, mockNext);
expect(mockResponse.query.offset).toEqual(parseInt(query.offset, 10));
expect(mockResponse.query.limit).toEqual(parseInt(query.limit, 10));
}));
it('should add sort and filters', () => __awaiter(void 0, void 0, void 0, function* () {
query.sort = 'type';
query.filter = 'type';
mockRequest = (0, node_mocks_http_1.createRequest)({
query,
});
yield controller.index(mockRequest, mockResponse, mockNext);
expect(mockResponse.query.sort).toEqual({ type: 1 });
}));
it('should call model parseQuery, if exists', () => __awaiter(void 0, void 0, void 0, function* () {
query.sort = 'type';
query.filter = 'type';
mockRequest = (0, node_mocks_http_1.createRequest)({
query,
});
mockModel.parseQuery = jest.fn().mockImplementation((_query) => _query);
yield controller.index(mockRequest, mockResponse, mockNext);
expect(mockResponse.query.sort).toEqual({ type: 1 });
}));
it('should return error, if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
query.sort = 'type';
query.filter = 'type';
mockRequest = (0, node_mocks_http_1.createRequest)({
query,
});
error = {
id: 'mockError',
message: 'mockMessage',
};
yield controller.index(mockRequest, mockResponse, (err) => {
expect(err).toEqual(error);
});
expect(mockResponse.query.sort).toEqual({ type: 1 });
}));
});
describe('"read()"', () => {
let mockRequest;
let mockResponse;
let _model;
beforeEach(() => {
_model = new mockModel({ property: 'bar' });
mockResponse = (0, node_mocks_http_1.createResponse)();
});
it('should return model as json', () => {
mockRequest = (0, node_mocks_http_1.createRequest)({
model: _model,
});
controller.read(mockRequest, mockResponse, mockNext);
const clone = JSON.parse(JSON.stringify(_model.toObject()));
expect(mockResponse.statusCode).toBe(200);
expect(JSON.parse(mockResponse._getData())).toEqual(clone);
});
it('should return model not found if no model', () => {
const err = {
id: 'modelMissing',
message: 'the model is missing in the request',
errors: [],
fields: {},
};
_model = null;
mockRequest = (0, node_mocks_http_1.createRequest)({});
controller.read(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({ error: err });
});
});
describe('"create()"', () => {
let mockRequest;
let mockResponse;
let body;
const user = 'test';
let error;
let _model;
beforeEach(() => {
error = null;
body = {
property: 'something',
};
mockResponse = (0, node_mocks_http_1.createResponse)();
mockModel.prototype.save = jest.fn(function () {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(this);
}
});
_model = new mockModel(body);
mockRequest = (0, node_mocks_http_1.createRequest)({
user: {
username: user,
},
body,
});
});
it('should create a model', () => __awaiter(void 0, void 0, void 0, function* () {
yield controller.create(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(201);
const response = JSON.parse(mockResponse._getData());
expect(response).toHaveProperty('property', body.property);
expect(response).toHaveProperty('timestamps.created.by', user);
}));
it('should return validation error if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
name: 'ValidationError',
id: 'validationError',
message: 'the model has invalid properties',
errors: 'fields',
};
yield controller.create(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({
error: {
id: error.id,
message: error.message,
fields: error.errors,
errors: [],
},
});
}));
it('should return duplicate error if is duplication', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
code: 11000,
};
yield controller.create(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({
error: {
id: 'duplicate',
message: `${mockModel.modelName} already exists`,
},
});
}));
it('should return next error, if not duplicate nor validation error', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
message: 'something',
};
yield controller.create(mockRequest, mockResponse, (err) => {
expect(err).toEqual(error);
});
}));
it('should not allow to set timestamps or id', () => __awaiter(void 0, void 0, void 0, function* () {
body = {
property: 'something else',
_id: 5,
id: 17,
timestamps: {
crated: {
at: new Date(),
by: 'someone',
},
},
};
_model = new mockModel(body);
mockRequest = (0, node_mocks_http_1.createRequest)({
user: {
username: user,
},
body,
});
yield controller.create(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(201);
const response = JSON.parse(mockResponse._getData());
expect(response).toHaveProperty('property', body.property);
expect(response).toHaveProperty('timestamps.created.by', user);
expect(response).not.toHaveProperty('_id', body._id);
expect(response).not.toHaveProperty('id', body.id);
}));
afterEach(() => {
delete _model.save;
});
});
describe('"update()"', () => {
let mockRequest;
let mockResponse;
let body;
const user = 'test';
let error;
let _model;
beforeEach(() => {
error = null;
body = {
property: 'something',
};
mockResponse = (0, node_mocks_http_1.createResponse)();
mockModel.prototype.save = jest.fn(function () {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(this);
}
});
_model = new mockModel({ property: 'initial' });
mockRequest = (0, node_mocks_http_1.createRequest)({
user: {
username: user,
},
model: _model,
body,
});
});
it('should update a model', () => __awaiter(void 0, void 0, void 0, function* () {
yield controller.update(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(200);
const response = JSON.parse(mockResponse._getData());
expect(response).toHaveProperty('property', body.property);
expect(response).toHaveProperty('timestamps.updated.by', user);
}));
it('should return validation error if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
name: 'ValidationError',
id: 'validationError',
message: 'the model has invalid properties',
errors: 'fields',
};
yield controller.update(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({
error: {
id: error.id,
message: error.message,
fields: error.errors,
errors: [],
},
});
}));
it('should return next error, if its not a validation error', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
message: 'something',
};
yield controller.update(mockRequest, mockResponse, (err) => {
expect(err).toEqual(error);
});
}));
it('should return model missing, if model is missing', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
id: 'modelMissing',
message: 'the model is missing in the request',
errors: [],
fields: {},
};
mockRequest = (0, node_mocks_http_1.createRequest)({
user: {
username: user,
},
body,
});
yield controller.update(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
it('should not allow to set timestamps or id', () => __awaiter(void 0, void 0, void 0, function* () {
body = {
property: 'something else',
_id: null,
id: 17,
timestamps: {
crated: {
at: new Date(),
by: 'someone',
},
},
};
_model = new mockModel({ property: 'initial' });
mockRequest = (0, node_mocks_http_1.createRequest)({
user: {
username: user,
},
model: _model,
body,
});
yield controller.update(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(200);
const response = JSON.parse(mockResponse._getData());
expect(response).toHaveProperty('property', body.property);
expect(response).toHaveProperty('timestamps.updated.by', user);
expect(response).not.toHaveProperty('_id', body._id);
expect(response).not.toHaveProperty('id', body.id);
}));
afterEach(() => {
delete _model.save;
});
});
describe('"softDelete()"', () => {
let mockRequest;
let mockResponse;
let error;
let _model;
const user = 'test';
beforeEach(() => {
error = null;
mockResponse = (0, node_mocks_http_1.createResponse)();
mockModel.prototype.save = jest.fn(function () {
if (error) {
return Promise.reject(error);
}
else {
return Promise.resolve(this);
}
});
_model = new mockModel({ property: 'something' });
mockRequest = (0, node_mocks_http_1.createRequest)({
model: _model,
user: {
username: user,
},
});
});
it('should mark a model as deleted', () => __awaiter(void 0, void 0, void 0, function* () {
yield controller.softDelete(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(200);
const response = JSON.parse(mockResponse._getData());
expect(response).toHaveProperty('mark.deleted', true);
}));
it('should return deletion error if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
id: 'delete',
message: 'the model has invalid properties',
errors: [],
fields: {},
};
yield controller.softDelete(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
it('should return model missing, if model is missing', () => __awaiter(void 0, void 0, void 0, function* () {
error = {
id: 'modelMissing',
message: 'the model is missing in the request',
errors: [],
fields: {},
};
mockRequest = (0, node_mocks_http_1.createRequest)({});
yield controller.softDelete(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
}));
afterEach(() => {
delete _model.save;
});
});
describe('"delete()"', () => {
let mockRequest;
let mockResponse;
let error;
let _model;
beforeEach(() => {
error = null;
mockResponse = (0, node_mocks_http_1.createResponse)();
mockModel.deleteOne = jest.fn().mockReturnValue(Promise.resolve(_model));
_model = new mockModel({ property: 'something' });
mockRequest = (0, node_mocks_http_1.createRequest)({
model: _model,
});
});
it('should remove a model', () => __awaiter(void 0, void 0, void 0, function* () {
yield controller.delete(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(200);
const response = JSON.parse(mockResponse._getData());
expect(response._id.toString()).toEqual(_model._id.toString());
}));
it('should return model missing, if model is missing', () => {
error = {
id: 'modelMissing',
message: 'the model is missing in the request',
errors: [],
fields: {},
};
mockRequest = (0, node_mocks_http_1.createRequest)({});
controller.delete(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(400);
expect(JSON.parse(mockResponse._getData())).toEqual({ error });
});
it('should return error if error occurs', () => {
_model = new mockModel({ property: 'something' });
mockRequest = (0, node_mocks_http_1.createRequest)({
model: _model,
});
error = {
id: 'mockError',
message: 'mock message',
};
controller.delete(mockRequest, mockResponse, (err) => {
expect(err).toEqual(error);
});
});
afterEach(() => {
delete _model.save;
});
});
describe('"apiResponse()"', () => {
let mockRequest;
let mockResponse;
let data = [];
let meta;
beforeEach(() => {
mockResponse = (0, node_mocks_http_1.createResponse)();
meta = {
total: 100,
count: 10,
offset: 0,
limit: 100,
};
data = [new mockModel(), new mockModel()];
});
it('should generate an api response', () => {
mockRequest = (0, node_mocks_http_1.createRequest)({
data: data,
meta: meta,
});
controller.apiResponse(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(200);
const response = JSON.parse(mockResponse._getData());
expect(response.data.length).toEqual(data.length);
expect(response.meta).toEqual(meta);
});
it('should return a 500 error on meta error', () => {
meta.error = {
id: 'foo',
message: 'bar',
errors: [],
fields: {},
};
mockRequest = (0, node_mocks_http_1.createRequest)({
data: data,
meta: meta,
});
controller.apiResponse(mockRequest, mockResponse, mockNext);
expect(mockResponse.statusCode).toBe(500);
const response = JSON.parse(mockResponse._getData());
expect(response.data.length).toEqual(data.length);
expect(response.meta).toEqual(meta);
});
});
describe('"populateMeta()"', () => {
let mockRequest;
let mockResponse;
let data = [];
let error;
let nrOfDocuments;
beforeEach(() => {
mockResponse = (0, node_mocks_http_1.createResponse)();
error = null;
data = [new mockModel(), new mockModel()];
nrOfDocuments = 111;
mockModel.countDocuments =
jest.fn().mockImplementation((_query) => Promise.resolve(nrOfDocuments));
});
it('should append meta data to request with strings', () => __awaiter(void 0, void 0, void 0, function* () {
const offset = '10';
const limit = '10';
mockRequest = (0, node_mocks_http_1.createRequest)({
data: data,
modelQuery: {
total: 'query',
offset: offset,
limit: limit,
},
});
yield controller.populateMeta(mockRequest, mockResponse, mockNext);
expect(mockRequest.meta).toBeTruthy();
expect(mockRequest.meta.total).toEqual(nrOfDocuments);
expect(mockRequest.meta.count).toEqual(data.length);
expect(mockRequest.meta.offset).toEqual(parseInt(offset, 10));
expect(mockRequest.meta.limit).toEqual(parseInt(limit, 10));
}));
it('should append meta data to request with numbers', () => __awaiter(void 0, void 0, void 0, function* () {
const offset = 10;
const limit = 10;
mockRequest = (0, node_mocks_http_1.createRequest)({
data: data,
modelQuery: {
offset: offset,
limit: limit,
},
});
yield controller.populateMeta(mockRequest, mockResponse, mockNext);
expect(mockRequest.meta).toBeTruthy();
expect(mockRequest.meta.total).toEqual(nrOfDocuments);
expect(mockRequest.meta.count).toEqual(data.length);
expect(mockRequest.meta.offset).toEqual(offset);
expect(mockRequest.meta.limit).toEqual(limit);
}));
it('should append meta data even if no data found', () => __awaiter(void 0, void 0, void 0, function* () {
const offset = 10;
const limit = 10;
mockRequest = (0, node_mocks_http_1.createRequest)({
data: null,
modelQuery: {
offset: offset,
limit: limit,
},
});
yield controller.populateMeta(mockRequest, mockResponse, mockNext);
expect(mockRequest.meta).toBeTruthy();
expect(mockRequest.meta.total).toEqual(nrOfDocuments);
expect(mockRequest.meta.count).toEqual(0);
expect(mockRequest.meta.offset).toEqual(offset);
expect(mockRequest.meta.limit).toEqual(limit);
}));
it('should return next, if error occurs', () => __awaiter(void 0, void 0, void 0, function* () {
mockRequest = (0, node_mocks_http_1.createRequest)({
modelQuery: {},
});
error = {
id: 'mockError',
message: 'mockMessage',
errors: [],
fields: {},
};
mockModel.countDocuments =
jest.fn().mockImplementation((_query) => Promise.reject(error));
yield controller.populateMeta(mockRequest, mockResponse, mockNext);
expect(mockNext).toHaveBeenCalledWith(error);
}));
});
describe('"parsePagination()"', () => {
it('should also parse pagination on a string value', () => {
const mockValue = controller.parsePagination('10', '100');
expect(mockValue).toBe(10);
});
});
});
//# sourceMappingURL=base.controller.spec.js.map