void expectUploadBroken() {
        throw new UnsupportedOperationException()
    }

    void expectGet() {
        server.stubListFile(directory, bucket, path)
    }

    void expectGetMissing() {
        server.expectGetMissing("/$bucket")
    }

    void expectGetBroken() {
        server.expectGetBroken("/$bucket")
    }

        throw new UnsupportedOperationException()
    }

    public void expectGet() {
        server.stubListFile(directory, bucket, path)
    }

    public void expectGetMissing() {
        server.expectGetMissing("/$bucket")
    }

    public void expectGetBroken() {
        server.expectGetBroken("/$bucket")
    }

    }

    abstract protected String getPath();

    abstract void expectGet()

    abstract void expectGetBroken()

    abstract void expectGetUnauthorized()

    abstract void expectGetMissing()

    abstract void expectGetRevalidate()

    abstract void expectHead()

    abstract void expectHeadBroken()

    abstract void expectHeadMissing()

    abstract void expectHeadRevalidate()

        }
        """

        when:
        module.pom.expectGet()
        sourceArtifact.expectGet()
        module.metaData.expectGetMissing()

        then:
        run 'retrieve'

        when:
        server.resetExpectations()
        module.metaData.expectGetMissing()
        sourceArtifact.expectHeadRevalidate()
        module.pom.expectHeadRevalidate()
        then:
        run 'retrieve'

        server.expectGetDirectoryListing(path, directory)
    }

    public void allowGet() {
        server.allowGetDirectoryListing(path, directory)
    }

    @Override
    public void expectGetMissing() {
        server.expectGetMissing(path)
    }

    @Override
    public void expectGetBroken() {
        server.expectGetBroken(path)
    }

    @Override
    void expectGetUnauthorized() {

        server.expectGetUnauthorized(getPath())
    }

    void expectGetBlocking() {
        server.expectGetBlocking(getPath())
    }

    void expectGetMissing(PasswordCredentials credentials = null) {
        server.expectGetMissing(getPath(), credentials)
    }

    @Override
    void expectGetRevalidate() {
        server.expectGetRevalidate(getPath(), file)
    }

    void expectHead() {

            .createVerifyTaskModuleComponentIdentifier()

        // TODO - should make a single request
        module.pom.expectGetMissing()
        module.pom.expectGetMissing()
        module.artifact.expectHead()

        then:
        checkArtifactsResolvedAndCached()
    }

    @ToBeFixedForConfigurationCache

dependencies {
    missing 'org.name:projectA:1.2'
}
task showMissing {
    def files = configurations.missing
    doLast {
        println files.files
    }
}
"""

        when:
        module.pom.expectGetMissing()

        then:
        fails("showMissing")

        when:
        server.resetExpectations()
        module.pom.expectGet()
        module.artifact.expectGet()

        then:

                conf "org:foo:1.0"
                conf "other:bar:2.0"
            }
        """

        when:
        foo.ivy.expectGet()
        foo.artifact.expectGet()
        barIvy.ivy.expectGetMissing()
        bar.pom.expectGet()
        bar.artifact.expectGet()

        run 'checkDeps'

        then:
        resolve.expectGraph {
            root(':', ':test:') {

                }
            }
"""

        when:
        def m1 = mavenHttpRepo.module("test", "test1", "1.2")
        m1.pom.expectGetMissing()
        def m2 = mavenHttpRepo.module("test", "test2", "1.2")
        m2.pom.expectGetUnauthorized()
        def m3 = mavenHttpRepo.module("test", "test3", "1.2").publish()
        m3.pom.expectGet()