snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/tests/e2e/omnichannel/omnichannel-contact-center-chats.spec.ts

@@ -0,0 +1,227 @@
+import { faker } from '@faker-js/faker';
+import type { Page } from '@playwright/test';
+
+import { IS_EE } from '../config/constants';
+import { Users } from '../fixtures/userStates';
+import { HomeOmnichannel } from '../page-objects';
+import { OmnichannelContactCenterChats } from '../page-objects/omnichannel';
+import { setSettingValueById } from '../utils';
+import { createAgent, makeAgentAvailable } from '../utils/omnichannel/agents';
+import { addAgentToDepartment, createDepartment } from '../utils/omnichannel/departments';
+import { createConversation, updateRoom } from '../utils/omnichannel/rooms';
+import { createTag } from '../utils/omnichannel/tags';
+import { test, expect } from '../utils/test';
+
+const visitorA = `${faker.person.firstName()}-${faker.database.mongodbObjectId()}`;
+const visitorB = `${faker.person.firstName()}-${faker.database.mongodbObjectId()}`;
+const visitorC = `${faker.person.firstName()}-${faker.database.mongodbObjectId()}`;
+
+test.skip(!IS_EE, 'OC - Contact Center Chats > Enterprise Only');
+
+test.use({ storageState: Users.admin.state });
+
+test.describe('OC - Contact Center Chats [Auto Selection]', async () => {
+	let poContactCenterChats: OmnichannelContactCenterChats;
+	let poHomeOmnichannel: HomeOmnichannel;
+	let departments: Awaited<ReturnType<typeof createDepartment>>[];
+	let conversations: Awaited<ReturnType<typeof createConversation>>[];
+	let agents: Awaited<ReturnType<typeof createAgent>>[];
+	let tagA: Awaited<ReturnType<typeof createTag>>;
+	let tagB: Awaited<ReturnType<typeof createTag>>;
+
+	// Allow manual on hold
+	test.beforeAll(async ({ api }) => {
+		const responses = await Promise.all([
+			api.post('/settings/Livechat_allow_manual_on_hold', { value: true }),
+			api.post('/settings/Livechat_allow_manual_on_hold_upon_agent_engagement_only', { value: false }),
+		]);
+		responses.forEach((res) => expect(res.status()).toBe(200));
+	});
+
+	// Create departments
+	test.beforeAll(async ({ api }) => {
+		departments = await Promise.all([createDepartment(api), createDepartment(api)]);
+	});
+
+	// Create agents
+	test.beforeAll(async ({ api }) => {
+		agents = await Promise.all([createAgent(api, 'user1'), createAgent(api, 'user2')]);
+
+		const agentsStatuses = await Promise.all(agents.map(({ data: agent }) => makeAgentAvailable(api, agent._id)));
+
+		agentsStatuses.forEach((res) => expect(res.status()).toBe(200));
+	});
+
+	// Add agents to departments
+	test.beforeAll(async ({ api }) => {
+		const [departmentA, departmentB] = departments.map(({ data }) => data);
+
+		const promises = await Promise.all([
+			addAgentToDepartment(api, { department: departmentA, agentId: 'user1' }),
+			addAgentToDepartment(api, { department: departmentB, agentId: 'user2' }),
+		]);
+
+		promises.forEach((res) => expect(res.status()).toBe(200));
+	});
+
+	// Create tags
+	test.beforeAll(async ({ api }) => {
+		tagA = await createTag(api);
+		tagB = await createTag(api);
+
+		[tagA, tagB].forEach((res) => expect(res.response.status()).toBe(200));
+	});
+
+	// Create rooms
+	test.beforeAll(async ({ api }) => {
+		const [departmentA, departmentB] = departments.map(({ data }) => data);
+
+		conversations = await Promise.all([
+			createConversation(api, {
+				visitorName: visitorA,
+				visitorToken: visitorA,
+				agentId: `user1`,
+				departmentId: departmentA._id,
+			}),
+			createConversation(api, {
+				visitorName: visitorB,
+				visitorToken: visitorB,
+				agentId: `user2`,
+				departmentId: departmentB._id,
+			}),
+			createConversation(api, {
+				visitorName: visitorC,
+				visitorToken: visitorC,
+			}),
+		]);
+
+		const [conversationA, conversationB] = conversations.map(({ data }) => data);
+
+		await Promise.all([
+			updateRoom(api, {
+				roomId: conversationA.room._id,
+				visitorId: conversationA.visitor._id,
+				tags: [tagA.data.name],
+			}),
+			updateRoom(api, {
+				roomId: conversationB.room._id,
+				visitorId: conversationB.visitor._id,
+				tags: [tagB.data.name],
+			}),
+		]);
+		await setSettingValueById(api, 'Omnichannel_enable_department_removal', true);
+	});
+
+	test.beforeEach(async ({ page }: { page: Page }) => {
+		poContactCenterChats = new OmnichannelContactCenterChats(page);
+		poHomeOmnichannel = new HomeOmnichannel(page);
+
+		await poContactCenterChats.goto();
+	});
+
+	test.afterAll(async ({ api }) => {
+		await Promise.all([
+			// Delete conversations
+			...conversations.map((conversation) => conversation.delete()),
+			// Delete departments
+			...departments.map((department) => department.delete()),
+			// Delete agents
+			...agents.map((agent) => agent.delete()),
+			// Delete tags
+			...[tagA, tagB].map((tag) => tag.delete()),
+			// Reset setting
+			api.post('/settings/Livechat_allow_manual_on_hold', { value: false }),
+			api.post('/settings/Livechat_allow_manual_on_hold_upon_agent_engagement_only', { value: true }),
+		]);
+		await setSettingValueById(api, 'Omnichannel_enable_department_removal', false);
+	});
+
+	// Change conversation A to on hold and close conversation B
+	test.beforeAll(async ({ api }) => {
+		const [conversationA, , conversationC] = conversations.map(({ data }) => data);
+
+		const statesPromises = await Promise.all([
+			api.post('/livechat/room.onHold', { roomId: conversationA.room._id }),
+			api.post('/livechat/room.close', { rid: conversationC.room._id, token: visitorC }),
+		]);
+
+		statesPromises.forEach((res) => expect(res.status()).toBe(200));
+	});
+
+	test('OC - Contact Center Chats - Basic navigation', async ({ page }) => {
+		await test.step('expect to be return using return button', async () => {
+			await poContactCenterChats.openChat(visitorA);
+			await poHomeOmnichannel.content.btnReturn.click();
+			expect(page.url()).toContain(`/omnichannel/current`);
+		});
+	});
+
+	test('OC - Contact Center Chats - Access in progress conversation from another agent', async () => {
+		await test.step('expect to be able to join', async () => {
+			const { visitor: visitorB } = conversations[1].data;
+			await poContactCenterChats.openChat(visitorB.name);
+			await expect(poHomeOmnichannel.composer.btnJoinRoom).toBeVisible();
+			await poHomeOmnichannel.composer.btnJoinRoom.click();
+			await expect(poHomeOmnichannel.composer.btnJoinRoom).not.toBeVisible();
+		});
+	});
+
+	test('OC - Contact Center Chats - Remove conversations', async () => {
+		await test.step('expect to be able to remove conversation from table', async () => {
+			await poContactCenterChats.removeChatByName(visitorC);
+			await expect(poContactCenterChats.table.findRowByName(visitorC)).not.toBeVisible();
+		});
+
+		// TODO: await test.step('expect to be able to close all closes conversations', async () => {});
+	});
+});
+
+test.describe('OC - Contact Center [Manual Selection]', () => {
+	let queuedConversation: Awaited<ReturnType<typeof createConversation>>;
+	let poHomeOmnichannel: HomeOmnichannel;
+	let poCurrentChats: OmnichannelContactCenterChats;
+	let agent: Awaited<ReturnType<typeof createAgent>>;
+
+	test.beforeAll(async ({ api }) => {
+		const res = await api.post('/settings/Livechat_Routing_Method', { value: 'Manual_Selection' });
+		expect(res.status()).toBe(200);
+	});
+
+	test.beforeAll(async ({ api }) => {
+		agent = await createAgent(api, 'rocketchat.internal.admin.test');
+
+		const agentStatus = await makeAgentAvailable(api, agent.data._id);
+
+		expect(agentStatus.status()).toBe(200);
+	});
+
+	test.beforeEach(async ({ page }: { page: Page }) => {
+		poHomeOmnichannel = new HomeOmnichannel(page);
+		poCurrentChats = new OmnichannelContactCenterChats(page);
+
+		await poCurrentChats.goto();
+	});
+
+	test('OC - Contact Center Chats - Access queued conversation', async ({ api }) => {
+		queuedConversation = await createConversation(api, { visitorToken: 'visitorQueued' });
+
+		await test.step('expect to be able to take it', async () => {
+			const { visitor } = queuedConversation.data;
+			await poCurrentChats.inputSearch.fill(visitor.name);
+			await poCurrentChats.openChat(visitor.name);
+			await expect(poHomeOmnichannel.content.btnTakeChat).toBeVisible();
+			await poHomeOmnichannel.content.btnTakeChat.click();
+			await expect(poHomeOmnichannel.content.btnTakeChat).not.toBeVisible();
+		});
+	});
+
+	test.afterAll(async ({ api }) => {
+		const res = await api.post('/settings/Livechat_Routing_Method', { value: 'Auto_Selection' });
+		expect(res.status()).toBe(200);
+	});
+
+	test.afterAll(async () => {
+		await queuedConversation.delete();
+		await agent.delete();
+	});
+});