Migration DukatIntegrationIT tests to new DSL

^KT-45745 In Progress

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

@@ -7,443 +7,447 @@ package org.jetbrains.kotlin.gradle
 
 import com.google.gson.Gson
 import org.gradle.api.logging.configuration.WarningMode
+import org.gradle.util.GradleVersion
 import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat
 import org.jetbrains.kotlin.gradle.targets.js.npm.NpmProject
 import org.jetbrains.kotlin.gradle.targets.js.npm.PackageJson
-import org.jetbrains.kotlin.gradle.util.modify
+import org.jetbrains.kotlin.gradle.testbase.*
-import org.junit.Test
+import org.junit.jupiter.api.DisplayName
-import kotlin.test.assertFalse
+import kotlin.io.path.readText
-import kotlin.test.assertTrue
 
-class DukatIntegrationIT : BaseGradleIT() {
+@DisplayName("Dukat standalone")
-    @Test
+@JsGradlePluginTests
-    fun testSeparateDukatKotlinDslRootDependencies() {
+class DukatIntegrationStandaloneIT : KGPBaseTest() {
+
+    @DisplayName("Kotlin DSL and root dependencies")
+    @GradleTest
+    fun testSeparateDukatKotlinDslRootDependencies(gradleVersion: GradleVersion) {
         testSeparateDukat(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Kotlin DSL and external dependencies")
-    fun testSeparateDukatKotlinDslExtDependencies() {
+    @GradleTest
+    fun testSeparateDukatKotlinDslExtDependencies(gradleVersion: GradleVersion) {
         testSeparateDukat(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.EXTENSION
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL and root dependencies")
-    fun testSeparateDukatGroovyDslRootDependencies() {
+    @GradleTest
+    fun testSeparateDukatGroovyDslRootDependencies(gradleVersion: GradleVersion) {
         testSeparateDukat(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL and external dependencies")
-    fun testSeparateDukatGroovyDslExtDependencies() {
+    @GradleTest
+    fun testSeparateDukatGroovyDslExtDependencies(gradleVersion: GradleVersion) {
         testSeparateDukat(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.EXTENSION
         )
     }
 
     private fun testSeparateDukat(
+        gradleVersion: GradleVersion,
         dslType: DslType,
         dependenciesLocation: DependenciesLocation
     ) {
-        val project = Project(
+        project(
-            projectName = projectName(dslType, dependenciesLocation),
+            projectName = projectName(dslType, dependenciesLocation, PROJECTS_PREFIX),
-            directoryPrefix = "dukat-integration"
+            gradleVersion
-        )
+        ) {
-        project.setupWorkingDir()
+            build("generateExternals")
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-
-        project.build("generateExternals") {
-            assertSuccessful()
         }
     }
+}
 
-    @Test
+@DisplayName("Dukat integrated")
-    fun testIntegratedDukatKotlinDslRootDependencies() {
+@JsGradlePluginTests
+class DukatIntegratedIntegrationIT : KGPBaseTest() {
+
+    @DisplayName("Kotlin DSL and root dependencies")
+    @GradleTest
+    fun testIntegratedDukatKotlinDslRootDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukat(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Kotlin DSL and external dependencies")
-    fun testIntegratedDukatKotlinDslExtDependencies() {
+    @GradleTest
+    fun testIntegratedDukatKotlinDslExtDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukat(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.EXTENSION
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL and root dependencies")
-    fun testIntegratedDukatGroovyDslRootDependencies() {
+    @GradleTest
+    fun testIntegratedDukatGroovyDslRootDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukat(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL and external dependencies")
-    fun testIntegratedDukatGroovyDslExtDependencies() {
+    @GradleTest
+    fun testIntegratedDukatGroovyDslExtDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukat(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.EXTENSION
         )
     }
 
     private fun testIntegratedDukat(
+        gradleVersion: GradleVersion,
         dslType: DslType,
         dependenciesLocation: DependenciesLocation
     ) {
-        val projectName = projectName(dslType, dependenciesLocation)
+        project(
-        val project = Project(
+            projectName = projectName(dslType, dependenciesLocation, PROJECTS_PREFIX),
-            projectName = projectName,
+            gradleVersion
-            directoryPrefix = "dukat-integration"
+        ) {
-        )
+            gradleProperties.modify {
-        project.setupWorkingDir()
+                "${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}"
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
+            }
-        project.gradleProperties().modify {
-            "${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}"
-        }
 
-        val externalSrcs = "build/externals/$projectName/src"
+            build("compileKotlinJs") {
-        project.build("compileKotlinJs") {
+                assertFileInProjectExists("build/externals/${projectName(dslType, dependenciesLocation)}/src/index.module_decamelize.kt")
-            assertSuccessful()
+            }
-
-            assertSingleFileExists(externalSrcs, "index.module_decamelize.kt")
         }
     }
 
-    @Test
+    @DisplayName("Kotlin DSL: change in root dependencies")
-    fun testIntegratedDukatWithChangeKotlinDslRootDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithChangeKotlinDslRootDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithChange(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Kotlin DSL: change in external dependencies")
-    fun testIntegratedDukatWithChangeKotlinDslExtDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithChangeKotlinDslExtDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithChange(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.EXTENSION
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL: change in root dependencies")
-    fun testIntegratedDukatWithChangeGroovyDslRootDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithChangeGroovyDslRootDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithChange(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL: change in external dependencies")
-    fun testIntegratedDukatWithChangeGroovyDslExtDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithChangeGroovyDslExtDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithChange(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.EXTENSION
         )
     }
 
     private fun testIntegratedDukatWithChange(
+        gradleVersion: GradleVersion,
         dslType: DslType,
         dependenciesLocation: DependenciesLocation
     ) {
-        val projectName = projectName(dslType, dependenciesLocation)
+        project(
-        val project = Project(
+            projectName = projectName(dslType, dependenciesLocation, PROJECTS_PREFIX),
-            projectName = projectName,
+            gradleVersion
-            directoryPrefix = "dukat-integration"
+        ) {
-        )
+            gradleProperties.modify {
-        project.setupWorkingDir()
+                "${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}"
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
+            }
-        project.gradleProperties().modify {
-            "${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}"
-        }
 
-        val externalSrcs = "build/externals/$projectName/src"
+            val externalSrcs = "build/externals/${projectName(dslType, dependenciesLocation)}/src"
-        project.build("compileKotlinJs") {
+            build("compileKotlinJs") {
-            assertSuccessful()
+                assertFileInProjectExists("$externalSrcs/index.module_decamelize.kt")
+            }
 
-            assertSingleFileExists(externalSrcs, "index.module_decamelize.kt")
+            buildFileForDslType(dslType).modify { buildScript ->
-        }
+                buildScript
+                    .replace(
+                        """implementation(npm("left-pad", "1.3.0"))""",
+                        """implementation(npm("left-pad", "1.3.0", true))"""
+                    )
+                    .replace(
+                        """implementation(npm("decamelize", "4.0.0", true))""",
+                        """implementation(npm("decamelize", "4.0.0"))"""
+                    )
+            }
 
-        project.gradleBuildScript().modify { buildScript ->
+            build("generateExternalsIntegrated") {
-            buildScript
+                assertFileInProjectExists("$externalSrcs/index.module_left-pad.kt")
-                .replace(
+            }
-                    """implementation(npm("left-pad", "1.3.0"))""",
-                    """implementation(npm("left-pad", "1.3.0", true))"""
-                )
-                .replace(
-                    """implementation(npm("decamelize", "4.0.0", true))""",
-                    """implementation(npm("decamelize", "4.0.0"))"""
-                )
-        }
-
-        project.build("generateExternalsIntegrated") {
-            assertSuccessful()
-
-            assertSingleFileExists(externalSrcs, "index.module_left-pad.kt")
         }
     }
 
-    @Test
+    @DisplayName("Kotlin DSL: with false default root dependencies")
-    fun testIntegratedDukatWithFalseDefaultKotlinDslRootDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithFalseDefaultKotlinDslRootDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithFalseDefault(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Kotlin DSL: with false external dependencies")
-    fun testIntegratedDukatWithFalseDefaultKotlinDslExtDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithFalseDefaultKotlinDslExtDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithFalseDefault(
+            gradleVersion,
             DslType.KOTLIN,
             DependenciesLocation.EXTENSION
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL: with false root dependencies")
-    fun testIntegratedDukatWithFalseDefaultGroovyDslRootDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithFalseDefaultGroovyDslRootDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithFalseDefault(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.ROOT
         )
     }
 
-    @Test
+    @DisplayName("Groovy DSL: with false external dependencies")
-    fun testIntegratedDukatWithFalseDefaultGroovyDslExtDependencies() {
+    @GradleTest
+    fun testIntegratedDukatWithFalseDefaultGroovyDslExtDependencies(gradleVersion: GradleVersion) {
         testIntegratedDukatWithFalseDefault(
+            gradleVersion,
             DslType.GROOVY,
             DependenciesLocation.EXTENSION
         )
     }
 
     private fun testIntegratedDukatWithFalseDefault(
+        gradleVersion: GradleVersion,
         dslType: DslType,
         dependenciesLocation: DependenciesLocation
     ) {
-        val projectName = projectName(dslType, dependenciesLocation)
+        project(
-        val project = Project(
+            projectName = projectName(dslType, dependenciesLocation, PROJECTS_PREFIX),
-            projectName = projectName,
+            gradleVersion
-            directoryPrefix = "dukat-integration"
+        ) {
-        )
+            gradleProperties.modify {
-        project.setupWorkingDir()
+                """
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-        project.gradleProperties().modify {
-            """
                 kotlin.js.generate.externals=true
                 ${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}
             """.trimIndent()
+            }
+
+            buildFileForDslType(dslType).modify { buildScript ->
+                buildScript
+                    .replace(
+                        """implementation(npm("decamelize", "4.0.0", true))""",
+                        """implementation(npm("decamelize", "4.0.0", false))"""
+                    )
+            }
+
+            val externalSrcs = "build/externals/${projectName(dslType, dependenciesLocation)}/src"
+            build("generateExternalsIntegrated") {
+                assertFileInProjectExists("$externalSrcs/index.module_left-pad.kt")
+            }
         }
+    }
+}
 
-        project.gradleBuildScript().modify { buildScript ->
+@DisplayName("Dukat in js BOTH mode")
-            buildScript
+@JsGradlePluginTests
-                .replace(
+class DukatIntegrationBothModeIT : KGPBaseTest() {
-                    """implementation(npm("decamelize", "4.0.0", true))""",
-                    """implementation(npm("decamelize", "4.0.0", false))"""
-                )
-        }
 
-        val externalSrcs = "build/externals/$projectName/src"
+    @DisplayName("Dependencies are generated only once")
-        project.build("generateExternalsIntegrated") {
+    @GradleTest
-            assertSuccessful()
+    fun testBothOnlyOnceGenerateDependencies(gradleVersion: GradleVersion) {
+        project("dukat-integration/both", gradleVersion) {
+            gradleProperties.modify {
+                "${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}"
+            }
 
-            assertSingleFileExists(externalSrcs, "index.module_left-pad.kt")
+            val externalSrcs = "build/externals/both-js-ir/src"
+            build("compileKotlinJsLegacy") {
+                assertTasksExecuted(":irGenerateExternalsIntegrated")
+                assertFileInProjectExists("$externalSrcs/index.module_decamelize.kt")
+
+                val legacyExternals = projectPath.resolve("build/externals/both-js-legacy/src")
+                assertFileNotExists(legacyExternals)
+            }
+
+            build(
+                "compileKotlinJsLegacy",
+                "--rerun-tasks"
+            ) {
+                assertTasksExecuted(":irGenerateExternalsIntegrated")
+                assertFileInProjectExists("$externalSrcs/index.module_decamelize.kt")
+            }
         }
     }
 
-    @Test
+    @DisplayName("Groovy DSL: compilation")
-    fun testBothOnlyOnceGenerateDependencies() {
+    @GradleTest
-        val project = Project(
+    fun testCompilationLegacyBinariesGroovyDsl(gradleVersion: GradleVersion) {
-            projectName = "both",
-            directoryPrefix = "dukat-integration"
-        )
-        project.setupWorkingDir()
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-        project.gradleProperties().modify {
-            "${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}"
-        }
-
-        val externalSrcs = "build/externals/both-js-ir/src"
-        project.build("compileKotlinJsLegacy") {
-            assertSuccessful()
-            assertTasksExecuted(":irGenerateExternalsIntegrated")
-
-            assertSingleFileExists(externalSrcs, "index.module_decamelize.kt")
-            val legacyExternals = "build/externals/both-js-legacy/src"
-            val directoryFile = fileInWorkingDir(legacyExternals)
-            assertTrue(
-                !directoryFile.exists(),
-                "[$legacyExternals] should not contain files"
-            )
-        }
-
-        project.build(
-            "compileKotlinJsLegacy",
-            "--rerun-tasks"
-        ) {
-            assertSuccessful()
-            assertTasksExecuted(":irGenerateExternalsIntegrated")
-
-            assertSingleFileExists(externalSrcs, "index.module_decamelize.kt")
-        }
-    }
-
-    @Test
-    fun testCompilationLegacyBinariesGroovyDsl() {
         testCompilationLegacyBinaries(
+            gradleVersion,
             DslType.GROOVY
         )
     }
 
-    @Test
+    @DisplayName("Kotlin DSL: compilation")
-    fun testCompilationLegacyBinariesKotlinDsl() {
+    @GradleTest
+    fun testCompilationLegacyBinariesKotlinDsl(gradleVersion: GradleVersion) {
         testCompilationLegacyBinaries(
+            gradleVersion,
             DslType.KOTLIN
         )
     }
 
     private fun testCompilationLegacyBinaries(
+        gradleVersion: GradleVersion,
         dslType: DslType
     ) {
-        val projectName = projectName(dslType, DependenciesLocation.EXTENSION)
+        project(
-        val project = Project(
+            projectName(dslType, DependenciesLocation.EXTENSION, PROJECTS_PREFIX),
-            projectName = projectName,
+            gradleVersion
-            directoryPrefix = "dukat-integration"
+        ) {
-        )
+            build("compileKotlinJs")
-        project.setupWorkingDir()
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-
-        project.build("compileKotlinJs") {
-            assertSuccessful()
         }
     }
 
-    @Test
+    @DisplayName("Assemble both binaries")
-    fun testAssembleBothBinaries() {
+    @GradleTest
-        val projectName = "both"
+    fun testAssembleBothBinaries(gradleVersion: GradleVersion) {
-        val project = Project(
+        project("${PROJECTS_PREFIX}/both", gradleVersion) {
-            projectName = projectName,
+            // Warning mode 'Summary' because
-            directoryPrefix = "dukat-integration"
+            // > Execution optimizations have been disabled for task ':kotlinSourcesJar' to ensure correctness due to the following reasons
-        )
+            build(
-        project.setupWorkingDir()
+                "assemble",
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
+                buildOptions = defaultBuildOptions.copy(warningMode = WarningMode.Summary)
-
+            )
-        project.build("assemble", options = defaultBuildOptions().copy(warningMode = WarningMode.Summary)) {
-            assertSuccessful()
         }
     }
 
-    @Test
+    @DisplayName("Compile both binaries in legacy mode")
-    fun testCompileLegacyBothBinaries() {
+    @GradleTest
-        val projectName = "both"
+    fun testCompileLegacyBothBinaries(gradleVersion: GradleVersion) {
-        val project = Project(
+        project("$PROJECTS_PREFIX/both", gradleVersion) {
-            projectName = projectName,
+            gradleProperties.modify {
-            directoryPrefix = "dukat-integration"
+                """
-        )
-        project.setupWorkingDir()
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-        project.gradleProperties().modify {
-            """
                 ${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.BINARY}
             """.trimIndent()
-        }
+            }
 
-        val externalSrcs = "build/externals/both-js-legacy/src"
+            val externalSrcs = "build/externals/both-js-legacy/src"
-        project.build("compileKotlinJsLegacy") {
+            build("compileKotlinJsLegacy") {
-            assertSuccessful()
+                assertFileInProjectExists("$externalSrcs/index.d.jar")
 
-            assertSingleFileExists(externalSrcs, "index.d.jar")
+                val irExternals = "build/externals/both-js-ir/src"
-
+                assertFileInProjectNotExists(irExternals)
-            val irExternals = "build/externals/both-js-ir/src"
-            val directoryFile = fileInWorkingDir(irExternals)
-            assertTrue(
-                !directoryFile.exists(),
-                "[$irExternals] should not contain files"
-            )
-        }
-    }
-
-    @Test
-    fun testAssembleBothSource() {
-        val projectName = "both"
-        val project = Project(
-            projectName = projectName,
-            directoryPrefix = "dukat-integration"
-        )
-        project.setupWorkingDir()
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-        project.gradleProperties().modify {
-            """
-                ${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}
-            """.trimIndent()
-        }
-
-        val externalSrcs = "build/externals/both-js-ir/src"
-        project.build("assemble", options = defaultBuildOptions().copy(warningMode = WarningMode.Summary)) {
-            assertSuccessful()
-
-            assertTasksExecuted(":irGenerateExternalsIntegrated")
-
-            assertSingleFileExists(externalSrcs, "index.module_decamelize.kt")
-            val legacyExternals = "build/externals/both-js-legacy/src"
-            val directoryFile = fileInWorkingDir(legacyExternals)
-            assertTrue(
-                !directoryFile.exists(),
-                "[$legacyExternals] should not contain files"
-            )
-        }
-    }
-
-    @Test
-    fun testWithoutGenerateExternals() {
-        val projectName = "without-generate-externals"
-        val project = Project(
-            projectName = projectName,
-            directoryPrefix = "dukat-integration"
-        )
-        project.setupWorkingDir()
-
-        project.gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
-
-        project.build("assemble", options = defaultBuildOptions().copy(warningMode = WarningMode.Summary)) {
-            assertSuccessful()
-
-            assertTasksNotExecuted(":generateExternalsIntegrated")
-
-            assertFalse("Dukat don't need to be dependency for thus project") {
-                fileInWorkingDir("build/js/packages/without-generate-externals")
-                    .resolve(NpmProject.PACKAGE_JSON)
-                    .let {
-                        Gson().fromJson(it.readText(), PackageJson::class.java)
-                    }.dependencies.containsKey("dukat")
             }
         }
     }
 
-    private fun projectName(
+    @DisplayName("Assemble both sources")
-        dslType: DslType,
+    @GradleTest
-        dependenciesLocation: DependenciesLocation
+    fun testAssembleBothSource(gradleVersion: GradleVersion) {
-    ): String =
+        project("$PROJECTS_PREFIX/both", gradleVersion) {
-        "${dslType.value}-${dependenciesLocation.value}"
+            gradleProperties.modify {
+                """
+                ${ExternalsOutputFormat.externalsOutputFormatProperty}=${ExternalsOutputFormat.SOURCE}
+            """.trimIndent()
+            }
 
-    private enum class DslType(
+            val externalSrcs = "build/externals/both-js-ir/src"
-        val value: String
+            build("assemble", buildOptions = defaultBuildOptions.copy(warningMode = WarningMode.Summary)) {
-    ) {
+                assertTasksExecuted(":irGenerateExternalsIntegrated")
-        KOTLIN("kotlin-dsl"),
+
-        GROOVY("groovy-dsl")
+                assertFileInProjectExists("$externalSrcs/index.module_decamelize.kt")
+                val legacyExternals = "build/externals/both-js-legacy/src"
+                assertFileInProjectNotExists(legacyExternals)
+            }
+        }
     }
 
-    private enum class DependenciesLocation(
+    @DisplayName("Without generating externals")
-        val value: String
+    @GradleTest
-    ) {
+    fun testWithoutGenerateExternals(gradleVersion: GradleVersion) {
-        ROOT("root"),
+        project("$PROJECTS_PREFIX/without-generate-externals", gradleVersion) {
-        EXTENSION("ext")
+            build("assemble", buildOptions = defaultBuildOptions.copy(warningMode = WarningMode.Summary)) {
+                assertTasksSkipped(":generateExternalsIntegrated")
+
+                assert(
+                    !projectPath
+                        .resolve("build/js/packages/without-generate-externals")
+                        .resolve(NpmProject.PACKAGE_JSON)
+                        .let {
+                            Gson().fromJson(it.readText(), PackageJson::class.java)
+                        }
+                        .dependencies
+                        .containsKey("dukat")
+                ) {
+                    "Dukat don't need to be dependency for thus project"
+                }
+            }
+        }
     }
 }
+
+private fun projectName(
+    dslType: DslType,
+    dependenciesLocation: DependenciesLocation,
+    directoryPrefix: String = ""
+): String =
+    "$directoryPrefix/${dslType.value}-${dependenciesLocation.value}"
+
+private enum class DslType(
+    val value: String
+) {
+    KOTLIN("kotlin-dsl"),
+    GROOVY("groovy-dsl")
+}
+
+private enum class DependenciesLocation(
+    val value: String
+) {
+    ROOT("root"),
+    EXTENSION("ext")
+}
+
+private fun TestProject.buildFileForDslType(dslType: DslType) =
+    when (dslType) {
+        DslType.KOTLIN -> buildGradleKts
+        DslType.GROOVY -> buildGradle
+    }
+
+private const val PROJECTS_PREFIX = "dukat-integration"

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/dukat-integration/both/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("js") version "<pluginMarkerVersion>"
+    kotlin("js")
 }
 
 repositories {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/dukat-integration/groovy-dsl-ext/build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id("org.jetbrains.kotlin.js") version "<pluginMarkerVersion>"
+    id("org.jetbrains.kotlin.js")
 }
 
 repositories {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/dukat-integration/groovy-dsl-root/build.gradle

@@ -1,5 +1,5 @@
 plugins {
-    id("org.jetbrains.kotlin.js") version "<pluginMarkerVersion>"
+    id("org.jetbrains.kotlin.js")
 }
 
 repositories {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/dukat-integration/kotlin-dsl-ext/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("js") version "<pluginMarkerVersion>"
+    kotlin("js")
 }
 
 repositories {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/dukat-integration/kotlin-dsl-root/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("js") version "<pluginMarkerVersion>"
+    kotlin("js")
 }
 
 repositories {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/dukat-integration/without-generate-externals/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    kotlin("js") version "<pluginMarkerVersion>"
+    kotlin("js")
 }
 
 repositories {