def "can create service with default directory"() {
        def cacheDir = temporaryFolder.file("build-cache-1")

        when:
        def service = factory.createBuildCacheService(config, buildCacheDescriber)
        then:
        service instanceof DirectoryBuildCacheService
        1 * config.getDirectory() >> null
        1 * config.getRemoveUnusedEntriesAfterDays() >> 10

                    ? createBuildCacheService(local, BuildCacheServiceRole.LOCAL, buildIdentityPath, buildCacheConfiguration, instanceGenerator)
                    : null;

                DescribedBuildCacheService<BuildCache, BuildCacheService> remoteDescribedService = remoteEnabled

        String value
    }

    static class TestRemoteBuildCacheServiceFactory implements BuildCacheServiceFactory<TestRemoteBuildCache> {
        @Override
        BuildCacheService createBuildCacheService(TestRemoteBuildCache configuration, Describer describer) {
            def chain = describer.type("remote")
            if (configuration.value != null) {
                chain.config("value", configuration.value)

            }
            class CustomBuildCache extends AbstractBuildCache {}
            class CustomBuildCacheFactory implements BuildCacheServiceFactory<CustomBuildCache> {
                @Override BuildCacheService createBuildCacheService(CustomBuildCache configuration, Describer describer) {
                    describer.type('$type').config('directory', '$directory')
                    new VisibleNoOpBuildCacheService()
                }
            }

                String shouldFail
            }

            class CustomBuildCacheServiceFactory implements BuildCacheServiceFactory<CustomBuildCache> {
                CustomBuildCacheService createBuildCacheService(CustomBuildCache configuration, Describer describer) {
                    return new CustomBuildCacheService()
                }
            }

            class CustomBuildCacheService implements BuildCacheService {

                String shouldFail
            }

            class FailingBuildCacheServiceFactory implements BuildCacheServiceFactory<FailingBuildCache> {
                FailingBuildCacheService createBuildCacheService(FailingBuildCache configuration, Describer describer) {
                    return new FailingBuildCacheService(configuration.shouldFail)
                }
            }

        this.resolver = resolver;
        this.fileAccessTimeJournal = fileAccessTimeJournal;
        this.cacheConfigurations = cacheConfigurations;
    }

    @Override
    public BuildCacheService createBuildCacheService(DirectoryBuildCache configuration, Describer describer) {
        Object cacheDirectory = configuration.getDirectory();
        File target;
        if (cacheDirectory != null) {

        this.requestCustomizer = requestCustomizer;
        this.httpClientHelperFactory = httpClientHelperFactory;
    }

    @Override
    public BuildCacheService createBuildCacheService(HttpBuildCache configuration, Describer describer) {
        URI url = configuration.getUrl();
        if (url == null) {
            throw new IllegalStateException("HTTP build cache has no URL configured");
        }

        settingsFile << """
            class ${className} extends AbstractBuildCache {}
            class ${className}ServiceFactory implements BuildCacheServiceFactory<${className}> {
                ${className}Service createBuildCacheService(${className} configuration, Describer describer) {
                    return new ${className}Service(configuration)
                }
            }
            class ${className}Service implements BuildCacheService {

            cacheRef = new DefaultHttpBuildCacheServiceFactory(new DefaultSslContextFactory(), { it.addHeader("X-Gradle-Version", "3.0") }, httpClientHelperFactory)
                .createBuildCacheService(this.config, buildCacheDescriber) as HttpBuildCacheService
        }
        cacheRef
    }

    def setup() {
        server.start()
        config.url = server.uri.resolve("/cache/")
    }