mirror of
https://github.com/pieartsy/PluralFlux.git
synced 2026-04-14 20:15:28 +10:00
refactor: Removing then/catch from async/await calls (#22)
* 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>
This commit is contained in:
GitHub
@@ -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)
|
||||
|
||||
@@ -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'));
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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(() => {
|
||||
|
||||
@@ -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);
|
||||
});
|
||||
})
|
||||
|
||||
|
||||
@@ -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(() => {
|
||||
|
||||
@@ -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();
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user