feat: Reintroduce collaboration feature (#10602)

packages/cli/test/integration/collaboration/collaboration.service.test.ts

@@ -0,0 +1,188 @@
+import { CollaborationService } from '@/collaboration/collaboration.service';
+import { Push } from '@/push';
+import { CacheService } from '@/services/cache/cache.service';
+import { mock } from 'jest-mock-extended';
+import * as testDb from '../shared/test-db';
+import Container from 'typedi';
+import type { User } from '@/databases/entities/user';
+import { createMember, createOwner } from '@test-integration/db/users';
+import type {
+	WorkflowClosedMessage,
+	WorkflowOpenedMessage,
+} from '@/collaboration/collaboration.message';
+import { createWorkflow, shareWorkflowWithUsers } from '@test-integration/db/workflows';
+import type { WorkflowEntity } from '@/databases/entities/workflow-entity';
+import { mockInstance } from '@test/mocking';
+import { UserService } from '@/services/user.service';
+
+describe('CollaborationService', () => {
+	mockInstance(Push, new Push(mock()));
+	let pushService: Push;
+	let collaborationService: CollaborationService;
+	let owner: User;
+	let memberWithoutAccess: User;
+	let memberWithAccess: User;
+	let workflow: WorkflowEntity;
+	let userService: UserService;
+	let cacheService: CacheService;
+
+	beforeAll(async () => {
+		await testDb.init();
+
+		pushService = Container.get(Push);
+		collaborationService = Container.get(CollaborationService);
+		userService = Container.get(UserService);
+		cacheService = Container.get(CacheService);
+
+		await cacheService.init();
+
+		[owner, memberWithAccess, memberWithoutAccess] = await Promise.all([
+			createOwner(),
+			createMember(),
+			createMember(),
+		]);
+		workflow = await createWorkflow({}, owner);
+		await shareWorkflowWithUsers(workflow, [memberWithAccess]);
+	});
+
+	afterEach(async () => {
+		jest.resetAllMocks();
+		await cacheService.reset();
+	});
+
+	const sendWorkflowOpenedMessage = async (workflowId: string, userId: string) => {
+		const openMessage: WorkflowOpenedMessage = {
+			type: 'workflowOpened',
+			workflowId,
+		};
+
+		return await collaborationService.handleUserMessage(userId, openMessage);
+	};
+
+	const sendWorkflowClosedMessage = async (workflowId: string, userId: string) => {
+		const openMessage: WorkflowClosedMessage = {
+			type: 'workflowClosed',
+			workflowId,
+		};
+
+		return await collaborationService.handleUserMessage(userId, openMessage);
+	};
+
+	describe('workflow opened message', () => {
+		it('should emit activeWorkflowUsersChanged after workflowOpened', async () => {
+			// Arrange
+			const sendToUsersSpy = jest.spyOn(pushService, 'sendToUsers');
+
+			// Act
+			await sendWorkflowOpenedMessage(workflow.id, owner.id);
+			await sendWorkflowOpenedMessage(workflow.id, memberWithAccess.id);
+
+			// Assert
+			expect(sendToUsersSpy).toHaveBeenNthCalledWith(
+				1,
+				'activeWorkflowUsersChanged',
+				{
+					activeUsers: [
+						{
+							lastSeen: expect.any(String),
+							user: {
+								...(await userService.toPublic(owner)),
+								isPending: false,
+							},
+						},
+					],
+					workflowId: workflow.id,
+				},
+				[owner.id],
+			);
+			expect(sendToUsersSpy).toHaveBeenNthCalledWith(
+				2,
+				'activeWorkflowUsersChanged',
+				{
+					activeUsers: expect.arrayContaining([
+						expect.objectContaining({
+							lastSeen: expect.any(String),
+							user: expect.objectContaining({
+								id: owner.id,
+							}),
+						}),
+						expect.objectContaining({
+							lastSeen: expect.any(String),
+							user: expect.objectContaining({
+								id: memberWithAccess.id,
+							}),
+						}),
+					]),
+					workflowId: workflow.id,
+				},
+				[owner.id, memberWithAccess.id],
+			);
+		});
+
+		it("should not emit activeWorkflowUsersChanged if user don't have access to the workflow", async () => {
+			const sendToUsersSpy = jest.spyOn(pushService, 'sendToUsers');
+
+			// Act
+			await sendWorkflowOpenedMessage(workflow.id, memberWithoutAccess.id);
+
+			// Assert
+			expect(sendToUsersSpy).not.toHaveBeenCalled();
+		});
+	});
+
+	describe('workflow closed message', () => {
+		it('should not emit activeWorkflowUsersChanged after workflowClosed when there are no active users', async () => {
+			// Arrange
+			const sendToUsersSpy = jest.spyOn(pushService, 'sendToUsers');
+			await sendWorkflowOpenedMessage(workflow.id, owner.id);
+			sendToUsersSpy.mockClear();
+
+			// Act
+			await sendWorkflowClosedMessage(workflow.id, owner.id);
+
+			// Assert
+			expect(sendToUsersSpy).not.toHaveBeenCalled();
+		});
+
+		it('should emit activeWorkflowUsersChanged after workflowClosed when there are active users', async () => {
+			// Arrange
+			const sendToUsersSpy = jest.spyOn(pushService, 'sendToUsers');
+			await sendWorkflowOpenedMessage(workflow.id, owner.id);
+			await sendWorkflowOpenedMessage(workflow.id, memberWithAccess.id);
+			sendToUsersSpy.mockClear();
+
+			// Act
+			await sendWorkflowClosedMessage(workflow.id, owner.id);
+
+			// Assert
+			expect(sendToUsersSpy).toHaveBeenCalledWith(
+				'activeWorkflowUsersChanged',
+				{
+					activeUsers: expect.arrayContaining([
+						expect.objectContaining({
+							lastSeen: expect.any(String),
+							user: expect.objectContaining({
+								id: memberWithAccess.id,
+							}),
+						}),
+					]),
+					workflowId: workflow.id,
+				},
+				[memberWithAccess.id],
+			);
+		});
+
+		it("should not emit activeWorkflowUsersChanged if user don't have access to the workflow", async () => {
+			// Arrange
+			const sendToUsersSpy = jest.spyOn(pushService, 'sendToUsers');
+			await sendWorkflowOpenedMessage(workflow.id, owner.id);
+			sendToUsersSpy.mockClear();
+
+			// Act
+			await sendWorkflowClosedMessage(workflow.id, memberWithoutAccess.id);
+
+			// Assert
+			expect(sendToUsersSpy).not.toHaveBeenCalled();
+		});
+	});
+});