@Override
    public <T> T withContent(ExternalResourceName location, boolean revalidate, ExternalResource.ContentAndMetadataAction<T> action) throws ResourceException {
        ExternalResourceReadResponse response = openResource(location, revalidate);
        if (response == null) {
            return null;
        }

        try (InputStream inputStream = response.openStream();

        }
        _ * metaData.getContentType() >> "text/html"
    }

    def "list returns null if HttpAccessor returns null"(){
        setup:
        accessorMock.openResource(new ExternalResourceName("http://testrepo/"), true)  >> null
        expect:
        null == lister.list(new ExternalResourceName("http://testrepo"))
    }

        }
        def httpResourceAccessor = new HttpResourceAccessor(http)

        when:
        10.times {
            concurrent.start {
                100.times {
                    httpResourceAccessor.openResource(name, false).close()
                }
            }
        }
        concurrent.finished()

        then:
        noExceptionThrown()
    }

    private final HttpClientHelper http;

    public HttpResourceAccessor(HttpClientHelper http) {
        this.http = http;
    }

    @Override
    @Nullable
    public HttpResponseResource openResource(final ExternalResourceName location, boolean revalidate) {
        String uri = location.getUri().toString();
        LOGGER.debug("Constructing external resource: {}", location);

            1 * getResource(uri) >> Mock(S3Object) {
                getObjectMetadata() >> objectMetadata
            }
        }

        when:
        def s3Resource = new S3ResourceConnector(s3Client).openResource(name, false)

        then:
        s3Resource != null

        cleanup:
        s3Resource?.close()
    }


    def "should call close() on S3Object when getMetaData is called"() {

    def "should get a resource"() {
        GcsClient gcsClient = Mock {
            1 * getResource(uri) >> new StorageObject()
        }

        when:
        def gcsResource = new GcsResourceConnector(gcsClient).openResource(name, false)

        then:
        gcsResource != null
    }

    def "should get a resource metaData"() {
        def lastModified = new DateTime(new Date())

            contentLength = attributes.getSize();
        }

        return new DefaultExternalResourceMetaData(uri, lastModified, contentLength);
    }

    @Override
    public ExternalResourceReadResponse openResource(ExternalResourceName location, boolean revalidate) {
        ExternalResourceMetaData metaData = getMetaData(location, revalidate);

        LOGGER.debug("Listing parent resources: {}", parent);
        return gcsClient.list(parent.getUri());
    }

    @Nullable
    @Override
    public ExternalResourceReadResponse openResource(ExternalResourceName location, boolean revalidate) throws ResourceException {
        LOGGER.debug("Attempting to get resource: {}", location);
        StorageObject gcsObject = gcsClient.getResource(location.getUri());

            return null;
        } catch (Exception e) {
            throw ResourceExceptions.getFailed(location.getUri(), e);
        }
    }

    @Nullable
    @Override
    public ExternalResourceReadResponse openResource(final ExternalResourceName location, boolean revalidate) throws ResourceException {
        try {
            URL url = location.getUri().toURL();
            final URLConnection connection = url.openConnection();

        LOGGER.debug("Listing parent resources: {}", parent);
        return s3Client.listDirectChildren(parent.getUri());
    }

    @Override
    public ExternalResourceReadResponse openResource(ExternalResourceName location, boolean revalidate) {
        LOGGER.debug("Attempting to get resource: {}", location);
        S3Object s3Object = s3Client.getResource(location.getUri());
        if (s3Object == null) {