IDEA-207570 added preferred existing run configuration finding

platform/lang-api/src/com/intellij/execution/actions/ConfigurationContext.java

@@ -34,6 +34,9 @@ import org.jetbrains.annotations.Nullable;
 
 import java.awt.*;
 import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Context for creating run configurations from a location in the source code.
@@ -53,6 +56,7 @@ public class ConfigurationContext {
 
   public static Key<ConfigurationContext> SHARED_CONTEXT = Key.create("SHARED_CONTEXT");
   private List<RuntimeConfigurationProducer> myPreferredProducers;
+  private List<RunConfigurationProducer<?>> myPreferredConfigurationProducers;
   private List<ConfigurationFromContext> myConfigurationsFromContext;
 
   @NotNull
@@ -208,7 +212,12 @@ public class ConfigurationContext {
       myExistingConfiguration.set(null);
       return null;
     }
+    cacheExistingRuntimeConfiguration();
+    cacheExistingRunConfiguration();
+    return myExistingConfiguration.get();
+  }
 
+  private void cacheExistingRuntimeConfiguration() {
     final List<RuntimeConfigurationProducer> producers = findPreferredProducers();
     if (myRuntimeConfiguration != null) {
       if (producers != null) {
@@ -234,7 +243,12 @@ public class ConfigurationContext {
         }
       }
     }
-    for (RunConfigurationProducer producer : RunConfigurationProducer.getProducers(getProject())) {
+  }
+
+  private void cacheExistingRunConfiguration() {
+    List<RunConfigurationProducer<?>> producers = findPreferredConfigurationProducers();
+    if (producers == null) return;
+    for (RunConfigurationProducer producer : producers) {
       RunnerAndConfigurationSettings configuration = producer.findExistingConfiguration(this);
       if (configuration != null) {
         if (!Registry.is("suggest.all.run.configurations.from.context") || configuration.equals(myConfiguration)) {
@@ -242,7 +256,6 @@ public class ConfigurationContext {
         }
       }
     }
-    return myExistingConfiguration.get();
   }
 
   @Nullable
@@ -328,6 +341,19 @@ public class ConfigurationContext {
     return myPreferredProducers;
   }
 
+  @Nullable
+  private List<RunConfigurationProducer<?>> findPreferredConfigurationProducers() {
+    if (myPreferredConfigurationProducers == null) {
+      List<ConfigurationFromContext> configurations = getConfigurationsFromContext();
+      if (configurations == null) return null;
+      List<RunConfigurationProducer<?>> producers = RunConfigurationProducer.getProducers(getProject());
+      Function<ConfigurationFromContext, Stream<RunConfigurationProducer<?>>> mapper = configurationFromContext ->
+        producers.stream().filter(producer -> configurationFromContext.isProducedBy(producer.getClass()));
+      myPreferredConfigurationProducers = configurations.stream().flatMap(mapper).collect(Collectors.toList());
+    }
+    return myPreferredConfigurationProducers;
+  }
+
   @Nullable
   public List<ConfigurationFromContext> getConfigurationsFromContext() {
     if (myConfigurationsFromContext == null) {

plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTest.kt

@@ -229,4 +229,25 @@ class GradleTestRunConfigurationProducerTest : GradleTestRunConfigurationProduce
       }
     }
   }
+
+  @Test
+  fun `test find existing preferred run configuration`() {
+    val projectData = generateAndImportTemplateProject()
+    runReadActionAndWait {
+      val psiClass = projectData["project"]["TestCase"].element
+      assertExistingConfigurationType(TestRunner.GRADLE, null, psiClass)
+      assertExistingConfigurationType(TestRunner.PLATFORM, null, psiClass)
+      assertExistingConfigurationType(TestRunner.CHOOSE_PER_TEST, null, psiClass)
+      withConfiguration(TestRunner.GRADLE, psiClass) { gradleType ->
+        assertExistingConfigurationType(TestRunner.GRADLE, gradleType, psiClass)
+        assertExistingConfigurationType(TestRunner.PLATFORM, null, psiClass)
+        assertExistingConfigurationType(TestRunner.CHOOSE_PER_TEST, gradleType, psiClass)
+      }
+      withConfiguration(TestRunner.PLATFORM, psiClass) { platformType ->
+        assertExistingConfigurationType(TestRunner.GRADLE, null, psiClass)
+        assertExistingConfigurationType(TestRunner.PLATFORM, platformType, psiClass)
+        assertExistingConfigurationType(TestRunner.CHOOSE_PER_TEST, platformType, psiClass)
+      }
+    }
+  }
 }

plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTestCase.kt

@@ -3,9 +3,12 @@ package org.jetbrains.plugins.gradle.execution.test.runner
 
 import com.intellij.execution.Location
 import com.intellij.execution.PsiLocation
+import com.intellij.execution.RunManager
 import com.intellij.execution.actions.ConfigurationContext
 import com.intellij.execution.actions.ConfigurationFromContextImpl
 import com.intellij.execution.actions.RunConfigurationProducer
+import com.intellij.execution.configurations.ConfigurationType
+import com.intellij.execution.impl.RunManagerImpl
 import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.actionSystem.LangDataKeys
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
@@ -18,6 +21,7 @@ import com.intellij.psi.*
 import com.intellij.testFramework.MapDataContext
 import org.jetbrains.plugins.gradle.importing.GradleBuildScriptBuilderEx
 import org.jetbrains.plugins.gradle.importing.GradleImportingTestCase
+import org.jetbrains.plugins.gradle.settings.TestRunner
 import org.jetbrains.plugins.gradle.util.*
 import org.junit.runners.Parameterized
 import java.io.File
@@ -39,10 +43,28 @@ abstract class GradleTestRunConfigurationProducerTestCase : GradleImportingTestC
     }
   }
 
+  protected fun withConfiguration(runner: TestRunner, vararg elements: PsiClass, action: (ConfigurationType) -> Unit) {
+    currentExternalProjectSettings.testRunner = runner
+    val context = getContextByLocation(*elements)
+    val configurationFromContext = getConfigurationFromContext(context)
+    val configuration = configurationFromContext.configurationSettings
+    val runManager = RunManager.getInstance(myProject) as RunManagerImpl
+    runManager.clearAll()
+    runManager.addConfiguration(configuration)
+    action(configuration.type)
+  }
+
+  protected fun assertExistingConfigurationType(runner: TestRunner, type: ConfigurationType?, vararg elements: PsiClass) {
+    currentExternalProjectSettings.testRunner = runner
+    val context = getContextByLocation(*elements)
+    val existing = context.findExisting()
+    assertEquals(type, existing?.type)
+  }
+
   protected fun getConfigurationFromContext(context: ConfigurationContext): ConfigurationFromContextImpl {
     val fromContexts = context.configurationsFromContext
     val fromContext = fromContexts?.firstOrNull()
-    assertNotNull("Gradle configuration from context not found", fromContext)
+    assertNotNull("Configuration from context not found", fromContext)
     return fromContext as ConfigurationFromContextImpl
   }
 
@@ -281,6 +303,6 @@ abstract class GradleTestRunConfigurationProducerTestCase : GradleImportingTestC
      */
     @Parameterized.Parameters(name = "with Gradle-{0}")
     @JvmStatic
-    fun tests(): Collection<Array<out String>> = arrayListOf(arrayOf(GradleImportingTestCase.BASE_GRADLE_VERSION))
+    fun tests(): Collection<Array<out String>> = arrayListOf(arrayOf(BASE_GRADLE_VERSION))
   }
 }
\ No newline at end of file