@wireapp/core 46.46.6-beta.10.d7a6c4c53 → 46.46.6-beta.14.f6fd03fe6

package/lib/conversation/ConversationService/ConversationService.test.js

@@ -45,13 +45,10 @@ const client_1 = require("@wireapp/api-client/lib/client");
 const conversation_1 = require("@wireapp/api-client/lib/conversation");
 const event_1 = require("@wireapp/api-client/lib/event");
 const http_1 = require("@wireapp/api-client/lib/http");
-const team_1 = require("@wireapp/api-client/lib/team");
 const http_status_codes_1 = require("http-status-codes");
 const api_client_1 = require("@wireapp/api-client");
-const core_crypto_1 = require("@wireapp/core-crypto");
 const __1 = require("..");
 const CoreCryptoMLSError_1 = require("../../messagingProtocols/mls/MLSService/CoreCryptoMLSError");
-const MLSService_1 = require("../../messagingProtocols/mls/MLSService/MLSService");
 const MessagingProtocols = __importStar(require("../../messagingProtocols/proteus"));
 const CoreDB_1 = require("../../storage/CoreDB");
 const PayloadHelper = __importStar(require("../../test/PayloadHelper"));
@@ -89,14 +86,9 @@ const mockedProteusService = {
     encryptGenericMessage: () => Promise.resolve(),
     sendProteusMessage: () => Promise.resolve({ sentAt: new Date() }),
 };
-const apiClients = [];
 describe('ConversationService', () => {
-    afterAll(() => {
-        apiClients.forEach(client => client.disconnect());
-    });
     async function buildConversationService() {
         const client = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
-        apiClients.push(client);
         jest.spyOn(client.api.conversation, 'postMlsMessage').mockReturnValue(Promise.resolve({
             events: [],
             time: new Date().toISOString(),
@@ -114,14 +106,13 @@ describe('ConversationService', () => {
         }));
         jest
             .spyOn(client.api.user, 'getUserSupportedProtocols')
-            .mockReturnValue(Promise.resolve([team_1.CONVERSATION_PROTOCOL.MLS, team_1.CONVERSATION_PROTOCOL.PROTEUS]));
+            .mockReturnValue(Promise.resolve([conversation_1.ConversationProtocol.MLS, conversation_1.ConversationProtocol.PROTEUS]));
         client.context = {
             clientType: client_1.ClientType.NONE,
             userId: PayloadHelper.getUUID(),
             clientId: PayloadHelper.getUUID(),
         };
         const mockedMLSService = {
-            on: jest.fn(),
             encryptMessage: () => { },
             commitPendingProposals: () => Promise.resolve(),
             getEpoch: () => Promise.resolve(),
@@ -133,10 +124,8 @@ describe('ConversationService', () => {
             conversationExists: jest.fn(),
             isConversationEstablished: jest.fn(),
             tryEstablishingMLSGroup: jest.fn(),
-            getClientIdsInGroup: jest.fn(),
             getKeyPackagesPayload: jest.fn(),
             addUsersToExistingConversation: jest.fn(),
-            removeClientsFromConversation: jest.fn(),
             resetKeyMaterialRenewal: jest.fn(),
             handleMLSWelcomeMessageEvent: jest.fn(),
         };
@@ -145,7 +134,7 @@ describe('ConversationService', () => {
         const mockedSubconversationService = {
             joinConferenceSubconversation: jest.fn(),
         };
-        const conversationService = new __1.ConversationService(client, mockedProteusService, mockedDb, groupIdFromConversationId, mockedSubconversationService, () => Promise.resolve(true), mockedMLSService);
+        const conversationService = new __1.ConversationService(client, mockedProteusService, mockedDb, groupIdFromConversationId, mockedSubconversationService, mockedMLSService);
         jest.spyOn(conversationService, 'joinByExternalCommit');
         jest.spyOn(conversationService, 'emit');
         return [
@@ -168,7 +157,7 @@ describe('ConversationService', () => {
                 const sentTime = new Date().toISOString();
                 mockedProteusService.sendMessage = jest.fn().mockResolvedValue({ sentAt: sentTime });
                 const promise = conversationService.send({
-                    protocol: team_1.CONVERSATION_PROTOCOL.PROTEUS,
+                    protocol: conversation_1.ConversationProtocol.PROTEUS,
                     conversationId: { id: 'conv1', domain: '' },
                     payload: message,
                 });
@@ -177,80 +166,6 @@ describe('ConversationService', () => {
             });
         });
     });
-    describe('removeUsersFromMLSConversation', () => {
-        it('recovers and retries when stale-message occurs during remove users commit upload', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const mockGroupId = 'groupId-stale-remove';
-            const mockConversationId = { id: PayloadHelper.getUUID(), domain: 'staging.zinfra.io' };
-            const qualifiedUserIds = [
-                { id: 'test-id-1', domain: 'test-domain' },
-                { id: 'test-id-2', domain: 'test-domain' },
-            ];
-            const staleMessageError = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
-                    },
-                },
-            };
-            // First removal attempt fails with stale, second succeeds
-            jest
-                .spyOn(mlsService, 'removeClientsFromConversation')
-                .mockRejectedValueOnce(staleMessageError)
-                .mockResolvedValueOnce(undefined);
-            const remoteEpoch = 6;
-            const localEpoch = 5;
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
-            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
-            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValue({
-                qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                epoch: remoteEpoch,
-                group_id: mockGroupId,
-            });
-            await conversationService.removeUsersFromMLSConversation({
-                groupId: mockGroupId,
-                conversationId: mockConversationId,
-                qualifiedUserIds,
-            });
-            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
-            expect(mlsService.removeClientsFromConversation).toHaveBeenCalledTimes(2);
-            expect(mlsService.resetKeyMaterialRenewal).toHaveBeenCalledWith(mockGroupId);
-        });
-    });
-    describe('joinByExternalCommit', () => {
-        it('retries join when stale-message occurs during external commit join', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const conversationId = { id: 'conv-join-stale', domain: 'staging.zinfra.io' };
-            const staleMessageError = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
-                    },
-                },
-            };
-            jest
-                .spyOn(mlsService, 'joinByExternalCommit')
-                .mockRejectedValueOnce(staleMessageError)
-                .mockResolvedValueOnce(undefined);
-            const remoteEpoch = 10;
-            const localEpoch = 9;
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
-            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
-            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
-                qualified_id: conversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                epoch: remoteEpoch,
-                group_id: 'gid-join-stale',
-            });
-            await conversationService.joinByExternalCommit(conversationId);
-            expect(mlsService.joinByExternalCommit).toHaveBeenCalledTimes(2);
-        });
-    });
     describe('"send MLS"', () => {
         const groupId = PayloadHelper.getUUID();
         const messages = [
@@ -266,7 +181,7 @@ describe('ConversationService', () => {
             it(`calls callbacks when sending '${type}' message is starting and successful`, async () => {
                 const [conversationService] = await buildConversationService();
                 const promise = conversationService.send({
-                    protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                    protocol: conversation_1.ConversationProtocol.MLS,
                     groupId,
                     payload: message,
                     conversationId: { id: '', domain: '' },
@@ -275,62 +190,26 @@ describe('ConversationService', () => {
                 expect(result.state).toBe(__1.MessageSendingState.OUTGOING_SENT);
             });
         });
-        it('rejoins a MLS group when stale-message error occurs during commit bundle upload', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const mockGroupId = 'AAEAAH87aajaQ011i+rNLmwpy0sAZGl5YS53aXJlamxpbms=';
-            const mockConversationId = { id: 'mockConversationId', domain: 'staging.zinfra.io' };
-            const mockedMessage = MessageBuilder.buildTextMessage({ text: 'test' });
-            const staleMessageError = new conversation_1.MLSStaleMessageError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_status_codes_1.StatusCodes.CONFLICT);
-            // First attempt to upload commit bundle fails with stale-message, second attempt succeeds
-            jest
-                .spyOn(mlsService, 'commitPendingProposals')
-                .mockRejectedValueOnce(staleMessageError)
-                .mockResolvedValueOnce(undefined);
-            const remoteEpoch = 5;
-            const localEpoch = 4;
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
-            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
-            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
-                qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                epoch: remoteEpoch,
-                group_id: mockGroupId,
-            });
-            await conversationService.send({
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                groupId: mockGroupId,
-                payload: mockedMessage,
-                conversationId: mockConversationId,
-            });
-            // Recovery via external commit should have been triggered
-            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
-            expect(conversationService.emit).toHaveBeenCalledWith('MLSConversationRecovered', {
-                conversationId: mockConversationId,
-            });
-            // Because the failure happened before posting the message, postMlsMessage should be called only once (after recovery)
-            expect(apiClient.api.conversation.postMlsMessage).toHaveBeenCalledTimes(1);
-            // commitPendingProposals is called twice: first fails, second succeeds
-            expect(mlsService.commitPendingProposals).toHaveBeenCalledTimes(2);
-        });
         it('rejoins a MLS group when failed encrypting MLS message', async () => {
             const [conversationService, { apiClient, mlsService }] = await buildConversationService();
             const mockGroupId = 'AAEAAH87aajaQ011i+rNLmwpy0sAZGl5YS53aXJlamxpbms=';
             const mockConversationId = { id: 'mockConversationId', domain: 'staging.zinfra.io' };
             const mockedMessage = MessageBuilder.buildTextMessage({ text: 'test' });
-            const staleMessageError = new conversation_1.MLSStaleMessageError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_status_codes_1.StatusCodes.CONFLICT);
-            jest.spyOn(apiClient.api.conversation, 'postMlsMessage').mockRejectedValueOnce(staleMessageError);
+            jest
+                .spyOn(apiClient.api.conversation, 'postMlsMessage')
+                .mockRejectedValueOnce(new http_1.BackendError('', http_1.BackendErrorLabel.MLS_STALE_MESSAGE, http_status_codes_1.StatusCodes.CONFLICT));
             const remoteEpoch = 5;
             const localEpoch = 4;
             jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             await conversationService.send({
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 groupId: mockGroupId,
                 payload: mockedMessage,
                 conversationId: mockConversationId,
@@ -341,34 +220,6 @@ describe('ConversationService', () => {
             });
             expect(apiClient.api.conversation.postMlsMessage).toHaveBeenCalledTimes(2);
         });
-        it('adds missing users to MLS group and retries when group is out of sync during send', async () => {
-            const [conversationService, { apiClient }] = await buildConversationService();
-            const mockGroupId = 'AAEAAH87aajaQ011i+rNLmwpy0sAZGl5YS53aXJlamxpbms=';
-            const mockConversationId = { id: 'mockConversationId', domain: 'staging.zinfra.io' };
-            const mockedMessage = MessageBuilder.buildTextMessage({ text: 'test' });
-            const missingUsers = [
-                { id: 'user-1', domain: 'staging.zinfra.io' },
-                { id: 'user-2', domain: 'staging.zinfra.io' },
-            ];
-            const outOfSyncError = new conversation_1.MLSGroupOutOfSyncError(http_status_codes_1.StatusCodes.CONFLICT, missingUsers, http_1.BackendErrorLabel.MLS_GROUP_OUT_OF_SYNC);
-            // First send fails with out-of-sync, second succeeds via default mock
-            jest.spyOn(apiClient.api.conversation, 'postMlsMessage').mockRejectedValueOnce(outOfSyncError);
-            const addUsersSpy = jest
-                .spyOn(conversationService, 'performAddUsersToMLSConversationAPI')
-                .mockResolvedValueOnce({ conversation: { members: { others: [] } } });
-            await conversationService.send({
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                groupId: mockGroupId,
-                payload: mockedMessage,
-                conversationId: mockConversationId,
-            });
-            expect(addUsersSpy).toHaveBeenCalledWith({
-                groupId: mockGroupId,
-                conversationId: mockConversationId,
-                qualifiedUsers: missingUsers,
-            });
-            expect(apiClient.api.conversation.postMlsMessage).toHaveBeenCalledTimes(2);
-        });
     });
     describe('handleConversationsEpochMismatch', () => {
         beforeEach(() => {
@@ -378,7 +229,7 @@ describe('ConversationService', () => {
             return {
                 group_id: 'group-id',
                 qualified_id: { id: conversationId || 'conversation-id', domain: 'staging.zinfra.io' },
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch,
             };
         };
@@ -428,7 +279,7 @@ describe('ConversationService', () => {
             const remoteEpoch = 1;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
@@ -447,19 +298,19 @@ describe('ConversationService', () => {
             const updatedEpoch = 2;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 2nd request we make after joining the conversation with external commit
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: updatedEpoch,
                 group_id: mockGroupId,
             });
             jest.spyOn(mlsService, 'isConversationEstablished').mockResolvedValueOnce(false);
-            jest.spyOn(mlsService, 'joinByExternalCommit');
+            jest.spyOn(mlsService, 'joinByExternalCommit').mockResolvedValueOnce({ events: [], time: '' });
             const establishedConversation = await conversationService.establishMLS1to1Conversation(mockGroupId, selfUser, otherUserId);
             expect(mlsService.registerConversation).not.toHaveBeenCalled();
             expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
@@ -475,14 +326,14 @@ describe('ConversationService', () => {
             const updatedEpoch = 1;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 2nd request we make after successfully registering a group
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: updatedEpoch,
                 group_id: mockGroupId,
             });
@@ -504,21 +355,21 @@ describe('ConversationService', () => {
             const updatedEpoch = 1;
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 2nd request we make when retrying to register the conversation
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
             // The 3rd request we make after successfully registering a group
             jest.spyOn(apiClient.api.conversation, 'getMLS1to1Conversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: updatedEpoch,
                 group_id: mockGroupId,
             });
@@ -547,7 +398,7 @@ describe('ConversationService', () => {
             jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: conversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: remoteEpoch,
                 group_id: mockGroupId,
             });
@@ -581,46 +432,19 @@ describe('ConversationService', () => {
             expect(subconversationService.joinConferenceSubconversation).toHaveBeenCalledWith(conversationId, 'groupId');
         });
         it('joins a MLS conversation if it was sent an orphan welcome message', async () => {
-            const [conversationService, { mlsService }] = await buildConversationService();
+            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
             const conversationId = { id: 'conversationId', domain: 'staging.zinfra.io' };
             const mockMLSWelcomeMessageEvent = createMLSWelcomeMessageEventMock(conversationId);
             const orphanWelcomeMessageError = new Error();
-            // Simulate core-crypto orphan welcome classification for mapper
-            orphanWelcomeMessageError.name = core_crypto_1.MlsErrorType.OrphanWelcome;
-            orphanWelcomeMessageError.context = { type: core_crypto_1.MlsErrorType.OrphanWelcome };
-            orphanWelcomeMessageError.type = core_crypto_1.ErrorType.Mls;
+            orphanWelcomeMessageError.name = CoreCryptoMLSError_1.CORE_CRYPTO_ERROR_NAMES.MlsErrorOrphanWelcomeMessage;
             jest.spyOn(mlsService, 'handleMLSWelcomeMessageEvent').mockRejectedValueOnce(orphanWelcomeMessageError);
-            // Ensure welcome processing is attempted (succeeds after recovery join)
-            jest.spyOn(mlsService, 'handleMLSWelcomeMessageEvent').mockResolvedValueOnce(undefined);
-            await conversationService.handleEvent(mockMLSWelcomeMessageEvent);
-            await new Promise(resolve => setImmediate(resolve));
-            // Orchestrator triggers a low-level join (performJoinByExternalCommitAPI -> mlsService.joinByExternalCommit)
-            expect(mlsService.joinByExternalCommit).toHaveBeenCalled();
-        });
-        it('wipes local MLS state and retries when welcome fails with ConversationAlreadyExists', async () => {
-            const [conversationService, { mlsService }] = await buildConversationService();
-            const conversationId = { id: 'conversationId', domain: 'staging.zinfra.io' };
-            const mockMLSWelcomeMessageEvent = createMLSWelcomeMessageEventMock(conversationId);
-            // Create a base64 group id and its byte-array form to simulate core-crypto error context
-            const expectedGroupId = 'AXNhbXBsZQ=='; // base64 for '\u0001sample'
-            const conversationIdArray = Array.from(Buffer.from(expectedGroupId, 'base64'));
-            const existsError = {};
-            // Simulate core-crypto "conversation already exists" classification for the mapper
-            existsError.type = core_crypto_1.ErrorType.Mls;
-            existsError.context = {
-                type: core_crypto_1.MlsErrorType.ConversationAlreadyExists,
-                context: { conversationId: conversationIdArray },
-            };
-            const welcomeSpy = jest
-                .spyOn(mlsService, 'handleMLSWelcomeMessageEvent')
-                .mockRejectedValueOnce(existsError)
-                .mockResolvedValueOnce(undefined);
+            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
+                qualified_id: conversationId,
+                protocol: conversation_1.ConversationProtocol.MLS,
+            });
             await conversationService.handleEvent(mockMLSWelcomeMessageEvent);
             await new Promise(resolve => setImmediate(resolve));
-            // Expect a single wipe with the extracted group id, and a single retry of welcome handling
-            expect(mlsService.wipeConversation).toHaveBeenCalledTimes(1);
-            expect(mlsService.wipeConversation).toHaveBeenCalledWith(expectedGroupId);
-            expect(welcomeSpy).toHaveBeenCalledTimes(2);
+            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(conversationId);
         });
     });
     describe('getConversations', () => {
@@ -687,22 +511,21 @@ describe('ConversationService', () => {
                 .map(() => ({ id: PayloadHelper.getUUID(), domain: 'local.wire.com' }));
             const selfUserToAdd = { id: 'self-user-id', domain: 'local.wire.com', skipOwnClientId: apiClient.clientId };
             const qualifiedUsers = [...otherUsersToAdd, selfUserToAdd];
-            jest
-                .spyOn(mlsService, 'getKeyPackagesPayload')
-                .mockResolvedValueOnce({ keyPackages: [new Uint8Array(0)], failures: [] });
+            jest.spyOn(mlsService, 'getKeyPackagesPayload').mockResolvedValueOnce({ keyPackages: [], failures: [] });
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: 1,
                 group_id: mockGroupId,
             });
-            jest.spyOn(mlsService, 'addUsersToExistingConversation');
+            const mlsMessage = { events: [], time: '', failures: [] };
+            jest.spyOn(mlsService, 'addUsersToExistingConversation').mockResolvedValueOnce(mlsMessage);
             await conversationService.addUsersToMLSConversation({
                 qualifiedUsers,
                 groupId: mockGroupId,
                 conversationId: mockConversationId,
             });
-            expect(mlsService.getKeyPackagesPayload).toHaveBeenCalledWith(qualifiedUsers, undefined);
+            expect(mlsService.getKeyPackagesPayload).toHaveBeenCalledWith(qualifiedUsers);
             expect(mlsService.resetKeyMaterialRenewal).toHaveBeenCalledWith(mockGroupId);
         });
         it('should return failure reasons for users it was not possible to claim keys for', async () => {
@@ -718,11 +541,20 @@ describe('ConversationService', () => {
                 reason: __1.AddUsersFailureReasons.OFFLINE_FOR_TOO_LONG,
                 users: [otherUsersToAdd[0]],
             };
+            const addUsersFailure = {
+                reason: __1.AddUsersFailureReasons.UNREACHABLE_BACKENDS,
+                users: [otherUsersToAdd[1]],
+                backends: [otherUsersToAdd[1].domain],
+            };
+            const mlsFailure = {
+                reason: __1.AddUsersFailureReasons.NOT_MLS_CAPABLE,
+                users: [otherUsersToAdd[2]],
+            };
             jest.spyOn(apiClient.api.user, 'getUserSupportedProtocols').mockImplementation(id => {
                 if (id === otherUsersToAdd[2]) {
-                    return Promise.resolve([team_1.CONVERSATION_PROTOCOL.PROTEUS]);
+                    return Promise.resolve([conversation_1.ConversationProtocol.PROTEUS]);
                 }
-                return Promise.resolve([team_1.CONVERSATION_PROTOCOL.MLS, team_1.CONVERSATION_PROTOCOL.PROTEUS]);
+                return Promise.resolve([conversation_1.ConversationProtocol.MLS, conversation_1.ConversationProtocol.PROTEUS]);
             });
             jest.spyOn(mlsService, 'getKeyPackagesPayload').mockResolvedValueOnce({
                 keyPackages: [new Uint8Array(0)],
@@ -730,63 +562,18 @@ describe('ConversationService', () => {
             });
             jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
                 qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
+                protocol: conversation_1.ConversationProtocol.MLS,
                 epoch: 1,
                 group_id: mockGroupId,
             });
-            jest.spyOn(mlsService, 'addUsersToExistingConversation');
+            const mlsMessage = { events: [], time: '', failures: [addUsersFailure] };
+            jest.spyOn(mlsService, 'addUsersToExistingConversation').mockResolvedValueOnce(mlsMessage);
             const { failedToAdd } = await conversationService.addUsersToMLSConversation({
                 qualifiedUsers,
                 groupId: mockGroupId,
                 conversationId: mockConversationId,
             });
-            expect(failedToAdd).toEqual([keysClaimingFailure]);
-        });
-        it('recovers and retries when stale-message occurs during add users commit upload', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const mockGroupId = 'groupId-stale-add';
-            const mockConversationId = { id: PayloadHelper.getUUID(), domain: 'local.wire.com' };
-            const otherUsersToAdd = Array(2)
-                .fill(0)
-                .map(() => ({ id: PayloadHelper.getUUID(), domain: 'local.wire.com' }));
-            const qualifiedUsers = [...otherUsersToAdd];
-            const staleMessageError = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
-                    },
-                },
-            };
-            const getKPSpy = jest.spyOn(mlsService, 'getKeyPackagesPayload');
-            getKPSpy.mockResolvedValue({
-                keyPackages: [new Uint8Array(0)],
-                failures: [],
-            });
-            // Simulate commit upload failing once with stale, then succeeding
-            jest
-                .spyOn(mlsService, 'addUsersToExistingConversation')
-                .mockRejectedValueOnce(staleMessageError)
-                .mockResolvedValueOnce(undefined);
-            const remoteEpoch = 5;
-            const localEpoch = 4;
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
-            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
-            const getConvSpy = jest.spyOn(apiClient.api.conversation, 'getConversation');
-            getConvSpy.mockResolvedValue({
-                qualified_id: mockConversationId,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                epoch: remoteEpoch,
-                group_id: mockGroupId,
-            });
-            await conversationService.addUsersToMLSConversation({
-                qualifiedUsers,
-                groupId: mockGroupId,
-                conversationId: mockConversationId,
-            });
-            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(mockConversationId);
-            expect(mlsService.addUsersToExistingConversation).toHaveBeenCalledTimes(2);
+            expect(failedToAdd).toEqual([keysClaimingFailure, addUsersFailure, mlsFailure]);
         });
     });
     describe('tryEstablishingMLSGroup', () => {
@@ -833,186 +620,6 @@ describe('ConversationService', () => {
             expect(conversationService.addUsersToMLSConversation).not.toHaveBeenCalled();
         });
     });
-    describe('reactToKeyMaterialUpdateFailure', () => {
-        function getKeyMaterialFailureHandler(mlsService) {
-            const onMock = mlsService.on;
-            const call = onMock.mock.calls.find(([event]) => event === MLSService_1.MLSServiceEvents.KEY_MATERIAL_UPDATE_FAILURE);
-            expect(call).toBeTruthy();
-            return call[1];
-        }
-        it('resets a broken MLS conversation', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const groupId = 'group-1';
-            const qualified_id = { id: 'conv-1', domain: 'staging.zinfra.io' };
-            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValueOnce({
-                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 1 }],
-            });
-            const resetSpy = jest
-                .spyOn(conversationService, 'handleBrokenMLSConversation')
-                .mockResolvedValue(undefined);
-            const addUsersSpy = jest.spyOn(conversationService, 'addUsersToMLSConversation');
-            const handler = getKeyMaterialFailureHandler(mlsService);
-            const brokenErr = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION }),
-                    },
-                },
-            };
-            await handler({ error: brokenErr, groupId });
-            expect(resetSpy).toHaveBeenCalledWith(qualified_id);
-            expect(addUsersSpy).not.toHaveBeenCalled();
-        });
-        it('adds missing users when group is out of sync', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const groupId = 'group-2';
-            const qualified_id = { id: 'conv-2', domain: 'staging.zinfra.io' };
-            const missingUsers = [
-                { id: 'u1', domain: 'staging.zinfra.io' },
-                { id: 'u2', domain: 'staging.zinfra.io' },
-            ];
-            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValueOnce({
-                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 1 }],
-            });
-            const addUsersSpy = jest
-                .spyOn(conversationService, 'performAddUsersToMLSConversationAPI')
-                .mockResolvedValue({ conversation: {} });
-            const resetSpy = jest
-                .spyOn(conversationService, 'handleBrokenMLSConversation')
-                .mockResolvedValue(undefined);
-            const handler = getKeyMaterialFailureHandler(mlsService);
-            const outOfSyncErr = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({
-                            message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_GROUP_OUT_OF_SYNC,
-                            missing_users: missingUsers,
-                        }),
-                    },
-                },
-            };
-            await handler({ error: outOfSyncErr, groupId });
-            expect(addUsersSpy).toHaveBeenCalledWith({
-                groupId,
-                conversationId: qualified_id,
-                qualifiedUsers: missingUsers,
-            });
-            expect(resetSpy).not.toHaveBeenCalled();
-        });
-        it('deduplicates concurrent recoveries for the same group id', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const groupId = 'group-dup';
-            const qualified_id = { id: 'conv-dup', domain: 'staging.zinfra.io' };
-            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValue({
-                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 1 }],
-            });
-            // Make the recovery hang until we resolve it, to simulate overlapping calls
-            let resolveDeferred;
-            const deferred = new Promise(res => (resolveDeferred = res));
-            const resetSpy = jest
-                .spyOn(conversationService, 'handleBrokenMLSConversation')
-                .mockReturnValue(deferred);
-            const handler = getKeyMaterialFailureHandler(mlsService);
-            const brokenErr = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.BROKEN_MLS_CONVERSATION }),
-                    },
-                },
-            };
-            const p1 = handler({ error: brokenErr, groupId });
-            const p2 = handler({ error: brokenErr, groupId });
-            // Complete the first recovery
-            if (resolveDeferred) {
-                resolveDeferred();
-            }
-            await Promise.allSettled([p1, p2]);
-            expect(resetSpy).toHaveBeenCalledTimes(1);
-        });
-        it('handles stale-message by rejoining via external commit and emits recovery event', async () => {
-            const [conversationService, { apiClient, mlsService }] = await buildConversationService();
-            const groupId = 'group-stale';
-            const qualified_id = { id: 'conv-stale', domain: 'staging.zinfra.io' };
-            jest.spyOn(apiClient.api.conversation, 'getConversationList').mockResolvedValueOnce({
-                found: [{ group_id: groupId, qualified_id, protocol: team_1.CONVERSATION_PROTOCOL.MLS, epoch: 2 }],
-            });
-            const handler = getKeyMaterialFailureHandler(mlsService);
-            const staleMessageError = {
-                type: core_crypto_1.ErrorType.Mls,
-                context: {
-                    type: core_crypto_1.MlsErrorType.MessageRejected,
-                    context: {
-                        reason: (0, CoreCryptoMLSError_1.serializeAbortReason)({ message: CoreCryptoMLSError_1.UPLOAD_COMMIT_BUNDLE_ABORT_REASONS.MLS_STALE_MESSAGE }),
-                    },
-                },
-            };
-            const remoteEpoch = 3;
-            const localEpoch = 2;
-            jest.spyOn(mlsService, 'conversationExists').mockResolvedValueOnce(true);
-            jest.spyOn(mlsService, 'getEpoch').mockResolvedValueOnce(localEpoch);
-            jest.spyOn(apiClient.api.conversation, 'getConversation').mockResolvedValueOnce({
-                qualified_id,
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                epoch: remoteEpoch,
-                group_id: groupId,
-            });
-            await handler({ error: staleMessageError, groupId });
-            // Expect a rejoin on stale and a recovery event
-            expect(conversationService.joinByExternalCommit).toHaveBeenCalledWith(qualified_id);
-            expect(conversationService.emit).toHaveBeenCalledWith('MLSConversationRecovered', { conversationId: qualified_id });
-        });
-    });
-    describe('groupIdConversationMap cache', () => {
-        function makeConversation(group_id, id) {
-            return {
-                group_id,
-                qualified_id: { id, domain: 'staging.zinfra.io' },
-                protocol: team_1.CONVERSATION_PROTOCOL.MLS,
-                epoch: 1,
-            };
-        }
-        it('refreshGroupIdConversationMap builds the cache from backend list', async () => {
-            const [conversationService, { apiClient }] = await buildConversationService();
-            const conv1 = makeConversation('g-1', 'c-1');
-            const conv2 = makeConversation('g-2', 'c-2');
-            const getListSpy = jest
-                .spyOn(apiClient.api.conversation, 'getConversationList')
-                .mockResolvedValueOnce({ found: [conv1, conv2] });
-            await conversationService.refreshGroupIdConversationMap();
-            expect(getListSpy).toHaveBeenCalledTimes(1);
-            // Validate through the private cache map
-            const cache = conversationService.groupIdConversationMap;
-            expect(cache.get('g-1')?.qualified_id.id).toBe('c-1');
-            expect(cache.get('g-2')?.qualified_id.id).toBe('c-2');
-        });
-        it('getConversationByGroupId uses cache when available without backend call', async () => {
-            const [conversationService, { apiClient }] = await buildConversationService();
-            const conv = makeConversation('g-hit', 'c-hit');
-            // Pre-populate cache
-            conversationService.groupIdConversationMap.set('g-hit', conv);
-            const getListSpy = jest
-                .spyOn(apiClient.api.conversation, 'getConversationList')
-                .mockImplementation(() => Promise.reject(new Error('should not be called')));
-            const result = await conversationService.getConversationByGroupId('g-hit');
-            expect(result?.qualified_id.id).toBe('c-hit');
-            expect(getListSpy).not.toHaveBeenCalled();
-        });
-        it('getConversationByGroupId refreshes on cache miss and returns undefined if not found', async () => {
-            const [conversationService, { apiClient }] = await buildConversationService();
-            const getListSpy = jest
-                .spyOn(apiClient.api.conversation, 'getConversationList')
-                .mockResolvedValueOnce({ found: [makeConversation('g-else', 'c-else')] });
-            const result = await conversationService.getConversationByGroupId('g-missing');
-            expect(result).toBeUndefined();
-            expect(getListSpy).toHaveBeenCalledTimes(1);
-        });
-    });
 });
 function generateImage() {
     const image = {
@@ -1029,7 +636,6 @@ function generateImage() {
             keyBytes: Buffer.from([]),
             sha256: Buffer.from([]),
             token: '',
-            domain: 'example.com',
         },
     };
 }