test: communication services

backend/src/libs/test-utils/mocks/factories/communication/UserRoleType-factory.mock.ts

@@ -0,0 +1,20 @@
+import faker from '@faker-js/faker';
+import { buildTestFactory } from '../generic-factory.mock';
+import { BoardRoles } from 'src/libs/enum/board.roles';
+import { UserRoleType } from 'src/modules/communication/dto/types';
+
+const mockBoardData = () => {
+	return {
+		id: faker.database.mongodbObjectId(),
+		role: faker.helpers.arrayElement([BoardRoles.MEMBER, BoardRoles.RESPONSIBLE]),
+		user: {
+			id: faker.database.mongodbObjectId(),
+			firstName: faker.lorem.word(),
+			lastName: faker.lorem.word()
+		}
+	};
+};
+
+export const UserRoleTypeFactory = buildTestFactory<UserRoleType>(() => {
+	return mockBoardData();
+});

backend/src/libs/test-utils/mocks/factories/communication/boardType-factory.mock.ts

@@ -0,0 +1,24 @@
+import faker from '@faker-js/faker';
+import { buildTestFactory } from '../generic-factory.mock';
+import { BoardType } from 'src/modules/communication/dto/types';
+import { UserRoleTypeFactory } from './UserRoleType-factory.mock';
+
+const mockBoardData = () => {
+	return {
+		id: faker.database.mongodbObjectId(),
+		title: faker.lorem.words(),
+		isSubBoard: faker.datatype.boolean(),
+		dividedBoards: [],
+		team: {
+			name: faker.lorem.words(),
+			users: UserRoleTypeFactory.createMany(3)
+		},
+		users: UserRoleTypeFactory.createMany(3),
+		slackChannelId: faker.lorem.word(),
+		boardNumber: Number(faker.random.numeric())
+	};
+};
+
+export const BoardTypeFactory = buildTestFactory<BoardType>(() => {
+	return mockBoardData();
+});

backend/src/libs/test-utils/mocks/factories/communication/changeResponsible.mock.ts

@@ -0,0 +1,13 @@
+import { faker } from '@faker-js/faker';
+
+const mockedChangeResponsible = {
+	newResponsibleEmail: faker.internet.email(),
+	previousResponsibleEmail: faker.internet.email(),
+	subTeamChannelId: faker.random.alphaNumeric(6),
+	email: faker.internet.email(),
+	teamNumber: Number(faker.random.numeric()),
+	responsiblesChannelId: faker.random.alphaNumeric(6),
+	mainChannelId: faker.random.alphaNumeric(6)
+};
+
+export default mockedChangeResponsible;

backend/src/libs/test-utils/mocks/factories/communication/mergeBoardType.mock.ts

@@ -0,0 +1,11 @@
+import { faker } from '@faker-js/faker';
+
+const mockedMergeBoardType = {
+	teamNumber: Number(faker.random.numeric()),
+	responsiblesChannelId: faker.random.alphaNumeric(6),
+	isLastSubBoard: faker.datatype.boolean(),
+	boardId: faker.random.alphaNumeric(6),
+	mainBoardId: faker.random.alphaNumeric(6)
+};
+
+export default mockedMergeBoardType;

backend/src/modules/communication/services/slack-archive-channel.service.spec.ts

@@ -0,0 +1,44 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DeepMocked, createMock } from '@golevelup/ts-jest';
+import { ArchiveChannelData, ArchiveChannelDataOptions } from '../dto/types';
+import { SlackArchiveChannelService } from './slack-archive-channel.service';
+import { ArchiveChannelServiceInterface } from '../interfaces/archive-channel.service.interface';
+import { SlackArchiveChannelProducer } from '../producers/slack-archive-channel.producer';
+
+describe('SlackArchiveChannelService', () => {
+	let service: ArchiveChannelServiceInterface;
+	let slackArchiveChannelProducer: DeepMocked<SlackArchiveChannelProducer>;
+
+	const slackMessageType: ArchiveChannelData = {
+		type: ArchiveChannelDataOptions.BOARD,
+		data: { id: 'someId', slackChannelId: 'someSlackChannelId' }
+	};
+
+	beforeAll(async () => {
+		const module: TestingModule = await Test.createTestingModule({
+			providers: [
+				SlackArchiveChannelService,
+				{
+					provide: SlackArchiveChannelProducer,
+					useValue: createMock<SlackArchiveChannelProducer>()
+				}
+			]
+		}).compile();
+
+		service = module.get<SlackArchiveChannelService>(SlackArchiveChannelService);
+		slackArchiveChannelProducer = module.get(SlackArchiveChannelProducer);
+	});
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should be defined', () => {
+		expect(service).toBeDefined();
+	});
+
+	it('should call SlackArchiveChannelProducer once with ArchiveChannelData', async () => {
+		await service.execute(slackMessageType);
+		expect(slackArchiveChannelProducer.add).toHaveBeenNthCalledWith(1, slackMessageType);
+	});
+});

backend/src/modules/communication/services/slack-communication.service.spec.ts

@@ -0,0 +1,85 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DeepMocked, createMock } from '@golevelup/ts-jest';
+import { SlackCommunicationProducer } from '../producers/slack-communication.producer';
+import { CommunicationServiceInterface } from '../interfaces/slack-communication.service.interface';
+import { SlackCommunicationService } from './slack-communication.service';
+import { SlackResponsibleProducer } from '../producers/slack-responsible.producer';
+import { SlackMergeBoardProducer } from '../producers/slack-merge-board.producer';
+import { SlackAddUserToChannelProducer } from '../producers/slack-add-user-channel.producer';
+import { BoardTypeFactory } from 'src/libs/test-utils/mocks/factories/communication/boardType-factory.mock';
+import { ConfigService } from '@nestjs/config';
+import configService from 'src/libs/test-utils/mocks/configService.mock';
+import mockedChangeResponsible from 'src/libs/test-utils/mocks/factories/communication/changeResponsible.mock';
+import mockedMergeBoardType from 'src/libs/test-utils/mocks/factories/communication/mergeBoardType.mock';
+
+describe('SlackCommunicationService', () => {
+	let service: CommunicationServiceInterface;
+	let slackArchiveChannelProducerMock: DeepMocked<SlackCommunicationProducer>;
+	let slackResponsibleProducerMock: DeepMocked<SlackResponsibleProducer>;
+	let slackMergeBoardProducerMock: DeepMocked<SlackMergeBoardProducer>;
+	let slackAddUserToChannelProducerMock: DeepMocked<SlackAddUserToChannelProducer>;
+
+	beforeAll(async () => {
+		const module: TestingModule = await Test.createTestingModule({
+			providers: [
+				SlackCommunicationService,
+				{
+					provide: ConfigService,
+					useValue: configService
+				},
+				{
+					provide: SlackCommunicationProducer,
+					useValue: createMock<SlackCommunicationProducer>()
+				},
+				{
+					provide: SlackResponsibleProducer,
+					useValue: createMock<SlackResponsibleProducer>()
+				},
+				{
+					provide: SlackMergeBoardProducer,
+					useValue: createMock<SlackMergeBoardProducer>()
+				},
+				{
+					provide: SlackAddUserToChannelProducer,
+					useValue: createMock<SlackAddUserToChannelProducer>()
+				}
+			]
+		}).compile();
+
+		service = module.get<SlackCommunicationService>(SlackCommunicationService);
+		slackArchiveChannelProducerMock = module.get(SlackCommunicationProducer);
+		slackResponsibleProducerMock = module.get(SlackResponsibleProducer);
+		slackMergeBoardProducerMock = module.get(SlackMergeBoardProducer);
+		slackAddUserToChannelProducerMock = module.get(SlackAddUserToChannelProducer);
+	});
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should be defined', () => {
+		expect(service).toBeDefined();
+	});
+
+	it('should call slackCommunicationProducer.add once with a boardType', async () => {
+		const boardMock = BoardTypeFactory.create();
+		await service.execute(boardMock);
+		expect(slackArchiveChannelProducerMock.add).toHaveBeenNthCalledWith(1, boardMock);
+	});
+
+	it('should call slackResponsibleProducer.add once with a changeResponsibleType', async () => {
+		await service.executeResponsibleChange(mockedChangeResponsible);
+		expect(slackResponsibleProducerMock.add).toHaveBeenNthCalledWith(1, mockedChangeResponsible);
+	});
+
+	it('should call slackMergeBoardProducer.add once with MergeBoardType data', async () => {
+		await service.executeMergeBoardNotification(mockedMergeBoardType);
+		expect(slackMergeBoardProducerMock.add).toHaveBeenNthCalledWith(1, mockedMergeBoardType);
+	});
+
+	it('should call slackAddUserToChannelProducer.add once with AddUserMainChannelType', async () => {
+		const emailMock = { email: 'someEmail@gmail.com' };
+		await service.executeAddUserMainChannel(emailMock);
+		expect(slackAddUserToChannelProducerMock.add).toHaveBeenNthCalledWith(1, emailMock);
+	});
+});

backend/src/modules/communication/services/slack-disabled-communication.service.spec.ts

@@ -0,0 +1,68 @@
+import { Logger } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { BoardTypeFactory } from 'src/libs/test-utils/mocks/factories/communication/boardType-factory.mock';
+import mockedChangeResponsible from 'src/libs/test-utils/mocks/factories/communication/changeResponsible.mock';
+import mockedMergeBoardType from 'src/libs/test-utils/mocks/factories/communication/mergeBoardType.mock';
+import { CommunicationServiceInterface } from '../interfaces/slack-communication.service.interface';
+import { SlackDisabledCommunicationService } from './slack-disabled-communication.service';
+
+const spyLoggerWarn = jest.spyOn(Logger.prototype, 'warn').mockImplementation(jest.fn);
+
+describe('SlackDisabledCommunicationService', () => {
+	let service: CommunicationServiceInterface;
+
+	beforeAll(async () => {
+		const module: TestingModule = await Test.createTestingModule({
+			providers: [SlackDisabledCommunicationService]
+		}).compile();
+
+		service = module.get<SlackDisabledCommunicationService>(SlackDisabledCommunicationService);
+	});
+
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should be defined', () => {
+		expect(service).toBeDefined();
+	});
+
+	it('should call logger warning if executeResponsibleChange is called', async () => {
+		await service.executeResponsibleChange(mockedChangeResponsible);
+
+		expect(spyLoggerWarn).toHaveBeenNthCalledWith(
+			1,
+			expect.stringContaining(JSON.stringify(mockedChangeResponsible))
+		);
+	});
+
+	it('should call logger warning if executeMergeBoardNotification is called', async () => {
+		await service.executeMergeBoardNotification(mockedMergeBoardType);
+
+		expect(spyLoggerWarn).toHaveBeenNthCalledWith(
+			1,
+			expect.stringContaining(JSON.stringify(mockedMergeBoardType))
+		);
+	});
+
+	it('should call logger warning if executeAddUserMainChannel is called', async () => {
+		const emailMock = { email: 'someEmail@gmail.com' };
+
+		await service.executeAddUserMainChannel(emailMock);
+
+		expect(spyLoggerWarn).toHaveBeenNthCalledWith(
+			1,
+			expect.stringContaining(JSON.stringify(emailMock.email))
+		);
+	});
+
+	it('should call logger warning if execute is called', async () => {
+		const boardMock = BoardTypeFactory.create();
+
+		await service.execute(boardMock);
+		expect(spyLoggerWarn).toHaveBeenNthCalledWith(
+			1,
+			expect.stringContaining(JSON.stringify(boardMock))
+		);
+	});
+});

backend/src/modules/communication/services/slack-send-messages.service.spec.ts

@@ -42,7 +42,7 @@ describe('SlackSendMessageService', () => {
 		expect(service).toBeDefined();
 	});
 
-	it('should call producer.send with SlackMessageType 1 time', async () => {
+	it('should call sendMessageProducer.send with SlackMessageType once', async () => {
 		await service.execute(slackMessageType);
 		expect(slackSendMessageProducerMock.send).toHaveBeenNthCalledWith(1, slackMessageType);
 	});