feat(editor): Show history opens the run containing the clicked test and selects it

The lens imported the globally newest run, so clicking a test could open an
unrelated run that didn't contain it. Now it scans saved history newest-first
for the first run whose XML contains the test's locationUrl (off the EDT) and
imports that; once the tree is built it selects the matching node so the user
lands on the test they clicked. Falls back to the newest run when none match.

Author: xepozz

src/main/kotlin/com/github/xepozz/testo/tests/console/TestoChannelHistory.kt

@@ -83,6 +83,15 @@ internal object TestoChannelHistory {
                 // Pass the root so install() renders the whole imported tree's aggregate immediately, independent of the
                 // async JTree selection (which is often still null at this instant).
                 TestoChannelsUi.install(console, store, levelFilter, project, console, root)
+                // If "Show history" was clicked on a specific test, select its node so the user lands on that test.
+                val targetUrl = (console.properties as? TestoImportedConsoleProperties)?.targetUrl
+                if (targetUrl != null && root != null) {
+                    val match = findByLocationUrl(root, targetUrl)
+                    val form = console.resultsViewer as? SMTestRunnerResultsForm
+                    if (match != null && form != null) {
+                        ApplicationManager.getApplication().invokeLater { form.selectAndNotify(match) }
+                    }
+                }
                 return
             }
             lastCount = count
@@ -104,6 +113,20 @@ internal object TestoChannelHistory {
         }
     }
 
+    // Find the node for a clicked test. Prefer an exact locationUrl match; fall back to a node whose url starts with the
+    // target (a data-provider method whose datasets carry a " with data set #N" suffix), so selecting it shows the
+    // method's aggregate.
+    private fun findByLocationUrl(root: SMTestProxy, url: String): SMTestProxy? {
+        var prefixMatch: SMTestProxy? = null
+        var result: SMTestProxy? = null
+        forEachDescendant(root) { proxy ->
+            val loc = proxy.locationUrl
+            if (loc == url) result = result ?: proxy
+            else if (prefixMatch == null && loc != null && loc.startsWith(url)) prefixMatch = proxy
+        }
+        return result ?: prefixMatch
+    }
+
     /** Encodes the test's full "all" stream (and the icon/color of every channel it used) for [SMTestProxy.setMetainfo]. */
     private fun encode(store: ChannelOutputStore, key: String): String? {
         val chunks = store.allFor(key)

src/main/kotlin/com/github/xepozz/testo/tests/console/TestoHistoryImport.kt

@@ -34,10 +34,10 @@ import javax.swing.Icon
  * import. We reconstruct the same import, but build the console on a subclass that re-delegates `createImportActions`,
  * so an imported-history tab carries the exact toolbar a live run does.
  */
-internal fun openTestoHistory(project: Project, file: VirtualFile) {
+internal fun openTestoHistory(project: Project, file: VirtualFile, targetUrl: String? = null) {
     try {
         val executor = DefaultRunExecutor.getRunExecutorInstance()
-        val profile = TestoImportRunProfile(file, project, executor)
+        val profile = TestoImportRunProfile(file, project, executor, targetUrl)
         ExecutionEnvironmentBuilder.create(project, executor, profile)
             .executor(executor)
             .target(profile.target)
@@ -48,6 +48,29 @@ internal fun openTestoHistory(project: Project, file: VirtualFile) {
     }
 }
 
+/**
+ * "Show history" for one test: open the most recent saved run that actually contains [url] (so clicking a test doesn't
+ * land on an unrelated latest run), and once imported, select that test's node. Falls back to the newest run overall.
+ * Scans files off the EDT (the largest history XML is sizeable), then imports on the EDT.
+ */
+internal fun openTestoHistoryForTest(project: Project, url: String) {
+    com.intellij.openapi.application.ApplicationManager.getApplication().executeOnPooledThread {
+        val root = com.intellij.execution.TestStateStorage.getTestHistoryRoot(project)
+        val files = com.intellij.execution.testframework.sm.TestHistoryConfiguration.getInstance(project).files
+            .map { File(root, it) }
+            .filter { it.exists() }
+            .sortedByDescending { it.lastModified() }
+        val target = files.firstOrNull { f -> runCatching { f.readText().contains(url) }.getOrDefault(false) }
+            ?: files.firstOrNull()
+            ?: return@executeOnPooledThread
+        com.intellij.openapi.application.ApplicationManager.getApplication().invokeLater {
+            val vf = com.intellij.openapi.vfs.LocalFileSystem.getInstance().refreshAndFindFileByIoFile(target)
+                ?: return@invokeLater
+            openTestoHistory(project, vf, url)
+        }
+    }
+}
+
 /**
  * Mirrors `AbstractImportTestsAction.ImportRunProfile` (reused for parsing the saved `<config>` and resolving the
  * target), but its first [getState] returns our [TestoImportedRunnableState] so the console is built on our properties.
@@ -58,6 +81,7 @@ internal class TestoImportRunProfile(
     file: VirtualFile,
     project: Project,
     private val executor: Executor,
+    private val targetUrl: String? = null,
 ) : RunProfile {
     private val inner = AbstractImportTestsAction.ImportRunProfile(file, project, executor)
     private val ioFile = VfsUtilCore.virtualToIoFile(file)
@@ -73,7 +97,7 @@ internal class TestoImportRunProfile(
         val config = inner.initialConfiguration
         if (!imported && config is SMRunnerConsolePropertiesProvider) {
             imported = true
-            return TestoImportedRunnableState(config as RunConfiguration, ioFile)
+            return TestoImportedRunnableState(config as RunConfiguration, ioFile, targetUrl)
         }
         // Re-run from an imported tab (second invocation): run the original configuration's tests, not a re-import.
         return config?.getState(executor, environment) ?: inner.getState(executor, environment)
@@ -87,13 +111,14 @@ internal class TestoImportRunProfile(
 private class TestoImportedRunnableState(
     private val initialConfig: RunConfiguration,
     private val file: File,
+    private val targetUrl: String?,
 ) : RunProfileState {
     override fun execute(executor: Executor, runner: ProgramRunner<*>): ExecutionResult {
         val handler = NopProcessHandler()
         val delegate = (initialConfig as SMRunnerConsolePropertiesProvider)
             .createTestConsoleProperties(DefaultRunExecutor.getRunExecutorInstance()) as TestoConsoleProperties
         val props = TestoImportedConsoleProperties(
-            delegate, file, handler, initialConfig.project, initialConfig, delegate.testFrameworkName, executor,
+            delegate, file, handler, initialConfig.project, initialConfig, delegate.testFrameworkName, executor, targetUrl,
         )
         Disposer.register(props, delegate)
 
@@ -120,6 +145,8 @@ internal class TestoImportedConsoleProperties(
     config: RunConfiguration,
     frameworkName: String,
     executor: Executor,
+    // The locationUrl of the test the "Show history" lens was clicked on, so installForImport can select its node.
+    val targetUrl: String? = null,
 ) : ImportedTestConsoleProperties(delegate, file, handler, project, config, frameworkName, executor) {
     override fun createImportActions(): Array<AnAction> = delegate.createImportActions()
 }

src/main/kotlin/com/github/xepozz/testo/ui/TestoHistoryCodeVisionProvider.kt

@@ -71,9 +71,10 @@ class TestoHistoryCodeVisionProvider : CodeVisionProviderBase() {
     private fun historyHint(url: String): String? = "Show history"
 
     override fun handleClick(editor: Editor, element: PsiElement, event: MouseEvent?) {
-        openLatestHistory(element.project)
-        // TODO(follow-up): after the imported tree is built, select the specific test node via
-        //  TestResultsViewer.selectAndNotify matching SMTestProxy.getLocationUrl() == the test url.
+        val function = element as? Function ?: return openLatestHistory(element.project)
+        val url = TestoTestRunLineMarkerProvider.getLocationHint(function)
+        // Open the most recent run that actually contains this test (not just the globally latest) and select its node.
+        com.github.xepozz.testo.tests.console.openTestoHistoryForTest(element.project, url)
     }
 
     /**