IDEA-CR-43035 cleanup tests

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

@@ -4,23 +4,20 @@ package org.jetbrains.plugins.gradle.execution.test.runner
 import com.intellij.execution.Location
 import com.intellij.execution.PsiLocation
 import com.intellij.execution.actions.ConfigurationContext
-import com.intellij.execution.actions.RunConfigurationProducer
 import com.intellij.execution.junit2.PsiMemberParameterizedLocation
-import com.intellij.idea.IdeaTestApplication
-import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.actionSystem.LangDataKeys
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
 import com.intellij.openapi.module.ModuleUtilCore
 import com.intellij.openapi.util.Computable
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.psi.*
+import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiMethod
 import com.intellij.psi.impl.PsiClassImplUtil
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.testFramework.MapDataContext
 import org.jetbrains.plugins.gradle.importing.GradleImportingTestCase
 import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
-import org.jetbrains.plugins.gradle.util.*
 import org.junit.runners.Parameterized
 
 abstract class GradleConfigurationProducerTestCase : GradleImportingTestCase() {
@@ -61,35 +58,6 @@ abstract class GradleConfigurationProducerTestCase : GradleImportingTestCase() {
     })
   }
 
-  fun assertTestPatternFilter(patternFilter: String, virtualFile: VirtualFile, vararg methodNames: String) {
-    ApplicationManager.getApplication().runReadAction {
-      val psiManager = PsiManager.getInstance(myProject)
-      val psiClass = psiManager.findFile(virtualFile)!!
-        .findChildByType<PsiClass>()
-      val psiMethods = psiClass
-        .findChildByElementType("CLASS_BODY")
-        .findChildrenByType<PsiMethod>()
-        .filter { it.name in methodNames }
-      val configurationProducer = RunConfigurationProducer.getInstance(PatternGradleConfigurationProducer::class.java)
-      val configurationContext = ConfigurationContext(psiClass)
-      val locations = psiMethods.map { PsiLocation.fromPsiElement(it) }.toTypedArray()
-      val module = ModuleUtilCore.findModuleForPsiElement(psiClass)
-      IdeaTestApplication.getInstance().setDataProvider {
-        when (it) {
-          CommonDataKeys.PROJECT.name -> myProject
-          LangDataKeys.MODULE.name -> module
-          Location.DATA_KEYS.name -> arrayOf(locations.first(), locations.last())
-          Location.DATA_KEY.name -> configurationContext.location
-          else -> null
-        }
-      }
-      val runConfiguration = configurationProducer.createLightConfiguration(configurationContext)
-      runConfiguration as ExternalSystemRunConfiguration
-      val scriptParameters = runConfiguration.settings.scriptParameters
-      assertEquals(patternFilter, scriptParameters)
-    }
-  }
-
   companion object {
     /**
      * It's sufficient to run the test against one gradle version

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

@@ -2,7 +2,9 @@
 package org.jetbrains.plugins.gradle.execution.test.runner
 
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
-import com.intellij.openapi.util.Ref
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiDirectory
+import com.intellij.psi.PsiMethod
 import org.jetbrains.plugins.gradle.util.runReadActionAndWait
 import org.junit.Test
 
@@ -11,97 +13,44 @@ class GradleTestRunConfigurationProducerTest : GradleTestRunConfigurationProduce
   @Test
   fun `test simple configuration`() {
     val projectData = generateAndImportTemplateProject()
-    runReadActionAndWait {
-      val context = getContextByLocation(projectData["project"]["TestCase"]["test1"].element)
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as TestMethodGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      assertTrue(producer.isConfigurationFromContext(configuration, context))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "TestCase.test1"""")
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(projectData["project"]["TestCase"].element)
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as TestClassGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      assertTrue(producer.isConfigurationFromContext(configuration, context))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "TestCase"""")
-    }
-  }
-
-  @Test
-  fun `test package configuration`() {
-    val projectData = generateAndImportTemplateProject()
-    runReadActionAndWait {
-      val context = getContextByLocation(projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory)
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as AllInPackageGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      assertTrue(producer.isConfigurationFromContext(configuration, context))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "pkg.*"""")
-    }
+    assertConfigurationFromContext<TestMethodGradleConfigurationProducer>(
+      """:cleanTest :test --tests "TestCase.test1"""",
+      projectData["project"]["TestCase"]["test1"].element
+    )
+    assertConfigurationFromContext<TestClassGradleConfigurationProducer>(
+      """:cleanTest :test --tests "TestCase"""",
+      projectData["project"]["TestCase"].element
+    )
+    assertConfigurationFromContext<AllInPackageGradleConfigurationProducer>(
+      """:cleanTest :test --tests "pkg.*"""",
+      runReadActionAndWait { projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory }
+    )
   }
 
   @Test
   fun `test pattern configuration`() {
     val projectData = generateAndImportTemplateProject()
-    runReadActionAndWait {
-      val context = getContextByLocation(
-        projectData["project"]["TestCase"]["test1"].element,
-        projectData["project"]["pkg.TestCase"]["test1"].element,
-        projectData["module"]["ModuleTestCase"]["test1"].element
-      )
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(
-        configuration,
-        """:cleanTest :test --tests "TestCase.test1" --tests "pkg.TestCase.test1" """ +
-        """:module:cleanTest :module:test --tests "ModuleTestCase.test1" --continue"""
-      )
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(
-        projectData["project"]["TestCase"].element,
-        projectData["project"]["pkg.TestCase"].element,
-        projectData["module"]["ModuleTestCase"].element
-      )
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(
-        configuration,
-        """:cleanTest :test --tests "TestCase" --tests "pkg.TestCase" """ +
-        """:module:cleanTest :module:test --tests "ModuleTestCase" --continue"""
-      )
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(
-        projectData["project"]["TestCase"]["test1"].element,
-        projectData["project"]["pkg.TestCase"]["test1"].element,
-        projectData["module"]["ModuleTestCase"].element
-      )
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(
-        configuration,
-        """:cleanTest :test --tests "TestCase.test1" --tests "pkg.TestCase.test1" """ +
-        """:module:cleanTest :module:test --tests "ModuleTestCase" --continue"""
-      )
-    }
+    assertConfigurationFromContext<PatternGradleConfigurationProducer>(
+      """:cleanTest :test --tests "TestCase.test1" --tests "pkg.TestCase.test1" """ +
+      """:module:cleanTest :module:test --tests "ModuleTestCase.test1" --continue""",
+      projectData["project"]["TestCase"]["test1"].element,
+      projectData["project"]["pkg.TestCase"]["test1"].element,
+      projectData["module"]["ModuleTestCase"]["test1"].element
+    )
+    assertConfigurationFromContext<PatternGradleConfigurationProducer>(
+      """:cleanTest :test --tests "TestCase" --tests "pkg.TestCase" """ +
+      """:module:cleanTest :module:test --tests "ModuleTestCase" --continue""",
+      projectData["project"]["TestCase"].element,
+      projectData["project"]["pkg.TestCase"].element,
+      projectData["module"]["ModuleTestCase"].element
+    )
+    assertConfigurationFromContext<PatternGradleConfigurationProducer>(
+      """:cleanTest :test --tests "TestCase.test1" --tests "pkg.TestCase.test1" """ +
+      """:module:cleanTest :module:test --tests "ModuleTestCase" --continue""",
+      projectData["project"]["TestCase"]["test1"].element,
+      projectData["project"]["pkg.TestCase"]["test1"].element,
+      projectData["module"]["ModuleTestCase"].element
+    )
   }
 
   @Test
@@ -179,61 +128,27 @@ class GradleTestRunConfigurationProducerTest : GradleTestRunConfigurationProduce
   @Test
   fun `test configuration escaping`() {
     val projectData = generateAndImportTemplateProject()
-    runReadActionAndWait {
-      val context = getContextByLocation(projectData["my module"]["MyModuleTestCase"]["test1"].element)
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as TestMethodGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      assertTrue(producer.isConfigurationFromContext(configuration, context))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(configuration, """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase.test1"""")
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(projectData["my module"]["MyModuleTestCase"].element)
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as TestClassGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      assertTrue(producer.isConfigurationFromContext(configuration, context))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(configuration, """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase"""")
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(
-        projectData["my module"]["MyModuleTestCase"]["test1"].element,
-        projectData["my module"]["MyModuleTestCase"]["test2"].element
-      )
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(
-        configuration, """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase.test1" --tests "MyModuleTestCase.test2"""")
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(projectData["project"]["GroovyTestCase"]["""Don\'t use single . quo\"tes"""].element)
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as TestMethodGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      assertTrue(producer.isConfigurationFromContext(configuration, context))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(configuration, """:cleanTest :test --tests "GroovyTestCase.Don\'t use single * quo\*tes"""")
-    }
-    runReadActionAndWait {
-      val context = getContextByLocation(
-        projectData["project"]["GroovyTestCase"]["""Don\'t use single . quo\"tes"""].element,
-        projectData["project"]["GroovyTestCase"]["test2"].element
-      )
-      val configurationFromContext = getConfigurationFromContext(context)
-      val producer = configurationFromContext.configurationProducer as PatternGradleConfigurationProducer
-      val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
-      assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
-      producer.onFirstRun(configurationFromContext, context, Runnable {})
-      assertEqualsConfigurationSettings(
-        configuration, """:cleanTest :test --tests "GroovyTestCase.Don\'t use single * quo\*tes" --tests "GroovyTestCase.test2"""")
-    }
+    assertConfigurationFromContext<TestMethodGradleConfigurationProducer>(
+      """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase.test1"""",
+      projectData["my module"]["MyModuleTestCase"]["test1"].element
+    )
+    assertConfigurationFromContext<TestClassGradleConfigurationProducer>(
+      """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase"""",
+      projectData["my module"]["MyModuleTestCase"].element
+    )
+    assertConfigurationFromContext<PatternGradleConfigurationProducer>(
+      """':my module:cleanTest' ':my module:test' --tests "MyModuleTestCase.test1" --tests "MyModuleTestCase.test2"""",
+      projectData["my module"]["MyModuleTestCase"]["test1"].element,
+      projectData["my module"]["MyModuleTestCase"]["test2"].element
+    )
+    assertConfigurationFromContext<TestMethodGradleConfigurationProducer>(
+      """:cleanTest :test --tests "GroovyTestCase.Don\'t use single * quo\*tes"""",
+      projectData["project"]["GroovyTestCase"]["""Don\'t use single . quo\"tes"""].element
+    )
+    assertConfigurationFromContext<PatternGradleConfigurationProducer>(
+      """:cleanTest :test --tests "GroovyTestCase.Don\'t use single * quo\*tes" --tests "GroovyTestCase.test2"""",
+      projectData["project"]["GroovyTestCase"]["""Don\'t use single . quo\"tes"""].element,
+      projectData["project"]["GroovyTestCase"]["test2"].element
+    )
   }
 }

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

@@ -5,9 +5,11 @@ import com.intellij.execution.Location
 import com.intellij.execution.PsiLocation
 import com.intellij.execution.actions.ConfigurationContext
 import com.intellij.execution.actions.ConfigurationFromContextImpl
+import com.intellij.execution.actions.RunConfigurationProducer
 import com.intellij.openapi.actionSystem.LangDataKeys
 import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration
 import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.openapi.util.Ref
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
@@ -35,7 +37,6 @@ abstract class GradleTestRunConfigurationProducerTestCase : GradleImportingTestC
     return object : ConfigurationContext(elements[0]) {
       override fun getDataContext() = dataContext
       override fun containsMultipleSelection() = elements.size > 1
-
     }
   }
 
@@ -46,8 +47,24 @@ abstract class GradleTestRunConfigurationProducerTestCase : GradleImportingTestC
     return fromContext as ConfigurationFromContextImpl
   }
 
-  protected fun assertEqualsConfigurationSettings(configuration: ExternalSystemRunConfiguration, settings: String) {
-    assertEquals(settings, configuration.settings.toString().trim())
+  protected inline fun <reified P : GradleTestRunConfigurationProducer> getConfigurationProducer(): P {
+    return RunConfigurationProducer.getInstance(P::class.java)
+  }
+
+  protected inline fun <reified P : GradleTestRunConfigurationProducer> assertConfigurationFromContext(
+    expectedSettings: String,
+    vararg elements: PsiElement
+  ) = runReadActionAndWait {
+    val context = getContextByLocation(*elements)
+    val configurationFromContext = getConfigurationFromContext(context)
+    val producer = configurationFromContext.configurationProducer as P
+    val configuration = configurationFromContext.configuration as ExternalSystemRunConfiguration
+    assertTrue(producer.setupConfigurationFromContext(configuration, context, Ref(context.psiLocation)))
+    if (producer !is PatternGradleConfigurationProducer) {
+      assertTrue(producer.isConfigurationFromContext(configuration, context))
+    }
+    producer.onFirstRun(configurationFromContext, context, Runnable {})
+    assertEquals(expectedSettings, configuration.settings.toString().trim())
   }
 
   protected fun generateAndImportTemplateProject(): ProjectData {