pom.expectGet()
            artifact.expectGet()
            allowAll()
        }
        module(group, artifactId, version).with {
            pom.expectGet()
            artifact.expectGet()
            allowAll()
        }
    }

    @Override

	// Credentials stores all credentials in the cluster
	Credentials credentials.Controller

	// Domain for the cluster. Typically, cluster.local
	Domain  string
	Context GatewayContext
}

type Grants struct {
	AllowAll     bool
	AllowedNames sets.String
}

type AllowedReferences map[Reference]map[Reference]*Grants

func (refs AllowedReferences) SecretAllowed(resourceName string, namespace string) bool {

        fileInReadReadOnlyCache("modules-${CacheLayout.MODULES.version}/files-${CacheLayout.FILE_STORE.version}/org.readonly/parent/1.0").eachFileRecurse { it.delete() }
        withReadOnlyCache()
        other.allowAll()
        parent.allowAll()
        succeeds ':checkDeps'

        then:
        noExceptionThrown()
    }


    @Override
    List<MavenHttpModule> getModulesInReadOnlyCache(MavenHttpRepository repo) {

        def invalidLocation = executer.gradleUserHomeDir.file(cachePath + invalidPath).canonicalFile

        testDep.allowAll()
        abusedCoordinates.allowAll()
        server.allowGetOrHead('/repo/org/.ssh/pwned.txt', fakeDep)

        and:
        withValidJavaSource()
        buildWithJavaLibraryAndMavenRepo()

        and:

        fileInReadReadOnlyCache("modules-${CacheLayout.MODULES.version}/metadata-${CacheLayout.META_DATA.version}/${file}.bin").bytes = [0, 0, 0]
        withReadOnlyCache()

        core.allowAll()
        core.rootMetaData.allowGetOrHead()
        util.allowAll()

        if (resolveDynamic) {
            mavenHttpRepo.module('org.readonly', 'core', '0.9').publish()
            executer.withArgument("--refresh-dependencies")
        }

 * limitations under the License.
 */
package org.gradle.test.fixtures

import org.gradle.test.fixtures.server.http.HttpArtifact

interface HttpModule extends Module {
    HttpModule allowAll()
    HttpArtifact getArtifact(Map<String, ?> notation)

        repo = new MavenHttpRepository(server, mavenRepo)

        repo.module("commons-io", "commons-io", "1.4").publish().allowAll()
        repo.module("commons-lang", "commons-lang", "2.6").publish().allowAll()

        server.start()
    }

    private void updateCaches() {
        String version = GradleVersion.current().version

            this.pluginModule = results.pluginModule as HttpModule
            this.markerModules = results.markerModules as List<HttpModule>
        }

        PluginHttpPublicationResults allowAll() {
            ([pluginModule] + markerModules)*.allowAll()
            return this
        }
    }

        }
    }

    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 }
            }

        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)