authentication.setPassphrase(server.getPassphrase());

                    repository.setAuthentication(authentication);
                } else {
                    repository.setAuthentication(null);
                }
            }
        }
    }

    private Authentication getAuthentication(RepositorySystemSession session, ArtifactRepository repository) {
        if (session != null) {

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

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

         */
        if (deploymentRepository instanceof DefaultArtifactRepository
                && deploymentRepository.getAuthentication() == null) {
            RemoteRepository.Builder builder = new RemoteRepository.Builder(remoteRepo);
            builder.setAuthentication(session.getAuthenticationSelector().getAuthentication(remoteRepo));
            builder.setProxy(session.getProxySelector().getProxy(remoteRepo));

                org.eclipse.aether.repository.Authentication auth = selector.getAuthentication(repo);
                if (auth != null) {
                    repo = new RemoteRepository.Builder(repo)
                            .setAuthentication(auth)
                            .build();
                    AuthenticationContext authCtx = AuthenticationContext.forRepository(session, repo);

        repositorySystem.injectAuthentication(Arrays.asList(repository), Arrays.asList(server));
        Authentication authentication = repository.getAuthentication();
        assertNotNull(authentication);
        assertEquals("jason", authentication.getUsername());
        assertEquals("abc123", authentication.getPassword());
    }

        }

        if (repository.getAuthentication() != null && repository.getProxy() != null) {
            wagon.connect(
                    new Repository(repository.getId(), repository.getUrl()),
                    authenticationInfo(repository),
                    proxyInfo(repository));

        } else if (repository.getAuthentication() != null) {

            return Collections.emptyList();
        }

        public boolean isProjectAware() {
            return false;
        }

        public void setAuthentication(Authentication authentication) {}

        public Authentication getAuthentication() {
            return null;
        }

        public void setProxy(Proxy proxy) {}

        public Proxy getProxy() {
            return null;

    /**
     * @param authentication authentication
     * @since 3.0-alpha-3
     */
    void setAuthentication(Authentication authentication);

    /**
     * @return repository authentication
     * @since 3.0-alpha-3
     */
    Authentication getAuthentication();

    /**
     * @param proxy proxy
     * @since 3.0-alpha-3
     */
    void setProxy(Proxy proxy);

        return Collections.emptyList();
    }

    public boolean isProjectAware() {
        return false;
    }

    public Authentication getAuthentication() {
        return authentication;
    }

    public void setAuthentication(Authentication authentication) {
        this.authentication = authentication;
    }

    public Proxy getProxy() {
        return proxy;
    }

    private static final long serialVersionUID = 1L;

    private static final Logger logger = LogManager.getLogger(WebAuthentication.class);

    private WebConfig webConfig;

    public Authentication getAuthentication() {
        return new AuthenticationImpl(getAuthScope(), getCredentials(), getAuthScheme());
    }

    private AuthScheme getAuthScheme() {
        final String scheme = getProtocolScheme();