substitutions.ruleAction.execute(moduleDetails)

        then:
        _ * moduleDetails.target >> moduleTarget
        _ * moduleDetails.requested >> moduleTarget
        1 * componentSelectorConverter.getSelector(moduleTarget) >> moduleOldRequested
        1 * action.execute({ DefaultDependencyResolveDetails details ->
            details.requested == moduleOldRequested
        })

 */
public interface DependencyMetadata {
    /**
     * Returns the component selector for this dependency.
     *
     * @return Component selector
     */
    ComponentSelector getSelector();

    /**
     * Select the matching variants for this dependency from the given target component.
     *
     * @implSpec An instance of {@link ResolutionFailureHandler} is supplied to this method, and

        }

        private void listModuleVersionsFromCache(ModuleDependencyMetadata dependency, BuildableModuleVersionListingResolveResult result) {
            ModuleComponentSelector requested = dependency.getSelector();
            final ModuleIdentifier moduleId = requested.getModuleIdentifier();
            ModuleVersionsCache.CachedModuleVersionList cachedModuleVersionList = moduleVersionsCache.getCachedModuleResolution(delegate, moduleId);

        ModuleComponentSelector requested = dependency.getSelector();
        LOGGER.debug("Attempting to resolve version for {} using repositories {}", requested, repositoryNames);
        List<Throwable> errors = new ArrayList<>();

        def componentState = Mock(LocalComponentGraphResolveState)
        def result = Mock(BuildableComponentIdResolveResult)
        def dependencyMetaData = Stub(DependencyMetadata) {
            getSelector() >> selector
        }
        def id = newProjectId(":project")

        when:
        resolver.resolve(dependencyMetaData, null, null, result)

        then:

    }

    @Override
    public ResolvedVersionConstraint getVersionConstraint() {
        return resolvedVersionConstraint;
    }

    @Override
    public ComponentSelector getSelector() {
        return new TestComponentSelector();
    }

    @Override
    public String toString() {
        return versionConstraint.toString();
    }

    @Override

            ComponentSelector key = entry.getKey();
            ModuleVersionSelector moduleVersionSelector = componentSelectorConverter.getSelector(key);
            builder.add(new DefaultUnresolvedDependency(moduleVersionSelector, entry.getValue().failure.withIncomingPaths(paths)));
        }
        return builder.build();
    }

    }

    @Override
    public String toString() {
        return "dependency: " + getSelector() + ", confs: " + confs;
    }

    @Override
    public ModuleComponentSelector getSelector() {
        return selector;
    }

    @Override
    public boolean isOptional() {
        return optional;
    }

    @Override

    }

    private static boolean hasStrongOpinion(NodeState node) {
        for (EdgeState edgeState : node.getIncomingEdges()) {
            if (edgeState.getSelector().hasStrongOpinion()) {
                return true;
            }
        }
        return false;
    }

        this.componentId = componentId;
        this.platformId = platformId;
        this.force = force;
        this.transitive = transitive;
    }

    @Override
    public ModuleComponentSelector getSelector() {
        return cs;
    }

    @Override
    public ModuleDependencyMetadata withRequestedVersion(VersionConstraint requestedVersion) {
        return this;
    }

    @Override