*Pfadoperation* erstellen, die einen Request an eine *externe API* auslösen könnte, welche von jemand anderem erstellt wurde (wahrscheinlich derselbe Entwickler, der Ihre API *verwenden* würde).

Der Vorgang, der stattfindet, wenn Ihre API-Anwendung die *externe API* aufruft, wird als „Callback“ („Rückruf“) bezeichnet. Denn die Software, die der externe Entwickler geschrieben hat, sendet einen Request an Ihre API und dann *ruft Ihre API zurück* (*calls back*) und sendet einen Request an eine *externe...

Sie möchten nicht, dass die ursprüngliche Abhängigkeit ausgeführt wird (und auch keine der möglicherweise vorhandenen Unterabhängigkeiten).

Stattdessen möchten Sie eine andere Abhängigkeit bereitstellen, die nur während Tests (möglicherweise nur bei einigen bestimmten Tests) verwendet wird und einen Wert bereitstellt, der dort verwendet werden kann, wo der Wert der ursprünglichen Abhängigkeit verwendet wurde.

### Anwendungsfälle: Externer Service

public class ResolutionResultPrinter {
    private static void printNode(DependencyResult dep, StringBuilder sb, Set visited, String indent) {
        if (dep instanceof UnresolvedDependencyResult) {
            sb.append(indent + dep + "\n");
            return
        }
        if (!visited.add(dep.getSelected())) {
            return
        }
        String reason = dep.selected.selectionReason.conflictResolution? "(C)" : "";

            }
        }
    }

    def "can add api dependency"() {
        def dep = Stub(Dependency)

        when:
        dependencies.api("a:b:c")

        then:
        1 * dependencyFactory.create("a:b:c") >> dep
        1 * deps.add(dep)
    }

    def "can add and configure api dependency"() {
        def dep = Stub(ExternalModuleDependency)
        def action = Mock(Action)

        when:

import org.example.*

// tag::failed-inferred-task-dep[]
plugins {
// end::failed-inferred-task-dep[]
    id 'base'
// tag::failed-inferred-task-dep[]
    id 'java-library'
}
// end::failed-inferred-task-dep[]

repositories {
    mavenCentral()
}

dependencies {
    implementation group: 'commons-collections', name: 'commons-collections', version: '3.2.2'
    testImplementation group: 'junit', name: 'junit', version: '4.+'
}

import org.example.*

// tag::failed-inferred-task-dep[]
plugins {
    // end::failed-inferred-task-dep[]
    base
// tag::failed-inferred-task-dep[]
    id("java-library")
}
// end::failed-inferred-task-dep[]

repositories {
    mavenCentral()
}

dependencies {
    implementation(group = "commons-collections", name = "commons-collections", version = "3.2.2")
    testImplementation(group = "junit", name = "junit", version = "4.+")

        given:
        settingsFile << "include 'dep'"
        buildFile << """
            dependencies {
                conf(project(':dep')) {
                    attributes {
                        attribute(Attribute.of('color', String), '$color')
                    }
                }
            }
        """
        file("dep/build.gradle") << blueAndRedVariants()

        when:

}
"""
        and:
        mavenRepo.module("org.test", "dep", "1.0").publish()
        mavenRepo.module("org.test", "dep", "1.5").publish()
        mavenRepo.module("org.test", "dep", "2.0-dev1").publish()
        mavenRepo.module("org.test", "dep", "2.0-final").publish()
        mavenRepo.module("org.test", "dep", "2.0").publish()
        mavenRepo.module("org.test", "dep", "2.1").publish()

        for (UnresolvedDependencyResult dep : deps) {
            log(dep);
        }
    }

    public void log(UnresolvedDependencyResult dep) {
        logger.warn("Could not resolve: " + dep.getAttempted());
        logger.debug("Could not resolve: " + dep.getAttempted(), dep.getFailure());
    }

    public File asFile(UnresolvedDependencyResult dep, File parent) {

        def differentConstraint = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, true)

        then:
        dep.is(same)
        !dep.is(differentFrom)
        !dep.is(differentRequested)
        !dep.is(differentSelected)
        !dep.is(differentConstraint)
    }

    def "creates and caches resolved dependencies with attributes"() {
        def fromModule = newModule('from')