From 65565a79c4dac3a1fb63bc97a256164941419eec Mon Sep 17 00:00:00 2001 From: boris Date: Tue, 14 May 2024 11:41:41 +0300 Subject: [PATCH 1/2] Commit with unresolved merge conflicts --- .../conversation/MemberJoinEventHandler.kt | 21 +++ .../MemberJoinEventHandlerTest.kt | 155 ++++++++++++++---- .../ConversationRepositoryArrangement.kt | 13 ++ 3 files changed, 154 insertions(+), 35 deletions(-) diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt index 7423d4fa98b..73b087198c0 100644 --- a/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt +++ b/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt @@ -21,6 +21,7 @@ package com.wire.kalium.logic.sync.receiver.conversation import com.benasher44.uuid.uuid4 import com.wire.kalium.logger.KaliumLogger import com.wire.kalium.logic.CoreFailure +import com.wire.kalium.logic.data.conversation.Conversation import com.wire.kalium.logic.data.conversation.ConversationRepository import com.wire.kalium.logic.data.event.Event import com.wire.kalium.logic.data.event.EventLoggingStatus @@ -72,6 +73,7 @@ internal class MemberJoinEventHandlerImpl( userRepository.fetchUsersIfUnknownByIds(event.members.map { it.id }.toSet()) conversationRepository.persistMembers(event.members, event.conversationId) }.onSuccess { +<<<<<<< HEAD val message = Message.System( id = event.id.ifEmpty { uuid4().toString() }, content = MessageContent.MemberChange.Added(members = event.members.map { it.id }), @@ -84,6 +86,11 @@ internal class MemberJoinEventHandlerImpl( ) persistMessage(message) legalHoldHandler.handleConversationMembersChanged(event.conversationId) +======= + conversationRepository.detailsById(event.conversationId).onSuccess { conversation -> + if (conversation.type == Conversation.Type.GROUP) addSystemMessage(event) + } +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) kaliumLogger .logEventProcessing( EventLoggingStatus.SUCCESS, @@ -97,4 +104,18 @@ internal class MemberJoinEventHandlerImpl( Pair("errorInfo", "$it") ) } + + private suspend fun addSystemMessage(event: Event.Conversation.MemberJoin) { + val message = Message.System( + id = event.id.ifEmpty { uuid4().toString() }, + content = MessageContent.MemberChange.Added(members = event.members.map { it.id }), + conversationId = event.conversationId, + date = event.timestampIso, + senderUserId = event.addedBy, + status = Message.Status.Sent, + visibility = Message.Visibility.VISIBLE, + expirationData = null + ) + persistMessage(message) + } } diff --git a/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt b/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt index c00fc5acab2..ede5da3a250 100644 --- a/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt +++ b/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt @@ -18,17 +18,14 @@ package com.wire.kalium.logic.sync.receiver.conversation -import com.wire.kalium.logic.CoreFailure import com.wire.kalium.logic.NetworkFailure -import com.wire.kalium.logic.StorageFailure import com.wire.kalium.logic.data.conversation.Conversation.Member -import com.wire.kalium.logic.data.conversation.ConversationRepository import com.wire.kalium.logic.data.message.Message import com.wire.kalium.logic.data.message.MessageContent -import com.wire.kalium.logic.data.message.PersistMessageUseCase -import com.wire.kalium.logic.data.user.UserRepository +import com.wire.kalium.logic.framework.TestConversation import com.wire.kalium.logic.framework.TestEvent import com.wire.kalium.logic.framework.TestUser +<<<<<<< HEAD import com.wire.kalium.logic.functional.Either import com.wire.kalium.logic.sync.receiver.handler.legalhold.LegalHoldHandler import io.mockative.Mock @@ -38,6 +35,19 @@ import io.mockative.coVerify import io.mockative.eq import io.mockative.matches import io.mockative.mock +======= +import com.wire.kalium.logic.functional.left +import com.wire.kalium.logic.functional.right +import com.wire.kalium.logic.util.arrangement.repository.ConversationRepositoryArrangement +import com.wire.kalium.logic.util.arrangement.repository.ConversationRepositoryArrangementImpl +import com.wire.kalium.logic.util.arrangement.repository.UserRepositoryArrangement +import com.wire.kalium.logic.util.arrangement.repository.UserRepositoryArrangementImpl +import com.wire.kalium.logic.util.arrangement.usecase.PersistMessageUseCaseArrangement +import com.wire.kalium.logic.util.arrangement.usecase.PersistMessageUseCaseArrangementImpl +import io.mockative.any +import io.mockative.eq +import io.mockative.matching +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) import io.mockative.once import kotlinx.coroutines.test.runTest import kotlin.test.Test @@ -45,16 +55,40 @@ import kotlin.test.Test class MemberJoinEventHandlerTest { @Test +<<<<<<< HEAD +======= + fun givenMemberJoinEventWithoutSelfUser_whenHandlingIt_thenShouldFetchConversationIfUnknown() = runTest { + val newMembers = listOf(Member(TestUser.OTHER_FEDERATED_USER_ID, Member.Role.Member)) + val event = TestEvent.memberJoin(members = newMembers) + + val (arrangement, eventHandler) = arrange { + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.CONVERSATION.right()) + } + + eventHandler.handle(event) + + verify(arrangement.conversationRepository) + .suspendFunction(arrangement.conversationRepository::fetchConversationIfUnknown) + .with(eq(event.conversationId)) + .wasInvoked(exactly = once) + + verify(arrangement.conversationRepository) + .suspendFunction(arrangement.conversationRepository::fetchConversation) + .with(eq(event.conversationId)) + .wasNotInvoked() + } + + @Test +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) fun givenMemberJoinEventWithSelfUser_whenHandlingIt_thenShouldFetchConversation() = runTest { val newMembers = listOf(Member(TestUser.SELF.id, Member.Role.Member)) val event = TestEvent.memberJoin(members = newMembers) - val (arrangement, eventHandler) = Arrangement() - .withPersistingMessageReturning(Either.Right(Unit)) - .withFetchConversationIfUnknownSucceeding() - .withPersistMembersSucceeding() - .withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) - .arrange() + val (arrangement, eventHandler) = arrange { + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.CONVERSATION.right()) + } eventHandler.handle(event) @@ -72,12 +106,10 @@ class MemberJoinEventHandlerTest { val newMembers = listOf(Member(TestUser.USER_ID, Member.Role.Member)) val event = TestEvent.memberJoin(members = newMembers) - val (arrangement, eventHandler) = Arrangement() - .withPersistingMessageReturning(Either.Right(Unit)) - .withFetchConversationIfUnknownSucceeding() - .withPersistMembersSucceeding() - .withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) - .arrange() + val (arrangement, eventHandler) = arrange { + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.CONVERSATION.right()) + } eventHandler.handle(event) @@ -91,12 +123,11 @@ class MemberJoinEventHandlerTest { val newMembers = listOf(Member(TestUser.USER_ID, Member.Role.Member)) val event = TestEvent.memberJoin(members = newMembers) - val (arrangement, eventHandler) = Arrangement() - .withPersistingMessageReturning(Either.Right(Unit)) - .withFetchConversationIfUnknownFailing(NetworkFailure.NoNetworkConnection(null)) - .withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) - .withPersistMembersSucceeding() - .arrange() + val (arrangement, eventHandler) = arrange { + withFetchConversationIfUnknownFailingWith(NetworkFailure.NoNetworkConnection(null)) + withFetchConversation(NetworkFailure.NoNetworkConnection(null).left()) + withConversationDetailsByIdReturning(TestConversation.CONVERSATION.right()) + } eventHandler.handle(event) @@ -110,41 +141,69 @@ class MemberJoinEventHandlerTest { val newMembers = listOf(Member(TestUser.USER_ID, Member.Role.Admin)) val event = TestEvent.memberJoin(members = newMembers) - val (arrangement, eventHandler) = Arrangement() - .withPersistingMessageReturning(Either.Right(Unit)) - .withFetchConversationIfUnknownSucceeding() - .withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) - .withPersistMembersSucceeding() - .arrange() + val (arrangement, eventHandler) = arrange { + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.GROUP().right()) + } eventHandler.handle(event) +<<<<<<< HEAD coVerify { arrangement.persistMessage.invoke( matches { +======= + verify(arrangement.persistMessageUseCase) + .suspendFunction(arrangement.persistMessageUseCase::invoke) + .with( + matching { +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) it is Message.System && it.content is MessageContent.MemberChange } ) }.wasInvoked(exactly = once) } + @Test + fun givenMemberJoinEventIn1o1Conversation_whenHandlingIt_thenShouldNotPersistSystemMessage() = runTest { + val newMembers = listOf(Member(TestUser.USER_ID, Member.Role.Admin)) + val event = TestEvent.memberJoin(members = newMembers) + + val (arrangement, eventHandler) = arrange { + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.CONVERSATION.right()) + } + + eventHandler.handle(event) + + verify(arrangement.persistMessageUseCase) + .suspendFunction(arrangement.persistMessageUseCase::invoke) + .with(any()) + .wasNotInvoked() + } + @Test fun givenMemberJoinEventWithEmptyId_whenHandlingIt_thenShouldPersistSystemMessage() = runTest { val newMembers = listOf(Member(TestUser.USER_ID, Member.Role.Admin)) val event = TestEvent.memberJoin(members = newMembers).copy(id = "") - val (arrangement, eventHandler) = Arrangement() - .withPersistingMessageReturning(Either.Right(Unit)) - .withFetchConversationIfUnknownSucceeding() - .withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) - .withPersistMembersSucceeding() - .arrange() + val (arrangement, eventHandler) = arrange { + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.GROUP().right()) + } eventHandler.handle(event) +<<<<<<< HEAD coVerify { arrangement.persistMessage.invoke( matches { +======= + verify(arrangement.persistMessageUseCase) + .suspendFunction(arrangement.persistMessageUseCase::invoke) + .with( + matching { +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) it is Message.System && it.content is MessageContent.MemberChange && it.id.isNotEmpty() } ) @@ -170,6 +229,7 @@ class MemberJoinEventHandlerTest { }.wasInvoked(exactly = once) } +<<<<<<< HEAD private class Arrangement { @Mock val persistMessage = mock(PersistMessageUseCase::class) @@ -232,6 +292,31 @@ class MemberJoinEventHandlerTest { }.returns(Either.Right(Unit)) this to memberJoinEventHandler } +======= + private class Arrangement( + private val block: Arrangement.() -> Unit + ) : ConversationRepositoryArrangement by ConversationRepositoryArrangementImpl(), + UserRepositoryArrangement by UserRepositoryArrangementImpl(), + PersistMessageUseCaseArrangement by PersistMessageUseCaseArrangementImpl() { + + fun withFetchConversationSucceeding() = apply { + withFetchConversationIfUnknownSucceeding() + withFetchConversation(Unit.right()) + } + + fun arrange() = run { + block() + + withPersistingMessage(Unit.right()) + withFetchUsersIfUnknownByIdsReturning(Unit.right()) + withPersistMembers(Unit.right()) + + this to MemberJoinEventHandlerImpl(conversationRepository, userRepository, persistMessageUseCase, TestUser.SELF.id) + } +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) } + private companion object { + fun arrange(block: Arrangement.() -> Unit) = Arrangement(block).arrange() + } } diff --git a/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt b/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt index e042ab2e656..76f0df26591 100644 --- a/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt +++ b/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt @@ -101,8 +101,14 @@ internal interface ConversationRepositoryArrangement { suspend fun withSetDegradedConversationNotifiedFlag(result: Either) +<<<<<<< HEAD suspend fun withSelectGroupStatusMembersNamesAndHandles(result: Either) suspend fun withConversationDetailsByIdReturning(result: Either) +======= + fun withSelectGroupStatusMembersNamesAndHandles(result: Either) + fun withConversationDetailsByIdReturning(result: Either) + fun withPersistMembers(result: Either) +>>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) } internal open class ConversationRepositoryArrangementImpl : ConversationRepositoryArrangement { @@ -259,4 +265,11 @@ internal open class ConversationRepositoryArrangementImpl : ConversationReposito conversationRepository.detailsById(any()) }.returns(result) } + + override fun withPersistMembers(result: Either) { + given(conversationRepository) + .suspendFunction(conversationRepository::persistMembers) + .whenInvokedWith(any()) + .thenReturn(result) + } } From 5b622f559aeb3dfb9547c3886665931cd860c144 Mon Sep 17 00:00:00 2001 From: Boris Safonov Date: Tue, 14 May 2024 14:29:04 +0300 Subject: [PATCH 2/2] Fixed cherry-pick merging conflict --- .../conversation/MemberJoinEventHandler.kt | 16 +- .../MemberJoinEventHandlerTest.kt | 149 +++--------------- .../LegalHoldHandlerArrangement.kt | 42 +++++ .../ConversationRepositoryArrangement.kt | 14 +- 4 files changed, 66 insertions(+), 155 deletions(-) create mode 100644 logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/eventHandler/LegalHoldHandlerArrangement.kt diff --git a/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt b/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt index 73b087198c0..f84524f6b3e 100644 --- a/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt +++ b/logic/src/commonMain/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandler.kt @@ -73,24 +73,10 @@ internal class MemberJoinEventHandlerImpl( userRepository.fetchUsersIfUnknownByIds(event.members.map { it.id }.toSet()) conversationRepository.persistMembers(event.members, event.conversationId) }.onSuccess { -<<<<<<< HEAD - val message = Message.System( - id = event.id.ifEmpty { uuid4().toString() }, - content = MessageContent.MemberChange.Added(members = event.members.map { it.id }), - conversationId = event.conversationId, - date = event.timestampIso, - senderUserId = event.addedBy, - status = Message.Status.Sent, - visibility = Message.Visibility.VISIBLE, - expirationData = null - ) - persistMessage(message) - legalHoldHandler.handleConversationMembersChanged(event.conversationId) -======= conversationRepository.detailsById(event.conversationId).onSuccess { conversation -> if (conversation.type == Conversation.Type.GROUP) addSystemMessage(event) } ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) + legalHoldHandler.handleConversationMembersChanged(event.conversationId) kaliumLogger .logEventProcessing( EventLoggingStatus.SUCCESS, diff --git a/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt b/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt index ede5da3a250..9d7ba2a5389 100644 --- a/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt +++ b/logic/src/commonTest/kotlin/com/wire/kalium/logic/sync/receiver/conversation/MemberJoinEventHandlerTest.kt @@ -25,7 +25,6 @@ import com.wire.kalium.logic.data.message.MessageContent import com.wire.kalium.logic.framework.TestConversation import com.wire.kalium.logic.framework.TestEvent import com.wire.kalium.logic.framework.TestUser -<<<<<<< HEAD import com.wire.kalium.logic.functional.Either import com.wire.kalium.logic.sync.receiver.handler.legalhold.LegalHoldHandler import io.mockative.Mock @@ -35,19 +34,16 @@ import io.mockative.coVerify import io.mockative.eq import io.mockative.matches import io.mockative.mock -======= import com.wire.kalium.logic.functional.left import com.wire.kalium.logic.functional.right +import com.wire.kalium.logic.util.arrangement.eventHandler.LegalHoldHandlerArrangement +import com.wire.kalium.logic.util.arrangement.eventHandler.LegalHoldHandlerArrangementImpl import com.wire.kalium.logic.util.arrangement.repository.ConversationRepositoryArrangement import com.wire.kalium.logic.util.arrangement.repository.ConversationRepositoryArrangementImpl import com.wire.kalium.logic.util.arrangement.repository.UserRepositoryArrangement import com.wire.kalium.logic.util.arrangement.repository.UserRepositoryArrangementImpl import com.wire.kalium.logic.util.arrangement.usecase.PersistMessageUseCaseArrangement import com.wire.kalium.logic.util.arrangement.usecase.PersistMessageUseCaseArrangementImpl -import io.mockative.any -import io.mockative.eq -import io.mockative.matching ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) import io.mockative.once import kotlinx.coroutines.test.runTest import kotlin.test.Test @@ -55,32 +51,6 @@ import kotlin.test.Test class MemberJoinEventHandlerTest { @Test -<<<<<<< HEAD -======= - fun givenMemberJoinEventWithoutSelfUser_whenHandlingIt_thenShouldFetchConversationIfUnknown() = runTest { - val newMembers = listOf(Member(TestUser.OTHER_FEDERATED_USER_ID, Member.Role.Member)) - val event = TestEvent.memberJoin(members = newMembers) - - val (arrangement, eventHandler) = arrange { - withFetchConversationSucceeding() - withConversationDetailsByIdReturning(TestConversation.CONVERSATION.right()) - } - - eventHandler.handle(event) - - verify(arrangement.conversationRepository) - .suspendFunction(arrangement.conversationRepository::fetchConversationIfUnknown) - .with(eq(event.conversationId)) - .wasInvoked(exactly = once) - - verify(arrangement.conversationRepository) - .suspendFunction(arrangement.conversationRepository::fetchConversation) - .with(eq(event.conversationId)) - .wasNotInvoked() - } - - @Test ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) fun givenMemberJoinEventWithSelfUser_whenHandlingIt_thenShouldFetchConversation() = runTest { val newMembers = listOf(Member(TestUser.SELF.id, Member.Role.Member)) val event = TestEvent.memberJoin(members = newMembers) @@ -148,16 +118,9 @@ class MemberJoinEventHandlerTest { eventHandler.handle(event) -<<<<<<< HEAD coVerify { - arrangement.persistMessage.invoke( + arrangement.persistMessageUseCase.invoke( matches { -======= - verify(arrangement.persistMessageUseCase) - .suspendFunction(arrangement.persistMessageUseCase::invoke) - .with( - matching { ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) it is Message.System && it.content is MessageContent.MemberChange } ) @@ -176,10 +139,7 @@ class MemberJoinEventHandlerTest { eventHandler.handle(event) - verify(arrangement.persistMessageUseCase) - .suspendFunction(arrangement.persistMessageUseCase::invoke) - .with(any()) - .wasNotInvoked() + coVerify { arrangement.persistMessageUseCase(any()) }.wasNotInvoked() } @Test @@ -194,16 +154,9 @@ class MemberJoinEventHandlerTest { eventHandler.handle(event) -<<<<<<< HEAD coVerify { - arrangement.persistMessage.invoke( + arrangement.persistMessageUseCase.invoke( matches { -======= - verify(arrangement.persistMessageUseCase) - .suspendFunction(arrangement.persistMessageUseCase::invoke) - .with( - matching { ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) it is Message.System && it.content is MessageContent.MemberChange && it.id.isNotEmpty() } ) @@ -215,12 +168,13 @@ class MemberJoinEventHandlerTest { // given val newMembers = listOf(Member(TestUser.USER_ID, Member.Role.Admin)) val event = TestEvent.memberJoin(members = newMembers) - val (arrangement, eventHandler) = Arrangement() - .withPersistingMessageReturning(Either.Right(Unit)) - .withFetchConversationIfUnknownSucceeding() - .withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) - .withPersistMembersSucceeding() - .arrange() + val (arrangement, eventHandler) = arrange { + withPersistingMessage(Either.Right(Unit)) + withFetchConversationSucceeding() + withConversationDetailsByIdReturning(TestConversation.GROUP().right()) + withFetchUsersIfUnknownByIdsReturning(Either.Right(Unit)) + withPersistMembers(Unit.right()) + } // when eventHandler.handle(event) // then @@ -229,94 +183,31 @@ class MemberJoinEventHandlerTest { }.wasInvoked(exactly = once) } -<<<<<<< HEAD - private class Arrangement { - @Mock - val persistMessage = mock(PersistMessageUseCase::class) - - @Mock - val conversationRepository = mock(ConversationRepository::class) - - @Mock - private val userRepository = mock(UserRepository::class) - - @Mock - val legalHoldHandler = mock(LegalHoldHandler::class) - - private val memberJoinEventHandler: MemberJoinEventHandler = MemberJoinEventHandlerImpl( - conversationRepository = conversationRepository, - userRepository = userRepository, - persistMessage = persistMessage, - legalHoldHandler = legalHoldHandler - ) - - suspend fun withPersistingMessageReturning(result: Either) = apply { - coEvery { - persistMessage.invoke(any()) - }.returns(result) - } - - suspend fun withFetchConversationIfUnknownSucceeding() = apply { - coEvery { - conversationRepository.fetchConversationIfUnknown(any()) - }.returns(Either.Right(Unit)) - coEvery { - conversationRepository.fetchConversation(any()) - }.returns(Either.Right(Unit)) - } - - suspend fun withFetchConversationIfUnknownFailing(coreFailure: CoreFailure) = apply { - coEvery { - conversationRepository.fetchConversationIfUnknown(any()) - }.returns(Either.Left(coreFailure)) - coEvery { - conversationRepository.fetchConversation(any()) - }.returns(Either.Left(coreFailure)) - } - - suspend fun withPersistMembersSucceeding() = apply { - coEvery { - conversationRepository.persistMembers(any(), any()) - }.returns(Either.Right(Unit)) - } - - suspend fun withFetchUsersIfUnknownByIdsReturning(result: Either) = apply { - coEvery { - userRepository.fetchUsersIfUnknownByIds(any()) - }.returns(result) - } - - suspend fun arrange() = run { - coEvery { - legalHoldHandler.handleConversationMembersChanged(any()) - }.returns(Either.Right(Unit)) - this to memberJoinEventHandler - } -======= private class Arrangement( - private val block: Arrangement.() -> Unit + private val block: suspend Arrangement.() -> Unit ) : ConversationRepositoryArrangement by ConversationRepositoryArrangementImpl(), UserRepositoryArrangement by UserRepositoryArrangementImpl(), - PersistMessageUseCaseArrangement by PersistMessageUseCaseArrangementImpl() { + PersistMessageUseCaseArrangement by PersistMessageUseCaseArrangementImpl(), + LegalHoldHandlerArrangement by LegalHoldHandlerArrangementImpl() { - fun withFetchConversationSucceeding() = apply { + suspend fun withFetchConversationSucceeding() = apply { withFetchConversationIfUnknownSucceeding() withFetchConversation(Unit.right()) } - fun arrange() = run { + suspend fun arrange() = run { block() withPersistingMessage(Unit.right()) withFetchUsersIfUnknownByIdsReturning(Unit.right()) withPersistMembers(Unit.right()) + withHandleConversationMembersChanged(Unit.right()) - this to MemberJoinEventHandlerImpl(conversationRepository, userRepository, persistMessageUseCase, TestUser.SELF.id) + this to MemberJoinEventHandlerImpl(conversationRepository, userRepository, persistMessageUseCase, legalHoldHandler) } ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) } private companion object { - fun arrange(block: Arrangement.() -> Unit) = Arrangement(block).arrange() + suspend fun arrange(block: suspend Arrangement.() -> Unit) = Arrangement(block).arrange() } } diff --git a/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/eventHandler/LegalHoldHandlerArrangement.kt b/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/eventHandler/LegalHoldHandlerArrangement.kt new file mode 100644 index 00000000000..bbaeec447f1 --- /dev/null +++ b/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/eventHandler/LegalHoldHandlerArrangement.kt @@ -0,0 +1,42 @@ +/* + * Wire + * Copyright (C) 2024 Wire Swiss GmbH + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://www.gnu.org/licenses/. + */ +package com.wire.kalium.logic.util.arrangement.eventHandler + +import com.wire.kalium.logic.CoreFailure +import com.wire.kalium.logic.functional.Either +import com.wire.kalium.logic.sync.receiver.handler.legalhold.LegalHoldHandler +import io.mockative.Mock +import io.mockative.any +import io.mockative.coEvery +import io.mockative.mock + +internal interface LegalHoldHandlerArrangement { + val legalHoldHandler: LegalHoldHandler + + suspend fun withHandleConversationMembersChanged(result: Either) +} + +internal open class LegalHoldHandlerArrangementImpl : LegalHoldHandlerArrangement { + @Mock + override val legalHoldHandler: LegalHoldHandler = mock(LegalHoldHandler::class) + + override suspend fun withHandleConversationMembersChanged(result: Either) { + coEvery { legalHoldHandler.handleConversationMembersChanged(any()) }.returns(result) + } + +} diff --git a/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt b/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt index 76f0df26591..e69f69d6bc4 100644 --- a/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt +++ b/logic/src/commonTest/kotlin/com/wire/kalium/logic/util/arrangement/repository/ConversationRepositoryArrangement.kt @@ -101,14 +101,9 @@ internal interface ConversationRepositoryArrangement { suspend fun withSetDegradedConversationNotifiedFlag(result: Either) -<<<<<<< HEAD suspend fun withSelectGroupStatusMembersNamesAndHandles(result: Either) suspend fun withConversationDetailsByIdReturning(result: Either) -======= - fun withSelectGroupStatusMembersNamesAndHandles(result: Either) - fun withConversationDetailsByIdReturning(result: Either) - fun withPersistMembers(result: Either) ->>>>>>> 39f2aa35cd (fix: No SystemMessage on new 1o1 conversation (#2730)) + suspend fun withPersistMembers(result: Either) } internal open class ConversationRepositoryArrangementImpl : ConversationRepositoryArrangement { @@ -266,10 +261,7 @@ internal open class ConversationRepositoryArrangementImpl : ConversationReposito }.returns(result) } - override fun withPersistMembers(result: Either) { - given(conversationRepository) - .suspendFunction(conversationRepository::persistMembers) - .whenInvokedWith(any()) - .thenReturn(result) + override suspend fun withPersistMembers(result: Either) { + coEvery { conversationRepository.persistMembers(any(), any()) }.returns(result) } }