package com.example import com.example.data.model.extractDateOnly import com.example.data.model.formatToShortDate import com.example.data.model.parseDateOnly import com.example.data.model.parseFullDateTime import org.junit.Assert.* import org.junit.Test import java.util.Calendar /** * Example local unit test, which will execute on the development machine (host). * * See [testing documentation](http://d.android.com/tools/testing). */ class ExampleUnitTest { @Test fun addition_isCorrect() { assertEquals(4, 2 + 2) } @Test fun testExtractDateOnly() { assertEquals("14/08/2026", extractDateOnly("14/08/2026 08:30")) assertEquals("14/08/2026", extractDateOnly("14/08/2026")) assertEquals("2026-08-14", extractDateOnly("2026-08-14T10:15:00")) assertEquals("N/A", extractDateOnly("N/A")) assertEquals("N/A", extractDateOnly("")) assertEquals("14/08/26", extractDateOnly("Sex 14/08/26 07:00")) assertEquals("17/08/26", extractDateOnly("Seg 17/08/26")) assertEquals("2026-08-15", extractDateOnly("2026-08-15")) } @Test fun testParseDateOnly() { val date1 = parseDateOnly("14/08/2026") assertNotNull(date1) val cal1 = Calendar.getInstance().apply { time = date1!! } assertEquals(2026, cal1.get(Calendar.YEAR)) assertEquals(Calendar.AUGUST, cal1.get(Calendar.MONTH)) assertEquals(14, cal1.get(Calendar.DAY_OF_MONTH)) val date2 = parseDateOnly("2026-08-15") assertNotNull(date2) val cal2 = Calendar.getInstance().apply { time = date2!! } assertEquals(2026, cal2.get(Calendar.YEAR)) assertEquals(Calendar.AUGUST, cal2.get(Calendar.MONTH)) assertEquals(15, cal2.get(Calendar.DAY_OF_MONTH)) // 2-digit years support tests val date3 = parseDateOnly("17/08/26") assertNotNull(date3) val cal3 = Calendar.getInstance().apply { time = date3!! } assertEquals(2026, cal3.get(Calendar.YEAR)) assertEquals(Calendar.AUGUST, cal3.get(Calendar.MONTH)) assertEquals(17, cal3.get(Calendar.DAY_OF_MONTH)) // Tests for dates containing weekdays or times val date4 = parseDateOnly("Sex 14/08/26 07:00") assertNotNull(date4) val cal4 = Calendar.getInstance().apply { time = date4!! } assertEquals(2026, cal4.get(Calendar.YEAR)) assertEquals(Calendar.AUGUST, cal4.get(Calendar.MONTH)) assertEquals(14, cal4.get(Calendar.DAY_OF_MONTH)) val date5 = parseDateOnly("14/08/2026 08:30") assertNotNull(date5) val cal5 = Calendar.getInstance().apply { time = date5!! } assertEquals(2026, cal5.get(Calendar.YEAR)) assertEquals(Calendar.AUGUST, cal5.get(Calendar.MONTH)) assertEquals(14, cal5.get(Calendar.DAY_OF_MONTH)) } @Test fun testParseFullDateTime() { val date1 = parseFullDateTime("14/08/2026 08:30") assertNotNull(date1) val cal1 = Calendar.getInstance().apply { time = date1!! } assertEquals(2026, cal1.get(Calendar.YEAR)) assertEquals(8, cal1.get(Calendar.HOUR_OF_DAY)) assertEquals(30, cal1.get(Calendar.MINUTE)) val date2 = parseFullDateTime("17/08/26 14:15") assertNotNull(date2) val cal2 = Calendar.getInstance().apply { time = date2!! } assertEquals(2026, cal2.get(Calendar.YEAR)) assertEquals(14, cal2.get(Calendar.HOUR_OF_DAY)) assertEquals(15, cal2.get(Calendar.MINUTE)) } @Test fun testParseFullDateTimeWithCsvFormats() { // Tests real date formats from documentacao/exemplo_testes/GestaoOS_Parada_project.csv val csvDates = listOf( "ter. 04/08/26 07:00", "sex. 14/08/26 07:00", "seg. 17/08/26 07:00", "ter. 18/08/26 17:00", "qua. 19/08/26 07:00", "qui. 27/08/26 17:00", "sáb. 22/08/26 07:00", "qua. 02/09/26 17:00", "sex. 11/09/26 16:00" ) for (str in csvDates) { val parsed = parseFullDateTime(str) assertNotNull("Failed to parse CSV date format: $str", parsed) } val d1 = parseFullDateTime("sex. 14/08/26 07:00")!! val d2 = parseFullDateTime("ter. 18/08/26 17:00")!! val d3 = parseFullDateTime("qua. 02/09/26 17:00")!! assertTrue(d1.before(d2)) assertTrue(d2.before(d3)) } @Test fun testSortingChronologicalOrderWithCsvData() { // Activities created using real entries from documentacao/exemplo_testes/GestaoOS_Parada_project.csv val act1 = com.example.data.model.MaintenanceActivity( numeroOs = "1", descricao = "PARADA ANUAL 2026", setor = "Geral", equipe = "Mecânica", recurso = "Sem Recurso", dataInicio = "ter. 04/08/26 07:00", dataFim = "sex. 11/09/26 16:00", percentualExecucao = 0 ) val act3 = com.example.data.model.MaintenanceActivity( numeroOs = "3", descricao = "UTILIDADES", setor = "Geral", equipe = "Mecânica", recurso = "Sem Recurso", dataInicio = "sex. 14/08/26 07:00", dataFim = "qua. 02/09/26 17:00", percentualExecucao = 0 ) val act4 = com.example.data.model.MaintenanceActivity( numeroOs = "4", descricao = "B-111113", setor = "Geral", equipe = "Mecânica", recurso = "Sem Recurso", dataInicio = "sex. 14/08/26 07:00", dataFim = "sex. 14/08/26 07:00", percentualExecucao = 0 ) val act1024 = com.example.data.model.MaintenanceActivity( numeroOs = "1024", descricao = "SUBSTITUIÇÃO DA CHAPA DE FIXAÇÃO DOS APARADORES", setor = "Geral", equipe = "Mecânica", recurso = "GTEC 1", dataInicio = "seg. 17/08/26 07:00", dataFim = "ter. 18/08/26 17:00", percentualExecucao = 0 ) val act1025 = com.example.data.model.MaintenanceActivity( numeroOs = "1025", descricao = "FABRICAÇÃO E MONTAGEM DA BASE ACIONAMENTO", setor = "Geral", equipe = "Mecânica", recurso = "GTEC 3", dataInicio = "seg. 17/08/26 07:00", dataFim = "qua. 19/08/26 17:00", percentualExecucao = 0 ) val act875 = com.example.data.model.MaintenanceActivity( numeroOs = "875", descricao = "SUBSTITUIR APARADORES DA CORREIA", setor = "Geral", equipe = "Mecânica", recurso = "LEANDRO", dataInicio = "qua. 26/08/26 07:00", dataFim = "qui. 27/08/26 17:00", percentualExecucao = 0 ) val unorganizedList = listOf(act1, act3, act1025, act1024, act875, act4) val sortedList = unorganizedList.sortedWith { a1, a2 -> val p1 = parseFullDateTime(a1.dataFim) val p2 = parseFullDateTime(a2.dataFim) when { p1 == null && p2 == null -> a1.numeroOs.compareTo(a2.numeroOs) p1 == null -> 1 p2 == null -> -1 else -> { val comp = p1.compareTo(p2) if (comp != 0) comp else a1.numeroOs.compareTo(a2.numeroOs) } } } val sortedOsNumbers = sortedList.map { it.numeroOs } val expectedOsNumbers = listOf("4", "1024", "1025", "875", "3", "1") assertEquals(expectedOsNumbers, sortedOsNumbers) } @Test fun testFormatToShortDate() { assertEquals("14/08/26", formatToShortDate("Sex 14/08/26 07:00")) assertEquals("14/08/26", formatToShortDate("14/08/2026 08:30")) assertEquals("14/08/26", formatToShortDate("14/08/2026")) assertEquals("15/08/26", formatToShortDate("2026-08-15")) assertEquals("Todas", formatToShortDate("Todas")) assertEquals("N/A", formatToShortDate("N/A")) } @Test fun testConflictResolutionComputation() { val localHistory = listOf( com.example.data.model.OSUpdateHistory(id = 1, numeroOs = "OS1", timestamp = 1000L, percentualAnterior = 0, percentualNovo = 20, recurso = "Mecânico", emailEditor = "local@empresa.com"), com.example.data.model.OSUpdateHistory(id = 2, numeroOs = "OS2", timestamp = 1500L, percentualAnterior = 0, percentualNovo = 50, recurso = "Elétrico", emailEditor = "local@empresa.com"), com.example.data.model.OSUpdateHistory(id = 4, numeroOs = "OS4", timestamp = 3000L, percentualAnterior = 0, percentualNovo = 90, recurso = "Mecânico", emailEditor = "local@empresa.com"), com.example.data.model.OSUpdateHistory(id = 5, numeroOs = "OS5", timestamp = 4000L, percentualAnterior = 0, percentualNovo = 10, recurso = "Elétrico", emailEditor = "local@empresa.com") ) val remoteHistory = listOf( com.example.data.model.OSUpdateHistory(id = 10, numeroOs = "OS1", timestamp = 1200L, percentualAnterior = 0, percentualNovo = 30, recurso = "Mecânico", emailEditor = "remote@empresa.com"), com.example.data.model.OSUpdateHistory(id = 11, numeroOs = "OS3", timestamp = 2000L, percentualAnterior = 0, percentualNovo = 70, recurso = "Elétrico", emailEditor = "remote@empresa.com"), com.example.data.model.OSUpdateHistory(id = 12, numeroOs = "OS4", timestamp = 2500L, percentualAnterior = 0, percentualNovo = 80, recurso = "Mecânico", emailEditor = "remote@empresa.com"), com.example.data.model.OSUpdateHistory(id = 13, numeroOs = "OS5", timestamp = 4500L, percentualAnterior = 0, percentualNovo = 40, recurso = "Elétrico", emailEditor = "remote@empresa.com") ) val localHistoryKeys = localHistory.map { "${it.numeroOs}_${it.timestamp}" }.toSet() val remoteHistoryKeys = remoteHistory.map { "${it.numeroOs}_${it.timestamp}" }.toSet() val unuploadedLocalLogs = localHistory.filter { "${it.numeroOs}_${it.timestamp}" !in remoteHistoryKeys } val ossWithUnuploadedLogs = unuploadedLocalLogs.map { it.numeroOs }.toSet() val newRemoteLogs = remoteHistory.filter { "${it.numeroOs}_${it.timestamp}" !in localHistoryKeys } val ossWithNewRemoteLogs = newRemoteLogs.map { it.numeroOs }.toSet() val conflictingOSs = ossWithUnuploadedLogs.intersect(ossWithNewRemoteLogs) assertEquals(3, conflictingOSs.size) assertTrue(conflictingOSs.contains("OS1")) assertTrue(conflictingOSs.contains("OS4")) assertTrue(conflictingOSs.contains("OS5")) assertFalse(conflictingOSs.contains("OS2")) assertFalse(conflictingOSs.contains("OS3")) // OS1: Remote (1200) wins over Local (1000) val os1Local = unuploadedLocalLogs.filter { it.numeroOs == "OS1" }.maxByOrNull { it.timestamp }!! val os1Remote = newRemoteLogs.filter { it.numeroOs == "OS1" }.maxByOrNull { it.timestamp }!! assertFalse(os1Local.timestamp >= os1Remote.timestamp) // OS4: Local (3000) wins over Remote (2500) val os4Local = unuploadedLocalLogs.filter { it.numeroOs == "OS4" }.maxByOrNull { it.timestamp }!! val os4Remote = newRemoteLogs.filter { it.numeroOs == "OS4" }.maxByOrNull { it.timestamp }!! assertTrue(os4Local.timestamp >= os4Remote.timestamp) // OS5: Remote (4500) wins over Local (4000) val os5Local = unuploadedLocalLogs.filter { it.numeroOs == "OS5" }.maxByOrNull { it.timestamp }!! val os5Remote = newRemoteLogs.filter { it.numeroOs == "OS5" }.maxByOrNull { it.timestamp }!! assertFalse(os5Local.timestamp >= os5Remote.timestamp) } @Test fun testDashboardCalculations() { val activities = listOf( com.example.data.model.MaintenanceActivity( numeroOs = "OS1", descricao = "Mec 1", setor = "Geral", equipe = "Mecânica", recurso = "A", dataInicio = "01/08/2026", dataFim = "10/08/2026", percentualExecucao = 100, tag = "TAG1" ), com.example.data.model.MaintenanceActivity( numeroOs = "OS2", descricao = "Mec 2", setor = "Geral", equipe = "Mecânica", recurso = "A", dataInicio = "01/08/2026", dataFim = "10/08/2026", percentualExecucao = 50, tag = "TAG1" ), com.example.data.model.MaintenanceActivity( numeroOs = "OS3", descricao = "Elec 1", setor = "Geral", equipe = "Elétrica", recurso = "B", dataInicio = "01/08/2026", dataFim = "10/08/2026", percentualExecucao = 100, tag = "TAG2" ) ) // 1. Team productivity (ratio of completed 100% OSs over total OSs per team) val mecActivities = activities.filter { it.equipe == "Mecânica" } val mecTotal = mecActivities.size val mecCompleted = mecActivities.count { it.percentualExecucao >= 100 } val mecRatio = if (mecTotal > 0) (mecCompleted.toFloat() / mecTotal.toFloat() * 100f).toInt() else 0 assertEquals(50, mecRatio) val elecActivities = activities.filter { it.equipe == "Elétrica" } val elecTotal = elecActivities.size val elecCompleted = elecActivities.count { it.percentualExecucao >= 100 } val elecRatio = if (elecTotal > 0) (elecCompleted.toFloat() / elecTotal.toFloat() * 100f).toInt() else 0 assertEquals(100, elecRatio) // 2. Overdue calculation val referenceDate = parseDateOnly("15/08/2026")!! val overdueActivities = activities.filter { act -> val isNotCompleted = act.percentualExecucao < 100 val endDate = parseDateOnly(act.dataFim) isNotCompleted && endDate != null && endDate.before(referenceDate) } assertEquals(1, overdueActivities.size) assertEquals("OS2", overdueActivities.first().numeroOs) assertEquals("TAG1", overdueActivities.first().tag) } @Test fun testUserAccessParsingAndValidation() { // Simulate user access lists matching dynamic headers val rows = listOf( listOf("E-mail", "Nível de Acesso"), listOf("admin@empresa.com", "total"), listOf("editor@empresa.com", "editor"), listOf("viewer@empresa.com", "leitor"), listOf("random@empresa.com", "outro") ) val headers = rows[0].map { it.trim().lowercase() } val emailIdx = headers.indexOfFirst { it == "email" || it == "e-mail" || it.contains("email") } val nivelIdx = headers.indexOfFirst { it == "nivel_acesso" || it == "nivel" || it.contains("nivel") || it.contains("nível") } assertEquals(0, emailIdx) assertEquals(1, nivelIdx) val accessMap = mutableMapOf() for (i in 1 until rows.size) { val row = rows[i] val email = row[emailIdx].trim() val nivel = row[nivelIdx].trim() accessMap[email] = nivel } assertEquals("total", accessMap["admin@empresa.com"]) assertEquals("editor", accessMap["editor@empresa.com"]) assertEquals("leitor", accessMap["viewer@empresa.com"]) // Function to check write permission val hasWriteAccess = { email: String -> val level = accessMap[email]?.trim()?.lowercase() level == "total" || level == "editor" } assertTrue(hasWriteAccess("admin@empresa.com")) assertTrue(hasWriteAccess("editor@empresa.com")) assertFalse(hasWriteAccess("viewer@empresa.com")) assertFalse(hasWriteAccess("random@empresa.com")) assertFalse(hasWriteAccess("nonexistent@empresa.com")) } @Test fun testDynamicEquipeFiltering() { val activities = listOf( com.example.data.model.MaintenanceActivity( numeroOs = "101", descricao = "Troca de Motor", setor = "Geral", equipe = "Elétrica", recurso = "Resp A", dataInicio = "01/08/2026", dataFim = "05/08/2026", percentualExecucao = 100 ), com.example.data.model.MaintenanceActivity( numeroOs = "102", descricao = "Reparo de Painel", setor = "Geral", equipe = "elétrica", recurso = "Resp B", dataInicio = "01/08/2026", dataFim = "05/08/2026", percentualExecucao = 50 ), com.example.data.model.MaintenanceActivity( numeroOs = "103", descricao = "Solda Estrutural", setor = "Geral", equipe = "Caldeiraria", recurso = "Resp C", dataInicio = "01/08/2026", dataFim = "05/08/2026", percentualExecucao = 20 ) ) // Verify dynamic extraction val eqList = activities.map { it.equipe.trim() }.filter { it.isNotBlank() }.distinct().sorted() val uniqueEquipes = listOf("Todas") + eqList assertTrue(uniqueEquipes.contains("Elétrica")) assertTrue(uniqueEquipes.contains("elétrica")) assertTrue(uniqueEquipes.contains("Caldeiraria")) // Case-insensitive filtering check for Elétrica val eletricaActivities = activities.filter { it.equipe.trim().equals("Elétrica", ignoreCase = true) } assertEquals(2, eletricaActivities.size) // Dynamic team filtering check for Caldeiraria val caldeirariaActivities = activities.filter { it.equipe.trim().equals("Caldeiraria", ignoreCase = true) } assertEquals(1, caldeirariaActivities.size) assertEquals("103", caldeirariaActivities[0].numeroOs) } }