String artifactVersion = "1.45-SNAPSHOT"
    MavenS3Module module

    def setup() {
        module = getMavenS3Repo().module("org.gradle", "test", artifactVersion)
    }

    def "resolves a maven snapshot module stored in S3"() {
        setup:
        module.publish()

        buildFile << mavenAwsRepoDsl()
        buildFile << """
configurations { compile }

        then:
        mavenRepo.module('com.example.foo.new', 'foo-new', '1.2.3').assertPublished()

        def module = mavenRepo.module('com.example.foo', 'com.example.foo' + PLUGIN_MARKER_SUFFIX, '1.0')
        module.assertPublished()
        module.getPomFile().text.contains('foo-new')
        module.getPomFile().text.contains('com.example.foo.new')
        module.getPomFile().text.contains('1.2.3')
    }

        def module = ideaProject.modules.find {it. name == 'root'}

        then:
        module.dependencies.size() == 11
        hasDependency(module, "a", "PROVIDED")
        hasDependency(module, "a", "RUNTIME")
        hasDependency(module, "a", "TEST")
        hasDependency(module, "f", "TEST")
        hasDependency(module, "b", "PROVIDED")
        hasDependency(module, "b", "RUNTIME")

        0 * pluginModuleRegistry.getApiModules()
    }

    def module(String name, Module... requiredModules) {
        Module module = Mock()
        _ * module.classpath >> DefaultClassPath.of(new File("$name-runtime"))
        _ * module.implementationClasspath >> DefaultClassPath.of(new File("$name-runtime"))

                edge("org:foo:1.0","org:foo:1.1").byConflictResolution()
                module("org:bar:1.0") {
                    module("org:foo:1.1")
                }
                // BUG: This module should not be included, but it is
                module("org:baz:1.0") {
                    module("org:baz-transitive:1.0")
                }
            }
        }
         */
    }

    def "a bom dependencyManagement entry can declare excludes which are applied unconditionally to module"() {
        given:
        moduleA.dependsOn(mavenHttpRepo.module("group", "moduleC", "1.0").allowAll().publish()).publish()
        bomDependency('moduleA', [[group: 'group', module: 'moduleC']])
        bomDependency('moduleB', [[group: 'group', module: 'moduleC']]).publish()

        buildFile << """
            dependencies {

        ex.message == "Cannot declare module replacement o:c->o:a because it introduces a cycle: o:c->o:a->o:b->o:c"
    }

    def "provides module metadata information"() {
        def module = replacements.module("com.google.collections:google-collections")

        expect:
        module.id == newId("com.google.collections", "google-collections")
        module.replacedBy == null

        when: module.replacedBy("a:b")

                    artifact(name: 'file4', version: '', legacyName: 'child/file4')
                }
            }
        }
    }

    def "module with module metadata can depend on another module with module metadata"() {
        def c = mavenRepo.module("test", "c", "preview")
            .withModuleMetadata()
        c.artifact(classifier: 'debug')
        c.publish()
        c.moduleMetadata.file.text = """
{

    def "has useful toString()"() {
        def module = new DefaultModuleVersionIdentifier("group", "module", "version")

        expect:
        module.toString().contains("group:module:version")
    }

    def "ids are equal when group, module and version are equal"() {
        def module = new DefaultModuleVersionIdentifier("group", "module", "version")

        and:
        def module = mavenHttpRepo.module('group', 'projectA', '1.2').publish()
        module.pomFile.text = "<project/>"

        when:
        module.pom.expectGet()

        then:
        fails "checkDeps"
        failedResolve.assertFailurePresent(failure)
        failure.assertResolutionFailure(":compile")
            .assertHasCause("Could not parse POM ${module.pom.uri}")