adjusted importHelper to properly test throwing of aggregate error

changed getAllMembersInfo map to say index not name as it actually gets the index of a member and then the member object
adjusted tests to properly use mockRejectedValue for async rejections
2026-02-24 22:29:03 -05:00 · 2026-02-24 21:26:42 -05:00 · 2026-02-24 21:08:04 -05:00 · 2026-02-24 20:38:39 -05:00 · 2026-02-24 20:38:39 -05:00 · 2026-02-24 20:38:39 -05:00
18 changed files with 901 additions and 925 deletions
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,8 +23,7 @@
        "@fetch-mock/jest": "^0.2.20",
        "babel-jest": "^30.2.0",
        "fetch-mock": "^12.6.0",
-        "jest": "^30.2.0",
-        "jest-fetch-mock": "^3.0.3"
+        "jest": "^30.2.0"
      }
    },
    "node_modules/@babel/code-frame": {
@@ -3858,16 +3857,6 @@
      "integrity": "sha512-/f6gpQuxDaqXu+1kwQYSckUglPaOrHdbIlBAu0YuW8/Cdb45XwXYNUBXg3r/9Mo6n540Kn/smKcZWko5x99KrQ==",
      "license": "MIT"
    },
-    "node_modules/cross-fetch": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.2.0.tgz",
-      "integrity": "sha512-Q+xVJLoGOeIMXZmbUK4HYk+69cQH6LudR0Vu/pRm2YlU/hDV9CiS0gKUMaWY5f2NeUH9C1nV3bsTlCo0FsTV1Q==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "node-fetch": "^2.7.0"
-      }
-    },
    "node_modules/cross-spawn": {
      "version": "7.0.6",
      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -5024,17 +5013,6 @@
        "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0"
      }
    },
-    "node_modules/jest-fetch-mock": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/jest-fetch-mock/-/jest-fetch-mock-3.0.3.tgz",
-      "integrity": "sha512-Ux1nWprtLrdrH4XwE7O7InRY6psIi3GOsqNESJgMJ+M5cv4A8Lh7SN9d2V2kKRZ8ebAfcd1LNyZguAOb6JiDqw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cross-fetch": "^3.0.4",
-        "promise-polyfill": "^8.1.3"
-      }
-    },
    "node_modules/jest-haste-map": {
      "version": "30.2.0",
      "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.2.0.tgz",
@@ -5722,27 +5700,6 @@
        "node": ">= 0.4.0"
      }
    },
-    "node_modules/node-fetch": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
-      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "whatwg-url": "^5.0.0"
-      },
-      "engines": {
-        "node": "4.x || >=6.0.0"
-      },
-      "peerDependencies": {
-        "encoding": "^0.1.0"
-      },
-      "peerDependenciesMeta": {
-        "encoding": {
-          "optional": true
-        }
-      }
-    },
    "node_modules/node-int64": {
      "version": "0.4.0",
      "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
@@ -6390,13 +6347,6 @@
        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
      }
    },
-    "node_modules/promise-polyfill": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/promise-polyfill/-/promise-polyfill-8.3.0.tgz",
-      "integrity": "sha512-H5oELycFml5yto/atYqmjyigJoAo3+OXwolYiH7OfQuYlAqhxNvTfiNMbV9hsC6Yp83yE5r2KTVmtrG6R9i6Pg==",
-      "dev": true,
-      "license": "MIT"
-    },
    "node_modules/promptly": {
      "version": "2.2.0",
      "resolved": "https://registry.npmjs.org/promptly/-/promptly-2.2.0.tgz",
@@ -7247,13 +7197,6 @@
      "integrity": "sha512-OsLcGGbYF3rMjPUf8oKktyvCiUxSbqMMS39m33MAjLTC1DVIH6x3WSt63/M77ihI09+Sdfk1AXvfhCEeUmC7mg==",
      "license": "MIT"
    },
-    "node_modules/tr46": {
-      "version": "0.0.3",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
-      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
-      "dev": true,
-      "license": "MIT"
-    },
    "node_modules/tslib": {
      "version": "2.8.1",
      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -7491,24 +7434,6 @@
        "makeerror": "1.0.12"
      }
    },
-    "node_modules/webidl-conversions": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
-      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
-      "dev": true,
-      "license": "BSD-2-Clause"
-    },
-    "node_modules/whatwg-url": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
-      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "tr46": "~0.0.3",
-        "webidl-conversions": "^3.0.0"
-      }
-    },
    "node_modules/which": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
--- a/package.json
+++ b/package.json
@@ -24,8 +24,7 @@
    "@fetch-mock/jest": "^0.2.20",
    "babel-jest": "^30.2.0",
    "fetch-mock": "^12.6.0",
-    "jest": "^30.2.0",
-    "jest-fetch-mock": "^3.0.3"
+    "jest": "^30.2.0"
  },
  "scripts": {
    "test": "jest"
--- a/src/bot.js
+++ b/src/bot.js
@@ -8,7 +8,7 @@ import {utils} from "./helpers/utils.js";

 env.config({path: './.env'});

-export const token = process.env.FLUXER_BOT_TOKEN;
+const token = process.env.FLUXER_BOT_TOKEN;

 if (!token) {
    console.error("Missing FLUXER_BOT_TOKEN environment variable.");
@@ -30,17 +30,13 @@ client.on(Events.MessageCreate, async (message) => {
 **/
 export const handleMessageCreate = async function(message) {
    try {
+        // Ignore bots
+        if (message.author.bot) return;
        // Parse command and arguments
        const content = message.content.trim();
-        // Ignore bots and messages without content
-        if (message.author.bot || content.length === 0) return;
-
        // If message doesn't start with the bot prefix, it could still be a message with a proxy tag. If it's not, return.
        if (!content.startsWith(messageHelper.prefix)) {
-            await webhookHelper.sendMessageAsMember(client, message).catch((e) => {
-                throw e
-            });
-            return;
+            return await webhookHelper.sendMessageAsMember(client, message);
        }

        const commandName = content.slice(messageHelper.prefix.length).split(" ")[0];
@@ -57,9 +53,7 @@ export const handleMessageCreate = async function(message) {
        }

        if (command) {
-            await command.execute(message, args).catch(e => {
-                throw e
-            });
+            await command.execute(message, args);
        }
        else {
            await message.reply(enums.err.COMMAND_NOT_RECOGNIZED);
@@ -67,7 +61,6 @@ export const handleMessageCreate = async function(message) {
    }
    catch(error) {
        console.error(error);
-        // return await message.reply(error.message);
    }
 }

@@ -88,13 +81,19 @@ function printGuilds() {
 const debouncePrintGuilds  = utils.debounce(printGuilds, 2000);
 export const debounceLogin  = utils.debounce(client.login, 60000);

-(async () => {
+export const login = async function() {
    try {
-
        await client.login(token);
        // await db.check_connection();
    } catch (err) {
        console.error('Login failed:', err);
        process.exit(1);
    }
-})();
+}
+
+function main()
+{
+    login();
+}
+
+main();
--- a/src/commands.js
+++ b/src/commands.js
@@ -26,22 +26,28 @@ cmds.commandsMap.set('member', {
 * @param {string[]} args - The parsed arguments
 *
 **/
-cmds.memberCommand = async function(message, args) {
+cmds.memberCommand = async function (message, args) {
    const authorFull = `${message.author.username}#${message.author.discriminator}`
    const attachmentUrl = message.attachments.size > 0 ? message.attachments.first().url : null;
    const attachmentExpires = message.attachments.size > 0 ? message.attachments.first().expires_at : null;
-
-    const reply = await memberHelper.parseMemberCommand(message.author.id, authorFull, args, attachmentUrl, attachmentExpires).catch(async (e) =>{console.error(e); await message.reply(e.message);});
+    let reply;
+    try {
+        reply = await memberHelper.parseMemberCommand(message.author.id, authorFull, args, attachmentUrl, attachmentExpires)
+    } catch (e) {
+        return await message.reply(e.message);
+    }

    if (typeof reply === 'string') {
        await message.reply(reply);
-    }
-    else if (reply instanceof EmbedBuilder) {
+    } else if (reply instanceof EmbedBuilder) {
        await message.reply({embeds: [reply]})
-    }
-    else if (typeof reply === 'object') {
-        const errorsText = reply.errors.length > 0 ? reply.errors.join('\n- ') : null;
-        return await message.reply({content: `${reply.success} ${errorsText ? `\n\n${enums.err.ERRORS_OCCURRED}\n` + errorsText : ""}`, embeds: [reply.embed]})
+    } else if (typeof reply === 'object') {
+        // The little dash is so that the errors print out in bullet points in Fluxer
+        const errorsText = reply.errors.length > 0 ? '- ' + reply.errors.join('\n- ') : null;
+        return await message.reply({
+            content: `${reply.success} ${errorsText ? `\n\n${enums.err.ERRORS_OCCURRED}\n` + errorsText : ""}`,
+            embeds: [reply.embed]
+        })
    }

 }
@@ -60,10 +66,10 @@ cmds.commandsMap.set('help', {
            .setTitle('Commands')
            .setDescription(enums.help.PLURALFLUX)
            .addFields(...fields)
-            .setFooter({ text: `Prefix: ${messageHelper.prefix}` })
+            .setFooter({text: `Prefix: ${messageHelper.prefix}`})
            .setTimestamp();

-        await message.reply({ embeds: [embed] });
+        await message.reply({embeds: [embed]});
    },
 })

@@ -82,29 +88,35 @@ cmds.commandsMap.set('import', {
 * @param {string[]} args - The parsed arguments
 *
 **/
-cmds.importCommand = async function(message, args) {
+cmds.importCommand = async function (message, args) {
    const attachmentUrl = message.attachments.size > 0 ? message.attachments.first().url : null;
-    if ((message.content.includes('--help') || (args[0] === '' && args.length === 1)) && !attachmentUrl ) {
+    if ((message.content.includes('--help') || (args[0] === '' && args.length === 1)) && !attachmentUrl) {
        return await message.reply(enums.help.IMPORT);
    }
-    return await importHelper.pluralKitImport(message.author.id, attachmentUrl).then(async (successfullyAdded) => {
-        await message.reply(successfullyAdded);
-    }).catch(async (error) => {
+    let errorsText;
+    try {
+        const successfullyAdded = await importHelper.pluralKitImport(message.author.id, attachmentUrl)
+        return await message.reply(successfullyAdded);
+    } catch (error) {
        if (error instanceof AggregateError) {
            // errors.message can be a list of successfully added members, or say that none were successful.
-            let errorsText = `${error.message}.\n\n${enums.err.ERRORS_OCCURRED}\n${error.errors.join('\n')}`;
-
-            await message.reply(errorsText).catch(async () => {
-                const returnedBuffer = messageHelper.returnBufferFromText(errorsText);
-                await message.reply({content: returnedBuffer.text, files: [{ name: 'text.txt', data: returnedBuffer.file }]
-                })
-            });
+            errorsText = `${error.message}.\n\n${enums.err.ERRORS_OCCURRED}\n\n${error.errors.join('\n')}`;
        }
        // If just one error was returned.
        else {
-            return await message.reply(error.message);
+            console.error(error);
+            errorsText = error.message;
        }
-    })
+    }
+    if (errorsText.length > 2000) {
+        const returnedBuffer = messageHelper.returnBufferFromText(errorsText);
+        await message.reply({
+            content: returnedBuffer.text, files: [{name: 'text.txt', data: returnedBuffer.file}]
+        })
+    } else {
+        await message.reply(errorsText)
+    }
+
 }

 export const commands = cmds;
--- a/src/database.js
+++ b/src/database.js
@@ -6,7 +6,7 @@ env.config();
 const password = process.env.POSTGRES_PASSWORD;

 if (!password) {
-    console.error("Missing POSTGRES_PWD environment variable.");
+    console.error("Missing POSTGRES_PASSWORD environment variable.");
    process.exit(1);
 }

@@ -59,26 +59,28 @@ db.systems = sequelize.define('System', {
 /**
 * Checks Sequelize database connection.
 */
-db.check_connection = async function() {
-        await sequelize.authenticate().then(async () => {
-            console.log('Connection has been established successfully.');
-            await syncModels();
-        }).catch(err => {
-            console.error('Unable to connect to the database:', err);
-            process.exit(1);
-        });
+db.check_connection = async function () {
+    try {
+        await sequelize.authenticate();
+        console.log('Connection has been established successfully.');
+        await syncModels();
+    } catch (err) {
+        console.error('Unable to connect to the database:', err);
+        process.exit(1);
+    }
 }

 /**
 * Syncs Sequelize models.
 */
 async function syncModels() {
-    await sequelize.sync().then(() => {
+    try {
+        await sequelize.sync()
        console.log('Models synced successfully.');
-    }).catch((err) => {
+    } catch(err) {
        console.error('Syncing models did not work', err);
        process.exit(1);
-    });
+    }
 }

 export const database = db;
--- a/src/enums.js
+++ b/src/enums.js
@@ -22,7 +22,8 @@ helperEnums.err = {
    NO_MEMBERS_IMPORTED: 'No members were imported.',
    ERRORS_OCCURRED: "These errors occurred:",
    COMMAND_NOT_RECOGNIZED: "Command not recognized. Try typing `pf;help` for command list.",
-    SET_TO_NULL: "It has been set to null instead."
+    SET_TO_NULL: "It has been set to null instead.",
+    CANNOT_FETCH_RESOURCE: "Could not download the file at this time."
 }

 helperEnums.help = {
--- a/src/helpers/importHelper.js
+++ b/src/helpers/importHelper.js
@@ -9,35 +9,50 @@ const ih = {};
 * @async
 * @param {string} authorId - The author of the message
 * @param {string | null} [attachmentUrl] - The attached JSON url.
- * @returns {string} A successful addition of all members.
+ * @returns {Promise<string>} A successful addition of all members.
 * @throws {Error}  When the member exists, or creating a member doesn't work.
 */
 ih.pluralKitImport = async function (authorId, attachmentUrl= null) {
+    let fetchResult, pkData;
    if (!attachmentUrl) {
        throw new Error(enums.err.NOT_JSON_FILE);
    }
-    return fetch(attachmentUrl).then((res) => res.json()).then(async(pkData) => {
-            const pkMembers = pkData.members;
-            let errors = [];
-            const addedMembers = [];
-            for (let pkMember of pkMembers) {
-                const proxy = pkMember.proxy_tags[0] ? `${pkMember.proxy_tags[0].prefix ?? ''}text${pkMember.proxy_tags[0].suffix ?? ''}` : null;
-                await memberHelper.addFullMember(authorId, pkMember.name, pkMember.display_name, proxy, pkMember.avatar_url).then((memberObj) => {
-                    addedMembers.push(memberObj.member.name);
-                    if (memberObj.errors.length > 0) {
-                        errors.push(`\n**${pkMember.name}:** `)
-                        errors = errors.concat(memberObj.errors);
-                    }
-                }).catch(e => {
-                    errors.push(e.message);
-                });
+    try {
+         fetchResult = await fetch(attachmentUrl);
+    }
+    catch(e) {
+        throw new Error(enums.err.CANNOT_FETCH_RESOURCE, { cause: e });
+    }
+
+    try {
+        pkData = await fetchResult.json();
+    }
+    catch(e) {
+        throw new Error(enums.err.NOT_JSON_FILE, { cause: e })
+    }
+
+    const pkMembers = pkData.members;
+    let errors = [];
+    let addedMembers = [];
+    for (let pkMember of pkMembers) {
+        const proxy = pkMember.proxy_tags[0] ? `${pkMember.proxy_tags[0].prefix ?? ''}text${pkMember.proxy_tags[0].suffix ?? ''}` : null;
+        try {
+            const memberObj = await memberHelper.addFullMember(authorId, pkMember.name, pkMember.display_name, proxy, pkMember.avatar_url);
+            addedMembers.push(memberObj.member.name);
+            if (memberObj.errors.length > 0) {
+                errors.push(`\n**${pkMember.name}:** `);
+                errors = errors.concat(memberObj.errors);
            }
-            const aggregatedText = addedMembers.length > 0 ? `Successfully added members: ${addedMembers.join(', ')}` : `${enums.err.NO_MEMBERS_IMPORTED}`;
-            if (errors.length > 0) {
-                throw new AggregateError(errors, aggregatedText);
-            }
-            return aggregatedText;
-        });
+        }
+        catch(e) {
+            errors.push(e.message);
+        }
+    }
+    const aggregatedText = addedMembers.length > 0 ? `Successfully added members: ${addedMembers.join(', ')}` : `${enums.err.NO_MEMBERS_IMPORTED}`;
+    if (errors.length > 0) {
+        throw new AggregateError(errors, aggregatedText);
+    }
+    return aggregatedText;
 }

 export const importHelper = ih;
--- a/src/helpers/memberHelper.js
+++ b/src/helpers/memberHelper.js
@@ -22,7 +22,6 @@ const newAndRemoveCommands = ['new', 'remove'];
 * @returns {Promise <EmbedBuilder>} A list of 25 members as an embed.
 * @returns {Promise <EmbedBuilder>} A list of member commands and descriptions.
 * @returns {Promise<{EmbedBuilder, string[], string}>} A member info embed + info/errors.
- * @throws {Error}
 */
 mh.parseMemberCommand = async function (authorId, authorFull, args, attachmentUrl = null, attachmentExpiration = null) {
    let memberName, command, isHelp = false;
@@ -72,7 +71,7 @@ mh.parseMemberCommand = async function (authorId, authorFull, args, attachmentUr
 * @returns {Promise <EmbedBuilder>} A list of 25 members as an embed.
 * @returns {Promise <EmbedBuilder>} A list of member commands and descriptions.
 * @returns {Promise<{EmbedBuilder, [string], string}>} A member info embed + info/errors.
- * @throws {Error}
+ * @throws {Error} When there's no member or a command is not recognized.
 */
 mh.memberArgumentHandler = async function(authorId, authorFull, isHelp, command = null, memberName = null, args = [], attachmentUrl = null, attachmentExpiration = null) {
    if (!command && !memberName && !isHelp) {
@@ -93,10 +92,10 @@ mh.memberArgumentHandler = async function(authorId, authorFull, isHelp, command

    // ex: pf;member blah blah
    if (command && memberName && (values.length > 0 || newAndRemoveCommands.includes(command) || attachmentUrl)) {
-        return await mh.memberCommandHandler(authorId, command, memberName, values, attachmentUrl, attachmentExpiration).catch((e) => {throw e});
+        return await mh.memberCommandHandler(authorId, command, memberName, values, attachmentUrl, attachmentExpiration);
    }
    else if (memberName && values.length === 0) {
-        return await mh.sendCurrentValue(authorId, memberName, command).catch((e) => {throw e});
+        return await mh.sendCurrentValue(authorId, memberName, command);
    }
 }

@@ -111,12 +110,11 @@ mh.memberArgumentHandler = async function(authorId, authorFull, isHelp, command
 * @returns {Promise <EmbedBuilder>} A list of 25 members as an embed.
 * @returns {Promise <EmbedBuilder>} A list of member commands and descriptions.
 * @returns {Promise<{EmbedBuilder, string[], string}>} A member info embed + info/errors.
+ * @throws {Error} When there's no member
 */
 mh.sendCurrentValue = async function(authorId, memberName, command= null) {
-    const member = await mh.getMemberByName(authorId, memberName).then((m) => {
-        if (!m) throw new Error(enums.err.NO_MEMBER);
-        return m;
-    });
+    const member = await mh.getMemberByName(authorId, memberName);
+    if (!member) throw new Error(enums.err.NO_MEMBER);

    if (!command) {
        return mh.getMemberInfo(member);
@@ -173,22 +171,23 @@ mh.sendHelpEnum = function(command) {
 * @returns {Promise <EmbedBuilder>} A list of 25 members as an embed.
 * @returns {Promise <EmbedBuilder>} A list of member commands and descriptions.
 * @returns {Promise<{EmbedBuilder, [string], string}>} A member info embed + info/errors.
- * @throws {Error}
 */
 mh.memberCommandHandler = async function(authorId, command, memberName, values, attachmentUrl = null, attachmentExpiration = null) {
    switch (command) {
        case 'new':
-            return await mh.addNewMember(authorId, memberName, values, attachmentUrl, attachmentExpiration).catch((e) => {throw e});
+            return await mh.addNewMember(authorId, memberName, values, attachmentUrl, attachmentExpiration);
        case 'remove':
-            return await mh.removeMember(authorId, memberName).catch((e) => {throw e});
+            return await mh.removeMember(authorId, memberName);
        case 'name':
-            return await mh.updateName(authorId, memberName, values[0]).catch((e) => {throw e});
+            return await mh.updateName(authorId, memberName, values[0]);
        case 'displayname':
-            return await mh.updateDisplayName(authorId, memberName, values[0]).catch((e) => {throw e});
+            return await mh.updateDisplayName(authorId, memberName, values[0]);
        case 'proxy':
-            return await mh.updateProxy(authorId, memberName, values[0]).catch((e) => {throw e});
+            return await mh.updateProxy(authorId, memberName, values[0]);
        case 'propic':
-            return await mh.updatePropic(authorId, memberName, values[0], attachmentUrl, attachmentExpiration).catch((e) => {throw e});
+            return await mh.updatePropic(authorId, memberName, values[0], attachmentUrl, attachmentExpiration);
+        default:
+            throw new Error(enums.err.COMMAND_NOT_RECOGNIZED);
    }
 }

@@ -202,20 +201,15 @@ mh.memberCommandHandler = async function(authorId, command, memberName, values,
 * @param {string | null} [attachmentUrl] - The attachment URL, if any
 * @param {string | null} [attachmentExpiration] - The attachment expiry date, if any
 * @returns {Promise<{EmbedBuilder, string[], string}>} A successful addition.
- * @throws {Error}  When creating a member doesn't work.
 */
 mh.addNewMember = async function (authorId, memberName, values, attachmentUrl = null, attachmentExpiration = null) {
    const displayName = values[0];
    const proxy = values[1];
    const propic = values[2] ?? attachmentUrl;

-    return await mh.addFullMember(authorId, memberName, displayName, proxy, propic, attachmentExpiration).then((response) => {
-        const memberInfoEmbed = mh.getMemberInfo(response.member);
-        return {embed: memberInfoEmbed, errors: response.errors, success: `${memberName} has been added successfully.`};
-    }).catch(e => {
-        console.error(e);
-        throw e;
-    })
+    const memberObj = await mh.addFullMember(authorId, memberName, displayName, proxy, propic, attachmentExpiration);
+    const memberInfoEmbed = mh.getMemberInfo(memberObj.member);
+    return {embed: memberInfoEmbed, errors: memberObj.errors, success: `${memberName} has been added successfully.`}
 }

 /**
@@ -233,9 +227,7 @@ mh.updateName = async function (authorId, memberName, name) {
    if (trimmedName === '') {
        throw new RangeError(`Name ${enums.err.NO_VALUE}`);
    }
-    return await mh.updateMemberField(authorId, memberName, "name", trimmedName).catch((e) => {
-        throw e
-    });
+    return await mh.updateMemberField(authorId, memberName, "name", trimmedName);
 }

 /**
@@ -257,9 +249,7 @@ mh.updateDisplayName = async function (authorId, membername, displayname) {
    else if (trimmedName === '') {
        throw new RangeError(`Display name ${enums.err.NO_VALUE}`);
    }
-    return await mh.updateMemberField(authorId, membername, "displayname", trimmedName).catch((e) => {
-        throw e
-    });
+    return await mh.updateMemberField(authorId, membername, "displayname", trimmedName);
 }

 /**
@@ -270,13 +260,12 @@ mh.updateDisplayName = async function (authorId, membername, displayname) {
 * @param {string} memberName - The member to update
 * @param {string} proxy - The proxy to set
 * @returns {Promise<string> } A successful update.
- * @throws {Error} When an empty proxy was provided, or a proxy exists.
 */
 mh.updateProxy = async function (authorId, memberName, proxy) {
    // Throws error if exists
-    await mh.checkIfProxyExists(authorId, proxy).catch((e) => { throw e; });
+    await mh.checkIfProxyExists(authorId, proxy);

-    return await mh.updateMemberField(authorId, memberName, "proxy", proxy).catch((e) => { throw e;});
+    return await mh.updateMemberField(authorId, memberName, "proxy", proxy);
 }

 /**
@@ -289,14 +278,13 @@ mh.updateProxy = async function (authorId, memberName, proxy) {
 * @param {string | null} attachmentUrl - The attachment URL, if any
 * @param {string | null} attachmentExpiration - The attachment expiry date, if any
 * @returns {Promise<string>} A successful update.
- * @throws {Error} When loading the profile picture from a URL doesn't work.
 */
 mh.updatePropic = async function (authorId, memberName, values, attachmentUrl = null, attachmentExpiration = null) {
    const imgUrl = values ?? attachmentUrl;
    // Throws error if invalid
-    await utils.checkImageFormatValidity(imgUrl).catch((e) => { throw e });
+    await utils.checkImageFormatValidity(imgUrl);

-    return await mh.updateMemberField(authorId, memberName, "propic", imgUrl, attachmentExpiration).catch((e) => { throw e });
+    return await mh.updateMemberField(authorId, memberName, "propic", imgUrl, attachmentExpiration);
 }

 /**
@@ -309,17 +297,17 @@ mh.updatePropic = async function (authorId, memberName, values, attachmentUrl =
 * @throws {Error} When there is no member to remove.
 */
 mh.removeMember = async function (authorId, memberName) {
-    return await database.members.destroy({
+    const destroyed = await database.members.destroy({
        where: {
            name: {[Op.iLike]: memberName},
            userid: authorId
        }
-    }).then((result) => {
-        if (result) {
-            return `Member "${memberName}" has been deleted.`;
-        }
-        throw new Error(`${enums.err.NO_MEMBER}`);
    })
+    if (destroyed > 0) {
+        return `Member "${memberName}" has been deleted.`;
+    } else {
+        throw new Error(`${enums.err.NO_MEMBER}`);
+    }
 }

 /*======Non-Subcommands======*/
@@ -338,11 +326,10 @@ mh.removeMember = async function (authorId, memberName) {
 * @throws {Error}  When the member already exists, there are validation errors, or adding a member doesn't work.
 */
 mh.addFullMember = async function (authorId, memberName, displayName = null, proxy = null, propic = null, attachmentExpiration = null) {
-    await mh.getMemberByName(authorId, memberName).then((member) => {
-        if (member) {
-            throw new Error(`Can't add ${memberName}. ${enums.err.MEMBER_EXISTS}`);
-        }
-    });
+    const existingMember = await mh.getMemberByName(authorId, memberName);
+    if (existingMember) {
+        throw new Error(`Can't add ${memberName}. ${enums.err.MEMBER_EXISTS}`);
+    }
    const errors = [];

    const trimmedName = memberName.trim();
@@ -366,25 +353,28 @@ mh.addFullMember = async function (authorId, memberName, displayName = null, pro
        }
    }

-
    let isValidProxy;
    if (proxy && proxy.length > 0) {
-        await mh.checkIfProxyExists(authorId, proxy).then(() => {
-            isValidProxy = true;
-        }).catch((e) => {
+        try {
+            const proxyExists = await mh.checkIfProxyExists(authorId, proxy);
+            isValidProxy = !proxyExists;
+        }
+        catch(e) {
            errors.push(`Tried to set proxy to \"${proxy}\". ${e.message}. ${enums.err.SET_TO_NULL}`);
            isValidProxy = false;
-        });
+        }
    }

    let isValidPropic;
    if (propic && propic.length > 0) {
-        await utils.checkImageFormatValidity(propic).then(() => {
-            isValidPropic = true;
-        }).catch((e) => {
+        try {
+            isValidPropic = await utils.checkImageFormatValidity(propic);
+
+        }
+        catch(e) {
            errors.push(`Tried to set profile picture to \"${propic}\". ${e.message}. ${enums.err.SET_TO_NULL}`);
            isValidPropic = false;
-        });
+        }
    }
    if (isValidPropic && attachmentExpiration) {
        errors.push(mh.setExpirationWarning(attachmentExpiration));
@@ -415,18 +405,17 @@ mh.updateMemberField = async function (authorId, memberName, columnName, value,
    if (columnName === "propic" && attachmentExpiration) {
        fluxerPropicWarning = mh.setExpirationWarning(value);
    }
-    return await database.members.update({[columnName]: value}, {
+    const res = await database.members.update({[columnName]: value}, {
        where: {
            name: {[Op.iLike]: memberName},
            userid: authorId
        }
-    }).then((res) => {
-            if (res[0] === 0) {
-                throw new Error(`Can't update ${memberName}. ${enums.err.NO_MEMBER}.`);
-            } else {
-                return `Updated ${columnName} for ${memberName} to ${value}${fluxerPropicWarning ?? ''}.`;
-            }
    })
+    if (res[0] === 0) {
+        throw new Error(`Can't update ${memberName}. ${enums.err.NO_MEMBER}.`);
+    } else {
+        return `Updated ${columnName} for ${memberName} to ${value}${fluxerPropicWarning ?? ''}.`;
+    }
 }

 /**
@@ -472,12 +461,12 @@ mh.getMemberInfo = function (member) {
 */
 mh.getAllMembersInfo = async function (authorId, authorName) {
    const members = await mh.getMembersByAuthor(authorId);
-    if (members == null) throw Error(enums.err.USER_NO_MEMBERS);
-    const fields = [...members.entries()].map(([name, member]) => ({
+    if (members.length === 0) throw Error(enums.err.USER_NO_MEMBERS);
+    const fields = [...members.entries()].map(([index, member]) => ({
        name: member.name, value: `(Proxy: \`${member.proxy ?? "unset"}\`)`, inline: true,
    }));
    return new EmbedBuilder()
-        .setTitle(`${fields > 25 ? "First 25 m" : "M"}embers for ${authorName}`)
+        .setTitle(`${fields.length > 25 ? "First 25 m" : "M"}embers for ${authorName}`)
        .addFields(...fields);
 }

@@ -517,14 +506,11 @@ mh.checkIfProxyExists = async function (authorId, proxy) {
    if (splitProxy.length < 2) throw new Error(enums.err.NO_TEXT_FOR_PROXY);
    if (!splitProxy[0] && !splitProxy[1]) throw new Error(enums.err.NO_PROXY_WRAPPER);

-    await mh.getMembersByAuthor(authorId).then((memberList) => {
-        const proxyExists = memberList.some(member => member.proxy === proxy);
-        if (proxyExists) {
-            throw new Error(enums.err.PROXY_EXISTS);
-        }
-    }).catch(e => {
-        throw e
-    });
+    const memberList = await mh.getMembersByAuthor(authorId);
+    const proxyExists = memberList.some(member => member.proxy === proxy);
+    if (proxyExists) {
+        throw new Error(enums.err.PROXY_EXISTS);
+    }
    return false;
 }

--- a/src/helpers/messageHelper.js
+++ b/src/helpers/messageHelper.js
@@ -36,8 +36,7 @@ msgh.parseCommandArgs = function(content, commandName) {
 * @param {string} authorId - The author of the message.
 * @param {string} content - The full message content
 * @param {string | null} [attachmentUrl] - The url for an attachment to the message, if any exists.
- * @returns {{model, string, bool}} The proxy message object.
- * @throws {Error} If a proxy message is sent with no message or attachment within it.
+ * @returns {Promise<{model, string, bool}>} The proxy message object.
 */
 msgh.parseProxyTags = async function (authorId, content, attachmentUrl = null){
    const members = await memberHelper.getMembersByAuthor(authorId);
--- a/src/helpers/utils.js
+++ b/src/helpers/utils.js
@@ -15,15 +15,23 @@ u.debounce = function(func, delay) {
 *
 * @async
 * @param {string} imageUrl - The url of the image
+ * @returns {bool} - Whether the image is in a valid format
 * @throws {Error} When loading the profile picture from a URL doesn't work, or it fails requirements.
 */
 u.checkImageFormatValidity = async function (imageUrl) {
    const acceptableImages = ['image/png', 'image/jpg', 'image/jpeg', 'image/webp'];
-    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);
-    }).catch((error) => {
-        throw new Error(`${enums.err.PROPIC_CANNOT_LOAD}: ${error.message}`);
-    });
+    let response, blobFile;
+    try {
+        response = await fetch(imageUrl);
+    }
+    catch(e) {
+        throw new Error(`${enums.err.PROPIC_CANNOT_LOAD}: ${e.message}`);
+    }
+
+    blobFile = await response.blob();
+    if (blobFile.size > 10000000 || !acceptableImages.includes(blobFile.type)) throw new Error(enums.err.PROPIC_FAILS_REQUIREMENTS);
+
+    return true;
 }

 export const utils = u;
--- a/src/helpers/webhookHelper.js
+++ b/src/helpers/webhookHelper.js
@@ -15,7 +15,7 @@ const name = 'PluralFlux Proxy Webhook';
 */
 wh.sendMessageAsMember = async function(client, message) {
    const attachmentUrl = message.attachments.size > 0 ? message.attachments.first().url : null;
-    const proxyMatch = await messageHelper.parseProxyTags(message.author.id, message.content, attachmentUrl).catch(e =>{throw e});
+    const proxyMatch = await messageHelper.parseProxyTags(message.author.id, message.content, attachmentUrl);
    // If the message doesn't match a proxy, just return.
    if (!proxyMatch || !proxyMatch.member || (proxyMatch.message.length === 0 && !proxyMatch.hasAttachment) ) {
        return;
@@ -27,7 +27,7 @@ wh.sendMessageAsMember = async function(client, message) {
    if (proxyMatch.hasAttachment) {
        return await message.reply(`${enums.misc.ATTACHMENT_SENT_BY} ${proxyMatch.member.displayname ?? proxyMatch.member.name}`)
    }
-    await wh.replaceMessage(client, message, proxyMatch.message, proxyMatch.member).catch(e =>{throw e});
+    await wh.replaceMessage(client, message, proxyMatch.message, proxyMatch.member);
 }

 /**
@@ -43,20 +43,19 @@ wh.replaceMessage = async function(client, message, text, member) {
    // attachment logic is not relevant yet, text length will always be over 0 right now
    if (text.length > 0 || message.attachments.size > 0) {
        const channel = client.channels.get(message.channelId);
-        const webhook = await wh.getOrCreateWebhook(client, channel).catch((e) =>{throw e});
+        const webhook = await wh.getOrCreateWebhook(client, channel);
        const username = member.displayname ?? member.name;
-        if (text.length > 0) {
-            await webhook.send({content: text, username: username, avatar_url: member.propic}).catch(async(e) => {
-                const returnedBuffer = messageHelper.returnBufferFromText(text);
-                await webhook.send({content: returnedBuffer.text, username: username, avatar_url: member.propic, files: [{ name: 'text.txt', data: returnedBuffer.file }]
-                })
-                console.error(e);
-            });
+        if (text.length <= 2000) {
+            await webhook.send({content: text, username: username, avatar_url: member.propic})
+        }
+        else if (text.length > 2000) {
+            const returnedBuffer = messageHelper.returnBufferFromText(text);
+            await webhook.send({content: returnedBuffer.text, username: username, avatar_url: member.propic, files: [{ name: 'text.txt', data: returnedBuffer.file }]
+            })
        }
        if (message.attachments.size > 0) {
            // Not implemented yet
        }
-
        await message.delete();
    }
 }
@@ -72,7 +71,7 @@ wh.replaceMessage = async function(client, message, text, member) {
 wh.getOrCreateWebhook = async function(client, channel) {
    // If channel doesn't allow webhooks
    if (!channel?.createWebhook) throw new Error(enums.err.NO_WEBHOOKS_ALLOWED);
-    let webhook = await wh.getWebhook(client, channel).catch((e) =>{throw e});
+    let webhook = await wh.getWebhook(client, channel)
    if (!webhook) {
        webhook = await channel.createWebhook({name: name});
    }
@@ -91,13 +90,7 @@ wh.getWebhook = async function(client, channel) {
    if (channelWebhooks.length === 0) {
        return;
    }
-    let pf_webhook;
-    channelWebhooks.forEach((webhook) => {
-        if (webhook.name === name) {
-            pf_webhook = webhook;
-        }
-    })
-    return pf_webhook;
+    return channelWebhooks.find((webhook) => webhook.name === name);
 }

 export const webhookHelper = wh;
--- a/tests/bot.test.js
+++ b/tests/bot.test.js
@@ -65,6 +65,7 @@ const {webhookHelper} = require("../src/helpers/webhookHelper.js");

 const {utils} = require("../src/helpers/utils.js");
 let {handleMessageCreate, client} = require("../src/bot.js");
+const {login} = require("../src/bot");

 describe('bot', () => {
    beforeEach(() => {
@@ -74,7 +75,7 @@ describe('bot', () => {

    describe('handleMessageCreate', () => {

-        test('on message creation, if message is from bot, return', () => {
+        test('on message creation, if message is from bot, return', async () => {
            // Arrange
            const message = {
                author: {
@@ -82,27 +83,11 @@ describe('bot', () => {
                }
            }
            // Act
-            return handleMessageCreate(message).then((res) => {
-                expect(res).toBe(undefined);
-            });
+            const res = await handleMessageCreate(message);
+            expect(res).toBeUndefined();
        })

-        test('on message creation, if message is empty, return', () => {
-            // Arrange
-            const message = {
-                content: "            ",
-                author: {
-                    bot: false
-                }
-            }
-            // Act
-            return handleMessageCreate(message).then((res) => {
-                // Assert
-                expect(res).toBe(undefined);
-            });
-        })
-
-        test("if message doesn't start with bot prefix, call sendMessageAsMember", () => {
+        test("if message doesn't start with bot prefix, call sendMessageAsMember", async () => {
            // Arrange
            webhookHelper.sendMessageAsMember.mockResolvedValue();
            const message = {
@@ -112,38 +97,32 @@ describe('bot', () => {
                }
            }
            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledTimes(1);
-                expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledWith(client, message)
-            });
+            const res = await handleMessageCreate(message);
+            // Assert
+            expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledTimes(1);
+            expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledWith(client, message)
        })

-        test("if sendMessageAsMember returns error, log error", () => {
+        test("if sendMessageAsMember returns error, catch and log error", async () => {
            // Arrange
-            webhookHelper.sendMessageAsMember.mockImplementation(() => {
-                throw Error("error")
-            });
+            webhookHelper.sendMessageAsMember.mockRejectedValue(new Error("error"));
            const message = {
                content: "hello",
                author: {
                    bot: false
                }
            }
-            jest.mock('console', () => {
-                return {error: jest.fn()}
-            })
+            jest.spyOn(global.console, 'error').mockImplementation(() => {});
            // Act
-            return handleMessageCreate(message).catch(() => {
-                // Assert
-                expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledTimes(1);
-                expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledWith(client, message)
-                expect(console.error).toHaveBeenCalledTimes(1);
-                expect(console.error).toHaveBeenCalledWith(new Error('error'))
-            });
+            await handleMessageCreate(message);
+            // Assert
+            expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledTimes(1);
+            expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledWith(client, message)
+            expect(console.error).toHaveBeenCalledTimes(1);
+            expect(console.error).toHaveBeenCalledWith(new Error('error'));
        })

-        test("if no command after prefix, return correct enum", () => {
+        test("if no command after prefix, return correct enum", async () => {
            // Arrange
            const message = {
                content: "pf;",
@@ -153,15 +132,14 @@ describe('bot', () => {
                reply: jest.fn()
            }
            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith(enums.help.SHORT_DESC_PLURALFLUX);
-                expect(webhookHelper.sendMessageAsMember).not.toHaveBeenCalled();
-            });
+            await handleMessageCreate(message);
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith(enums.help.SHORT_DESC_PLURALFLUX);
+            expect(webhookHelper.sendMessageAsMember).not.toHaveBeenCalled();
        })

-        test("if command after prefix, call parseCommandArgs and commandsMap.get", () => {
+        test("if command after prefix, call parseCommandArgs and commandsMap.get", async () => {
            // Arrange
            const message = {
                content: "pf;help",
@@ -175,17 +153,16 @@ describe('bot', () => {
            }
            commands.commandsMap.get = jest.fn().mockReturnValue(command);
            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(messageHelper.parseCommandArgs).toHaveBeenCalledTimes(1);
-                expect(messageHelper.parseCommandArgs).toHaveBeenCalledWith('pf;help', 'help');
-                expect(commands.commandsMap.get).toHaveBeenCalledTimes(1);
-                expect(commands.commandsMap.get).toHaveBeenCalledWith('help');
-                expect(webhookHelper.sendMessageAsMember).not.toHaveBeenCalled();
-            });
+            await handleMessageCreate(message);
+            // Assert
+            expect(messageHelper.parseCommandArgs).toHaveBeenCalledTimes(1);
+            expect(messageHelper.parseCommandArgs).toHaveBeenCalledWith('pf;help', 'help');
+            expect(commands.commandsMap.get).toHaveBeenCalledTimes(1);
+            expect(commands.commandsMap.get).toHaveBeenCalledWith('help');
+            expect(webhookHelper.sendMessageAsMember).not.toHaveBeenCalled();
        })

-        test('if commands.commandsMap.get returns undefined, call aliasesMap.get and commandsMap.get again with that value', () => {
+        test('if commands.commandsMap.get returns undefined, call aliasesMap.get and commandsMap.get again with that value', async () => {
            // Arrange
            const message = {
                content: "pf;m",
@@ -200,18 +177,17 @@ describe('bot', () => {
            commands.commandsMap.get = jest.fn().mockReturnValueOnce();
            commands.aliasesMap.get = jest.fn().mockReturnValueOnce(mockAlias);
            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(commands.commandsMap.get).toHaveBeenCalledTimes(2);
-                expect(commands.commandsMap.get).toHaveBeenNthCalledWith(1, 'm');
-                expect(commands.commandsMap.get).toHaveBeenNthCalledWith(2, 'member');
-                expect(commands.aliasesMap.get).toHaveBeenCalledTimes(1);
-                expect(commands.aliasesMap.get).toHaveBeenCalledWith('m');
-            });
+            await handleMessageCreate(message);
+            // Assert
+            expect(commands.commandsMap.get).toHaveBeenCalledTimes(2);
+            expect(commands.commandsMap.get).toHaveBeenNthCalledWith(1, 'm');
+            expect(commands.commandsMap.get).toHaveBeenNthCalledWith(2, 'member');
+            expect(commands.aliasesMap.get).toHaveBeenCalledTimes(1);
+            expect(commands.aliasesMap.get).toHaveBeenCalledWith('m');
        })


-        test('if aliasesMap.get returns undefined, do not call commandsMap again', () => {
+        test('if aliasesMap.get returns undefined, do not call commandsMap again', async () => {
            // Arrange
            const message = {
                content: "pf;m",
@@ -226,16 +202,13 @@ describe('bot', () => {
            commands.commandsMap.get = jest.fn().mockReturnValueOnce();
            commands.aliasesMap.get = jest.fn().mockReturnValueOnce();
            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(commands.commandsMap.get).toHaveBeenCalledTimes(1);
-                expect(commands.commandsMap.get).toHaveBeenNthCalledWith(1, 'm');
-                expect(commands.aliasesMap.get).toHaveBeenCalledTimes(1);
-                expect(commands.aliasesMap.get).toHaveBeenCalledWith('m');
-            });
+            await handleMessageCreate(message);
+            // Assert
+            expect(commands.aliasesMap.get).toHaveBeenCalledTimes(1);
+            expect(commands.aliasesMap.get).toHaveBeenCalledWith('m');
        })

-        test("if command exists, call command.execute", () => {
+        test("if command exists, call command.execute", async () => {
            // Arrange
            const message = {
                content: "pf;member test",
@@ -252,64 +225,60 @@ describe('bot', () => {
            command.execute = jest.fn().mockResolvedValue();

            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(command.execute).toHaveBeenCalledTimes(1);
-                expect(command.execute).toHaveBeenCalledWith(message, ['test']);
-                expect(webhookHelper.sendMessageAsMember).not.toHaveBeenCalled();
-            });
-        })
-
-        test("if command.execute returns error, log error", () => {
-            // Arrange
-            const command = {
-                execute: jest.fn()
-            }
-            commands.get = jest.fn().mockReturnValue(command);
-            command.execute.mockImplementation(() => {
-                throw Error("error")
-            });
-            const message = {
-                content: "pf;member test",
-                author: {
-                    bot: false
-                },
-                reply: jest.fn()
-            }
-            jest.mock('console', () => {
-                return {error: jest.fn()}
-            })
-            // Act
-            return handleMessageCreate(message).catch(() => {
-                // Assert
-                expect(console.error).toHaveBeenCalledTimes(1);
-                expect(console.error).toHaveBeenCalledWith(new Error('error'))
-            });
-        })
-
-        test("if command does not exist, return correct enum", () => {
-            // Arrange
-            commands.commandsMap.get = jest.fn().mockReturnValue();
-            commands.aliasesMap.get = jest.fn().mockReturnValue();
-            const message = {
-                content: "pf;asdfjlas",
-                author: {
-                    bot: false
-                },
-                reply: jest.fn()
-            }
-            // Act
-            return handleMessageCreate(message).then(() => {
-                // Assert
-                expect(message.reply).toHaveBeenCalledWith(enums.err.COMMAND_NOT_RECOGNIZED);
-                expect(message.reply).toHaveBeenCalledTimes(1);
-            });
-        })
+            await handleMessageCreate(message)
+            // Assert
+            expect(command.execute).toHaveBeenCalledTimes(1);
+            expect(command.execute).toHaveBeenCalledWith(message, ['test']);
+            expect(webhookHelper.sendMessageAsMember).not.toHaveBeenCalled();
+        });
    })

-    test('calls client.login with correct argument', () => {
+    test("if command.execute returns error, log error", async () => {
+        // Arrange
+        const command = {
+            execute: jest.fn()
+        }
+        commands.commandsMap.get = jest.fn().mockReturnValue(command);
+        command.execute.mockRejectedValue(new Error("error"));
+        const message = {
+            content: "pf;member test",
+            author: {
+                bot: false
+            },
+            reply: jest.fn()
+        }
+        jest.spyOn(global.console, 'error').mockImplementation(() => {
+        })
        // Act
+        await handleMessageCreate(message);
+        // Assert
+        expect(console.error).toHaveBeenCalledTimes(1);
+        expect(console.error).toHaveBeenCalledWith(new Error('error'))
+    })
+
+    test("if command does not exist, return correct enum", async () => {
+        // Arrange
+        commands.commandsMap.get = jest.fn().mockReturnValue();
+        commands.aliasesMap.get = jest.fn().mockReturnValue();
+        const message = {
+            content: "pf;asdfjlas",
+            author: {
+                bot: false
+            },
+            reply: jest.fn()
+        }
+        // Act
+        await handleMessageCreate(message);
+        // Assert
+        expect(message.reply).toHaveBeenCalledWith(enums.err.COMMAND_NOT_RECOGNIZED);
+        expect(message.reply).toHaveBeenCalledTimes(1);
+    })
+
+    test('login calls client.login with correct argument', async () => {
+        // Arrange
        client.login = jest.fn().mockResolvedValue();
+        // Act
+        await login();
        // Assert
        expect(client.login).toHaveBeenCalledTimes(1);
        expect(client.login).toHaveBeenCalledWith(process.env.FLUXER_BOT_TOKEN)
--- a/tests/commands.test.js
+++ b/tests/commands.test.js
@@ -24,11 +24,8 @@ jest.mock('../src/helpers/importHelper.js', () => {
        }
    }
 })
-jest.mock('console', () => {
-    return {error: jest.fn()}
-})

-import {messageHelper, prefix} from "../src/helpers/messageHelper.js";
+import {messageHelper} from "../src/helpers/messageHelper.js";

 import {memberHelper} from "../src/helpers/memberHelper.js";
 import {EmbedBuilder} from "@fluxerjs/core";
@@ -40,139 +37,169 @@ describe('commands', () => {
    const authorId = '123';
    const discriminator = '123';
    const username = 'somePerson'
-    const attachmentUrl = 'oya.png';
+    const attachmentUrl = 'oya.json';
    const attachmentExpiration = new Date('2026-01-01').toDateString();
-    const message = {
-        author: {
-            username: username,
-            id: authorId,
-            discriminator: discriminator,
-        },
-        attachments: {
-            size: 1,
-            first: jest.fn().mockImplementation(() => ({
-                expires_at: attachmentExpiration,
-                url: attachmentUrl
-            }))
-        },
-        reply: jest.fn().mockResolvedValue(),
-    }
+    let message;
    const args = ['new']

    beforeEach(() => {

        jest.resetModules();
        jest.clearAllMocks();
+        message = {
+            author: {
+                username: username,
+                id: authorId,
+                discriminator: discriminator,
+            },
+            attachments: {
+                size: 1,
+                first: jest.fn().mockImplementation(() => {
+                    return {
+                        url: attachmentUrl,
+                        expires_at: attachmentExpiration
+                    }
+                })
+            },
+            reply: jest.fn().mockResolvedValue(),
+            content: 'pf;import'
+        }
    })

    describe('memberCommand', () => {


-        test('calls parseMemberCommand with the correct arguments', () => {
+        test('calls parseMemberCommand with the correct arguments', async () => {
            // Arrange
            memberHelper.parseMemberCommand = jest.fn().mockResolvedValue("parsed command");
            // Act
-            return commands.memberCommand(message, args).then(() => {
-                expect(memberHelper.parseMemberCommand).toHaveBeenCalledTimes(1);
-                expect(memberHelper.parseMemberCommand).toHaveBeenCalledWith(authorId, `${username}#${discriminator}`, args, attachmentUrl, attachmentExpiration);
-            });
-        })
+            await commands.memberCommand(message, args)
+            // Assert
+            expect(memberHelper.parseMemberCommand).toHaveBeenCalledTimes(1);
+            expect(memberHelper.parseMemberCommand).toHaveBeenCalledWith(authorId, `${username}#${discriminator}`, args, attachmentUrl, attachmentExpiration);
+        });
+    })

-        test('if parseMemberCommand returns error, log error and reply with error', () => {
-            // Arrange
-            memberHelper.parseMemberCommand = jest.fn().mockImplementation(() => {throw new Error('error')});
-            // Act
-            return commands.memberCommand(message, args).catch(() => {
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith('error');
-                expect(console.error).toHaveBeenCalledWith(new Error('error'));
-            });
-        })
+    test('if parseMemberCommand returns error, log error and reply with error', async () => {
+        // Arrange
+        memberHelper.parseMemberCommand = jest.fn().mockRejectedValue(new Error('error'));
+        // Act
+        await commands.memberCommand(message, args)
+        // Assert
+        expect(message.reply).toHaveBeenCalledTimes(1);
+        expect(message.reply).toHaveBeenCalledWith('error');
+    });

-        test('if parseMemberCommand returns embed, reply with embed', () => {
-            // Arrange
-            const embed = new EmbedBuilder();
-            memberHelper.parseMemberCommand = jest.fn().mockResolvedValue();
-            // Act
-            return commands.memberCommand(message, args).catch(() => {
-                // Assert
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith({embeds: [embed]})
-            });
-        })
+    test('if parseMemberCommand returns embed, reply with embed', async () => {
+        // Arrange
+        const embed = new EmbedBuilder();
+        memberHelper.parseMemberCommand = jest.fn().mockResolvedValue(embed);
+        // Act
+        await commands.memberCommand(message, args);
+        expect(message.reply).toHaveBeenCalledTimes(1);
+        expect(message.reply).toHaveBeenCalledWith({embeds: [embed]})
+    })

-        test('if parseMemberCommand returns object, reply with embed and content', () => {
-            // Arrange
-            const reply = {
-                errors: ['error', 'error2'],
-                success: 'success',
-                embed: {}
-            }
-            memberHelper.parseMemberCommand = jest.fn().mockResolvedValue(reply);
-            // Act
-            return commands.memberCommand(message, args).catch(() => {
-                // Assert
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith({content: `success\n\n${enums.err.ERRORS_OCCURRED}\n\nerror\nerror2}`, embeds: [reply.embed]})
-            });
-        })
+    test('if parseMemberCommand returns object, reply with embed and content', async () => {
+        // Arrange
+        const reply = {
+            errors: ['error', 'error2'],
+            success: 'success',
+            embed: {title: 'hi'}
+        }
+        const expected = {
+            content: `success \n\n${enums.err.ERRORS_OCCURRED}\n- error\n- error2`,
+            embeds: [reply.embed]
+        }
+        console.log(expected)
+        memberHelper.parseMemberCommand = jest.fn().mockResolvedValue(reply);
+        // Act
+        await commands.memberCommand(message, args);
+        // Assert
+        expect(message.reply).toHaveBeenCalledTimes(1);
+        expect(message.reply).toHaveBeenCalledWith(expected)
    })

    describe('importCommand', () => {
-        test('if message includes --help and no attachmentURL, return help message', () => {
+        test('if message includes --help and no attachmentURL, return help message', async () => {
+            // Arrange
            const args = ["--help"];
            message.content = "pf;import --help";
            message.attachments.size = 0;
-            return commands.importCommand(message, args).then(() => {
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith(enums.help.IMPORT);
-                expect(importHelper.pluralKitImport).not.toHaveBeenCalled();
-            })
+            // Act
+            await commands.importCommand(message, args)
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith(enums.help.IMPORT);
+            expect(importHelper.pluralKitImport).not.toHaveBeenCalled();
        })

-        test('if no args and no attachmentURL, return help message', () => {
-            const args = [""];
-            message.content = 'pf;import'
-            message.attachments.size = 0;
-            return commands.importCommand(message, args).then(() => {
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith(enums.help.IMPORT);
-                expect(importHelper.pluralKitImport).not.toHaveBeenCalled();
-            })
-        })
-
-        test('if attachment URL, call pluralKitImport with correct arguments', () => {
-            const args = [""];
-            message.content = 'pf;import'
-            importHelper.pluralKitImport = jest.fn().mockResolvedValue('success');
-            return commands.importCommand(message, args).then(() => {
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith('success');
-                expect(importHelper.pluralKitImport).toHaveBeenCalledTimes(1);
-                expect(importHelper.pluralKitImport).toHaveBeenCalledWith(authorId, attachmentUrl);
-            })
-        })
-
-        test('if pluralKitImport returns aggregate errors, send errors.', () => {
-            const args = [""];
-            message.content = 'pf;import'
-            importHelper.pluralKitImport = jest.fn().mockImplementation(() => {throw new AggregateError(['error1', 'error2'], 'errors')});
-            return commands.importCommand(message, args).catch(() => {
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith(`errors. \n\n${enums.err.ERRORS_OCCURRED}\n\nerror1\nerror2`);
-            })
-        })
-
-        test('if message.reply throws error, call returnBufferFromText and message.reply again.', () => {
+        test('if no args and no attachmentURL, return help message', async () => {
            // Arrange
            const args = [""];
            message.content = 'pf;import'
-            message.reply = jest.fn().mockImplementationOnce(() => {throw e})
-            messageHelper.returnBufferFromText = jest.fn().mockResolvedValue({file: 'test.txt', text: 'normal content'});
-            return commands.importCommand(message, args).catch(() => {
-                expect(message.reply).toHaveBeenCalledTimes(2);
-                expect(message.reply).toHaveBeenNthCalledWith(1, {content: 'normal content', files: [{name: 'test.txt', data: 'test.txt' }],});
-            })
+            message.attachments.size = 0;
+            // Act
+            await commands.importCommand(message, args)
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith(enums.help.IMPORT);
+            expect(importHelper.pluralKitImport).not.toHaveBeenCalled();
+        })
+
+        test('if attachment URL, call pluralKitImport with correct arguments', async () => {
+            // Arrange
+            const args = [""];
+            message.content = 'pf;import';
+            importHelper.pluralKitImport = jest.fn().mockResolvedValue('success');
+            // Act
+            await commands.importCommand(message, args);
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith('success');
+            expect(importHelper.pluralKitImport).toHaveBeenCalledTimes(1);
+            expect(importHelper.pluralKitImport).toHaveBeenCalledWith(authorId, attachmentUrl);
+        })
+
+        test('if pluralKitImport returns aggregate errors with length <= 2000, send errors.', async () => {
+            // Arrange
+            const args = [""];
+            message.content = 'pf;import'
+            importHelper.pluralKitImport = jest.fn().mockRejectedValue(new AggregateError(['error1', 'error2'], 'errors'));
+            // Act
+            await commands.importCommand(message, args);
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith(`errors.\n\n${enums.err.ERRORS_OCCURRED}\n\nerror1\nerror2`);
+        })
+
+        test('if pluralKitImport returns aggregate errors with length > 2000, call returnBufferFromText and message.reply.', async () => {
+            // Arrange
+            const args = [""];
+            const text = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbb";
+            const file = Buffer.from(text, 'utf-8');
+            const returnedBuffer = {text: 'bbbb', file: file};
+            const expected = {content: returnedBuffer.text, files: [{name: 'text.txt', data: returnedBuffer.file}]};
+
+            importHelper.pluralKitImport = jest.fn().mockRejectedValue(new AggregateError([text, 'error2'], 'errors'));
+            messageHelper.returnBufferFromText = jest.fn().mockReturnValue(returnedBuffer);
+            // Act
+            await commands.importCommand(message, args);
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith(expected);
+        })
+
+        test('if pluralKitImport returns one error, reply with error and log it', async () => {
+            // Arrange
+            importHelper.pluralKitImport = jest.fn().mockRejectedValue(new Error('error'));
+            jest.spyOn(global.console, 'error').mockImplementation(() => {})
+            // Act
+            await commands.importCommand(message, args);
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith('error');
+            expect(console.error).toHaveBeenCalledTimes(1);
+            expect(console.error).toHaveBeenCalledWith(new Error('error'));
        })
    })

--- a/tests/helpers/importHelper.test.js
+++ b/tests/helpers/importHelper.test.js
@@ -1,5 +1,4 @@
 const {enums} = require('../../src/enums.js');
-const fetchMock = require('jest-fetch-mock');

 jest.mock('../../src/helpers/memberHelper.js', () => {
    return {
@@ -9,7 +8,6 @@ jest.mock('../../src/helpers/memberHelper.js', () => {
    }
 })

-fetchMock.enableMocks();
 const {memberHelper} = require("../../src/helpers/memberHelper.js");
 const {importHelper} = require('../../src/helpers/importHelper.js');

@@ -40,58 +38,63 @@ describe('importHelper', () => {
    }

    beforeEach(() => {
-        global.fetch = jest.fn();
+        jest.resetModules();
+        jest.clearAllMocks();
        global.fetch = jest.fn().mockResolvedValue({
            ok: true,
            json: () => Promise.resolve(mockData)
        })
-
    })

    describe('pluralKitImport', () => {

-        test('if no attachment URL, throws error', () => {
-            return importHelper.pluralKitImport(authorId).catch((e) => {
-                expect(e).toEqual(new Error(enums.err.NOT_JSON_FILE));
-            })
+        test('if no attachment URL, throws error', async () => {
+            await expect(importHelper.pluralKitImport(authorId)).rejects.toThrow(enums.err.NOT_JSON_FILE);
        })

-        test('if attachment URL, calls fetch and addFullMember and returns value', () => {
+        test('if attachment URL, calls fetch and addFullMember and returns value', async () => {
            memberHelper.addFullMember.mockResolvedValue(mockAddReturn);
-            return importHelper.pluralKitImport(authorId, attachmentUrl).then((res) => {
-                expect(fetch).toHaveBeenCalledTimes(1);
-                expect(fetch).toHaveBeenCalledWith(attachmentUrl);
-                expect(memberHelper.addFullMember).toHaveBeenCalledWith(authorId, mockImportedMember.name, mockImportedMember.display_name, 'SP{text}', mockImportedMember.avatar_url);
-                expect(res).toEqual(`Successfully added members: ${mockAddReturnMember.name}`)
-            })
+            const result = await importHelper.pluralKitImport(authorId, attachmentUrl);
+
+            expect(fetch).toHaveBeenCalledTimes(1);
+            expect(fetch).toHaveBeenCalledWith(attachmentUrl);
+            expect(memberHelper.addFullMember).toHaveBeenCalledWith(authorId, mockImportedMember.name, mockImportedMember.display_name, 'SP{text}', mockImportedMember.avatar_url);
+            expect(result).toEqual(`Successfully added members: ${mockAddReturnMember.name}`)
        })

-        test('if addFullMember returns nothing, return correct enum', () => {
+
+        test('if fetch fails, throws error', async () => {
+            global.fetch = jest.fn().mockRejectedValue("can't get");
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow(enums.err.CANNOT_FETCH_RESOURCE, "can't get file");
+        })
+
+        test('if json conversion fails, throws error', async () => {
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.reject("not json")
+            })
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toThrow(enums.err.NOT_JSON_FILE, "not json");
+        })
+
+        test('if addFullMember returns nothing, return correct enum', async () => {
            memberHelper.addFullMember.mockResolvedValue();
-            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
-                expect(res).toEqual(new AggregateError([], enums.err.NO_MEMBERS_IMPORTED));
-            })
+            const promise = importHelper.pluralKitImport(authorId, attachmentUrl);
+            await expect(promise).rejects.toBeInstanceOf(AggregateError);
+            await expect(promise).rejects.toMatchObject(AggregateError([], enums.err.NO_MEMBERS_IMPORTED));
        })

-        test('if addFullMember returns nothing and throws error, catch and return error', () => {
-            memberHelper.addFullMember.mockResolvedValue(new Error('error'));
-            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
-                expect(res).toEqual(new AggregateError([new Error('error')], enums.err.NO_MEMBERS_IMPORTED))
-            })
-        })
+        test('if addFullMember throws error, catch and return error', async () => {
+            memberHelper.addFullMember.mockRejectedValue(new Error('error'));
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toMatchObject(new AggregateError(['error'], enums.err.NO_MEMBERS_IMPORTED));
+        });

-        test('if addFullMember returns member but also contains error, return member and error', () => {
+        test('if addFullMember returns member but also contains error, return member and error', async () => {
            // Arrange
            const memberObj = {errors: ['error'], member: mockAddReturnMember};
            memberHelper.addFullMember.mockResolvedValue(memberObj);
-            // Act
-            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
-                // Assert
-                expect(res).toEqual(new AggregateError(['error'], `Successfully added members: ${mockAddReturnMember.name}`))
-            })
-        })
-
-    })
+            await expect(importHelper.pluralKitImport(authorId, attachmentUrl)).rejects.toMatchObject(new AggregateError(['error'], `Successfully added members: ${mockAddReturnMember.name}`));
+        });
+    });

    afterEach(() => {
        // restore the spy created with spyOn
--- a/tests/helpers/memberHelper.test.js
+++ b/tests/helpers/memberHelper.test.js
@@ -63,12 +63,11 @@ describe('MemberHelper', () => {
            [[]]
        ])('%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();
-            });
+            const result = await memberHelper.parseMemberCommand(authorId, authorFull, args);
+            // Assert
+            expect(result).toEqual("member command info");
+            expect(memberHelper.getMemberCommandInfo).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMemberCommandInfo).toHaveBeenCalledWith();
        });

        test.each([
@@ -92,12 +91,12 @@ describe('MemberHelper', () => {
            [[mockMember.name, 'remove', 'test'], null, null, 'remove', false, mockMember.name],
            [[mockMember.name, 'new'], null, null, 'new', false, mockMember.name],
            [[mockMember.name, 'new', mockMember.displayname], null, null, 'new', false, mockMember.name],
-            [[mockMember.name, 'new',  mockMember.displayname, mockMember.proxy], null, null, 'new', false, mockMember.name],
-            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy,mockMember.propic], null, null, 'new', false, mockMember.name],
-            [[mockMember.name, 'new',mockMember.displayname, mockMember.proxy, null], mockMember.propic, null, 'new', false, mockMember.name],
+            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy], null, null, 'new', false, mockMember.name],
+            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy, mockMember.propic], null, null, 'new', false, mockMember.name],
+            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy, null], mockMember.propic, null, 'new', false, mockMember.name],
            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy, null], mockMember.propic, attachmentExpiration, 'new', false, mockMember.name],
            [[mockMember.name, 'name', mockMember.name], null, null, 'name', false, mockMember.name],
-            [[mockMember.name, 'new',  '', mockMember.proxy], null, null, 'new', false, mockMember.name],
+            [[mockMember.name, 'new', '', mockMember.proxy], null, null, 'new', false, mockMember.name],
            [[mockMember.name, 'new', '', '', mockMember.propic], null, null, 'new', false, mockMember.name],
            [[mockMember.name, 'new', '', '', null], mockMember.propic, null, 'new', false, mockMember.name],
            [[mockMember.name, 'new', '', '', null], mockMember.propic, attachmentExpiration, 'new', false, mockMember.name],
@@ -115,7 +114,7 @@ describe('MemberHelper', () => {
            [['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic], null, null, 'new', false, mockMember.name],
            [['new', mockMember.name, undefined, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, null, 'new', false, mockMember.name],
            [['new', mockMember.name, undefined, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, attachmentExpiration, 'new', false, mockMember.name],
-            [['new',mockMember.name,  '', mockMember.proxy], null, null, 'new', false, mockMember.name],
+            [['new', mockMember.name, '', mockMember.proxy], null, null, 'new', false, mockMember.name],
            [['new', mockMember.name, '', '', mockMember.propic], null, null, 'new', false, mockMember.name],
            [['new', mockMember.name, '', '', null], mockMember.propic, null, 'new', false, mockMember.name],
            [['new', mockMember.name, '', '', null], mockMember.propic, attachmentExpiration, 'new', false, mockMember.name],
@@ -126,15 +125,14 @@ describe('MemberHelper', () => {
            [['propic', mockMember.name, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic], null, null, 'propic', false, mockMember.name],
            [['propic', mockMember.name, undefined, mockMember.name, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, null, 'propic', false, mockMember.name],
            [['propic', mockMember.name, undefined, mockMember.name, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, attachmentExpiration, 'propic', false, mockMember.name]
-        ])('%s args with attachmentURL %s and attachment expiration %s calls memberCommandHandler with correct values', (args, attachmentUrl, attachmentExpiration, command, isHelp, memberName) => {
+        ])('%s args with attachmentURL %s and attachment expiration %s calls memberCommandHandler with correct values', async (args, attachmentUrl, attachmentExpiration, command, isHelp, memberName) => {
            console.log(args, command, isHelp)
            // Act
-            return memberHelper.parseMemberCommand(authorId, authorFull, args, attachmentUrl, attachmentExpiration).then((result) => {
-                // Assert
-                expect(result).toEqual("handled argument");
-                expect(memberHelper.memberArgumentHandler).toHaveBeenCalledTimes(1);
-                expect(memberHelper.memberArgumentHandler).toHaveBeenCalledWith(authorId, authorFull, isHelp, command, memberName, args, attachmentUrl, attachmentExpiration);
-            });
+            const result = await memberHelper.parseMemberCommand(authorId, authorFull, args, attachmentUrl, attachmentExpiration);
+            // Assert
+            expect(result).toEqual("handled argument");
+            expect(memberHelper.memberArgumentHandler).toHaveBeenCalledTimes(1);
+            expect(memberHelper.memberArgumentHandler).toHaveBeenCalledWith(authorId, authorFull, isHelp, command, memberName, args, attachmentUrl, attachmentExpiration);
        })
    });

@@ -146,12 +144,10 @@ describe('MemberHelper', () => {
            jest.spyOn(memberHelper, 'sendHelpEnum').mockReturnValue("help enum");
        })

-        test('when all values are null should return command not recognized enum', () => {
+        test('when all values are null should throw command not recognized enum', async () => {
            // Arrange
-            return memberHelper.memberArgumentHandler(authorId, authorFull, false, null, null, []).catch((result) => {
-                // Assert
-                expect(result).toEqual(new Error(enums.err.COMMAND_NOT_RECOGNIZED));
-            });
+            await expect(memberHelper.memberArgumentHandler(authorId, authorFull, false, null, null, [])).rejects.toThrow(enums.err.COMMAND_NOT_RECOGNIZED);
+
        })

        test.each([
@@ -161,12 +157,9 @@ describe('MemberHelper', () => {
            ['displayname'],
            ['proxy'],
            ['propic'],
-        ])('when %s is present but other values are null, should return no member enum', (command) => {
+        ])('when %s is present but other values are null, should throw no member enum', async (command) => {
            // Arrange
-            return memberHelper.memberArgumentHandler(authorId, authorFull, false, command, null, []).catch((result) => {
-                // Assert
-                expect(result).toEqual(new Error(enums.err.NO_MEMBER));
-            });
+            await expect(memberHelper.memberArgumentHandler(authorId, authorFull, false, command, null, [])).rejects.toThrow(enums.err.NO_MEMBER);
        })


@@ -178,24 +171,22 @@ describe('MemberHelper', () => {
            ['displayname'],
            ['proxy'],
            ['propic'],
-        ])('%s calls sendHelpEnum', (command) => {
+        ])('%s calls sendHelpEnum', async (command) => {
            // Arrange
-            return memberHelper.memberArgumentHandler(authorId, authorFull, true, command, mockMember.name, []).then((result) => {
-                // Assert
-                expect(result).toEqual("help enum");
-                expect(memberHelper.sendHelpEnum).toHaveBeenCalledTimes(1);
-                expect(memberHelper.sendHelpEnum).toHaveBeenCalledWith(command);
-            });
+            const result = await memberHelper.memberArgumentHandler(authorId, authorFull, true, command, mockMember.name, []);
+            // Assert
+            expect(result).toEqual("help enum");
+            expect(memberHelper.sendHelpEnum).toHaveBeenCalledTimes(1);
+            expect(memberHelper.sendHelpEnum).toHaveBeenCalledWith(command);
        })

-        test('list should call getAllMembersInfo', () => {
+        test('list should call getAllMembersInfo', async () => {
            // Arrange
-            return memberHelper.memberArgumentHandler(authorId, authorFull, false, 'list', mockMember.name, []).then((result) => {
-                // Assert
-                expect(result).toEqual("all member info");
-                expect(memberHelper.getAllMembersInfo).toHaveBeenCalledTimes(1);
-                expect(memberHelper.getAllMembersInfo).toHaveBeenCalledWith(authorId, authorFull);
-            });
+            const result = await memberHelper.memberArgumentHandler(authorId, authorFull, false, 'list', mockMember.name, []);
+            // Assert
+            expect(result).toEqual("all member info");
+            expect(memberHelper.getAllMembersInfo).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getAllMembersInfo).toHaveBeenCalledWith(authorId, authorFull);
        })

        test.each([
@@ -203,14 +194,14 @@ describe('MemberHelper', () => {
            [[mockMember.name, 'remove', 'test'], null, null, 'remove'],
            [[mockMember.name, 'new'], null, null, 'new'],
            [[mockMember.name, 'new', mockMember.displayname], null, null, 'new'],
-            [[mockMember.name, 'new',  mockMember.displayname, mockMember.proxy], null, null, 'new'],
-            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy,mockMember.propic], null, null, 'new'],
-            [[mockMember.name, 'new',mockMember.displayname, mockMember.proxy, null], mockMember.propic, null, 'new'],
+            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy], null, null, 'new'],
+            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy, mockMember.propic], null, null, 'new'],
+            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy, null], mockMember.propic, null, 'new'],
            [[mockMember.name, 'new', mockMember.displayname, mockMember.proxy, null], mockMember.propic, attachmentExpiration, 'new'],
            [[mockMember.name, 'name', mockMember.name], null, null, 'name'],
            [[mockMember.name, 'displayname', mockMember.displayname], null, null, 'displayname'],
            [[mockMember.name, 'new', mockMember.displayname], null, null, 'new'],
-            [[mockMember.name, 'new',  '', mockMember.proxy], null, null, 'new'],
+            [[mockMember.name, 'new', '', mockMember.proxy], null, null, 'new'],
            [[mockMember.name, 'new', '', '', mockMember.propic], null, null, 'new'],
            [[mockMember.name, 'new', '', '', undefined], mockMember.propic, null, 'new'],
            [[mockMember.name, 'new', '', '', undefined], mockMember.propic, attachmentExpiration, 'new'],
@@ -230,7 +221,7 @@ describe('MemberHelper', () => {
            [['new', mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic], null, null, 'new'],
            [['new', mockMember.name, undefined, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, null, 'new'],
            [['new', mockMember.name, undefined, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, attachmentExpiration, 'new'],
-            [['new', mockMember.name,  '', mockMember.proxy], null, null, 'new'],
+            [['new', mockMember.name, '', mockMember.proxy], null, null, 'new'],
            [['new', mockMember.name, '', '', mockMember.propic], null, null, 'new'],
            [['new', mockMember.name, '', '', undefined], mockMember.propic, null, 'new'],
            [['new', mockMember.name, '', '', undefined], mockMember.propic, attachmentExpiration, 'new'],
@@ -242,16 +233,16 @@ describe('MemberHelper', () => {
            [['propic', mockMember.name, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic], null, null, 'propic'],
            [['propic', mockMember.name, undefined, mockMember.name, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, null, 'propic'],
            [['propic', mockMember.name, undefined, mockMember.name, mockMember.displayname, mockMember.proxy, undefined], mockMember.propic, attachmentExpiration, 'propic']
-        ])('%s args with attachmentURL %s and attachment expiration %s calls memberCommandHandler', (args, attachmentUrl, attachmentExpiration, command) => {
+        ])('%s args with attachmentURL %s and attachment expiration %s calls memberCommandHandler', async (args, attachmentUrl, attachmentExpiration, command) => {
            // Arrange
            let values = args.slice(2);

-            return memberHelper.memberArgumentHandler(authorId, authorFull, false, command, mockMember.name, args, attachmentUrl, attachmentExpiration).then((result) => {
-                // Assert
-                expect(result).toEqual("handled command");
-                expect(memberHelper.memberCommandHandler).toHaveBeenCalledTimes(1);
-                expect(memberHelper.memberCommandHandler).toHaveBeenCalledWith(authorId, command, mockMember.name, values, attachmentUrl, attachmentExpiration);
-            });
+            const result = await memberHelper.memberArgumentHandler(authorId, authorFull, false, command, mockMember.name, args, attachmentUrl, attachmentExpiration);
+            // Assert
+            expect(result).toEqual("handled command");
+            expect(memberHelper.memberCommandHandler).toHaveBeenCalledTimes(1);
+            expect(memberHelper.memberCommandHandler).toHaveBeenCalledWith(authorId, command, mockMember.name, values, attachmentUrl, attachmentExpiration);
+
        })

        test.each([
@@ -260,16 +251,14 @@ describe('MemberHelper', () => {
            ['displayname'],
            ['proxy'],
            ['propic'],
-        ])('%s calls sendCurrentValue', (command) => {
-            return memberHelper.memberArgumentHandler(authorId, authorFull, false, command, mockMember.name, []).then((result) => {
-                // Assert
-                expect(result).toEqual("current value");
-                expect(memberHelper.sendCurrentValue).toHaveBeenCalledTimes(1);
-                expect(memberHelper.sendCurrentValue).toHaveBeenCalledWith(authorId,mockMember.name, command);
-            });
+        ])('%s calls sendCurrentValue', async (command) => {
+            const result = await memberHelper.memberArgumentHandler(authorId, authorFull, false, command, mockMember.name, []);
+            // Assert
+            expect(result).toEqual("current value");
+            expect(memberHelper.sendCurrentValue).toHaveBeenCalledTimes(1);
+            expect(memberHelper.sendCurrentValue).toHaveBeenCalledWith(authorId, mockMember.name, command);
+
        })
-
-
    });

    describe('sendCurrentValue', () => {
@@ -279,88 +268,87 @@ describe('MemberHelper', () => {
            ['displayname', `The display name for ${mockMember.name} is \"${mockMember.displayname}\".`],
            ['proxy', `The proxy for ${mockMember.name} is \"${mockMember.proxy}\".`],
            ['propic', `The profile picture for ${mockMember.name} is \"${mockMember.propic}\".`],
-        ])('%s calls getMemberByName and returns value', (command, expected) => {
+        ])('%s calls getMemberByName and returns value', async (command, expected) => {
            // Arrange
            jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(mockMember);
            // Act
-            return memberHelper.sendCurrentValue(authorId, mockMember.name, command).then((result) => {
-                // Assert
-                expect(result).toEqual(expected);
-                expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
-                expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId,mockMember.name);
-            });
+            const result = await memberHelper.sendCurrentValue(authorId, mockMember.name, command);
+            // Assert
+            expect(result).toEqual(expected);
+            expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, mockMember.name);
+
        })

-        test('returns error if no member found', () => {
+        test('returns error if no member found', async () => {
            // Arrange
            jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(null);
            // Act
-            return memberHelper.sendCurrentValue(authorId, mockMember.name, 'name').catch((result) => {
-                // Assert
-                expect(result).toEqual(new Error(enums.err.NO_MEMBER));
-                expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
-                expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId,mockMember.name);
-            });
-        })
+            await expect(memberHelper.sendCurrentValue(authorId, mockMember.name, 'name')).rejects.toThrow(enums.err.NO_MEMBER);
+            // Assert
+            expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, mockMember.name);
+        });

-        test('calls getMemberInfo with member if no command present', () => {
+        test('calls getMemberInfo with member if no command present', async () => {
            // Arrange
            jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(mockMember);
            jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue('member info');
            // Act
-            return memberHelper.sendCurrentValue(authorId, mockMember.name, null).then((result) => {
-                // Assert
-                expect(result).toEqual('member info');
-                expect(memberHelper.getMemberInfo).toHaveBeenCalledTimes(1);
-                expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(mockMember);
-            });
+            const result = await memberHelper.sendCurrentValue(authorId, mockMember.name, null);
+            // Assert
+            expect(result).toEqual('member info');
+            expect(memberHelper.getMemberInfo).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(mockMember);
        })

        test.each([
            ['displayname', `Display name ${enums.err.NO_VALUE}`],
            ['proxy', `Proxy ${enums.err.NO_VALUE}`],
            ['propic', `Propic ${enums.err.NO_VALUE}`],
-        ])('returns null message if no member found', (command, expected) => {
+        ])('returns null message if no value found', async (command, expected) => {
            // Arrange
            const empty = {name: mockMember.name, displayname: null, proxy: null, propic: null}
            jest.spyOn(memberHelper, 'getMemberByName').mockResolvedValue(empty);
            // Act
-            return memberHelper.sendCurrentValue(authorId, mockMember.name, command).then((result) => {
-                // Assert
-                expect(result).toEqual(expected);
-                expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
-                expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId,mockMember.name);
-            });
+            const result = await memberHelper.sendCurrentValue(authorId, mockMember.name, command);
+            // Assert
+            expect(result).toEqual(expected);
+            expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, mockMember.name);
        })
    })

    describe('addNewMember', () => {
-        test('calls addFullMember with correct arguments', async() => {
+        test('calls addFullMember with correct arguments', async () => {
            // Arrange
            const args = [mockMember.displayname, mockMember.proxy, mockMember.propic];
            jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(mockMember);
            jest.spyOn(memberHelper, 'getMemberInfo').mockResolvedValue();
            // Act
-            return memberHelper.addNewMember(authorId, mockMember.name, args, attachmentUrl, attachmentExpiration).then(() => {
-                expect(memberHelper.addFullMember).toHaveBeenCalledTimes(1);
-                expect(memberHelper.addFullMember).toHaveBeenCalledWith(authorId, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic, attachmentExpiration);
-            })
+            const result = await memberHelper.addNewMember(authorId, mockMember.name, args, attachmentUrl, attachmentExpiration);
+            // Assert
+            expect(memberHelper.addFullMember).toHaveBeenCalledTimes(1);
+            expect(memberHelper.addFullMember).toHaveBeenCalledWith(authorId, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic, attachmentExpiration);
        })

        test('calls getMemberInfo when successful and returns result', async () => {
            // Arrange
            const args = [mockMember.displayname, mockMember.proxy, mockMember.propic];
            const fullMemberResponse = {member: mockMember, errors: []}
-            const expected = {embed: mockMember, errors: [],  success: `${mockMember.name} has been added successfully.`};
+            const expected = {
+                embed: mockMember,
+                errors: [],
+                success: `${mockMember.name} has been added successfully.`
+            };
            jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(fullMemberResponse);
            jest.spyOn(memberHelper, 'getMemberInfo').mockReturnValue(mockMember);
            //Act
-            return memberHelper.addNewMember(authorId, mockMember.name, args, attachmentUrl, attachmentExpiration).then((result) => {
-                // Assert
-                expect(result).toEqual(expected);
-                expect(memberHelper.getMemberInfo).toHaveBeenCalledTimes(1);
-                expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(mockMember);
-            })
+            const result = await memberHelper.addNewMember(authorId, mockMember.name, args, attachmentUrl, attachmentExpiration);
+            // Assert
+            expect(result).toEqual(expected);
+            expect(memberHelper.getMemberInfo).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMemberInfo).toHaveBeenCalledWith(mockMember);
        })

        test('throws expected error when getMemberInfo throws error', async () => {
@@ -368,29 +356,19 @@ describe('MemberHelper', () => {
            const args = [];
            const memberObject = {name: args[1]}
            jest.spyOn(memberHelper, 'addFullMember').mockResolvedValue(memberObject);
-            jest.spyOn(memberHelper, 'getMemberInfo').mockImplementation(() => {
-                throw new Error('getMemberInfo error')
-            });
+            jest.spyOn(memberHelper, 'getMemberInfo').mockImplementation(() => {throw new Error('getMemberInfo error')});
            //Act
-            return memberHelper.addNewMember(authorId, mockMember.name, args).catch((result) => {
-                // Assert
-                expect(result).toEqual(new Error('getMemberInfo error'));
-            })
+            await expect(memberHelper.addNewMember(authorId, mockMember.name, args)).rejects.toThrow('getMemberInfo error');
        })

        test('throws expected error when addFullMember throws error', async () => {
            // Arrange
            const args = [];
            const expected = 'add full member error';
-            jest.spyOn(memberHelper, 'addFullMember').mockImplementation(() => {
-                throw new Error(expected)
-            });
+            jest.spyOn(memberHelper, 'addFullMember').mockRejectedValue(new Error(expected));

            //Act
-            return memberHelper.addNewMember(authorId, mockMember.name, args).catch((result) => {
-                // Assert
-                expect(result).toEqual(new Error(expected));
-            })
+            await expect(memberHelper.addNewMember(authorId, mockMember.name, args)).rejects.toThrow(expected)
        })
    })

@@ -400,23 +378,20 @@ describe('MemberHelper', () => {
            // 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");
-            })
+            const result = await memberHelper.updateName(authorId, mockMember.name, "   somePerson   ")
+            // 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();
-            })
+            // Act & Assert
+            await expect(memberHelper.updateName(authorId, mockMember.name, "        ")).rejects.toThrow('Name ' + enums.err.NO_VALUE);
+            // Assert
+            expect(memberHelper.updateMemberField).not.toHaveBeenCalled();
        })
    })

@@ -425,52 +400,47 @@ describe('MemberHelper', () => {
        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();
-            })
+            // Act & Assert
+            await expect(memberHelper.updateDisplayName(authorId, mockMember.name, "           ")).rejects.toThrow("Display name " + enums.err.NO_VALUE);
+            // Assert
+            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();
-            })
+            // Act & Assert
+            await expect(memberHelper.updateDisplayName(authorId, mockMember.name, tooLongDisplayName)).rejects.toThrow(enums.err.DISPLAY_NAME_TOO_LONG);
+            // Assert
+            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);
-            })
+            const result = await memberHelper.updateDisplayName(authorId, mockMember.name, "      Some Person ");
+            // 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() => {
+        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);
-            });
+            const result = await memberHelper.updateProxy(authorId, mockMember.name, "--text");
+            // Assert
+            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);
        })
    })

@@ -480,54 +450,50 @@ describe('MemberHelper', () => {
            [mockMember.propic, null, null, mockMember.propic],
            [mockMember.propic, attachmentUrl, null, attachmentUrl],
            [null, attachmentUrl, attachmentExpiration, attachmentUrl]
-        ])('calls checkImageFormatValidity and updateMemberField and returns string', async(imgUrl, attachmentUrl, attachmentExpiration, expected) => {
+        ])('calls checkImageFormatValidity and updateMemberField and returns string', async (imgUrl, attachmentUrl, attachmentExpiration, expected) => {
            // Arrange

            jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
            // Act
-            return memberHelper.updatePropic(authorId, mockMember.name, imgUrl, attachmentUrl, attachmentExpiration).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, attachmentExpiration);
-            });
+            const result = await memberHelper.updatePropic(authorId, mockMember.name, imgUrl, attachmentUrl, attachmentExpiration);
+            // Assert
+            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, attachmentExpiration);
        })
    })

    describe('addFullMember', () => {
-        const { database} = require('../../src/database.js');
+        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);
-            })
+            await memberHelper.addFullMember(authorId, mockMember.name)
+            // Assert
+            expect(memberHelper.getMemberByName).toHaveBeenCalledWith(authorId, mockMember.name);
+            expect(memberHelper.getMemberByName).toHaveBeenCalledTimes(1);
        })

        test('if getMemberByName returns member, throw error', async () => {
+            // Arrange
            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();
-            })
+            // Act & Assert
+            await expect(memberHelper.addFullMember(authorId, mockMember.name)).rejects.toThrow(`Can't add ${mockMember.name}. ${enums.err.MEMBER_EXISTS}`)
+            // Assert
+            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();
-            })
+            // Act & Assert
+            await expect(memberHelper.addFullMember(authorId, "       ")).rejects.toThrow(`Name ${enums.err.NO_VALUE}. ${enums.err.NAME_REQUIRED}`);
+            // Assert
+            expect(database.members.create).not.toHaveBeenCalled();
        })

        test('if displayname is over 32 characters, call database.member.create with null value', async () => {
@@ -548,43 +514,39 @@ describe('MemberHelper', () => {
            }

            // 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);
-            })
+            const res = await memberHelper.addFullMember(authorId, mockMember.name, tooLongDisplayName, null, null);
+            // 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();
+            jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue(true);
            const expectedMemberArgs = {
                name: mockMember.name,
                userid: authorId,
                displayname: null,
-                proxy: mockMember.proxy,
+                proxy: null,
                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);
-            })
+            const res = await memberHelper.addFullMember(authorId, mockMember.name, null, mockMember.proxy)
+            // 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')
-            });
+            jest.spyOn(memberHelper, 'checkIfProxyExists').mockRejectedValue(new Error('error'));
            const expectedMemberArgs = {
                name: mockMember.name,
                userid: authorId,
@@ -599,12 +561,11 @@ describe('MemberHelper', () => {
            }

            // 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);
-            })
+            const res = await memberHelper.addFullMember(authorId, mockMember.name, null, mockMember.proxy, null)
+            // Assert
+            expect(res).toEqual(expectedReturn);
+            expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
+            expect(database.members.create).toHaveBeenCalledTimes(1);
        })

        test('if propic, call checkImageFormatValidity', async () => {
@@ -614,24 +575,23 @@ describe('MemberHelper', () => {
                userid: authorId,
                displayname: null,
                proxy: null,
-                propic: mockMember.propic
+                propic: null
            }
            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);
-            })
+            const res = await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic);
+            // 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")})
+            utils.checkImageFormatValidity = jest.fn().mockRejectedValue(new Error("error"));
            const expectedMemberArgs = {
                name: mockMember.name,
                userid: authorId,
@@ -645,17 +605,16 @@ describe('MemberHelper', () => {
                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);
-            })
+            const res = await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic);
+            // 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();
+            jest.spyOn(memberHelper, 'checkIfProxyExists').mockResolvedValue(false);
            const expectedMemberArgs = {
                name: mockMember.name,
                userid: authorId,
@@ -664,15 +623,14 @@ describe('MemberHelper', () => {
                propic: mockMember.propic
            }
            database.members.create = jest.fn().mockResolvedValue(expectedMemberArgs);
-            utils.checkImageFormatValidity = jest.fn().mockResolvedValue();
+            utils.checkImageFormatValidity = jest.fn().mockResolvedValue(true);
            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);
-            })
+            const res = await memberHelper.addFullMember(authorId, mockMember.name, mockMember.displayname, mockMember.proxy, mockMember.propic);
+            // Assert
+            expect(res).toEqual(expectedReturn);
+            expect(database.members.create).toHaveBeenCalledWith(expectedMemberArgs);
+            expect(database.members.create).toHaveBeenCalledTimes(1);
        })

    })
@@ -687,10 +645,9 @@ describe('MemberHelper', () => {
        })

        test('calls setExpirationWarning if attachmentExpiration', async () => {
-            return memberHelper.updateMemberField(authorId, mockMember.name, "propic", mockMember.propic, attachmentExpiration).then((res) => {
-                expect(memberHelper.setExpirationWarning).toHaveBeenCalledTimes(1);
-                expect(memberHelper.setExpirationWarning).toHaveBeenCalledWith(mockMember.propic);
-            })
+            await memberHelper.updateMemberField(authorId, mockMember.name, "propic", mockMember.propic, attachmentExpiration)
+            expect(memberHelper.setExpirationWarning).toHaveBeenCalledTimes(1);
+            expect(memberHelper.setExpirationWarning).toHaveBeenCalledWith(mockMember.propic);
        })

        test.each([
@@ -700,28 +657,25 @@ describe('MemberHelper', () => {
            ['propic', mockMember.propic, null, `Updated name for ${mockMember.name} to ${mockMember.propic}`],
            ['propic', mockMember.propic, attachmentExpiration, `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
-                    }
-                })
+            // Act
+            await memberHelper.updateMemberField(authorId, mockMember.name, columnName, value, attachmentExpiration)
+            // Assert
+            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', () => {
+        test('if database.members.update returns 0 rows changed, throw error', async () => {
            // 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}.`))
-            })
+            await expect(memberHelper.updateMemberField(authorId, mockMember.name, "displayname", mockMember.displayname)).rejects.toThrow(`Can't update ${mockMember.name}. ${enums.err.NO_MEMBER}.`);
        })
    })

@@ -742,32 +696,30 @@ describe('MemberHelper', () => {
            ['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);
-            })
+            // Act
+            const res = await memberHelper.checkIfProxyExists(authorId, proxy)
+            // Assert
+            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();
-                }
-            })
+        ])('%s returns correct error and does not call getMemberByAuthor', async (proxy, error, shouldCall) => {
+            // Act & Assert
+            await expect(memberHelper.checkIfProxyExists(authorId, proxy)).rejects.toThrow(error);
+
+            expect(memberHelper.getMembersByAuthor).not.toHaveBeenCalled();
        })

-
+        test('--text returns correct error and calls getMemberByAuthor', async () => {
+            await expect(memberHelper.checkIfProxyExists(authorId, "--text")).rejects.toThrow(enums.err.PROXY_EXISTS);
+            expect(memberHelper.getMembersByAuthor).toHaveBeenCalledTimes(1);
+            expect(memberHelper.getMembersByAuthor).toHaveBeenCalledWith(authorId);
+        })
    })

    afterEach(() => {
--- a/tests/helpers/messageHelper.test.js
+++ b/tests/helpers/messageHelper.test.js
@@ -3,9 +3,11 @@ env.config();


 jest.mock('../../src/helpers/memberHelper.js', () => {
-    return {memberHelper: {
-        getMembersByAuthor: jest.fn()
-    }}
+    return {
+        memberHelper: {
+            getMembersByAuthor: jest.fn()
+        }
+    }
 })

 const {memberHelper} = require("../../src/helpers/memberHelper.js");
@@ -20,11 +22,11 @@ describe('messageHelper', () => {

    describe('parseCommandArgs', () => {
        test.each([
-            ['pk;member', ['']],
-            ['pk;member add somePerson "Some Person"', ['add', 'somePerson', 'Some Person']],
-            ['pk;member add \"Some Person\"', ['add', 'Some Person']],
-            ['pk;member add somePerson \'Some Person\'', ['add', 'somePerson', 'Some Person']],
-            ['pk;member add somePerson \"\'Some\' Person\"', ['add', 'somePerson', 'Some Person']],
+            ['pf;member', ['']],
+            ['pf;member add somePerson "Some Person"', ['add', 'somePerson', 'Some Person']],
+            ['pf;member add \"Some Person\"', ['add', 'Some Person']],
+            ['pf;member add somePerson \'Some Person\'', ['add', 'somePerson', 'Some Person']],
+            ['pf;member add somePerson \"\'Some\' Person\"', ['add', 'somePerson', 'Some Person']],
        ])('%s returns correct arguments', (content, expected) => {
            // Arrange
            const command = "member";
@@ -72,17 +74,16 @@ describe('messageHelper', () => {
            ['2', 'hello', null, undefined],
            ['2', '--hello', null, undefined],
            ['2', 'hello', attachmentUrl, undefined],
-            ['2', '--hello', attachmentUrl,undefined],
+            ['2', '--hello', attachmentUrl, undefined],
            ['3', 'hello', null, {}],
            ['3', '--hello', null, {}],
            ['3', 'hello', attachmentUrl, {}],
-            ['3', '--hello', attachmentUrl,{}],
-        ])('ID %s with string %s returns correct proxy', async(specificAuthorId, content, attachmentUrl, expected) => {
+            ['3', '--hello', attachmentUrl, {}],
+        ])('ID %s with string %s returns correct proxy', async (specificAuthorId, content, attachmentUrl, expected) => {
            // Act
-            return messageHelper.parseProxyTags(specificAuthorId, content, attachmentUrl).then((res) => {
-                // Assert
-                expect(res).toEqual(expected);
-            })
+            const res = await messageHelper.parseProxyTags(specificAuthorId, content, attachmentUrl);
+            // Assert
+            expect(res).toEqual(expected);
        });
    })

--- a/tests/helpers/utils.test.js
+++ b/tests/helpers/utils.test.js
@@ -1,15 +1,63 @@
 const {enums} = require("../../src/enums");

-const fetchMock = require('jest-fetch-mock');
-fetchMock.enableMocks();
-
 const {utils} = require("../../src/helpers/utils.js");

 describe('utils', () => {

+    const attachmentUrl = 'oya.png';
+    let blob;
+
    beforeEach(() => {
        jest.resetModules();
        jest.clearAllMocks();
+        blob = new Blob([JSON.stringify({attachmentUrl: attachmentUrl})], {type: 'image/png'});
+        global.fetch = jest.fn(() =>
+            Promise.resolve({
+                blob: () => Promise.resolve(blob),
+            })
+        );
+
+    })
+
+    describe('checkImageFormatValidity', () => {
+
+        test('calls fetch with imageUrl and returns true if no errors', async() => {
+            // Act
+            const res = await utils.checkImageFormatValidity(attachmentUrl);
+            // Assert
+            expect(res).toBe(true);
+            expect(fetch).toHaveBeenCalledTimes(1);
+            expect(fetch).toHaveBeenCalledWith(attachmentUrl);
+        })
+
+        test('throws error if fetch returns error', async() => {
+            // Arrange
+            global.fetch = jest.fn().mockRejectedValue(new Error('error'));
+            // Act & Assert
+            await expect(utils.checkImageFormatValidity(attachmentUrl)).rejects.toThrow(`${enums.err.PROPIC_CANNOT_LOAD}: error`);
+        })
+
+        test('throws error if blob returns error', async() => {
+            // Arrange
+            global.fetch = jest.fn(() =>
+                Promise.resolve({
+                    blob: () => Promise.reject(new Error('error'))
+                }))
+            // Act & Assert
+            await expect(utils.checkImageFormatValidity(attachmentUrl)).rejects.toThrow('error');
+        })
+
+        test('throws error if blob in wrong format', async() => {
+            // Arrange
+            blob =  new Blob([JSON.stringify({attachmentUrl})], {type: 'text/html'});
+            global.fetch = jest.fn(() =>
+                Promise.resolve({
+                    blob: () => Promise.resolve(blob),
+                })
+            );
+            // Act & Assert
+            await expect(utils.checkImageFormatValidity(attachmentUrl)).rejects.toThrow(enums.err.PROPIC_FAILS_REQUIREMENTS);
+        })
    })

    afterEach(() => {
--- a/tests/helpers/webhookHelper.test.js
+++ b/tests/helpers/webhookHelper.test.js
@@ -14,10 +14,44 @@ const {webhookHelper} = require("../../src/helpers/webhookHelper.js");
 const {enums} = require("../../src/enums");

 describe('webhookHelper', () => {
+    const channelId = '123';
+    const authorId = '456';
+    const guildId = '789';
+    const text = "hello";
+    let client, member, attachments, message, webhook;

    beforeEach(() => {
        jest.resetModules();
        jest.clearAllMocks();
+        client = {
+            channels: {
+                get: jest.fn().mockReturnValue(channelId)
+            }
+        }
+        member = {proxy: "--text", name: 'somePerson', displayname: "Some Person", propic: 'oya.png'};
+        attachments = {
+            size: 1,
+            first: () => {return channelId;}
+        };
+
+        message = {
+            client,
+            channelId: channelId,
+            content: text,
+            attachments: attachments,
+            author: {
+                id: authorId
+            },
+            guild: {
+                guildId: guildId
+            },
+            reply: jest.fn().mockResolvedValue(),
+            delete: jest.fn().mockResolvedValue()
+        }
+
+        webhook = {
+            send: async() => jest.fn().mockResolvedValue()
+        }
    })

    describe(`sendMessageAsMember`, () => {
@@ -34,9 +68,7 @@ describe('webhookHelper', () => {
            author: {
                id: '123'
            },
-            guild: {
-                guildId: '123'
-            },
+            guildId: '123',
            reply: jest.fn()
        }
        const member = {proxy: "--text", name: 'somePerson', displayname: "Some Person"};
@@ -50,25 +82,24 @@ describe('webhookHelper', () => {
            // Arrange
            messageHelper.parseProxyTags.mockResolvedValue({});
            // Act
-            return webhookHelper.sendMessageAsMember(client, message).then((res) => {
-                expect(res).toBeUndefined();
-                expect(messageHelper.parseProxyTags).toHaveBeenCalledTimes(1);
-                expect(messageHelper.parseProxyTags).toHaveBeenCalledWith(message.author.id, content, null);
-                expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
-            })
+            const res = await webhookHelper.sendMessageAsMember(client, message)
+            // Assert
+            expect(res).toBeUndefined();
+            expect(messageHelper.parseProxyTags).toHaveBeenCalledTimes(1);
+            expect(messageHelper.parseProxyTags).toHaveBeenCalledWith(message.author.id, content, null);
+            expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
        })

        test('calls parseProxyTags and returns if proxyMatch is undefined', async() => {
            // Arrange
            messageHelper.parseProxyTags.mockResolvedValue(undefined);
            // Act
-            return webhookHelper.sendMessageAsMember(client, message).then((res) => {
-                // Assert
-                expect(res).toBeUndefined();
-                expect(messageHelper.parseProxyTags).toHaveBeenCalledTimes(1);
-                expect(messageHelper.parseProxyTags).toHaveBeenCalledWith(message.author.id, content, null);
-                expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
-            })
+            const res = await webhookHelper.sendMessageAsMember(client, message)
+            // Assert
+            expect(res).toBeUndefined();
+            expect(messageHelper.parseProxyTags).toHaveBeenCalledTimes(1);
+            expect(messageHelper.parseProxyTags).toHaveBeenCalledWith(message.author.id, content, null);
+            expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
        })

        test('calls parseProxyTags with attachmentUrl', async() => {
@@ -79,27 +110,22 @@ describe('webhookHelper', () => {
                    return {url: 'oya.png'}
                }
            }
-            // message.attachments.set('attachment', {url: 'oya.png'})
-            // message.attachments.set('first', () => {return {url: 'oya.png'}})
            messageHelper.parseProxyTags.mockResolvedValue(undefined);
            // Act
-            return webhookHelper.sendMessageAsMember(client, message).then((res) => {
-                // Assert
-                expect(res).toBeUndefined();
-                expect(messageHelper.parseProxyTags).toHaveBeenCalledTimes(1);
-                expect(messageHelper.parseProxyTags).toHaveBeenCalledWith(message.author.id, content, 'oya.png');
-            })
+            const res = await webhookHelper.sendMessageAsMember(client, message)
+            // Assert
+            expect(res).toBeUndefined();
+            expect(messageHelper.parseProxyTags).toHaveBeenCalledTimes(1);
+            expect(messageHelper.parseProxyTags).toHaveBeenCalledWith(message.author.id, content, 'oya.png');
        })

        test('if message matches member proxy but is not sent from a guild, throw an error', async() => {
            // Arrange
+            message.guildId = null;
            messageHelper.parseProxyTags.mockResolvedValue(proxyMessage);
-            // Act
-            return webhookHelper.sendMessageAsMember(client, message).catch((res) => {
-                // Assert
-                expect(res).toEqual(new Error(enums.err.NOT_IN_SERVER));
-                expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
-            })
+            // Act and Assert
+            await expect(webhookHelper.sendMessageAsMember(client, message)).rejects.toThrow(enums.err.NOT_IN_SERVER);
+            expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
        })

        test('if message matches member proxy and sent in a guild and has an attachment, reply to message with ping', async() => {
@@ -109,12 +135,11 @@ describe('webhookHelper', () => {
            messageHelper.parseProxyTags.mockResolvedValue(proxyMessage);
            const expected = `${enums.misc.ATTACHMENT_SENT_BY} ${proxyMessage.member.displayname}`
            // Act
-            return webhookHelper.sendMessageAsMember(client, message).then((res) => {
-                // Assert
-                expect(message.reply).toHaveBeenCalledTimes(1);
-                expect(message.reply).toHaveBeenCalledWith(expected);
-                expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
-            })
+            await webhookHelper.sendMessageAsMember(client, message)
+            // Assert
+            expect(message.reply).toHaveBeenCalledTimes(1);
+            expect(message.reply).toHaveBeenCalledWith(expected);
+            expect(webhookHelper.replaceMessage).not.toHaveBeenCalled();
        })

        test('if message matches member proxy and sent in a guild channel and no attachment, calls replace message', async() => {
@@ -124,63 +149,26 @@ describe('webhookHelper', () => {
            messageHelper.parseProxyTags.mockResolvedValue(proxyMessage);
            jest.spyOn(webhookHelper,  'replaceMessage').mockResolvedValue();
            // Act
-            return webhookHelper.sendMessageAsMember(client, message).then((res) => {
-                // Assert
-                expect(message.reply).not.toHaveBeenCalled();
-                expect(webhookHelper.replaceMessage).toHaveBeenCalledTimes(1);
-                expect(webhookHelper.replaceMessage).toHaveBeenCalledWith(client, message, proxyMessage.message, proxyMessage.member);
-            })
+            await webhookHelper.sendMessageAsMember(client, message);
+            // Assert
+            expect(message.reply).not.toHaveBeenCalled();
+            expect(webhookHelper.replaceMessage).toHaveBeenCalledTimes(1);
+            expect(webhookHelper.replaceMessage).toHaveBeenCalledWith(client, message, proxyMessage.message, proxyMessage.member);
        })

-        test('if replace message throws error, throw same error', async() => {
+        test('if replace message throws error, throw same error and does not call message.reply', async () => {
            // Arrange
            message.guildId = '123';
            messageHelper.parseProxyTags.mockResolvedValue(proxyMessage);
-            jest.spyOn(webhookHelper,  'replaceMessage').mockImplementation(() => {throw new Error("error")});
+            jest.spyOn(webhookHelper, 'replaceMessage').mockRejectedValue(new Error("error"));
            // Act
-            return webhookHelper.sendMessageAsMember(client, message).catch((res) => {
-                // Assert
-                expect(message.reply).not.toHaveBeenCalled();
-                expect(webhookHelper.replaceMessage).toHaveBeenCalledTimes(1);
-                expect(webhookHelper.replaceMessage).toHaveBeenCalledWith(client, message, proxyMessage.message, proxyMessage.member);
-                expect(res).toEqual(new Error('error'));
-            })
+            await expect(webhookHelper.sendMessageAsMember(client, message)).rejects.toThrow("error");
+            // Assert
+            expect(message.reply).not.toHaveBeenCalled();
        })
    })

    describe(`replaceMessage`, () => {
-        const channelId = '123';
-        const authorId = '456';
-        const guildId = '789';
-        const text = "hello";
-        const client = {
-            channels: {
-                get: jest.fn().mockReturnValue(channelId)
-            }
-        }
-        const member = {proxy: "--text", name: 'somePerson', displayname: "Some Person", propic: 'oya.png'};
-        const attachments= {
-            size: 1,
-            first: () => {return channelId;}
-        };
-        const message = {
-            client,
-            channelId: channelId,
-            content: text,
-            attachments: attachments,
-            author: {
-                id: authorId
-            },
-            guild: {
-                guildId: guildId
-            },
-            reply: jest.fn(),
-            delete: jest.fn()
-        }
-
-        const webhook = {
-            send: async() => jest.fn().mockResolvedValue()
-        }

        test('does not call anything if text is 0 or message has no attachments', async() => {
            // Arrange
@@ -192,13 +180,12 @@ describe('webhookHelper', () => {
            message.attachments = noAttachments;
            jest.spyOn(webhookHelper, 'getOrCreateWebhook').mockResolvedValue(webhook);
            // Act
-            return webhookHelper.replaceMessage(client, message, emptyText, member).then(() => {
-                expect(webhookHelper.getOrCreateWebhook).not.toHaveBeenCalled();
-                expect(message.delete).not.toHaveBeenCalled();
-            })
+            await webhookHelper.replaceMessage(client, message, emptyText, member)
+            expect(webhookHelper.getOrCreateWebhook).not.toHaveBeenCalled();
+            expect(message.delete).not.toHaveBeenCalled();
        })

-        test('calls getOrCreateWebhook and message.delete with correct arguments if text >= 0', async() => {
+        test('calls getOrCreateWebhook and message.delete with correct arguments if text > 0 & < 2000', async() => {
            // Arrange
            message.attachments = {
                size: 0,
@@ -207,58 +194,108 @@ describe('webhookHelper', () => {
            };
            jest.spyOn(webhookHelper, 'getOrCreateWebhook').mockResolvedValue(webhook);
            // Act
-            return webhookHelper.replaceMessage(client, message, text, member).then((res) => {
-                // Assert
-                expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledTimes(1);
-                expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledWith(client, channelId);
-                expect(message.delete).toHaveBeenCalledTimes(1);
-                expect(message.delete).toHaveBeenCalledWith();
-            })
+            await webhookHelper.replaceMessage(client, message, text, member);
+            // Assert
+            expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledTimes(1);
+            expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledWith(client, channelId);
+            expect(message.delete).toHaveBeenCalledTimes(1);
+            expect(message.delete).toHaveBeenCalledWith();
        })

-        // TODO: flaky for some reason
-        test('calls getOrCreateWebhook and message.delete with correct arguments if attachments exist', async() => {
+        // TODO: Flaky for some reason. Skipping until attachments are implemented
+        test.skip('calls getOrCreateWebhook and message.delete with correct arguments if attachments exist', async() => {
            // Arrange
            const emptyText = ''
            jest.spyOn(webhookHelper, 'getOrCreateWebhook').mockResolvedValue(webhook);
            // Act
-            return webhookHelper.replaceMessage(client, message, emptyText, member).then((res) => {
-                // Assert
-                expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledTimes(1);
-                expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledWith(client, channelId);
-                expect(message.delete).toHaveBeenCalledTimes(1);
-                expect(message.delete).toHaveBeenCalledWith();
-            })
+            await webhookHelper.replaceMessage(client, message, emptyText, member);
+            // Assert
+            // expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledTimes(1);
+            // expect(webhookHelper.getOrCreateWebhook).toHaveBeenCalledWith(client, channelId);
+            expect(message.delete).toHaveBeenCalledTimes(1);
+            expect(message.delete).toHaveBeenCalledWith();
        })

-        test('calls returnBufferFromText and console error if webhook.send returns error', async() => {
+        test('calls returnBufferFromText if text is more than 2000 characters', async() => {
            // Arrange
+            const text = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbb";
+            message.content = text;
            const file = Buffer.from(text, 'utf-8');
-            const returnedBuffer = {text: text, file: file};
-            const expected2ndSend = {content: returnedBuffer.text, username: member.displayname, avatar_url: member.propic, files: [{name: 'text.txt', data: returnedBuffer.file}]};
-            jest.mock('console', () => ({error: jest.fn()}));
+            const returnedBuffer = {text: 'bbbb', file: file};
+            const expected = {content: returnedBuffer.text, username: member.displayname, avatar_url: member.propic, files: [{name: 'text.txt', data: returnedBuffer.file}]};
+
            jest.spyOn(webhookHelper, 'getOrCreateWebhook').mockResolvedValue(webhook);
-            webhook.send = jest.fn().mockImplementationOnce(async() => {throw new Error('error')});
-            messageHelper.returnBufferFromText = jest.fn().mockResolvedValue(returnedBuffer);
+            webhook.send = jest.fn();
+            messageHelper.returnBufferFromText = jest.fn().mockReturnValue(returnedBuffer);
+
            // Act
-            return webhookHelper.replaceMessage(client, message, text, member).catch((res) => {
-                // Assert
-                expect(messageHelper.returnBufferFromText).toHaveBeenCalledTimes(1);
-                expect(messageHelper.returnBufferFromText).toHaveBeenCalledWith(text);
-                expect(webhook.send).toHaveBeenCalledTimes(2);
-                expect(webhook.send).toHaveBeenNthCalledWith(2, expected2ndSend);
-                expect(console.error).toHaveBeenCalledTimes(1);
-                expect(console.error).toHaveBeenCalledWith(new Error('error'));
-            })
+            await webhookHelper.replaceMessage(client, message, text, member);
+            // Assert
+            expect(messageHelper.returnBufferFromText).toHaveBeenCalledTimes(1);
+            expect(messageHelper.returnBufferFromText).toHaveBeenCalledWith(text);
+            expect(webhook.send).toHaveBeenCalledTimes(1);
+            expect(webhook.send).toHaveBeenCalledWith(expected);
        })
    })

    describe(`getOrCreateWebhook`, () => {
+        let channel;

+        beforeEach(async () => {
+            channel = {
+                createWebhook: jest.fn().mockResolvedValue()
+            }
+            jest.spyOn(webhookHelper, 'getWebhook').mockResolvedValue(webhook);
+        })
+
+        test('throws error if channel does not allow webhooks', async() => {
+            channel.createWebhook = false;
+
+            await expect(webhookHelper.getOrCreateWebhook(client, channel)).rejects.toThrow(enums.err.NO_WEBHOOKS_ALLOWED);
+        })
+
+        test('calls getWebhook if channel allows webhooks and returns webhook', async() => {
+            const res = await webhookHelper.getOrCreateWebhook(client, channel);
+            expect(webhookHelper.getWebhook).toHaveBeenCalledTimes(1);
+            expect(webhookHelper.getWebhook).toHaveBeenCalledWith(client, channel);
+            expect(res).toEqual(webhook);
+        })
+
+        test("calls createWebhook if getWebhook doesn't return webhook", async() => {
+            jest.spyOn(webhookHelper, 'getWebhook').mockResolvedValue();
+            await webhookHelper.getOrCreateWebhook(client, channel);
+            expect(channel.createWebhook).toHaveBeenCalledTimes(1);
+            expect(channel.createWebhook).toHaveBeenCalledWith({name: 'PluralFlux Proxy Webhook'});
+        })
    })

    describe(`getWebhook`, () => {
+        let webhook1, webhook2, channel;
+        beforeEach(() => {
+            webhook1 = {name: 'PluralFlux Proxy Webhook'};
+            webhook2 = {name: 'other webhook'};
+            channel = {
+                fetchWebhooks: jest.fn().mockResolvedValue([webhook1, webhook2])
+            }
+        })

+        test('calls fetchWebhooks and returns correct webhook', async() => {
+            // Act
+            const res = await webhookHelper.getWebhook(client, channel);
+            // Assert
+            expect(res).toEqual(webhook1);
+            expect(channel.fetchWebhooks).toHaveBeenCalledTimes(1);
+            expect(channel.fetchWebhooks).toHaveBeenCalledWith();
+        })
+
+        test('if fetchWebhooks returns no webhooks, return', async() => {
+            // Arrange
+            channel.fetchWebhooks = jest.fn().mockResolvedValue([]);
+            // Act
+            const res = await webhookHelper.getWebhook(client, channel);
+            // Assert
+            expect(res).toBeUndefined();
+        })
    })
Author	SHA1	Message	Date
Aster Fialla	db8f2c59de	adjusted importHelper to properly test throwing of aggregate error	2026-02-24 22:29:03 -05:00
Aster Fialla	dd21ed564b	changed getAllMembersInfo map to say `index` not `name` as it actually gets the index of a member and then the member object	2026-02-24 21:26:42 -05:00
Aster Fialla	d226238e14	adjusted tests to properly use mockRejectedValue for async rejections	2026-02-24 21:08:04 -05:00
Aster Fialla	5050f98e8f	pushes e.message instead of full error object to errors array in importHelper	2026-02-24 20:38:39 -05:00
Aster Fialla	dad80bd385	reversed check for valid proxy (was returning valid if the proxy existed and invalid if it didn't)	2026-02-24 20:38:39 -05:00
Aster Fialla	545136bec7	added default case to memberCommandHandler to throw error if command is not recognized	2026-02-24 20:38:39 -05:00
Aster Fialla	b02937a660	getAllMembersInfo checks for fields.length	2026-02-24 20:38:39 -05:00
Aster Fialla	6d82a067a1	Got rid of unnecessary check for empty message from user (Fluxer doesn't allow this to happen) Removed export of token	2026-02-24 20:38:37 -05:00
Aster Fialla	1d9d9600e5	replaced "pk;" with "pf;" in test	2026-02-24 20:08:52 -05:00
Aster Fialla	c7d5f8a341	made importHelper mock throw error instead of "resolve" error	2026-02-24 20:05:29 -05:00
Aster Fialla	15d2f7d79d	updated console.error message in database.js	2026-02-24 20:02:32 -05:00
Aster Fialla	ba2274e5be	changed commands.js to not have user interaction within the catch	2026-02-24 20:02:11 -05:00
Aster Fialla	de674281f9	make memberCommand exit when error occurs with parseMemberCommand	2026-02-24 19:54:10 -05:00
Aster Fialla	102d694240	Simplify getWebhook to use .find() instead of foreach logic	2026-02-24 19:52:29 -05:00
Aster Fialla	fb878222dd	removed unnecessary try/catch from utils	2026-02-24 19:49:59 -05:00
Aster Fialla	a1e007448f	changed utils to check for 10MB size not 1MB	2026-02-24 19:47:46 -05:00
Aster Fialla	efefcb69f4	added the remaining webhook tests	2026-02-24 18:58:45 -05:00
Aster Fialla	ad783ae6b7	added dash to commands.js and test to pass	2026-02-24 18:48:59 -05:00
Aster Fialla	664295e4a5	refactored database to not use then/catch	2026-02-24 18:12:43 -05:00
Aster Fialla	ded5910a7c	removed jest-fetch-mock since it turns out I was just manually mocking it anyway	2026-02-24 18:06:13 -05:00
Aster Fialla	cdf5c6e537	tested utils checkImageFormatValidity	2026-02-24 18:04:15 -05:00
Aster Fialla	34cb8f3cdb	converted utils.js to not use then/catch	2026-02-24 16:58:56 -05:00
Aster Fialla	8d946ce921	put console.error in commands	2026-02-24 16:58:39 -05:00
Aster Fialla	8919fce34f	removed console.log from import helper	2026-02-24 16:56:03 -05:00
Aster Fialla	15a040d1d1	forgot to switch over some tests in bot.test and commands.test	2026-02-24 16:55:51 -05:00
Aster Fialla	6470b223f6	fixed typo in webhookHelper	2026-02-24 16:41:00 -05:00
Aster Fialla	5d8ff9c6c6	one more test in commands.js, and removed console.error	2026-02-24 16:22:38 -05:00
Aster Fialla	2bf218683a	edited bot to have top level main function	2026-02-24 16:18:40 -05:00
Aster Fialla	8b8cdd6d12	fixed set up for commands tests	2026-02-24 15:57:33 -05:00
Aster Fialla	5a91a529b1	removing then/catch from messageHelper.test.js	2026-02-24 15:47:30 -05:00
Aster Fialla	b36a3ae236	refactoring memberHelper.js and tests to not use then/catch	2026-02-24 15:43:43 -05:00
Aster Fialla	c19614b6a1	refactoring commands.js and tests to not use then/catch	2026-02-24 14:50:46 -05:00
Aster Fialla	b4e4e5a951	refactoring bot and tests to not use then/catch	2026-02-24 14:13:48 -05:00
Aster Fialla	5ba5435d46	changed docstring	2026-02-24 13:56:46 -05:00
Aster Fialla	fc58c47b03	refactor webhookHelper and tests to not use then/catch	2026-02-24 13:56:37 -05:00
Aster Fialla	a0f62763af	Merge branch 'main' of https://github.com/pieartsy/PluralFlux into refactor-async-await # Conflicts: # src/helpers/importHelper.js # tests/helpers/importHelper.test.js	2026-02-24 12:43:52 -05:00
Aster Fialla	8318d715ad	added enum	2026-02-24 12:39:42 -05:00
Aster Fialla	971638bfe3	refactored async/await for import helper to not also use then/catch	2026-02-24 12:39:37 -05:00
Aster Fialla	123aabf650	documentation: adjusted docstrings	2026-02-24 10:37:02 -05:00
Aster Fialla	3c7dfcb72b	update enums	2026-02-23 15:55:01 -05:00
Aster Fialla	9059c63747	mostly finished command tests	2026-02-23 15:54:45 -05:00
Aster Fialla	6937d7b694	made import error not a PDF again	2026-02-23 15:51:12 -05:00
Aster Fialla	e31d9c2881	removed now-unneeded .toJSON() for embeds	2026-02-23 15:20:39 -05:00
Aster Fialla	654338f88e	removed duplicate text from importHelper	2026-02-23 15:11:10 -05:00
Aster Fialla	2a2de70b46	starting commands tests	2026-02-23 15:10:57 -05:00
Aster Fialla	7dfc949b63	separated out commands to be more easily testable and added functionality for aliases	2026-02-23 15:10:48 -05:00
Aster Fialla	bb99ee7ef1	structure for utils test edited a bit	2026-02-23 13:38:38 -05:00
Aster Fialla	088eaaa654	package.lock	2026-02-23 13:36:58 -05:00
Aster Fialla	a2746a25f9	updated enums	2026-02-23 13:36:40 -05:00
Aster Fialla	daf23b2f5d	adding import tests	2026-02-23 13:36:31 -05:00
Aster Fialla	813e893afb	more accurate framework for utils tests	2026-02-23 12:30:40 -05:00
Aster Fialla	10c145a02d	imported env files better	2026-02-23 12:27:25 -05:00
Aster Fialla	6638756a9a	replaced reference to [text] in proxy command instructions so it's clearer in contrast to the instructions to type without brackets	2026-02-23 12:01:07 -05:00
Aster Fialla	df60ec489b	updated package.json	2026-02-23 11:56:35 -05:00
Aster Fialla	79f0f19733	adjusted bot.test mock	2026-02-23 11:50:50 -05:00
Aster Fialla	91e98f2434	fixed bug with memberHelper not processing attached URL	2026-02-23 11:35:01 -05:00
Aster Fialla	c752ee2bf2	Revert "adding debounce" cus it's not working This reverts commit `1d27db960c`. # Conflicts: # src/bot.js	2026-02-23 11:19:26 -05:00
Aster Fialla	bfb5bf9cbb	testing bot login, added invoke for login	2026-02-23 10:47:02 -05:00
Aster Fialla	a2bd7b755c	testing bot.js handleMessageCreate	2026-02-23 10:38:04 -05:00
Aster Fialla	0f65db2d42	add frameworks for other tests	2026-02-23 09:00:48 -05:00
Aster Fialla	da79db856a	removed unneeded imports from messageHelper tests	2026-02-23 08:59:56 -05:00
Aster Fialla	50c41990ed	removed unused argument from bot call to sendMessageAsMember	2026-02-23 08:59:32 -05:00
Aster Fialla	1d27db960c	adding debounce	2026-02-23 08:47:27 -05:00
Aster Fialla	264c3e19fd	removing some unused imports in messageHelper	2026-02-23 08:44:50 -05:00
Aster Fialla	0a1652f243	updated docstrings	2026-02-23 08:02:30 -05:00
Aster Fialla	580a0cb42e	renaming test interpolation to be less silly	2026-02-23 07:53:03 -05:00
Aster Fialla	71c8736a38	added to docstring	2026-02-23 00:18:57 -05:00
Aster Fialla	d9530a2ccf	structure and test revamp for memberHelper	2026-02-23 00:18:14 -05:00
Aster Fialla	72ec047f48	test frame for utils	2026-02-22 21:40:53 -05:00
Aster Fialla	be24034d48	updating tests and memberHelper to try and make parseMemberCommand less bloated/broken (not working ATM)	2026-02-22 21:40:42 -05:00
Aster Fialla	c3e7bf4433	updated enums	2026-02-22 18:48:52 -05:00
Aster Fialla	7dae9f52b1	fixed call to getMemberInfo to not include authorId	2026-02-22 18:32:47 -05:00
Aster Fialla	630ce7888c	adjusted parsing logic to not try and call member when none exists (due to "new" command)	2026-02-22 18:06:18 -05:00
Aster Fialla	b88b9252be	forgot to import enums into utils	2026-02-22 17:09:02 -05:00
Aster Fialla	79cfc1563d	add license	2026-02-22 12:03:44 -05:00
Aster Fialla	fa4ca779ee	accidental error with memberHelper not allowing pf;member fixed	2026-02-22 11:52:51 -05:00
Aster Fialla	eb7340faf7	finished relevant tests for memberHelper	2026-02-22 11:24:57 -05:00
Aster Fialla	d4adbc028a	typo not importing utils right	2026-02-22 09:54:01 -05:00
Aster Fialla	57336b4e58	added to enums	2026-02-21 23:05:59 -05:00
Aster Fialla	71803fd10c	made utils file	2026-02-21 23:05:15 -05:00
Aster Fialla	cc8cb6e925	write more tests for addNewMember	2026-02-21 23:05:01 -05:00
Aster Fialla	a797e9e06d	write more tests for parseMemberCommand	2026-02-21 21:37:57 -05:00
Aster Fialla	4146591c90	figured out issue (was missing return value)	2026-02-21 20:09:39 -05:00
Aster Fialla	0bca359b7f	trying to get refactored memberhelper to pass tests -_-	2026-02-20 11:28:28 -05:00
Aster Fialla	932fc9c967	update getMemberCommandInfo	2026-02-20 11:03:50 -05:00
Aster Fialla	cd01473121	update enums	2026-02-20 11:00:57 -05:00
Aster Fialla	c133ee2c42	refactored memberHelper	2026-02-20 11:00:21 -05:00
Aster Fialla	f055518b1f	Merge branch 'main' into add-tests # Conflicts: # README.md	2026-02-20 10:02:13 -05:00
Aster Fialla	3ed24458e0	Merge branch 'main' of https://github.com/pieartsy/PluralFlux into add-tests	2026-02-19 21:44:07 -05:00
Aster Fialla	a30d408c02	Merge branch 'main' of https://github.com/pieartsy/PluralFlux into add-tests	2026-02-19 21:41:59 -05:00
Aster Fialla	e9052624d4	Merge branch 'main' of https://github.com/pieartsy/PluralFlux into add-tests	2026-02-19 21:41:29 -05:00
Aster Fialla	4d3db8c001	updated documentation	2026-02-19 21:38:10 -05:00
Aster Fialla	eb6c60618b	added nicer error listing to importHelper	2026-02-19 21:38:03 -05:00
Aster Fialla	b64ba6e787	made it easier to make a member	2026-02-19 21:36:19 -05:00
Aster Fialla	d640322392	removed unnecessary await and console.log	2026-02-19 20:32:35 -05:00
Aster Fialla	b1a29fd3ff	edit enums, tweak import content command	2026-02-19 20:30:55 -05:00
Aster Fialla	e7198230a7	updated member helper and tests	2026-02-19 20:08:26 -05:00
Aster Fialla	fad6d42ee2	updated to be enum	2026-02-19 19:32:37 -05:00
Aster Fialla	c4c6ad0fdd	fixed bug for import not sending help text, added help text if you type a unrecognized command	2026-02-19 19:31:56 -05:00
Aster Fialla	1e2724bbfb	update bot to suppress errors from API	2026-02-19 19:13:54 -05:00
Aster Fialla	849acf7275	update message helper test to include space case	2026-02-19 18:54:35 -05:00
Aster Fialla	7a3b8c1994	edited help message trigger for updatePropic	2026-02-19 01:45:43 -05:00
Aster Fialla	2e0a8adec5	added tests for updateDisplayName	2026-02-19 01:31:38 -05:00
Aster Fialla	7aeae1837f	added todo note	2026-02-19 00:59:57 -05:00
Aster Fialla	6eb9fef376	added debounce to count guilds properly	2026-02-19 00:52:06 -05:00
Aster Fialla	9dab429d0d	, updated tests for webhookHelper and removed error response when proxy is sent without content	2026-02-19 00:51:33 -05:00
Aster Fialla	f9199f8477	removed error response when proxy is sent without content	2026-02-19 00:48:57 -05:00
Aster Fialla	a7cd4e96f0	updating enums	2026-02-19 00:20:53 -05:00
Aster Fialla	21efbccfd7	adding more cases to messageHelper tests	2026-02-19 00:20:46 -05:00
Aster Fialla	873959a5f4	finally mocking correctly	2026-02-18 21:24:41 -05:00
Aster Fialla	d33c3213f3	removed confusing brackets from enum docs	2026-02-18 21:20:56 -05:00
Aster Fialla	75c4c548d8	deleted extra file added during merge	2026-02-18 21:13:25 -05:00
Aster Fialla	9d5493e8ab	Merge remote-tracking branch 'origin/add-tests' into add-tests # Conflicts: # src/bot.js # src/commands.js # src/database.js # src/helpers/importHelper.js # src/helpers/memberHelper.js # src/helpers/messageHelper.js # src/helpers/webhookHelper.js	2026-02-18 21:03:44 -05:00
Aster Fialla	fc1c463696	more tests for webhookhelper	2026-02-18 17:14:04 -05:00
Aster Fialla	1bba8099e9	updating docstring for messageHelper parseProxyTags	2026-02-18 16:29:08 -05:00
Aster Fialla	acd9ce7c3e	more cases for messageHelper just in case	2026-02-18 16:28:35 -05:00
Aster Fialla	da9a3d2c8a	finished tests for messageHelper!	2026-02-18 12:37:39 -05:00
Aster Fialla	274f1ead15	added "return" so tests dont terminate on failure and deleted env.jest	2026-02-18 12:11:55 -05:00
Aster Fialla	223292c2d3	added tests for parseProxyTags and updated logic	2026-02-18 10:17:08 -05:00
Aster Fialla	400e40a405	updated sendMessageAsAttachment to returnBufferFromText and updated commands/webhookHelper accordingly	2026-02-18 09:19:44 -05:00
Aster Fialla	152bc8873d	added test for memberHelper	2026-02-18 09:16:26 -05:00
Aster Fialla	e16694ac2d	fixed test and logic	2026-02-18 08:47:37 -05:00
Aster Fialla	f0ac02e86d	readded line i shouldn't have removed in sendMessageAsMember	2026-02-18 00:33:05 -05:00
Aster Fialla	5c01f2e284	test setup for messagehelper and webhookhelper	2026-02-18 00:28:18 -05:00
Aster Fialla	da5a250445	added return to addFullMember so that addNewMember can reference it properly in strings	2026-02-18 00:27:51 -05:00
Aster Fialla	23a57b3e99	simplified sendMessageAsAttachment	2026-02-18 00:26:51 -05:00
Aster Fialla	1bf6c8c1f2	think i fixed weird error with webhook sending error when a user has no members	2026-02-18 00:25:41 -05:00
Aster Fialla	fe00f66104	more tests for member helper	2026-02-17 23:03:45 -05:00
Aster Fialla	15703c24cd	moved import to helpers folder	2026-02-17 23:03:19 -05:00
Aster Fialla	3dbbe7df50	moved import to helpers folder	2026-02-17 23:03:08 -05:00
Aster Fialla	31eb4262dd	upgraded fluxer.js	2026-02-17 22:23:55 -05:00
Aster Fialla	c645bb0aea	renamed db to database more tests and fixing logic for memberhelper	2026-02-17 22:23:47 -05:00
Aster Fialla	0b7f549bdf	added error handling parseMemberCommand test	2026-02-17 21:21:07 -05:00
Aster Fialla	bfc633a755	setup fixed more	2026-02-17 20:52:22 -05:00
Aster Fialla	01e620a935	finally figured out issue with tests (referencing the method directly in the test.each calls the real method not the mock in beforeEach())	2026-02-17 20:49:19 -05:00
Aster Fialla	a4804c2ea7	added babel to convert es modules to cjs	2026-02-17 20:48:44 -05:00
Aster Fialla	164ff7d8b6	nevermind it wasn't actually working, gonna move on for now	2026-02-17 19:58:56 -05:00
Aster Fialla	5e3b3f33d3	mostly working except for the weirdest error	2026-02-17 19:38:50 -05:00
Aster Fialla	4fcb53482c	separating out enum return from method return	2026-02-17 19:36:14 -05:00
Aster Fialla	ba9552b4aa	updated jest to sort of work with es6	2026-02-17 17:38:06 -05:00
Aster Fialla	35b454bc80	Revert "converted import syntax to commonJS" This reverts commit `5ab0d62b`	2026-02-17 17:25:18 -05:00
Aster Fialla	321fe7f0a9	more correct dockerfile and compose.yaml	2026-02-17 17:16:48 -05:00
Aster Fialla	0a4bfa59ad	more correct test setup	2026-02-17 17:16:10 -05:00
Aster Fialla	79d98c3618	adjusted beforeeach/beforeall so more pass	2026-02-17 17:16:10 -05:00
Aster Fialla	a44e2745c5	got test sort of working (jest set up is not crashing but also not mocking correctly)	2026-02-17 17:16:10 -05:00
Aster Fialla	5ab0d62bdb	converted import syntax to commonJS removed unused methods	2026-02-17 17:16:09 -05:00
Aster Fialla	876f9486ad	more correct test setup	2026-02-17 07:14:47 -05:00
Aster Fialla	5e28cdfd01	adjusted beforeeach/beforeall so more pass	2026-02-17 07:11:22 -05:00
Aster Fialla	5a39610547	got test sort of working (jest set up is not crashing but also not mocking correctly)	2026-02-16 18:46:33 -05:00
Aster Fialla	a3caa2dc42	converted import syntax to ES modules removed unused methods	2026-02-16 18:46:32 -05:00