feat: Add unit tests (#21)

Tests are mostly complete (though some are failing -- to be fixed in the
async/await refactor.

Also refactored, fixed bugs found while testing, and added ability to
type `pf;m` instead of `pf;member`.

---------

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

tests/bot.test.js

@@ -0,0 +1,322 @@
+const env = require('dotenv').config({path: './.env.jest'})
+const {enums} = require("../src/enums.js");
+
+jest.mock('@fluxerjs/core', () => {
+    return {
+        Events: {
+            MessageCreate: jest.fn(),
+            Ready: jest.fn(),
+            GuildCreate: jest.fn(),
+        },
+        Client: jest.fn().mockImplementation(() => {
+            return {
+                on: jest.fn(),
+                intents: 0,
+                login: jest.fn()
+            }
+        }),
+        Message: jest.fn()
+    };
+});
+
+jest.mock("../src/helpers/messageHelper.js", () => {
+    return {
+        messageHelper: {
+            parseCommandArgs: jest.fn(),
+            prefix: "pf;"
+        }
+    }
+});
+
+jest.mock("../src/helpers/webhookHelper.js", () => {
+    return {
+        webhookHelper: {
+            sendMessageAsMember: jest.fn()
+        }
+    }
+})
+jest.mock("../src/helpers/utils.js", () => {
+    return {
+        utils: {
+            debounce: jest.fn()
+        }
+    }
+})
+
+jest.mock("../src/commands.js", () => {
+    return {
+        commands: {
+            commandsMap: {
+                get: jest.fn(),
+            },
+            aliasesMap: {
+                get: jest.fn()
+            }
+        }
+    }
+})
+
+
+const {Client, Events} = require('@fluxerjs/core');
+const {messageHelper} = require("../src/helpers/messageHelper.js");
+
+const {commands} = require("../src/commands.js");
+const {webhookHelper} = require("../src/helpers/webhookHelper.js");
+
+const {utils} = require("../src/helpers/utils.js");
+let {handleMessageCreate, client} = require("../src/bot.js");
+
+describe('bot', () => {
+    beforeEach(() => {
+        jest.resetModules();
+        jest.clearAllMocks();
+    })
+
+    describe('handleMessageCreate', () => {
+
+        test('on message creation, if message is from bot, return', () => {
+            // Arrange
+            const message = {
+                author: {
+                    bot: true
+                }
+            }
+            // Act
+            return handleMessageCreate(message).then((res) => {
+                expect(res).toBe(undefined);
+            });
+        })
+
+        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", () => {
+            // Arrange
+            webhookHelper.sendMessageAsMember.mockResolvedValue();
+            const message = {
+                content: "hello",
+                author: {
+                    bot: false
+                }
+            }
+            // Act
+            return handleMessageCreate(message).then(() => {
+                // Assert
+                expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledTimes(1);
+                expect(webhookHelper.sendMessageAsMember).toHaveBeenCalledWith(client, message)
+            });
+        })
+
+        test("if sendMessageAsMember returns error, log error", () => {
+            // Arrange
+            webhookHelper.sendMessageAsMember.mockImplementation(() => {
+                throw Error("error")
+            });
+            const message = {
+                content: "hello",
+                author: {
+                    bot: false
+                }
+            }
+            jest.mock('console', () => {
+                return {error: jest.fn()}
+            })
+            // 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'))
+            });
+        })
+
+        test("if no command after prefix, return correct enum", () => {
+            // Arrange
+            const message = {
+                content: "pf;",
+                author: {
+                    bot: false
+                },
+                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();
+            });
+        })
+
+        test("if command after prefix, call parseCommandArgs and commandsMap.get", () => {
+            // Arrange
+            const message = {
+                content: "pf;help",
+                author: {
+                    bot: false
+                },
+                reply: jest.fn()
+            }
+            const command = {
+                execute: jest.fn().mockResolvedValue(),
+            }
+            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();
+            });
+        })
+
+        test('if commands.commandsMap.get returns undefined, call aliasesMap.get and commandsMap.get again with that value', () => {
+            // Arrange
+            const message = {
+                content: "pf;m",
+                author: {
+                    bot: false
+                },
+                reply: jest.fn()
+            }
+            const mockAlias = {
+                command: 'member'
+            }
+            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');
+            });
+        })
+
+
+        test('if aliasesMap.get returns undefined, do not call commandsMap again', () => {
+            // Arrange
+            const message = {
+                content: "pf;m",
+                author: {
+                    bot: false
+                },
+                reply: jest.fn()
+            }
+            const mockAlias = {
+                command: 'member'
+            }
+            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');
+            });
+        })
+
+        test("if command exists, call command.execute", () => {
+            // Arrange
+            const message = {
+                content: "pf;member test",
+                author: {
+                    bot: false
+                },
+                reply: jest.fn()
+            }
+            const command = {
+                execute: jest.fn()
+            }
+            messageHelper.parseCommandArgs = jest.fn().mockReturnValue(['test']);
+            commands.commandsMap.get = jest.fn().mockReturnValue(command);
+            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);
+            });
+        })
+    })
+
+    test('calls client.login with correct argument', () => {
+        // Act
+        client.login = jest.fn().mockResolvedValue();
+        // Assert
+        expect(client.login).toHaveBeenCalledTimes(1);
+        expect(client.login).toHaveBeenCalledWith(process.env.FLUXER_BOT_TOKEN)
+    })
+
+    afterEach(() => {
+        // restore the spy created with spyOn
+        jest.restoreAllMocks();
+    });
+})

tests/commands.test.js

@@ -0,0 +1,183 @@
+import {enums} from "../src/enums.js";
+
+jest.mock("../src/helpers/messageHelper.js", () => {
+    return {
+        messageHelper: {
+            returnBufferFromText: jest.fn(),
+            prefix: 'pf;'
+        }
+    }
+})
+
+jest.mock('../src/helpers/memberHelper.js', () => {
+    return {
+        memberHelper: {
+            parseMemberCommand: jest.fn()
+        }
+    }
+})
+
+jest.mock('../src/helpers/importHelper.js', () => {
+    return {
+        importHelper: {
+            pluralKitImport: jest.fn()
+        }
+    }
+})
+jest.mock('console', () => {
+    return {error: jest.fn()}
+})
+
+import {messageHelper, prefix} from "../src/helpers/messageHelper.js";
+
+import {memberHelper} from "../src/helpers/memberHelper.js";
+import {EmbedBuilder} from "@fluxerjs/core";
+import {importHelper} from "../src/helpers/importHelper.js";
+import {commands} from "../src/commands.js";
+
+
+describe('commands', () => {
+    const authorId = '123';
+    const discriminator = '123';
+    const username = 'somePerson'
+    const attachmentUrl = 'oya.png';
+    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(),
+    }
+    const args = ['new']
+
+    beforeEach(() => {
+
+        jest.resetModules();
+        jest.clearAllMocks();
+    })
+
+    describe('memberCommand', () => {
+
+
+        test('calls parseMemberCommand with the correct arguments', () => {
+            // 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);
+            });
+        })
+
+        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 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 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]})
+            });
+        })
+    })
+
+    describe('importCommand', () => {
+        test('if message includes --help and no attachmentURL, return help message', () => {
+            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();
+            })
+        })
+
+        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.', () => {
+            // 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' }],});
+            })
+        })
+    })
+
+    afterEach(() => {
+        // restore the spy created with spyOn
+        jest.restoreAllMocks();
+    });
+})

tests/helpers/importHelper.test.js

@@ -0,0 +1,100 @@
+const {enums} = require('../../src/enums.js');
+const fetchMock = require('jest-fetch-mock');
+
+jest.mock('../../src/helpers/memberHelper.js', () => {
+    return {
+        memberHelper: {
+            addFullMember: jest.fn()
+        }
+    }
+})
+
+fetchMock.enableMocks();
+const {memberHelper} = require("../../src/helpers/memberHelper.js");
+const {importHelper} = require('../../src/helpers/importHelper.js');
+
+describe('importHelper', () => {
+    const authorId = '123';
+    const attachmentUrl = 'system.json';
+    const mockImportedMember = {
+        proxy_tags: [{
+            prefix: "SP{",
+            suffix: "}"
+        }],
+            display_name: "SomePerson",
+        avatar_url: 'oya.png',
+        name: 'somePerson'
+    }
+    const mockData = {
+        members: [mockImportedMember]
+    };
+    const mockAddReturnMember = {
+        proxy: "SP{text}",
+        displayname: "SomePerson",
+        propic: 'oya.png',
+        name: 'somePerson'
+    }
+    const mockAddReturn = {
+        member: mockAddReturnMember,
+        errors: []
+    }
+
+    beforeEach(() => {
+        global.fetch = jest.fn();
+        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 attachment URL, calls fetch and addFullMember and returns value', () => {
+            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}`)
+            })
+        })
+
+        test('if addFullMember returns nothing, return correct enum', () => {
+            memberHelper.addFullMember.mockResolvedValue();
+            return importHelper.pluralKitImport(authorId, attachmentUrl).catch((res) => {
+                expect(res).toEqual(new 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 returns member but also contains error, return member and error', () => {
+            // 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}`))
+            })
+        })
+
+    })
+
+    afterEach(() => {
+        // restore the spy created with spyOn
+        jest.clearAllMocks();
+    });
+})

tests/helpers/messageHelper.test.js

@@ -1,11 +1,6 @@
 const env = require('dotenv');
 env.config();
 
-const {memberHelper} = require("../../src/helpers/memberHelper.js");
-const {Message} = require("@fluxerjs/core");
-const {fs} = require('fs');
-const {enums} = require('../../src/enums');
-const {tmp, setGracefulCleanup} = require('tmp');
 
 jest.mock('../../src/helpers/memberHelper.js', () => {
     return {memberHelper: {
@@ -13,10 +8,7 @@ jest.mock('../../src/helpers/memberHelper.js', () => {
     }}
 })
 
-jest.mock('tmp');
-jest.mock('fs');
-jest.mock('@fluxerjs/core');
-
+const {memberHelper} = require("../../src/helpers/memberHelper.js");
 const {messageHelper} = require("../../src/helpers/messageHelper.js");
 
 describe('messageHelper', () => {

tests/helpers/utils.test.js

@@ -0,0 +1,19 @@
+const {enums} = require("../../src/enums");
+
+const fetchMock = require('jest-fetch-mock');
+fetchMock.enableMocks();
+
+const {utils} = require("../../src/helpers/utils.js");
+
+describe('utils', () => {
+
+    beforeEach(() => {
+        jest.resetModules();
+        jest.clearAllMocks();
+    })
+
+    afterEach(() => {
+        // restore the spy created with spyOn
+        jest.restoreAllMocks();
+    });
+})