347 lines
16 KiB
Kotlin
347 lines
16 KiB
Kotlin
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<String, String>()
|
|
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)
|
|
}
|
|
}
|
|
|