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

apps/meteor/tests/unit/server/lib/omnichannel/closeLivechatRoom.tests.ts

@@ -0,0 +1,123 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import proxyquire from 'proxyquire';
+import sinon from 'sinon';
+
+import { createFakeRoom, createFakeSubscription, createFakeUser } from '../../../../mocks/data';
+
+const subscriptionsStub = {
+	findOneByRoomIdAndUserId: sinon.stub(),
+	removeByRoomId: sinon.stub(),
+	countByRoomId: sinon.stub(),
+};
+
+const livechatRoomsStub = {
+	findOneById: sinon.stub(),
+};
+
+const livechatStub = {
+	closeRoom: sinon.stub(),
+};
+
+const hasPermissionStub = sinon.stub();
+
+const { closeLivechatRoom } = proxyquire.noCallThru().load('../../../../../server/lib/omnichannel/closeLivechatRoom.ts', {
+	'./closeRoom': livechatStub,
+	'../authorization/hasPermission': {
+		hasPermissionAsync: hasPermissionStub,
+	},
+	'@rocket.chat/models': {
+		Subscriptions: subscriptionsStub,
+		LivechatRooms: livechatRoomsStub,
+	},
+});
+
+describe('closeLivechatRoom', () => {
+	const user = createFakeUser();
+	const room = createFakeRoom({ t: 'l', open: true });
+	const subscription = createFakeSubscription({ rid: room._id, u: { username: user.username, _id: user._id } });
+
+	beforeEach(() => {
+		subscriptionsStub.findOneByRoomIdAndUserId.reset();
+		subscriptionsStub.removeByRoomId.reset();
+		subscriptionsStub.countByRoomId.reset();
+		livechatRoomsStub.findOneById.reset();
+		livechatStub.closeRoom.reset();
+		hasPermissionStub.reset();
+	});
+
+	it('should not perform any operation when an invalid room id is provided', async () => {
+		livechatRoomsStub.findOneById.resolves(null);
+		hasPermissionStub.resolves(true);
+
+		await expect(closeLivechatRoom(user, room._id, {})).to.be.rejectedWith('error-invalid-room');
+		expect(livechatStub.closeRoom.notCalled).to.be.true;
+		expect(livechatRoomsStub.findOneById.calledOnceWith(room._id)).to.be.true;
+		expect(subscriptionsStub.findOneByRoomIdAndUserId.notCalled).to.be.true;
+		expect(subscriptionsStub.removeByRoomId.notCalled).to.be.true;
+	});
+
+	it('should not perform any operation when the caller is not subscribed to an open room and does not have the permission to close others rooms', async () => {
+		livechatRoomsStub.findOneById.resolves(room);
+		subscriptionsStub.findOneByRoomIdAndUserId.resolves(null);
+		hasPermissionStub.resolves(false);
+
+		await expect(closeLivechatRoom(user, room._id, {})).to.be.rejectedWith('error-not-authorized');
+		expect(livechatStub.closeRoom.notCalled).to.be.true;
+		expect(livechatRoomsStub.findOneById.calledOnceWith(room._id)).to.be.true;
+		expect(subscriptionsStub.findOneByRoomIdAndUserId.calledOnceWith(room._id, user._id)).to.be.true;
+		expect(subscriptionsStub.removeByRoomId.notCalled).to.be.true;
+	});
+
+	it('should close the room when the caller is not subscribed to it but has the permission to close others rooms', async () => {
+		livechatRoomsStub.findOneById.resolves(room);
+		subscriptionsStub.findOneByRoomIdAndUserId.resolves(null);
+		hasPermissionStub.resolves(true);
+
+		await closeLivechatRoom(user, room._id, {});
+		expect(livechatStub.closeRoom.calledOnceWith(sinon.match({ room, user }))).to.be.true;
+		expect(livechatRoomsStub.findOneById.calledOnceWith(room._id)).to.be.true;
+		expect(subscriptionsStub.findOneByRoomIdAndUserId.calledOnceWith(room._id, user._id)).to.be.true;
+		expect(subscriptionsStub.removeByRoomId.notCalled).to.be.true;
+	});
+
+	it('should close the room when the caller is subscribed to it and does not have the permission to close others rooms', async () => {
+		livechatRoomsStub.findOneById.resolves(room);
+		subscriptionsStub.findOneByRoomIdAndUserId.resolves(subscription);
+		hasPermissionStub.resolves(false);
+
+		await closeLivechatRoom(user, room._id, {});
+		expect(livechatStub.closeRoom.calledOnceWith(sinon.match({ room, user }))).to.be.true;
+		expect(livechatRoomsStub.findOneById.calledOnceWith(room._id)).to.be.true;
+		expect(subscriptionsStub.findOneByRoomIdAndUserId.calledOnceWith(room._id, user._id)).to.be.true;
+		expect(subscriptionsStub.removeByRoomId.notCalled).to.be.true;
+	});
+
+	it('should call Livechat.closeRoom directly when forceClose is true even if room is in invalid state', async () => {
+		// Here we're using `open: false` as a way to simulate an invalid state. This should not happen in production. A room like this is effectively a "bad egg"
+		livechatRoomsStub.findOneById.resolves({ ...room, open: false });
+		subscriptionsStub.findOneByRoomIdAndUserId.resolves(subscription);
+		hasPermissionStub.resolves(true);
+
+		await closeLivechatRoom(user, room._id, { forceClose: true });
+
+		expect(
+			livechatStub.closeRoom.calledOnceWith(
+				sinon.match({ room: { ...room, open: false }, user, options: sinon.match({ clientAction: true }), forceClose: true }),
+			),
+		).to.be.true;
+		expect(livechatRoomsStub.findOneById.calledOnceWith(room._id)).to.be.true;
+		expect(subscriptionsStub.findOneByRoomIdAndUserId.calledOnceWith(room._id, user._id)).to.be.true;
+	});
+
+	it('should throw an error if forceClose is false and room is already closed', async () => {
+		livechatRoomsStub.findOneById.resolves({ ...room, open: false });
+		subscriptionsStub.findOneByRoomIdAndUserId.resolves(subscription);
+		hasPermissionStub.resolves(true);
+
+		await expect(closeLivechatRoom(user, room._id, { forceClose: false })).to.be.rejectedWith('error-room-already-closed');
+		expect(livechatStub.closeRoom.notCalled).to.be.true;
+		expect(livechatRoomsStub.findOneById.calledOnceWith(room._id)).to.be.true;
+		expect(subscriptionsStub.findOneByRoomIdAndUserId.calledOnceWith(room._id, user._id)).to.be.true;
+	});
+});