unit test

Author: leigaol

plugins/amazonq/codewhisperer/jetbrains-community/tst/software/aws/toolkits/jetbrains/services/codewhisperer/CodeWhispererUtilTest.kt

@@ -28,9 +28,16 @@ import software.aws.toolkits.jetbrains.services.codewhisperer.util.isWithin
 import software.aws.toolkits.jetbrains.services.codewhisperer.util.runIfIdcConnectionOrTelemetryEnabled
 import software.aws.toolkits.jetbrains.services.codewhisperer.util.toCodeChunk
 import software.aws.toolkits.jetbrains.services.codewhisperer.util.truncateLineByLine
+import software.aws.toolkits.jetbrains.services.codewhisperer.util.getDiagnosticDifferences
+import software.aws.toolkits.jetbrains.services.codewhisperer.util.getDiagnosticsType
+import software.aws.toolkits.jetbrains.services.codewhisperer.util.convertSeverity
+import com.intellij.lang.annotation.HighlightSeverity
 import software.aws.toolkits.jetbrains.settings.AwsSettings
 import software.aws.toolkits.jetbrains.utils.rules.JavaCodeInsightTestFixtureRule
 import software.aws.toolkits.telemetry.CodewhispererCompletionType
+import software.amazon.awssdk.services.codewhispererruntime.model.IdeDiagnostic
+import software.amazon.awssdk.services.codewhispererruntime.model.Position
+import software.amazon.awssdk.services.codewhispererruntime.model.Range
 
 class CodeWhispererUtilTest {
     @JvmField
@@ -308,4 +315,116 @@ class CodeWhispererUtilTest {
         val file = fixture.addFileToProject("workspace/projectA1/src/Sample.java", "").virtualFile
         assertThat(file.isWithin(projectRoot)).isFalse()
     }
+    @Test
+    fun `getDiagnosticsType correctly identifies syntax errors`() {
+        val messages = listOf(
+            "Expected semicolon at end of line",
+            "Incorrect indent level",
+            "Syntax error in expression"
+        )
+
+        messages.forEach { message ->
+            assertThat(getDiagnosticsType(message)).isEqualTo("SYNTAX_ERROR")
+        }
+    }
+
+    @Test
+    fun `getDiagnosticsType correctly identifies type errors`() {
+        val messages = listOf(
+            "Cannot cast String to Int",
+            "Type mismatch: expected String but got Int"
+        )
+
+        messages.forEach { message ->
+            assertThat(getDiagnosticsType(message)).isEqualTo("TYPE_ERROR")
+        }
+    }
+
+    @Test
+    fun `getDiagnosticsType returns OTHER for unrecognized patterns`() {
+        val message = "Some random message"
+        assertThat(getDiagnosticsType(message)).isEqualTo("OTHER")
+    }
+
+    @Test
+    fun `convertSeverity correctly maps severity levels`() {
+        assertThat(convertSeverity(HighlightSeverity.ERROR)).isEqualTo("ERROR")
+        assertThat(convertSeverity(HighlightSeverity.WARNING)).isEqualTo("WARNING")
+        assertThat(convertSeverity(HighlightSeverity.INFORMATION)).isEqualTo("INFORMATION")
+        assertThat(convertSeverity(HighlightSeverity.INFO)).isEqualTo("INFORMATION")
+    }
+
+    @Test
+    fun `getDiagnosticDifferences correctly identifies added and removed diagnostics`() {
+        val diagnostic1 = IdeDiagnostic.builder()
+            .ideDiagnosticType("SYNTAX_ERROR")
+            .severity("ERROR")
+            .source("inspection1")
+            .range(Range.builder()
+                .start(Position.builder().line(0).character(0).build())
+                .end(Position.builder().line(0).character(10).build())
+                .build())
+            .build()
+
+        val diagnostic2 = IdeDiagnostic.builder()
+            .ideDiagnosticType("TYPE_ERROR")
+            .severity("WARNING")
+            .source("inspection2")
+            .range(Range.builder()
+                .start(Position.builder().line(1).character(0).build())
+                .end(Position.builder().line(1).character(10).build())
+                .build())
+            .build()
+
+        val oldList = listOf(diagnostic1)
+        val newList = listOf(diagnostic2)
+
+        val differences = getDiagnosticDifferences(oldList, newList)
+
+        assertThat(differences.added).containsExactly(diagnostic2)
+        assertThat(differences.removed).containsExactly(diagnostic1)
+    }
+
+    @Test
+    fun `getDiagnosticDifferences handles empty lists`() {
+        val diagnostic = IdeDiagnostic.builder()
+            .ideDiagnosticType("SYNTAX_ERROR")
+            .severity("ERROR")
+            .source("inspection1")
+            .range(Range.builder()
+                .start(Position.builder().line(0).character(0).build())
+                .end(Position.builder().line(0).character(10).build())
+                .build())
+            .build()
+
+        val emptyList = emptyList<IdeDiagnostic>()
+        val nonEmptyList = listOf(diagnostic)
+
+        val differencesWithEmptyOld = getDiagnosticDifferences(emptyList, nonEmptyList)
+        assertThat(differencesWithEmptyOld.added).containsExactly(diagnostic)
+        assertThat(differencesWithEmptyOld.removed).isEmpty()
+
+        val differencesWithEmptyNew = getDiagnosticDifferences(nonEmptyList, emptyList)
+        assertThat(differencesWithEmptyNew.added).isEmpty()
+        assertThat(differencesWithEmptyNew.removed).containsExactly(diagnostic)
+    }
+
+    @Test
+    fun `getDiagnosticDifferences handles identical lists`() {
+        val diagnostic = IdeDiagnostic.builder()
+            .ideDiagnosticType("SYNTAX_ERROR")
+            .severity("ERROR")
+            .source("inspection1")
+            .range(Range.builder()
+                .start(Position.builder().line(0).character(0).build())
+                .end(Position.builder().line(0).character(10).build())
+                .build())
+            .build()
+
+        val list = listOf(diagnostic)
+        val differences = getDiagnosticDifferences(list, list)
+
+        assertThat(differences.added).isEmpty()
+        assertThat(differences.removed).isEmpty()
+    }
 }