465 lines
22 KiB
Kotlin
465 lines
22 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)
|
|
}
|
|
|
|
@Test
|
|
fun testIsDateInExecutionPeriod() {
|
|
val dataInicio = "18/08/2026"
|
|
val dataFim = "22/08/2026"
|
|
|
|
// 1. "Todas" matches everything
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("Todas", dataInicio, dataFim))
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("", dataInicio, dataFim))
|
|
|
|
// 2. Exact start date match (inclusive)
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("18/08/2026", dataInicio, dataFim))
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("18/08/26", dataInicio, dataFim))
|
|
|
|
// 3. Intermediate date inside range
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("20/08/2026", dataInicio, dataFim))
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("20/08/26", dataInicio, dataFim))
|
|
|
|
// 4. Exact end date match (inclusive)
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("22/08/2026", dataInicio, dataFim))
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("22/08/26", dataInicio, dataFim))
|
|
|
|
// 5. Out of bounds (before start date)
|
|
assertFalse(com.example.data.model.isDateInExecutionPeriod("17/08/2026", dataInicio, dataFim))
|
|
assertFalse(com.example.data.model.isDateInExecutionPeriod("17/08/26", dataInicio, dataFim))
|
|
|
|
// 6. Out of bounds (after end date)
|
|
assertFalse(com.example.data.model.isDateInExecutionPeriod("23/08/2026", dataInicio, dataFim))
|
|
assertFalse(com.example.data.model.isDateInExecutionPeriod("23/08/26", dataInicio, dataFim))
|
|
|
|
// 7. Formats with weekday and timestamps
|
|
val fullStart = "ter. 18/08/26 07:00"
|
|
val fullEnd = "sáb. 22/08/26 17:00"
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("20/08/26", fullStart, fullEnd))
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("18/08/26", fullStart, fullEnd))
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("22/08/26", fullStart, fullEnd))
|
|
assertFalse(com.example.data.model.isDateInExecutionPeriod("23/08/26", fullStart, fullEnd))
|
|
|
|
// 8. Missing end date ("N/A") falls back to start date only
|
|
assertTrue(com.example.data.model.isDateInExecutionPeriod("18/08/26", "18/08/26", "N/A"))
|
|
assertFalse(com.example.data.model.isDateInExecutionPeriod("19/08/26", "18/08/26", "N/A"))
|
|
}
|
|
|
|
@Test
|
|
fun testActivitiesFilteringByExecutionPeriod() {
|
|
val act1 = com.example.data.model.MaintenanceActivity(
|
|
numeroOs = "OS-100", descricao = "Manutenção Preventiva", setor = "Geral", equipe = "Mecânica", recurso = "Sem Recurso",
|
|
dataInicio = "18/08/2026", dataFim = "22/08/2026", percentualExecucao = 0
|
|
)
|
|
val act2 = com.example.data.model.MaintenanceActivity(
|
|
numeroOs = "OS-200", descricao = "Inspeção Elétrica", setor = "Geral", equipe = "Elétrica", recurso = "Sem Recurso",
|
|
dataInicio = "23/08/2026", dataFim = "25/08/2026", percentualExecucao = 0
|
|
)
|
|
val activities = listOf(act1, act2)
|
|
|
|
// Selecting 20/08/26 should include OS-100 (18/08 to 22/08) and exclude OS-200
|
|
val filtered = activities.filter { activity ->
|
|
com.example.data.model.isDateInExecutionPeriod("20/08/26", activity.dataInicio, activity.dataFim)
|
|
}
|
|
|
|
assertEquals(1, filtered.size)
|
|
assertEquals("OS-100", filtered[0].numeroOs)
|
|
}
|
|
|
|
@Test
|
|
fun testSCurveWeightedByHours() {
|
|
val actHeavy = com.example.data.model.MaintenanceActivity(
|
|
numeroOs = "OS-HEAVY", descricao = "Grande Substituição Eixo", setor = "Utilidades", equipe = "Mecânica", recurso = "A",
|
|
dataInicio = "01/08/2026 07:00", dataFim = "10/08/2026 17:00", percentualExecucao = 100, quantidadeHoras = 90.0
|
|
)
|
|
val actLight = com.example.data.model.MaintenanceActivity(
|
|
numeroOs = "OS-LIGHT", descricao = "Inspeção Visual", setor = "Utilidades", equipe = "Mecânica", recurso = "B",
|
|
dataInicio = "01/08/2026 07:00", dataFim = "10/08/2026 17:00", percentualExecucao = 0, quantidadeHoras = 10.0
|
|
)
|
|
|
|
val activities = listOf(actHeavy, actLight)
|
|
val history = emptyList<com.example.data.model.OSUpdateHistory>()
|
|
|
|
// Unweighted average would give (100 + 0) / 2 = 50%
|
|
// Weighted average by hours must give (100*90 + 0*10) / (90+10) = 90%
|
|
val analyticsState = com.example.ui.viewmodel.MaintenanceViewModel.calculateAnalyticsState(
|
|
activities, history, referenceDateOverride = parseDateOnly("15/08/2026")
|
|
)
|
|
val finalRealizedPct = analyticsState.realizedProgressPoints.last()
|
|
|
|
assertEquals(90.0f, finalRealizedPct, 0.5f)
|
|
}
|
|
|
|
@Test
|
|
fun testSCurveSectorFiltering() {
|
|
val actUtilidades = com.example.data.model.MaintenanceActivity(
|
|
numeroOs = "OS-UTIL", descricao = "Revisão Caldeira", setor = "Utilidades", equipe = "Mecânica", recurso = "A",
|
|
dataInicio = "01/08/2026 07:00", dataFim = "10/08/2026 17:00", percentualExecucao = 100, quantidadeHoras = 50.0
|
|
)
|
|
val actPreparacao = com.example.data.model.MaintenanceActivity(
|
|
numeroOs = "OS-PREP", descricao = "Pintura Estrutura", setor = "Preparação", equipe = "Pintura", recurso = "B",
|
|
dataInicio = "01/08/2026 07:00", dataFim = "10/08/2026 17:00", percentualExecucao = 0, quantidadeHoras = 50.0
|
|
)
|
|
|
|
val activities = listOf(actUtilidades, actPreparacao)
|
|
val history = emptyList<com.example.data.model.OSUpdateHistory>()
|
|
|
|
val stateAll = com.example.ui.viewmodel.MaintenanceViewModel.calculateAnalyticsState(
|
|
activities, history, selectedSetorSCurve = "Todos"
|
|
)
|
|
val stateUtil = com.example.ui.viewmodel.MaintenanceViewModel.calculateAnalyticsState(
|
|
activities, history, selectedSetorSCurve = "Utilidades"
|
|
)
|
|
val statePrep = com.example.ui.viewmodel.MaintenanceViewModel.calculateAnalyticsState(
|
|
activities, history, selectedSetorSCurve = "Preparação"
|
|
)
|
|
|
|
assertEquals(50.0f, stateAll.realizedProgressPoints.last(), 0.5f)
|
|
assertEquals(100.0f, stateUtil.realizedProgressPoints.last(), 0.5f)
|
|
assertEquals(0.0f, statePrep.realizedProgressPoints.last(), 0.5f)
|
|
}
|
|
}
|
|
|
|
|
|
|