mirror of
https://github.com/naturalcrit/homebrewery.git
synced 2025-12-24 20:42:43 +00:00
706 lines
21 KiB
JavaScript
706 lines
21 KiB
JavaScript
/*eslint max-lines: ["warn", {"max": 1000, "skipBlankLines": true, "skipComments": true}]*/
|
|
import supertest from 'supertest';
|
|
import HBApp from './app.js';
|
|
import { model as NotificationModel } from './notifications.model.js';
|
|
import { model as HomebrewModel } from './homebrew.model.js';
|
|
|
|
|
|
// Mimic https responses to avoid being redirected all the time
|
|
const app = supertest.agent(HBApp).set('X-Forwarded-Proto', 'https');
|
|
|
|
describe('Tests for admin api', ()=>{
|
|
afterEach(()=>{
|
|
jest.resetAllMocks();
|
|
});
|
|
|
|
describe('Notifications', ()=>{
|
|
it('should return list of all notifications', async ()=>{
|
|
const testNotifications = ['a', 'b'];
|
|
|
|
jest.spyOn(NotificationModel, 'find')
|
|
.mockImplementationOnce(()=>{
|
|
return { exec: jest.fn().mockResolvedValue(testNotifications) };
|
|
});
|
|
|
|
const response = await app
|
|
.get('/admin/notification/all')
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`);
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual(testNotifications);
|
|
});
|
|
|
|
it('should add a new notification', async ()=>{
|
|
const inputNotification = {
|
|
title : 'Test Notification',
|
|
text : 'This is a test notification',
|
|
startAt : new Date().toISOString(),
|
|
stopAt : new Date().toISOString(),
|
|
dismissKey : 'testKey'
|
|
};
|
|
|
|
const savedNotification = {
|
|
...inputNotification,
|
|
_id : expect.any(String),
|
|
createdAt : expect.any(String),
|
|
startAt : inputNotification.startAt,
|
|
stopAt : inputNotification.stopAt,
|
|
};
|
|
|
|
jest.spyOn(NotificationModel.prototype, 'save')
|
|
.mockImplementationOnce(function() {
|
|
return Promise.resolve(this);
|
|
});
|
|
|
|
const response = await app
|
|
.post('/admin/notification/add')
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.send(inputNotification);
|
|
|
|
expect(response.status).toBe(201);
|
|
expect(response.body).toEqual(savedNotification);
|
|
});
|
|
|
|
it('should handle error adding a notification without dismissKey', async ()=>{
|
|
const inputNotification = {
|
|
title : 'Test Notification',
|
|
text : 'This is a test notification',
|
|
startAt : 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() {
|
|
return Promise.resolve(this);
|
|
});
|
|
|
|
const response = await app
|
|
.post('/admin/notification/add')
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.send(inputNotification);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({ message: 'Dismiss key is required!' });
|
|
});
|
|
|
|
it('should delete a notification based on its dismiss key', async ()=>{
|
|
const dismissKey = 'testKey';
|
|
|
|
jest.spyOn(NotificationModel, 'findOneAndDelete')
|
|
.mockImplementationOnce((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' });
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({ dismissKey: 'testKey' });
|
|
});
|
|
|
|
it('should handle error deleting a notification that doesnt exist', async ()=>{
|
|
const dismissKey = 'testKey';
|
|
|
|
jest.spyOn(NotificationModel, 'findOneAndDelete')
|
|
.mockImplementationOnce(()=>{
|
|
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' });
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({ message: 'Notification not found' });
|
|
});
|
|
});
|
|
|
|
describe('Locks', ()=>{
|
|
describe('Count', ()=>{
|
|
it('Count of all locked documents', async ()=>{
|
|
const testNumber = 16777216; // 8^8, because why not
|
|
|
|
jest.spyOn(HomebrewModel, 'countDocuments')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testNumber);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.get('/api/lock/count');
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({ count: testNumber });
|
|
});
|
|
|
|
it('Handle error while fetching count of locked documents', async ()=>{
|
|
jest.spyOn(HomebrewModel, 'countDocuments')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.reject();
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.get('/api/lock/count');
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '61',
|
|
message : 'Unable to get lock count',
|
|
name : 'Lock Count Error',
|
|
originalUrl : '/api/lock/count',
|
|
status : 500,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Lists', ()=>{
|
|
it('Get list of all locked documents', async ()=>{
|
|
const testLocks = ['a', 'b'];
|
|
|
|
jest.spyOn(HomebrewModel, 'aggregate')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testLocks);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.get('/api/locks');
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({ lockedDocuments: testLocks });
|
|
});
|
|
|
|
it('Handle error while fetching list of all locked documents', async ()=>{
|
|
jest.spyOn(HomebrewModel, 'aggregate')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.reject();
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.get('/api/locks');
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '68',
|
|
message : 'Unable to get locked brew collection',
|
|
name : 'Can Not Get Locked Brews',
|
|
originalUrl : '/api/locks',
|
|
status : 500
|
|
});
|
|
});
|
|
|
|
it('Get list of all locked documents with pending review requests', async ()=>{
|
|
const testLocks = ['a', 'b'];
|
|
|
|
jest.spyOn(HomebrewModel, 'aggregate')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testLocks);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.get('/api/lock/reviews');
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({ reviewDocuments: testLocks });
|
|
});
|
|
|
|
it('Handle error while fetching list of all locked documents with pending review requests', async ()=>{
|
|
jest.spyOn(HomebrewModel, 'aggregate')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.reject();
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.get('/api/lock/reviews');
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '68',
|
|
message : 'Unable to get review collection',
|
|
name : 'Can Not Get Reviews',
|
|
originalUrl : '/api/lock/reviews',
|
|
status : 500
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Lock', ()=>{
|
|
it('Lock a brew', async ()=>{
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.resolve(); }
|
|
};
|
|
|
|
const testLock = {
|
|
code : 999,
|
|
editMessage : 'edit',
|
|
shareMessage : 'share'
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.post(`/api/lock/${testBrew.shareId}`)
|
|
.send(testLock);
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toMatchObject({
|
|
applied : expect.any(String),
|
|
code : testLock.code,
|
|
editMessage : testLock.editMessage,
|
|
shareMessage : testLock.shareMessage,
|
|
name : 'LOCKED',
|
|
message : `Lock applied to brew ID ${testBrew.shareId} - ${testBrew.title}`
|
|
});
|
|
});
|
|
|
|
it('Overwrite lock on a locked brew', async ()=>{
|
|
const testLock = {
|
|
code : 999,
|
|
editMessage : 'newEdit',
|
|
shareMessage : 'newShare',
|
|
overwrite : true
|
|
};
|
|
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.resolve(); },
|
|
lock : {
|
|
code : 1,
|
|
editMessage : 'oldEdit',
|
|
shareMessage : 'oldShare',
|
|
}
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.post(`/api/lock/${testBrew.shareId}`)
|
|
.send(testLock);
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toMatchObject({
|
|
applied : expect.any(String),
|
|
code : testLock.code,
|
|
editMessage : testLock.editMessage,
|
|
shareMessage : testLock.shareMessage,
|
|
name : 'LOCKED',
|
|
message : `Lock applied to brew ID ${testBrew.shareId} - ${testBrew.title}`
|
|
});
|
|
});
|
|
|
|
it('Error when locking a locked brew', async ()=>{
|
|
const testLock = {
|
|
code : 999,
|
|
editMessage : 'newEdit',
|
|
shareMessage : 'newShare'
|
|
};
|
|
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.resolve(); },
|
|
lock : {
|
|
code : 1,
|
|
editMessage : 'oldEdit',
|
|
shareMessage : 'oldShare',
|
|
}
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.post(`/api/lock/${testBrew.shareId}`)
|
|
.send(testLock);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '64',
|
|
message : 'Lock already exists on brew',
|
|
name : 'Already Locked',
|
|
originalUrl : `/api/lock/${testBrew.shareId}`,
|
|
shareId : testBrew.shareId,
|
|
status : 500,
|
|
title : 'title'
|
|
});
|
|
});
|
|
|
|
it('Handle save error while locking a brew', async ()=>{
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.reject(); }
|
|
};
|
|
|
|
const testLock = {
|
|
code : 999,
|
|
editMessage : 'edit',
|
|
shareMessage : 'share'
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.post(`/api/lock/${testBrew.shareId}`)
|
|
.send(testLock);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '62',
|
|
message : 'Unable to set lock',
|
|
name : 'Lock Error',
|
|
originalUrl : `/api/lock/${testBrew.shareId}`,
|
|
shareId : testBrew.shareId,
|
|
status : 500
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Unlock', ()=>{
|
|
it('Unlock a brew', async ()=>{
|
|
const testLock = {
|
|
applied : 'YES',
|
|
code : 999,
|
|
editMessage : 'edit',
|
|
shareMessage : 'share'
|
|
};
|
|
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.resolve(); },
|
|
lock : testLock
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.put(`/api/unlock/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({
|
|
name : 'Unlocked',
|
|
message : `Lock removed from brew ID ${testBrew.shareId}`
|
|
});
|
|
});
|
|
|
|
it('Error when unlocking a brew with no lock', async ()=>{
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.resolve(); },
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.put(`/api/unlock/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '67',
|
|
message : 'Cannot unlock as brew is not locked',
|
|
name : 'Not Locked',
|
|
originalUrl : `/api/unlock/${testBrew.shareId}`,
|
|
shareId : testBrew.shareId,
|
|
status : 500,
|
|
});
|
|
});
|
|
|
|
it('Handle error while unlocking a brew', async ()=>{
|
|
const testLock = {
|
|
applied : 'YES',
|
|
code : 999,
|
|
editMessage : 'edit',
|
|
shareMessage : 'share'
|
|
};
|
|
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.reject(); },
|
|
lock : testLock
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.put(`/api/unlock/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '65',
|
|
message : 'Unable to clear lock',
|
|
name : 'Cannot Unlock',
|
|
originalUrl : `/api/unlock/${testBrew.shareId}`,
|
|
shareId : testBrew.shareId,
|
|
status : 500
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('Reviews', ()=>{
|
|
it('Add review request to a locked brew', async ()=>{
|
|
const testLock = {
|
|
applied : 'YES',
|
|
code : 999,
|
|
editMessage : 'edit',
|
|
shareMessage : 'share'
|
|
};
|
|
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.resolve(); },
|
|
lock : testLock
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.put(`/api/lock/review/request/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({
|
|
message : `Review requested on brew ID ${testBrew.shareId} - ${testBrew.title}`,
|
|
name : 'Review Requested',
|
|
});
|
|
});
|
|
|
|
it('Error when cannot find a locked brew', async ()=>{
|
|
const testBrew = {
|
|
shareId : 'shareId'
|
|
};
|
|
|
|
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({
|
|
message : `Cannot find a locked brew with ID ${testBrew.shareId}`,
|
|
name : 'Brew Not Found',
|
|
HBErrorCode : '70',
|
|
code : 500,
|
|
originalUrl : `/api/lock/review/request/${testBrew.shareId}`
|
|
});
|
|
});
|
|
|
|
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 ()=>{
|
|
const testLock = {
|
|
applied : 'YES',
|
|
code : 999,
|
|
editMessage : 'edit',
|
|
shareMessage : 'share'
|
|
};
|
|
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
title : 'title',
|
|
markModified : ()=>{ return true; },
|
|
save : ()=>{ return Promise.reject(); },
|
|
lock : testLock
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.put(`/api/lock/review/request/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '69',
|
|
code : 500,
|
|
message : `Unable to set request for review on brew ID ${testBrew.shareId}`,
|
|
name : 'Can Not Set Review Request',
|
|
originalUrl : `/api/lock/review/request/${testBrew.shareId}`
|
|
});
|
|
});
|
|
|
|
it('Clear review request from a locked brew', 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(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.put(`/api/lock/review/remove/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(200);
|
|
expect(response.body).toEqual({
|
|
message : `Review request removed for brew ID ${testBrew.shareId} - ${testBrew.title}`,
|
|
name : 'Review Request Cleared'
|
|
});
|
|
});
|
|
|
|
it('Error when clearing review request from a brew with no review request', async ()=>{
|
|
const testBrew = {
|
|
shareId : 'shareId',
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(false);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.put(`/api/lock/review/remove/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '73',
|
|
message : `Brew ID ${testBrew.shareId} does not have a review pending!`,
|
|
name : 'Can Not Clear Review Request',
|
|
originalUrl : `/api/lock/review/remove/${testBrew.shareId}`
|
|
});
|
|
});
|
|
|
|
it('Handle error while clearing review request from a locked brew', 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.reject(); },
|
|
lock : testLock
|
|
};
|
|
|
|
jest.spyOn(HomebrewModel, 'findOne')
|
|
.mockImplementationOnce(()=>{
|
|
return Promise.resolve(testBrew);
|
|
});
|
|
|
|
const response = await app
|
|
.set('Authorization', `Basic ${Buffer.from('admin:password3').toString('base64')}`)
|
|
.put(`/api/lock/review/remove/${testBrew.shareId}`);
|
|
|
|
expect(response.status).toBe(500);
|
|
expect(response.body).toEqual({
|
|
HBErrorCode : '72',
|
|
message : `Unable to remove request for review on brew ID ${testBrew.shareId}`,
|
|
name : 'Can Not Clear Review Request',
|
|
originalUrl : `/api/lock/review/remove/${testBrew.shareId}`
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|