forked from PluralFlux/PluralFlux
727 lines
36 KiB
JavaScript
727 lines
36 KiB
JavaScript
const {enums} = require('../../src/enums.js');
|
|
const {utils} = require("../../src/helpers/utils.js");
|
|
|
|
jest.mock('@fluxerjs/core', () => jest.fn());
|
|
jest.mock('../../src/database.js', () => {
|
|
return {
|
|
database: {
|
|
members: {
|
|
create: jest.fn().mockResolvedValue(),
|
|
update: jest.fn().mockResolvedValue(),
|
|
destroy: jest.fn().mockResolvedValue(),
|
|
findOne: jest.fn().mockResolvedValue(),
|
|
findAll: jest.fn().mockResolvedValue(),
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
jest.mock("../../src/helpers/utils.js", () => {
|
|
return {
|
|
utils:
|
|
{
|
|
checkImageFormatValidity: jest.fn().mockResolvedValue(),
|
|
}
|
|
}
|
|
});
|
|
|
|
const {Op} = require('sequelize');
|
|
|
|
const {memberHelper} = require("../../src/helpers/memberHelper.js");
|
|
const {database} = require("../../src/database");
|
|
|
|
describe('MemberHelper', () => {
|
|
const authorId = "0001";
|
|
const authorFull = "author#0001";
|
|
const attachmentUrl = "../oya.png";
|
|
const attachmentExpiry = new Date('2026-01-01T00.00.00.0000Z')
|
|
const mockMember = {
|
|
name: "somePerson",
|
|
displayname: "Some Person",
|
|
proxy: "--text",
|
|
propic: attachmentUrl
|
|
}
|
|
|
|
beforeEach(() => {
|
|
jest.resetModules();
|
|
jest.clearAllMocks();
|
|
})
|
|
|
|
describe('parseMemberCommand', () => {
|
|
|
|
beforeEach(() => {
|
|
// jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(mockMember);
|
|
// jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue("member info");
|
|
// jest.spyOn(memberHelper, 'addNewMember').mockResolvedValue("new member");
|
|
// jest.spyOn(memberHelper, 'removeMember').mockResolvedValue("remove member");
|
|
// jest.spyOn(memberHelper, 'getAllMembersInfo').mockResolvedValue("all member info");
|
|
// jest.spyOn(memberHelper, 'updateName').mockResolvedValue("update name");
|
|
// jest.spyOn(memberHelper, 'updateDisplayName').mockResolvedValue("update display name");
|
|
// jest.spyOn(memberHelper, 'updateProxy').mockResolvedValue("update proxy");
|
|
// jest.spyOn(memberHelper, 'updatePropic').mockResolvedValue("update propic");
|
|
jest.spyOn(memberHelper, 'getMemberCommandInfo').mockResolvedValue("member command info");
|
|
jest.spyOn(memberHelper, 'memberArgumentHandler').mockResolvedValue("handled argument");
|
|
jest.spyOn(memberHelper, 'memberCommandHandler').mockResolvedValue("called command");
|
|
jest.spyOn(memberHelper, 'sendCurrentValue').mockResolvedValue("current value");
|
|
jest.spyOn(memberHelper, 'sendHelpEnum').mockResolvedValue("help enum")
|
|
});
|
|
|
|
// test.each([
|
|
// [['new', 'somePerson'], attachmentUrl],
|
|
// [['new', 'somePerson'], null],
|
|
// ])('%s calls addNewMember and returns correct values', async(args, attachmentUrl) => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, args, attachmentUrl).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual("new member");
|
|
// expect(memberHelper.addNewMember).toHaveBeenCalledTimes(1);
|
|
// expect(memberHelper.addNewMember).toHaveBeenCalledWith(authorId, args, attachmentUrl);
|
|
// });
|
|
// })
|
|
//
|
|
// test('["remove", "somePerson"] calls removeMember with authorId and "somePerson" and returns expected result', async() => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, ["remove", "somePerson"]).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual("remove member");
|
|
// expect(memberHelper.removeMember).toHaveBeenCalledTimes(1);
|
|
// expect(memberHelper.removeMember).toHaveBeenCalledWith(authorId, "somePerson");
|
|
// });
|
|
// });
|
|
//
|
|
// test('["list"] calls getAllMembersInfo and returns expected result', async () => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, ["list"]).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual("all member info");
|
|
// expect(memberHelper.getAllMembersInfo).toHaveBeenCalledTimes(1);
|
|
// expect(memberHelper.getAllMembersInfo).toHaveBeenCalledWith(authorId, authorFull);
|
|
// });
|
|
// });
|
|
//
|
|
test.each([
|
|
[['--help']],
|
|
[['']],
|
|
[[]]
|
|
])('%s calls getMemberCommandInfo and returns expected result', async (args) => {
|
|
// Act
|
|
return memberHelper.parseMemberCommand(authorId, authorFull, args).then((result) => {
|
|
// Assert
|
|
expect(result).toEqual("member command info");
|
|
expect(memberHelper.getMemberCommandInfo).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.getMemberCommandInfo).toHaveBeenCalledWith();
|
|
});
|
|
});
|
|
|
|
test.each([
|
|
[[mockMember.name, '--help'], null, true],
|
|
[['new', '--help'], 'new', true],
|
|
[['remove', '--help'], 'remove', true],
|
|
[['name', '--help'], 'name', true],
|
|
[['list', '--help'], 'list', true],
|
|
[['displayname', '--help'], 'displayname', true],
|
|
[['proxy', '--help'], 'proxy', true],
|
|
[['propic', '--help'], 'propic', true],
|
|
[['new'], 'new', true],
|
|
[['remove'], 'remove', true],
|
|
[['name'], 'name', true],
|
|
[['list'], 'list', true],
|
|
[['displayname'], 'displayname', true],
|
|
[['proxy'], 'proxy', true],
|
|
[['propic'], 'propic', true],
|
|
[[mockMember.name, 'remove'], 'remove', false],
|
|
[[mockMember.name, 'remove', 'test'], 'remove', false],
|
|
[[mockMember.name, 'new'], 'new', false],
|
|
[[mockMember.name, 'new', 'test'], 'new', false],
|
|
[[mockMember.name, 'new', mockMember.displayname], 'new', false],
|
|
[[mockMember.name, 'new', mockMember.proxy], 'new', false],
|
|
[[mockMember.name, 'new', mockMember.propic], 'new', false],
|
|
[[mockMember.name, 'new', null, mockMember.propic], 'new', false],
|
|
[[mockMember.name, 'new', null, mockMember.propic, attachmentExpiry], 'new', false],
|
|
[[mockMember.name, 'name', mockMember.name], 'name', false],
|
|
[[mockMember.name, 'displayname', mockMember.displayname], 'displayname', false],
|
|
[[mockMember.name, 'proxy', mockMember.proxy], 'proxy', false],
|
|
[[mockMember.name, 'propic', mockMember.propic], 'propic', false],
|
|
[[mockMember.name, 'propic', null, mockMember.propic], 'propic', false],
|
|
[[mockMember.name, 'propic', null, mockMember.propic, attachmentExpiry], 'propic', false],
|
|
[['remove', mockMember.name], 'remove'],
|
|
[['remove', mockMember.name, 'test'], 'remove'],
|
|
[['new', mockMember.name], 'new'],
|
|
[['new', mockMember.name, mockMember.displayname], 'new'],
|
|
[['new', mockMember.name, mockMember.displayname, mockMember.proxy], 'new'],
|
|
[['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic], 'new'],
|
|
[['new', mockMember.name, null, mockMember.displayname, mockMember.proxy, mockMember.propic, attachmentExpiry], 'new'],
|
|
[['new', mockMember.name, null, mockMember.displayname, mockMember.proxy, mockMember.propic, attachmentExpiry], 'new'],
|
|
[['name', mockMember.name, mockMember.name], 'name'],
|
|
[['displayname', mockMember.name, mockMember.name, mockMember.displayname], 'displayname'],
|
|
[['proxy', mockMember.name, mockMember.name, mockMember.displayname, mockMember.proxy], 'proxy'],
|
|
[['propic', mockMember.name, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic], 'propic'],
|
|
[['propic', mockMember.name, null, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic, attachmentExpiry], 'propic'],
|
|
[['propic', mockMember.name, null, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic, attachmentExpiry], 'propic'],
|
|
])('%s calls memberCommandHandler with correct values', async (args, command, isHelp) => {
|
|
// Act
|
|
return memberHelper.parseMemberCommand(authorId, authorFull, args).then((result, command) => {
|
|
// Assert
|
|
expect(result).toEqual("handled argument");
|
|
expect(memberHelper.memberArgumentHandler).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.memberArgumentHandler).toHaveBeenCalledWith(authorId, authorFull, isHelp, command, mockMember.name, args.slice(2));
|
|
});
|
|
})
|
|
//
|
|
// test.each([
|
|
// [['somePerson', 'name', 'newPerson'], "updateName", "update name"],
|
|
// [['somePerson', 'displayname', 'Some Person'], "updateDisplayName", "update display name"],
|
|
// [['somePerson', 'proxy', '--text'], "updateProxy", "update proxy"],
|
|
// ])('%s calls %s returns expected result %s', async (args, method, expectedResult) => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, args).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual(expectedResult);
|
|
// expect(memberHelper[method]).toHaveBeenCalledTimes(1);
|
|
// expect(memberHelper[method]).toHaveBeenCalledWith(authorId, args[0], args[2]);
|
|
// });
|
|
// });
|
|
//
|
|
// test.each([
|
|
// [["somePerson", "propic", attachmentUrl], null, null],
|
|
// [["somePerson", "propic", null], 'ono.png', attachmentExpiry],
|
|
// ])('%s calls updatePropic and returns expected values', async (args, attachmentUrl, attachmentExpiration) => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, args, attachmentUrl, attachmentExpiration).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual("update propic");
|
|
// expect(memberHelper['updatePropic']).toHaveBeenCalledTimes(1);
|
|
// expect(memberHelper['updatePropic']).toHaveBeenCalledWith(authorId, args[0], args[2], attachmentUrl, attachmentExpiration)
|
|
// });
|
|
// })
|
|
//
|
|
// test('any non-command returns getMemberInfo', async() => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, ['somePerson']).then(() => {
|
|
// // Assert
|
|
// expect(memberHelper['getMemberInfo']).toHaveBeenCalledTimes(1);
|
|
// expect(memberHelper['getMemberInfo']).toHaveBeenCalledWith(mockMember);
|
|
// })
|
|
// })
|
|
//
|
|
// test.each([
|
|
// [['new'], "addNewMember", enums.help.NEW],
|
|
// [['new', '--help'], "addNewMember", enums.help.NEW],
|
|
// [['remove'], "removeMember", enums.help.REMOVE],
|
|
// [['remove', '--help'], "removeMember", enums.help.REMOVE],
|
|
// [['name'], "updateName", enums.help.NAME],
|
|
// [['name', '--help'], "updateName", enums.help.NAME],
|
|
// [['somePerson', 'name'], "updateName", mockMember.name],
|
|
// [['displayname'], "updateDisplayName", enums.help.DISPLAY_NAME],
|
|
// [['displayname', '--help'], "updateDisplayName", enums.help.DISPLAY_NAME],
|
|
// [['somePerson', 'displayname'], "updateDisplayName", mockMember.displayname],
|
|
// [['proxy'], "updateProxy", enums.help.PROXY],
|
|
// [['proxy', '--help'], "updateProxy", enums.help.PROXY],
|
|
// [['somePerson', 'proxy'], "updateProxy", mockMember.proxy],
|
|
// [['propic'], "updatePropic", enums.help.PROPIC],
|
|
// [['propic', '--help'], "updatePropic", enums.help.PROPIC],
|
|
// [['somePerson', 'propic'], "updatePropic", mockMember.propic],
|
|
// [['list', '--help'], "getAllMembersInfo", enums.help.LIST],
|
|
// ])('%s shall not call %s and returns correct string', async (args, method, expectedResult) => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, args).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual(expectedResult);
|
|
// expect(memberHelper[method]).not.toHaveBeenCalled();
|
|
// });
|
|
// });
|
|
//
|
|
// test.each([
|
|
// [['somePerson', 'displayname'], "updateDisplayName", "Display name"],
|
|
// [['somePerson', 'proxy'], "updateProxy", "Proxy"],
|
|
// [['somePerson', 'propic'], "updatePropic", "Profile picture"],
|
|
// ])('if value not set, %s shall not call %s and returns value error', async (args, method, expectedResult) => {
|
|
// // Arrange
|
|
// const mockEmptyMember = {
|
|
// name: "somePerson",
|
|
// displayname: null,
|
|
// proxy: null,
|
|
// propic: null,
|
|
// }
|
|
// jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(mockEmptyMember);
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, args).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual(`${expectedResult} ${enums.err.NO_VALUE}`);
|
|
// expect(memberHelper[method]).not.toHaveBeenCalled();
|
|
// });
|
|
// });
|
|
//
|
|
// test('["new", "someNewPerson"] shall call addNewMember and return correct results', async () => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, ['new', 'someNewPerson']).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual("new member");
|
|
// expect(memberHelper.getMemberByName).not.toHaveBeenCalled();
|
|
// });
|
|
// });
|
|
//
|
|
// test('["new", "--help"] shall return help enum', async () => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, ['new', '--help']).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual(enums.help.NEW);
|
|
// expect(memberHelper.addNewMember).not.toHaveBeenCalled();
|
|
// expect(memberHelper.getMemberByName).not.toHaveBeenCalled();
|
|
// });
|
|
// });
|
|
//
|
|
// test('["new"] shall return help enum', async () => {
|
|
// // Act
|
|
// return memberHelper.parseMemberCommand(authorId, authorFull, ['new']).then((result) => {
|
|
// // Assert
|
|
// expect(result).toEqual(enums.help.NEW);
|
|
// expect(memberHelper.addNewMember).not.toHaveBeenCalled();
|
|
// expect(memberHelper.getMemberByName).not.toHaveBeenCalled();
|
|
// });
|
|
// });
|
|
})
|
|
|
|
describe('addNewMember', () => {
|
|
test('calls addFullMember with correct arguments', async() => {
|
|
// Arrange
|
|
const args = ['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic];
|
|
jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(mockMember);
|
|
jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue();
|
|
// Act
|
|
return memberHelper.addNewMember(authorId, args).then(() => {
|
|
expect(memberHelper.addFullMember).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.addFullMember).toHaveBeenCalledWith(authorId, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic);
|
|
})
|
|
})
|
|
|
|
test('calls getMemberInfo when successful and returns result', async () => {
|
|
// Arrange
|
|
const args = ['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic];
|
|
const fullMemberResponse = {member: mockMember, errors: []}
|
|
const expected = {embed: mockMember, errors: [], success: `${mockMember.name} has been added successfully.`};
|
|
jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(fullMemberResponse);
|
|
jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue(mockMember);
|
|
//Act
|
|
return memberHelper.addNewMember(authorId, args).then((result) => {
|
|
// Assert
|
|
expect(result).toEqual(expected);
|
|
expect(memberHelper.getMemberInfo).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(mockMember);
|
|
})
|
|
})
|
|
|
|
test('throws expected error when getMemberInfo throws error', async () => {
|
|
// Arrange
|
|
const args = ['new', 'some person'];
|
|
const memberObject = {name: args[1]}
|
|
jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(memberObject);
|
|
jest.spyOn(memberHelper, 'getMemberInfo').mockImplementation(() => {
|
|
throw new Error('getMemberInfo error')
|
|
});
|
|
//Act
|
|
return memberHelper.addNewMember(authorId, args).catch((result) => {
|
|
// Assert
|
|
expect(result).toEqual(new Error('getMemberInfo error'));
|
|
})
|
|
})
|
|
|
|
test('throws expected error when addFullMember throws error', async () => {
|
|
// Arrange
|
|
const args = ['new', 'somePerson'];
|
|
const expected = 'add full member error';
|
|
jest.spyOn(memberHelper, 'addFullMember').mockImplementation(() => {
|
|
throw new Error(expected)
|
|
});
|
|
|
|
//Act
|
|
return memberHelper.addNewMember(authorId, args).catch((result) => {
|
|
// Assert
|
|
expect(result).toEqual(new Error(expected));
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('updateName', () => {
|
|
|
|
test('call updateMemberField with correct arguments when displayname passed in correctly and returns string', async () => {
|
|
// Arrange;
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
|
|
// Act
|
|
return memberHelper.updateName(authorId, mockMember.name, " somePerson ").then((result) => {
|
|
// Assert
|
|
expect(result).toEqual("Updated");
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, mockMember.name, "name", "somePerson");
|
|
})
|
|
})
|
|
|
|
test('throws error when name is blank', async () => {
|
|
// Arrange;
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
|
|
// Act
|
|
return memberHelper.updateName(authorId, mockMember.name, " ").catch((result) => {
|
|
// Assert
|
|
expect(result).toEqual(new RangeError("Name " + enums.err.NO_VALUE));
|
|
expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('updateDisplayName', () => {
|
|
|
|
test('throws error when displayname is blank', async () => {
|
|
// Arrange
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue();
|
|
// Act
|
|
return memberHelper.updateDisplayName(authorId, mockMember.name, mockMember.displayname).catch((result) => {
|
|
// Assert
|
|
expect(result).toEqual(new Error(`Display name ${enums.err.NO_VALUE}`));
|
|
expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
|
|
})
|
|
})
|
|
|
|
test('Sends error when display name is too long', async () => {
|
|
// Arrange
|
|
const tooLongDisplayName = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue();
|
|
// Act
|
|
return memberHelper.updateDisplayName(authorId, mockMember.name, tooLongDisplayName).catch((result) => {
|
|
// Assert
|
|
expect(result).toEqual(new RangeError(enums.err.DISPLAY_NAME_TOO_LONG));
|
|
expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
|
|
})
|
|
})
|
|
|
|
test('call updateMemberField with correct arguments when displayname passed in correctly and returns string', async () => {
|
|
// Arrange
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
|
|
// Act
|
|
return memberHelper.updateDisplayName(authorId, mockMember.name, " Some Person ").then((result) => {
|
|
// Assert
|
|
expect(result).toEqual("Updated");
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, mockMember.name, "displayname", mockMember.displayname);
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('updateProxy', () => {
|
|
test('calls checkIfProxyExists and updateMemberField and returns string', async() => {
|
|
// Arrange
|
|
jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue();
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
|
|
// Act
|
|
return memberHelper.updateProxy(authorId, mockMember.name, "--text").then((result) => {
|
|
expect(result).toEqual("Updated");
|
|
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledWith(authorId, mockMember.proxy);
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, mockMember.name, "proxy", mockMember.proxy);
|
|
});
|
|
})
|
|
})
|
|
|
|
describe('updatePropic', () => {
|
|
test.each([
|
|
[null, attachmentUrl, null, attachmentUrl],
|
|
[mockMember.propic, null, null, mockMember.propic],
|
|
[mockMember.propic, attachmentUrl, null, attachmentUrl],
|
|
[null, attachmentUrl, attachmentExpiry, attachmentUrl]
|
|
])('calls checkImageFormatValidity and updateMemberField and returns string', async(imgUrl, attachmentUrl, attachmentExpiry, expected) => {
|
|
// Arrange
|
|
|
|
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
|
|
// Act
|
|
return memberHelper.updatePropic(authorId, mockMember.name, imgUrl, attachmentUrl, attachmentExpiry).then((result) => {
|
|
expect(result).toEqual("Updated");
|
|
expect(utils.checkImageFormatValidity).toHaveBeenCalledTimes(1);
|
|
expect(utils.checkImageFormatValidity).toHaveBeenCalledWith(expected);
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, mockMember.name, "propic", expected, attachmentExpiry);
|
|
});
|
|
})
|
|
})
|
|
|
|
describe('addFullMember', () => {
|
|
const { database} = require('../../src/database.js');
|
|
beforeEach(() => {
|
|
jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue();
|
|
})
|
|
|
|
test('calls getMemberByName', async () => {
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name).then(() => {
|
|
// Assert
|
|
expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, mockMember.name);
|
|
expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
test('if getMemberByName returns member, throw error', async () => {
|
|
memberHelper.getMemberByName.mockResolvedValue({name: mockMember.name});
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name).catch((e) => {
|
|
// Assert
|
|
expect(e).toEqual(new Error(`Can't add ${mockMember.name}. ${enums.err.MEMBER_EXISTS}`))
|
|
expect(database.members.create).not.toHaveBeenCalled();
|
|
})
|
|
})
|
|
|
|
|
|
test('if name is not filled out, throw error', async () => {
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, " ").catch((e) => {
|
|
// Assert
|
|
expect(e).toEqual(new Error(`Name ${enums.err.NO_VALUE}. ${enums.err.NAME_REQUIRED}`))
|
|
expect(database.members.create).not.toHaveBeenCalled();
|
|
})
|
|
})
|
|
|
|
test('if displayname is over 32 characters, call database.member.create with null value', async () => {
|
|
// Arrange
|
|
memberHelper.getMemberByName.mockResolvedValue();
|
|
const tooLongDisplayName = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
|
|
const expectedMemberArgs = {
|
|
name: mockMember.name,
|
|
userid: authorId,
|
|
displayname: null,
|
|
proxy: null,
|
|
propic: null
|
|
}
|
|
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
|
|
const expectedReturn = {
|
|
member: expectedMemberArgs,
|
|
errors: [`Tried to set displayname to \"${tooLongDisplayName}\". ${enums.err.DISPLAY_NAME_TOO_LONG}. ${enums.err.SET_TO_NULL}`]
|
|
}
|
|
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name, tooLongDisplayName, null, null).then((res) => {
|
|
// Assert
|
|
expect(res).toEqual(expectedReturn);
|
|
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
|
|
expect(database.members.create).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
test('if proxy, call checkIfProxyExists', async () => {
|
|
// Arrange
|
|
jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue();
|
|
const expectedMemberArgs = {
|
|
name: mockMember.name,
|
|
userid: authorId,
|
|
displayname: null,
|
|
proxy: mockMember.proxy,
|
|
propic: null
|
|
}
|
|
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
|
|
const expectedReturn = {member: expectedMemberArgs, errors: []}
|
|
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name, null, mockMember.proxy).then((res) => {
|
|
// Assert
|
|
expect(res).toEqual(expectedReturn);
|
|
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledWith(authorId, mockMember.proxy);
|
|
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledTimes(1);
|
|
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
|
|
expect(database.members.create).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
test('if checkProxyExists throws error, call database.member.create with null value', async () => {
|
|
// Arrange
|
|
jest.spyOn(memberHelper, 'checkIfProxyExists').mockImplementation(() => {
|
|
throw new Error('error')
|
|
});
|
|
const expectedMemberArgs = {
|
|
name: mockMember.name,
|
|
userid: authorId,
|
|
displayname: null,
|
|
proxy: null,
|
|
propic: null
|
|
}
|
|
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
|
|
const expectedReturn = {
|
|
member: expectedMemberArgs,
|
|
errors: [`Tried to set proxy to \"${mockMember.proxy}\". error. ${enums.err.SET_TO_NULL}`]
|
|
}
|
|
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name, null, mockMember.proxy, null).then((res) => {
|
|
// Assert
|
|
expect(res).toEqual(expectedReturn);
|
|
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
|
|
expect(database.members.create).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
test('if propic, call checkImageFormatValidity', async () => {
|
|
// Arrange
|
|
const expectedMemberArgs = {
|
|
name: mockMember.name,
|
|
userid: authorId,
|
|
displayname: null,
|
|
proxy: null,
|
|
propic: mockMember.propic
|
|
}
|
|
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
|
|
const expectedReturn = {member: expectedMemberArgs, errors: []}
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic).then((res) => {
|
|
// Assert
|
|
expect(res).toEqual(expectedReturn);
|
|
expect(utils.checkImageFormatValidity).toHaveBeenCalledWith(mockMember.propic);
|
|
expect(utils.checkImageFormatValidity).toHaveBeenCalledTimes(1);
|
|
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
|
|
expect(database.members.create).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
test('if checkImageFormatValidity throws error, call database.member.create with null value', async () => {
|
|
// Arrange
|
|
utils.checkImageFormatValidity = jest.fn().mockImplementation(() => {throw new Error("error")})
|
|
const expectedMemberArgs = {
|
|
name: mockMember.name,
|
|
userid: authorId,
|
|
displayname: null,
|
|
proxy: null,
|
|
propic: null
|
|
}
|
|
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
|
|
const expectedReturn = {
|
|
member: expectedMemberArgs,
|
|
errors: [`Tried to set profile picture to \"${mockMember.propic}\". error. ${enums.err.SET_TO_NULL}`]
|
|
}
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic).then((res) => {
|
|
// Assert
|
|
expect(res).toEqual(expectedReturn);
|
|
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
|
|
expect(database.members.create).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
test('if all values are valid, call database.members.create', async () => {
|
|
// Arrange
|
|
jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue();
|
|
const expectedMemberArgs = {
|
|
name: mockMember.name,
|
|
userid: authorId,
|
|
displayname: mockMember.displayname,
|
|
proxy: mockMember.proxy,
|
|
propic: mockMember.propic
|
|
}
|
|
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
|
|
utils.checkImageFormatValidity = jest.fn().mockResolvedValue();
|
|
const expectedReturn = {member: expectedMemberArgs, errors: []}
|
|
// Act
|
|
return await memberHelper.addFullMember(authorId, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic).then((res) => {
|
|
// Assert
|
|
expect(res).toEqual(expectedReturn);
|
|
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
|
|
expect(database.members.create).toHaveBeenCalledTimes(1);
|
|
})
|
|
})
|
|
|
|
})
|
|
|
|
describe('updateMemberField', () => {
|
|
const {database} = require('../../src/database.js');
|
|
beforeEach(() => {
|
|
jest.spyOn(memberHelper, "setExpirationWarning").mockReturnValue(' warning');
|
|
database.members = {
|
|
update: jest.fn().mockResolvedValue([1])
|
|
};
|
|
})
|
|
|
|
test('calls setExpirationWarning if attachmentExpiration', async () => {
|
|
return memberHelper.updateMemberField(authorId, mockMember.name, "propic", mockMember.propic, attachmentExpiry).then((res) => {
|
|
expect(memberHelper.setExpirationWarning).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.setExpirationWarning).toHaveBeenCalledWith(mockMember.propic);
|
|
})
|
|
})
|
|
|
|
test.each([
|
|
['name', mockMember.name, null, `Updated name for ${mockMember.name} to ${mockMember.name}`],
|
|
['displayname', mockMember.displayname, null, `Updated name for ${mockMember.name} to ${mockMember.displayname}`],
|
|
['proxy', mockMember.proxy, null, `Updated name for ${mockMember.name} to ${mockMember.proxy}`],
|
|
['propic', mockMember.propic, null, `Updated name for ${mockMember.name} to ${mockMember.propic}`],
|
|
['propic', mockMember.propic, attachmentExpiry, `Updated name for ${mockMember.name} to ${mockMember.propic} warning}`]
|
|
])('calls database.members.update with correct column and value and return string', async (columnName, value, attachmentExpiration) => {
|
|
// Arrange
|
|
return memberHelper.updateMemberField(authorId, mockMember.name, columnName, value, attachmentExpiration).then((res) => {
|
|
// Act
|
|
expect(database.members.update).toHaveBeenCalledTimes(1);
|
|
expect(database.members.update).toHaveBeenCalledWith({[columnName]: value}, {
|
|
where: {
|
|
name: {[Op.iLike]: mockMember.name},
|
|
userid: authorId
|
|
}
|
|
})
|
|
})
|
|
})
|
|
|
|
test('if database.members.update returns 0 rows changed, throw error', () => {
|
|
// Arrange
|
|
database.members = {
|
|
update: jest.fn().mockResolvedValue([0])
|
|
};
|
|
// Act
|
|
return memberHelper.updateMemberField(authorId, mockMember.name, "displayname", mockMember.displayname).catch((res) => {
|
|
expect(res).toEqual(new Error(`Can't update ${mockMember.name}. ${enums.err.NO_MEMBER}.`))
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('checkIfProxyExists', () => {
|
|
|
|
beforeEach(() => {
|
|
jest.spyOn(memberHelper, "getMembersByAuthor").mockResolvedValue([mockMember]);
|
|
})
|
|
|
|
test.each([
|
|
['!text'],
|
|
['! text'],
|
|
['⭐text'],
|
|
['⭐ text'],
|
|
['⭐ text ⭐'],
|
|
['--text--'],
|
|
['!text ?'],
|
|
['SP: text'],
|
|
['text --SP'],
|
|
])('%s should call getMembersByAuthor and return false', async (proxy) => {
|
|
return memberHelper.checkIfProxyExists(authorId, proxy).then((res) => {
|
|
expect(res).toEqual(false)
|
|
expect(memberHelper.getMembersByAuthor).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.getMembersByAuthor).toHaveBeenCalledWith(authorId);
|
|
})
|
|
})
|
|
|
|
test.each([
|
|
['--', enums.err.NO_TEXT_FOR_PROXY, false],
|
|
[' ', enums.err.NO_TEXT_FOR_PROXY, false],
|
|
['text', enums.err.NO_PROXY_WRAPPER, false],
|
|
['--text', enums.err.PROXY_EXISTS, true]
|
|
])('%s returns correct error and calls getMembersByAuthor if appropriate', async (proxy, error, shouldCall) => {
|
|
return memberHelper.checkIfProxyExists(authorId, proxy).catch((res) => {
|
|
expect(res).toEqual(new Error(error))
|
|
if (shouldCall) {
|
|
expect(memberHelper.getMembersByAuthor).toHaveBeenCalledTimes(1);
|
|
expect(memberHelper.getMembersByAuthor).toHaveBeenCalledWith(authorId);
|
|
}
|
|
else {
|
|
expect(memberHelper.getMembersByAuthor).not.toHaveBeenCalled();
|
|
}
|
|
})
|
|
})
|
|
|
|
|
|
})
|
|
|
|
afterEach(() => {
|
|
// restore the spy created with spyOn
|
|
jest.restoreAllMocks();
|
|
});
|
|
})
|
|
|