[Gradle] LazyResolvedConfiguration: Ensure lenient resolution of artifacts

^KT-56153 Verification Pending

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/LazyResolvedConfiguration.kt

@@ -31,7 +31,7 @@ internal class LazyResolvedConfiguration private constructor(
         // via ResolutionResult::root does. ResolutionResult can't be serialised for Configuration Cache
         // but ResolvedComponentResult can. Wrapping it in `lazy` makes it resolve upon serialisation.
         resolvedComponentsRootProvider = configuration.incoming.resolutionResult.let { rr -> lazy { rr.root } },
-        artifactCollection = configuration.incoming.artifacts, // lazy ArtifactCollection
+        artifactCollection = configuration.incoming.artifactView { view -> view.isLenient = true }.artifacts, // lazy ArtifactCollection
         configurationName = configuration.name
     )
 
@@ -39,7 +39,9 @@ internal class LazyResolvedConfiguration private constructor(
 
     val root by resolvedComponentsRootProvider
 
-    private val resolvedArtifacts: Set<ResolvedArtifactResult> get() = artifactCollection.artifacts
+    val resolvedArtifacts: Set<ResolvedArtifactResult> get() = artifactCollection.artifacts
+
+    val resolutionFailures: Collection<Throwable> get() = artifactCollection.failures
 
     private val artifactsByComponentId by TransientLazy { resolvedArtifacts.groupBy { it.id.componentIdentifier } }
 

libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/dependencyResolutionTests/LazyResolvedConfigurationTest.kt

@@ -9,6 +9,7 @@ package org.jetbrains.kotlin.gradle.dependencyResolutionTests
 
 import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.component.ModuleComponentIdentifier
+import org.gradle.internal.component.external.model.DefaultModuleComponentSelector
 import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.kotlinToolingVersion
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal
@@ -118,4 +119,29 @@ class LazyResolvedConfigurationTest {
             }
         }
     }
+
+    @Test
+    fun `test - unresolved dependency`() {
+        val project = buildProject()
+        val configuration = project.configurations.create("forTest")
+        val unresolvedDependency = project.dependencies.create("unresolved:dependency")
+        configuration.dependencies.add(unresolvedDependency)
+
+        val lazyConfiguration = LazyResolvedConfiguration(configuration)
+        if (lazyConfiguration.files.toList().isNotEmpty()) fail("Expected no files to be resolved")
+        if (lazyConfiguration.resolvedArtifacts.toList().isNotEmpty()) fail("Expected no artifacts to be resolved")
+        if (lazyConfiguration.allResolvedDependencies.isNotEmpty()) fail("Expected no resolved dependencies")
+
+        if (lazyConfiguration.resolutionFailures.size != 1) fail("Expected one resolution failure: ${lazyConfiguration.resolutionFailures}")
+        val failure = lazyConfiguration.resolutionFailures.first()
+        if ("unresolved:dependency" !in failure.message.orEmpty()) fail("Expected dependency mentioned in failure: ${failure.message}")
+
+        if (lazyConfiguration.allDependencies.size != 1) fail("Expected one dependency: ${lazyConfiguration.allDependencies}")
+        val resolvedDependencyResult = lazyConfiguration.allDependencies.first()
+        val moduleIdentifier = (resolvedDependencyResult.requested as DefaultModuleComponentSelector).moduleIdentifier
+        assertEquals("unresolved", moduleIdentifier.group)
+        assertEquals("dependency", moduleIdentifier.name)
+
+        if (lazyConfiguration.allResolvedDependencies.isNotEmpty()) fail("Expected no resolved dependencies")
+    }
 }