then:
        result == null

        and:
        1 * index.lookup("thing") >> null
        1 * localCandidates.isNone() >> true
        1 * repository.withProgressLogging() >> progressLoggingRepo
        1 * progressLoggingRepo.resource(location) >> resource
        1 * resource.withContentIfPresent(_) >> null
        0 * _._
    }

 */
public interface ExternalResourceRepository {
    /**
     * Returns a copy of this repository with progress logging enabled.
     */
    ExternalResourceRepository withProgressLogging();

    /**
     * Returns the resource with the given name. Note that this method does not access the resource in any way, it simply creates an object that can. To access the resource, use the methods on the returned object.

        this.fileSystem = fileSystem;
        this.listener = listenerManager.getBroadcaster(FileResourceListener.class);
    }

    @Override
    public ExternalResourceRepository withProgressLogging() {
        return this;
    }

    @Override
    public LocalBinaryResource localResource(File file) {
        return new LocalFileStandInExternalResource(file, fileSystem, listener);
    }

            Throwable failure = null;
            long bytesDownloaded = 0;
            try {
                bytesDownloaded = withProgressLogging(address, destination, descriptor);
            } catch (Throwable t) {
                failure = t;
            }

            long endTime = clock.getCurrentTime();

                getRepository() >> Mock(ExternalResourceRepository) {
                    withProgressLogging() >> Mock(ExternalResourceRepository) {
                        resource(_ as ExternalResourceName) >> Mock(ExternalResource) {

    ) {
        this.name = name;
        this.accessor = accessor;
        this.uploader = uploader;
        this.lister = lister;
    }

    @Override
    public ExternalResourceRepository withProgressLogging() {
        return this;
    }

    @Override
    public ExternalResource resource(ExternalResourceName resource, boolean revalidate) {

            if (cached == null && (additionalCandidates == null || additionalCandidates.isNone())) {
                return copyToCache(location, fileStore, delegate.withProgressLogging().resource(location));
            }

            // We might be able to use a cached/locally available version

            @Override
            public String getShortDisplayName() {
                return source.toString();
            }
        };
        return getTransport(source, authentications).getRepository().withProgressLogging().resource(resourceName);
    }

    private void downloadResource(URI source, File targetFile, ExternalResource resource) {
        final File downloadFile = new File(targetFile.getAbsoluteFile() + ".part");

        ModuleArtifactPublisher(ExternalResourceRepository repository, boolean localRepo, URI rootUri, String groupId, String artifactId, String moduleVersion) {
            this.repository = repository.withProgressLogging();
            this.localRepo = localRepo;
            this.rootUri = rootUri;
            this.groupPath = groupId.replace('.', '/');
            this.artifactId = artifactId;

        put(src, destination);
        LOGGER.info("Published {} to {}", artifact, destination);
    }

    private void put(File src, ExternalResourceName destination) {
        repository.withProgressLogging().resource(destination).put(new FileReadableContent(src));
        publishChecksums(destination, src);
    }

    private void publishChecksums(ExternalResourceName destination, File content) {