jetbrains: Split generated output over multiple files (#830)

Single generated file exceeded IDE default limits for code completion functionality

Resolve by splitting generated metric objects by namespace

Author: rli

telemetry/jetbrains/src/main/kotlin/software/aws/toolkits/telemetry/generator/TelemetryGenerator.kt

@@ -66,15 +66,27 @@ fun generateTelemetryFromFiles(
         metric.copy(metadata = metric.metadata + commonMetadata)
     }
 
+    val indent = " ".repeat(4)
     // make sure the output directory exists before writing to it
     outputFolder.mkdirs()
-    FileSpec.builder(PACKAGE_NAME, "TelemetryDefinitions")
-        .indent(" ".repeat(4))
+    FileSpec.builder(PACKAGE_NAME, "TelemetryEnums")
+        .indent(indent)
         .generateHeader()
         .generateTelemetryEnumTypes(telemetry.types)
-        .generateTelemetryObjects(metricsWithCommonMetadata)
         .build()
         .writeTo(outputFolder)
+
+    // Namespaced metrics
+    metricsWithCommonMetadata.groupBy { it.namespace() }
+        .toSortedMap()
+        .forEach { (namespace, metrics) ->
+            FileSpec.builder(PACKAGE_NAME, namespace.capitalize() + "Telemetry")
+                .indent(indent)
+                .generateHeader()
+                .generateNamespaces(namespace, metrics)
+                .build()
+                .writeTo(outputFolder)
+        }
 }
 
 private fun FileSpec.Builder.generateHeader(): FileSpec.Builder {
@@ -144,14 +156,6 @@ private fun FileSpec.Builder.generateTelemetryEnumType(item: TelemetryMetricType
     return this
 }
 
-private fun FileSpec.Builder.generateTelemetryObjects(schema: List<MetricSchema>): FileSpec.Builder {
-    schema.groupBy { it.namespace() }
-        .toSortedMap()
-        .forEach { (namespace, metrics) -> generateNamespaces(namespace, metrics) }
-
-    return this
-}
-
 private fun FileSpec.Builder.generateNamespaces(namespace: String, metrics: List<MetricSchema>): FileSpec.Builder {
     val telemetryObject = TypeSpec.objectBuilder("${namespace.toTypeFormat()}Telemetry")
 

telemetry/jetbrains/src/test/kotlin/software/aws/toolkits/telemetry/generator/GeneratorTest.kt

@@ -3,20 +3,28 @@
 
 package software.aws.toolkits.telemetry.generator
 
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Paths
+import kotlin.io.path.isRegularFile
+import kotlin.io.path.readText
+import kotlin.io.path.toPath
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.Rule
 import org.junit.Test
 import org.junit.rules.TemporaryFolder
-import java.io.File
-import java.nio.file.Files
-import java.nio.file.Paths
+import org.junit.rules.TestName
 
 class GeneratorTest {
     @JvmField
     @Rule
     val folder = TemporaryFolder()
 
+    @Rule
+    @JvmField
+    val testName = TestName()
+
     @Test
     fun generateFailsWhenValidationFails() {
         assertThatThrownBy {
@@ -26,51 +34,67 @@ class GeneratorTest {
 
     @Test
     fun generateWithGlobalMetadata() {
-        testGenerator(defaultDefinitionsFile = "/testGlobalMetadataInput.json", expectedOutputFile = "/testGlobalMetadataOutput")
+        testGenerator()
     }
 
     @Test
     fun generatesWithNormalInput() {
-        testGenerator(defaultDefinitionsFile = "/testGeneratorInput.json", expectedOutputFile = "/testGeneratorOutput")
+        testGenerator()
     }
 
     @Test
     fun resultGeneratesTwoFunctions() {
-        testGenerator(defaultDefinitionsFile = "/testResultInput.json", expectedOutputFile = "/testResultOutput")
+        testGenerator()
     }
 
     @Test
     fun generateOverrides() {
-        testGenerator(defaultDefinitionsFile = "/testResultInput.json", definitionsOverrides = listOf("/testOverrideInput.json"), expectedOutputFile = "/testOverrideOutput")
+        testGenerator(definitionsFile = "/resultGeneratesTwoFunctions/input.json", definitionsOverrides = listOf("/generateOverrides/overrideInput.json"))
     }
 
     @Test
     fun longEnum() {
-        testGenerator(defaultDefinitionsFile = "/testLongEnumInput.json", expectedOutputFile = "/testLongEnumOutput")
+        testGenerator()
     }
 
     @Test
     fun generateGeneratesWithDefaultDefinitions() {
         generateTelemetryFromFiles(inputFiles = listOf(), outputFolder = folder.root)
-        val outputFile = Paths.get(folder.root.absolutePath, "software", "aws", "toolkits", "telemetry", "TelemetryDefinitions.kt")
-        assertThat(Files.exists(outputFile)).isTrue
+        val outputFile = Paths.get(folder.root.absolutePath, "software", "aws", "toolkits", "telemetry")
+        assertThat(Files.walk(outputFile).toList()).isNotEmpty
     }
 
     // inputPath and outputPath must be in test resources
-    private fun testGenerator(defaultDefinitionsFile: String, definitionsOverrides: List<String> = listOf(), expectedOutputFile: String) {
+    private fun testGenerator(definitionsFile: String? = null, definitionsOverrides: List<String> = listOf()) {
+        val methodName = testName.methodName
         generateTelemetryFromFiles(
-            defaultDefinitions = listOf(this.javaClass.getResourceAsStream(defaultDefinitionsFile).use { it.bufferedReader().readText() }),
+            defaultDefinitions = listOf(this.javaClass.getResourceAsStream(definitionsFile ?: "/$methodName/input.json").use { it.bufferedReader().readText() }),
             inputFiles = definitionsOverrides.map { File(javaClass.getResource(it).toURI()) },
             outputFolder = folder.root
         )
 
-        val outputFile = Paths.get(folder.root.absolutePath, "software", "aws", "toolkits", "telemetry", "TelemetryDefinitions.kt")
-        assertThat(outputFile).exists()
+        val outputRoot = Paths.get(folder.root.absolutePath)
+        val outputFiles = Files.walk(outputRoot).filter { it.isRegularFile() }.toList()
+        val expectedRoot = this.javaClass.getResource("/$methodName").toURI().toPath().resolve("output")
+        val expectedFiles = Files.walk(expectedRoot).filter { it.isRegularFile() }.toList()
 
-        val expected = this.javaClass.getResourceAsStream(expectedOutputFile).use {
-            it.bufferedReader().readText()
+        if (expectedFiles.isEmpty()) {
+            // for dev convenience, populate the test files and consider it a pass
+            val root = Paths.get("src", "test", "resources", methodName, "output")
+            outputFiles.forEach {
+                val dest = root.resolve(outputRoot.relativize(it))
+                Files.createDirectories(dest.parent)
+                Files.copy(it, dest)
+            }
+            return
         }
 
-        assertThat(outputFile.toFile().readText()).isEqualTo(expected)
+        assertThat(outputFiles.map { outputRoot.relativize(it) })
+            .containsExactlyInAnyOrder(*expectedFiles.map { expectedRoot.relativize(it) }.toTypedArray())
+
+        outputFiles.forEach {
+            val relPath = outputRoot.relativize(it)
+            assertThat(it.readText()).isEqualTo(expectedRoot.resolve(relPath).readText())
+        }
     }
 }

telemetry/jetbrains/src/test/resources/generateOverrides/input.json

@@ -9,30 +9,12 @@ import com.intellij.openapi.project.Project
 import java.time.Instant
 import kotlin.Boolean
 import kotlin.Double
-import kotlin.String
 import kotlin.Suppress
 import software.amazon.awssdk.services.toolkittelemetry.model.Unit
 import software.aws.toolkits.core.ConnectionSettings
 import software.aws.toolkits.jetbrains.services.telemetry.MetricEventMetadata
 import software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
 
-/**
- * The result of the operation
- */
-public enum class Result(
-    private val `value`: String,
-) {
-    Succeeded("Succeeded"),
-    Unknown("unknown"),
-    ;
-
-    override fun toString(): String = value
-
-    public companion object {
-        public fun from(type: String): Result = values().firstOrNull { it.value == type } ?: Unknown
-    }
-}
-
 public object MetadataTelemetry {
     /**
      * It does not actually have a result, yep

telemetry/jetbrains/src/test/resources/testOverrideOutput renamed to telemetry/jetbrains/src/test/resources/generateOverrides/output/software/aws/toolkits/telemetry/MetadataTelemetry.kt

@@ -0,0 +1,26 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// THIS FILE IS GENERATED! DO NOT EDIT BY HAND!
+@file:Suppress("unused", "MemberVisibilityCanBePrivate")
+
+package software.aws.toolkits.telemetry
+
+import kotlin.String
+import kotlin.Suppress
+
+/**
+ * The result of the operation
+ */
+public enum class Result(
+    private val `value`: String,
+) {
+    Succeeded("Succeeded"),
+    Unknown("unknown"),
+    ;
+
+    override fun toString(): String = value
+
+    public companion object {
+        public fun from(type: String): Result = values().firstOrNull { it.value == type } ?: Unknown
+    }
+}

telemetry/jetbrains/src/test/resources/generateOverrides/output/software/aws/toolkits/telemetry/TelemetryEnums.kt

@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// THIS FILE IS GENERATED! DO NOT EDIT BY HAND!
+@file:Suppress("unused", "MemberVisibilityCanBePrivate")
+
+package software.aws.toolkits.telemetry
+
+import kotlin.String
+import kotlin.Suppress
+
+/**
+ * The result of the operation
+ */
+public enum class Result(
+    private val `value`: String,
+) {
+    Succeeded("Succeeded"),
+    Failed("Failed"),
+    Cancelled("Cancelled"),
+    Unknown("unknown"),
+    ;
+
+    override fun toString(): String = value
+
+    public companion object {
+        public fun from(type: String): Result = values().firstOrNull { it.value == type } ?: Unknown
+    }
+}

telemetry/jetbrains/src/test/resources/testOverrideInput.json renamed to telemetry/jetbrains/src/test/resources/generateOverrides/overrideInput.json

@@ -16,25 +16,6 @@ import software.aws.toolkits.core.ConnectionSettings
 import software.aws.toolkits.jetbrains.services.telemetry.MetricEventMetadata
 import software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
 
-/**
- * The result of the operation
- */
-public enum class Result(
-    private val `value`: String,
-) {
-    Succeeded("Succeeded"),
-    Failed("Failed"),
-    Cancelled("Cancelled"),
-    Unknown("unknown"),
-    ;
-
-    override fun toString(): String = value
-
-    public companion object {
-        public fun from(type: String): Result = values().firstOrNull { it.value == type } ?: Unknown
-    }
-}
-
 public object TestTelemetry {
     /**
      * Testing metric with global metadata fields