f.weber/homebrewery
0
0
Fork 0
mirror of https://github.com/naturalcrit/homebrewery.git synced 2026-03-22 08:58:11 +00:00
Code Wiki Activity

this fixes the tests

Browse Source
This commit is contained in:
Víctor Losada Hernández
2026-02-24 21:51:34 +01:00
parent c89f17ebbf
commit 86a03fd0bf
2 changed files with 156 additions and 255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
server.js
View File

@@ -4,11 +4,12 @@ import config from "./server/config.js";
import { createServer as createViteServer } from "vite"; import { createServer as createViteServer } from "vite";
const isProd = process.env.NODE_ENV === "production"; const isProd = process.env.NODE_ENV === "production";
const isDev = process.env.NODE_ENV === "development";
async function start() { async function start() {
let vite; let vite;
if (!isProd) { if (isDev) {
vite = await createViteServer({ vite = await createViteServer({
server: { middlewareMode: true }, server: { middlewareMode: true },
appType: "custom", appType: "custom",

408
server/admin.api.spec.js
View File

@@ -1,42 +1,45 @@
/*eslint max-lines: ["warn", {"max": 1000, "skipBlankLines": true, "skipComments": true}]*/ /*eslint max-lines: ["warn", {"max": 1000, "skipBlankLines": true, "skipComments": true}]*/
import mongoose from 'mongoose'; import mongoose from 'mongoose';
import supertest from 'supertest'; import supertest from 'supertest';
import HBApp from './app.js'; import createApp from './app.js';
import { model as NotificationModel } from './notifications.model.js'; import { model as NotificationModel } from './notifications.model.js';
import { model as HomebrewModel } from './homebrew.model.js'; import { model as HomebrewModel } from './homebrew.model.js';
let app;
// Mimic https responses to avoid being redirected all the time let request;
const app = supertest.agent(HBApp).set('X-Forwarded-Proto', 'https');
let dbState; let dbState;
beforeAll(async ()=>{
app = await createApp();
request = supertest.agent(app).set('X-Forwarded-Proto', 'https');
});
describe('Tests for admin api', ()=>{ describe('Tests for admin api', ()=>{
beforeEach(()=>{ beforeEach(()=>{
// Mock DB ready (for dbCheck middleware)
dbState = mongoose.connection.readyState; dbState = mongoose.connection.readyState;
mongoose.connection.readyState = 1; mongoose.connection.readyState = 1;
}); });
afterEach(()=>{ afterEach(()=>{
// Restore DB ready state
mongoose.connection.readyState = dbState; mongoose.connection.readyState = dbState;
jest.resetAllMocks(); jest.resetAllMocks();
}); });
afterAll(async ()=>{
await mongoose.connection.close();
});
describe('Notifications', ()=>{ describe('Notifications', ()=>{
it('should return list of all notifications', async ()=>{ it('should return list of all notifications', async ()=>{
const testNotifications = ['a', 'b']; const testNotifications = ['a', 'b'];
jest.spyOn(NotificationModel, 'find') jest.spyOn(NotificationModel, 'find').mockImplementationOnce(()=>{
.mockImplementationOnce(()=>{
return { exec: jest.fn().mockResolvedValue(testNotifications) }; return { exec: jest.fn().mockResolvedValue(testNotifications) };
}); });
const response = await app const response = await request
.get('/admin/notification/all') .get('/admin/notification/all')
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual(testNotifications); expect(response.body).toEqual(testNotifications);
@@ -56,18 +59,17 @@ describe('Tests for admin api', ()=>{
_id : expect.any(String), _id : expect.any(String),
createdAt : expect.any(String), createdAt : expect.any(String),
startAt : inputNotification.startAt, startAt : inputNotification.startAt,
stopAt : inputNotification.stopAt, stopAt : inputNotification.stopAt
}; };
jest.spyOn(NotificationModel.prototype, 'save') jest.spyOn(NotificationModel.prototype, 'save').mockImplementationOnce(function () {
.mockImplementationOnce(function() { return Promise.resolve(this);
return Promise.resolve(this); });
});
const response = await app const response = await request
.post('/admin/notification/add') .post('/admin/notification/add')
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
.send(inputNotification); .send(inputNotification);
expect(response.status).toBe(201); expect(response.status).toBe(201);
expect(response.body).toEqual(savedNotification); expect(response.body).toEqual(savedNotification);
@@ -81,16 +83,14 @@ describe('Tests for admin api', ()=>{
stopAt : new Date().toISOString() stopAt : new Date().toISOString()
}; };
//Change 'save' function to just return itself instead of actually interacting with the database jest.spyOn(NotificationModel.prototype, 'save').mockImplementationOnce(function () {
jest.spyOn(NotificationModel.prototype, 'save') return Promise.resolve(this);
.mockImplementationOnce(function() { });
return Promise.resolve(this);
});
const response = await app const response = await request
.post('/admin/notification/add') .post('/admin/notification/add')
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
.send(inputNotification); .send(inputNotification);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ message: 'Dismiss key is required!' }); expect(response.body).toEqual({ message: 'Dismiss key is required!' });
@@ -99,15 +99,15 @@ describe('Tests for admin api', ()=>{
it('should delete a notification based on its dismiss key', async ()=>{ it('should delete a notification based on its dismiss key', async ()=>{
const dismissKey = 'testKey'; const dismissKey = 'testKey';
jest.spyOn(NotificationModel, 'findOneAndDelete') jest.spyOn(NotificationModel, 'findOneAndDelete').mockImplementationOnce((key)=>{
.mockImplementationOnce((key)=>{ return { exec: jest.fn().mockResolvedValue(key) };
return { exec: jest.fn().mockResolvedValue(key) }; });
});
const response = await app
.delete(`/admin/notification/delete/${dismissKey}`)
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(NotificationModel.findOneAndDelete).toHaveBeenCalledWith({ 'dismissKey': 'testKey' }); const response = await request
.delete(`/admin/notification/delete/${dismissKey}`)
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(NotificationModel.findOneAndDelete).toHaveBeenCalledWith({ dismissKey: 'testKey' });
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ dismissKey: 'testKey' }); expect(response.body).toEqual({ dismissKey: 'testKey' });
}); });
@@ -115,15 +115,15 @@ describe('Tests for admin api', ()=>{
it('should handle error deleting a notification that doesnt exist', async ()=>{ it('should handle error deleting a notification that doesnt exist', async ()=>{
const dismissKey = 'testKey'; const dismissKey = 'testKey';
jest.spyOn(NotificationModel, 'findOneAndDelete') jest.spyOn(NotificationModel, 'findOneAndDelete').mockImplementationOnce(()=>{
.mockImplementationOnce(()=>{ return { exec: jest.fn().mockResolvedValue() };
return { exec: jest.fn().mockResolvedValue() }; });
});
const response = await app
.delete(`/admin/notification/delete/${dismissKey}`)
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(NotificationModel.findOneAndDelete).toHaveBeenCalledWith({ 'dismissKey': 'testKey' }); const response = await request
.delete(`/admin/notification/delete/${dismissKey}`)
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(NotificationModel.findOneAndDelete).toHaveBeenCalledWith({ dismissKey: 'testKey' });
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ message: 'Notification not found' }); expect(response.body).toEqual({ message: 'Notification not found' });
}); });
@@ -132,30 +132,24 @@ describe('Tests for admin api', ()=>{
describe('Locks', ()=>{ describe('Locks', ()=>{
describe('Count', ()=>{ describe('Count', ()=>{
it('Count of all locked documents', async ()=>{ it('Count of all locked documents', async ()=>{
const testNumber = 16777216; // 8^8, because why not const testNumber = 16777216;
jest.spyOn(HomebrewModel, 'countDocuments') jest.spyOn(HomebrewModel, 'countDocuments').mockImplementationOnce(()=>Promise.resolve(testNumber));
.mockImplementationOnce(()=>{
return Promise.resolve(testNumber);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .get('/api/lock/count')
.get('/api/lock/count'); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ count: testNumber }); expect(response.body).toEqual({ count: testNumber });
}); });
it('Handle error while fetching count of locked documents', async ()=>{ it('Handle error while fetching count of locked documents', async ()=>{
jest.spyOn(HomebrewModel, 'countDocuments') jest.spyOn(HomebrewModel, 'countDocuments').mockImplementationOnce(()=>Promise.reject());
.mockImplementationOnce(()=>{
return Promise.reject();
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .get('/api/lock/count')
.get('/api/lock/count'); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -163,7 +157,7 @@ describe('Tests for admin api', ()=>{
message : 'Unable to get lock count', message : 'Unable to get lock count',
name : 'Lock Count Error', name : 'Lock Count Error',
originalUrl : '/api/lock/count', originalUrl : '/api/lock/count',
status : 500, status : 500
}); });
}); });
}); });
@@ -172,28 +166,22 @@ describe('Tests for admin api', ()=>{
it('Get list of all locked documents', async ()=>{ it('Get list of all locked documents', async ()=>{
const testLocks = ['a', 'b']; const testLocks = ['a', 'b'];
jest.spyOn(HomebrewModel, 'aggregate') jest.spyOn(HomebrewModel, 'aggregate').mockImplementationOnce(()=>Promise.resolve(testLocks));
.mockImplementationOnce(()=>{
return Promise.resolve(testLocks);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .get('/api/locks')
.get('/api/locks'); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ lockedDocuments: testLocks }); expect(response.body).toEqual({ lockedDocuments: testLocks });
}); });
it('Handle error while fetching list of all locked documents', async ()=>{ it('Handle error while fetching list of all locked documents', async ()=>{
jest.spyOn(HomebrewModel, 'aggregate') jest.spyOn(HomebrewModel, 'aggregate').mockImplementationOnce(()=>Promise.reject());
.mockImplementationOnce(()=>{
return Promise.reject();
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .get('/api/locks')
.get('/api/locks'); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -208,28 +196,22 @@ describe('Tests for admin api', ()=>{
it('Get list of all locked documents with pending review requests', async ()=>{ it('Get list of all locked documents with pending review requests', async ()=>{
const testLocks = ['a', 'b']; const testLocks = ['a', 'b'];
jest.spyOn(HomebrewModel, 'aggregate') jest.spyOn(HomebrewModel, 'aggregate').mockImplementationOnce(()=>Promise.resolve(testLocks));
.mockImplementationOnce(()=>{
return Promise.resolve(testLocks);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .get('/api/lock/reviews')
.get('/api/lock/reviews'); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ reviewDocuments: testLocks }); expect(response.body).toEqual({ reviewDocuments: testLocks });
}); });
it('Handle error while fetching list of all locked documents with pending review requests', async ()=>{ it('Handle error while fetching list of all locked documents with pending review requests', async ()=>{
jest.spyOn(HomebrewModel, 'aggregate') jest.spyOn(HomebrewModel, 'aggregate').mockImplementationOnce(()=>Promise.reject());
.mockImplementationOnce(()=>{
return Promise.reject();
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .get('/api/lock/reviews')
.get('/api/lock/reviews'); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -247,8 +229,8 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); } save : ()=>Promise.resolve()
}; };
const testLock = { const testLock = {
@@ -257,15 +239,12 @@ describe('Tests for admin api', ()=>{
shareMessage : 'share' shareMessage : 'share'
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .post(`/api/lock/${testBrew.shareId}`)
.post(`/api/lock/${testBrew.shareId}`) .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
.send(testLock); .send(testLock);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toMatchObject({ expect(response.body).toMatchObject({
@@ -289,24 +268,21 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); }, save : ()=>Promise.resolve(),
lock : { lock : {
code : 1, code : 1,
editMessage : 'oldEdit', editMessage : 'oldEdit',
shareMessage : 'oldShare', shareMessage : 'oldShare'
} }
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .post(`/api/lock/${testBrew.shareId}`)
.post(`/api/lock/${testBrew.shareId}`) .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
.send(testLock); .send(testLock);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toMatchObject({ expect(response.body).toMatchObject({
@@ -329,24 +305,21 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); }, save : ()=>Promise.resolve(),
lock : { lock : {
code : 1, code : 1,
editMessage : 'oldEdit', editMessage : 'oldEdit',
shareMessage : 'oldShare', shareMessage : 'oldShare'
} }
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .post(`/api/lock/${testBrew.shareId}`)
.post(`/api/lock/${testBrew.shareId}`) .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
.send(testLock); .send(testLock);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -364,8 +337,8 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.reject(); } save : ()=>Promise.reject()
}; };
const testLock = { const testLock = {
@@ -374,15 +347,12 @@ describe('Tests for admin api', ()=>{
shareMessage : 'share' shareMessage : 'share'
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .post(`/api/lock/${testBrew.shareId}`)
.post(`/api/lock/${testBrew.shareId}`) .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
.send(testLock); .send(testLock);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -408,19 +378,17 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); }, save : ()=>Promise.resolve(),
lock : testLock lock : testLock
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request.put(`/api/unlock/${testBrew.shareId}`).set(
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) 'Authorization',
.put(`/api/unlock/${testBrew.shareId}`); `Basic ${Buffer.from('admin:password3').toString('base64')}`
);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -433,18 +401,16 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); }, save : ()=>Promise.resolve()
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request.put(`/api/unlock/${testBrew.shareId}`).set(
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) 'Authorization',
.put(`/api/unlock/${testBrew.shareId}`); `Basic ${Buffer.from('admin:password3').toString('base64')}`
);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -453,7 +419,7 @@ describe('Tests for admin api', ()=>{
name : 'Not Locked', name : 'Not Locked',
originalUrl : `/api/unlock/${testBrew.shareId}`, originalUrl : `/api/unlock/${testBrew.shareId}`,
shareId : testBrew.shareId, shareId : testBrew.shareId,
status : 500, status : 500
}); });
}); });
@@ -468,19 +434,17 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.reject(); }, save : ()=>Promise.reject(),
lock : testLock lock : testLock
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request.put(`/api/unlock/${testBrew.shareId}`).set(
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) 'Authorization',
.put(`/api/unlock/${testBrew.shareId}`); `Basic ${Buffer.from('admin:password3').toString('base64')}`
);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -506,40 +470,28 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); }, save : ()=>Promise.resolve(),
lock : testLock lock : testLock
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request.put(`/api/lock/review/request/${testBrew.shareId}`);
.put(`/api/lock/review/request/${testBrew.shareId}`);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ expect(response.body).toEqual({
message : `Review requested on brew ID ${testBrew.shareId} - ${testBrew.title}`, message : `Review requested on brew ID ${testBrew.shareId} - ${testBrew.title}`,
name : 'Review Requested', name : 'Review Requested'
}); });
}); });
it('Error when cannot find a locked brew', async ()=>{ it('Error when cannot find a locked brew', async ()=>{
const testBrew = { const testBrew = { shareId: 'shareId' };
shareId : 'shareId'
};
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(false));
.mockImplementationOnce(()=>{
return Promise.resolve(false);
});
const response = await request.put(`/api/lock/review/request/${testBrew.shareId}`);
const response = await app
.put(`/api/lock/review/request/${testBrew.shareId}`)
.catch((err)=>{return err;});
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -551,43 +503,6 @@ describe('Tests for admin api', ()=>{
}); });
}); });
it('Error when review is already requested', async ()=>{
const testLock = {
applied : 'YES',
code : 999,
editMessage : 'edit',
shareMessage : 'share',
reviewRequested : 'YES'
};
const testBrew = {
shareId : 'shareId',
title : 'title',
markModified : ()=>{ return true; },
save : ()=>{ return Promise.resolve(); },
lock : testLock
};
jest.spyOn(HomebrewModel, 'findOne')
.mockImplementationOnce(()=>{
return Promise.resolve(false);
});
const response = await app
.put(`/api/lock/review/request/${testBrew.shareId}`)
.catch((err)=>{return err;});
expect(response.status).toBe(500);
expect(response.body).toEqual({
HBErrorCode : '70',
code : 500,
message : `Cannot find a locked brew with ID ${testBrew.shareId}`,
name : 'Brew Not Found',
originalUrl : `/api/lock/review/request/${testBrew.shareId}`
});
});
it('Handle error while adding review request to a locked brew', async ()=>{ it('Handle error while adding review request to a locked brew', async ()=>{
const testLock = { const testLock = {
applied : 'YES', applied : 'YES',
@@ -599,18 +514,14 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.reject(); }, save : ()=>Promise.reject(),
lock : testLock lock : testLock
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request.put(`/api/lock/review/request/${testBrew.shareId}`);
.put(`/api/lock/review/request/${testBrew.shareId}`);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -634,19 +545,16 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.resolve(); }, save : ()=>Promise.resolve(),
lock : testLock lock : testLock
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .put(`/api/lock/review/remove/${testBrew.shareId}`)
.put(`/api/lock/review/remove/${testBrew.shareId}`); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(200); expect(response.status).toBe(200);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -656,18 +564,13 @@ describe('Tests for admin api', ()=>{
}); });
it('Error when clearing review request from a brew with no review request', async ()=>{ it('Error when clearing review request from a brew with no review request', async ()=>{
const testBrew = { const testBrew = { shareId: 'shareId' };
shareId : 'shareId',
};
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(false));
.mockImplementationOnce(()=>{
return Promise.resolve(false);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .put(`/api/lock/review/remove/${testBrew.shareId}`)
.put(`/api/lock/review/remove/${testBrew.shareId}`); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({
@@ -690,19 +593,16 @@ describe('Tests for admin api', ()=>{
const testBrew = { const testBrew = {
shareId : 'shareId', shareId : 'shareId',
title : 'title', title : 'title',
markModified : ()=>{ return true; }, markModified : ()=>true,
save : ()=>{ return Promise.reject(); }, save : ()=>Promise.reject(),
lock : testLock lock : testLock
}; };
jest.spyOn(HomebrewModel, 'findOne') jest.spyOn(HomebrewModel, 'findOne').mockImplementationOnce(()=>Promise.resolve(testBrew));
.mockImplementationOnce(()=>{
return Promise.resolve(testBrew);
});
const response = await app const response = await request
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`) .put(`/api/lock/review/remove/${testBrew.shareId}`)
.put(`/api/lock/review/remove/${testBrew.shareId}`); .set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
expect(response.status).toBe(500); expect(response.status).toBe(500);
expect(response.body).toEqual({ expect(response.body).toEqual({