From 629f7a66d6aced2a8663c33effb7a9b02243a855 Mon Sep 17 00:00:00 2001 From: "sebastian.sellmair" Date: Wed, 19 Jan 2022 16:26:11 +0100 Subject: [PATCH] [KPM] Implement KotlinFragmentConfigurationDefinitionTest --- ...tlinFragmentConfigurationDefinitionTest.kt | 209 ++++++++++++++++++ 1 file changed, 209 insertions(+) create mode 100644 libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/kpm/KotlinFragmentConfigurationDefinitionTest.kt diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/kpm/KotlinFragmentConfigurationDefinitionTest.kt b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/kpm/KotlinFragmentConfigurationDefinitionTest.kt new file mode 100644 index 00000000000..5bc1531af4b --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/kpm/KotlinFragmentConfigurationDefinitionTest.kt @@ -0,0 +1,209 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +@file:Suppress("FunctionName") + +package org.jetbrains.kotlin.gradle.kpm + +import org.gradle.api.attributes.Attribute +import org.gradle.api.capabilities.Capability +import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.* +import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.FragmentNameDisambiguation +import org.junit.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull +import kotlin.test.assertSame +import kotlin.test.fail + +class KotlinFragmentConfigurationDefinitionTest : AbstractKpmExtensionTest() { + + private val testContext by lazy { + val names = FragmentNameDisambiguation(kotlin.main, "test") + KotlinGradleFragmentConfigurationContextImpl( + kotlin.main, DefaultKotlinFragmentDependencyConfigurationsFactory.create(kotlin.main, names), names + ) + } + + private val testFragment by lazy { + KotlinCommonFragmentFactory(kotlin.main).create("testFragment") + } + + @Test + fun `test withProvider`() { + val testDefinition = ConfigurationDefinition( + provider = { project.configurations.create("a") } + ).withConfigurationProvider { project.configurations.create("b") } + + assertEquals( + "b", testDefinition.provider.getConfiguration(testContext).name, + "Expected configuration 'b' to be provided" + ) + + assertNull( + project.configurations.findByName("a"), + "Expected configuration 'a' never being created" + ) + + assertEquals( + "c", testDefinition.withConfigurationProvider { project.configurations.create("c") } + .provider.getConfiguration(testContext).name, + "Expected configuration 'c' to be provided" + ) + } + + @Test + fun `test attributes + attributes`() { + val testAttribute1 = Attribute.of("testAttribute1", String::class.java) + val testAttribute2 = Attribute.of("testAttribute2", String::class.java) + val testConfiguration = project.configurations.create("dummy") + + val fragmentAttributes1 = FragmentAttributes { + assertSame(testConfiguration.attributes, this) + assertNull(attributes.getAttribute(testAttribute1)) + assertNull(attributes.getAttribute(testAttribute2)) + attribute(testAttribute1, "value1") + } + + val fragmentAttributes2 = FragmentAttributes { + assertSame(testConfiguration.attributes, this) + assertEquals(attributes.getAttribute(testAttribute1), "value1") + assertNull(attributes.getAttribute(testAttribute2)) + attribute(testAttribute2, "value2") + } + + val composite = fragmentAttributes1 + fragmentAttributes2 + if (composite !is CompositeFragmentAttributes) + fail("Expected ${CompositeFragmentAttributes::class} but found $composite") + + assertEquals( + listOf(fragmentAttributes1, fragmentAttributes2), composite.children + ) + + testConfiguration.attributes.attributes(composite, testFragment) + + assertEquals( + "value1", testConfiguration.attributes.getAttribute(testAttribute1), + "Expected 'testAttribute1' to be set" + ) + + assertEquals( + "value2", testConfiguration.attributes.getAttribute(testAttribute2), + "Expected 'testAttribute2' to be set" + ) + } + + @Test + fun `test definition + attributes`() { + val definition = ConfigurationDefinition( + provider = { project.configurations.create("a") } + ) + + val attributes1 = FragmentAttributes { } + val attributes2 = FragmentAttributes { } + + val newDefinition = definition + attributes1 + attributes2 + assertEquals( + listOf(attributes1, attributes2), (newDefinition.attributes as? CompositeFragmentAttributes)?.children, + "Expected 'newDefinition' to list the two added attributes" + ) + } + + @Test + fun `test artifacts + artifacts`() { + val artifacts1 = FragmentArtifacts { + artifact(project.file("artifact1.jar")) + } + + val artifacts2 = FragmentArtifacts { + artifact(project.file("artifact2-a.jar")) + artifact(project.file("artifact2-b.jar")) + } + + val composite = artifacts1 + artifacts2 + if (composite !is CompositeFragmentArtifacts) { + fail("Expected ${CompositeFragmentArtifacts::class.java}, but found $composite") + } + + assertEquals( + listOf(artifacts1, artifacts2), composite.children + ) + + project.configurations.create("dummy").apply { + outgoing.artifacts(composite, testFragment) + assertEquals( + project.files("artifact1.jar", "artifact2-a.jar", "artifact2-b.jar").toSet(), + outgoing.artifacts.files.toSet() + ) + } + } + + @Test + fun `test definition + artifacts`() { + val definition = ConfigurationDefinition( + provider = { throw NotImplementedError() } + ) + + val artifacts1 = FragmentArtifacts {} + val artifacts2 = FragmentArtifacts {} + + val newDefinition = definition + artifacts1 + artifacts2 + assertEquals( + listOf(artifacts1, artifacts2), (newDefinition.artifacts as? CompositeFragmentArtifacts)?.children, + "Expected 'newDefinition' to list new added artifacts" + ) + } + + @Test + fun `test capability + capability`() { + val capabilities1 = FragmentCapabilities { + capability("capability1") + } + + val capabilities2 = FragmentCapabilities { + capability("capability2") + } + + val composite = capabilities1 + capabilities2 + if (composite !is CompositeFragmentCapabilities) { + fail("Expected ${CompositeFragmentCapabilities::class}, but found $composite") + } + + assertEquals( + listOf(capabilities1, capabilities2), composite.children + ) + + val dummyContext = object : KotlinGradleFragmentConfigurationCapabilities.Context { + val setCapabilities = mutableListOf() + override fun capability(notation: Any) { + setCapabilities.add(notation) + } + + override val capabilities: List get() = throw NotImplementedError() + + } + + dummyContext.capabilities(composite, testFragment) + assertEquals( + listOf("capability1", "capability2"), dummyContext.setCapabilities, + "Expected 'dummyContext' to receive all capabilities" + ) + } + + @Test + fun `test definition + capability`() { + val definition = ConfigurationDefinition( + provider = { throw NotImplementedError() } + ) + + val capabilities1 = FragmentCapabilities {} + val capabilities2 = FragmentCapabilities {} + val newDefinition = definition + capabilities1 + capabilities2 + + assertEquals( + listOf(capabilities1, capabilities2), (newDefinition.capabilities as? CompositeFragmentCapabilities)?.children, + "Expected 'newDefinition' to list all added capabilities" + ) + } +}