MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

[gradle][kotlin] IDEA-354292 refactor tests, add verification of the isConfigurationFromContext method of producer

Browse Source 
GitOrigin-RevId: 853e1bc91a3be3095f53f07cee446c758d920072
This commit is contained in:
Nikita Biriukov
2024-06-28 10:49:52 +00:00
committed by intellij-monorepo-bot
parent 652efdbe79
commit dee5a9223b
1 changed files with 52 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/kotlin/gradle/gradle-java/tests.shared/test/org/jetbrains/kotlin/idea/run/gradle/AbstractKotlinGradleTaskRunConfigurationProducerTest.kt
+52 -23
View File
@@ -1,16 +1,22 @@
// Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.run.gradle
import com.intellij.execution.PsiLocation
import com.intellij.execution.actions.ConfigurationContext
import com.intellij.execution.actions.ConfigurationFromContext
import com.intellij.execution.actions.ConfigurationFromContextImpl
import com.intellij.testFramework.assertInstanceOf
import com.intellij.testFramework.runInEdtAndWait
import org.gradle.util.GradleVersion
import org.jetbrains.kotlin.gradle.AbstractKotlinGradleCodeInsightBaseTest
import org.jetbrains.kotlin.idea.run.getConfiguration
import org.jetbrains.kotlin.idea.test.util.elementByOffset
import org.jetbrains.kotlin.idea.testFramework.gradle.assumeThatKotlinDslScriptsModelImportIsSupported
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration
import org.jetbrains.plugins.gradle.testFramework.annotations.AllGradleVersionsSource
import org.jetbrains.plugins.gradle.util.runReadActionAndWait
import org.junit.jupiter.params.ParameterizedTest
import kotlin.test.assertEquals
import kotlin.test.assertTrue
/**
* @see org.jetbrains.kotlin.idea.gradleJava.run.KotlinGradleTaskRunConfigurationProducer
@@ -19,33 +25,56 @@ abstract class AbstractKotlinGradleTaskRunConfigurationProducerTest : AbstractKo
@ParameterizedTest
@AllGradleVersionsSource("""
taskName : 'task("taskName") {}',
taskName : 'project.task("taskName") {}',
taskName : 'task("taskName<caret>") {}',
taskName : 'project.task("taskName<caret>") {}',
taskName : 'project.tasks.register("taskName") {}',
taskName : 'tasks.register("taskName") {}',
taskName : 'tasks.register<Task>("taskName") {}',
taskName : 'getTasks().register("taskName") {}',
taskName : 'tasks.create("taskName") {}',
taskName : 'tasks.create<Task>("taskName") {}',
help : 'tasks.named("help") {}',
taskName : 'project.tasks.register("taskName<caret>") {}',
taskName : 'tasks.register("taskName<caret>") {}',
taskName : 'tasks.register<Task>("taskName<caret>") {}',
taskName : 'getTasks().register("taskName<caret>") {}',
taskName : 'tasks.create("taskName<caret>") {}',
taskName : 'tasks.create<Task>("taskName<caret>") {}',
help : 'tasks.named("help<caret>") {}',
taskName : 'val taskName by tasks.registering {}',
taskName : 'val taskName by tasks.registering(Task::class) {}',
taskName : 'var taskName by tasks.creating {}',
taskName : 'var taskName by tasks.creating(Task::class) {}'
taskName : 'val task<caret>Name by tasks.registering {}',
taskName : 'val task<caret>Name by tasks.registering(Task::class) {}',
taskName : 'var task<caret>Name by tasks.creating {}',
taskName : 'var task<caret>Name by tasks.creating(Task::class) {}'
""")
fun testTaskHasConfiguration(gradleVersion: GradleVersion, taskName: String, taskDefinition: String) {
assumeThatKotlinDslScriptsModelImportIsSupported(gradleVersion)
testKotlinDslEmptyProject(gradleVersion) {
writeTextAndCommit("build.gradle.kts", taskDefinition)
runReadActionAndWait {
val buildFile = getFile("build.gradle.kts")
val configurationFromContext = getConfiguration(buildFile, project, taskName)
val taskConfiguration = assertInstanceOf<GradleRunConfiguration>(configurationFromContext.configuration)
assertEquals(listOf(taskName), taskConfiguration.settings.taskNames)
assertEquals("${project.name} [$taskName]", taskConfiguration.name)
}
verifyConfigurationAtCaret(taskName)
}
}
}
private fun verifyConfigurationAtCaret(taskName: String) {
runInEdtAndWait {
codeInsightFixture.configureFromExistingVirtualFile(getFile("build.gradle.kts"))
val location = PsiLocation(codeInsightFixture.elementByOffset)
val context = ConfigurationContext.createEmptyContextForLocation(location)
val configurationFromContext = context.configurationsFromContext?.singleOrNull()
?: error("Unable to find a single configuration from context")
verifyGradleRunConfiguration(configurationFromContext, taskName)
verifyConfigurationProducer(configurationFromContext, context)
}
}
private fun verifyGradleRunConfiguration(configurationFromContext: ConfigurationFromContext, taskName: String) {
val gradleConfiguration = assertInstanceOf<GradleRunConfiguration>(configurationFromContext.configuration)
assertEquals(listOf(taskName), gradleConfiguration.settings.taskNames,
"GradleRunConfiguration must contain only expected task name")
assertEquals("${project.name} [$taskName]", gradleConfiguration.name)
}
private fun verifyConfigurationProducer(
configurationFromContext: ConfigurationFromContext,
context: ConfigurationContext,
) {
val producer = configurationFromContext.safeAs<ConfigurationFromContextImpl>()?.configurationProducer
?: error("Unable to find a RunConfigurationProducer for configuration")
assertTrue(producer.isConfigurationFromContext(configurationFromContext.configuration, context),
"Producer must be able to identify a configuration that was created by it")
}
}