Merge pull request #10 from QuickBlox/rc-0.7.0

0.7.0

Author: vdovbnya-qb

README.md

@@ -74,7 +74,7 @@ Then need to add implementation of QuickBlox UIKit and QuickBlox SDK to dependen
 
 ```
 dependencies {
-    implementation "com.quickblox:android-ui-kit:0.6.0"
+    implementation "com.quickblox:android-ui-kit:0.7.0"
 
     implementation 'com.quickblox:quickblox-android-sdk-messages:4.1.1'
     implementation 'com.quickblox:quickblox-android-sdk-chat:4.1.1'

ui-kit/build.gradle

@@ -10,7 +10,7 @@ ext {
     qbSdkVersion = '4.1.1'
 
     uiKitVersionCode = 1
-    uiKitVersionName = "0.6.0"
+    uiKitVersionName = "0.7.0"
 }
 
 android {

ui-kit/src/androidTest/java/com/quickblox/android_ui_kit/domain/SendChatMessageWithContentUseCaseIntegrationTest.kt

@@ -236,7 +236,7 @@ class SendChatMessageWithContentUseCaseIntegrationTest : BaseTest() {
     private fun subscribeToReceiveDialogChatMessage(
         createdContent: MediaContentEntity,
         createdDialog: DialogEntity,
-        receivedMessageLatch: CountDownLatch
+        receivedMessageLatch: CountDownLatch,
     ) {
         val qbDialog = QBChatDialog()
         qbDialog.dialogId = createdDialog.getDialogId()!!

ui-kit/src/androidTest/java/com/quickblox/android_ui_kit/domain/SendForwardMessageIntegrationTest.kt

@@ -9,7 +9,7 @@ import android.content.Context
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
 import com.quickblox.android_ui_kit.*
-import com.quickblox.android_ui_kit.data.source.remote.parser.ForwardMessageParser
+import com.quickblox.android_ui_kit.data.source.remote.parser.ForwardReplyMessageParser
 import com.quickblox.android_ui_kit.dependency.DependencyImpl
 import com.quickblox.android_ui_kit.domain.entity.DialogEntity
 import com.quickblox.android_ui_kit.domain.entity.implementation.PaginationEntityImpl
@@ -25,7 +25,7 @@ import com.quickblox.android_ui_kit.domain.usecases.CreatePrivateDialogUseCase
 import com.quickblox.android_ui_kit.domain.usecases.GetAllMessagesUseCase
 import com.quickblox.android_ui_kit.domain.usecases.GetDialogByIdUseCase
 import com.quickblox.android_ui_kit.domain.usecases.SendChatMessageUseCase
-import com.quickblox.android_ui_kit.domain.usecases.SendForwardMessageUseCase
+import com.quickblox.android_ui_kit.domain.usecases.SendForwardReplyMessageUseCase
 import com.quickblox.chat.QBChatService
 import com.quickblox.chat.model.QBChatDialog
 import com.quickblox.chat.model.QBChatMessage
@@ -103,10 +103,12 @@ class SendForwardMessageIntegrationTest : BaseTest() {
     fun sendFiveTextForwardedMessagesFromOpponentUser_loadMessage_messageIsForwardedAndIncoming(): Unit = runBlocking {
         val messageCount = 5
 
-        sendXMessagesByOpponent(createdDialog?.getDialogId()!!, messagesCount = messageCount)
+        val messageContentText = "opponent_user_forwarded_test_message_${System.currentTimeMillis()}"
+
+        sendXMessagesByOpponent(createdDialog?.getDialogId()!!, messageContentText, messageCount)
         val loadedMessages = loadXChatMessages(messagesCount = messageCount)
 
-        sendForwardedMessageByOpponent(loadedMessages)
+        sendForwardedMessageByOpponent(loadedMessages, messageContentText)
 
         val dialogEntity = GetDialogByIdUseCase(createdDialog?.getDialogId()!!).execute()
 
@@ -121,21 +123,26 @@ class SendForwardMessageIntegrationTest : BaseTest() {
         assertEquals(messageCount, message.getForwardedRepliedMessages()!!.size)
         assertEquals(OPPONENT_ID, message.getForwardedRepliedMessages()!![0].getSender()!!.getUserId())
         assertNotNull(message.getForwardedRepliedMessages()!![0].getRelatedMessageId())
+        assertEquals(messageContentText, message.getContent())
+        assertEquals(messageContentText, message.getForwardedRepliedMessages()!![0].getContent())
     }
 
     @Test
     @ExperimentalCoroutinesApi
     fun sendFiveTextForwardedMessagesFromLoggedUser_execute_messageIsForwardedAndOutgoing(): Unit = runBlocking {
         val messageCount = 5
 
-        sendXMessagesByLoggedUser(createdDialog?.getDialogId()!!, messagesCount = messageCount)
+        val forwardMessageText = "logged_user_forwarded_test_message_${System.currentTimeMillis()}"
+
+        sendXMessagesByLoggedUser(createdDialog?.getDialogId()!!, forwardMessageText, messageCount)
         val loadedMessages = loadXChatMessages(messagesCount = messageCount)
 
-        val relatedMessage = buildRelatedMessage(createdDialog?.getDialogId()!!)
+        val relatedMessageText = "related_message_${System.currentTimeMillis()}"
+        val relatedMessage = buildRelatedMessage(createdDialog?.getDialogId()!!, relatedMessageText)
 
         val createdMessage = CreateForwardMessageUseCase(loadedMessages, relatedMessage).execute()
 
-        SendForwardMessageUseCase(createdMessage!!, createdDialog?.getDialogId()!!).execute()
+        SendForwardReplyMessageUseCase(createdMessage!!, createdDialog?.getDialogId()!!).execute()
 
         val dialogEntity = GetDialogByIdUseCase(createdDialog?.getDialogId()!!).execute()
 
@@ -150,31 +157,30 @@ class SendForwardMessageIntegrationTest : BaseTest() {
         assertEquals(messageCount, message.getForwardedRepliedMessages()!!.size)
         assertEquals(USER_ID, message.getForwardedRepliedMessages()!![0].getSender()!!.getUserId())
         assertNotNull(message.getForwardedRepliedMessages()!![0].getRelatedMessageId())
+        assertEquals(relatedMessageText, message.getContent())
+        assertEquals(forwardMessageText, message.getForwardedRepliedMessages()!![0].getContent())
     }
 
-    private fun sendXMessagesByOpponent(dialogId: String, messagesCount: Int = 5) {
-        val messages = createMessagesFromOpponent(dialogId, qbChatMessageCount = messagesCount)
+    private fun sendXMessagesByOpponent(dialogId: String, messageBodyText: String, messagesCount: Int = 5) {
+        val messages = createMessagesFromOpponent(dialogId, messageBodyText, messagesCount)
 
         for (message in messages) {
             sendChatMessageToDialog(message, opponentChatService!!)
         }
     }
 
-    private fun createMessagesFromOpponent(dialogId: String, qbChatMessageCount: Int = 5): List<QBChatMessage> {
+    private fun createMessagesFromOpponent(
+        dialogId: String, messageBodyText: String, qbChatMessageCount: Int = 5
+    ): List<QBChatMessage> {
         val builtMessages = mutableListOf<QBChatMessage>()
 
         for (index in 1..qbChatMessageCount) {
-            builtMessages.add(createMessageFromOpponent(dialogId))
+            builtMessages.add(createMessageFromOpponent(dialogId, messageBodyText))
         }
 
         return builtMessages
     }
 
-    /*private fun createForwardMessageFromOpponent(dialogId: String, messageToForward: List<QBChatMessage>) {
-        val qbChatMessage = buildMessageFromOpponent(dialogId)
-        qbChatMessage.setProperty()
-    }*/
-
     private fun sendChatMessageToDialog(qbChatMessage: QBChatMessage, chatService: QBChatService) {
         val qbDialog = QBChatDialog()
         qbDialog.dialogId = qbChatMessage.dialogId
@@ -186,49 +192,51 @@ class SendForwardMessageIntegrationTest : BaseTest() {
         qbDialog.sendMessage(qbChatMessage)
     }
 
-    private fun createMessageFromOpponent(dialogId: String): QBChatMessage {
+    private fun createMessageFromOpponent(dialogId: String, messageBodyText: String): QBChatMessage {
         val qbChatMessage = QBChatMessage()
         qbChatMessage.dialogId = dialogId
-        qbChatMessage.body = "opponent_user_test_message: ${System.currentTimeMillis()}"
+        qbChatMessage.body = messageBodyText
         qbChatMessage.setSaveToHistory(true)
 
         return qbChatMessage
     }
 
-    private suspend fun sendXMessagesByLoggedUser(dialogId: String, messagesCount: Int = 5) {
-        val messages = createMessagesFromLoggedUser(dialogId, messageCount = messagesCount)
+    private suspend fun sendXMessagesByLoggedUser(dialogId: String, messageBodyText: String, messagesCount: Int = 5) {
+        val messages = createMessagesFromLoggedUser(dialogId, messageBodyText, messagesCount)
 
         for (message in messages) {
             SendChatMessageUseCase(message).execute()
         }
     }
 
-    private fun createMessagesFromLoggedUser(dialogId: String, messageCount: Int = 5): List<OutgoingChatMessageEntity> {
+    private fun createMessagesFromLoggedUser(
+        dialogId: String, messageBodyText: String, messageCount: Int = 5
+    ): List<OutgoingChatMessageEntity> {
         val builtMessages = mutableListOf<OutgoingChatMessageEntity>()
 
         for (index in 1..messageCount) {
-            builtMessages.add(createMessageFromLoggedUser(dialogId))
+            builtMessages.add(createMessageFromLoggedUser(dialogId, messageBodyText))
         }
 
         return builtMessages
     }
 
-    private fun createMessageFromLoggedUser(dialogId: String): OutgoingChatMessageEntity {
+    private fun createMessageFromLoggedUser(dialogId: String, messageBodyText: String): OutgoingChatMessageEntity {
         val message = OutgoingChatMessageEntityImpl(
             OutgoingChatMessageEntity.OutgoingStates.SENT, ChatMessageEntity.ContentTypes.TEXT
         )
         message.setParticipantId(OPPONENT_ID)
         message.setDialogId(dialogId)
-        message.setContent("logged_user_test_message_${System.currentTimeMillis()}")
+        message.setContent(messageBodyText)
 
         return message
     }
 
-    private fun buildRelatedMessage(dialogId: String, title: String? = "normal"): OutgoingChatMessageEntity {
+    private fun buildRelatedMessage(dialogId: String, messageBodyText: String): OutgoingChatMessageEntity {
         val message = OutgoingChatMessageEntityImpl(null, ChatMessageEntity.ContentTypes.TEXT)
         message.setDialogId(dialogId)
         message.setParticipantId(OPPONENT_ID)
-        message.setContent("$title: test_message: ${System.currentTimeMillis()}")
+        message.setContent(messageBodyText)
         message.setTime(System.currentTimeMillis())
 
         return message
@@ -256,9 +264,9 @@ class SendForwardMessageIntegrationTest : BaseTest() {
         return loadedMessages
     }
 
-    private fun sendForwardedMessageByOpponent(messages: List<ForwardedRepliedMessageEntity>) {
-        val qbChatMessage = createMessageFromOpponent(createdDialog?.getDialogId()!!)
-        val properties = ForwardMessageParser.parsePropertiesFrom(messages)
+    private fun sendForwardedMessageByOpponent(messages: List<ForwardedRepliedMessageEntity>, messageBodyText: String) {
+        val qbChatMessage = createMessageFromOpponent(createdDialog?.getDialogId()!!, messageBodyText)
+        val properties = ForwardReplyMessageParser.parseForwardPropertiesFrom(messages)
 
         for ((key, value) in properties) {
             qbChatMessage.setProperty(key, value)