write more tests for addNewMember

src/helpers/memberHelper.js

@@ -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") {
+    // Throws error if exists
-        return enums.help.PROXY;
+    await mh.checkIfProxyExists(authorId, proxy).catch((e) => { throw e; });
-    }
+
-    const proxyExists = await mh.checkIfProxyExists(authorId, proxy).then((proxyExists) => {
+    return await mh.updateMemberField(authorId, memberName, "proxy", proxy).catch((e) => { throw e;});
-        return proxyExists;
-    }).catch((e) => {
-        throw e
-    });
-    if (!proxyExists) {
-        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") {
+    // Throws error if invalid
-        return enums.help.PROPIC;
+    await utils.checkImageFormatValidity(attachmentUrl ?? imgUrl).catch((e) => { throw e });
-    }
-    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
-        });
-    }
-}
 
-/**
+    return await mh.updateMemberField(authorId, memberName, "propic", attachmentUrl ?? imgUrl, attachmentExpiry).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}`);
-    });
 }
 
 /**
@@ -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) {
+    if (displayName) {
-        const trimmedName = displayName ? displayName.trim() : null;
+        const trimmedDisplayName= displayName ? displayName.trim() : null;
-        if (trimmedName && trimmedName.length > 32) {
+        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}`)

tests/helpers/memberHelper.test.js

@@ -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('calls addFullMember with correct arguments', async() => {
-        test('returns help if --help passed in', async () => {
             // Arrange
-            const args = ['new', '--help'];
+            const args = ['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic];
-            const expected = enums.help.NEW;
+            jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(mockMember);
-            //Act
+            jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue();
-            return memberHelper.addNewMember(authorId, args).then((result) => {
+            // Act
-                // Assert
+            return memberHelper.addNewMember(authorId, args).then(() => {
-                expect(result).toEqual(expected);
+                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 args = ['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic];
-            const memberObject = {name: args[1]}
+            const fullMemberResponse = {member: mockMember, errors: []}
-            jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(memberObject);
+            const expected = {embed: mockMember, errors: [],  success: `${mockMember.name} has been added successfully.`};
-            jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue(memberObject);
+            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 () => {
+        test('call updateMemberField with correct arguments when displayname passed in correctly and returns string', async () => {
-            // Arrange
+            // 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'];
             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) => {
+            return memberHelper.updateDisplayName(authorId, mockMember.name, mockMember.displayname).catch((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) => {
                 // Assert
                 expect(result).toEqual(new Error(`Display name ${enums.err.NO_VALUE}`));
                 expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
@@ -339,46 +294,64 @@ describe('MemberHelper', () => {
 
         test('Sends error when display name is too long', async () => {
             // Arrange
-            const displayname = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+            const tooLongDisplayName = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-            const args = ['somePerson', 'displayname', 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, 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 = "                  ";
+            jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
-            const args = ['somePerson', 'displayname', 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, "      Some Person ").then((result) => {
                 // Assert
-                expect(result).toEqual(new Error(`Display name ${enums.err.NO_VALUE}`));
+                expect(result).toEqual("Updated");
-                expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
+                expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, mockMember.name, "displayname", mockMember.displayname);
+                expect(memberHelper.updateMemberField).toHaveBeenCalledTimes(1);
+            })
         })
     })
 
-        test('call updateMemberField with correct arguments when displayname passed in correctly', async () => {
+    describe('updateProxy', () => {
+        test('calls checkIfProxyExists and updateMemberField and returns string', async() => {
             // Arrange
-            const args = ['somePerson', 'displayname', "Some Person"];
+            jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue();
-            const member = {};
+            jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
-            jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue(member);
             // Act
-            return memberHelper.updateDisplayName(authorId, args).then((result) => {
+            return memberHelper.updateProxy(authorId, mockMember.name, "--text").then((result) => {
-                // Assert
+                expect(result).toEqual("Updated");
-                expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, args);
+                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', () => {
@@ -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(utils.checkImageFormatValidity).toHaveBeenCalledWith(mockMember.propic);
-                expect(memberHelper.checkImageFormatValidity).toHaveBeenCalledTimes(1);
+                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(() => {
+            utils.checkImageFormatValidity = jest.fn().mockImplementation(() => {throw new Error("error")})
-                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,
+                displayname: mockMember.displayname,
-                proxy: proxy,
+                proxy: mockMember.proxy,
-                propic: propic
+                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, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic).then((res) => {
-            return await memberHelper.addFullMember(authorId, memberName, displayName, proxy, propic).then((res) => {
                 // Assert
                 expect(res).toEqual(expectedReturn);
                 expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);