Add unit tests to common package for allowedValues change

telemetry/csharp/AwsToolkit.Telemetry.Events.Generator/DefinitionsBuilder.cs

@@ -213,7 +213,7 @@ private CodeTypeDeclaration GenerateEnumStruct(MetricType type)
                     allowedValue.Replace(" ", "_").ToPascalCase().Replace(".", "").Replace("-", ""))
                 {
                     InitExpression = new CodeObjectCreateExpression(type.GetGeneratedTypeName(),
-                        new CodeExpression[] {new CodePrimitiveExpression(allowedValue)}),
+                        new CodeExpression[] {new CodePrimitiveExpression(allowedValue.Replace(" ", "_"))}),
                     Attributes = MemberAttributes.Static | MemberAttributes.Public
                 };
                 field.Comments.Add(new CodeCommentStatement(allowedValue, true));

telemetry/csharp/AwsToolkit.Telemetry.Events.Tests/GeneratedCodeTests.cs

@@ -217,6 +217,40 @@ public void RecordMetricWithNewTransform()
             Assert.Single(datum.Metadata);
         }
 
+        /// <summary>
+        /// RecordCodeTransformIsDoubleClickedToTriggerInvalidProject was chosen as a sample call that has a 
+        /// CodeTransformPreValidationError for allowedValues which have spaces in the values that 
+        /// should be converted to underscores.
+        /// </summary>
+        [Fact]
+        public void RecordWithAllowedValues()
+        {
+            var doubleClickRecord = new CodeTransformIsDoubleClickedToTriggerInvalidProject()
+            {
+                CodeTransformPreValidationError = CodeTransformPreValidationError.NoJavaProjectFound,
+                CodeTransformSessionId = "test-session-id",
+                Result = Result.Succeeded
+            };
+
+            _telemetryLogger.Object.RecordCodeTransformIsDoubleClickedToTriggerInvalidProject(doubleClickRecord);
+
+            Assert.NotNull(_recordedMetrics);
+            _telemetryLogger.Verify(
+                mock => mock.Record(_recordedMetrics),
+                Times.Once
+            );
+
+            var datum = Assert.Single(_recordedMetrics.Data);
+            Assert.NotNull(datum);
+            Assert.Equal("codeTransform_isDoubleClickedToTriggerInvalidProject", datum.MetricName);
+            Assert.Equal(Unit.None, datum.Unit);
+            Assert.False(datum.Passive);
+            Assert.True(datum.Metadata.ContainsKey("codeTransformSessionId"));
+            Assert.Equal("test-session-id", datum.Metadata["codeTransformSessionId"]);
+            Assert.True(datum.Metadata.ContainsKey("codeTransformPreValidationError"));
+            Assert.Equal("No_Java_project_found", datum.Metadata["codeTransformPreValidationError"]);
+        }
+
         private MetricDatum TransformDuplicateReason(MetricDatum datum)
         {
             datum.Metadata["reason1"] = datum.Metadata["reason"];

telemetry/csharp/README.md

@@ -81,6 +81,15 @@ Supplemental telemetry definitions can be integrated as follows:
 1. Run the generator, using the Toolkit's supplemental telemetry definition file(s) as command line arguments (`toolkitcore\AWSToolkit.Util\Telemetry\vs-telemetry-definitions.json`)
 1. Take the generated file(s) (GeneratedCode.cs), and place them in the toolkit (`toolkitcore\AWSToolkit.Util\Telemetry\ToolkitTelemetryEvents.generated.cs`)
 
+## Testing 
+
+Tests are located under `AwsToolkit.Telmetry.Events.Tests`. These 
+tests are based off the build from `commonDefinitions.json`.
+
+### Running Tests
+
+To run the tests you can run them from this directory `telemetry/csharp` with the `dotnet build -c Release AwsToolkit.Telemetry.sln` command. This command will build the repo, including `commonDefinitions.json` and the tests will be run against that JSON file output for C#.
+
 ## Roadmap
 
 -   Standalone NuGet Package containing the Telemetry Event generator

telemetry/jetbrains/README.md

@@ -24,3 +24,9 @@
     compileJava.dependsOn(generateTelemetry)
     ```
 To add additional telemetry files, add `file("/path/to/file)` entries into the inputFiles array.
+
+## Testing 
+
+### Running Tests
+
+To run the tests you can run them from this directory `telemetry/jetbrains` with the `./gradlew test` command.

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

@@ -86,7 +86,7 @@ private fun FileSpec.Builder.generateTelemetryEnumType(item: TelemetryMetricType
     item.allowedValues!!.forEach { enumValue ->
         enum.addEnumConstant(
             enumValue.toString().replace(Regex("\\s"), "_").toTypeFormat(), TypeSpec.anonymousClassBuilder()
-                .addSuperclassConstructorParameter("%S", enumValue.toString())
+                .addSuperclassConstructorParameter("%S", enumValue.toString().replace(Regex("\\s"), "_"))
                 .build()
         )
     }

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

@@ -39,6 +39,11 @@ class GeneratorTest {
         testGenerator(defaultDefinitionsFile = "/testResultInput.json", definitionsOverrides = listOf("/testOverrideInput.json"), expectedOutputFile = "/testOverrideOutput")
     }
 
+    @Test
+    fun generateAllowedValuesWithUnderscores() {
+        testGenerator(defaultDefinitionsFile = "/testGeneratorAllowedValuesInput.json", expectedOutputFile = "/testGeneratorAllowedValuesOutput")
+    }
+
     @Test
     fun longEnum() {
         testGenerator(defaultDefinitionsFile = "/testLongEnumInput.json", expectedOutputFile = "/testLongEnumOutput")

telemetry/jetbrains/src/test/resources/testGeneratorAllowedValuesInput.json

@@ -0,0 +1,21 @@
+
+{
+  "types": [
+    {
+      "name": "testAllowedValues",
+      "allowedValues": [
+        "test spaces are replaced",
+        "in allowed values"
+      ],
+      "description": "A test object for parsing allowedValues"
+    }
+  ],
+  "metrics": [
+      {
+          "name": "test_metric",
+          "description": "A test for defining allowedValues",
+          "unit": "None",
+          "metadata": [{ "type": "testAllowedValues" }]
+      }
+  ]
+}

telemetry/jetbrains/src/test/resources/testGeneratorAllowedValuesOutput

@@ -0,0 +1,101 @@
+// 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 com.intellij.openapi.project.Project
+import java.time.Instant
+import kotlin.Boolean
+import kotlin.Double
+import kotlin.String
+import kotlin.Suppress
+import kotlin.Unit
+import software.aws.toolkits.core.ConnectionSettings
+import software.aws.toolkits.jetbrains.services.telemetry.MetricEventMetadata
+import software.aws.toolkits.jetbrains.services.telemetry.TelemetryService
+
+/**
+ * A test object for parsing allowedValues
+ */
+public enum class TestAllowedValues(
+    private val `value`: String,
+) {
+    TestSpacesAreReplaced("test_spaces_are_replaced"),
+    InAllowedValues("in_allowed_values"),
+    Unknown("unknown"),
+    ;
+
+    public override fun toString(): String = value
+
+    public companion object {
+        public fun from(type: String): TestAllowedValues = values().firstOrNull { it.value == type }
+                ?: Unknown
+    }
+}
+
+public object TestTelemetry {
+    /**
+     * A test for defining allowedValues
+     */
+    public fun metric(
+        project: Project?,
+        testAllowedValues: TestAllowedValues,
+        passive: Boolean = false,
+        `value`: Double = 1.0,
+        createTime: Instant = Instant.now(),
+    ): Unit {
+        TelemetryService.getInstance().record(project) {
+            datum("test_metric") {
+                createTime(createTime)
+                unit(software.amazon.awssdk.services.toolkittelemetry.model.Unit.NONE)
+                value(value)
+                passive(passive)
+                metadata("testAllowedValues", testAllowedValues.toString())
+            }
+        }
+    }
+
+    /**
+     * A test for defining allowedValues
+     */
+    public fun metric(
+        connectionSettings: ConnectionSettings? = null,
+        testAllowedValues: TestAllowedValues,
+        passive: Boolean = false,
+        `value`: Double = 1.0,
+        createTime: Instant = Instant.now(),
+    ): Unit {
+        TelemetryService.getInstance().record(connectionSettings) {
+            datum("test_metric") {
+                createTime(createTime)
+                unit(software.amazon.awssdk.services.toolkittelemetry.model.Unit.NONE)
+                value(value)
+                passive(passive)
+                metadata("testAllowedValues", testAllowedValues.toString())
+            }
+        }
+    }
+
+    /**
+     * A test for defining allowedValues
+     */
+    public fun metric(
+        metadata: MetricEventMetadata,
+        testAllowedValues: TestAllowedValues,
+        passive: Boolean = false,
+        `value`: Double = 1.0,
+        createTime: Instant = Instant.now(),
+    ): Unit {
+        TelemetryService.getInstance().record(metadata) {
+            datum("test_metric") {
+                createTime(createTime)
+                unit(software.amazon.awssdk.services.toolkittelemetry.model.Unit.NONE)
+                value(value)
+                passive(passive)
+                metadata("testAllowedValues", testAllowedValues.toString())
+            }
+        }
+    }
+}

telemetry/vscode/README.md

@@ -12,3 +12,9 @@ The script has two arguments:
 
 1. `--extraInput` accepts lists of paths to telemetry JSON files, seperated by commas. For example, "--extraInput=abc.json,/abc/bcd.json"
 2. `--output` accepts one path which represents where the final output will go. For example, "--output=abc.ts"
+
+## Testing 
+
+### Running Tests
+
+To run the tests you can run them from this directory `telemetry/vscode` with the `npm run test` command.

telemetry/vscode/test/generator.test.ts

@@ -12,7 +12,6 @@ describe('Generator', () => {
     beforeAll(() => {
         tempDir = tmpdir()
     })
-
     test('Generate fails when validation fails', async () => {
         await expect(testGenerator(['resources/invalidInput.json'], '/invalid/file/path')).rejects.toBeDefined()
     })
@@ -28,6 +27,13 @@ describe('Generator', () => {
         )
     })
 
+    test('Generate replaces allowedValues spaces with underscores', async () => {
+        await testGenerator(
+            ['resources/generatorAllowedValuesInput.json'],
+            'resources/generatorAllowedValuesOutput.ts'
+        )
+    })
+
     async function testGenerator(inputFiles: string[], expectedOutputFile: string) {
         const output = `${tempDir}/output`
         await generate({ inputFiles: inputFiles.map(item => `${__dirname}/${item}`), outputFile: output })

telemetry/vscode/test/resources/generatorAllowedValuesInput.json

@@ -0,0 +1,36 @@
+
+{
+  "types": [
+    {
+        "name": "result",
+        "allowedValues": ["Succeeded"],
+        "description": "The result of the operation"
+    },
+    {
+        "name": "reason",
+        "type": "string",
+        "description": "The reason for a metric or exception depending on context"
+    },
+    {
+      "name": "duration",
+      "type": "double",
+      "description": "The duration of the operation in miliseconds"
+    },
+    {
+      "name": "testAllowedValues",
+      "allowedValues": [
+        "test spaces are replaced",
+        "in allowed values"
+      ],
+      "description": "A test object for parsing allowedValues"
+    }
+  ],
+  "metrics": [
+      {
+          "name": "test_metric",
+          "description": "A test for defining allowedValues",
+          "unit": "None",
+          "metadata": [{ "type": "testAllowedValues" }]
+      }
+  ]
+}

telemetry/vscode/test/resources/generatorAllowedValuesOutput.ts

@@ -0,0 +1,62 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface MetricBase {
+    /** The result of the operation */
+    readonly result?: Result
+    /** The reason for a metric or exception depending on context */
+    readonly reason?: string
+    /** The duration of the operation in miliseconds */
+    readonly duration?: number
+    /** A flag indicating that the metric was not caused by the user. */
+    readonly passive?: boolean
+    /** @deprecated Arbitrary "value" of the metric. */
+    readonly value?: number
+}
+
+export interface TestMetric extends MetricBase {
+    /** A test object for parsing allowedValues */
+    readonly testAllowedValues: TestAllowedValues
+}
+
+export type Result = 'Succeeded'
+export type LambdaRuntime = 'dotnetcore2.1' | 'nodejs12.x'
+export type TestAllowedValues = 'test_spaces_are_replaced' | 'in_allowed_values'
+
+export interface MetricDefinition {
+    readonly unit: string
+    readonly passive: boolean
+    readonly requiredMetadata: readonly string[]
+}
+
+export interface MetricShapes {
+    readonly test_metric: TestMetric
+}
+
+export type MetricName = keyof MetricShapes
+
+export const definitions: Record<string, MetricDefinition> = {
+    test_metric: { unit: 'None', passive: false, requiredMetadata: ['testAllowedValues'] },
+}
+
+export type Metadata<T extends MetricBase> = Partial<Omit<T, keyof MetricBase>>
+
+export interface Metric<T extends MetricBase = MetricBase> {
+    readonly name: string
+    /** Adds data to the metric which is preserved for the remainder of the execution context */
+    record(data: Metadata<T>): void
+    /** Sends the metric to the telemetry service */
+    emit(data?: T): void
+    /** Executes a callback, automatically sending the metric after completion */
+    run<U>(fn: (span: this) => U): U
+}
+
+export abstract class TelemetryBase {
+    /** A test for defining allowedValues */
+    public get test_metric(): Metric<TestMetric> {
+        return this.getMetric('test_metric')
+    }
+
+    protected abstract getMetric(name: string): Metric
+}