Added unit tests

.github/workflows/ci.yml

@@ -0,0 +1,136 @@
+name: Android CI
+
+on:
+  pull_request:
+    branches: [ main ]
+  push:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v1
+        with:
+          java-version: 17
+
+      - name: Set up Android SDK
+        uses: android-actions/setup-android@v2
+        with:
+          api-level: 30
+          build-tools: 30.0.3
+
+      - name: Cache Gradle
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Build with Gradle (no tests)
+        run: ./gradlew assemble
+
+      - name: Save Build Artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: app-build
+          path: app/build/outputs/apk/
+
+  test:
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v1
+        with:
+          java-version: 17
+
+      - name: Set up Android SDK
+        uses: android-actions/setup-android@v2
+        with:
+          api-level: 30
+          build-tools: 30.0.3
+
+      - name: Cache Gradle
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Run Unit Tests and Capture Results
+        id: run_tests
+        run: |
+          ./gradlew test | tee test-results.txt
+          TEST_RESULTS=$(grep -A 7 "Test Summary" test-results.txt | tail -n +2 | sed 's/\x1B\[[0-9;]*[JKmsu]//g' | tr -d '[:space:]')
+          echo "$TEST_RESULTS" > test-summary.txt
+
+      # - name: Format Test Results for Two-Row Markdown Table with Emojis
+      #   run: |
+      #     echo "### Test Results" > formatted-summary.txt
+      #     echo "" >> formatted-summary.txt
+      #     echo "| Total Tests | Passed | Failed | Skipped | Result |" >> formatted-summary.txt
+      #     echo "|-------------|--------|--------|---------|--------|" >> formatted-summary.txt
+
+      #     echo "Raw Test Summary Content:"
+      #     cat test-summary.txt
+
+      #     # Extracting values using awk
+      #     TOTAL=$(echo "$TEST_RESULTS" | awk -F'[: ]+' '/TotalTests/ {print $2}')
+      #     PASSED=$(echo "$TEST_RESULTS" | awk -F'[: ]+' '/Passed/ {print $2}')
+      #     FAILED=$(echo "$TEST_RESULTS" | awk -F'[: ]+' '/Failed/ {print $2}')
+      #     SKIPPED=$(echo "$TEST_RESULTS" | awk -F'[: ]+' '/Skipped/ {print $2}')
+      #     RESULT=$(echo "$TEST_RESULTS" | awk -F'[: ]+' '/Result/ {print $2}')
+
+      #     # Detailed debugging
+      #     echo "Debug: Extracted Values:"
+      #     echo "  TOTAL: '$TOTAL'"
+      #     echo "  PASSED: '$PASSED'"
+      #     echo "  FAILED: '$FAILED'"
+      #     echo "  SKIPPED: '$SKIPPED'"
+      #     echo "  RESULT (Raw): '$RESULT'"
+
+      #     if [[ "$RESULT" == "SUCCESS" ]]; then
+      #       EMOJI="✅"
+      #     elif [[ "$RESULT" == "FAILURE" ]]; then
+      #       EMOJI="❌"
+      #     else
+      #       EMOJI="⚠️"
+      #     fi
+
+      #     echo "Debug: Final RESULT after processing: '$RESULT $EMOJI'"
+
+      #     echo "| $TOTAL | $PASSED | $FAILED | $SKIPPED | $RESULT $EMOJI |" >> formatted-summary.txt
+
+      #     # Show the final output for debugging
+      #     echo "Final formatted-summary.txt content:"
+      #     cat formatted-summary.txt
+
+      # - name: Comment on PR
+      #   if: github.event_name == 'pull_request'
+      #   uses: actions/github-script@v6
+      #   with:
+      #     script: |
+      #       const fs = require('fs');
+      #       const testResults = fs.readFileSync('formatted-summary.txt', 'utf8');
+      #       github.rest.issues.createComment({
+      #         issue_number: context.issue.number,
+      #         owner: context.repo.owner,
+      #         repo: context.repo.repo,
+      #         body: testResults
+      #       });

chat-sdk/build.gradle.kts

@@ -64,16 +64,7 @@ dependencies {
     implementation(libs.composeUiGraphics)
     implementation(libs.composeUiToolingPreview)
     implementation(libs.material3)
-    implementation("com.google.android.gms:play-services-basement:18.2.0")
     implementation(libs.runtimeLivedata)
-    implementation(libs.lifecycleProcess) // Add this dependency in libs.versions.toml if necessary
-    testImplementation(libs.junit)
-    androidTestImplementation(libs.androidxJunit)
-    androidTestImplementation(libs.espressoCore)
-    androidTestImplementation(platform(libs.composeBom))
-    androidTestImplementation(libs.composeUiTestJunit4)
-    debugImplementation(libs.composeUiTooling)
-    debugImplementation(libs.composeUiTestManifest)
 
     // Lifecycle livedata
     implementation(libs.lifecycleLivedataKtx)
@@ -91,6 +82,7 @@ dependencies {
     //Hilt
     implementation(libs.hiltAndroid)
     implementation(libs.hiltNavigationCompose)
+    implementation(libs.lifecycleProcess)
     kapt(libs.hiltCompiler)
     implementation(libs.navigationCompose)
     kapt(libs.hiltAndroidCompiler)
@@ -105,6 +97,24 @@ dependencies {
     // Image loading
     implementation(libs.coilCompose)
 
+    // Testing
+    // Mockito for mocking
+    testImplementation(libs.mockito.core)
+    testImplementation(libs.mockito.inline)
+
+    // Kotlin extensions for Mockito
+    testImplementation(libs.mockito.kotlin)
+
+    // Coroutines test library
+    testImplementation(libs.coroutines.test)
+
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidxJunit)
+    androidTestImplementation(platform(libs.composeBom))
+    androidTestImplementation(libs.composeUiTestJunit4)
+    debugImplementation(libs.composeUiTooling)
+    debugImplementation(libs.composeUiTestManifest)
+    testImplementation(libs.robolectric)
 }
 
 publishing {
@@ -129,3 +139,6 @@ publishing {
 tasks.withType<AbstractPublishToMaven>().configureEach {
     dependsOn(tasks.named("assembleRelease"))
 }
+
+// Test summary gradle file
+apply(from = "test-summary.gradle.kts")

chat-sdk/src/main/java/com/amazon/connect/chat/sdk/network/WebSocketManager.kt

@@ -5,25 +5,24 @@ import android.net.Network
 import android.util.Log
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
-import androidx.lifecycle.LifecycleObserver
 import androidx.lifecycle.ProcessLifecycleOwner
 import com.amazon.connect.chat.sdk.Config
 import com.amazon.connect.chat.sdk.model.Message
 import com.amazon.connect.chat.sdk.model.MessageType
 import com.amazon.connect.chat.sdk.model.TranscriptItem
 import com.amazon.connect.chat.sdk.utils.CommonUtils
 import com.amazon.connect.chat.sdk.utils.ContentType
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
 import okhttp3.WebSocket
 import okhttp3.WebSocketListener
-import java.util.concurrent.TimeUnit
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
 import okio.IOException
 import org.json.JSONObject
+import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
 object EventTypes {

chat-sdk/src/main/java/com/amazon/connect/chat/sdk/repository/ChatService.kt

@@ -20,7 +20,7 @@ interface ChatService {
      * Disconnects the current chat session.
      * @return A Result indicating whether the disconnection was successful.
      */
-    suspend fun disconnectChatSession(): Result<Unit>
+    suspend fun disconnectChatSession(): Result<Boolean>
 }
 
 class ChatServiceImpl @Inject constructor(
@@ -44,13 +44,13 @@ class ChatServiceImpl @Inject constructor(
         }
     }
 
-    override suspend fun disconnectChatSession(): Result<Unit> {
+    override suspend fun disconnectChatSession(): Result<Boolean> {
         return runCatching {
             val connectionDetails = connectionDetailsProvider.getConnectionDetails()
                 ?: throw Exception("No connection details available")
             awsClient.disconnectParticipantConnection(connectionDetails.connectionToken).getOrThrow()
             Log.d("ChatServiceImpl", "Participant Disconnected")
-            Unit
+            true
         }.onFailure { exception ->
             Log.e("ChatServiceImpl", "Failed to disconnect participant: ${exception.message}", exception)
         }

chat-sdk/src/test/java/com/amazon/connect/chat/sdk/ChatSessionImplTest.kt

@@ -0,0 +1,84 @@
+package com.amazon.connect.chat.sdk
+
+import com.amazon.connect.chat.sdk.model.ChatDetails
+import com.amazon.connect.chat.sdk.model.GlobalConfig
+import com.amazon.connect.chat.sdk.repository.ChatService
+import com.amazonaws.regions.Regions
+import junit.framework.TestCase.assertTrue
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.Mockito.*
+import org.mockito.MockitoAnnotations
+import org.mockito.kotlin.verify
+import org.robolectric.RobolectricTestRunner
+
+
+@ExperimentalCoroutinesApi
+@RunWith(RobolectricTestRunner::class)
+class ChatSessionImplTest {
+
+    @Mock
+    private lateinit var chatService: ChatService
+
+    private lateinit var chatSession: ChatSession
+
+    @Before
+    fun setUp() {
+        MockitoAnnotations.openMocks(this)
+        chatSession = ChatSessionImpl(chatService)
+    }
+
+    @Test
+    fun test_configure(){
+        val config = GlobalConfig(region = Regions.US_WEST_2)
+        chatSession.configure(config)
+        verify(chatService).configure(config)
+    }
+
+    @Test
+    fun test_connect_success() = runTest {
+        val chatDetails = ChatDetails(participantToken = "participant-token")
+        `when`(chatService.createChatSession(chatDetails)).thenReturn(Result.success(true))
+
+        val result = chatSession.connect(chatDetails)
+
+        assertTrue(result.isSuccess)
+        verify(chatService).createChatSession(chatDetails)
+    }
+
+    @Test
+    fun test_connect_failure() = runTest {
+        val chatDetails = ChatDetails(participantToken = "invalid token")
+        `when`(chatService.createChatSession(chatDetails)).thenThrow(RuntimeException("Network error"))
+
+        val result = chatSession.connect(chatDetails)
+
+        assertTrue(result.isFailure)
+        verify(chatService).createChatSession(chatDetails)
+    }
+
+    @Test
+    fun test_disconnect_success() = runTest {
+        `when`(chatService.disconnectChatSession()).thenReturn(Result.success(true))
+
+        val result = chatSession.disconnect()
+
+        assertTrue(result.isSuccess)
+        verify(chatService).disconnectChatSession()
+    }
+
+    @Test
+    fun test_disconnect_failure() = runTest {
+        `when`(chatService.disconnectChatSession()).thenThrow(RuntimeException("Network error"))
+
+        val result = chatSession.disconnect()
+
+        assertTrue(result.isFailure)
+        verify(chatService).disconnectChatSession()
+    }
+
+}