diff --git a/.changeset/fresh-hats-kneel.md b/.changeset/fresh-hats-kneel.md
new file mode 100644
index 0000000000000..5d2738f5ee2d9
--- /dev/null
+++ b/.changeset/fresh-hats-kneel.md
@@ -0,0 +1,5 @@
+---
+"@rocket.chat/meteor": patch
+---
+
+Fixes an issue where words are breaking mid-character in user card's bio
diff --git a/apps/meteor/app/livechat/server/lib/RoutingManager.ts b/apps/meteor/app/livechat/server/lib/RoutingManager.ts
index 655af9646f28a..ff91d04819846 100644
--- a/apps/meteor/app/livechat/server/lib/RoutingManager.ts
+++ b/apps/meteor/app/livechat/server/lib/RoutingManager.ts
@@ -47,7 +47,7 @@ type Routing = {
 		agent?: SelectedAgent | null,
 		options?: { clientAction?: boolean; forwardingToDepartment?: { oldDepartmentId?: string; transferData?: any } },
 		room?: IOmnichannelRoom,
-	): Promise<(IOmnichannelRoom & { chatQueued?: boolean }) | null | void>;
+	): Promise<(IOmnichannelRoom & { chatQueued?: boolean }) | null | false>;
 	unassignAgent(
 		inquiry: ILivechatInquiryRecord,
 		departmentId?: string,
@@ -62,7 +62,7 @@ type Routing = {
 		agent: SelectedAgent | null,
 		options: { clientAction?: boolean; forwardingToDepartment?: { oldDepartmentId?: string; transferData?: any } },
 		room: IOmnichannelRoom,
-	): Promise<IOmnichannelRoom | null | void>;
+	): Promise<IOmnichannelRoom | false>;
 	transferRoom(room: IOmnichannelRoom, guest: ILivechatVisitor, transferData: TransferData): Promise<boolean>;
 	delegateAgent(agent: SelectedAgent | undefined, inquiry: ILivechatInquiryRecord): Promise<SelectedAgent | null | undefined>;
 	removeAllRoomSubscriptions(room: Pick<IOmnichannelRoom, '_id'>, ignoreUser?: { _id: string }): Promise<void>;
diff --git a/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultiple.tsx b/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultiple.tsx
index 827f88ee309e4..413cab7f6ea0c 100644
--- a/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultiple.tsx
+++ b/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultiple.tsx
@@ -94,7 +94,6 @@ const UserAutoCompleteMultiple = ({ onChange, value, placeholder, federated, ...
 		<OptionsContext.Provider value={{ options }}>
 			<MultiSelectFiltered
 				{...props}
-				data-qa-type='user-auto-complete-input'
 				placeholder={placeholder}
 				value={value}
 				onChange={handleOnChange}
diff --git a/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultipleOption.tsx b/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultipleOption.tsx
index f234cad7ec6da..096a06a0df5ff 100644
--- a/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultipleOption.tsx
+++ b/apps/meteor/client/components/UserAutoCompleteMultiple/UserAutoCompleteMultipleOption.tsx
@@ -17,7 +17,6 @@ const UserAutoCompleteMultipleOption = ({ label, ...props }: UserAutoCompleteMul
 	return (
 		<Option
 			{...props}
-			data-qa-type='autocomplete-user-option'
 			avatar={_federated ? undefined : <UserAvatar username={username || ''} size='x20' />}
 			icon={_federated ? 'globe' : undefined}
 			key={username}
diff --git a/apps/meteor/client/components/UserCard/UserCard.tsx b/apps/meteor/client/components/UserCard/UserCard.tsx
index 7482621c49ae4..8a042c0733e72 100644
--- a/apps/meteor/client/components/UserCard/UserCard.tsx
+++ b/apps/meteor/client/components/UserCard/UserCard.tsx
@@ -18,7 +18,7 @@ const clampStyle = css`
 	overflow: hidden;
 	-webkit-line-clamp: 3;
 	-webkit-box-orient: vertical;
-	word-break: break-all;
+	word-break: break-word;
 `;
 
 type UserCardProps = {
diff --git a/apps/meteor/client/views/omnichannel/additionalForms/AutoCompleteUnit.tsx b/apps/meteor/client/views/omnichannel/additionalForms/AutoCompleteUnit.tsx
index 8b8452c1385ed..a9cb772b92e6f 100644
--- a/apps/meteor/client/views/omnichannel/additionalForms/AutoCompleteUnit.tsx
+++ b/apps/meteor/client/views/omnichannel/additionalForms/AutoCompleteUnit.tsx
@@ -43,7 +43,7 @@ const AutoCompleteUnit = ({
 	return (
 		<PaginatedSelectFiltered
 			id={id}
-			data-qa='autocomplete-unit'
+			aria-label={t('Unit')} // FIXME: remove this when PaginatedSelectFiltered properly associates the input with the label htmlFor
 			error={error}
 			filter={unitsFilter}
 			flexGrow={0}
diff --git a/apps/meteor/client/views/omnichannel/agents/AgentsTable/AddAgent.tsx b/apps/meteor/client/views/omnichannel/agents/AgentsTable/AddAgent.tsx
index 43e5937297eb4..5b23d29d22f02 100644
--- a/apps/meteor/client/views/omnichannel/agents/AgentsTable/AddAgent.tsx
+++ b/apps/meteor/client/views/omnichannel/agents/AgentsTable/AddAgent.tsx
@@ -3,7 +3,7 @@ import { useEffectEvent } from '@rocket.chat/fuselage-hooks';
 import { UserAutoComplete } from '@rocket.chat/ui-client';
 import { useToastMessageDispatch } from '@rocket.chat/ui-contexts';
 import { useQueryClient } from '@tanstack/react-query';
-import { useState } from 'react';
+import { useId, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { useEndpointMutation } from '../../../../hooks/useEndpointMutation';
@@ -15,6 +15,8 @@ const AddAgent = () => {
 	const dispatchToastMessage = useToastMessageDispatch();
 	const queryClient = useQueryClient();
 
+	const usernameFieldId = useId();
+
 	const { mutateAsync: saveAction } = useEndpointMutation('POST', '/v1/livechat/users/agent', {
 		onSuccess: () => {
 			queryClient.invalidateQueries({ queryKey: omnichannelQueryKeys.agents() });
@@ -36,9 +38,9 @@ const AddAgent = () => {
 	return (
 		<Box display='flex' alignItems='center'>
 			<Field>
-				<FieldLabel>{t('Username')}</FieldLabel>
+				<FieldLabel htmlFor={usernameFieldId}>{t('Username')}</FieldLabel>
 				<FieldRow>
-					<UserAutoComplete value={username} onChange={handleChange} />
+					<UserAutoComplete id={usernameFieldId} value={username} onChange={handleChange} />
 					<Button disabled={!username} onClick={handleSave} mis={8} primary>
 						{t('Add_agent')}
 					</Button>
diff --git a/apps/meteor/client/views/omnichannel/components/AutoCompleteAgent.tsx b/apps/meteor/client/views/omnichannel/components/AutoCompleteAgent.tsx
index 78301720a05d3..a02ba5243c310 100644
--- a/apps/meteor/client/views/omnichannel/components/AutoCompleteAgent.tsx
+++ b/apps/meteor/client/views/omnichannel/components/AutoCompleteAgent.tsx
@@ -48,7 +48,6 @@ const AutoCompleteAgent = ({
 			filter={agentsFilter}
 			setFilter={setAgentsFilter as (value: string | number | undefined) => void}
 			options={agentsItems}
-			data-qa='autocomplete-agent'
 			onChange={onChange}
 			endReached={() => fetchNextPage()}
 		/>
diff --git a/apps/meteor/client/views/omnichannel/components/AutoCompleteDepartment.tsx b/apps/meteor/client/views/omnichannel/components/AutoCompleteDepartment.tsx
index a6cec618dc5d3..241bf46fdb3f9 100644
--- a/apps/meteor/client/views/omnichannel/components/AutoCompleteDepartment.tsx
+++ b/apps/meteor/client/views/omnichannel/components/AutoCompleteDepartment.tsx
@@ -62,7 +62,6 @@ const AutoCompleteDepartment = ({
 			setFilter={setDepartmentsFilter as (value?: string | number) => void}
 			options={departmentsItems}
 			placeholder={isPending ? t('Loading...') : t('Select_an_option')}
-			data-qa='autocomplete-department'
 			endReached={() => fetchNextPage()}
 			renderItem={({ label, ...props }) => <Option {...props} label={<span style={{ whiteSpace: 'normal' }}>{label}</span>} />}
 		/>
diff --git a/apps/meteor/client/views/omnichannel/modals/ForwardChatModal.tsx b/apps/meteor/client/views/omnichannel/modals/ForwardChatModal.tsx
index a46b11b11920c..0f99674040599 100644
--- a/apps/meteor/client/views/omnichannel/modals/ForwardChatModal.tsx
+++ b/apps/meteor/client/views/omnichannel/modals/ForwardChatModal.tsx
@@ -19,7 +19,7 @@ import {
 } from '@rocket.chat/fuselage';
 import { useEndpoint, useSetting } from '@rocket.chat/ui-contexts';
 import type { ReactElement } from 'react';
-import { useCallback, useEffect } from 'react';
+import { useCallback, useEffect, useId } from 'react';
 import { useForm } from 'react-hook-form';
 import { useTranslation } from 'react-i18next';
 
@@ -43,6 +43,9 @@ const ForwardChatModal = ({ onForward, onCancel, room, ...props }: ForwardChatMo
 	const getUserData = useEndpoint('GET', '/v1/users.info');
 	const idleAgentsAllowedForForwarding = useSetting('Livechat_enabled_when_agent_idle', true);
 
+	const departmentFieldId = useId();
+	const userFieldId = useId();
+
 	const {
 		getValues,
 		handleSubmit,
@@ -93,13 +96,14 @@ const ForwardChatModal = ({ onForward, onCancel, room, ...props }: ForwardChatMo
 			<ModalContent fontScale='p2'>
 				<FieldGroup>
 					<Field>
-						<FieldLabel>{t('Forward_to_department')}</FieldLabel>
+						<FieldLabel htmlFor={departmentFieldId}>{t('Forward_to_department')}</FieldLabel>
 						<FieldRow>
 							<AutoCompleteDepartment
+								id={departmentFieldId}
+								aria-label={t('Forward_to_department')}
 								withTitle={false}
 								maxWidth='100%'
 								flexGrow={1}
-								data-qa-id='forward-to-department'
 								onChange={(value: string): void => {
 									setValue('department', value);
 								}}
@@ -108,9 +112,11 @@ const ForwardChatModal = ({ onForward, onCancel, room, ...props }: ForwardChatMo
 					</Field>
 					<Divider p={0} children={t('or')} />
 					<Field>
-						<FieldLabel>{t('Forward_to_user')}</FieldLabel>
+						<FieldLabel htmlFor={userFieldId}>{t('Forward_to_user')}</FieldLabel>
 						<FieldRow>
 							<AutoCompleteAgent
+								id={userFieldId}
+								aria-label={t('Forward_to_user')}
 								withTitle
 								onlyAvailable
 								value={getValues().username}
diff --git a/apps/meteor/client/views/omnichannel/monitors/MonitorsTable.tsx b/apps/meteor/client/views/omnichannel/monitors/MonitorsTable.tsx
index d632feef52627..3aca318d9a480 100644
--- a/apps/meteor/client/views/omnichannel/monitors/MonitorsTable.tsx
+++ b/apps/meteor/client/views/omnichannel/monitors/MonitorsTable.tsx
@@ -28,7 +28,7 @@ import {
 } from '@rocket.chat/ui-client';
 import { useTranslation, useToastMessageDispatch, useEndpoint, useSetModal } from '@rocket.chat/ui-contexts';
 import { useMutation, useQuery, hashKey, useQueryClient } from '@tanstack/react-query';
-import { useMemo, useState } from 'react';
+import { useId, useMemo, useState } from 'react';
 
 import FilterByText from '../../../components/FilterByText';
 import GenericNoResults from '../../../components/GenericNoResults';
@@ -37,6 +37,7 @@ import { links } from '../../../lib/links';
 const MonitorsTable = () => {
 	const t = useTranslation();
 	const setModal = useSetModal();
+	const usernameFieldId = useId();
 
 	const [text, setText] = useState('');
 	const [username, setUsername] = useState('');
@@ -139,9 +140,9 @@ const MonitorsTable = () => {
 		<>
 			<Box display='flex' flexDirection='column'>
 				<Field>
-					<FieldLabel>{t('Username')}</FieldLabel>
+					<FieldLabel htmlFor={usernameFieldId}>{t('Username')}</FieldLabel>
 					<FieldRow>
-						<UserAutoComplete name='monitor' value={username} onChange={setUsername as () => void} />
+						<UserAutoComplete id={usernameFieldId} name='monitor' value={username} onChange={setUsername as () => void} />
 						<Button primary disabled={!username} loading={addMutation.isPending} onClick={() => handleAdd()} mis={8}>
 							{t('Add_monitor')}
 						</Button>
diff --git a/apps/meteor/ee/app/livechat-enterprise/server/hooks/onAgentAssignmentFailed.ts b/apps/meteor/ee/app/livechat-enterprise/server/hooks/onAgentAssignmentFailed.ts
index cb0c4f14c8c91..c2be90593b852 100644
--- a/apps/meteor/ee/app/livechat-enterprise/server/hooks/onAgentAssignmentFailed.ts
+++ b/apps/meteor/ee/app/livechat-enterprise/server/hooks/onAgentAssignmentFailed.ts
@@ -17,22 +17,22 @@ const handleOnAgentAssignmentFailed = async (
 	},
 ) => {
 	if (!inquiry || !room) {
-		return;
+		return false;
 	}
 
 	if (!settings.get('Livechat_waiting_queue')) {
-		return;
+		return false;
 	}
 
 	const { forwardingToDepartment: { oldDepartmentId } = {}, forwardingToDepartment } = options;
 	if (!forwardingToDepartment) {
-		return;
+		return false;
 	}
 
 	const { department: newDepartmentId } = inquiry;
 
 	if (!newDepartmentId || !oldDepartmentId || newDepartmentId === oldDepartmentId) {
-		return;
+		return false;
 	}
 
 	return { ...room, chatQueued: true } as IOmnichannelRoom & { chatQueued: boolean };
diff --git a/apps/meteor/server/lib/callbacks.ts b/apps/meteor/server/lib/callbacks.ts
index 91ad655c5bc11..791df468f5da0 100644
--- a/apps/meteor/server/lib/callbacks.ts
+++ b/apps/meteor/server/lib/callbacks.ts
@@ -188,7 +188,7 @@ type ChainedCallbackSignatures = {
 			};
 			options: { forwardingToDepartment?: { oldDepartmentId?: string; transferData?: any }; clientAction?: boolean };
 		},
-	) => Promise<(IOmnichannelRoom & { chatQueued: boolean }) | undefined>;
+	) => Promise<(IOmnichannelRoom & { chatQueued: boolean }) | false>;
 	'beforeGetMentions': (mentionIds: string[], teamMentions: MessageMention[]) => Promise<string[]>;
 	'livechat.manageDepartmentUnit': (params: { userId: string; departmentId: string; unitId?: string }) => void;
 	'afterRoomTopicChange': (
diff --git a/apps/meteor/server/services/omnichannel/queue.ts b/apps/meteor/server/services/omnichannel/queue.ts
index bd4b5c0d5d4ca..89acb5434702f 100644
--- a/apps/meteor/server/services/omnichannel/queue.ts
+++ b/apps/meteor/server/services/omnichannel/queue.ts
@@ -254,7 +254,12 @@ export class OmnichannelQueue implements IOmnichannelQueue {
 
 		const room = await RoutingManager.delegateInquiry(inquiry, defaultAgent, undefined, roomFromDb);
 
-		if (room?.servedBy) {
+		if (!room) {
+			queueLogger.debug({ msg: 'RoutingManager failed to delegate inquiry', inquiry: inquiry._id, queue });
+			return false;
+		}
+
+		if (room.servedBy) {
 			const {
 				_id: rid,
 				servedBy: { _id: agentId },
diff --git a/apps/meteor/tests/e2e/federation/page-objects/channel.ts b/apps/meteor/tests/e2e/federation/page-objects/channel.ts
index 07f05807064ab..34c5e4879a4c5 100644
--- a/apps/meteor/tests/e2e/federation/page-objects/channel.ts
+++ b/apps/meteor/tests/e2e/federation/page-objects/channel.ts
@@ -78,9 +78,6 @@ export class FederationChannel {
 		for await (const username of usernamesToInvite) {
 			await this.newDMModal.inviteUserToDM(username);
 		}
-		await this.page
-			.locator('//*[@id="modal-root"]//*[contains(@class, "rcx-modal__title") and contains(text(), "Direct messages")]')
-			.click();
 		await this.newDMModal.btnCreate.click();
 	}
 
diff --git a/apps/meteor/tests/e2e/federation/page-objects/fragments/home-flextab-members.ts b/apps/meteor/tests/e2e/federation/page-objects/fragments/home-flextab-members.ts
index 937e55bf8d920..1d04abc37f99b 100644
--- a/apps/meteor/tests/e2e/federation/page-objects/fragments/home-flextab-members.ts
+++ b/apps/meteor/tests/e2e/federation/page-objects/fragments/home-flextab-members.ts
@@ -41,9 +41,11 @@ export class FederationHomeFlextabMembers {
 	async addMultipleUsers(usernames: string[]) {
 		await this.addUsersButton.click();
 		for await (const username of usernames) {
-			await this.page.locator('//label[contains(text(), "Choose users")]/..//input').type(username);
-			await this.page.locator(`[data-qa-type="autocomplete-user-option"] >> text=${username}`).waitFor();
-			await this.page.locator(`[data-qa-type="autocomplete-user-option"] >> text=${username}`).first().click();
+			await this.page.getByRole('textbox', { name: 'Choose users' }).click();
+			await this.page.getByRole('textbox', { name: 'Choose users' }).fill(username);
+
+			await this.page.getByRole('listbox').waitFor();
+			await this.page.getByRole('listbox').selectOption(username);
 		}
 		await this.addUsersButton.click();
 	}
diff --git a/apps/meteor/tests/e2e/page-objects/fragments/modals/create-new-modal.ts b/apps/meteor/tests/e2e/page-objects/fragments/modals/create-new-modal.ts
index 5d1f33efd0b12..2ad3e2fe12666 100644
--- a/apps/meteor/tests/e2e/page-objects/fragments/modals/create-new-modal.ts
+++ b/apps/meteor/tests/e2e/page-objects/fragments/modals/create-new-modal.ts
@@ -52,16 +52,14 @@ export class CreateNewChannelModal extends CreateNewModal {
 		return this.root.getByRole('button', { name: 'Advanced settings', exact: true });
 	}
 
-	// TODO: improve locator
 	get autocompleteUser(): Locator {
-		return this.root.locator('//*[@id="modal-root"]//*[contains(@class, "rcx-box--full") and contains(text(), "Add Members")]/..//input');
+		return this.root.getByRole('textbox', { name: 'Add people' });
 	}
 
 	async inviteUserToChannel(username: string) {
 		await this.autocompleteUser.click();
-		await this.autocompleteUser.type(username);
-		await this.root.locator('[data-qa-type="autocomplete-user-option"]', { hasText: username }).waitFor();
-		await this.root.locator('[data-qa-type="autocomplete-user-option"]', { hasText: username }).click();
+		await this.autocompleteUser.fill(username);
+		await this.listbox.selectOption(username);
 	}
 }
 
@@ -75,14 +73,13 @@ export class CreateNewDMModal extends CreateNewModal {
 	}
 
 	get autocompleteUser(): Locator {
-		return this.root.locator('//*[@id="modal-root"]//*[contains(@class, "rcx-box--full")]/..//input');
+		return this.root.getByRole('listbox').getByRole('textbox');
 	}
 
 	async inviteUserToDM(username: string) {
 		await this.autocompleteUser.click();
-		await this.autocompleteUser.type(username);
-		await this.root.locator('[data-qa-type="autocomplete-user-option"]', { hasText: username }).waitFor();
-		await this.root.locator('[data-qa-type="autocomplete-user-option"]', { hasText: username }).click();
+		await this.autocompleteUser.fill(username);
+		await this.dmListbox.selectOption(username);
 	}
 }
 
diff --git a/apps/meteor/tests/e2e/page-objects/fragments/modals/omnichannel-transfer-chat-modal.ts b/apps/meteor/tests/e2e/page-objects/fragments/modals/omnichannel-transfer-chat-modal.ts
index 12dcfa148f73e..9398213613477 100644
--- a/apps/meteor/tests/e2e/page-objects/fragments/modals/omnichannel-transfer-chat-modal.ts
+++ b/apps/meteor/tests/e2e/page-objects/fragments/modals/omnichannel-transfer-chat-modal.ts
@@ -16,11 +16,11 @@ export class OmnichannelTransferChatModal extends Modal {
 	}
 
 	get inputForwardDepartment(): Locator {
-		return this.root.locator('[data-qa-id="forward-to-department"] input');
+		return this.root.getByLabel('Forward to department').getByRole('textbox');
 	}
 
 	get inputForwardUser(): Locator {
-		return this.root.locator('[data-qa="autocomplete-agent"] input');
+		return this.root.getByLabel('Forward to user').getByRole('textbox');
 	}
 
 	get btnForward(): Locator {
diff --git a/apps/meteor/tests/e2e/page-objects/omnichannel-agents.ts b/apps/meteor/tests/e2e/page-objects/omnichannel-agents.ts
index d7cca6f89def2..3eaf9fa304d09 100644
--- a/apps/meteor/tests/e2e/page-objects/omnichannel-agents.ts
+++ b/apps/meteor/tests/e2e/page-objects/omnichannel-agents.ts
@@ -19,7 +19,7 @@ export class OmnichannelAgents {
 	}
 
 	get inputUsername(): Locator {
-		return this.page.locator('[data-qa-id="UserAutoComplete"]');
+		return this.page.getByRole('textbox', { name: 'Username' });
 	}
 
 	get inputSearch(): Locator {
diff --git a/apps/meteor/tests/e2e/page-objects/omnichannel-contact-center-chats.ts b/apps/meteor/tests/e2e/page-objects/omnichannel-contact-center-chats.ts
index 339a3b96621bb..3f5918ba07787 100644
--- a/apps/meteor/tests/e2e/page-objects/omnichannel-contact-center-chats.ts
+++ b/apps/meteor/tests/e2e/page-objects/omnichannel-contact-center-chats.ts
@@ -54,22 +54,10 @@ export class OmnichannelChats extends OmnichannelAdministration {
 		return this.contactCenterChatsTable.getByRole('link', { name: contactName });
 	}
 
-	get inputServedBy(): Locator {
-		return this.page.locator('[data-qa="autocomplete-agent"] input');
-	}
-
 	get inputStatus(): Locator {
 		return this.page.locator('[data-qa="current-chats-status"]');
 	}
 
-	get inputDepartment(): Locator {
-		return this.page.locator('[data-qa="autocomplete-department"] input');
-	}
-
-	get inputDepartmentValue(): Locator {
-		return this.page.locator('[data-qa="autocomplete-department"] span');
-	}
-
 	get inputTags(): Locator {
 		return this.page.locator('[data-qa="current-chats-tags"] [role="listbox"]');
 	}
@@ -78,12 +66,6 @@ export class OmnichannelChats extends OmnichannelAdministration {
 		return this.page.locator('[data-qa-id="current-chats-modal-remove-all-closed"]');
 	}
 
-	async selectServedBy(option: string) {
-		await this.inputServedBy.click();
-		await this.inputServedBy.fill(option);
-		await this.page.locator(`[role='option'][value='${option}']`).click();
-	}
-
 	async addTag(option: string) {
 		await this.inputTags.click();
 		await this.page.locator(`[role='option'][value='${option}']`).click();
@@ -94,12 +76,6 @@ export class OmnichannelChats extends OmnichannelAdministration {
 		await this.page.locator(`role=option[name='${option}']`).click();
 	}
 
-	async selectDepartment(option: string) {
-		await this.inputDepartment.click();
-		await this.inputDepartment.fill(option);
-		await this.page.locator(`role=option[name='${option}']`).click();
-	}
-
 	async selectStatus(option: string) {
 		await this.inputStatus.click();
 		await this.page.locator(`[role='option'][data-key='${option}']`).click();
diff --git a/apps/meteor/tests/e2e/page-objects/omnichannel-departments.ts b/apps/meteor/tests/e2e/page-objects/omnichannel-departments.ts
index 315377de91f29..e5965b67a3a5a 100644
--- a/apps/meteor/tests/e2e/page-objects/omnichannel-departments.ts
+++ b/apps/meteor/tests/e2e/page-objects/omnichannel-departments.ts
@@ -126,8 +126,7 @@ export class OmnichannelDepartments {
 	}
 
 	get inputUnit(): Locator {
-		// TODO: Improve PaginatedSelectFiltered to allow for more accessible locators
-		return this.page.locator('[data-qa="autocomplete-unit"] input');
+		return this.page.getByLabel('Unit').getByRole('textbox', { name: 'Select an option' });
 	}
 
 	btnTag(tagName: string) {
diff --git a/apps/meteor/tests/end-to-end/api/livechat/07-queue.ts b/apps/meteor/tests/end-to-end/api/livechat/07-queue.ts
index d1e7f77aeee4a..969a7dbe1d184 100644
--- a/apps/meteor/tests/end-to-end/api/livechat/07-queue.ts
+++ b/apps/meteor/tests/end-to-end/api/livechat/07-queue.ts
@@ -19,6 +19,7 @@ import {
 	getLivechatRoomInfo,
 	makeAgentAvailable,
 	updateDepartment,
+	startANewLivechatRoomAndTakeIt,
 } from '../../../data/livechat/rooms';
 import { createAnOnlineAgent, updateLivechatSettingsForUser } from '../../../data/livechat/users';
 import { sleep } from '../../../data/livechat/utils';
@@ -644,6 +645,8 @@ describe('LIVECHAT - Queue', () => {
 		await makeAgentAvailable(credentials3);
 		await makeAgentAvailable(credentials4);
 
+		await updatePermission('transfer-livechat-guest', ['livechat-agent']);
+
 		testUser = {
 			user,
 			credentials: credentials3,
@@ -881,4 +884,122 @@ describe('LIVECHAT - Queue', () => {
 		expect(roomInfo.servedBy).to.be.an('object');
 		expect(roomInfo.servedBy?._id).to.be.equal(testUser2.user._id);
 	});
+
+	describe('when forwarding a chat to an agent already at their limit', () => {
+		let forwardingRoom: { _id: string };
+		let otherRoom: { _id: string };
+		let visitor1: ILivechatVisitor;
+		let visitor2: ILivechatVisitor;
+		let forwardingDept: ILivechatDepartment;
+		let forwardUserA: { user: IUser; credentials: Credentials };
+		let forwardUserB: { user: IUser; credentials: Credentials };
+
+		before(async () => {
+			await updateSetting('Livechat_Routing_Method', 'Manual_Selection');
+
+			const userA = await createUser();
+			const userB = await createUser();
+
+			await createAgent(userA.username);
+			await createAgent(userB.username);
+
+			const credA = await login(userA.username, password);
+			const credB = await login(userB.username, password);
+
+			await makeAgentAvailable(credA);
+			await makeAgentAvailable(credB);
+
+			forwardUserA = { user: userA, credentials: credA };
+			forwardUserB = { user: userB, credentials: credB };
+
+			forwardingDept = await createDepartment(
+				[{ agentId: forwardUserA.user._id }, { agentId: forwardUserB.user._id }],
+				`${new Date().toISOString()}-forward-limit`,
+				true,
+				{
+					maxNumberSimultaneousChat: 1,
+				},
+			);
+
+			await updateLivechatSettingsForUser(forwardUserA.user._id, { maxNumberSimultaneousChat: 1 }, [forwardingDept._id]);
+			await updateLivechatSettingsForUser(forwardUserB.user._id, { maxNumberSimultaneousChat: 1 }, [forwardingDept._id]);
+
+			// Force agent A to take a room on the dedicated department
+			const { room: room1, visitor } = await startANewLivechatRoomAndTakeIt({
+				departmentId: forwardingDept._id,
+				agent: forwardUserA.credentials,
+			});
+			visitor1 = visitor;
+
+			const roomInfo1 = await getLivechatRoomInfo(room1._id);
+			expect(roomInfo1.servedBy).to.be.an('object');
+			expect(roomInfo1.servedBy?._id).to.be.equal(forwardUserA.user._id);
+			otherRoom = room1;
+		});
+
+		before(async () => {
+			// Force agent B to take another room on the same department
+			const { room: room2, visitor } = await startANewLivechatRoomAndTakeIt({
+				departmentId: forwardingDept!._id,
+				agent: forwardUserB.credentials,
+			});
+			visitor2 = visitor;
+
+			const roomInfo2 = await getLivechatRoomInfo(room2._id);
+			expect(roomInfo2.servedBy).to.be.an('object');
+			expect(roomInfo2.servedBy?._id).to.be.equal(forwardUserB.user._id);
+
+			forwardingRoom = room2;
+		});
+
+		after(async () => {
+			await closeOmnichannelRoom(forwardingRoom._id);
+			await closeOmnichannelRoom(otherRoom._id);
+			await deleteDepartment(forwardingDept._id);
+			await deleteVisitor(visitor1._id);
+			await deleteVisitor(visitor2._id);
+			await deleteUser(forwardUserA.user);
+			await deleteUser(forwardUserB.user);
+		});
+
+		it('should not allow forwarding and should not add system messages to the room', async () => {
+			const res = await request.post(api('livechat/room.forward')).set(forwardUserB.credentials).send({
+				roomId: forwardingRoom._id,
+				userId: forwardUserA.user._id,
+				clientAction: true,
+				comment: 'forward to agent at limit',
+			});
+
+			expect(res.status).to.equal(400);
+			expect(res.body).to.have.property('success', false);
+
+			const messagesResponse = await request.get(api('channels.messages')).set(credentials).query({ roomId: forwardingRoom._id });
+
+			expect(messagesResponse.status).to.equal(200);
+			expect(messagesResponse.body).to.have.property('messages');
+			const systemMessages = messagesResponse.body.messages.filter((msg: any) => msg.t === 'livechat_transfer_history');
+			expect(systemMessages).to.have.length(0);
+		});
+
+		it('should allow forwarding with the waiting queue disabled', async () => {
+			await updateEESetting('Livechat_waiting_queue', false);
+
+			const res = await request.post(api('livechat/room.forward')).set(forwardUserB.credentials).send({
+				roomId: forwardingRoom._id,
+				userId: forwardUserA.user._id,
+				clientAction: true,
+				comment: 'forward to agent at limit with waiting queue disabled',
+			});
+
+			expect(res.status).to.equal(200);
+			expect(res.body).to.have.property('success', true);
+
+			const messagesResponse = await request.get(api('channels.messages')).set(credentials).query({ roomId: forwardingRoom._id });
+
+			expect(messagesResponse.status).to.equal(200);
+			expect(messagesResponse.body).to.have.property('messages');
+			const systemMessages = messagesResponse.body.messages.filter((msg: any) => msg.t === 'livechat_transfer_history');
+			expect(systemMessages).to.have.length.greaterThan(0);
+		});
+	});
 });
diff --git a/ee/packages/abac/src/subject-attributes-validations.spec.ts b/ee/packages/abac/src/subject-attributes-validations.spec.ts
index dbc9e9b157c05..8ededa04cee40 100644
--- a/ee/packages/abac/src/subject-attributes-validations.spec.ts
+++ b/ee/packages/abac/src/subject-attributes-validations.spec.ts
@@ -1,10 +1,9 @@
 import type { ILDAPEntry, IUser, IAbacAttributeDefinition } from '@rocket.chat/core-typings';
-import { registerServiceModels, Users } from '@rocket.chat/models';
+import { Users } from '@rocket.chat/models';
 import type { Collection, Db } from 'mongodb';
-import { MongoClient } from 'mongodb';
-import { MongoMemoryServer } from 'mongodb-memory-server';
 
 import { AbacService } from './index';
+import { acquireSharedInMemoryMongo, SHARED_ABAC_TEST_DB, type SharedMongoConnection } from './test-helpers/mongoMemoryServer';
 
 jest.mock('@rocket.chat/core-services', () => ({
 	ServiceClass: class {},
@@ -16,13 +15,13 @@ jest.mock('@rocket.chat/core-services', () => ({
 
 const makeUser = (overrides: Partial<IUser> = {}): IUser =>
 	({
-		_id: `user-${Math.random().toString(36).substring(2, 15)}`,
-		username: `user${Math.random().toString(36).substring(2, 15)}`,
+		_id: `user-fixed-id-${Math.random()}`,
+		username: 'user-fixed-username',
 		roles: [],
 		type: 'user',
 		active: true,
-		createdAt: new Date(),
-		_updatedAt: new Date(),
+		createdAt: new Date(0),
+		_updatedAt: new Date(0),
 		...overrides,
 	}) as IUser;
 
@@ -31,48 +30,172 @@ const makeLdap = (overrides: Partial<ILDAPEntry> = {}): ILDAPEntry =>
 		...overrides,
 	}) as ILDAPEntry;
 
-describe('Subject Attributes validation', () => {
-	let db: Db;
-	let mongo: MongoMemoryServer;
-	let client: MongoClient;
+type StaticUserDefinition = {
+	_id: string;
+	username: string;
+};
+
+const staticUserDefinitions: StaticUserDefinition[] = [
+	{ _id: 'u-no-map-attrs', username: 'user-no-map' },
+	{ _id: 'u-merge-memberof', username: 'merge-memberof' },
+	{ _id: 'u-distinct-keys', username: 'distinct-keys' },
+	{ _id: 'u-merge-array-string', username: 'merge-array-string' },
+	{ _id: 'u-unset-loss', username: 'unset-loss' },
+	{ _id: 'u-unset-none', username: 'unset-none' },
+	{ _id: 'u-loss-values', username: 'loss-values' },
+	{ _id: 'u-loss-key', username: 'loss-key' },
+	{ _id: 'u-gain-values', username: 'gain-values' },
+	{ _id: 'u-order-only', username: 'order-only' },
+	{ _id: 'u-merge-ldap-dup', username: 'merge-ldap-dup' },
+	{ _id: 'u-immutability', username: 'immutability' },
+	{ _id: 'u-loss', username: 'lossy' },
+	{ _id: 'u-key-loss', username: 'keyloss' },
+	{ _id: 'u-growth', username: 'growth' },
+	{ _id: 'u-extra-room-key', username: 'extrakey' },
+	{ _id: 'u-empty', username: 'empty' },
+	{ _id: 'u-lose-unrelated', username: 'unrelated' },
+];
+
+const staticTestUsers: IUser[] = staticUserDefinitions.map(({ _id, username }) => ({
+	_id,
+	username,
+	roles: [],
+	type: 'user',
+	active: true,
+	createdAt: new Date(0),
+	_updatedAt: new Date(0),
+	__rooms: [],
+})) as IUser[];
+
+const staticUserIds = staticTestUsers.map(({ _id }) => _id);
+const staticUserBaseMap = Object.fromEntries(staticTestUsers.map((user) => [user._id, { ...user }])) as Record<string, IUser>;
+
+const getStaticUser = (_id: string, overrides: Partial<IUser> = {}): IUser => {
+	const base = staticUserBaseMap[_id];
+	if (!base) {
+		throw new Error(`Unknown static user ${_id}`);
+	}
+	return {
+		...base,
+		...overrides,
+		_id: base._id,
+		username: overrides.username ?? base.username,
+		__rooms: overrides.__rooms ?? base.__rooms ?? [],
+	};
+};
+
+type StaticUserUpdate = Partial<IUser> & { _id: string };
+
+const service = new AbacService();
+
+let db: Db;
+let sharedMongo: SharedMongoConnection;
+let roomsCol: Collection<any>;
+let usersCol: Collection<IUser>;
+
+const resetStaticUsers = async () => {
+	await usersCol.updateMany(
+		{ _id: { $in: staticUserIds } },
+		{
+			$set: {
+				__rooms: [],
+				_updatedAt: new Date(),
+			},
+			$unset: {
+				abacAttributes: 1,
+			},
+		},
+	);
+};
+
+const configureStaticUsers = async (users: StaticUserUpdate[]) => {
+	if (!usersCol) {
+		throw new Error('users collection not initialized');
+	}
+
+	const operations = users.map(({ _id, ...fields }) => {
+		const update: { $set: Record<string, any>; $unset?: Record<string, 1> } = {
+			$set: { _updatedAt: new Date() },
+		};
+
+		for (const [key, value] of Object.entries(fields)) {
+			if (key === 'abacAttributes') {
+				if (value === undefined) {
+					update.$unset = { ...(update.$unset || {}), abacAttributes: 1 };
+				} else {
+					update.$set.abacAttributes = value;
+				}
+				continue;
+			}
+			if (key === '__rooms') {
+				update.$set.__rooms = value ?? [];
+				continue;
+			}
+			update.$set[key] = value;
+		}
+
+		return {
+			updateOne: {
+				filter: { _id },
+				update,
+			},
+		};
+	});
+
+	await usersCol.bulkWrite(operations);
+};
 
+const makeLdapEntry = makeLdap; // preserve existing helper naming intent
+
+const insertRooms = async (rooms: { _id: string; abacAttributes?: IAbacAttributeDefinition[] }[]) => {
+	await roomsCol.insertMany(
+		rooms.map((room) => ({
+			_id: room._id,
+			name: room._id,
+			t: 'p',
+			abacAttributes: room.abacAttributes,
+		})),
+	);
+};
+
+describe('Subject Attributes validation', () => {
 	beforeAll(async () => {
-		mongo = await MongoMemoryServer.create();
-		client = await MongoClient.connect(mongo.getUri(), {});
-		db = client.db('abac_global');
-		registerServiceModels(db);
+		sharedMongo = await acquireSharedInMemoryMongo(SHARED_ABAC_TEST_DB);
+		db = sharedMongo.db;
+
+		roomsCol = db.collection('rocketchat_room');
+		usersCol = db.collection('users');
 
-		// @ts-expect-error - ignore
-		await db.collection('abac_dummy_init').insertOne({ _id: 'init', createdAt: new Date() });
+		await usersCol.deleteMany({ _id: { $in: staticUserIds } });
+		await usersCol.insertMany(staticTestUsers);
 	}, 30_000);
 
 	afterAll(async () => {
-		await client.close();
-		await mongo.stop();
+		await usersCol.deleteMany({ _id: { $in: staticUserIds } });
+		await sharedMongo.release();
 	});
 
-	describe('AbacService.addSubjectAttributes (unit)', () => {
-		let service: AbacService;
-
-		beforeEach(async () => {
-			service = new AbacService();
-		});
+	beforeEach(async () => {
+		await resetStaticUsers();
+		await roomsCol.deleteMany({});
+	});
 
+	describe('AbacService.addSubjectAttributes (unit)', () => {
 		describe('early returns and no-ops', () => {
 			it('returns early when user has no _id', async () => {
 				const user = makeUser({ _id: undefined });
 				await service.addSubjectAttributes(user, makeLdap(), { group: 'dept' });
-				// Nothing inserted, ensure no user doc created
 				const found = await Users.findOne({ username: user.username });
 				expect(found).toBeFalsy();
 			});
 
 			it('does nothing (no update) when map produces no attributes and user had none', async () => {
-				const user = makeUser({ abacAttributes: undefined });
-				await Users.insertOne(user);
-				const ldap = makeLdap({ group: '' });
+				const userId = 'u-no-map-attrs';
+				await configureStaticUsers([{ _id: userId, abacAttributes: undefined }]);
+				const user = getStaticUser(userId);
+				const ldap = makeLdapEntry({ group: '' });
 				await service.addSubjectAttributes(user, ldap, { group: 'dept' });
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated).toBeTruthy();
 				expect(updated?.abacAttributes ?? undefined).toBeUndefined();
 			});
@@ -80,29 +203,31 @@ describe('Subject Attributes validation', () => {
 
 		describe('building and setting attributes', () => {
 			it('merges multiple LDAP keys mapping to the same ABAC key, deduplicating values', async () => {
-				const user = makeUser();
-				await Users.insertOne(user);
-				const ldap = makeLdap({
+				const userId = 'u-merge-memberof';
+				await configureStaticUsers([{ _id: userId }]);
+				const user = getStaticUser(userId);
+				const ldap = makeLdapEntry({
 					memberOf: ['eng', 'sales', 'eng'],
 					department: ['sales', 'support'],
 				});
 				const map = { memberOf: 'dept', department: 'dept' };
 				await service.addSubjectAttributes(user, ldap, map);
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([{ key: 'dept', values: ['eng', 'sales', 'support'] }]);
 			});
 
 			it('creates distinct ABAC attributes for different mapped keys preserving insertion order', async () => {
-				const user = makeUser();
-				await Users.insertOne(user);
-				const ldap = makeLdap({
+				const userId = 'u-distinct-keys';
+				await configureStaticUsers([{ _id: userId }]);
+				const user = getStaticUser(userId);
+				const ldap = makeLdapEntry({
 					groups: ['alpha', 'beta'],
 					regionCodes: ['emea', 'apac'],
 					role: 'admin',
 				});
 				const map = { groups: 'team', regionCodes: 'region', role: 'role' };
 				await service.addSubjectAttributes(user, ldap, map);
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([
 					{ key: 'team', values: ['alpha', 'beta'] },
 					{ key: 'region', values: ['emea', 'apac'] },
@@ -111,159 +236,149 @@ describe('Subject Attributes validation', () => {
 			});
 
 			it('merges array and string LDAP values into one attribute', async () => {
-				const user = makeUser();
-				await Users.insertOne(user);
-				const ldap = makeLdap({ deptCode: 'eng', deptName: ['engineering', 'eng'] });
+				const userId = 'u-merge-array-string';
+				await configureStaticUsers([{ _id: userId }]);
+				const user = getStaticUser(userId);
+				const ldap = makeLdapEntry({ deptCode: 'eng', deptName: ['engineering', 'eng'] });
 				const map = { deptCode: 'dept', deptName: 'dept' };
 				await service.addSubjectAttributes(user, ldap, map);
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([{ key: 'dept', values: ['eng', 'engineering'] }]);
 			});
 		});
 
 		describe('unsetting attributes when none extracted', () => {
 			it('unsets abacAttributes when user previously had attributes but now extracts none', async () => {
-				const user = makeUser({ abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] });
-				await Users.insertOne(user);
-				const ldap = makeLdap({ other: ['x'] });
+				const userId = 'u-unset-loss';
+				await configureStaticUsers([{ _id: userId, abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }]);
+				const user = getStaticUser(userId, { abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] });
+				const ldap = makeLdapEntry({ other: ['x'] });
 				const map = { missing: 'dept' };
 				await service.addSubjectAttributes(user, ldap, map);
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toBeUndefined();
 			});
 
 			it('does not unset when user had no prior attributes and extraction yields none', async () => {
-				const user = makeUser({ abacAttributes: [] });
-				await Users.insertOne(user);
-				const ldap = makeLdap({});
+				const userId = 'u-unset-none';
+				await configureStaticUsers([{ _id: userId, abacAttributes: [] }]);
+				const user = getStaticUser(userId, { abacAttributes: [] });
+				const ldap = makeLdapEntry({});
 				const map = { missing: 'dept' };
 				await service.addSubjectAttributes(user, ldap, map);
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([]);
 			});
 		});
 
 		describe('loss detection triggering hook (attribute changes)', () => {
 			it('updates attributes reducing values on loss', async () => {
-				const user = makeUser({ abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] });
-				await Users.insertOne(user);
-				const ldap = makeLdap({ memberOf: ['eng'] });
+				const userId = 'u-loss-values';
+				await configureStaticUsers([{ _id: userId, abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] }]);
+				const user = getStaticUser(userId, { abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] });
+				const ldap = makeLdapEntry({ memberOf: ['eng'] });
 				await service.addSubjectAttributes(user, ldap, { memberOf: 'dept' });
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([{ key: 'dept', values: ['eng'] }]);
 			});
 
 			it('updates attributes removing an entire key', async () => {
-				const user = makeUser({
+				const userId = 'u-loss-key';
+				await configureStaticUsers([
+					{
+						_id: userId,
+						abacAttributes: [
+							{ key: 'dept', values: ['eng'] },
+							{ key: 'region', values: ['emea'] },
+						],
+					},
+				]);
+				const user = getStaticUser(userId, {
 					abacAttributes: [
 						{ key: 'dept', values: ['eng'] },
 						{ key: 'region', values: ['emea'] },
 					],
 				});
-				await Users.insertOne(user);
-				const ldap = makeLdap({ department: ['eng'] });
+				const ldap = makeLdapEntry({ department: ['eng'] });
 				await service.addSubjectAttributes(user, ldap, { department: 'dept' });
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([{ key: 'dept', values: ['eng'] }]);
 			});
 
 			it('gains new values without triggering loss logic', async () => {
-				const user = makeUser({ abacAttributes: [{ key: 'dept', values: ['eng'] }] });
-				await Users.insertOne(user);
-				const ldap = makeLdap({ memberOf: ['eng', 'qa'] });
+				const userId = 'u-gain-values';
+				await configureStaticUsers([{ _id: userId, abacAttributes: [{ key: 'dept', values: ['eng'] }] }]);
+				const user = getStaticUser(userId, { abacAttributes: [{ key: 'dept', values: ['eng'] }] });
+				const ldap = makeLdapEntry({ memberOf: ['eng', 'qa'] });
 				await service.addSubjectAttributes(user, ldap, { memberOf: 'dept' });
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([{ key: 'dept', values: ['eng', 'qa'] }]);
 			});
 
 			it('keeps attributes unchanged when only ordering differs', async () => {
-				const user = makeUser({ abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] });
-				await Users.insertOne(user);
-				const ldap = makeLdap({ memberOf: ['qa', 'eng'] });
+				const userId = 'u-order-only';
+				await configureStaticUsers([{ _id: userId, abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] }]);
+				const user = getStaticUser(userId, { abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] });
+				const ldap = makeLdapEntry({ memberOf: ['qa', 'eng'] });
 				await service.addSubjectAttributes(user, ldap, { memberOf: 'dept' });
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes?.[0].key).toBe('dept');
 				expect(new Set(updated?.abacAttributes?.[0].values)).toEqual(new Set(['eng', 'qa']));
 			});
 
 			it('merges duplicate LDAP mapping keys retaining union of values', async () => {
-				const user = makeUser({ abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] });
-				await Users.insertOne(user);
-				const ldap = makeLdap({ deptA: ['eng', 'sales'], deptB: ['eng'] });
+				const userId = 'u-merge-ldap-dup';
+				await configureStaticUsers([{ _id: userId, abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }]);
+				const user = getStaticUser(userId, { abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] });
+				const ldap = makeLdapEntry({ deptA: ['eng', 'sales'], deptB: ['eng'] });
 				await service.addSubjectAttributes(user, ldap, { deptA: 'dept', deptB: 'dept' });
-				const updated = await Users.findOneById(user._id, { projection: { abacAttributes: 1 } });
+				const updated = await Users.findOneById(userId, { projection: { abacAttributes: 1 } });
 				expect(updated?.abacAttributes).toEqual([{ key: 'dept', values: ['eng', 'sales'] }]);
 			});
 		});
 
 		describe('input immutability', () => {
+			let sharedUser: IUser;
+			let original: IAbacAttributeDefinition[];
+			let clone: IAbacAttributeDefinition[];
+
+			beforeAll(() => {
+				original = [{ key: 'dept', values: ['eng', 'sales'] }] as IAbacAttributeDefinition[];
+				clone = JSON.parse(JSON.stringify(original));
+			});
+
+			beforeEach(async () => {
+				await configureStaticUsers([{ _id: 'u-immutability', abacAttributes: original }]);
+				sharedUser = getStaticUser('u-immutability', { abacAttributes: original });
+			});
+
 			it('does not mutate original user.abacAttributes array reference contents', async () => {
-				const original = [{ key: 'dept', values: ['eng', 'sales'] }] as IAbacAttributeDefinition[];
-				const user = makeUser({ abacAttributes: original });
-				await Users.insertOne(user);
-				const clone = JSON.parse(JSON.stringify(original));
-				const ldap = makeLdap({ memberOf: ['eng', 'sales', 'support'] });
-				await service.addSubjectAttributes(user, ldap, { memberOf: 'dept' });
+				const ldap = makeLdapEntry({ memberOf: ['eng', 'sales', 'support'] });
+				await service.addSubjectAttributes(sharedUser, ldap, { memberOf: 'dept' });
 				expect(original).toEqual(clone);
 			});
 		});
 	});
 
 	describe('AbacService.addSubjectAttributes (room removals)', () => {
-		let service: AbacService;
-		let roomsCol: Collection<any>;
-		let usersCol: Collection<any>;
-
 		const originalCoreServices = jest.requireMock('@rocket.chat/core-services');
 		originalCoreServices.Room.removeUserFromRoom = async (rid: string, user: IUser) => {
-			// @ts-expect-error - test
 			await usersCol.updateOne({ _id: user._id }, { $pull: { __rooms: rid } });
 		};
 
-		const insertRoom = async (room: { _id: string; abacAttributes?: IAbacAttributeDefinition[] }) =>
-			roomsCol.insertOne({
-				_id: room._id,
-				name: room._id,
-				t: 'p',
-				abacAttributes: room.abacAttributes,
-			});
-
-		const insertUser = async (user: IUser & { __rooms?: string[] }) =>
-			usersCol.insertOne({
-				...user,
-				__rooms: user.__rooms || [],
-			});
-
-		beforeEach(async () => {
-			service = new AbacService();
-			roomsCol = db.collection('rocketchat_room');
-			usersCol = db.collection('users');
-			await Promise.all([roomsCol.deleteMany({}), usersCol.deleteMany({})]);
-		});
-
 		it('removes user from rooms whose attributes become non-compliant after losing a value', async () => {
-			const user: IUser = {
-				_id: 'u-loss',
-				username: 'lossy',
-				roles: [],
-				type: 'user',
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
+			const userId = 'u-loss';
+			const user = getStaticUser(userId, {
 				abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }],
 				__rooms: ['rKeep', 'rRemove'],
-			};
+			});
+			await configureStaticUsers([{ _id: userId, abacAttributes: user.abacAttributes, __rooms: user.__rooms }]);
 
-			// Rooms:
-			// rKeep requires only 'eng' (will remain compliant)
-			// rRemove requires both 'eng' and 'qa' (will become non-compliant after loss)
-			await Promise.all([
-				insertRoom({ _id: 'rKeep', abacAttributes: [{ key: 'dept', values: ['eng'] }] }),
-				insertRoom({ _id: 'rRemove', abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] }),
+			await insertRooms([
+				{ _id: 'rKeep', abacAttributes: [{ key: 'dept', values: ['eng'] }] },
+				{ _id: 'rRemove', abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] },
 			]);
 
-			await insertUser({ ...user, __rooms: ['rKeep', 'rRemove'] });
-
 			const ldap: ILDAPEntry = {
 				memberOf: ['eng'],
 				_raw: {},
@@ -271,46 +386,35 @@ describe('Subject Attributes validation', () => {
 
 			await service.addSubjectAttributes(user, ldap, { memberOf: 'dept' });
 
-			const updatedUser = await usersCol.findOne({ _id: user._id }, { projection: { abacAttributes: 1, __rooms: 1 } });
+			const updatedUser = await usersCol.findOne({ _id: userId }, { projection: { abacAttributes: 1, __rooms: 1 } });
 			expect(updatedUser?.abacAttributes).toEqual([{ key: 'dept', values: ['eng'] }]);
 			expect(updatedUser?.abacAttributes).not.toEqual(user.abacAttributes);
-			expect(updatedUser?.__rooms.sort()).toEqual(['rKeep']);
+			expect(updatedUser?.__rooms?.sort()).toEqual(['rKeep']);
 		});
 
 		it('removes user from rooms containing attribute keys they no longer possess (key loss)', async () => {
-			const user: IUser = {
-				_id: 'u-key-loss',
-				username: 'keyloss',
-				roles: [],
-				type: 'user',
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
+			const userId = 'u-key-loss';
+			const user = getStaticUser(userId, {
 				abacAttributes: [
 					{ key: 'dept', values: ['eng'] },
 					{ key: 'region', values: ['emea'] },
 				],
 				__rooms: ['rDeptOnly', 'rRegionOnly', 'rBoth'],
-			};
+			});
+			await configureStaticUsers([{ _id: userId, abacAttributes: user.abacAttributes, __rooms: user.__rooms }]);
 
-			// Rooms:
-			// rDeptOnly -> only dept (will stay)
-			// rRegionOnly -> region only (will be removed after region key loss)
-			// rBoth -> both dept & region (will be removed)
-			await Promise.all([
-				insertRoom({ _id: 'rDeptOnly', abacAttributes: [{ key: 'dept', values: ['eng'] }] }),
-				insertRoom({ _id: 'rRegionOnly', abacAttributes: [{ key: 'region', values: ['emea'] }] }),
-				insertRoom({
+			await insertRooms([
+				{ _id: 'rDeptOnly', abacAttributes: [{ key: 'dept', values: ['eng'] }] },
+				{ _id: 'rRegionOnly', abacAttributes: [{ key: 'region', values: ['emea'] }] },
+				{
 					_id: 'rBoth',
 					abacAttributes: [
 						{ key: 'dept', values: ['eng'] },
 						{ key: 'region', values: ['emea'] },
 					],
-				}),
+				},
 			]);
 
-			await insertUser({ ...user, __rooms: ['rDeptOnly', 'rRegionOnly', 'rBoth'] });
-
 			const ldap: ILDAPEntry = {
 				department: ['eng'],
 				_raw: {},
@@ -318,32 +422,25 @@ describe('Subject Attributes validation', () => {
 
 			await service.addSubjectAttributes(user, ldap, { department: 'dept' });
 
-			const updatedUser = await usersCol.findOne({ _id: user._id }, { projection: { abacAttributes: 1, __rooms: 1 } });
+			const updatedUser = await usersCol.findOne({ _id: userId }, { projection: { abacAttributes: 1, __rooms: 1 } });
 			expect(updatedUser?.abacAttributes).toEqual([{ key: 'dept', values: ['eng'] }]);
 			expect(updatedUser?.abacAttributes).not.toEqual(user.abacAttributes);
 			expect(updatedUser?.__rooms).toEqual(['rDeptOnly']);
 		});
 
 		it('does not remove user from any room when attribute values only grow (gain without loss)', async () => {
-			const user: IUser = {
-				_id: 'u-growth',
-				username: 'growth',
-				roles: [],
-				type: 'user',
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
+			const userId = 'u-growth';
+			const user = getStaticUser(userId, {
 				abacAttributes: [{ key: 'dept', values: ['eng'] }],
 				__rooms: ['rGrowthA', 'rGrowthB'],
-			};
+			});
+			await configureStaticUsers([{ _id: userId, abacAttributes: user.abacAttributes, __rooms: user.__rooms }]);
 
-			await Promise.all([
-				insertRoom({ _id: 'rGrowthA', abacAttributes: [{ key: 'dept', values: ['eng'] }] }),
-				insertRoom({ _id: 'rGrowthB', abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] }), // superset; still compliant after growth
+			await insertRooms([
+				{ _id: 'rGrowthA', abacAttributes: [{ key: 'dept', values: ['eng'] }] },
+				{ _id: 'rGrowthB', abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] },
 			]);
 
-			await insertUser({ ...user, __rooms: ['rGrowthA', 'rGrowthB'] });
-
 			const ldap: ILDAPEntry = {
 				memberOf: ['eng', 'qa'],
 				_raw: {},
@@ -351,43 +448,36 @@ describe('Subject Attributes validation', () => {
 
 			await service.addSubjectAttributes(user, ldap, { memberOf: 'dept' });
 
-			const updatedUser = await usersCol.findOne({ _id: user._id }, { projection: { abacAttributes: 1, __rooms: 1 } });
+			const updatedUser = await usersCol.findOne({ _id: userId }, { projection: { abacAttributes: 1, __rooms: 1 } });
 			expect(updatedUser?.abacAttributes).toEqual([{ key: 'dept', values: ['eng', 'qa'] }]);
-			expect(updatedUser?.__rooms.sort()).toEqual(['rGrowthA', 'rGrowthB']);
+			expect(updatedUser?.__rooms?.sort()).toEqual(['rGrowthA', 'rGrowthB']);
 		});
 
 		it('removes user from rooms having attribute keys not present in new attribute set (extra keys in room)', async () => {
-			const user: IUser = {
-				_id: 'u-extra-room-key',
-				username: 'extrakey',
-				roles: [],
-				type: 'user',
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
+			const userId = 'u-extra-room-key';
+			const user = getStaticUser(userId, {
 				abacAttributes: [
 					{ key: 'dept', values: ['eng', 'sales'] },
 					{ key: 'otherKey', values: ['value'] },
 				],
 				__rooms: ['rExtraKeyRoom', 'rBaseline'],
-			};
+			});
+			await configureStaticUsers([{ _id: userId, abacAttributes: user.abacAttributes, __rooms: user.__rooms }]);
 
-			await Promise.all([
-				insertRoom({
+			await insertRooms([
+				{
 					_id: 'rExtraKeyRoom',
 					abacAttributes: [
 						{ key: 'dept', values: ['eng', 'sales'] },
 						{ key: 'project', values: ['X'] },
 					],
-				}),
-				insertRoom({
+				},
+				{
 					_id: 'rBaseline',
 					abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }],
-				}),
+				},
 			]);
 
-			await insertUser({ ...user, __rooms: ['rExtraKeyRoom', 'rBaseline'] });
-
 			const ldap: ILDAPEntry = {
 				deptCodes: ['eng', 'sales'],
 				_raw: {},
@@ -395,31 +485,24 @@ describe('Subject Attributes validation', () => {
 
 			await service.addSubjectAttributes(user, ldap, { deptCodes: 'dept' });
 
-			const updatedUser = await usersCol.findOne({ _id: user._id }, { projection: { abacAttributes: 1, __rooms: 1 } });
+			const updatedUser = await usersCol.findOne({ _id: userId }, { projection: { abacAttributes: 1, __rooms: 1 } });
 			expect(updatedUser?.abacAttributes).toEqual([{ key: 'dept', values: ['eng', 'sales'] }]);
-			expect(updatedUser?.__rooms.sort()).toEqual(['rBaseline']);
+			expect(updatedUser?.__rooms?.sort()).toEqual(['rBaseline']);
 		});
 
 		it('unsets attributes and removes user from all ABAC rooms when no LDAP values extracted', async () => {
-			const user: IUser = {
-				_id: 'u-empty',
-				username: 'empty',
-				roles: [],
-				type: 'user',
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
+			const userId = 'u-empty';
+			const user = getStaticUser(userId, {
 				abacAttributes: [{ key: 'dept', values: ['eng'] }],
 				__rooms: ['rAny1', 'rAny2'],
-			};
+			});
+			await configureStaticUsers([{ _id: userId, abacAttributes: user.abacAttributes, __rooms: user.__rooms }]);
 
-			await Promise.all([
-				insertRoom({ _id: 'rAny1', abacAttributes: [{ key: 'dept', values: ['eng'] }] }),
-				insertRoom({ _id: 'rAny2', abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] }),
+			await insertRooms([
+				{ _id: 'rAny1', abacAttributes: [{ key: 'dept', values: ['eng'] }] },
+				{ _id: 'rAny2', abacAttributes: [{ key: 'dept', values: ['eng', 'qa'] }] },
 			]);
 
-			await insertUser({ ...user, __rooms: ['rAny1', 'rAny2'] });
-
 			const ldap: ILDAPEntry = {
 				unrelated: ['x'],
 				_raw: {},
@@ -427,38 +510,33 @@ describe('Subject Attributes validation', () => {
 
 			await service.addSubjectAttributes(user, ldap, { missing: 'dept' });
 
-			const updatedUser = await usersCol.findOne({ _id: user._id }, { projection: { abacAttributes: 1, __rooms: 1 } });
+			const updatedUser = await usersCol.findOne({ _id: userId }, { projection: { abacAttributes: 1, __rooms: 1 } });
 			expect(updatedUser?.abacAttributes).toBeUndefined();
 			expect(updatedUser?.abacAttributes).not.toEqual(user.abacAttributes);
 			expect(updatedUser?.__rooms).toEqual([]);
 		});
 
 		it('does not remove user from room when losing attribute not used by room (hook runs but no change)', async () => {
-			const user: IUser = {
-				_id: 'u-lose-unrelated',
-				username: 'unrelated',
-				roles: [],
-				type: 'user',
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
+			const userId = 'u-lose-unrelated';
+			const user = getStaticUser(userId, {
 				abacAttributes: [
 					{ key: 'dept', values: ['eng'] },
 					{ key: 'region', values: ['emea'] },
 					{ key: 'project', values: ['X'] },
 				],
 				__rooms: ['rDeptRegion'],
-			};
-
-			await insertRoom({
-				_id: 'rDeptRegion',
-				abacAttributes: [
-					{ key: 'dept', values: ['eng'] },
-					{ key: 'region', values: ['emea'] },
-				],
 			});
+			await configureStaticUsers([{ _id: userId, abacAttributes: user.abacAttributes, __rooms: user.__rooms }]);
 
-			await insertUser({ ...user, __rooms: ['rDeptRegion'] });
+			await insertRooms([
+				{
+					_id: 'rDeptRegion',
+					abacAttributes: [
+						{ key: 'dept', values: ['eng'] },
+						{ key: 'region', values: ['emea'] },
+					],
+				},
+			]);
 
 			const ldap: ILDAPEntry = {
 				department: ['eng', 'ceo'],
@@ -468,7 +546,7 @@ describe('Subject Attributes validation', () => {
 
 			await service.addSubjectAttributes(user, ldap, { department: 'dept', regionCodes: 'region', projectCodes: 'project' });
 
-			const updatedUser = await usersCol.findOne({ _id: user._id }, { projection: { abacAttributes: 1, __rooms: 1 } });
+			const updatedUser = await usersCol.findOne({ _id: userId }, { projection: { abacAttributes: 1, __rooms: 1 } });
 			expect(updatedUser?.abacAttributes).toEqual([
 				{ key: 'dept', values: ['eng', 'ceo'] },
 				{ key: 'region', values: ['emea', 'apac'] },
diff --git a/ee/packages/abac/src/test-helpers/mongoMemoryServer.ts b/ee/packages/abac/src/test-helpers/mongoMemoryServer.ts
new file mode 100644
index 0000000000000..71c22000be3fa
--- /dev/null
+++ b/ee/packages/abac/src/test-helpers/mongoMemoryServer.ts
@@ -0,0 +1,94 @@
+import { registerModel, UsersRaw, RoomsRaw, AbacAttributesRaw, ServerEventsRaw, SubscriptionsRaw } from '@rocket.chat/models';
+import type { Db } from 'mongodb';
+import { MongoClient } from 'mongodb';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+
+export const SHARED_ABAC_TEST_DB = 'abac_test';
+
+type SharedState = {
+	mongo: MongoMemoryServer;
+	client: MongoClient;
+	refCount: number;
+};
+
+let sharedState: SharedState | null = null;
+let initialization: Promise<SharedState> | null = null;
+
+const ensureState = async (): Promise<SharedState> => {
+	if (sharedState) {
+		return sharedState;
+	}
+
+	if (!initialization) {
+		initialization = (async () => {
+			const mongo = await MongoMemoryServer.create();
+			const client = await MongoClient.connect(mongo.getUri(), {});
+			return {
+				mongo,
+				client,
+				refCount: 0,
+			};
+		})();
+	}
+
+	sharedState = await initialization;
+	initialization = null;
+	return sharedState;
+};
+
+const dropDatabase = async (db: Db) => {
+	try {
+		await db.dropDatabase();
+	} catch (err) {
+		if (!(err instanceof Error) || !/ns not found/i.test(err.message)) {
+			throw err;
+		}
+	}
+};
+
+export type SharedMongoConnection = {
+	mongo: MongoMemoryServer;
+	client: MongoClient;
+	db: Db;
+	cleanupDatabase: () => Promise<void>;
+	release: () => Promise<void>;
+};
+
+const registerAbacTestModels = (db: Db) => {
+	registerModel('IUsersModel', () => new UsersRaw(db));
+	registerModel('IRoomsModel', () => new RoomsRaw(db));
+	registerModel('IAbacAttributesModel', () => new AbacAttributesRaw(db));
+	registerModel('IServerEventsModel', () => new ServerEventsRaw(db));
+	registerModel('ISubscriptionsModel', () => new SubscriptionsRaw(db));
+};
+
+export const acquireSharedInMemoryMongo = async (dbName: string): Promise<SharedMongoConnection> => {
+	const state = await ensureState();
+	state.refCount += 1;
+
+	const connectionDb = state.client.db(dbName);
+	let released = false;
+
+	registerAbacTestModels(connectionDb);
+	return {
+		mongo: state.mongo,
+		client: state.client,
+		db: connectionDb,
+		cleanupDatabase: async () => dropDatabase(connectionDb),
+		release: async () => {
+			if (released || !sharedState) {
+				return;
+			}
+
+			released = true;
+			sharedState.refCount -= 1;
+
+			if (sharedState.refCount === 0) {
+				const { client, mongo } = sharedState;
+				sharedState = null;
+				await client.close();
+				await mongo.stop();
+			}
+		},
+	};
+};
diff --git a/ee/packages/abac/src/user-auto-removal.spec.ts b/ee/packages/abac/src/user-auto-removal.spec.ts
index 4fae4f0c05c02..a287ca14dfa49 100644
--- a/ee/packages/abac/src/user-auto-removal.spec.ts
+++ b/ee/packages/abac/src/user-auto-removal.spec.ts
@@ -1,28 +1,25 @@
 import type { IAbacAttributeDefinition, IRoom, IUser } from '@rocket.chat/core-typings';
-import { registerServiceModels } from '@rocket.chat/models';
+import { Subscriptions } from '@rocket.chat/models';
 import type { Collection, Db } from 'mongodb';
-import { MongoClient } from 'mongodb';
-import { MongoMemoryServer } from 'mongodb-memory-server';
 
 import { Audit } from './audit';
 import { AbacService } from './index';
+import { acquireSharedInMemoryMongo, SHARED_ABAC_TEST_DB, type SharedMongoConnection } from './test-helpers/mongoMemoryServer';
 
 jest.mock('@rocket.chat/core-services', () => ({
 	ServiceClass: class {},
 	Room: {
 		// Mimic the DB side-effects of removing a user from a room (no apps/system messages)
 		removeUserFromRoom: async (roomId: string, user: any) => {
-			const { Subscriptions } = await import('@rocket.chat/models');
 			await Subscriptions.removeByRoomIdAndUserId(roomId, user._id);
 		},
 	},
 }));
 
 describe('AbacService integration (onRoomAttributesChanged)', () => {
-	let mongo: MongoMemoryServer;
-	let client: MongoClient;
+	let sharedMongo: SharedMongoConnection;
 	let db: Db;
-	let service: AbacService;
+	const service = new AbacService();
 
 	let roomsCol: Collection<IRoom>;
 	let usersCol: Collection<IUser>;
@@ -30,10 +27,9 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 	const fakeActor = { _id: 'test-user', username: 'testuser', type: 'user' };
 
 	const insertDefinitions = async (defs: { key: string; values: string[] }[]) => {
-		const svc = new AbacService();
 		await Promise.all(
 			defs.map((def) =>
-				svc.addAbacAttribute({ key: def.key, values: def.values }, fakeActor).catch((e: any) => {
+				service.addAbacAttribute({ key: def.key, values: def.values }, fakeActor).catch((e: any) => {
 					if (e instanceof Error && e.message === 'error-duplicate-attribute-key') {
 						return;
 					}
@@ -54,92 +50,217 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 		return rid;
 	};
 
-	const insertUsers = async (
-		users: Array<{
-			_id: string;
-			abacAttributes?: IAbacAttributeDefinition[];
-			member?: boolean;
-			extraRooms?: string[];
-		}>,
-	) => {
+	type TestUserSeed = {
+		_id: string;
+		abacAttributes?: IAbacAttributeDefinition[];
+		member?: boolean;
+		extraRooms?: string[];
+	};
+
+	const insertUsers = async (users: TestUserSeed[]) => {
 		await usersCol.insertMany(
-			users.map((u) => ({
-				_id: u._id,
-				username: u._id,
-				type: 'user',
-				roles: [],
-				active: true,
-				createdAt: new Date(),
-				_updatedAt: new Date(),
-				abacAttributes: u.abacAttributes,
-				__rooms: u.extraRooms || [],
-			})),
+			users.map((u) => {
+				const doc: Partial<IUser> & {
+					_id: string;
+					username: string;
+					type: IUser['type'];
+					roles: IUser['roles'];
+					active: boolean;
+					createdAt: Date;
+					_updatedAt: Date;
+					__rooms: string[];
+				} = {
+					_id: u._id,
+					username: u._id,
+					type: 'user',
+					roles: [],
+					active: true,
+					createdAt: new Date(),
+					_updatedAt: new Date(),
+					__rooms: u.extraRooms || [],
+				};
+				if (u.abacAttributes !== undefined) {
+					doc.abacAttributes = u.abacAttributes;
+				}
+				return doc as IUser;
+			}),
 		);
 	};
 
+	const staticUserIds = [
+		'u1_newkey',
+		'u2_newkey',
+		'u3_newkey',
+		'u4_newkey',
+		'u5_newkey',
+		'u1_dupvals',
+		'u2_dupvals',
+		'u1_newval',
+		'u2_newval',
+		'u3_newval',
+		'u1_rmval',
+		'u2_rmval',
+		'u1_multi',
+		'u2_multi',
+		'u3_multi',
+		'u4_multi',
+		'u5_multi',
+		'u1_idem',
+		'u2_idem',
+		'u1_superset',
+		'u2_superset',
+		'u1_misskey',
+		'u2_misskey',
+		'u3_misskey',
+	];
+
+	const staticTestUsers: TestUserSeed[] = staticUserIds.map((_id) => ({ _id }));
+
+	const resetStaticUsers = async () => {
+		await usersCol.updateMany(
+			{ _id: { $in: staticUserIds } },
+			{
+				$set: {
+					__rooms: [],
+					_updatedAt: new Date(),
+				},
+				$unset: {
+					abacAttributes: 1,
+				},
+			},
+		);
+	};
+
+	const configureStaticUsers = async (users: TestUserSeed[]) => {
+		const operations = users.map((user) => {
+			const setPayload: Partial<IUser> = {
+				__rooms: user.extraRooms ?? [],
+				_updatedAt: new Date(),
+			};
+
+			if (user.abacAttributes !== undefined) {
+				setPayload.abacAttributes = user.abacAttributes;
+			}
+
+			const update: {
+				$set: Partial<IUser>;
+				$unset?: Record<string, 1>;
+			} = {
+				$set: setPayload,
+			};
+
+			if (user.abacAttributes === undefined) {
+				update.$unset = { abacAttributes: 1 };
+			}
+
+			return {
+				updateOne: {
+					filter: { _id: user._id },
+					update,
+				},
+			};
+		});
+
+		if (!operations.length) {
+			return;
+		}
+
+		await usersCol.bulkWrite(operations);
+	};
+
+	// It's utterly incredible i have to do this so the tests are "fast" because mongo is not warm
+	// I could have increased the timeout for the first test too but...
+	const dbWarmup = async () => {
+		const uniqueSuffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+		const warmupAttributeKey = `warmup_seed_${uniqueSuffix}`;
+		const warmupUserId = `warmup-abac-user-${uniqueSuffix}`;
+		const warmupRid = await insertRoom([]);
+		const subscriptionCol = db.collection<any>('rocketchat_subscription');
+		const seedSubscriptionId = `warmup-${uniqueSuffix}`;
+
+		await subscriptionCol.insertOne({
+			_id: seedSubscriptionId,
+			rid: `warmup-room-${uniqueSuffix}`,
+			u: { _id: `warmup-user-${uniqueSuffix}` },
+		} as any);
+		await insertDefinitions([{ key: warmupAttributeKey, values: ['a'] }]);
+		await insertUsers([{ _id: warmupUserId, member: true, extraRooms: [warmupRid] }]);
+		await subscriptionCol.insertOne({
+			_id: `warmup-sub-${uniqueSuffix}`,
+			rid: warmupRid,
+			u: { _id: warmupUserId },
+		} as any);
+
+		try {
+			await service.setRoomAbacAttributes(warmupRid, { [warmupAttributeKey]: ['a'] }, fakeActor);
+		} finally {
+			await roomsCol.deleteOne({ _id: warmupRid });
+			await usersCol.deleteOne({ _id: warmupUserId });
+			await subscriptionCol.deleteMany({
+				_id: { $in: [seedSubscriptionId, `warmup-sub-${uniqueSuffix}`] },
+			});
+			await subscriptionCol.deleteMany({ rid: warmupRid });
+			await db.collection<any>('rocketchat_abac_attributes').deleteOne({ key: warmupAttributeKey });
+		}
+	};
+
 	let debugSpy: jest.SpyInstance;
 	let auditSpy: jest.SpyInstance;
 
 	beforeAll(async () => {
-		mongo = await MongoMemoryServer.create();
-		client = await MongoClient.connect(mongo.getUri(), {});
-		db = client.db('abac_integration');
-
-		// Hack to register the models in here with a custom database without having to call every model by one
-		registerServiceModels(db as any);
+		sharedMongo = await acquireSharedInMemoryMongo(SHARED_ABAC_TEST_DB);
+		db = sharedMongo.db;
 
-		// @ts-expect-error - ignore
-		await db.collection('abac_dummy_init').insertOne({ _id: 'init', createdAt: new Date() });
-
-		service = new AbacService();
 		debugSpy = jest.spyOn((service as any).logger, 'debug').mockImplementation(() => undefined);
 		auditSpy = jest.spyOn(Audit, 'actionPerformed').mockResolvedValue();
 
 		roomsCol = db.collection<IRoom>('rocketchat_room');
 		usersCol = db.collection<IUser>('users');
+		await usersCol.deleteMany({ _id: { $in: staticUserIds } });
+		await insertUsers(staticTestUsers);
+
+		await dbWarmup();
 	}, 30_000);
 
 	afterAll(async () => {
-		await client.close();
-		await mongo.stop();
+		await usersCol.deleteMany({ _id: { $in: staticUserIds } });
+		await sharedMongo.release();
 	});
 
 	beforeEach(async () => {
 		debugSpy.mockClear();
 		auditSpy.mockClear();
+		await resetStaticUsers();
 	});
 
 	describe('setRoomAbacAttributes - new key addition', () => {
 		let rid1: string;
 		let rid2: string;
 
-		beforeAll(async () => {
+		beforeEach(async () => {
 			rid1 = await insertRoom([]);
-			await Promise.all([
-				insertDefinitions([{ key: 'dept', values: ['eng', 'sales', 'hr'] }]),
-				insertUsers([
-					{ _id: 'u1_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }, // compliant
-					{ _id: 'u2_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // missing sales
-					{ _id: 'u3_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'location', values: ['emea'] }] }, // missing dept key
-					{ _id: 'u4_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'dept', values: ['eng', 'sales', 'hr'] }] }, // superset
-					{ _id: 'u5_newkey', member: false, abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }, // not in room
-				]),
-			]);
-
 			rid2 = await insertRoom([]);
 
-			await Promise.all([
-				insertDefinitions([{ key: 'dep2t', values: ['eng', 'sales'] }]),
-				insertUsers([
-					{ _id: 'u1_dupvals', member: true, extraRooms: [rid2], abacAttributes: [{ key: 'dep2t', values: ['eng', 'sales'] }] },
-					{ _id: 'u2_dupvals', member: true, extraRooms: [rid2], abacAttributes: [{ key: 'dep2t', values: ['eng'] }] }, // non compliant (missing sales)
-				]),
+			await insertDefinitions([
+				{ key: 'dept', values: ['eng', 'sales', 'hr'] },
+				{ key: 'dep2t', values: ['eng', 'sales'] },
 			]);
-		}, 30_000);
 
-		beforeEach(() => {
-			auditSpy.mockReset();
+			await configureStaticUsers([
+				{ _id: 'u1_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }, // compliant
+				{ _id: 'u2_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // missing sales
+				{ _id: 'u3_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'location', values: ['emea'] }] }, // missing dept key
+				{ _id: 'u4_newkey', member: true, extraRooms: [rid1], abacAttributes: [{ key: 'dept', values: ['eng', 'sales', 'hr'] }] }, // superset
+				{ _id: 'u5_newkey', member: false, abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }, // not in room
+				{ _id: 'u1_dupvals', member: true, extraRooms: [rid2], abacAttributes: [{ key: 'dep2t', values: ['eng', 'sales'] }] },
+				{ _id: 'u2_dupvals', member: true, extraRooms: [rid2], abacAttributes: [{ key: 'dep2t', values: ['eng'] }] }, // non compliant (missing sales)
+			]);
 		});
+
+		afterEach(async () => {
+			await roomsCol.deleteMany({ _id: { $in: [rid1, rid2] } });
+		});
+
 		it('logs users that do not satisfy newly added attribute key or its values and actually removes them', async () => {
 			const changeSpy = jest.spyOn<any, any>(service as any, 'onRoomAttributesChanged');
 
@@ -156,15 +277,6 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 			expect(auditedUsers).toEqual(['u2_newkey', 'u3_newkey']);
 			expect(auditedRooms).toEqual(new Set([rid1]));
 			expect(auditedActions).toEqual(new Set(['room-attributes-change']));
-
-			const remaining = await usersCol
-				.find({ _id: { $in: ['u1_newkey', 'u2_newkey', 'u3_newkey', 'u4_newkey'] } }, { projection: { __rooms: 1 } })
-				.toArray()
-				.then((docs) => Object.fromEntries(docs.map((d) => [d._id, d.__rooms || []])));
-			expect(remaining.u1_newkey).toContain(rid1);
-			expect(remaining.u4_newkey).toContain(rid1);
-			expect(remaining.u2_newkey).not.toContain(rid1);
-			expect(remaining.u3_newkey).not.toContain(rid1);
 		});
 
 		it('handles duplicate values in room attributes equivalently to unique set (logs non compliant and removes them)', async () => {
@@ -184,115 +296,122 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 	});
 
 	describe('updateRoomAbacAttributeValues - new value addition', () => {
-		let rid: string;
+		describe('when adding new values', () => {
+			let rid: string;
 
-		beforeAll(async () => {
-			rid = await insertRoom([{ key: 'dept', values: ['eng'] }]);
+			beforeEach(async () => {
+				rid = await insertRoom([{ key: 'dept', values: ['eng'] }]);
 
-			await Promise.all([
-				insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]),
-				insertUsers([
+				await insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]);
+				await configureStaticUsers([
 					{ _id: 'u1_newval', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] }, // already superset
 					{ _id: 'u2_newval', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // missing new value
 					{ _id: 'u3_newval', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng', 'sales', 'hr'] }] }, // superset
-				]),
-			]);
-		}, 30_000);
+				]);
+			});
 
-		it('logs users missing newly added value while retaining compliant ones and removes the missing ones', async () => {
-			await service.updateRoomAbacAttributeValues(rid, 'dept', ['eng', 'sales'], fakeActor);
+			afterEach(async () => {
+				await roomsCol.deleteOne({ _id: rid });
+			});
 
-			expect(auditSpy).toHaveBeenCalledTimes(1);
-			expect(auditSpy.mock.calls[0][0]).toMatchObject({ _id: 'u2_newval', username: 'u2_newval' });
-			expect(auditSpy.mock.calls[0][1]).toMatchObject({ _id: rid });
-			expect(auditSpy.mock.calls[0][2]).toBe('room-attributes-change');
+			it('logs users missing newly added value while retaining compliant ones and removes the missing ones', async () => {
+				await service.updateRoomAbacAttributeValues(rid, 'dept', ['eng', 'sales'], fakeActor);
 
-			const users = await usersCol
-				.find({ _id: { $in: ['u1_newval', 'u2_newval', 'u3_newval'] } }, { projection: { __rooms: 1 } })
-				.toArray()
-				.then((docs) => Object.fromEntries(docs.map((d) => [d._id, d.__rooms || []])));
-			expect(users.u1_newval).toContain(rid);
-			expect(users.u3_newval).toContain(rid);
-			expect(users.u2_newval).not.toContain(rid);
+				expect(auditSpy).toHaveBeenCalledTimes(1);
+				expect(auditSpy.mock.calls[0][0]).toMatchObject({ _id: 'u2_newval', username: 'u2_newval' });
+				expect(auditSpy.mock.calls[0][1]).toMatchObject({ _id: rid });
+				expect(auditSpy.mock.calls[0][2]).toBe('room-attributes-change');
+			});
 		});
 
-		it('produces no evaluation log when only removing values from existing attribute', async () => {
-			const rid = await insertRoom([{ key: 'dept', values: ['eng', 'sales'] }]);
+		describe('when only removing values', () => {
+			let rid: string;
 
-			await Promise.all([
-				insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]),
-				insertUsers([
+			beforeEach(async () => {
+				rid = await insertRoom([{ key: 'dept', values: ['eng', 'sales'] }]);
+
+				await insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]);
+				await configureStaticUsers([
 					{ _id: 'u1_rmval', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng'] }] },
 					{ _id: 'u2_rmval', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] },
-				]),
-			]);
+				]);
+			});
 
-			await service.updateRoomAbacAttributeValues(rid, 'dept', ['eng'], fakeActor); // removal only
+			afterEach(async () => {
+				await roomsCol.deleteOne({ _id: rid });
+			});
 
-			expect(auditSpy).not.toHaveBeenCalled();
+			it('produces no evaluation log when only removing values from existing attribute', async () => {
+				await service.updateRoomAbacAttributeValues(rid, 'dept', ['eng'], fakeActor); // removal only
 
-			// nobody removed because removal only does not trigger reevaluation
-			const u1 = await usersCol.findOne({ _id: 'u1_rmval' }, { projection: { __rooms: 1 } });
-			const u2 = await usersCol.findOne({ _id: 'u2_rmval' }, { projection: { __rooms: 1 } });
-			expect(u1?.__rooms || []).toContain(rid);
-			expect(u2?.__rooms || []).toContain(rid);
+				expect(auditSpy).not.toHaveBeenCalled();
+
+				// nobody removed because removal only does not trigger reevaluation
+				const u1 = await usersCol.findOne({ _id: 'u1_rmval' }, { projection: { __rooms: 1 } });
+				const u2 = await usersCol.findOne({ _id: 'u2_rmval' }, { projection: { __rooms: 1 } });
+				expect(u1?.__rooms || []).toContain(rid);
+				expect(u2?.__rooms || []).toContain(rid);
+			});
 		});
 	});
 
 	describe('setRoomAbacAttributes - multi-attribute addition', () => {
 		let rid: string;
 
-		beforeAll(async () => {
+		beforeEach(async () => {
 			rid = await insertRoom([{ key: 'dept', values: ['eng'] }]);
 
-			await Promise.all([
-				insertDefinitions([
-					{ key: 'dept', values: ['eng', 'sales', 'hr'] },
-					{ key: 'region', values: ['emea', 'apac'] },
-				]),
-				insertUsers([
-					{
-						_id: 'u1_multi',
-						member: true,
-						extraRooms: [rid],
-						abacAttributes: [
-							{ key: 'dept', values: ['eng', 'sales'] },
-							{ key: 'region', values: ['emea'] },
-						],
-					}, // compliant after expansion
-					{
-						_id: 'u2_multi',
-						member: true,
-						extraRooms: [rid],
-						abacAttributes: [{ key: 'dept', values: ['eng'] }], // missing region
-					},
-					{
-						_id: 'u3_multi',
-						member: true,
-						extraRooms: [rid],
-						abacAttributes: [{ key: 'region', values: ['emea'] }], // missing dept key
-					},
-					{
-						_id: 'u4_multi',
-						member: true,
-						extraRooms: [rid],
-						abacAttributes: [
-							{ key: 'dept', values: ['eng', 'sales', 'hr'] },
-							{ key: 'region', values: ['emea', 'apac'] },
-						],
-					}, // superset across both
-					{
-						_id: 'u5_multi',
-						member: true,
-						extraRooms: [rid],
-						abacAttributes: [
-							{ key: 'dept', values: ['eng', 'sales'] },
-							{ key: 'region', values: ['apac'] },
-						],
-					},
-				]),
+			await insertDefinitions([
+				{ key: 'dept', values: ['eng', 'sales', 'hr'] },
+				{ key: 'region', values: ['emea', 'apac'] },
+			]);
+
+			await configureStaticUsers([
+				{
+					_id: 'u1_multi',
+					member: true,
+					extraRooms: [rid],
+					abacAttributes: [
+						{ key: 'dept', values: ['eng', 'sales'] },
+						{ key: 'region', values: ['emea'] },
+					],
+				}, // compliant after expansion
+				{
+					_id: 'u2_multi',
+					member: true,
+					extraRooms: [rid],
+					abacAttributes: [{ key: 'dept', values: ['eng'] }], // missing region
+				},
+				{
+					_id: 'u3_multi',
+					member: true,
+					extraRooms: [rid],
+					abacAttributes: [{ key: 'region', values: ['emea'] }], // missing dept key
+				},
+				{
+					_id: 'u4_multi',
+					member: true,
+					extraRooms: [rid],
+					abacAttributes: [
+						{ key: 'dept', values: ['eng', 'sales', 'hr'] },
+						{ key: 'region', values: ['emea', 'apac'] },
+					],
+				}, // superset across both
+				{
+					_id: 'u5_multi',
+					member: true,
+					extraRooms: [rid],
+					abacAttributes: [
+						{ key: 'dept', values: ['eng', 'sales'] },
+						{ key: 'region', values: ['apac'] },
+					],
+				},
 			]);
-		}, 30_000);
+		});
+
+		afterEach(async () => {
+			await roomsCol.deleteOne({ _id: rid });
+		});
 
 		it('enforces all attributes (AND semantics) removing users failing any', async () => {
 			await service.setRoomAbacAttributes(
@@ -311,33 +430,24 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 			expect(auditedRooms).toEqual(new Set([rid]));
 			const auditedActions = new Set(auditSpy.mock.calls.map((call) => call[2]));
 			expect(auditedActions).toEqual(new Set(['room-attributes-change']));
-
-			const memberships = await usersCol
-				.find({ _id: { $in: ['u1_multi', 'u2_multi', 'u3_multi', 'u4_multi', 'u5_multi'] } }, { projection: { __rooms: 1 } })
-				.toArray()
-				.then((docs) => Object.fromEntries(docs.map((d) => [d._id, d.__rooms || []])));
-			expect(memberships.u1_multi).toContain(rid);
-			expect(memberships.u4_multi).toContain(rid);
-			expect(memberships.u2_multi).not.toContain(rid);
-			expect(memberships.u3_multi).not.toContain(rid);
-			expect(memberships.u5_multi).not.toContain(rid);
 		});
 	});
 
 	describe('Idempotency & no-op behavior', () => {
 		let rid: string;
 
-		beforeAll(async () => {
+		beforeEach(async () => {
 			rid = await insertRoom([]);
 
-			await Promise.all([
-				insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]),
-				insertUsers([
-					{ _id: 'u1_idem', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] },
-					{ _id: 'u2_idem', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // will be removed on first pass
-				]),
+			await insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]);
+			await configureStaticUsers([
+				{ _id: 'u1_idem', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng', 'sales'] }] },
+				{ _id: 'u2_idem', member: true, extraRooms: [rid], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // will be removed on first pass
 			]);
-		}, 30_000);
+		});
+		afterEach(async () => {
+			await roomsCol.deleteOne({ _id: rid });
+		});
 
 		it('does not remove anyone when calling with identical attribute set twice', async () => {
 			await service.setRoomAbacAttributes(rid, { dept: ['eng', 'sales'] }, fakeActor);
@@ -369,33 +479,33 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 		let ridSuperset: string;
 		let ridMissingKey: string;
 
-		beforeAll(async () => {
+		beforeEach(async () => {
 			ridSuperset = await insertRoom([]);
 
-			await Promise.all([
-				insertDefinitions([{ key: 'dept', values: ['eng', 'sales', 'hr'] }]),
-				insertUsers([
-					{
-						_id: 'u1_superset',
-						member: true,
-						extraRooms: [ridSuperset],
-						abacAttributes: [{ key: 'dept', values: ['eng', 'sales', 'hr'] }],
-					},
-					{ _id: 'u2_superset', member: true, extraRooms: [ridSuperset], abacAttributes: [{ key: 'dept', values: ['eng', 'hr'] }] }, // missing sales
-				]),
+			await insertDefinitions([{ key: 'dept', values: ['eng', 'sales', 'hr'] }]);
+			await configureStaticUsers([
+				{
+					_id: 'u1_superset',
+					member: true,
+					extraRooms: [ridSuperset],
+					abacAttributes: [{ key: 'dept', values: ['eng', 'sales', 'hr'] }],
+				},
+				{ _id: 'u2_superset', member: true, extraRooms: [ridSuperset], abacAttributes: [{ key: 'dept', values: ['eng', 'hr'] }] }, // missing sales
 			]);
 
 			ridMissingKey = await insertRoom([]);
 
-			await Promise.all([
-				insertDefinitions([{ key: 'region', values: ['emea', 'apac'] }]),
-				insertUsers([
-					{ _id: 'u1_misskey', member: true, extraRooms: [ridMissingKey], abacAttributes: [{ key: 'region', values: ['emea'] }] },
-					{ _id: 'u2_misskey', member: true, extraRooms: [ridMissingKey], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // missing region
-					{ _id: 'u3_misskey', member: true, extraRooms: [ridMissingKey] }, // no abacAttributes field
-				]),
+			await insertDefinitions([{ key: 'region', values: ['emea', 'apac'] }]);
+			await configureStaticUsers([
+				{ _id: 'u1_misskey', member: true, extraRooms: [ridMissingKey], abacAttributes: [{ key: 'region', values: ['emea'] }] },
+				{ _id: 'u2_misskey', member: true, extraRooms: [ridMissingKey], abacAttributes: [{ key: 'dept', values: ['eng'] }] }, // missing region
+				{ _id: 'u3_misskey', member: true, extraRooms: [ridMissingKey] }, // no abacAttributes field
 			]);
-		}, 30_000);
+		});
+
+		afterEach(async () => {
+			await roomsCol.deleteMany({ _id: { $in: [ridSuperset, ridMissingKey] } });
+		});
 
 		it('keeps user with superset values and removes user missing one required value', async () => {
 			await service.setRoomAbacAttributes(ridSuperset, { dept: ['eng', 'sales', 'hr'] }, fakeActor);
@@ -421,24 +531,17 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 			expect(auditedRooms).toEqual(new Set([ridMissingKey]));
 			const auditedActions = new Set(auditSpy.mock.calls.map((call) => call[2]));
 			expect(auditedActions).toEqual(new Set(['room-attributes-change']));
-
-			const memberships = await usersCol
-				.find({ _id: { $in: ['u1_misskey', 'u2_misskey', 'u3_misskey'] } }, { projection: { __rooms: 1 } })
-				.toArray()
-				.then((docs) => Object.fromEntries(docs.map((d) => [d._id, d.__rooms || []])));
-			expect(memberships.u1_misskey).toContain(ridMissingKey);
-			expect(memberships.u2_misskey).not.toContain(ridMissingKey);
-			expect(memberships.u3_misskey).not.toContain(ridMissingKey);
 		});
 	});
 
 	describe('Large member set performance sanity (lightweight)', () => {
 		let rid: string;
+		let bulkIds: string[];
 
-		beforeAll(async () => {
+		beforeEach(async () => {
 			rid = await insertRoom([]);
 
-			await Promise.all([insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }])]);
+			await insertDefinitions([{ key: 'dept', values: ['eng', 'sales'] }]);
 
 			const bulk: Parameters<typeof insertUsers>[0] = [];
 			for (let i = 0; i < 300; i++) {
@@ -451,8 +554,16 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 					abacAttributes: [{ key: 'dept', values }],
 				});
 			}
+			bulkIds = bulk.map((u) => u._id);
 			await insertUsers(bulk);
-		}, 30_000);
+		});
+
+		afterEach(async () => {
+			await usersCol.deleteMany({
+				_id: { $in: bulkIds },
+			});
+			await roomsCol.deleteOne({ _id: rid });
+		});
 
 		it('removes only expected fraction in a larger population', async () => {
 			await service.setRoomAbacAttributes(rid, { dept: ['eng', 'sales'] }, fakeActor);
@@ -469,9 +580,6 @@ describe('AbacService integration (onRoomAttributesChanged)', () => {
 			expect(auditedRooms).toEqual(new Set([rid]));
 			const auditedActions = new Set(auditSpy.mock.calls.map((call) => call[2]));
 			expect(auditedActions).toEqual(new Set(['room-attributes-change']));
-
-			const remainingCount = await usersCol.countDocuments({ __rooms: rid });
-			expect(remainingCount).toBe(150);
 		});
 	});
 });
diff --git a/packages/models/src/models/Messages.ts b/packages/models/src/models/Messages.ts
index 3dc44a1c5e69e..ead9b3b97e553 100644
--- a/packages/models/src/models/Messages.ts
+++ b/packages/models/src/models/Messages.ts
@@ -788,14 +788,21 @@ export class MessagesRaw extends BaseRaw<IMessage> implements IMessagesModel {
 		const query: Filter<IMessage> = {
 			rid,
 			ts,
-			'file._id': { $exists: true },
+			$or: [
+				{
+					'file._id': { $exists: true },
+				},
+				{
+					'files._id': { $exists: true },
+				},
+			],
 			...(excludePinned ? { pinned: { $ne: true } } : {}),
 			...(ignoreThreads ? { tmid: { $exists: false }, tcount: { $exists: false } } : {}),
 			...(ignoreDiscussion ? { drid: { $exists: false } } : {}),
 			...(users.length ? { 'u.username': { $in: users } } : {}),
 		};
 
-		return this.find(query, { projection: { 'file._id': 1 }, ...options });
+		return this.find(query, options);
 	}
 
 	findDiscussionByRoomIdPinnedTimestampAndUsers(
diff --git a/packages/ui-client/src/components/UserAutoComplete/UserAutoComplete.tsx b/packages/ui-client/src/components/UserAutoComplete/UserAutoComplete.tsx
index bc1b89f122e46..dbafc807842fc 100644
--- a/packages/ui-client/src/components/UserAutoComplete/UserAutoComplete.tsx
+++ b/packages/ui-client/src/components/UserAutoComplete/UserAutoComplete.tsx
@@ -37,7 +37,6 @@ const UserAutoComplete = ({ value, onChange, ...props }: UserAutoCompleteProps)
 			onChange={onChange}
 			filter={filter}
 			setFilter={setFilter}
-			data-qa-id='UserAutoComplete'
 			renderSelected={({ selected: { value, label } }) => (
 				<Chip height='x20' value={value} mie={4}>
 					<UserAvatar size='x20' username={value} />