setup:
        def resourceConnectorSpecification = Mock(ResourceConnectorSpecification)
        1 * resourceConnectorSpecification.getCredentials(AwsCredentials) >> null
        1 * resourceConnectorSpecification.getAuthentications() >> [ new AllSchemesAuthentication(null) ]
        
        when:
        factory.createResourceConnector(resourceConnectorSpecification)

        then:
        def e = thrown(IllegalArgumentException)

import java.util.Collections;

public interface ResourceConnectorSpecification {
    default <T> T getCredentials(Class<T> type) {
        return null;
    }

    default Collection<Authentication> getAuthentications() {
        return Collections.emptyList();
    }

    default HttpRedirectVerifier getRedirectVerifier() {
        return uris -> {
        };
    }

        this.repository = repository;
    }

    public JavaToolchainResolver getResolver() {
        return resolverProvider.get();
    }

    public Collection<Authentication> getAuthentications(URI uri) {
        Collection<Authentication> configuredAuthentication = repository.getConfiguredAuthentication();

        for (Authentication authentication : configuredAuthentication) {

        HttpClientHelper http = httpClientHelperFactory.create(DefaultHttpSettings.builder()
            .withAuthenticationSettings(connectionDetails.getAuthentications())
            .withSslContextFactory(sslContextFactory)
            .withRedirectVerifier(connectionDetails.getRedirectVerifier())
            .build()
        );

    }

    @Override
    public ExternalResourceConnector createResourceConnector(ResourceConnectorSpecification connectionDetails) {
        Collection<? extends Authentication> authentications = connectionDetails.getAuthentications();
        // Since s3 transport supports only one type of credentials at a time, let's use the first one found.
        for (Authentication authentication : authentications) {

        RealizedJavaToolchainRepository repository = Mock(RealizedJavaToolchainRepository)
        repository.getResolver() >> resolver
        repository.getRepositoryName() >> repositoryName

        repository.getAuthentications(_ as URI) >> Collections.emptyList()
        repository
    }

            }
        }

        @Override
        public Collection<Authentication> getAuthentications() {
            return authentications;
        }

        @Override
        public HttpRedirectVerifier getRedirectVerifier() {
            return redirectVerifier;
        }
    }

                continue;
            }
            try {
                if (download.isPresent()) {
                    Collection<Authentication> authentications = repository.getAuthentications(download.get().getUri());
                    successfulProvisioning = provisionInstallation(spec, download.get().getUri(), authentications);
                    break;
                }

        if (repositories != null && selector != null) {
            for (ArtifactRepository repository : repositories) {
                repository.setAuthentication(getAuthentication(selector, repository));
            }
        }
    }

    private Authentication getAuthentication(AuthenticationSelector selector, ArtifactRepository repository) {
        if (selector != null) {

        return credentials;
    }

    public void authentication(Action<? super AuthenticationContainer> action) {
        action.execute(getAuthentication());
    }

    public AuthenticationContainer getAuthentication() {
        return authenticationContainer;
    }

    public Collection<Authentication> getConfiguredAuthentication() {
        populateAuthenticationCredentials();