Skip to content

Commit 0dcefdd

Browse files
one-communityone-community
authored
Merge pull request #1991 from OneCommunityGlobal/julia-fix-ownerMessageController-test
Julia - Add tests for ownerMessage
2 parents 6ed80c0 + ba3822b commit 0dcefdd

5 files changed

Lines changed: 299 additions & 145 deletions

File tree

‎package-lock.json‎

Lines changed: 10 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎src/controllers/ownerMessageController.js‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ const ownerMessageController = function (OwnerMessage) {
5757

5858
const updateOwnerMessage = async function (req, res) {
5959
if (!(await helper.hasPermission(req.body.requestor, 'editHeaderMessage'))) {
60-
res.status(403).send('You are not authorized to create messages!');
60+
return res.status(403).send('You are not authorized to create messages!');
6161
}
6262
const { isStandard, newMessage } = req.body;
6363
// Use a session to ensure atomicity of operations
@@ -103,7 +103,7 @@ const ownerMessageController = function (OwnerMessage) {
103103

104104
const deleteOwnerMessage = async function (req, res) {
105105
if (!(await helper.hasPermission(req.body.requestor, 'editHeaderMessage'))) {
106-
res.status(403).send('You are not authorized to delete messages!');
106+
return res.status(403).send('You are not authorized to delete messages!');
107107
}
108108
// Use a session to ensure atomicity of operations
109109
const session = await mongoose.startSession();

‎src/controllers/ownerMessageController.spec.js‎

Lines changed: 152 additions & 142 deletions
Original file line numberDiff line numberDiff line change
@@ -1,143 +1,153 @@
1-
// TODO: Fix whole file
2-
describe('ownerMessageControler tests', () => {
3-
it('Fix this test suite', () => {});
1+
jest.mock('../utilities/permissions', () => ({
2+
hasPermission: jest.fn(),
3+
}));
4+
const helper = require('../utilities/permissions');
5+
const OwnerMessage = require('../models/ownerMessage');
6+
const { mockReq, mockRes, assertResMock } = require('../test');
7+
const ownerMessageController = require('./ownerMessageController');
8+
9+
const makeSut = () => {
10+
const { getOwnerMessage, updateOwnerMessage, deleteOwnerMessage } =
11+
ownerMessageController(OwnerMessage);
12+
return {
13+
getOwnerMessage,
14+
updateOwnerMessage,
15+
deleteOwnerMessage,
16+
};
17+
};
18+
const flushPromises = () => new Promise(setImmediate);
19+
20+
describe('ownerMessageController Unit Tests', () => {
21+
let mockFind;
22+
let mockSave;
23+
afterEach(() => {
24+
jest.clearAllMocks();
25+
});
26+
27+
beforeEach(() => {
28+
mockFind = jest.spyOn(OwnerMessage, 'find');
29+
mockSave = jest.fn();
30+
});
31+
describe('getOwnerMessage', () => {
32+
test('Ensures getOwnerMessage returns status 404 if owner message cant be found', async () => {
33+
const { getOwnerMessage } = makeSut();
34+
const errorMsg = 'Error occurred when finding owner message';
35+
mockFind.mockImplementationOnce(() => Promise.reject(errorMsg));
36+
const response = await getOwnerMessage(mockReq, mockRes);
37+
await flushPromises();
38+
assertResMock(404, errorMsg, response, mockRes);
39+
});
40+
test('Ensures getOwnerMessage returns status 200 with new owner message if none exist', async () => {
41+
mockFind.mockResolvedValue([]);
42+
const ownerMessageInstance = new OwnerMessage();
43+
ownerMessageInstance.set = jest.fn();
44+
const mockSaveFn = jest.fn().mockResolvedValue(ownerMessageInstance);
45+
46+
jest.spyOn(OwnerMessage.prototype, 'save').mockImplementation(mockSaveFn);
47+
await makeSut().getOwnerMessage(mockReq, mockRes);
48+
await flushPromises();
49+
50+
expect(mockRes.status).toHaveBeenCalledWith(200);
51+
expect(mockRes.send).toHaveBeenCalledWith(
52+
expect.objectContaining({
53+
ownerMessage: expect.objectContaining({
54+
_id: expect.anything(),
55+
message: '',
56+
standardMessage: '',
57+
}),
58+
}),
59+
);
60+
expect(mockSaveFn).toHaveBeenCalled();
61+
});
62+
63+
test('Ensures getOwnerMessage returns status 200 with the first owner message if it exists', async () => {
64+
const existingMessage = { message: 'Existing message', standardMessage: 'Standard message' };
65+
mockFind.mockResolvedValue([existingMessage]);
66+
await makeSut().getOwnerMessage(mockReq, mockRes);
67+
expect(mockRes.status).toHaveBeenCalledWith(200);
68+
expect(mockRes.send).toHaveBeenCalledWith({ ownerMessage: existingMessage });
69+
});
70+
});
71+
72+
describe('updateOwnerMessage', () => {
73+
test('Ensures updateOwnerMessage returns status 403 if requestor is not an owner', async () => {
74+
const { updateOwnerMessage } = makeSut();
75+
helper.hasPermission.mockResolvedValue(false);
76+
const req = { body: { requestor: { role: 'User' } } };
77+
const response = await updateOwnerMessage(req, mockRes);
78+
await flushPromises();
79+
assertResMock(403, 'You are not authorized to create messages!', response, mockRes);
80+
});
81+
test('Ensures updateOwnerMessage returns status 201 and updates the owner message correctly with custom message', async () => {
82+
const existingMessage = { message: '', standardMessage: '', save: mockSave };
83+
mockFind.mockResolvedValue([existingMessage]);
84+
const mockReqDup = {
85+
...mockReq,
86+
body: {
87+
...mockReq.body,
88+
isStandard: false,
89+
newMessage: 'New custom message',
90+
requestor: { role: 'Owner' },
91+
},
92+
};
93+
helper.hasPermission.mockResolvedValue(true);
94+
await makeSut().updateOwnerMessage(mockReqDup, mockRes);
95+
expect(mockRes.status).toHaveBeenCalledWith(201);
96+
expect(mockRes.send).toHaveBeenCalledWith({
97+
_serverMessage: 'Update successfully!',
98+
ownerMessage: { standardMessage: '', message: 'New custom message' },
99+
});
100+
expect(mockSave).toHaveBeenCalled();
101+
});
102+
test('Ensures updateOwnerMessage returns status 500 if an error occurs during the update', async () => {
103+
const errorMsg = 'Error occurred during update';
104+
mockFind.mockRejectedValue(errorMsg);
105+
const mockReqDup = { ...mockReq, body: { ...mockReq.body, requestor: { role: 'Owner' } } };
106+
helper.hasPermission.mockResolvedValue(true);
107+
await makeSut().updateOwnerMessage(mockReqDup, mockRes);
108+
expect(mockRes.status).toHaveBeenCalledWith(500);
109+
expect(mockRes.send).toHaveBeenCalledWith(errorMsg);
110+
});
111+
});
112+
113+
describe('deleteOwnerMessage', () => {
114+
test('Ensures deleteOwnerMessage returns status 403 if requestor is not an owner', async () => {
115+
const { deleteOwnerMessage } = makeSut();
116+
mockReq.body.requestor.role = 'notOwner';
117+
helper.hasPermission.mockResolvedValue(false);
118+
const response = await deleteOwnerMessage(mockReq, mockRes);
119+
await flushPromises();
120+
assertResMock(403, 'You are not authorized to delete messages!', response, mockRes);
121+
});
122+
test('Ensures deleteOwnerMessage returns status 200 and deletes the owner message correctly', async () => {
123+
const existingMessage = {
124+
message: 'Existing message',
125+
standardMessage: 'Standard message',
126+
save: mockSave,
127+
};
128+
mockFind.mockResolvedValue([existingMessage]);
129+
mockReq.body.requestor.role = '';
130+
helper.hasPermission.mockResolvedValue(true);
131+
132+
const { deleteOwnerMessage } = makeSut();
133+
await deleteOwnerMessage(mockReq, mockRes);
134+
expect(mockRes.status).toHaveBeenCalledWith(200);
135+
expect(mockRes.send).toHaveBeenCalledWith({
136+
_serverMessage: 'Delete successfully!',
137+
ownerMessage: existingMessage,
138+
});
139+
expect(mockSave).toHaveBeenCalled();
140+
});
141+
test('Ensures deleteOwnerMessage returns status 500 if an error occurs during the delete', async () => {
142+
const errorMsg = 'Error occurred during delete';
143+
mockFind.mockRejectedValue(errorMsg);
144+
mockReq.body.requestor.role = 'Owner';
145+
helper.hasPermission.mockResolvedValue(true);
146+
147+
const { deleteOwnerMessage } = makeSut();
148+
await deleteOwnerMessage(mockReq, mockRes);
149+
expect(mockRes.status).toHaveBeenCalledWith(500);
150+
expect(mockRes.send).toHaveBeenCalledWith(errorMsg);
151+
});
152+
});
4153
});
5-
// const OwnerMessage = require('../models/ownerMessage');
6-
// const ownerMessageController = require('./ownerMessageController');
7-
// const { mockReq, mockRes, assertResMock } = require('../test');
8-
//
9-
// const makeSut = () => {
10-
// const { getOwnerMessage, updateOwnerMessage, deleteOwnerMessage } =
11-
// ownerMessageController(OwnerMessage);
12-
// return {
13-
// getOwnerMessage,
14-
// updateOwnerMessage,
15-
// deleteOwnerMessage,
16-
// };
17-
// };
18-
// const flushPromises = () => new Promise(setImmediate);
19-
//
20-
// describe('ownerMessageController Unit Tests', () => {
21-
// let mockFind;
22-
// let mockSave;
23-
// afterEach(() => {
24-
// jest.clearAllMocks();
25-
// });
26-
//
27-
// beforeEach(() => {
28-
// mockFind = jest.spyOn(OwnerMessage, 'find');
29-
// mockSave = jest.fn();
30-
// });
31-
// describe('getOwnerMessage', () => {
32-
// test('Ensures getOwnerMessage returns status 404 if owner message cant be found', async () => {
33-
// const { getOwnerMessage } = makeSut();
34-
// const errorMsg = 'Error occurred when finding owner message';
35-
// mockFind.mockImplementationOnce(() => Promise.reject(errorMsg));
36-
// const response = await getOwnerMessage(mockReq, mockRes);
37-
// await flushPromises();
38-
// assertResMock(404, errorMsg, response, mockRes);
39-
// });
40-
// test('Ensures getOwnerMessage returns status 200 with new owner message if none exist', async () => {
41-
// mockFind.mockResolvedValue([]);
42-
// const ownerMessageInstance = new OwnerMessage();
43-
// ownerMessageInstance.set = jest.fn();
44-
// const mockSaveFn = jest.fn().mockResolvedValue(ownerMessageInstance);
45-
//
46-
// jest.spyOn(OwnerMessage.prototype, 'save').mockImplementation(mockSaveFn);
47-
// await makeSut().getOwnerMessage(mockReq, mockRes);
48-
// await flushPromises();
49-
//
50-
// expect(mockRes.status).toHaveBeenCalledWith(200);
51-
// expect(mockRes.send).toHaveBeenCalledWith(
52-
// expect.objectContaining({
53-
// ownerMessage: expect.objectContaining({
54-
// _id: expect.anything(),
55-
// message: '',
56-
// standardMessage: '',
57-
// }),
58-
// }),
59-
// );
60-
// expect(mockSaveFn).toHaveBeenCalled();
61-
// });
62-
//
63-
// test('Ensures getOwnerMessage returns status 200 with the first owner message if it exists', async () => {
64-
// const existingMessage = { message: 'Existing message', standardMessage: 'Standard message' };
65-
// mockFind.mockResolvedValue([existingMessage]);
66-
// await makeSut().getOwnerMessage(mockReq, mockRes);
67-
// expect(mockRes.status).toHaveBeenCalledWith(200);
68-
// expect(mockRes.send).toHaveBeenCalledWith({ ownerMessage: existingMessage });
69-
// });
70-
// });
71-
// describe('updateOwnerMessage', () => {
72-
// test('Ensures updateOwnerMessage returns status 403 if requestor is not an owner', async () => {
73-
// const { updateOwnerMessage } = makeSut();
74-
// const req = { body: { requestor: { role: 'User' } } };
75-
// const response = await updateOwnerMessage(req, mockRes);
76-
// await flushPromises();
77-
// assertResMock(403, 'You are not authorized to create messages!', response, mockRes);
78-
// });
79-
// test('Ensures updateOwnerMessage returns status 201 and updates the owner message correctly with custom message', async () => {
80-
// const existingMessage = { message: '', standardMessage: '', save: mockSave };
81-
// mockFind.mockResolvedValue([existingMessage]);
82-
// const mockReqDup = {
83-
// ...mockReq,
84-
// body: {
85-
// ...mockReq.body,
86-
// isStandard: false,
87-
// newMessage: 'New custom message',
88-
// requestor: { role: 'Owner' },
89-
// },
90-
// };
91-
// await makeSut().updateOwnerMessage(mockReqDup, mockRes);
92-
// expect(mockRes.status).toHaveBeenCalledWith(201);
93-
// expect(mockRes.send).toHaveBeenCalledWith({
94-
// _serverMessage: 'Update successfully!',
95-
// ownerMessage: { standardMessage: '', message: 'New custom message' },
96-
// });
97-
// expect(mockSave).toHaveBeenCalled();
98-
// });
99-
// test('Ensures updateOwnerMessage returns status 500 if an error occurs during the update', async () => {
100-
// const errorMsg = 'Error occurred during update';
101-
// mockFind.mockRejectedValue(errorMsg);
102-
// const mockReqDup = { ...mockReq, body: { ...mockReq.body, requestor: { role: 'Owner' } } };
103-
// await makeSut().updateOwnerMessage(mockReqDup, mockRes);
104-
// expect(mockRes.status).toHaveBeenCalledWith(500);
105-
// expect(mockRes.send).toHaveBeenCalledWith(errorMsg);
106-
// });
107-
// });
108-
// describe('deleteOwnerMessage', () => {
109-
// test('Ensures deleteOwnerMessage returns status 403 if requestor is not an owner', async () => {
110-
// const { deleteOwnerMessage } = makeSut();
111-
// mockReq.body.requestor.role = 'notOwner';
112-
// const response = await deleteOwnerMessage(mockReq, mockRes);
113-
// await flushPromises();
114-
// assertResMock(403, 'You are not authorized to delete messages!', response, mockRes);
115-
// });
116-
// test('Ensures deleteOwnerMessage returns status 200 and deletes the owner message correctly', async () => {
117-
// const existingMessage = {
118-
// message: 'Existing message',
119-
// standardMessage: 'Standard message',
120-
// save: mockSave,
121-
// };
122-
// const { deleteOwnerMessage } = makeSut();
123-
// mockFind.mockResolvedValue([existingMessage]);
124-
// mockReq.body.requestor.role = '';
125-
// await deleteOwnerMessage(mockReq, mockRes);
126-
// expect(mockRes.status).toHaveBeenCalledWith(200);
127-
// expect(mockRes.send).toHaveBeenCalledWith({
128-
// _serverMessage: 'Delete successfully!',
129-
// ownerMessage: existingMessage,
130-
// });
131-
// expect(mockSave).toHaveBeenCalled();
132-
// });
133-
// test('Ensures deleteOwnerMessage returns status 500 if an error occurs during the delete', async () => {
134-
// const { deleteOwnerMessage } = makeSut();
135-
// const errorMsg = 'Error occurred during delete';
136-
// mockFind.mockRejectedValue(errorMsg);
137-
// mockReq.body.requestor.role = 'Owner';
138-
// await deleteOwnerMessage(mockReq, mockRes);
139-
// expect(mockRes.status).toHaveBeenCalledWith(500);
140-
// expect(mockRes.send).toHaveBeenCalledWith(errorMsg);
141-
// });
142-
// });
143-
// });

0 commit comments

Comments
 (0)