Update Docker image for pluralflux service

* refactored async/await for import helper to not also use then/catch

* added enum

* refactor webhookHelper and tests to not use then/catch

* changed docstring

* refactoring bot and tests to not use then/catch

* refactoring commands.js and tests to not use then/catch

* refactoring memberHelper.js and tests to not use then/catch

* removing then/catch from messageHelper.test.js

* fixed set up for commands tests

* edited bot to have top level main function

* one more test in commands.js, and removed console.error

* fixed typo in webhookHelper

* forgot to switch over some tests in bot.test and commands.test

* removed console.log from import helper

* put console.error in commands

* converted utils.js to not use then/catch

* tested utils checkImageFormatValidity

* removed jest-fetch-mock since it turns out I was just manually mocking it anyway

* refactored database to not use then/catch

* added dash to commands.js and test to pass

* added the remaining webhook tests

* changed utils to check for 10MB size not 1MB

* removed unnecessary try/catch from utils

* Simplify getWebhook to use .find() instead of foreach logic

* make memberCommand exit when error occurs with parseMemberCommand

* changed commands.js to not have user interaction within the catch

* updated console.error message in database.js

* made importHelper mock throw error instead of "resolve" error

* replaced "pk;" with "pf;" in test

* Got rid of unnecessary check for empty message from user (Fluxer doesn't allow this to happen)

Removed export of token

* getAllMembersInfo checks for fields.length

* added default case to memberCommandHandler to throw error if command is not recognized

* reversed check for valid proxy (was returning valid if the proxy existed and invalid if it didn't)

* pushes e.message instead of full error object to errors array in importHelper

* adjusted tests to properly use mockRejectedValue for async rejections

* changed getAllMembersInfo map to say `index` not `name` as it actually gets the index of a member and then the member object

* adjusted importHelper to properly test throwing of aggregate error

* revamped setting of expiration warning (moved to utils and changed logic, wrote tests)

---------

Co-authored-by: Aster Fialla <asterfialla@gmail.com>

compose.yaml

@@ -1,21 +1,18 @@
 services:
   main:
-    build: .
+    image: engineering.sanya.gay/pluralflux/pluralflux
     container_name: pluralflux
     restart: unless-stopped
     networks:
       - pluralflux-net
+    env_file: "variables.env"
   postgres:
     image: postgres:latest
     container_name: pluralflux-postgres
-    environment:
-      POSTGRES_PASSWORD_FILE: /run/secrets/postgres_pwd
-    secrets:
-      - postgres_pwd
+    env_file: "variables.env"
     volumes:
       - pgdata:/var/lib/postgresql
-    ports:
-      - "5432:5432"
+      - ./pgBackup:/mnt/pgBackup
     networks:
       - pluralflux-net
   pgadmin:
@@ -23,24 +20,19 @@ services:
     container_name: pluralflux-pgadmin
     ports:
       - "5050:80"
-    environment:
-      PGADMIN_DEFAULT_EMAIL: code@asterfialla.com
-      PGADMIN_DEFAULT_PASSWORD_FILE: /run/secrets/postgres_pwd
-      PGADMIN_CONFIG_SERVER_MODE: 'False'
-      PGADMIN_CONFIG_MASTER_PASSWORD_REQUIRED: 'False'
-    secrets:
-      - postgres_pwd
+    env_file: "variables.env"
     depends_on:
       - postgres
     networks:
       - pluralflux-net
-
+    volumes:
+      - pgadmindata:/var/lib/pgadmin
+      #- ./pgBackup:/mnt/host
+      # uncomment the above line if you plan to restore / backup dump files from PGAdmin UI
 networks:
   pluralflux-net:
+    driver: bridge
 
 volumes:
   pgdata:
-
-secrets:
-  postgres_pwd:
-    file: ./secrets/postgres-password.txt
+  pgadmindata:

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",

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"

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();

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;

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;

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 = {
@@ -43,7 +44,10 @@ helperEnums.help = {
 }
 
 helperEnums.misc = {
-    ATTACHMENT_SENT_BY: "Attachment sent by:"
+    ATTACHMENT_SENT_BY: "Attachment sent by:",
+    ATTACHMENT_EXPIRATION_WARNING: "**NOTE:** Because this profile picture is hosted on Fluxer, it will expire. To avoid this, upload the picture to another website like <https://imgbb.com/> and link to it directly.",
+    FLUXER_ATTACHMENT_URL: "https://fluxerusercontent.com/attachments/"
+
 }
 
 export const enums = helperEnums;

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;

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 });
-
-    return await mh.updateMemberField(authorId, memberName, "propic", imgUrl, attachmentExpiration).catch((e) => { throw e });
+    await utils.checkImageFormatValidity(imgUrl);
+    const expirationWarning = utils.setExpirationWarning(imgUrl, attachmentExpiration);
+    return await mh.updateMemberField(authorId, memberName, "propic", imgUrl, expirationWarning);
 }
 
 /**
@@ -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,28 +353,31 @@ 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));
+    const expirationWarning = utils.setExpirationWarning(propic, attachmentExpiration);
+    if (expirationWarning) {
+        errors.push(expirationWarning);
     }
     const member = await database.members.create({
         name: memberName, userid: authorId, displayname: isValidDisplayName ? displayName : null, proxy: isValidProxy ? proxy : null, propic: isValidPropic ? propic : null
@@ -404,42 +394,21 @@ mh.addFullMember = async function (authorId, memberName, displayName = null, pro
  * @param {string} memberName - The member to update
  * @param {string} columnName - The column name to update.
  * @param {string} value - The value to update to.
- * @param {string | null} [attachmentExpiration] - The attachment expiration date (if any)
+ * @param {string | null} [expirationWarning] - The attachment expiration warning (if any)
  * @returns {Promise<string>} A successful update.
  * @throws {Error} When no member row was updated.
  */
-mh.updateMemberField = async function (authorId, memberName, columnName, value, attachmentExpiration = null) {
-    let fluxerPropicWarning;
-
-    // indicates that an attachment was uploaded on Fluxer directly
-    if (columnName === "propic" && attachmentExpiration) {
-        fluxerPropicWarning = mh.setExpirationWarning(value);
-    }
-    return await database.members.update({[columnName]: value}, {
+mh.updateMemberField = async function (authorId, memberName, columnName, value, expirationWarning = null) {
+    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 ?? ''}.`;
-            }
     })
-}
-
-/**
- * Sets the warning for an expiration date.
- *
- * @param {string} expirationString - An expiration date string.
- * @returns {string} A description of the expiration, interpolating the expiration string.
- */
-mh.setExpirationWarning = function (expirationString) {
-    let expirationDate = new Date(expirationString);
-    if (!isNaN(expirationDate.valueOf())) {
-        expirationDate = expirationDate.toDateString();
-        return `\n**NOTE:** Because this profile picture was uploaded via Fluxer, it will currently expire on *${expirationDate}*. To avoid this, upload the picture to another website like <https://imgbb.com/> and link to it directly`
+    if (res[0] === 0) {
+        throw new Error(`Can't update ${memberName}. ${enums.err.NO_MEMBER}.`);
+    } else {
+        return `Updated ${columnName} for ${memberName} to ${value}${expirationWarning ? `. ${expirationWarning}.` : '.'}`;
     }
 }
 
@@ -472,12 +441,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 +486,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;
 }
 

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);

src/helpers/utils.js

@@ -15,15 +15,43 @@ 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;
+}
+
+/**
+ * Sets the warning that a Fluxer-uploaded image will expire.
+ *
+ * @param {string | null} [imgUrl] - An image URL.
+ * @param {string | null} [expirationString] - An expiration date string.
+ * @returns {string | null} A description of the expiration, or null.
+ */
+u.setExpirationWarning = function (imgUrl = null, expirationString = null) {
+    if (imgUrl && imgUrl.startsWith(enums.misc.FLUXER_ATTACHMENT_URL)) {
+        return enums.misc.ATTACHMENT_EXPIRATION_WARNING;
+    }
+    else if (expirationString) {
+        let expirationDate = new Date(expirationString);
+        if (!isNaN(expirationDate.valueOf())) {
+            return `${enums.misc.ATTACHMENT_EXPIRATION_WARNING}. Expiration date: *${expirationString}*.`;
+        }
+    }
+    return null;
 }
 
 export const utils = u;

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;

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)

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'));
         })
     })
 

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

tests/helpers/memberHelper.test.js

@@ -39,7 +39,7 @@ describe('MemberHelper', () => {
         name: "somePerson",
         displayname: "Some Person",
         proxy: "--text",
-        propic: attachmentUrl
+        propic: 'ono.png'
     }
 
     beforeEach(() => {
@@ -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,109 +400,113 @@ 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);
         })
     })
 
     describe('updatePropic', () => {
         test.each([
-            [null, attachmentUrl, null, attachmentUrl],
-            [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) => {
+            [null, attachmentUrl, undefined, attachmentUrl],
+            [mockMember.propic, null, undefined, mockMember.propic],
+            [mockMember.propic, attachmentUrl, undefined, mockMember.propic],
+        ])('calls checkImageFormatValidity and updateMemberField and returns string', async (imgUrl, attachmentUrl, attachmentExpiration, expected) => {
             // Arrange
-
             jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
+            utils.setExpirationWarning = jest.fn().mockReturnValue(undefined);
             // 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, undefined);
+        })
+
+        test('calls setExpirationWarning', async() => {
+            // Arrange
+            jest.spyOn(memberHelper, 'updateMemberField').mockResolvedValue("Updated");
+            utils.setExpirationWarning = jest.fn().mockReturnValue(enums.misc.ATTACHMENT_EXPIRATION_WARNING);
+            // Act
+            const result = await memberHelper.updatePropic(authorId, mockMember.name, null, attachmentUrl, attachmentExpiration);
+            // Assert
+            expect(result).toEqual("Updated");
+            expect(utils.setExpirationWarning).toHaveBeenCalledTimes(1);
+            expect(utils.setExpirationWarning).toHaveBeenCalledWith(attachmentUrl, attachmentExpiration);
+            expect(memberHelper.updateMemberField).toHaveBeenCalledTimes(1);
+            expect(memberHelper.updateMemberField).toHaveBeenCalledWith(authorId, mockMember.name, "propic", attachmentUrl, enums.misc.ATTACHMENT_EXPIRATION_WARNING);
         })
     })
 
     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 +527,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 +574,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 +588,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 +618,27 @@ 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('calls setExpirationWarning if attachmentExpiration exists', async () => {
+            // Arrange
+            utils.checkImageFormatValidity = jest.fn().mockResolvedValue(true);
+            jest.spyOn(memberHelper, 'setExpirationWarning').mockReturnValue(`${enums.misc.ATTACHMENT_EXPIRATION_WARNING}`);
+            // Act
+            await memberHelper.addFullMember(authorId, mockMember.name, null, null, mockMember.propic, attachmentExpiration)
+            // Assert
+            expect(memberHelper.setExpirationWarning).toHaveBeenCalledTimes(1);
+            expect(memberHelper.setExpirationWarning).toHaveBeenCalledWith(mockMember.propic, attachmentExpiration);
         })
 
         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 +647,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);
         })
 
     })
@@ -686,42 +668,34 @@ 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);
-            })
-        })
-
         test.each([
-            ['name', mockMember.name, null, `Updated name for ${mockMember.name} to ${mockMember.name}`],
-            ['displayname', mockMember.displayname, null, `Updated name for ${mockMember.name} to ${mockMember.displayname}`],
-            ['proxy', mockMember.proxy, null, `Updated name for ${mockMember.name} to ${mockMember.proxy}`],
-            ['propic', mockMember.propic, null, `Updated name for ${mockMember.name} to ${mockMember.propic}`],
-            ['propic', mockMember.propic, 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
-                    }
-                })
+            ['name', mockMember.name, undefined, `Updated name for ${mockMember.name} to ${mockMember.name}.`],
+            ['displayname', mockMember.displayname, undefined, `Updated displayname for ${mockMember.name} to ${mockMember.displayname}.`],
+            ['proxy', mockMember.proxy, undefined, `Updated proxy for ${mockMember.name} to ${mockMember.proxy}.`],
+            ['propic', mockMember.propic, undefined, `Updated propic for ${mockMember.name} to ${mockMember.propic}.`],
+            ['propic', mockMember.propic,
+                'warning', `Updated propic for ${mockMember.name} to ${mockMember.propic}. warning.`]
+        ])('calls database.members.update with correct column and value and return string', async (columnName, value, attachmentExpiration, expected) => {
+            // Act
+            const res = await memberHelper.updateMemberField(authorId, mockMember.name, columnName, value, attachmentExpiration)
+            // Assert
+            expect(res).toEqual(expected);
+            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 +716,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(() => {

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);
         });
     })
 

tests/helpers/utils.test.js

@@ -1,15 +1,86 @@
 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';
+    const expirationString = new Date("2026-01-01").toDateString();
+    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);
+        })
+    })
+
+    describe('setExpirationWarning', () => {
+        test('sets warning if image Url starts with Fluxer host', () => {
+            // Act
+            const result = utils.setExpirationWarning(`${enums.misc.FLUXER_ATTACHMENT_URL}${attachmentUrl}`);
+            // Assert
+            expect(result).toEqual(enums.misc.ATTACHMENT_EXPIRATION_WARNING);
+        })
+
+        test('sets warning if expiration string exists', () => {
+            const result = utils.setExpirationWarning(null, expirationString);
+            // Assert
+            expect(result).toEqual(`${enums.misc.ATTACHMENT_EXPIRATION_WARNING}. Expiration date: *${expirationString}*.`);
+        })
+
+       test('returns null if img url does not start iwth fluxer host and no expiration', () => {
+           // Act
+           const result = utils.setExpirationWarning(attachmentUrl);
+           // Assert
+           expect(result).toBeNull();
+       })
     })
 
     afterEach(() => {

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();
+        })
     })