refactor(test): enhance test failure handling with async and related code collection #259

phodal · phodal · commit ac0b670407d7 · 2025-03-13T18:05:05.000+08:00
- Refactor `sendResult` to run asynchronously with a delay for test failures.
- Add related code collection from console hyperlinks to provide more context in error notifications.
- Simplify `getConsoleView` logic and improve error handling.
- Remove redundant build issue handling in `ExternalTaskAgentObserver`.
diff --git a/core/src/main/kotlin/cc/unitmesh/devti/observer/ExternalTaskAgentObserver.kt b/core/src/main/kotlin/cc/unitmesh/devti/observer/ExternalTaskAgentObserver.kt
@@ -49,17 +49,17 @@ class ExternalTaskAgentObserver : AgentObserver, Disposable {
                     return
                 }
 
-                if (exitCode != 0 && exitCode != IDEA_INTERRUPTED_CODE) {
+//                if (exitCode != 0 && exitCode != IDEA_INTERRUPTED_CODE) {
+//                    val prompt = "Help Me fix follow build issue:\n```bash\n$globalBuffer\n```\n"
+//                    sendErrorNotification(project, prompt)
+//                } else {
+                val isSpringFailureToStart =
+                    globalBuffer.contains("***************************") && globalBuffer.contains("APPLICATION FAILED TO START")
+                if (isSpringFailureToStart) {
                     val prompt = "Help Me fix follow build issue:\n```bash\n$globalBuffer\n```\n"
                     sendErrorNotification(project, prompt)
-                } else {
-                    val isSpringFailureToStart =
-                        globalBuffer.contains("***************************") && globalBuffer.contains("APPLICATION FAILED TO START")
-                    if (isSpringFailureToStart) {
-                        val prompt = "Help Me fix follow build issue:\n```bash\n$globalBuffer\n```\n"
-                        sendErrorNotification(project, prompt)
-                    }
                 }
+//                }
             }
         })
     }
diff --git a/core/src/main/kotlin/cc/unitmesh/devti/observer/TestAgentObserver.kt b/core/src/main/kotlin/cc/unitmesh/devti/observer/TestAgentObserver.kt
@@ -1,47 +1,66 @@
 package cc.unitmesh.devti.observer
 
 import cc.unitmesh.devti.provider.observer.AgentObserver
+import cc.unitmesh.devti.sketch.ui.patch.readText
+import cc.unitmesh.devti.util.isInProject
 import cc.unitmesh.devti.util.relativePath
+import com.intellij.build.BuildView
+import com.intellij.execution.filters.FileHyperlinkInfo
 import com.intellij.execution.impl.ConsoleViewImpl
+import com.intellij.execution.impl.EditorHyperlinkSupport
 import com.intellij.execution.testframework.sm.runner.SMTRunnerEventsAdapter
 import com.intellij.execution.testframework.sm.runner.SMTRunnerEventsListener
 import com.intellij.execution.testframework.sm.runner.SMTestProxy
 import com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView
 import com.intellij.execution.ui.ExecutionConsole
 import com.intellij.execution.ui.RunContentManager
 import com.intellij.openapi.Disposable
-import com.intellij.openapi.application.runInEdt
 import com.intellij.openapi.application.runReadAction
-import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.markup.RangeHighlighter
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.ProgressManager
+import com.intellij.openapi.progress.Task
+import com.intellij.openapi.progress.impl.BackgroundableProcessIndicator
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.ProjectScope
 import com.intellij.refactoring.suggested.range
 import com.intellij.util.messages.MessageBusConnection
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import java.lang.reflect.Field
 
 class TestAgentObserver : AgentObserver, Disposable {
     private var connection: MessageBusConnection? = null
+
+    @OptIn(DelicateCoroutinesApi::class)
     override fun onRegister(project: Project) {
         connection = project.messageBus.connect()
         connection?.subscribe(SMTRunnerEventsListener.TEST_STATUS, object : SMTRunnerEventsAdapter() {
             override fun onTestFailed(test: SMTestProxy) {
-                sendResult(test, project, ProjectScope.getProjectScope(project))
+                GlobalScope.launch {
+                    delay(3000)
+                    sendResult(test, project, ProjectScope.getProjectScope(project))
+                }
             }
         })
     }
 
     private fun sendResult(test: SMTestProxy, project: Project, searchScope: GlobalSearchScope) {
-        runInEdt {
-            getConsoleEditor(project)
-            val sourceCode = test.getLocation(project, searchScope)
-            val psiElement = sourceCode?.psiElement
-            val language = psiElement?.language?.displayName ?: ""
-            val filepath = psiElement?.containingFile?.virtualFile?.relativePath(project) ?: ""
-            val code = runReadAction<String> { psiElement?.text ?: "" }
-            val prompt = """Help me fix follow test issue:
+        val task = object : Task.Backgroundable(project, "Processing context", false) {
+            override fun run(indicator: ProgressIndicator) {
+                val relatedCode = collectConsoleRelatedCode(project) ?: emptyList()
+                val sourceCode = runReadAction { test.getLocation(project, searchScope) }
+                val psiElement = sourceCode?.psiElement
+                val language = psiElement?.language?.displayName ?: ""
+                val filepath = psiElement?.containingFile?.virtualFile?.relativePath(project) ?: ""
+                val code = runReadAction<String> { psiElement?.text ?: "" }
+                val formatedRelatedCode = "\n## related code:\n```$language\n${relatedCode.joinToString("\n")}\n```"
+                val prompt = """Help me fix follow test issue:
                                |## ErrorMessage:
                                |```
                                |${test.errorMessage}
@@ -54,57 +73,106 @@ class TestAgentObserver : AgentObserver, Disposable {
                                |```$language
                                |$code
                                |```
+                               |${formatedRelatedCode}
                                |""".trimMargin()
 
-            sendErrorNotification(project, prompt)
+                sendErrorNotification(project, prompt)
+            }
         }
+
+        ProgressManager.getInstance()
+            .runProcessWithProgressAsynchronously(task, BackgroundableProcessIndicator(task))
     }
 
     /**
      *```kotlin
      * (content.component.components.firstOrNull() as? NonOpaquePanel)?.components?.firstOrNull { it is JBRunnerTabs }
      *```
      */
-    private fun getConsoleEditor(project: Project): Editor? {
+    private fun collectConsoleRelatedCode(project: Project): List<String>? {
         val content = RunContentManager.getInstance(project).selectedContent ?: return null
         val executionConsole = content.executionConsole ?: return null
         val consoleViewImpl: ConsoleViewImpl = getConsoleView(executionConsole) ?: return null
         val editor = consoleViewImpl.editor ?: return null
 
         val startOffset = 0
-        val allText = editor.document.text
         val endOffset = editor.document.textLength
         val textRange = TextRange(startOffset, endOffset)
         val highlighters: Array<RangeHighlighter> = editor.markupModel.allHighlighters
 
-        for (highlighter in highlighters) {
+        /// todo: first collect file path and line number, then build by range
+        val relatedCode = highlighters.mapNotNull { highlighter ->
             if (textRange.contains(highlighter.range!!)) {
-//                val hyperlinkInfo: FileHyperlinkInfo? = EditorHyperlinkSupport.getHyperlinkInfo(highlighter) as FileHyperlinkInfo
-//                val descriptor = hyperlinkInfo?.descriptor ?: return null
-                val range = highlighter.range!!
-                val hyperlinkText = allText.substring(range.startOffset, range.endOffset)
-                println("hyperlinkText: $hyperlinkText")
+                // call be .DiffHyperlink
+                val hyperlinkInfo: FileHyperlinkInfo? = EditorHyperlinkSupport.getHyperlinkInfo(highlighter) as? FileHyperlinkInfo
+                val descriptor = hyperlinkInfo?.descriptor ?: return@mapNotNull null
+                val virtualFile: VirtualFile = descriptor.file
+
+                val isProjectFile = runReadAction { project.isInProject(virtualFile) }
+                if (isProjectFile) {
+                    val lineNumber = descriptor.line
+                    val allText = virtualFile.readText()
+                    val startLine = if (lineNumber - 10 < 0) {
+                        0
+                    } else {
+                        lineNumber - 10
+                    }
+                    //  endLine should be less than allText.lines().size
+                    val endLine = if (lineNumber + 10 > allText.lines().size) {
+                        allText.lines().size
+                    } else {
+                        lineNumber + 10
+                    }
+
+                    return@mapNotNull allText.lines().subList(startLine, endLine).joinToString("\n")
+                } else {
+                    return@mapNotNull null
+                }
+            } else {
+                return@mapNotNull null
             }
         }
 
-        return consoleViewImpl.editor
+        return relatedCode.distinct()
     }
 
+
     private fun getConsoleView(executionConsole: ExecutionConsole): ConsoleViewImpl? {
-        if (executionConsole is SMTRunnerConsoleView) {
-            try {
-                val resultsViewerClass = executionConsole.resultsViewer::class.java
-                val myConsoleViewField: Field = resultsViewerClass.getDeclaredField("myConsoleView")
-                myConsoleViewField.isAccessible = true
-                val myConsoleView = myConsoleViewField.get(executionConsole.resultsViewer) as? ConsoleViewImpl
-                return myConsoleView
-            } catch (e: Exception) {
-                e.printStackTrace()
+        when (executionConsole) {
+            is ConsoleViewImpl -> {
+                return executionConsole
+            }
+
+            is BuildView -> {
+                when (executionConsole.consoleView) {
+                    is SMTRunnerConsoleView -> {
+                        return getTestView(executionConsole.consoleView as SMTRunnerConsoleView)
+                    }
+                }
+            }
+
+            is SMTRunnerConsoleView -> {
+                return getTestView(executionConsole)
             }
         }
-        return executionConsole as? ConsoleViewImpl
+
+        return null
     }
 
+    private fun getTestView(executionConsole: SMTRunnerConsoleView): ConsoleViewImpl? {
+        try {
+            val resultsViewerClass = executionConsole.resultsViewer::class.java
+            val myConsoleViewField: Field = resultsViewerClass.getDeclaredField("myConsoleView")
+            myConsoleViewField.isAccessible = true
+            val myConsoleView = myConsoleViewField.get(executionConsole.resultsViewer) as? ConsoleViewImpl
+            return myConsoleView
+        } catch (e: Exception) {
+            return null
+        }
+    }
+
+// ToolWindowManager.getInstance(project).getToolWindow(ToolWindowId.DEBUG)
+
     override fun dispose() {
         connection?.disconnect()
     }
