Convert KotlinProjectIT to new test dsl

^KT-45745 In Progress

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinProjectIT.kt

@@ -5,98 +5,138 @@
 
 package org.jetbrains.kotlin.gradle.model
 
-import org.jetbrains.kotlin.gradle.BaseGradleIT
+import org.gradle.api.logging.configuration.WarningMode
-import org.jetbrains.kotlin.gradle.util.AGPVersion
+import org.gradle.util.GradleVersion
-import org.jetbrains.kotlin.test.util.KtTestUtil
+import org.jetbrains.kotlin.gradle.testbase.*
-import org.junit.Test
+import org.junit.jupiter.api.DisplayName
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotEquals
 import kotlin.test.assertTrue
 
-class KotlinProjectIT : BaseGradleIT() {
+@DisplayName("Kotlin plugin model")
-    override fun defaultBuildOptions(): BuildOptions {
+@OtherGradlePluginTests
-        return super.defaultBuildOptions().copy(
+class KotlinProjectIT : KGPBaseTest() {
-            androidGradlePluginVersion = AGPVersion.v3_4_1,
+    override val defaultBuildOptions = super.defaultBuildOptions.copy(
-            androidHome = KtTestUtil.findAndroidSdk()
+        androidVersion = TestVersions.AGP.AGP_34,
     )
-    }
 
-    @Test
+    @DisplayName("Valid model is available in Kotlin only project")
-    fun testKotlinProject() {
+    @GradleTest
-        val project = Project("kotlinProject")
+    fun testKotlinProject(gradleVersion: GradleVersion) {
-        val kotlinProject = project.getModels(KotlinProject::class.java).getModel(":")!!
+        project("kotlinProject", gradleVersion) {
-
+            getModels<KotlinProject> {
-        kotlinProject.assertBasics(
+                with(getModel(":")!!) {
+                    assertBasics(
                         "kotlinProject",
-            defaultBuildOptions().kotlinVersion,
+                        defaultBuildOptions.kotlinVersion,
                         KotlinProject.ProjectType.PLATFORM_JVM,
                         "DEFAULT"
                     )
-        assertTrue(kotlinProject.expectedByDependencies.isEmpty())
+                    assertTrue(expectedByDependencies.isEmpty())
 
-        assertEquals(2, kotlinProject.sourceSets.size)
+                    assertEquals(2, sourceSets.size)
-        val mainSourceSet = kotlinProject.sourceSets.find { it.name == "main" }!!
+                    val mainSourceSet = sourceSets.single { it.name == "main" }
-        val testSourceSet = kotlinProject.sourceSets.find { it.name == "test" }!!
+                    val testSourceSet = sourceSets.single { it.name == "test" }
 
                     mainSourceSet.assertBasics("main", SourceSet.SourceSetType.PRODUCTION, emptySet())
                     testSourceSet.assertBasics("test", SourceSet.SourceSetType.TEST, listOf("main"))
 
                     assertEquals(2, mainSourceSet.sourceDirectories.size)
-        assertTrue(mainSourceSet.sourceDirectories.contains(project.projectDir.resolve("src/main/kotlin")))
+                    assertTrue(
-        assertTrue(mainSourceSet.sourceDirectories.contains(project.projectDir.resolve("src/main/java")))
+                        mainSourceSet.sourceDirectories.contains(
+                            projectPath.resolve("src/main/kotlin").toFile()
+                        )
+                    )
+                    assertTrue(
+                        mainSourceSet.sourceDirectories.contains(
+                            projectPath.resolve("src/main/java").toFile()
+                        )
+                    )
                     assertEquals(1, mainSourceSet.resourcesDirectories.size)
-        assertTrue(mainSourceSet.resourcesDirectories.contains(project.projectDir.resolve("src/main/resources")))
+                    assertTrue(
-        assertEquals(project.projectDir.resolve("build/classes/kotlin/main"), mainSourceSet.classesOutputDirectory)
+                        mainSourceSet.resourcesDirectories.contains(
-        assertEquals(project.projectDir.resolve("build/resources/main"), mainSourceSet.resourcesOutputDirectory)
+                            projectPath.resolve("src/main/resources").toFile()
+                        )
+                    )
+                    assertEquals(
+                        projectPath.resolve("build/classes/kotlin/main").toFile(),
+                        mainSourceSet.classesOutputDirectory
+                    )
+                    assertEquals(
+                        projectPath.resolve("build/resources/main").toFile(),
+                        mainSourceSet.resourcesOutputDirectory
+                    )
                     assertTrue(mainSourceSet.compilerArguments.compileClasspath.any { it.absolutePath.contains("guava") })
                     assertFalse(mainSourceSet.compilerArguments.compileClasspath.any { it.absolutePath.contains("testng") })
 
                     assertEquals(2, testSourceSet.sourceDirectories.size)
-        assertTrue(testSourceSet.sourceDirectories.contains(project.projectDir.resolve("src/test/kotlin")))
+                    assertTrue(testSourceSet.sourceDirectories.contains(projectPath.resolve("src/test/kotlin").toFile()))
-        assertTrue(testSourceSet.sourceDirectories.contains(project.projectDir.resolve("src/test/java")))
+                    assertTrue(testSourceSet.sourceDirectories.contains(projectPath.resolve("src/test/java").toFile()))
                     assertEquals(1, testSourceSet.resourcesDirectories.size)
-        assertTrue(testSourceSet.resourcesDirectories.contains(project.projectDir.resolve("src/test/resources")))
+                    assertTrue(testSourceSet.resourcesDirectories.contains(projectPath.resolve("src/test/resources").toFile()))
-        assertEquals(project.projectDir.resolve("build/classes/kotlin/test"), testSourceSet.classesOutputDirectory)
+                    assertEquals(projectPath.resolve("build/classes/kotlin/test").toFile(), testSourceSet.classesOutputDirectory)
-        assertEquals(project.projectDir.resolve("build/resources/test"), testSourceSet.resourcesOutputDirectory)
+                    assertEquals(projectPath.resolve("build/resources/test").toFile(), testSourceSet.resourcesOutputDirectory)
                     assertTrue(testSourceSet.compilerArguments.compileClasspath.any { it.absolutePath.contains("guava") })
                     assertTrue(testSourceSet.compilerArguments.compileClasspath.any { it.absolutePath.contains("testng") })
                 }
+            }
+        }
+    }
 
-    @Test
+    @DisplayName("Valid model in mixed Kotlin-Java project")
-    fun testKotlinJavaProject() {
+    @GradleTest
-        val project = Project("kotlinJavaProject")
+    fun testKotlinJavaProject(gradleVersion: GradleVersion) {
-        val kotlinProject = project.getModels(KotlinProject::class.java).getModel(":")!!
+        project("kotlinJavaProject", gradleVersion) {
-
+            getModels<KotlinProject> {
-        kotlinProject.assertBasics(
+                with(getModel(":")!!) {
+                    assertBasics(
                         "kotlinJavaProject",
-            defaultBuildOptions().kotlinVersion,
+                        defaultBuildOptions.kotlinVersion,
                         KotlinProject.ProjectType.PLATFORM_JVM,
                         "DEFAULT"
                     )
 
-        assertEquals(3, kotlinProject.sourceSets.size)
+                    assertEquals(3, sourceSets.size)
-        val mainSourceSet = kotlinProject.sourceSets.find { it.name == "main" }!!
+                    val mainSourceSet = sourceSets.single { it.name == "main" }
-        val deploySourceSet = kotlinProject.sourceSets.find { it.name == "deploy" }!!
+                    val deploySourceSet = sourceSets.single { it.name == "deploy" }
-        val testSourceSet = kotlinProject.sourceSets.find { it.name == "test" }!!
+                    val testSourceSet = sourceSets.single { it.name == "test" }
 
                     mainSourceSet.assertBasics("main", SourceSet.SourceSetType.PRODUCTION, emptySet())
                     deploySourceSet.assertBasics("deploy", SourceSet.SourceSetType.PRODUCTION, emptySet())
                     testSourceSet.assertBasics("test", SourceSet.SourceSetType.TEST, listOf("main"))
                 }
+            }
+        }
+    }
 
-    @Test
+    @DisplayName("Valid model in multiplatform project")
-    fun testMultiplatformProject() {
+    @GradleTest
-        val project = Project("multiplatformProject")
+    fun testMultiplatformProject(gradleVersion: GradleVersion) {
-        val models = project.getModels(KotlinProject::class.java)
+        project("multiplatformProject", gradleVersion) {
+            getModels<KotlinProject> {
+                val libKotlinProject = getModel(":lib")!!
+                val libJsKotlinProject = getModel(":libJs")!!
+                val libJvmKotlinProject = getModel(":libJvm")!!
 
-        val libKotlinProject = models.getModel(":lib")!!
+                libKotlinProject.assertBasics(
-        val libJsKotlinProject = models.getModel(":libJs")!!
+                    "lib",
-        val libJvmKotlinProject = models.getModel(":libJvm")!!
+                    defaultBuildOptions.kotlinVersion,
-
+                    KotlinProject.ProjectType.PLATFORM_COMMON,
-        libKotlinProject.assertBasics("lib", defaultBuildOptions().kotlinVersion, KotlinProject.ProjectType.PLATFORM_COMMON, "DEFAULT")
+                    "DEFAULT"
-        libJsKotlinProject.assertBasics("libJs", defaultBuildOptions().kotlinVersion, KotlinProject.ProjectType.PLATFORM_JS, "DEFAULT")
+                )
-        libJvmKotlinProject.assertBasics("libJvm", defaultBuildOptions().kotlinVersion, KotlinProject.ProjectType.PLATFORM_JVM, "DEFAULT")
+                libJsKotlinProject.assertBasics(
+                    "libJs",
+                    defaultBuildOptions.kotlinVersion,
+                    KotlinProject.ProjectType.PLATFORM_JS,
+                    "DEFAULT"
+                )
+                libJvmKotlinProject.assertBasics(
+                    "libJvm",
+                    defaultBuildOptions.kotlinVersion,
+                    KotlinProject.ProjectType.PLATFORM_JVM,
+                    "DEFAULT"
+                )
 
                 assertEquals(1, libJsKotlinProject.expectedByDependencies.size)
                 assertTrue(libJsKotlinProject.expectedByDependencies.contains(":lib"))
@@ -106,68 +146,53 @@ class KotlinProjectIT : BaseGradleIT() {
 
 
                 assertEquals(2, libJsKotlinProject.sourceSets.size)
-        val mainJsSourceSet = libJsKotlinProject.sourceSets.find { it.name == "main" }!!
+                val mainJsSourceSet = libJsKotlinProject.sourceSets.single { it.name == "main" }
-        val testJsSourceSet = libJsKotlinProject.sourceSets.find { it.name == "test" }!!
+                val testJsSourceSet = libJsKotlinProject.sourceSets.single { it.name == "test" }
 
                 mainJsSourceSet.assertBasics("main", SourceSet.SourceSetType.PRODUCTION, emptySet())
                 testJsSourceSet.assertBasics("test", SourceSet.SourceSetType.TEST, listOf("main"))
 
                 assertEquals(1, mainJsSourceSet.sourceDirectories.size)
-        assertTrue(mainJsSourceSet.sourceDirectories.contains(project.projectDir.resolve("libJs/src/main/kotlin")))
+                assertTrue(mainJsSourceSet.sourceDirectories.contains(projectPath.resolve("libJs/src/main/kotlin").toFile()))
                 assertEquals(1, mainJsSourceSet.resourcesDirectories.size)
-        assertTrue(mainJsSourceSet.resourcesDirectories.contains(project.projectDir.resolve("libJs/src/main/resources")))
+                assertTrue(mainJsSourceSet.resourcesDirectories.contains(projectPath.resolve("libJs/src/main/resources").toFile()))
-        assertEquals(project.projectDir.resolve("libJs/build/classes/kotlin/main"), mainJsSourceSet.classesOutputDirectory)
+                assertEquals(projectPath.resolve("libJs/build/classes/kotlin/main").toFile(), mainJsSourceSet.classesOutputDirectory)
-        assertEquals(project.projectDir.resolve("libJs/build/resources/main"), mainJsSourceSet.resourcesOutputDirectory)
+                assertEquals(projectPath.resolve("libJs/build/resources/main").toFile(), mainJsSourceSet.resourcesOutputDirectory)
 
                 assertEquals(1, testJsSourceSet.sourceDirectories.size)
-        assertTrue(testJsSourceSet.sourceDirectories.contains(project.projectDir.resolve("libJs/src/test/kotlin")))
+                assertTrue(testJsSourceSet.sourceDirectories.contains(projectPath.resolve("libJs/src/test/kotlin").toFile()))
                 assertEquals(1, testJsSourceSet.resourcesDirectories.size)
-        assertTrue(testJsSourceSet.resourcesDirectories.contains(project.projectDir.resolve("libJs/src/test/resources")))
+                assertTrue(testJsSourceSet.resourcesDirectories.contains(projectPath.resolve("libJs/src/test/resources").toFile()))
-        assertEquals(project.projectDir.resolve("libJs/build/classes/kotlin/test"), testJsSourceSet.classesOutputDirectory)
+                assertEquals(projectPath.resolve("libJs/build/classes/kotlin/test").toFile(), testJsSourceSet.classesOutputDirectory)
-        assertEquals(project.projectDir.resolve("libJs/build/resources/test"), testJsSourceSet.resourcesOutputDirectory)
+                assertEquals(projectPath.resolve("libJs/build/resources/test").toFile(), testJsSourceSet.resourcesOutputDirectory)
+            }
+        }
     }
 
-    @Test
+    @DisplayName("Kotlin-android project model is valid")
-    fun testAndroidProject() {
+    @GradleTest
-        val project = Project("AndroidExtensionsProject")
+    fun testAndroidProject(gradleVersion: GradleVersion) {
-        val kotlinProject = project.getModels(KotlinProject::class.java).getModel(":app")!!
+        project(
-
+            "AndroidExtensionsProject",
-        kotlinProject.assertBasics(
+            gradleVersion,
+            buildOptions = defaultBuildOptions.copy(warningMode = WarningMode.Summary)
+        ) {
+            getModels<KotlinProject> {
+                with(getModel(":app")!!) {
+                    assertBasics(
                         "app",
-            defaultBuildOptions().kotlinVersion,
+                        defaultBuildOptions.kotlinVersion,
                         KotlinProject.ProjectType.PLATFORM_JVM,
                         "DEFAULT"
                     )
 
-        assertTrue(kotlinProject.expectedByDependencies.isEmpty())
+                    assertTrue(expectedByDependencies.isEmpty())
-        assertEquals(5, kotlinProject.sourceSets.size)
+                    assertEquals(5, sourceSets.size)
 
-        val sourceSets = kotlinProject.sourceSets.sortedBy { it.name }
+                    val sourceSets = sourceSets.sortedBy { it.name }
-
-        fun SourceSet.verifySourceSet(
-            name: String, type: SourceSet.SourceSetType, friends: List<String>, sources: List<String>, resources: List<String>,
-            classesOutputDir: String, resourcesOutputDir: String
-        ) {
-            assertEquals(name, name)
-            assertEquals(type, this.type)
-
-            assertEquals(friends.size, friendSourceSets.size)
-            assertEquals(friends, friendSourceSets)
-
-            assertEquals(sources.size, sourceDirectories.size)
-            assertEquals(sources.map { project.projectDir.resolve(it) }, sourceDirectories)
-
-            assertEquals(resources.size, resourcesDirectories.size)
-            assertEquals(resources.map { project.projectDir.resolve(it) }, resourcesDirectories)
-
-            assertEquals(project.projectDir.resolve(classesOutputDir), classesOutputDirectory)
-            assertEquals(project.projectDir.resolve(resourcesOutputDir), resourcesOutputDirectory)
-
-            assertNotEquals(0, compilerArguments.currentArguments.size)
-            assertNotEquals(0, compilerArguments.defaultArguments.size)
-        }
 
                     sourceSets[0].verifySourceSet(
+                        this@project,
                         "debug",
                         SourceSet.SourceSetType.PRODUCTION,
                         listOf(),
@@ -184,6 +209,7 @@ class KotlinProjectIT : BaseGradleIT() {
                         "app/build/tmp/kotlin-classes/debug", "app/build/processedResources/debug"
                     )
                     sourceSets[1].verifySourceSet(
+                        this@project,
                         "debugAndroidTest",
                         SourceSet.SourceSetType.TEST,
                         listOf("debug"),
@@ -202,6 +228,7 @@ class KotlinProjectIT : BaseGradleIT() {
                         "app/build/tmp/kotlin-classes/debugAndroidTest", "app/build/processedResources/debugAndroidTest"
                     )
                     sourceSets[2].verifySourceSet(
+                        this@project,
                         "debugUnitTest",
                         SourceSet.SourceSetType.TEST,
                         listOf("debug"),
@@ -220,6 +247,7 @@ class KotlinProjectIT : BaseGradleIT() {
                         "app/build/tmp/kotlin-classes/debugUnitTest", "app/build/processedResources/debugUnitTest"
                     )
                     sourceSets[3].verifySourceSet(
+                        this@project,
                         "release",
                         SourceSet.SourceSetType.PRODUCTION,
                         listOf(),
@@ -236,6 +264,7 @@ class KotlinProjectIT : BaseGradleIT() {
                         "app/build/tmp/kotlin-classes/release", "app/build/processedResources/release"
                     )
                     sourceSets[4].verifySourceSet(
+                        this@project,
                         "releaseUnitTest",
                         SourceSet.SourceSetType.TEST,
                         listOf("release"),
@@ -254,19 +283,54 @@ class KotlinProjectIT : BaseGradleIT() {
                         "app/build/tmp/kotlin-classes/releaseUnitTest", "app/build/processedResources/releaseUnitTest"
                     )
                 }
+            }
+        }
+    }
 
-    @Test
+    private fun SourceSet.verifySourceSet(
-    fun testCoroutinesProjectDSL() {
+        testProject: TestProject,
-        val project = Project("coroutinesProjectDSL")
+        name: String,
-        val kotlinProject = project.getModels(KotlinProject::class.java).getModel(":")!!
+        type: SourceSet.SourceSetType,
+        friends: List<String>,
+        sources: List<String>,
+        resources: List<String>,
+        classesOutputDir: String,
+        resourcesOutputDir: String
+    ) {
+        assertEquals(name, name)
+        assertEquals(type, this.type)
 
-        kotlinProject.assertBasics(
+        assertEquals(friends.size, friendSourceSets.size)
+        assertEquals(friends, friendSourceSets)
+
+        assertEquals(sources.size, sourceDirectories.size)
+        assertEquals(sources.map { testProject.projectPath.resolve(it).toFile() }, sourceDirectories)
+
+        assertEquals(resources.size, resourcesDirectories.size)
+        assertEquals(resources.map { testProject.projectPath.resolve(it).toFile() }, resourcesDirectories)
+
+        assertEquals(testProject.projectPath.resolve(classesOutputDir).toFile(), classesOutputDirectory)
+        assertEquals(testProject.projectPath.resolve(resourcesOutputDir).toFile(), resourcesOutputDirectory)
+
+        assertNotEquals(0, compilerArguments.currentArguments.size)
+        assertNotEquals(0, compilerArguments.defaultArguments.size)
+    }
+
+
+    @DisplayName("Project with coroutines dsl enabled has valid model")
+    @GradleTest
+    fun testCoroutinesProjectDSL(gradleVersion: GradleVersion) {
+        project("coroutinesProjectDSL", gradleVersion) {
+            getModels<KotlinProject> {
+                getModel(":")!!.assertBasics(
                     "coroutinesProjectDSL",
-            defaultBuildOptions().kotlinVersion,
+                    defaultBuildOptions.kotlinVersion,
                     KotlinProject.ProjectType.PLATFORM_JVM,
                     "ENABLE"
                 )
             }
+        }
+    }
 
     companion object {