prefer uniqueIds to method if parameterized node is selected (IDEA-189535)

java/execution/impl/src/com/intellij/execution/JavaTestConfigurationBase.java

@@ -45,6 +45,8 @@ public abstract class JavaTestConfigurationBase extends ModuleBasedConfiguration
   public abstract void beClassConfiguration(PsiClass aClass);
 
   public abstract boolean isConfiguredByElement(PsiElement element);
+  
+  public abstract String getTestType();
 
   public String prepareParameterizedParameter(String paramSetName) {
     return paramSetName;

java/execution/impl/src/com/intellij/execution/testframework/AbstractJavaTestConfigurationProducer.java

@@ -83,6 +83,10 @@ public abstract class AbstractJavaTestConfigurationProducer<T extends JavaTestCo
     return null;
   }
 
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return true;
+  }
+  
   @Override
   public boolean isConfigurationFromContext(T configuration, ConfigurationContext context) {
     if (isMultipleElementsSelected(context)) {
@@ -109,6 +113,8 @@ public abstract class AbstractJavaTestConfigurationProducer<T extends JavaTestCo
     if (vmParameters != null && !Comparing.strEqual(vmParameters, configuration.getVMParameters())) return false;
     if (differentParamSet(configuration, contextLocation)) return false;
 
+    if (!isApplicableTestType(configuration.getTestType(), context)) return false;
+
     if (configuration.isConfiguredByElement(element)) {
       final Module configurationModule = configuration.getConfigurationModule().getModule();
       if (Comparing.equal(location.getModule(), configurationModule)) return true;

plugins/junit/src/com/intellij/execution/junit/AbstractAllInDirectoryConfigurationProducer.java

@@ -23,6 +23,11 @@ public abstract class AbstractAllInDirectoryConfigurationProducer extends JUnitC
     super(configurationType);
   }
 
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return JUnitConfiguration.TEST_DIRECTORY.equals(type);
+  }
+
   @Override
   protected boolean setupConfigurationFromContext(JUnitConfiguration configuration,
                                                   ConfigurationContext context,

plugins/junit/src/com/intellij/execution/junit/AbstractAllInPackageConfigurationProducer.java

@@ -18,6 +18,11 @@ public abstract class AbstractAllInPackageConfigurationProducer extends JUnitCon
     super(configurationType);
   }
 
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return JUnitConfiguration.TEST_PACKAGE.equals(type);
+  }
+
   @Override
   protected boolean setupConfigurationFromContext(JUnitConfiguration configuration,
                                                   ConfigurationContext context,

plugins/junit/src/com/intellij/execution/junit/JUnitConfiguration.java

@@ -320,6 +320,11 @@ public class JUnitConfiguration extends JavaTestConfigurationBase {
     return getTestObject().isConfiguredByElement(this, testClass, testMethod, testPackage, testDir);
   }
 
+  @Override
+  public String getTestType() {
+    return getPersistentData().TEST_OBJECT;
+  }
+
   @Override
   public TestSearchScope getTestSearchScope() {
     return getPersistentData().getScope();

plugins/junit/src/com/intellij/execution/junit/PatternConfigurationProducer.java

@@ -65,6 +65,11 @@ public class PatternConfigurationProducer extends AbstractPatternBasedConfigurat
     return true;
   }
 
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return JUnitConfiguration.TEST_PATTERN.equals(type);
+  }
+
   @Override
   protected Module findModule(JUnitConfiguration configuration, Module contextModule) {
     final Set<String> patterns = configuration.getPersistentData().getPatterns();
@@ -73,12 +78,9 @@ public class PatternConfigurationProducer extends AbstractPatternBasedConfigurat
 
   @Override
   public boolean isConfigurationFromContext(JUnitConfiguration unitConfiguration, ConfigurationContext context) {
-    final TestObject testobject = unitConfiguration.getTestObject();
-    if (testobject instanceof TestsPattern) {
-      if (differentParamSet(unitConfiguration, context.getLocation())) return false;
-      final Set<String> patterns = unitConfiguration.getPersistentData().getPatterns();
-      if (isConfiguredFromContext(context, patterns)) return true;
-    }
+    if (differentParamSet(unitConfiguration, context.getLocation())) return false;
+    final Set<String> patterns = unitConfiguration.getPersistentData().getPatterns();
+    if (isConfiguredFromContext(context, patterns)) return true;
     return false;
   }
 }

plugins/junit/src/com/intellij/execution/junit/TestInClassConfigurationProducer.java

@@ -42,10 +42,26 @@ public class TestInClassConfigurationProducer extends JUnitConfigurationProducer
     myDelegate.onFirstRun(configuration, fromContext, performRunnable);
   }
 
+  @Override
+  public boolean isConfigurationFromContext(JUnitConfiguration configuration, ConfigurationContext context) {
+    if (UniqueIdConfigurationProducer.getNodeIds(context) != null) return false;
+    return super.isConfigurationFromContext(configuration, context);
+  }
+
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return myDelegate.isApplicableTestType(type, context);
+  }
+
   private static class JUnitInClassConfigurationProducerDelegate
     extends AbstractInClassConfigurationProducer<JUnitConfiguration> {
     public JUnitInClassConfigurationProducerDelegate() {super(JUnitConfigurationType.getInstance());}
 
+    @Override
+    protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+      return JUnitConfiguration.TEST_CLASS.equals(type) || JUnitConfiguration.TEST_METHOD.equals(type);
+    }
+
     @Override
     protected boolean setupConfigurationFromContext(JUnitConfiguration configuration, ConfigurationContext context, Ref<PsiElement> sourceElement) {
       return super.setupConfigurationFromContext(configuration, context, sourceElement);

plugins/junit/src/com/intellij/execution/junit/UniqueIdConfigurationProducer.java

@@ -8,7 +8,6 @@ import com.intellij.execution.configurations.RunConfiguration;
 import com.intellij.execution.testframework.AbstractTestProxy;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.search.GlobalSearchScope;
@@ -28,28 +27,36 @@ public class UniqueIdConfigurationProducer extends JUnitConfigurationProducer {
   protected boolean setupConfigurationFromContext(JUnitConfiguration configuration,
                                                   ConfigurationContext context,
                                                   Ref<PsiElement> sourceElement) {
-    final Project project = configuration.getProject();
-    DataContext dataContext = context.getDataContext();
-    AbstractTestProxy[] testProxies = dataContext.getData(AbstractTestProxy.DATA_KEYS);
-    if (testProxies == null) return false;
-    RunConfiguration runConfiguration = dataContext.getData(RunConfiguration.DATA_KEY);
-    if (!(runConfiguration instanceof JUnitConfiguration)) return false;
-    Module module = ((JUnitConfiguration)runConfiguration).getConfigurationModule().getModule();
-    configuration.setModule(module);
-    GlobalSearchScope searchScope =
-      module != null ? GlobalSearchScope.moduleWithDependenciesScope(module) : GlobalSearchScope.projectScope(project);
-    String[] nodeIds =
-      Arrays.stream(testProxies).map(testProxy -> TestUniqueId.getEffectiveNodeId(testProxy, project, searchScope))
-        .filter(Objects::nonNull)
-        .toArray(String[]::new);
+    String[] nodeIds = getNodeIds(context);
     if (nodeIds == null || nodeIds.length == 0) return false;
     final JUnitConfiguration.Data data = configuration.getPersistentData();
     data.setUniqueIds(nodeIds);
     data.TEST_OBJECT = JUnitConfiguration.TEST_UNIQUE_ID;
     configuration.setGeneratedName();
+    setupConfigurationModule(context, configuration);
     return true;
   }
 
+  public static String[] getNodeIds(ConfigurationContext context) {
+    DataContext dataContext = context.getDataContext();
+    AbstractTestProxy[] testProxies = dataContext.getData(AbstractTestProxy.DATA_KEYS);
+    if (testProxies == null) return null;
+    RunConfiguration runConfiguration = dataContext.getData(RunConfiguration.DATA_KEY);
+    if (!(runConfiguration instanceof JUnitConfiguration)) return null;
+    Module module = ((JUnitConfiguration)runConfiguration).getConfigurationModule().getModule();
+    
+    GlobalSearchScope searchScope =
+      module != null ? GlobalSearchScope.moduleWithDependenciesScope(module) : GlobalSearchScope.projectScope(context.getProject());
+    return 
+      Arrays.stream(testProxies).map(testProxy -> TestUniqueId.getEffectiveNodeId(testProxy, context.getProject(), searchScope))
+        .filter(Objects::nonNull)
+        .toArray(String[]::new);
+  }
+
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return JUnitConfiguration.TEST_UNIQUE_ID.equals(type);
+  }
 
   //prefer to method
   @Override

plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPackageConfigurationProducer.java

@@ -58,4 +58,8 @@ public abstract class AbstractTestNGPackageConfigurationProducer extends TestNGC
     return true;
   }
 
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return TestType.PACKAGE.getType().equals(type);
+  }
 }

plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGPatternConfigurationProducer.java

@@ -20,7 +20,6 @@ import com.intellij.execution.actions.ConfigurationContext;
 import com.intellij.execution.configurations.ConfigurationType;
 import com.intellij.execution.testframework.AbstractPatternBasedConfigurationProducer;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiElement;
 import com.theoryinpractice.testng.model.TestData;
@@ -61,11 +60,12 @@ public abstract class AbstractTestNGPatternConfigurationProducer extends Abstrac
 
   @Override
   public boolean isConfigurationFromContext(TestNGConfiguration testNGConfiguration, ConfigurationContext context) {
-    final String type = testNGConfiguration.getPersistantData().TEST_OBJECT;
-    if (Comparing.equal(type, TestType.PATTERN.getType())) {
-      if (differentParamSet(testNGConfiguration, context.getLocation())) return false;
-      return isConfiguredFromContext(context, testNGConfiguration.getPersistantData().getPatterns());
-    }
-    return false;
+    if (differentParamSet(testNGConfiguration, context.getLocation())) return false;
+    return isConfiguredFromContext(context, testNGConfiguration.getPersistantData().getPatterns());
+  }
+
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return TestType.PATTERN.getType().equals(type);
   }
 }

plugins/testng/src/com/theoryinpractice/testng/configuration/AbstractTestNGSuiteConfigurationProducer.java

@@ -55,4 +55,9 @@ public abstract class AbstractTestNGSuiteConfigurationProducer extends TestNGCon
     sourceElement.set(containingFile);
     return true;
   }
+
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return TestType.SUITE.getType().equals(type);
+  }
 }

plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGConfiguration.java

@@ -211,6 +211,11 @@ public class TestNGConfiguration extends JavaTestConfigurationBase {
     return TestNGTestObject.fromConfig(this).isConfiguredByElement(element);
   }
 
+  @Override
+  public String getTestType() {
+    return getPersistantData().TEST_OBJECT;
+  }
+
   @Override
   public String prepareParameterizedParameter(String paramSetName) {
     return TestNGConfigurationProducer.getInvocationNumber(paramSetName);

plugins/testng/src/com/theoryinpractice/testng/configuration/TestNGInClassConfigurationProducer.java

@@ -21,6 +21,7 @@ import com.intellij.execution.configurations.ConfigurationType;
 import com.intellij.execution.testframework.AbstractInClassConfigurationProducer;
 import com.intellij.openapi.util.Ref;
 import com.intellij.psi.PsiElement;
+import com.theoryinpractice.testng.model.TestType;
 import org.jetbrains.annotations.NotNull;
 
 public class TestNGInClassConfigurationProducer extends TestNGConfigurationProducer {
@@ -43,6 +44,11 @@ public class TestNGInClassConfigurationProducer extends TestNGConfigurationProdu
     return myDelegate.setupConfigurationFromContext(configuration, context, sourceElement);
   }
 
+  @Override
+  protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+    return myDelegate.isApplicableTestType(type, context);
+  }
+
   private static class TestNGInClassConfigurationProducerDelegate extends AbstractInClassConfigurationProducer<TestNGConfiguration> {
     protected TestNGInClassConfigurationProducerDelegate(ConfigurationType configurationType) {
       super(configurationType);
@@ -54,5 +60,10 @@ public class TestNGInClassConfigurationProducer extends TestNGConfigurationProdu
                                                     Ref<PsiElement> sourceElement) {
       return super.setupConfigurationFromContext(configuration, context, sourceElement);
     }
+
+    @Override
+    protected boolean isApplicableTestType(String type, ConfigurationContext context) {
+      return TestType.CLASS.getType().equals(type) || TestType.METHOD.getType().equals(type);
+    }
   }
 }