version(v) {
                                allowAll()
                            }
                        }
                    }
                }
            }
            'bom:bom:1.0' {
                allowAll()
            }
            'root:root:1.0' {
                allowAll()
            }
        }

        succeeds ':checkDeps'

        then:

        }
    }

    def "can resolve remote dependencies"() {
        def repo = new MavenHttpRepository(server, mavenRepo)
        repo.module("org.gradle", "a", "1.0").publish().allowAll()
        server.start()

        when:
        project = ProjectBuilder.builder().build()
        project.with {
            repositories {
                maven { url repo.uri }
            }

}

task retrieve(type: Sync) {
    into 'libs'
    from configurations.compile
}
"""
        and:
        def userHome = file('user-home')

        when:
        projectB.allowAll()

        and:
        version previous withGradleUserHomeDir userHome withTasks 'retrieve' withArguments '-i' run()

        then:
        file('libs').assertHasDescendants('projectB-1.0.jar')

"""
repositories {
    ivy {
        url "$ivyHttpRepo.uri"
    }
}
"""
    }

    def setup() {
        repo.module('org.test', 'projectA', '1.0').withStatus("silver").publish().allowAll()
    }

    def "module with custom status can be resolved by adapting status scheme"() {
        buildFile <<
                """
class StatusRule implements ComponentMetadataRule {

        return getArtifact(type: 'module')
    }

    MetaDataArtifact getRootMetaData() {
        return new MetaDataArtifact(server, moduleRootUriPath, backingModule)
    }

    MavenHttpModule allowAll() {
        server.allowGetOrHead(uriPath, backingModule.moduleDir)
        return this
    }

    void missing() {
        server.allowGetOrHeadMissing(pomPath)
        server.allowGetOrHeadMissing(metaDataPath)

        mavenHttpRepo.module("org.external", "external-lib")
            .dependsOn(util)
            .publish()
            .allowAll()
        mavenHttpRepo.module("org.external", "external-lib2")
            .dependsOn(util)
            .withModuleMetadata()
            .publish()
            .allowAll()

        given:
        def pluginBuilder = withSoftwareTypePlugins()
        pluginBuilder.publishAs("com", "example", "1.0", pluginPortal, createExecuter()).allowAll()

        file("settings.gradle.dcl") << """
            plugins {
                id("com.example.test-software-type").version("1.0")
            }
        """

        given:
        def message = "hello from settings plugin"
        pluginBuilder.addSettingsPlugin("println '$message'")
        pluginBuilder.publishAs("org", "settings-plugin", "1.0", pluginRepo, createExecuter()).allowAll()

        and:
        settingsFile.text = """
            pluginManagement {
                repositories {
                    maven { url "$pluginRepo.uri" }
                }
            }

        repositoryInteractions {
            group("org") {
                module("a") {
                    version("1") {
                        expectGetMetadata()
                        allowAll()
                    }
                }
            }
        }
        succeeds 'checkDeps'
        resolve.expectGraph {
            root(":", ":test:") {
                module("org:a:1") {

                spec.delegate = delegate
                spec.resolveStrategy = Closure.DELEGATE_FIRST
                spec()
            }
        }
    }

    void allowAll() {
        withModule {
            delegate.allowAll()
        }
    }

    void build(HttpRepository repository) {
        def module = repository.module(groupId, artifactId, version)