Claudia/PluralFlux-infra
1
1
Fork 0
forked from PluralFlux/PluralFlux
Code Pull Requests Actions Packages Releases Activity

write more tests for addNewMember

Browse Source
This commit is contained in:
Aster Fialla
2026-02-21 23:05:01 -05:00
parent a797e9e06d
commit cc8cb6e925
2 changed files with 156 additions and 206 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
src/helpers/memberHelper.js
View File

@@ -2,6 +2,7 @@ import {database} from '../database.js';
import {enums} from "../enums.js";
import {EmptyResultError, Op} from "sequelize";
import {EmbedBuilder} from "@fluxerjs/core";
import {utils} from "./utils";
const mh = {};
@@ -68,7 +69,7 @@ mh.parseMemberCommand = async function (authorId, authorFull, args, attachmentUr
if (!args[2] && !attachmentUrl) return member.propic ?? `Profile picture ${enums.err.NO_VALUE}`;
return await mh.updatePropic(authorId, args[0], args[2], attachmentUrl, attachmentExpiration).catch((e) => {throw e});
default:
return await mh.getMemberInfo(authorId, member);
return await mh.getMemberInfo(member);
}
}
@@ -107,9 +108,6 @@ mh.addNewMember = async function (authorId, args, attachmentURL = null) {
* @throws {RangeError} When the name doesn't exist.
*/
mh.updateName = async function (authorId, memberName, name) {
if (name === "--help") {
return enums.help.NAME;
}
const trimmedName = name.trim();
if (trimmedName === '') {
throw new RangeError(`Name ${enums.err.NO_VALUE}`);
@@ -130,9 +128,6 @@ mh.updateName = async function (authorId, memberName, name) {
* @throws {RangeError} When the display name is too long or doesn't exist.
*/
mh.updateDisplayName = async function (authorId, membername, displayname) {
if (displayname === "--help") {
return enums.help.DISPLAY_NAME;
}
const trimmedName = displayname.trim();
if (trimmedName.length > 32) {
@@ -157,19 +152,10 @@ mh.updateDisplayName = async function (authorId, membername, displayname) {
* @throws {RangeError | Error} When an empty proxy was provided, or no proxy exists.
*/
mh.updateProxy = async function (authorId, memberName, proxy) {
if (proxy === "--help") {
return enums.help.PROXY;
}
const proxyExists = await mh.checkIfProxyExists(authorId, proxy).then((proxyExists) => {
return proxyExists;
}).catch((e) => {
throw e
});
if (!proxyExists) {
return await mh.updateMemberField(authorId, memberName, "proxy", proxy).catch((e) => {
throw e
});
}
// Throws error if exists
await mh.checkIfProxyExists(authorId, proxy).catch((e) => { throw e; });
return await mh.updateMemberField(authorId, memberName, "proxy", proxy).catch((e) => { throw e;});
}
/**
@@ -185,35 +171,10 @@ mh.updateProxy = async function (authorId, memberName, proxy) {
* @throws {Error} When loading the profile picture from a URL doesn't work.
*/
mh.updatePropic = async function (authorId, memberName, imgUrl = null, attachmentUrl = null, attachmentExpiry = null) {
if (imgUrl === "--help") {
return enums.help.PROPIC;
}
const isValidImage = await mh.checkImageFormatValidity(attachmentUrl ?? imgUrl).catch((e) => {
throw e
});
if (isValidImage) {
return await mh.updateMemberField(authorId, memberName, "propic", attachmentUrl ?? imgUrl, attachmentExpiry).catch((e) => {
throw e
});
}
}
// Throws error if invalid
await utils.checkImageFormatValidity(attachmentUrl ?? imgUrl).catch((e) => { throw e });
/**
* Checks if an uploaded picture is in the right format.
*
* @async
* @param {string} imageUrl - The url of the image
* @returns {Promise<boolean>} - If the image is a valid format.
* @throws {Error} When loading the profile picture from a URL doesn't work, or it fails requirements.
*/
mh.checkImageFormatValidity = async function (imageUrl) {
const acceptableImages = ['image/png', 'image/jpg', 'image/jpeg', 'image/webp'];
return await fetch(imageUrl).then(r => r.blob()).then(blobFile => {
if (blobFile.size > 1000000 || !acceptableImages.includes(blobFile.type)) throw new Error(enums.err.PROPIC_FAILS_REQUIREMENTS);
return true;
}).catch((error) => {
throw new Error(`${enums.err.PROPIC_CANNOT_LOAD}: ${error.message}`);
});
return await mh.updateMemberField(authorId, memberName, "propic", attachmentUrl ?? imgUrl, attachmentExpiry).catch((e) => { throw e });
}
/**
@@ -261,10 +222,19 @@ mh.addFullMember = async function (authorId, memberName, displayName = null, pro
});
const errors = [];
const trimmedName = memberName.trim();
if (trimmedName.length === 0) {
throw new Error(`Name ${enums.err.NO_VALUE}. ${enums.err.NAME_REQUIRED}`);
}
let isValidDisplayName;
if (displayName && displayName.length > 0) {
const trimmedName = displayName ? displayName.trim() : null;
if (trimmedName && trimmedName.length > 32) {
if (displayName) {
const trimmedDisplayName= displayName ? displayName.trim() : null;
if (!trimmedDisplayName || trimmedDisplayName.length === 0) {
errors.push(`Display name ${enums.err.NO_VALUE}. ${enums.err.SET_TO_NULL}`);
isValidDisplayName = false;
}
else if (trimmedDisplayName.length > 32) {
errors.push(`Tried to set displayname to \"${displayName}\". ${enums.err.DISPLAY_NAME_TOO_LONG}. ${enums.err.SET_TO_NULL}`);
isValidDisplayName = false;
}
@@ -273,6 +243,7 @@ mh.addFullMember = async function (authorId, memberName, displayName = null, pro
}
}
let isValidProxy;
if (proxy && proxy.length > 0) {
await mh.checkIfProxyExists(authorId, proxy).then(() => {
@@ -285,7 +256,7 @@ mh.addFullMember = async function (authorId, memberName, displayName = null, pro
let isValidPropic;
if (propic && propic.length > 0) {
await mh.checkImageFormatValidity(propic).then(() => {
await utils.checkImageFormatValidity(propic).then(() => {
isValidPropic = true;
}).catch((e) => {
errors.push(`Tried to set profile picture to \"${propic}\". ${e.message}. ${enums.err.SET_TO_NULL}`);
@@ -350,11 +321,10 @@ mh.setExpirationWarning = function (expirationString) {
* Gets the details for a member.
*
* @async
* @param {string} authorId - The author of the message
* @param {model} member - The member object
* @returns {Promise<EmbedBuilder>} The member's info.
*/
mh.getMemberInfo = async function (authorId, member) {
mh.getMemberInfo = async function (member) {
return new EmbedBuilder()
.setTitle(member.name)
.setDescription(`Details for ${member.name}`)

284
tests/helpers/memberHelper.test.js
View File

@@ -2,6 +2,7 @@ const {EmbedBuilder} = require("@fluxerjs/core");
const {database} = require('../../src/database.js');
const {enums} = require('../../src/enums.js');
const {memberHelper} = require("../../src/helpers/memberHelper.js");
const {utils} = require("../../src/helpers/utils.js");
jest.mock('@fluxerjs/core', () => jest.fn());
jest.mock('../../src/database.js', () => {
@@ -18,13 +19,22 @@ jest.mock('../../src/database.js', () => {
}
});
jest.mock("../../src/helpers/utils.js", () => {
return {
utils:
{
checkImageFormatValidity: jest.fn().mockResolvedValue(),
}
}
});
jest.mock('sequelize', () => jest.fn());
describe('MemberHelper', () => {
const authorId = "0001";
const authorFull = "author#0001";
const attachmentUrl = "../oya.png";
const attachmentExpiration = new Date('2026-01-01T00.00.00.0000Z')
const attachmentExpiry = new Date('2026-01-01T00.00.00.0000Z')
const mockMember = {
name: "somePerson",
displayname: "Some Person",
@@ -114,7 +124,7 @@ describe('MemberHelper', () => {
test.each([
[["somePerson", "propic", attachmentUrl], null, null],
[["somePerson", "propic", null], 'ono.png', attachmentExpiration],
[["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) => {
@@ -130,7 +140,7 @@ describe('MemberHelper', () => {
return memberHelper.parseMemberCommand(authorId, authorFull, ['somePerson']).then(() => {
// Assert
expect(memberHelper['getMemberInfo']).toHaveBeenCalledTimes(1);
expect(memberHelper['getMemberInfo']).toHaveBeenCalledWith(authorId, mockMember);
expect(memberHelper['getMemberInfo']).toHaveBeenCalledWith(mockMember);
})
})
@@ -184,30 +194,31 @@ describe('MemberHelper', () => {
})
describe('addNewMember', () => {
test('returns help if --help passed in', async () => {
test('calls addFullMember with correct arguments', async() => {
// Arrange
const args = ['new', '--help'];
const expected = enums.help.NEW;
//Act
return memberHelper.addNewMember(authorId, args).then((result) => {
// Assert
expect(result).toEqual(expected);
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', 'some person'];
const memberObject = {name: args[1]}
jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(memberObject);
jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue(memberObject);
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(memberObject);
expect(result).toEqual(expected);
expect(memberHelper.getMemberInfo).toHaveBeenCalledTimes(1);
expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(authorId, args[1]);
expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(authorId, mockMember);
})
})
@@ -244,93 +255,37 @@ describe('MemberHelper', () => {
describe('updateName', () => {
test('sends help message when --help parameter passed in', async () => {
// Arrange
const args = ['somePerson', 'name', '--help'];
// Act
return memberHelper.updateName(authorId, args).then((result) => {
// Assert
expect(result).toEqual(enums.help.NAME);
})
})
test('Sends string when no name', async () => {
// Arrange
const args = ['somePerson', 'name'];
const expected = `The name for ${args[0]} is ${args[0]}, but you probably knew that!`;
// Act
return memberHelper.updateName(authorId, args).then((result) => {
expect(result).toEqual(expected);
})
})
test('throws error when name is empty', async () => {
// Arrange
const args = ['somePerson', 'name', " "];
// Act
return memberHelper.updateName(authorId, args).catch((result) => {
// Assert
expect(result).toEqual(new RangeError("Name " + enums.err.NO_VALUE));
})
})
test('throws error when updateMemberField returns error', async () => {
// Arrange
const expected = 'update error';
const args = ['somePerson', "name", "someNewPerson"];
jest.spyOn(memberHelper, 'updateMemberField').mockImplementation(() => {
throw new Error(expected)
});
// Act
return memberHelper.updateName(authorId, args).catch((result) => {
// Assert
expect(result).toEqual(new Error(expected));
})
});
test('sends string when updateMemberField returns successfully', async () => {
// Arrange
const args = ['somePerson', 'name', 'someNewPerson'];
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, args).then((result) => {
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('Sends string of current displayname when it exists and no displayname passed in', async () => {
test('throws error when displayname is blank', async () => {
// Arrange
const args = ['somePerson', 'displayname'];
const displayname = "Some Person";
const member = {
displayname: displayname,
}
jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(member);
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue();
// Act
return memberHelper.updateDisplayName(authorId, args).then((result) => {
// Assert
expect(result).toEqual(`Display name for ${args[0]} is: "${member.displayname}".`);
expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
})
})
test('Sends error when no displayname passed in', async () => {
// Arrange
const args = ['somePerson', 'displayname'];
const member = {}
jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(member);
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue();
// Act
return memberHelper.updateDisplayName(authorId, args).catch((result) => {
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();
@@ -339,48 +294,66 @@ describe('MemberHelper', () => {
test('Sends error when display name is too long', async () => {
// Arrange
const displayname = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const args = ['somePerson', 'displayname', displayname];
const member = {};
jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(member);
const tooLongDisplayName = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue();
// Act
return memberHelper.updateDisplayName(authorId, args).catch((result) => {
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('Sends error when display name is blank', async () => {
test('call updateMemberField with correct arguments when displayname passed in correctly and returns string', async () => {
// Arrange
const displayname = " ";
const args = ['somePerson', 'displayname', displayname];
const member = {};
jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(member);
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue();
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
// Act
return memberHelper.updateDisplayName(authorId, args).catch((result) => {
return memberHelper.updateDisplayName(authorId, mockMember.name, " Some Person ").then((result) => {
// Assert
expect(result).toEqual(new Error(`Display name ${enums.err.NO_VALUE}`));
expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
})
})
test('call updateMemberField with correct arguments when displayname passed in correctly', async () => {
// Arrange
const args = ['somePerson', 'displayname', "Some Person"];
const member = {};
jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue(member);
// Act
return memberHelper.updateDisplayName(authorId, args).then((result) => {
// Assert
expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, args);
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', () => {
beforeEach(() => {
database.members.create = jest.fn().mockResolvedValue();
@@ -389,28 +362,39 @@ describe('MemberHelper', () => {
test('calls getMemberByName', async () => {
// Act
return await memberHelper.addFullMember(authorId, memberName).then(() => {
return await memberHelper.addFullMember(authorId, mockMember.name).then(() => {
// Assert
expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, memberName);
expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, mockMember.name);
expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
})
})
test('if getMemberByName returns member, throw error', async () => {
memberHelper.getMemberByName.mockResolvedValue({name: memberName});
memberHelper.getMemberByName.mockResolvedValue({name: mockMember.name});
// Act
return await memberHelper.addFullMember(authorId, memberName).catch((e) => {
return await memberHelper.addFullMember(authorId, mockMember.name).catch((e) => {
// Assert
expect(e).toEqual(new Error(`Can't add ${memberName}. ${enums.err.MEMBER_EXISTS}`))
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
const displayName = "Some person with a very very very long name that can't be processed";
memberHelper.getMemberByName.mockResolvedValue();
const tooLongDisplayName = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const expectedMemberArgs = {
name: memberName,
name: mockMember.name,
userid: authorId,
displayname: null,
proxy: null,
@@ -419,11 +403,11 @@ describe('MemberHelper', () => {
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
const expectedReturn = {
member: expectedMemberArgs,
errors: [`Tried to set displayname to \"${displayName}\". ${enums.err.DISPLAY_NAME_TOO_LONG}. ${enums.err.SET_TO_NULL}`]
errors: [`Tried to set displayname to \"${tooLongDisplayName}\". ${enums.err.DISPLAY_NAME_TOO_LONG}. ${enums.err.SET_TO_NULL}`]
}
// Act
return await memberHelper.addFullMember(authorId, memberName, displayName, null, null).then((res) => {
return await memberHelper.addFullMember(authorId, mockMember.name, tooLongDisplayName, null, null).then((res) => {
// Assert
expect(res).toEqual(expectedReturn);
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
@@ -435,20 +419,20 @@ describe('MemberHelper', () => {
// Arrange
jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue();
const expectedMemberArgs = {
name: memberName,
name: mockMember.name,
userid: authorId,
displayname: null,
proxy: proxy,
proxy: mockMember.proxy,
propic: null
}
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
const expectedReturn = {member: expectedMemberArgs, errors: []}
// Act
return await memberHelper.addFullMember(authorId, memberName, null, proxy).then((res) => {
return await memberHelper.addFullMember(authorId, mockMember.name, null, mockMember.proxy).then((res) => {
// Assert
expect(res).toEqual(expectedReturn);
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledWith(authorId, proxy);
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledWith(authorId, mockMember.proxy);
expect(memberHelper.checkIfProxyExists).toHaveBeenCalledTimes(1);
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
expect(database.members.create).toHaveBeenCalledTimes(1);
@@ -461,7 +445,7 @@ describe('MemberHelper', () => {
throw new Error('error')
});
const expectedMemberArgs = {
name: memberName,
name: mockMember.name,
userid: authorId,
displayname: null,
proxy: null,
@@ -470,11 +454,11 @@ describe('MemberHelper', () => {
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
const expectedReturn = {
member: expectedMemberArgs,
errors: [`Tried to set proxy to \"${proxy}\". error. ${enums.err.SET_TO_NULL}`]
errors: [`Tried to set proxy to \"${mockMember.proxy}\". error. ${enums.err.SET_TO_NULL}`]
}
// Act
return await memberHelper.addFullMember(authorId, memberName, null, proxy, null).then((res) => {
return await memberHelper.addFullMember(authorId, mockMember.name, null, mockMember.proxy, null).then((res) => {
// Assert
expect(res).toEqual(expectedReturn);
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
@@ -484,22 +468,21 @@ describe('MemberHelper', () => {
test('if propic, call checkImageFormatValidity', async () => {
// Arrange
jest.spyOn(memberHelper, 'checkImageFormatValidity').mockResolvedValue();
const expectedMemberArgs = {
name: memberName,
name: mockMember.name,
userid: authorId,
displayname: null,
proxy: null,
propic: propic
propic: mockMember.propic
}
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
const expectedReturn = {member: expectedMemberArgs, errors: []}
// Act
return await memberHelper.addFullMember(authorId, memberName, null, null, propic).then((res) => {
return await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic).then((res) => {
// Assert
expect(res).toEqual(expectedReturn);
expect(memberHelper.checkImageFormatValidity).toHaveBeenCalledWith(propic);
expect(memberHelper.checkImageFormatValidity).toHaveBeenCalledTimes(1);
expect(utils.checkImageFormatValidity).toHaveBeenCalledWith(mockMember.propic);
expect(utils.checkImageFormatValidity).toHaveBeenCalledTimes(1);
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
expect(database.members.create).toHaveBeenCalledTimes(1);
})
@@ -507,11 +490,9 @@ describe('MemberHelper', () => {
test('if checkImageFormatValidity throws error, call database.member.create with null value', async () => {
// Arrange
jest.spyOn(memberHelper, 'checkImageFormatValidity').mockImplementation(() => {
throw new Error('error')
});
utils.checkImageFormatValidity = jest.fn().mockImplementation(() => {throw new Error("error")})
const expectedMemberArgs = {
name: memberName,
name: mockMember.name,
userid: authorId,
displayname: null,
proxy: null,
@@ -520,10 +501,10 @@ describe('MemberHelper', () => {
database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
const expectedReturn = {
member: expectedMemberArgs,
errors: [`Tried to set profile picture to \"${propic}\". error. ${enums.err.SET_TO_NULL}`]
errors: [`Tried to set profile picture to \"${mockMember.propic}\". error. ${enums.err.SET_TO_NULL}`]
}
// Act
return await memberHelper.addFullMember(authorId, memberName, null, null, propic).then((res) => {
return await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic).then((res) => {
// Assert
expect(res).toEqual(expectedReturn);
expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
@@ -534,19 +515,18 @@ describe('MemberHelper', () => {
test('if all values are valid, call database.members.create', async () => {
// Arrange
jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue();
jest.spyOn(memberHelper, 'checkImageFormatValidity').mockResolvedValue();
const expectedMemberArgs = {
name: memberName,
name: mockMember.name,
userid: authorId,
displayname: displayName,
proxy: proxy,
propic: propic
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
// Act
return await memberHelper.addFullMember(authorId, memberName, displayName, proxy, propic).then((res) => {
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);