From d80f62063a9a84fe41463e39b95e709cbf24a8d9 Mon Sep 17 00:00:00 2001 From: Sergei Vorobyov Date: Fri, 8 Feb 2019 14:17:37 +0300 Subject: [PATCH] added tests on gradle configuration producers --- .../actions/ConfigurationFromContextImpl.java | 6 + .../action/GradleRerunFailedTestsAction.java | 6 +- .../GradleTestRunConfigurationProducer.java | 2 +- .../TestGradleConfigurationProducerUtil.kt | 16 +- .../src/util/GradleExecutionSettingsUtil.kt | 2 + .../GradleTestRunConfigurationProducerTest.kt | 239 ++++++++++++++++++ ...dleTestRunConfigurationProducerTestCase.kt | 219 ++++++++++++++++ ...stMethodGradleConfigurationProducerTest.kt | 44 +--- 8 files changed, 487 insertions(+), 47 deletions(-) create mode 100644 plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTest.kt create mode 100644 plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTestCase.kt diff --git a/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java index 8487f91efdeb..c68c84c334fd 100644 --- a/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java +++ b/platform/lang-api/src/com/intellij/execution/actions/ConfigurationFromContextImpl.java @@ -18,6 +18,7 @@ package com.intellij.execution.actions; import com.intellij.execution.RunnerAndConfigurationSettings; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.TestOnly; /** * @author yole @@ -69,4 +70,9 @@ public class ConfigurationFromContextImpl extends ConfigurationFromContext { public void onFirstRun(ConfigurationContext context, Runnable startRunnable) { myConfigurationProducer.onFirstRun(this, context, startRunnable); } + + @TestOnly + public RunConfigurationProducer getConfigurationProducer() { + return myConfigurationProducer; + } } diff --git a/plugins/gradle/java/src/action/GradleRerunFailedTestsAction.java b/plugins/gradle/java/src/action/GradleRerunFailedTestsAction.java index ba3b39aa1620..cb125e1449c5 100644 --- a/plugins/gradle/java/src/action/GradleRerunFailedTestsAction.java +++ b/plugins/gradle/java/src/action/GradleRerunFailedTestsAction.java @@ -42,6 +42,7 @@ import java.util.List; import static com.intellij.util.containers.ContainerUtil.filterIsInstance; import static org.jetbrains.plugins.gradle.execution.test.runner.GradleTestRunConfigurationProducer.findAllTestsTaskToRun; import static org.jetbrains.plugins.gradle.execution.test.runner.TestGradleConfigurationProducerUtilKt.applyTestConfiguration; +import static org.jetbrains.plugins.gradle.execution.test.runner.TestGradleConfigurationProducerUtilKt.escapeIfNeeded; import static org.jetbrains.plugins.gradle.util.GradleRerunFailedTasksActionUtilsKt.containsSubSequenceInSequence; import static org.jetbrains.plugins.gradle.util.GradleRerunFailedTasksActionUtilsKt.containsTasksInScriptParameters; @@ -83,8 +84,9 @@ public class GradleRerunFailedTestsAction extends JavaRerunFailedTestsAction { List> tasksToRun = new ArrayList<>(); boolean isSpecificTask = false; for (List tasks : foundTasksToRun) { - if (containsSubSequenceInSequence(runProfile.getSettings().getTaskNames(), tasks) || - containsTasksInScriptParameters(runProfile.getSettings().getScriptParameters(), tasks)) { + List escapedTasks = ContainerUtil.map(tasks, it -> escapeIfNeeded(it)); + if (containsSubSequenceInSequence(runProfile.getSettings().getTaskNames(), escapedTasks) || + containsTasksInScriptParameters(runProfile.getSettings().getScriptParameters(), escapedTasks)) { ContainerUtil.addAllNotNull(tasksToRun, tasks); isSpecificTask = true; } diff --git a/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java b/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java index 03ee20b91604..385ed8fa3fec 100644 --- a/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java +++ b/plugins/gradle/java/src/execution/test/runner/GradleTestRunConfigurationProducer.java @@ -113,7 +113,7 @@ public abstract class GradleTestRunConfigurationProducer extends RunConfiguratio public static boolean hasTasksInConfiguration(VirtualFile source, Project project, ExternalSystemTaskExecutionSettings settings) { List tasksToRun = findAllTestsTaskToRun(source, project); - List taskNames = settings.getTaskNames(); + List taskNames = ContainerUtil.map(settings.getTaskNames(), StringUtil::stripQuotesAroundValue); return tasksToRun.stream().anyMatch(taskNames::containsAll); } diff --git a/plugins/gradle/java/src/execution/test/runner/TestGradleConfigurationProducerUtil.kt b/plugins/gradle/java/src/execution/test/runner/TestGradleConfigurationProducerUtil.kt index d772900cda18..c6642836b565 100644 --- a/plugins/gradle/java/src/execution/test/runner/TestGradleConfigurationProducerUtil.kt +++ b/plugins/gradle/java/src/execution/test/runner/TestGradleConfigurationProducerUtil.kt @@ -1,4 +1,5 @@ // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +@file:ApiStatus.Experimental package org.jetbrains.plugins.gradle.execution.test.runner import com.intellij.openapi.externalSystem.model.execution.ExternalSystemTaskExecutionSettings @@ -8,6 +9,7 @@ import com.intellij.openapi.roots.ProjectFileIndex import com.intellij.openapi.vfs.VirtualFile import com.intellij.psi.PsiElement import com.intellij.psi.PsiFileSystemItem +import org.jetbrains.annotations.ApiStatus import org.jetbrains.plugins.gradle.execution.GradleRunnerUtil import org.jetbrains.plugins.gradle.execution.test.runner.GradleTestRunConfigurationProducer.findTestsTaskToRun import java.util.* @@ -89,7 +91,7 @@ fun ExternalSystemTaskExecutionSettings.applyTestConfigurati module = projectFileIndex.getModuleForFile(sourceFile) ?: return false if (!GradleRunnerUtil.isGradleModule(module)) return false val (_, arguments) = testRunConfigurations.getOrPut(module.name) { Pair(sourceFile, ArrayList()) } - arguments.add(createFilter(sourceElement, test)) + arguments.add(createFilter(sourceElement, test).trim()) } if (module == null) return false externalProjectPath = GradleRunnerUtil.resolveProjectPath(module) ?: return false @@ -117,10 +119,7 @@ private fun ExternalSystemTaskExecutionSettings.setFrom(taskSettings: List joiner.add("'$task'") - else -> joiner.add(task) - } + joiner.add(task.escapeIfNeeded()) joiner.addAll(arguments) } joiner.addAll(unorderedParameters) @@ -131,11 +130,16 @@ private fun ExternalSystemTaskExecutionSettings.setFrom(taskSettings: List "'$this'" + else -> this +} + private fun StringJoiner.addAll(elements: Iterable) = apply { for (element in elements) { add(element) diff --git a/plugins/gradle/java/src/util/GradleExecutionSettingsUtil.kt b/plugins/gradle/java/src/util/GradleExecutionSettingsUtil.kt index 4e4a88db832e..bc1472ee2834 100644 --- a/plugins/gradle/java/src/util/GradleExecutionSettingsUtil.kt +++ b/plugins/gradle/java/src/util/GradleExecutionSettingsUtil.kt @@ -7,7 +7,9 @@ import com.intellij.execution.junit2.PsiMemberParameterizedLocation import com.intellij.psi.PsiClass import com.intellij.psi.PsiMethod import com.intellij.psi.PsiPackage +import org.jetbrains.annotations.ApiStatus +@ApiStatus.Experimental object GradleExecutionSettingsUtil { private fun createTestFilter(filter: String, hasSuffix: Boolean): String { diff --git a/plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTest.kt b/plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTest.kt new file mode 100644 index 000000000000..dcdbec9825d4 --- /dev/null +++ b/plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTest.kt @@ -0,0 +1,239 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +package org.jetbrains.plugins.gradle.execution.test.runner + +import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration +import com.intellij.openapi.util.Ref +import org.jetbrains.plugins.gradle.util.runReadActionAndWait +import org.junit.Test + +class GradleTestRunConfigurationProducerTest : GradleTestRunConfigurationProducerTestCase() { + + @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.*"""") + } + } + + @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""" + ) + } + } + + @Test + fun `test configuration from context`() { + val projectData = generateAndImportTemplateProject() + runReadActionAndWait { + val context1 = getContextByLocation(projectData["project"]["TestCase"]["test1"].element) + val context2 = getContextByLocation(projectData["project"]["TestCase"].element) + val context3 = getContextByLocation(projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory) + val context4 = getContextByLocation(projectData["project"]["TestCase"]["test2"].element) + val context5 = getContextByLocation(projectData["project"]["TestCase"]["test1"].element) + val context6 = getContextByLocation(projectData["project"]["TestCase"].element) + val context7 = getContextByLocation(projectData["project"]["pkg.TestCase"].element.containingFile.containingDirectory) + val context8 = getContextByLocation(projectData["project"]["TestCase"]["test2"].element) + val configurationFromContext1 = getConfigurationFromContext(context1) + val configurationFromContext2 = getConfigurationFromContext(context2) + val configurationFromContext3 = getConfigurationFromContext(context3) + val configurationFromContext4 = getConfigurationFromContext(context4) + val configurationFromContext5 = getConfigurationFromContext(context5) + val configurationFromContext6 = getConfigurationFromContext(context6) + val configurationFromContext7 = getConfigurationFromContext(context7) + val configurationFromContext8 = getConfigurationFromContext(context8) + val configuration1 = configurationFromContext1.configuration as ExternalSystemRunConfiguration + val configuration2 = configurationFromContext2.configuration as ExternalSystemRunConfiguration + val configuration3 = configurationFromContext3.configuration as ExternalSystemRunConfiguration + val configuration4 = configurationFromContext4.configuration as ExternalSystemRunConfiguration + val configuration5 = configurationFromContext5.configuration as ExternalSystemRunConfiguration + val configuration6 = configurationFromContext6.configuration as ExternalSystemRunConfiguration + val configuration7 = configurationFromContext7.configuration as ExternalSystemRunConfiguration + val configuration8 = configurationFromContext8.configuration as ExternalSystemRunConfiguration + val producer1 = configurationFromContext1.configurationProducer + val producer2 = configurationFromContext2.configurationProducer + val producer3 = configurationFromContext3.configurationProducer + val producer4 = configurationFromContext4.configurationProducer + assertTrue(producer1.isConfigurationFromContext(configuration1, context1)) + assertFalse(producer1.isConfigurationFromContext(configuration1, context2)) + assertFalse(producer1.isConfigurationFromContext(configuration1, context3)) + assertFalse(producer1.isConfigurationFromContext(configuration1, context4)) + assertFalse(producer2.isConfigurationFromContext(configuration2, context1)) + assertTrue(producer2.isConfigurationFromContext(configuration2, context2)) + assertFalse(producer2.isConfigurationFromContext(configuration2, context3)) + assertFalse(producer2.isConfigurationFromContext(configuration2, context4)) + assertFalse(producer3.isConfigurationFromContext(configuration3, context1)) + assertFalse(producer3.isConfigurationFromContext(configuration3, context2)) + assertTrue(producer3.isConfigurationFromContext(configuration3, context3)) + assertFalse(producer3.isConfigurationFromContext(configuration3, context4)) + assertFalse(producer4.isConfigurationFromContext(configuration4, context1)) + assertFalse(producer4.isConfigurationFromContext(configuration4, context2)) + assertFalse(producer4.isConfigurationFromContext(configuration4, context3)) + assertTrue(producer4.isConfigurationFromContext(configuration4, context4)) + assertTrue(producer1.isConfigurationFromContext(configuration5, context5)) + assertTrue(producer2.isConfigurationFromContext(configuration6, context6)) + assertTrue(producer3.isConfigurationFromContext(configuration7, context7)) + assertTrue(producer4.isConfigurationFromContext(configuration8, context8)) + assertTrue(producer1.isConfigurationFromContext(configuration1, context5)) + assertTrue(producer2.isConfigurationFromContext(configuration2, context6)) + assertTrue(producer3.isConfigurationFromContext(configuration3, context7)) + assertTrue(producer4.isConfigurationFromContext(configuration4, context8)) + assertTrue(producer1.isConfigurationFromContext(configuration5, context1)) + assertTrue(producer2.isConfigurationFromContext(configuration6, context2)) + assertTrue(producer3.isConfigurationFromContext(configuration7, context3)) + assertTrue(producer4.isConfigurationFromContext(configuration8, context4)) + val context = getContextByLocation( + projectData["project"]["TestCase"]["test1"].element, + projectData["project"]["pkg.TestCase"]["test1"].element, + projectData["module"]["ModuleTestCase"]["test1"].element + ) + assertFalse(producer1.isConfigurationFromContext(configuration1, context)) + assertFalse(producer2.isConfigurationFromContext(configuration2, context)) + assertFalse(producer3.isConfigurationFromContext(configuration3, context)) + assertFalse(producer4.isConfigurationFromContext(configuration4, context)) + } + } + + @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"""") + } + } +} diff --git a/plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTestCase.kt b/plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTestCase.kt new file mode 100644 index 000000000000..998a35c33eab --- /dev/null +++ b/plugins/gradle/java/testSources/execution/test/runner/GradleTestRunConfigurationProducerTestCase.kt @@ -0,0 +1,219 @@ +// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. +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.ConfigurationFromContextImpl +import com.intellij.openapi.actionSystem.LangDataKeys +import com.intellij.openapi.externalSystem.service.execution.ExternalSystemRunConfiguration +import com.intellij.openapi.module.ModuleUtilCore +import com.intellij.openapi.vfs.VirtualFile +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiManager +import com.intellij.psi.PsiMethod +import com.intellij.testFramework.MapDataContext +import org.jetbrains.plugins.gradle.importing.GradleBuildScriptBuilderEx +import org.jetbrains.plugins.gradle.importing.GradleImportingTestCase +import org.jetbrains.plugins.gradle.util.findChildByElementType +import org.jetbrains.plugins.gradle.util.findChildByType +import org.jetbrains.plugins.gradle.util.findChildrenByType +import org.jetbrains.plugins.gradle.util.runReadActionAndWait +import org.junit.runners.Parameterized + +abstract class GradleTestRunConfigurationProducerTestCase : GradleImportingTestCase() { + + protected fun getContextByLocation(vararg elements: PsiElement): ConfigurationContext { + assertTrue(elements.isNotEmpty()) + val dataContext = MapDataContext().apply { + put(LangDataKeys.PROJECT, myProject) + put(LangDataKeys.MODULE, ModuleUtilCore.findModuleForPsiElement(elements[0])) + put(Location.DATA_KEY, PsiLocation.fromPsiElement(elements[0])) + put(Location.DATA_KEYS, elements.map { PsiLocation.fromPsiElement(it) }.toTypedArray()) + } + return object : ConfigurationContext(elements[0]) { + override fun getDataContext() = dataContext + override fun containsMultipleSelection() = elements.size > 1 + + } + } + + protected fun getConfigurationFromContext(context: ConfigurationContext): ConfigurationFromContextImpl { + val fromContexts = context.configurationsFromContext + val fromContext = fromContexts?.firstOrNull() + assertNotNull("Gradle configuration from context not found", fromContext) + return fromContext as ConfigurationFromContextImpl + } + + protected fun assertEqualsConfigurationSettings(configuration: ExternalSystemRunConfiguration, settings: String) { + assertEquals(settings, configuration.settings.toString().trim()) + } + + protected fun generateAndImportTemplateProject(): ProjectData { + val testCaseFile = createProjectSubFile("src/test/java/TestCase.java", """ + import org.junit.Test; + public class TestCase extends AbstractTestCase { + @Test public void test1() {} + @Test public void test2() {} + @Test public void test3() {} + } + """.trimIndent()) + val packageTestCaseFile = createProjectSubFile("src/test/java/pkg/TestCase.java", """ + package pkg; + import org.junit.Test; + public class TestCase extends AbstractTestCase { + @Test public void test1() {} + @Test public void test2() {} + @Test public void test3() {} + } + """.trimIndent()) + val automationTestCaseFile = createProjectSubFile("automation/AutomationTestCase.java", """ + import org.junit.Test; + public class AutomationTestCase extends AbstractTestCase { + @Test public void test1() {} + @Test public void test2() {} + @Test public void test3() {} + } + """.trimIndent()) + val abstractTestCaseFile = createProjectSubFile("src/test/java/AbstractTestCase.java", """ + import org.junit.Test; + public class AbstractTestCase { + @Test public void test() {} + } + """.trimIndent()) + val moduleTestCaseFile = createProjectSubFile("module/src/test/java/ModuleTestCase.java", """ + import org.junit.Test; + public class ModuleTestCase extends AbstractTestCase { + @Test public void test1() {} + @Test public void test2() {} + @Test public void test3() {} + } + """.trimIndent()) + val groovyTestCaseFile = createProjectSubFile("src/test/groovy/GroovyTestCase.groovy", """ + import org.junit.Test; + public class GroovyTestCase extends AbstractTestCase { + @Test public void 'Don\\\'t use single . quo\\"tes'() {} + @Test public void test1() {} + @Test public void test2() {} + @Test public void test3() {} + } + """.trimIndent()) + val myModuleTestCaseFile = createProjectSubFile("my module/src/test/groovy/MyModuleTestCase.groovy", """ + import org.junit.Test; + public class MyModuleTestCase extends AbstractTestCase { + @Test public void test1() {} + @Test public void test2() {} + @Test public void test3() {} + } + """.trimIndent()) + val buildScript = GradleBuildScriptBuilderEx() + .withJavaPlugin() + .withJUnit("4.12") + .withGroovyPlugin("2.4.14") + .addPrefix(""" + sourceSets { + automation.java.srcDirs = ['automation'] + automation.compileClasspath += sourceSets.test.runtimeClasspath + } + task autoTest(type: Test) { + testClassesDirs = sourceSets.automation.output.classesDirs + } + task automationTest(type: Test) { + testClassesDirs = sourceSets.automation.output.classesDirs + } + """.trimIndent()) + .addPrefix(""" + task myTestsJar(type: Jar, dependsOn: testClasses) { + baseName = "test-${'$'}{project.archivesBaseName}" + from sourceSets.automation.output + } + configurations { + testArtifacts + } + artifacts { + testArtifacts myTestsJar + } + """.trimIndent()) + val moduleBuildScript = GradleBuildScriptBuilderEx() + .withJavaPlugin() + .withJUnit("4.12") + .withGroovyPlugin("2.4.14") + .addDependency("testCompile project(path: ':', configuration: 'testArtifacts')") + createSettingsFile(""" + rootProject.name = 'project' + include 'module', 'my module' + """.trimIndent()) + createProjectSubFile("module/build.gradle", moduleBuildScript.generate()) + createProjectSubFile("my module/build.gradle", moduleBuildScript.generate()) + importProject(buildScript.generate()) + assertModules("project", "project.main", "project.test", "project.automation", + "project.module", "project.module.main", "project.module.test", + "project.my_module", "project.my_module.main", "project.my_module.test") + val automationTestCase = extractJavaClassData(automationTestCaseFile) + val testCase = extractJavaClassData(testCaseFile) + val abstractTestCase = extractJavaClassData(abstractTestCaseFile) + val moduleTestCase = extractJavaClassData(moduleTestCaseFile) + val packageTestCase = extractJavaClassData(packageTestCaseFile) + val groovyTestCase = extractGroovyClassData(groovyTestCaseFile) + val myModuleTestCase = extractGroovyClassData(myModuleTestCaseFile) + return ProjectData( + ModuleData("project", testCase, packageTestCase, automationTestCase, abstractTestCase, groovyTestCase), + ModuleData("module", moduleTestCase), + ModuleData("my module", myModuleTestCase) + ) + } + + private fun extractJavaClassData(file: VirtualFile) = runReadActionAndWait { + val psiManager = PsiManager.getInstance(myProject) + val psiFile = psiManager.findFile(file)!! + val psiClass = psiFile.findChildByType() + val psiMethods = psiClass.findChildrenByType() + val methods = psiMethods.map { MethodData(it.name, it) } + ClassData(psiClass.qualifiedName!!, psiClass, methods) + } + + private fun extractGroovyClassData(file: VirtualFile) = runReadActionAndWait { + val psiManager = PsiManager.getInstance(myProject) + val psiFile = psiManager.findFile(file)!! + val psiClass = psiFile.findChildByType() + val classBody = psiClass.findChildByElementType("CLASS_BODY") + val psiMethods = classBody.findChildrenByType() + val methods = psiMethods.map { MethodData(it.name, it) } + ClassData(psiClass.qualifiedName!!, psiClass, methods) + } + + + protected open class Mapping(val data: Map) { + operator fun get(key: String): D = data.getValue(key) + } + + protected class ProjectData( + vararg modules: ModuleData + ) : Mapping(modules.map { it.name to it }.toMap()) + + protected class ModuleData( + val name: String, + vararg classes: ClassData + ) : Mapping(classes.map { it.name to it }.toMap()) + + protected class ClassData( + val name: String, + val element: PsiClass, + methods: List + ) : Mapping(methods.map { it.name to it }.toMap()) + + protected class MethodData( + val name: String, + val element: PsiMethod + ) + + companion object { + /** + * It's sufficient to run the test against one gradle version + */ + @Parameterized.Parameters(name = "with Gradle-{0}") + @JvmStatic + fun tests(): Collection> = arrayListOf(arrayOf(GradleImportingTestCase.BASE_GRADLE_VERSION)) + } +} \ No newline at end of file diff --git a/plugins/gradle/java/testSources/execution/test/runner/TestMethodGradleConfigurationProducerTest.kt b/plugins/gradle/java/testSources/execution/test/runner/TestMethodGradleConfigurationProducerTest.kt index fa50f65d096d..6a7451472c54 100644 --- a/plugins/gradle/java/testSources/execution/test/runner/TestMethodGradleConfigurationProducerTest.kt +++ b/plugins/gradle/java/testSources/execution/test/runner/TestMethodGradleConfigurationProducerTest.kt @@ -1,7 +1,6 @@ // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package org.jetbrains.plugins.gradle.execution.test.runner -import org.jetbrains.plugins.gradle.importing.GradleBuildScriptBuilderEx import org.jetbrains.plugins.gradle.settings.TestRunner import org.junit.Test @@ -56,43 +55,12 @@ class TestMethodGradleConfigurationProducerTest : GradleConfigurationProducerTes currentExternalProjectSettings.testRunner = TestRunner.GRADLE assertTestFilter("package1.T1Test", null, "--tests \"package1.T1Test\"") - assertTestFilter("package1.T1Test", "testFoo", "--tests \"package1.T1Test.testFoo[*]\" ") - assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param1", "--tests \"package1.T1Test.testFoo[*param1*]\" ") - assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param2", "--tests \"package1.T1Test.testFoo[*param2*]\" ") + assertTestFilter("package1.T1Test", "testFoo", "--tests \"package1.T1Test.testFoo[*]\"") + assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param1", "--tests \"package1.T1Test.testFoo[*param1*]\"") + assertParameterizedLocationTestFilter("package1.T1Test", "testFoo", "param2", "--tests \"package1.T1Test.testFoo[*param2*]\"") assertTestFilter("package1.T2Test", null, "--tests \"package1.T2Test\"") - assertTestFilter("package1.T2Test", "testFoo2", "--tests \"package1.T2Test.testFoo2[*]\" ") - assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param1", "--tests \"package1.T2Test.testFoo2[*param1*]\" ") - assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param2", "--tests \"package1.T2Test.testFoo2[*param2*]\" ") - } - - @Test - fun `test pattern gradle run configuration`() { - val virtualFile = createProjectSubFile("src/test/groovy/Test.groovy", """ - import static org.junit.Assert.fail - import org.junit.Test - - class MyGroovyTest { - @Test - void 'Don\\\'t use single . quo\\"tes'() { - fail() - } - @Test - void test1() { - fail() - } - @Test - void test2() { - fail() - } - } - """.trimIndent()) - val buildScript = GradleBuildScriptBuilderEx() - .withGroovyPlugin("2.4.14") - .withJUnit("4.12") - importProject(buildScript.generate()) - - currentExternalProjectSettings.testRunner = TestRunner.GRADLE - val filter = "--tests \"MyGroovyTest.Don\\'t use single * quo\\*tes\" --tests \"MyGroovyTest.test2\" " - assertTestPatternFilter(filter, virtualFile, "Don\\'t use single . quo\\\"tes", "test2") + assertTestFilter("package1.T2Test", "testFoo2", "--tests \"package1.T2Test.testFoo2[*]\"") + assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param1", "--tests \"package1.T2Test.testFoo2[*param1*]\"") + assertParameterizedLocationTestFilter("package1.T2Test", "testFoo2", "param2", "--tests \"package1.T2Test.testFoo2[*param2*]\"") } } \ No newline at end of file