given:
        transport.isLocal() >> isLocal
        ModuleComponentIdentifier moduleComponentIdentifier = DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId("org", "foo"), "1.0")
        ImmutableMetadataSources metadataSources = mockMetadataSourcesForComponentMetadataRulesCachingTest()
        def resolver = resolver(metadataSources)

        when:

        spec.execute(builder);
    }

    @Override
    public void configureExplicitAlias(String alias, String group, String name) {
        builder.configureExplicitAlias(DefaultModuleIdentifier.newId(group, name), alias);
    }

    @Override
    public Provider<DefaultVersionCatalog> getVersionCatalog() {
        return model;
    }

        moduleIdentifier << [id('org.foobar', 'foo-core'),
                             id('org.foo', 'foo-coreImpl')]
    }

    private DefaultModuleIdentifier id(String group, String name) {
        DefaultModuleIdentifier.newId(group, name)
    }

    private AttributeContainerInternal attributes;
    private boolean force;

    public DefaultDependencyConstraint(String group, String name, String version) {
        this.moduleIdentifier = DefaultModuleIdentifier.newId(group, name);
        this.versionConstraint = new DefaultMutableVersionConstraint(version);
    }

    public static DefaultDependencyConstraint strictly(String group, String name, String strictVersion) {

        def rootPublication = publication(rootComponent, id)

        def id1 = DefaultModuleVersionIdentifier.newId("group", "other-1", "1")
        def comp1 = Stub(TestComponent)
        def publication1 = publication(comp1, id1)
        def id2 = DefaultModuleVersionIdentifier.newId("group", "other-2", "2")
        def comp2 = Stub(TestComponent)
        def publication2 = publication(comp2, id2)

        1 * lockingProvider.loadLockState('lockedConf', _) >> lockingState
        1 * lockingState.mustValidateLockState() >> true
        1 * lockingState.lockedDependencies >> [DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId('org', 'foo'), '1.0')]
        1 * delegate.resolveGraph(resolveContext) >> delegateResults
        results == delegateResults
    }

import spock.lang.Specification

class DefaultUnresolvedDependencySpec extends Specification {

    def "provides module details"() {
        when:
        def module = DefaultModuleIdentifier.newId("org.foo", "foo")
        def dep = new DefaultUnresolvedDependency(DefaultModuleVersionSelector.newSelector(module, '1.0'), new RuntimeException("boo!"))

        then:
        dep.selector.group == 'org.foo'

        this.componentIdentifier = componentIdentifier;
        this.id = id;
    }

    public TestComponentResolutionState(ModuleVersionIdentifier id) {
        this.componentIdentifier = DefaultModuleComponentIdentifier.newId(id);
        this.id = id;
    }

    @Override
    public String getVersion() {
        return id.getVersion();
    }

    @Override
    public ComponentIdentifier getComponentId() {

    }

    def "can mark as failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId("a", "b"), "c"), broken)

        when:
        descriptor.failed(failure)

        then:
        descriptor.state == Failed
        descriptor.failure == failure
        descriptor.authoritative

        def (group, name, version) = id.split(":")
        builder.addIgnoredKey(
            new ModuleComponentFileArtifactIdentifier(
                DefaultModuleComponentIdentifier.newId(
                    DefaultModuleIdentifier.newId(group, name),
                    version
                ),
                fileName
            ),
            new IgnoredKey(key, reason)
        )
    }