}

    def resolver = new DefaultProjectDependencyPublicationResolver(registry, projectConfigurer, projects)

    def "resolving component configures project"() {
        when:
        resolver.resolveComponent(ModuleVersionIdentifier, project.identityPath)

        then:
        1 * projectConfigurer.configureFully(project.owner)
    }

    def "resolving variant configures project"() {
        when:

        Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();
        ModuleVersionIdentifier coordinates = projectDependencyResolver.resolveComponent(ModuleVersionIdentifier.class, identityPath);
        ModuleVersionIdentifier resolved = maybeResolveVersion(coordinates.getGroup(), coordinates.getName(), identityPath);

     * project identified by {@code identityPath}.
     *
     * @throws UnsupportedOperationException if the project cannot be resolved.
     */
    <T> T resolveComponent(Class<T> coordsType, Path identityPath);

    /**
     * Determines the coordinates of the given type that should be used to reference the
     * variant with name {@code variantName}, contained in the root component of the

        //       via the resolution result.
        Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();
        ModuleVersionIdentifier identifier = projectDependencyResolver.resolveComponent(ModuleVersionIdentifier.class, identityPath);
        return ResolvedCoordinates.create(identifier);
    }

    @Nullable
    @Override

            Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();
            return ResolvedCoordinates.create(projectDependencyResolver.resolveComponent(ModuleVersionIdentifier.class, identityPath));
        }

        @Nullable
        @Override
        public ResolvedCoordinates resolveComponentCoordinates(DependencyConstraint dependency) {

        projectDependency.getArtifacts() >> []
        projectDependency.getGroup() >> "pub-group"
        projectDependency.getName() >> "pub-name"
        projectDependencyResolver.resolveComponent(ModuleVersionIdentifier, projectDependency.identityPath) >> DefaultModuleVersionIdentifier.newId("pub-group", "pub-name", "pub-version")

        when:
        publication.from(componentWithDependency(projectDependency))

                    Path identityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
                    SwiftPmTarget identifier = publicationResolver.resolveComponent(SwiftPmTarget.class, identityPath);
                    target.getRequiredTargets().add(identifier.getTargetName());
                } else if (dependency instanceof ExternalModuleDependency) {

            getDependencyProject() >> Mock(Project)
            getIdentityPath() >> Stub(Path)
        }
        def exclude = Mock(ExcludeRule)

        and:
        projectDependencyResolver.resolveComponent(ModuleVersionIdentifier, projectDependency.identityPath) >> DefaultModuleVersionIdentifier.newId("pub-org", "pub-module", "pub-revision")
        projectDependency.targetConfiguration >> "dep-configuration"

        this.publicationRegistry = publicationRegistry;
        this.projectConfigurer = projectConfigurer;
        this.projects = projects;
    }

    @Override
    public <T> T resolveComponent(Class<T> coordsType, Path identityPath) {
        return withCoordinateResolver(coordsType, identityPath,
            VariantCoordinateResolver::getComponentCoordinates
        );
    }

    @Nullable