def "resolves available-at variant even if transitive dependencies are excluded"() {
        given:
        mavenHttpRepo.module('org', 'moduleB', '1.0')
            .dependsOn(mavenHttpRepo.module("org", "moduleA", "1.0"), exclusions: [[group: '*', module: '*']])
            .publish() // no Gradle Module metadata for this one because we don't support excludes on dependencies
        repository {
            'org:moduleA:1.0' {

# TODO: Containerize the script to remove dependency issues with go mod and dot.

# To generate graph with all Kubernetes modules run
# ./hack/module-graph.sh
# To generate graph with just staging modules run
# ./hack/module-graph.sh staging

error_exit()
{
	echo "$1" 1>&2
	exit 1
}

staging_dependencies()
{

                runtimeOnly "org:bar"
            }
        """
        checkConfiguration("runtimeClasspath")

        when:
        module1.pom.expectGet()
        module1.artifact.expectGet()
        module2.pom.expectGet()
        module2.artifact.expectGet()

        run ":checkDeps"

        then:
        resolve.expectGraph {
            root(":", "org.test:test:1.9") {

    /**
     * Returns the modules required by this module.
     */
    Set<Module> getRequiredModules();

    /**
     * Returns the transitive closure of all modules required by this module, including the module itself.
     */
    Set<Module> getAllRequiredModules();

    /**
     * Returns the implementation + runtime classpath of the transitive closure of all modules required by this module, including the module itself.

                { "module": "m5", "version": { "prefers": "v5", "rejects": ["v6", "v7"] }, "group": "g5"},
                { "module": "m6", "version": { "rejects": ["v8"] }, "group": "g6"},
                { "module": "m7", "version": { "rejects": ["v7"] }, "group": "g7", "reason": "v7 is buggy"},
                { "module": "m8", "version": { "strictly": "v8" }, "group": "g8"},

        """

        when:
        parent.pom.expectGet()
        moduleA.pom.expectGet()
        moduleA.artifact.expectGet()
        moduleB.pom.expectGet()
        moduleB.artifact.expectGet()

        then:
        // have to run twice to trigger the failure, to parse the descriptor from the cache
        succeeds ":libs"

        given: "3 modules, where there are dependency relations such that module1 depends on module2 and module2 depends on module3"
        mavenRepo.module('org.test', 'module1', '1.0').publish()
        mavenRepo.module('org.test', 'module2', '1.0')
            .dependsOn('org.test', 'module1', '1.0')
            .publish()
        mavenRepo.module('org.test', 'module3', '1.0')

    }
    retrieve.dependsOn(':a:retrieve')
}
"""

        when:
        module1.ivy.expectGet()
        module1.jar.expectGet()

        module2.ivy.expectHead()
        module2.ivy.sha1.expectGet()
        module2.ivy.expectGet()
        module2.jar.expectHead()
        module2.jar.sha1.expectGet()
        module2.jar.expectGet()

        then:
        succeeds 'retrieve'

        and:

        def module2 = registry.getModule("gradle-module-2")
        module1.allRequiredModules as List == [module1, module2]
        module2.allRequiredModules as List == [module2, module1]
    }

    def "supports cycles between optional modules"() {
        given:
        def module1Dir = createModule("module-1", properties(optional: 'gradle-optional-module,gradle-module-2'))

            return false;
        }
        Module module = (Module) o;
        return Objects.equal(dependencies, module.dependencies)
            && Objects.equal(excludeFolders, module.excludeFolders)
            && Objects.equal(outputDir, module.outputDir)
            && Objects.equal(sourceFolders, module.sourceFolders)
            && Objects.equal(generatedSourceFolders, module.generatedSourceFolders)