Add unit tests to utils

app/src/test/java/com/amazon/connect/chat/androidchatexample/utils/CommonUtilsTest.kt

@@ -0,0 +1,137 @@
+package com.amazon.connect.chat.androidchatexample.utils
+
+import com.amazon.connect.chat.sdk.model.ContentType
+import com.amazon.connect.chat.sdk.model.MessageDirection
+import com.amazon.connect.chat.sdk.model.MessageStatus
+import org.junit.Assert.*
+import org.junit.Test
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.TimeZone
+
+class CommonUtilsTest {
+
+    @Test
+    fun formatTime_validTimestamp_returnsFormattedTime() {
+        val timestamp = "2023-05-15T14:30:45.123Z"
+
+        val result = CommonUtils.formatTime(timestamp)
+
+        assertTrue(result.matches(Regex("\\d{2}:\\d{2}")))
+    }
+
+    @Test
+    fun formatTime_invalidTimestamp_throwsParseException() {
+        val invalidTimestamp = "invalid-timestamp"
+
+        try {
+            CommonUtils.formatTime(invalidTimestamp)
+            fail("Expected a ParseException to be thrown")
+        } catch (e: java.text.ParseException) {
+            // Test passes if exception is thrown
+            assertTrue(e.message?.contains("Unparseable date") ?: false)
+        }
+    }
+
+    @Test
+    fun formatDate_forLogsTrue_returnsCorrectFormat() {
+        val timeMillis = 1684159845123L // 2023-05-15T14:30:45.123Z
+
+        val result = CommonUtils.formatDate(timeMillis, true)
+
+        // Create the same formatter to verify the expected result
+        val utcFormatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply {
+            timeZone = TimeZone.getTimeZone("UTC")
+        }
+        val expected = utcFormatter.format(Date(timeMillis))
+        assertEquals(expected, result)
+    }
+
+    @Test
+    fun formatDate_forLogsFalse_returnsCorrectFormat() {
+        val timeMillis = 1684159845123L // 2023-05-15T14:30:45.123Z
+
+        val result = CommonUtils.formatDate(timeMillis, false)
+
+        // Create the same formatter to verify the expected result
+        val utcFormatter = SimpleDateFormat("yyyy-MM-dd_HH-mm", Locale.US).apply {
+            timeZone = TimeZone.getTimeZone("UTC")
+        }
+        val expected = utcFormatter.format(Date(timeMillis))
+        assertEquals(expected, result)
+    }
+
+    @Test
+    fun customMessageStatus_delivered_returnsCorrectString() {
+        val status = MessageStatus.Delivered
+
+        val result = CommonUtils.customMessageStatus(status)
+
+        assertEquals("Delivered", result)
+    }
+
+    @Test
+    fun customMessageStatus_read_returnsCorrectString() {
+        val status = MessageStatus.Read
+
+        val result = CommonUtils.customMessageStatus(status)
+
+        assertEquals("Read", result)
+    }
+
+    @Test
+    fun customMessageStatus_sending_returnsCorrectString() {
+        val status = MessageStatus.Sending
+
+        val result = CommonUtils.customMessageStatus(status)
+
+        assertEquals("Sending", result)
+    }
+
+    @Test
+    fun customMessageStatus_failed_returnsDefaultMessage() {
+        val status = MessageStatus.Failed
+
+        val result = CommonUtils.customMessageStatus(status)
+
+        assertTrue(result.isNotEmpty())
+    }
+
+    @Test
+    fun customMessageStatus_sent_returnsCorrectString() {
+        val status = MessageStatus.Sent
+
+        val result = CommonUtils.customMessageStatus(status)
+
+        assertEquals("Sent", result)
+    }
+
+    @Test
+    fun customMessageStatus_null_returnsEmptyString() {
+        val status: MessageStatus? = null
+
+        val result = CommonUtils.customMessageStatus(status)
+
+        assertEquals("", result)
+    }
+
+    @Test
+    fun retryButtonEnabled_failedStatus_returnsTrue() {
+        val status = MessageStatus.Failed
+
+        val result = CommonUtils.retryButtonEnabled(status)
+
+        assertTrue(result)
+    }
+
+    @Test
+    fun retryButtonEnabled_otherStatus_returnsFalse() {
+        // Test with various non-failed statuses
+        assertFalse(CommonUtils.retryButtonEnabled(MessageStatus.Delivered))
+        assertFalse(CommonUtils.retryButtonEnabled(MessageStatus.Read))
+        assertFalse(CommonUtils.retryButtonEnabled(MessageStatus.Sending))
+        assertFalse(CommonUtils.retryButtonEnabled(MessageStatus.Sent))
+        assertFalse(CommonUtils.retryButtonEnabled(null))
+    }
+}

app/src/test/java/com/amazon/connect/chat/androidchatexample/utils/CustomLoggerTest.kt

@@ -0,0 +1,126 @@
+package com.amazon.connect.chat.androidchatexample.utils
+
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.PrintStream
+
+class CustomLoggerTest {
+
+    @get:Rule
+    val tempFolder = TemporaryFolder()
+
+    private lateinit var customLogger: CustomLogger
+
+    private val originalOut = System.out
+    private val outputStreamCaptor = ByteArrayOutputStream()
+
+    @Before
+    fun setUp() {
+        customLogger = CustomLogger()
+
+        // Capture System.out.println output
+        System.setOut(PrintStream(outputStreamCaptor))
+    }
+
+    @After
+    fun tearDown() {
+        // Restore original System.out
+        System.setOut(originalOut)
+    }
+
+    @Test
+    fun logVerbose_shouldPrintMessageWithVerbosePrefix() {
+        val message = "Test verbose message"
+
+        customLogger.logVerbose { message }
+
+        assertTrue(outputStreamCaptor.toString().contains("VERBOSE: $message"))
+    }
+
+    @Test
+    fun logInfo_shouldPrintMessageWithInfoPrefix() {
+        val message = "Test info message"
+
+        customLogger.logInfo { message }
+
+        assertTrue(outputStreamCaptor.toString().contains("INFO: $message"))
+    }
+
+    @Test
+    fun logDebug_shouldPrintMessageWithDebugPrefix() {
+        val message = "Test debug message"
+
+        customLogger.logDebug { message }
+
+        assertTrue(outputStreamCaptor.toString().contains("DEBUG: $message"))
+    }
+
+    @Test
+    fun logWarn_shouldPrintMessageWithWarnPrefix() {
+        val message = "Test warn message"
+
+        customLogger.logWarn { message }
+
+        assertTrue(outputStreamCaptor.toString().contains("WARN: $message"))
+    }
+
+    @Test
+    fun logError_shouldPrintMessageWithErrorPrefix() {
+        val message = "Test error message"
+
+        customLogger.logError { message }
+
+        assertTrue(outputStreamCaptor.toString().contains("ERROR: $message"))
+    }
+
+    @Test
+    fun setLogOutputDir_shouldSetOutputDirectory() {
+        val tempDir = tempFolder.newFolder("logs")
+
+        customLogger.setLogOutputDir(tempDir)
+
+        // No assertion needed, just verifying no exception is thrown
+    }
+
+    @Test
+    fun writeToAppTempFile_shouldHandleNullOutputFileDir() {
+        // Given
+        // outputFileDir is null by default
+
+        customLogger.logInfo { "Test message" }
+
+        // No assertion needed, just verifying no exception is thrown
+        // Wait a bit to allow the coroutine to execute
+        Thread.sleep(100)
+    }
+
+    @Test
+    fun writeToAppTempFile_shouldHandleValidDirectory() {
+        val tempDir = tempFolder.newFolder("logs")
+        customLogger.setLogOutputDir(tempDir)
+
+        customLogger.logInfo { "Test message for file" }
+
+        // No assertion needed, just verifying no exception is thrown
+        // Wait a bit to allow the coroutine to execute
+        Thread.sleep(100)
+    }
+
+    @Test
+    fun writeToAppTempFile_shouldHandleNonExistentDirectory() {
+        val nonExistentDir = File("/non/existent/directory")
+        customLogger.setLogOutputDir(nonExistentDir)
+
+        customLogger.logInfo { "Test message" }
+
+        // No assertion needed, just verifying no exception is thrown
+        // Wait a bit to allow the coroutine to execute
+        Thread.sleep(100)
+    }
+}

app/src/test/java/com/amazon/connect/chat/androidchatexample/utils/FileUtilsTest.kt

@@ -0,0 +1,64 @@
+package com.amazon.connect.chat.androidchatexample.utils
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.File
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+@RunWith(JUnit4::class)
+class FileUtilsTest {
+
+    @Test
+    fun testFileNameExtraction() {
+        // Test the extension extraction logic that's part of getMimeType
+        val fileName1 = "document.pdf"
+        val fileName2 = "image.jpg"
+        val fileName3 = "noextension"
+        val fileName4 = ".hiddenfile"
+        val fileName5 = "archive.tar.gz"
+
+        assertEquals("pdf", fileName1.substringAfterLast('.', ""))
+        assertEquals("jpg", fileName2.substringAfterLast('.', ""))
+        assertEquals("", fileName3.substringAfterLast('.', ""))
+        assertEquals("hiddenfile", fileName4.substringAfterLast('.', ""))
+        assertEquals("gz", fileName5.substringAfterLast('.', ""))
+    }
+
+    @Test
+    fun testFilePathConstruction() {
+        // Test file path construction logic
+        val dirPath = "/cache"
+        val fileName = "test.txt"
+
+        val tempDir = File(dirPath, "attachments")
+        val file = File(tempDir, fileName)
+
+        assertEquals("/cache/attachments/test.txt", file.path)
+    }
+
+    @Test
+    fun testFilePathWithSpecialCharacters() {
+        // Test file path with special characters
+        val dirPath = "/user/data"
+        val fileName = "test file with spaces.pdf"
+
+        val tempDir = File(dirPath, "attachments")
+        val file = File(tempDir, fileName)
+
+        assertEquals("/user/data/attachments/test file with spaces.pdf", file.path)
+    }
+
+    @Test
+    fun testNestedDirectoryConstruction() {
+        // Test nested directory construction
+        val baseDir = "/storage/emulated/0"
+        val nestedPath = "Download/documents/reports"
+        val fileName = "annual_report.xlsx"
+
+        val tempDir = File(baseDir, nestedPath)
+        val file = File(tempDir, fileName)
+
+        assertEquals("/storage/emulated/0/Download/documents/reports/annual_report.xlsx", file.path)
+    }
+}