tor-browser

BuildMetricsServiceTest.kt (8018B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

import groovy.json.JsonSlurper
import org.gradle.tooling.events.task.*
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.io.TempDir
import org.mockito.Mockito.*
import java.io.File

class BuildMetricsServiceTest {
   @TempDir
   lateinit var tempDir: File

   @Test
   fun `service records different task statuses correctly`() {
       val suffix = "task-status"
       val service = createService(tempDir, suffix)

       service.onFinish(createTaskEvent(":app:compileJava", upToDate = true))
       service.onFinish(createTaskEvent(":lib:test", fromCache = true))
       service.onFinish(createTaskEvent(":app:build"))
       service.onFinish(createTaskEvent(":app:failedTask", failed = true))
       service.onFinish(createTaskEvent(":app:skippedTask", skipped = true))

       service.close()

       val metricsFile = File(tempDir, "gradle/build/metrics/build-metrics-$suffix.json")
       assertTrue(metricsFile.exists())

       val metrics = JsonSlurper().parseText(metricsFile.readText()) as Map<*, *>
       val tasks = metrics["tasks"] as List<*>
       assertEquals(5, tasks.size)

       val taskMap = tasks.associate { task ->
           val t = task as Map<*, *>
           t["path"] to t["status"]
       }

       assertEquals("UP-TO-DATE", taskMap[":app:compileJava"])
       assertEquals("FROM-CACHE", taskMap[":lib:test"])
       assertEquals("EXECUTED", taskMap[":app:build"])
       assertEquals("FAILED", taskMap[":app:failedTask"])
       assertEquals("SKIPPED", taskMap[":app:skippedTask"])
   }

   @Test
   fun `service creates metrics file with correct structure`() {
       val suffix = "structure"
       val service = createService(tempDir, suffix)

       service.onFinish(createTaskEvent(":task1"))
       service.onFinish(createTaskEvent(":task2", upToDate = true))

       service.close()

       val metricsFile = File(tempDir, "gradle/build/metrics/build-metrics-$suffix.json")
       val metrics = JsonSlurper().parseText(metricsFile.readText()) as Map<*, *>

       assertNotNull(metrics["invocation"])
       assertNotNull(metrics["configPhase"])
       assertNotNull(metrics["tasks"])

       val tasks = metrics["tasks"] as List<*>
       assertEquals(2, tasks.size)
   }

   @Test
   fun `service uses custom file suffix`() {
       val suffix = "custom-suffix"
       val service = createService(tempDir, suffix)

       service.onFinish(createTaskEvent(":task1"))
       service.close()

       val metricsFile = File(tempDir, "gradle/build/metrics/build-metrics-$suffix.json")
       assertTrue(metricsFile.exists())
   }

   @Test
   fun `tasks appear in execution order`() {
       val suffix = "order"
       val service = createService(tempDir, suffix)

       service.onFinish(createTaskEvent(":first"))
       service.onFinish(createTaskEvent(":second"))
       service.onFinish(createTaskEvent(":third"))

       service.close()

       val metricsFile = File(tempDir, "gradle/build/metrics/build-metrics-$suffix.json")
       val metrics = JsonSlurper().parseText(metricsFile.readText()) as Map<*, *>
       val tasks = metrics["tasks"] as List<*>

       assertEquals(":first", (tasks[0] as Map<*, *>)["path"])
       assertEquals(":second", (tasks[1] as Map<*, *>)["path"])
       assertEquals(":third", (tasks[2] as Map<*, *>)["path"])
   }

   @Test
   fun `task timing fields are present in JSON`() {
       val suffix = "timing"
       val service = createService(tempDir, suffix)

       service.onFinish(createTaskEvent(":testTask"))
       service.close()

       val metricsFile = File(tempDir, "gradle/build/metrics/build-metrics-$suffix.json")
       val metrics = JsonSlurper().parseText(metricsFile.readText()) as Map<*, *>
       val tasks = metrics["tasks"] as List<*>
       val task = tasks[0] as Map<*, *>

       assertNotNull(task["start"])
       assertNotNull(task["stop"])
       assertNotNull(task["duration"])
   }

   @Test
   fun `service handles different task path formats`() {
       val suffix = "paths"
       val service = createService(tempDir, suffix)

       service.onFinish(createTaskEvent(":rootTask"))
       service.onFinish(createTaskEvent(":project:subTask"))
       service.onFinish(createTaskEvent(":deep:nested:project:deepTask"))

       service.close()

       val metricsFile = File(tempDir, "gradle/build/metrics/build-metrics-$suffix.json")
       val metrics = JsonSlurper().parseText(metricsFile.readText()) as Map<*, *>
       val tasks = metrics["tasks"] as List<*>

       val taskPaths = tasks.map { (it as Map<*, *>)["path"] }
       assertTrue(taskPaths.contains(":rootTask"))
       assertTrue(taskPaths.contains(":project:subTask"))
       assertTrue(taskPaths.contains(":deep:nested:project:deepTask"))
   }

   @Test
   fun `service creates metrics directory if it does not exist`() {
       val suffix = "newdir"
       val newTempDir = File(tempDir, "nonexistent")
       val service = createService(newTempDir, suffix)

       service.onFinish(createTaskEvent(":task"))
       service.close()

       val metricsDir = File(newTempDir, "gradle/build/metrics")
       assertTrue(metricsDir.exists())
       assertTrue(metricsDir.isDirectory)

       val metricsFile = File(metricsDir, "build-metrics-$suffix.json")
       assertTrue(metricsFile.exists())
   }

   @Suppress("UNCHECKED_CAST")
   private fun createService(topobjdir: File, fileSuffix: String): BuildMetricsService {
       val topojdirProperty = mock(org.gradle.api.provider.Property::class.java) as org.gradle.api.provider.Property<String>
       `when`(topojdirProperty.get()).thenReturn(topobjdir.absolutePath)

       val fileSuffixProperty = mock(org.gradle.api.provider.Property::class.java) as org.gradle.api.provider.Property<String>
       `when`(fileSuffixProperty.get()).thenReturn(fileSuffix)

       val parameters = object : BuildMetricsServiceParameters {
           override val topobjdir = topojdirProperty
           override val fileSuffix = fileSuffixProperty
       }
       return TestBuildMetricsService(parameters).apply {
           invocationStart = System.currentTimeMillis()
           configStart = invocationStart + 100
           configEnd = configStart + 200
       }
   }

   private fun createTaskEvent(taskPath: String, upToDate: Boolean = false, fromCache: Boolean = false, failed: Boolean = false, skipped: Boolean = false): TaskFinishEvent {
       val result = if (failed) mockFailedResult() else if (skipped) mockSkippedResult() else mockSuccessResult(upToDate, fromCache)
       val descriptor = mock(TaskOperationDescriptor::class.java).apply { `when`(getTaskPath()).thenReturn(taskPath) }
       return mock(TaskFinishEvent::class.java).apply { `when`(getDescriptor()).thenReturn(descriptor); `when`(getResult()).thenReturn(result) }
   }

   private fun mockSuccessResult(upToDate: Boolean, fromCache: Boolean) = mock(TaskSuccessResult::class.java).apply {
       `when`(getStartTime()).thenReturn(1000L); `when`(getEndTime()).thenReturn(2000L)
       `when`(isUpToDate()).thenReturn(upToDate); `when`(isFromCache()).thenReturn(fromCache)
   }

   private fun mockFailedResult() = mock(TaskFailureResult::class.java).apply {
       `when`(getStartTime()).thenReturn(1000L); `when`(getEndTime()).thenReturn(2000L)
   }

   private fun mockSkippedResult() = mock(TaskSkippedResult::class.java).apply {
       `when`(getStartTime()).thenReturn(1000L); `when`(getEndTime()).thenReturn(2000L)
   }

   class TestBuildMetricsService(private val testParameters: BuildMetricsServiceParameters) : BuildMetricsService(testParameters) {
       override fun getParameters() = testParameters
   }
}