@Test
public void testUrlCredDefaultProvider() throws HTTPException {
  String url = "https://" + username + ":" + password + "@" + host + "/something/garbage.grb?query";
  logger.info("Testing {}", url);
  try (HTTPMethod method = HTTPFactory.Get(url)) {
    // we should have a default BasicCredentialProvider available, even though
    // we didn't call the factory with a specific provider
    HTTPSession session = method.getSession();
    CredentialsProvider credentialsProvider = session.sessionprovider;
    assertThat(credentialsProvider).isNotNull();
    AuthScope expectedAuthScope = new AuthScope(host, 80);
    Credentials credentials = credentialsProvider.getCredentials(expectedAuthScope);
    assertThat(credentials).isNotNull();
    assertThat(credentials.getUserPrincipal().getName()).isEqualTo(username);
    assertThat(credentials.getPassword()).isEqualTo(password);
  }
}
 

public void initServers() throws HTTPException {
  if (serverNames == null) {
    servers = new ArrayList<>(); // empty list
    return;
  }

  this.servers = new ArrayList<>(this.serverNames.length);
  for (String name : this.serverNames) {
    HTTPSession session = HTTPFactory.newSession(name);
    if (user != null && pass != null) {
      Credentials bp = new UsernamePasswordCredentials(user, pass);
      BasicCredentialsProvider bcp = new BasicCredentialsProvider();
      bcp.setCredentials(AuthScope.ANY, bp);
      session.setCredentialsProvider(bcp);
    }
    session.setUserAgent("TDM");
    servers.add(new Server(name, session));
  }
}
 

public static Credentials getCredentials( final String user,
                                          final String password ) {
  if ( StringUtils.isEmpty( user ) ) {
    return null;
  }

  final int domainIdx = user.indexOf( DOMAIN_SEPARATOR );
  if ( domainIdx == -1 ) {
    return new UsernamePasswordCredentials( user, password );
  }
  try {
    final String domain = user.substring( 0, domainIdx );
    final String username = user.substring( domainIdx + 1 );
    final String host = InetAddress.getLocalHost().getHostName();
    return new NTCredentials( username, password, host, domain );
  } catch ( UnknownHostException uhe ) {
    return new UsernamePasswordCredentials( user, password );
  }
}
 

private void doTest(boolean async) throws Exception {
    setupClient(async);
    assertEquals("Hello Alice", greeter.greetMe("Alice"));
    assertEquals("Hello Bob", greeter.greetMe("Bob"));

    try {
        BindingProvider bp = (BindingProvider)greeter;
        if (async) {
            UsernamePasswordCredentials creds = new UsernamePasswordCredentials("blah", "foo");
            bp.getRequestContext().put(Credentials.class.getName(), creds);
        } else {
            bp.getRequestContext().put(BindingProvider.USERNAME_PROPERTY, "blah");
            bp.getRequestContext().put(BindingProvider.PASSWORD_PROPERTY, "foo");
        }
        greeter.greetMe("Alice");
        fail("Password was wrong, should have failed");
    } catch (WebServiceException wse) {
        //ignore - expected
    }
}
 

public static CloseableHttpResponse execute(HttpUriRequest req, @Nullable Credentials auth) throws IOException {
   if (auth != null) {
      URI uri = req.getURI();
      AuthScope scope = new AuthScope(uri.getHost(), uri.getPort());

      CredentialsProvider provider = new BasicCredentialsProvider();
      provider.setCredentials(scope, auth);

      HttpClientContext context = HttpClientContext.create();
      context.setCredentialsProvider(provider);

      return get().execute(req, context);
   }

   return execute(req);
}
 

public boolean add(Credentials credential) {
    boolean exists = false;
    for (CredentialsTableRow credentialData : credentialsTableData) {
        UsernamePasswordCredentials savedCredential = (UsernamePasswordCredentials) credentialData.getCredentials();
        String savedUsername = savedCredential.getUserPrincipal().getName();
        String username = credential.getUserPrincipal().getName();
        String savedPassword = savedCredential.getPassword();
        String password = credential.getPassword();
        if (savedUsername.contentEquals(username) && savedPassword.contentEquals(password)) {
            exists = true;
            break;
        }
    }
    if (!exists) {
        CredentialsTableRow credentialsTableRow = new CredentialsTableRow(credential, credentialsTableData.size());
        credentialsTableData.add(credentialsTableRow);
        int row = credentialsTableData.indexOf(credentialsTableRow);
        fireTableRowsInserted(row, row);
        return true;
    }
    return false;
}
 

private void outputProductsPageChanged() {
    this.downloadRemoteProductsHelper.cancelDownloadingProductsQuickLookImage();
    if (this.localRepositoryProductsThread == null) {
        AbstractProductsRepositoryPanel selectedProductsRepositoryPanel = this.repositorySelectionPanel.getSelectedProductsRepositoryPanel();
        if (selectedProductsRepositoryPanel instanceof RemoteProductsRepositoryPanel) {
            OutputProductListModel productListModel = this.repositoryOutputProductListPanel.getProductListPanel().getProductListModel();
            List<RepositoryProduct> productsWithoutQuickLookImage = productListModel.findProductsWithoutQuickLookImage();
            if (productsWithoutQuickLookImage.size() > 0) {
                if (logger.isLoggable(Level.FINE)) {
                    int currentPageNumber = selectedProductsRepositoryPanel.getOutputProductResults().getCurrentPageNumber();
                    String repositoryName = selectedProductsRepositoryPanel.getRepositoryName();
                    logger.log(Level.FINE, "Start downloading the quick look images for " + productsWithoutQuickLookImage.size()+" products from page number " + currentPageNumber + " using the '" +repositoryName+"' remote repository.");
                }

                RemoteProductsRepositoryPanel remoteProductsRepositoryPanel = (RemoteProductsRepositoryPanel)selectedProductsRepositoryPanel;
                Credentials selectedCredentials = remoteProductsRepositoryPanel.getSelectedAccount();
                RemoteProductsRepositoryProvider productsRepositoryProvider = remoteProductsRepositoryPanel.getProductsRepositoryProvider();
                this.downloadRemoteProductsHelper.downloadProductsQuickLookImageAsync(productsWithoutQuickLookImage, productsRepositoryProvider, selectedCredentials, this.repositoryOutputProductListPanel);
            }
        }
    }
}
 

@Override
public void process( final HttpRequest request, final HttpContext context )
    throws HttpException, IOException
{
    AuthState authState = (AuthState) context.getAttribute( ClientContext.TARGET_AUTH_STATE );
    CredentialsProvider credsProvider = (CredentialsProvider) context
        .getAttribute( ClientContext.CREDS_PROVIDER );
    HttpHost targetHost = (HttpHost) context.getAttribute( ExecutionContext.HTTP_TARGET_HOST );

    // If not auth scheme has been initialized yet
    if( authState.getAuthScheme() == null )
    {
        AuthScope authScope = new AuthScope( targetHost.getHostName(),
                                             targetHost.getPort() );
        // Obtain credentials matching the target host
        Credentials creds = credsProvider.getCredentials( authScope );
        // If found, generate BasicScheme preemptively
        if( creds != null )
        {
            authState.setAuthScheme( new BasicScheme() );
            authState.setCredentials( creds );
        }
    }
}
 

public void downloadProductsQuickLookImageAsync(List<RepositoryProduct> productsWithoutQuickLookImage, RemoteProductsRepositoryProvider productsRepositoryProvider,
                                                Credentials credentials, RepositoryOutputProductListPanel repositoryProductListPanel) {

    createThreadPoolExecutorIfNeeded();

    DownloadProductsQuickLookImageRunnable runnable = new DownloadProductsQuickLookImageRunnable(productsWithoutQuickLookImage, productsRepositoryProvider,
                                                                                                 credentials, this.remoteRepositoriesSemaphore, repositoryProductListPanel) {

        @Override
        protected void finishRunning() {
            super.finishRunning();
            finishRunningDownloadProductsQuickLookImageThreadLater(this);
        }
    };
    this.runningTasks.put(runnable, null);
    this.threadPoolExecutor.execute(runnable); // start the thread
}
 

/**
 * Create an {@link ApacheHttpTransport} for calling Google APIs with an optional HTTP proxy.
 *
 * @param proxyUri Optional HTTP proxy URI to use with the transport.
 * @param proxyCredentials Optional HTTP proxy credentials to authenticate with the transport
 *     proxy.
 * @return The resulting HttpTransport.
 * @throws IOException If there is an issue connecting to Google's certification server.
 * @throws GeneralSecurityException If there is a security issue with the keystore.
 */
public static ApacheHttpTransport createApacheHttpTransport(
    @Nullable URI proxyUri, @Nullable Credentials proxyCredentials)
    throws IOException, GeneralSecurityException {
  checkArgument(
      proxyUri != null || proxyCredentials == null,
      "if proxyUri is null than proxyCredentials should be null too");

  ApacheHttpTransport transport =
      new ApacheHttpTransport.Builder()
          .trustCertificates(GoogleUtils.getCertificateTrustStore())
          .setProxy(
              proxyUri == null ? null : new HttpHost(proxyUri.getHost(), proxyUri.getPort()))
          .build();

  if (proxyCredentials != null) {
    ((DefaultHttpClient) transport.getHttpClient())
        .getCredentialsProvider()
        .setCredentials(new AuthScope(proxyUri.getHost(), proxyUri.getPort()), proxyCredentials);
  }

  return transport;
}
 

@Override
public void process(HttpRequest request, HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE);
    Credentials creds;
    
    if (authState.getAuthScheme() == null) {
        AuthScheme authScheme = (AuthScheme) context.getAttribute("preemptive-auth");
        CredentialsProvider credsProvider =
                (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER);
        HttpHost targetHost =
                (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
        if (authScheme != null) {
            creds =
                    credsProvider.getCredentials(new AuthScope(
                            targetHost.getHostName(),
                            targetHost.getPort()));
            if (creds == null) {
                throw new HttpException("No credentials for preemptive authentication");
            }
            authState.update(authScheme, creds);
        }
    }
}
 

public Response execute(final Request request) throws ArangoDBException, IOException {
    final String url = buildUrl(buildBaseUrl(host), request);
    final HttpRequestBase httpRequest = buildHttpRequestBase(request, url);
    httpRequest.setHeader("User-Agent", "Mozilla/5.0 (compatible; ArangoDB-JavaDriver/1.1; +http://mt.orz.at/)");
    if (contentType == Protocol.HTTP_VPACK) {
        httpRequest.setHeader("Accept", "application/x-velocypack");
    }
    addHeader(request, httpRequest);
    final Credentials credentials = addCredentials(httpRequest);
    if (LOGGER.isDebugEnabled()) {
        CURLLogger.log(url, request, credentials, util);
    }
    Response response;
    response = buildResponse(client.execute(httpRequest));
    checkError(response);
    return response;
}
 

public static void checkUserCredentials(String username, String password, AuthScheme authScheme) throws NoSuchFieldException,
    IllegalAccessException
{
  CredentialsProvider provider = getCredentialsProvider();
  String httpScheme = AuthScope.ANY_SCHEME;
  if (authScheme == AuthScheme.BASIC) {
    httpScheme = AuthSchemes.BASIC;
  } else if (authScheme == AuthScheme.DIGEST) {
    httpScheme = AuthSchemes.DIGEST;
  }
  AuthScope authScope = new AuthScope(AuthScope.ANY_HOST, AuthScope.ANY_PORT, AuthScope.ANY_REALM, httpScheme);
  Credentials credentials = provider.getCredentials(authScope);
  Assert.assertNotNull("Credentials", credentials);
  Assert.assertTrue("Credentials type is user", UsernamePasswordCredentials.class.isAssignableFrom(credentials.getClass()));
  UsernamePasswordCredentials pwdCredentials = (UsernamePasswordCredentials)credentials;
  Assert.assertEquals("Username", username, pwdCredentials.getUserName());
  Assert.assertEquals("Password", password, pwdCredentials.getPassword());
}
 

/**
 * @return a generic REST client with authentication configured
 */
protected Client restClient() {
  try {
    final HttpClient httpClient = clientBuilder().build();
    final Credentials credentials = credentials();
    return restClientFactory
        .create(RestClientConfiguration.DEFAULTS
            .withHttpClient(() -> httpClient)
            .withCustomizer(getObjectMapperCustomizer(testSuiteObjectMapperResolver))
        )
        .register(new BasicAuthentication(credentials.getUserPrincipal().getName(), credentials.getPassword()));
  }
  catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

@Test
public void testAddCredentials() throws IOException, ClassNotFoundException {
  String testUser = "test_username";
  slaveServer.setUsername( testUser );
  String testPassword = "test_password";
  slaveServer.setPassword( testPassword );
  String host = "somehost";
  slaveServer.setHostname( host );
  int port = 1000;
  slaveServer.setPort( "" + port );

  HttpClientContext auth = slaveServer.getAuthContext();
  Credentials cred = auth.getCredentialsProvider().getCredentials( new AuthScope( host, port ) );
  assertEquals( testUser, cred.getUserPrincipal().getName() );
  assertEquals( testPassword, cred.getPassword() );

  String user2 = "user2";
  slaveServer.setUsername( user2 );
  slaveServer.setPassword( "pass2" );
  auth = slaveServer.getAuthContext();
  cred = auth.getCredentialsProvider().getCredentials( new AuthScope( host, port ) );
  assertEquals( user2, cred.getUserPrincipal().getName() );
}
 

private SystemDefaultHttpClient getHttpClient() {
  final SystemDefaultHttpClient httpClient = new SystemDefaultHttpClient();
  httpClient.getAuthSchemes().register(AuthPolicy.SPNEGO, new SPNegoSchemeFactory(true));
   Credentials use_jaas_creds = new Credentials() {
     public String getPassword() {
       return null;
     }

     public Principal getUserPrincipal() {
       return null;
     }
   };

   httpClient.getCredentialsProvider().setCredentials(
     AuthScope.ANY, use_jaas_creds);
   return httpClient;
}
 

private Credentials getCredentials() {
    if (StringUtil.isEmpty(getUsername())) {
        throw new CrawlerSystemException("username is empty.");
    }

    if (Constants.NTLM.equals(getProtocolScheme())) {
        final Map<String, String> parameterMap = ParameterUtil.parse(getParameters());
        final String workstation = parameterMap.get("workstation");
        final String domain = parameterMap.get("domain");
        return new NTCredentials(getUsername(), getPassword(), workstation == null ? StringUtil.EMPTY : workstation,
                domain == null ? StringUtil.EMPTY : domain);
    }

    return new UsernamePasswordCredentials(getUsername(), getPassword() == null ? StringUtil.EMPTY : getPassword());
}
 

public RemoteProductDownloader(RemoteProductsRepositoryProvider remoteProductsRepositoryProvider, RepositoryProduct productToDownload,
                               Path localRepositoryFolderPath, Credentials credentials) {

    this.remoteProductsRepositoryProvider = remoteProductsRepositoryProvider;
    this.productToDownload = productToDownload;
    this.localRepositoryFolderPath = localRepositoryFolderPath;
    this.credentials = credentials;
}
 

private static boolean isRepositoryChanged(RemoteRepositoryCredentials savedRepositoryCredentials, RemoteRepositoryCredentials repositoryCredentials) {
    List<Credentials> credentials = repositoryCredentials.getCredentialsList();
    if (credentials.size() != savedRepositoryCredentials.getCredentialsList().size()) {
        // some credentials deleted or added = changed
        return true;
    }
    for (Credentials credential : credentials) {
        if (!savedRepositoryCredentials.credentialExists(credential)) {
            return true; // the credential was not found = changed
        }
    }
    return false;
}
 

public InputStream getStream(String baseUrl, RasterLayer layer) throws IOException {
	String url = baseUrl;
	HttpContext context = null;
	if (layer instanceof ProxyLayerSupport) {
		context = new BasicHttpContext();
		// pass url and layer id to the CompositeInterceptor
		context.setAttribute(CompositeInterceptor.BASE_URL, baseUrl);
		context.setAttribute(CompositeInterceptor.LAYER_ID, layer.getId());
		// handle proxy authentication and interceptors
		ProxyLayerSupport proxyLayer = (ProxyLayerSupport) layer;
		ProxyAuthentication authentication = proxyLayer.getProxyAuthentication();
		url = addCredentialsToUrl(baseUrl, authentication);

		// -- add basic authentication
		if (null != authentication
				&& (ProxyAuthenticationMethod.BASIC.equals(authentication.getMethod()) ||
					ProxyAuthenticationMethod.DIGEST.equals(authentication.getMethod()))) {
			// Set up the credentials:
			Credentials creds = new UsernamePasswordCredentials(authentication.getUser(),
					authentication.getPassword());
			URL u = new URL(url);
			AuthScope scope = new AuthScope(u.getHost(), u.getPort(), authentication.getRealm());
			// thread-safe, this is ok
			client.getCredentialsProvider().setCredentials(scope, creds);
		}
	}

	// Create the GET method with the correct URL:
	HttpGet get = new HttpGet(url);

	// Execute the GET:
	HttpResponse response = client.execute(get, context);
	log.debug("Response: {} - {}", response.getStatusLine().getStatusCode(), response.getStatusLine()
			.getReasonPhrase());

	return response.getEntity().getContent();
}
 

/**
 * Create an {@link HttpTransport} based on an type class and an optional HTTP proxy.
 *
 * @param type The type of HttpTransport to use.
 * @param proxyAddress The HTTP proxy to use with the transport. Of the form hostname:port. If
 *     empty no proxy will be used.
 * @param proxyUsername The HTTP proxy username to use with the transport. If empty no proxy
 *     username will be used.
 * @param proxyPassword The HTTP proxy password to use with the transport. If empty no proxy
 *     password will be used.
 * @return The resulting HttpTransport.
 * @throws IllegalArgumentException If the proxy address is invalid.
 * @throws IOException If there is an issue connecting to Google's Certification server.
 */
public static HttpTransport createHttpTransport(
    HttpTransportType type,
    @Nullable String proxyAddress,
    @Nullable RedactedString proxyUsername,
    @Nullable RedactedString proxyPassword)
    throws IOException {
  logger.atFine().log(
      "createHttpTransport(%s, %s, %s, %s)", type, proxyAddress, proxyUsername, proxyPassword);
  checkArgument(
      proxyAddress != null || (proxyUsername == null && proxyPassword == null),
      "if proxyAddress is null then proxyUsername and proxyPassword should be null too");
  checkArgument(
      (proxyUsername == null) == (proxyPassword == null),
      "both proxyUsername and proxyPassword should be null or not null together");
  URI proxyUri = parseProxyAddress(proxyAddress);
  try {
    switch (type) {
      case APACHE:
        Credentials proxyCredentials =
            proxyUsername != null
                ? new UsernamePasswordCredentials(proxyUsername.value(), proxyPassword.value())
                : null;
        return createApacheHttpTransport(proxyUri, proxyCredentials);
      case JAVA_NET:
        PasswordAuthentication proxyAuth =
            proxyUsername != null
                ? new PasswordAuthentication(
                    proxyUsername.value(), proxyPassword.value().toCharArray())
                : null;
        return createNetHttpTransport(proxyUri, proxyAuth);
      default:
        throw new IllegalArgumentException(
            String.format("Invalid HttpTransport type '%s'", type.name()));
    }
  } catch (GeneralSecurityException e) {
    throw new IOException(e);
  }
}
 

@Test
public void createNtlmCredentialsProvider() {
    CredentialsProvider credentialsProvider = getCredentialsProvider(AuthSchemes.NTLM);
    Credentials credentials = credentialsProvider.getCredentials(new AuthScope("host", 80));

    assertThat(credentials, instanceOf(NTCredentials.class));
    NTCredentials ntCredentials = (NTCredentials) credentials;
    assertEquals("DOMAIN", ntCredentials.getDomain());
    assertEquals("HOST", ntCredentials.getWorkstation());
    assertEquals("pass", ntCredentials.getPassword());
    Credentials proxyCredentials = credentialsProvider.getCredentials(new AuthScope("proxy", 8080));
    assertThat(proxyCredentials, instanceOf(UsernamePasswordCredentials.class));
    UsernamePasswordCredentials userCredentials = (UsernamePasswordCredentials) proxyCredentials;
    assertEquals("proxyUsername", userCredentials.getUserName());
}
 

@Test
public void testHttpDownloadWithAuthenticationAndSsl() throws Exception {
   Credentials auth = HttpService.basic("testuser", "testpasswd");
   String output = HttpService.contentAsString("https://httpbin.org/basic-auth/testuser/testpasswd", auth);
   System.out.println("downloaded size: " + output.length());
   System.out.println("downloaded content: " + output);
   Assert.assertTrue("download did not work correctly", output != null && output.length() > 16);
}
 

private static Credentials createCredentials(final String username, final String password) {
    final String user;
    final String domain;
    int backslashIndex = username.indexOf('\\');
    if (backslashIndex >= 0) {
        user = username.substring(backslashIndex + 1);
        domain = username.substring(0, backslashIndex);
    } else {
        user = username;
        domain = System.getProperty("http.auth.ntlm.domain", "");
    }
    return new NTCredentials(user, password, HostUtil.getLocalHostName(), domain);
}
 

public static void log(
        final String url,
        final Request request,
        final Credentials credencials,
        final ArangoSerialization util) {
    final RequestType requestType = request.getRequestType();
    final boolean includeBody = (requestType == RequestType.POST || requestType == RequestType.PUT
            || requestType == RequestType.PATCH || requestType == RequestType.DELETE) && request.getBody() != null;
    final StringBuilder buffer = new StringBuilder();
    if (includeBody) {
        buffer.append("\n");
        buffer.append("cat <<-___EOB___ | ");
    }
    buffer.append("curl -X ").append(requestType);
    buffer.append(" --dump -");
    if (request.getHeaderParam().size() > 0) {
        for (final Entry<String, String> header : request.getHeaderParam().entrySet()) {
            buffer.append(" -H '").append(header.getKey()).append(":").append(header.getValue()).append("'");
        }
    }
    if (credencials != null) {
        buffer.append(" -u ").append(credencials.getUserPrincipal().getName()).append(":")
                .append(credencials.getPassword());
    }
    if (includeBody) {
        buffer.append(" -d @-");
    }
    buffer.append(" '").append(url).append("'");
    if (includeBody) {
        buffer.append("\n");
        buffer.append((String) util.deserialize(request.getBody(), String.class));
        buffer.append("\n");
        buffer.append("___EOB___");
    }
    LOGGER.debug("[CURL] {}", buffer);
}
 

private HttpClient createHttpClient(){
	CredentialsProvider credsProvider = new BasicCredentialsProvider();
	if(user !=null && pwd !=null){
		Credentials credentials = new UsernamePasswordCredentials(user, pwd);
		credsProvider.setCredentials(AuthScope.ANY, credentials);
	}
	HttpClient httpclient = HttpClients.custom()
	    .setDefaultCredentialsProvider(credsProvider)
	    .build();
	return httpclient;
}
 

/**
 * Returns the NTCredentials or UsernamePasswordCredentials object
 *
 * @param type
 * @param authenticationInfo
 * @return
 */
public static Credentials getCredentials(final ServerContext.Type type, final AuthenticationInfo authenticationInfo) {
    if (type == ServerContext.Type.TFS) {
        return getNTCredentials(authenticationInfo.getUserName(), authenticationInfo.getPassword());
    } else {
        return new UsernamePasswordCredentials(authenticationInfo.getUserName(), authenticationInfo.getPassword());
    }
}
 

public static HttpsDispatcher getInstance(String uri, Credentials credentials) {

        HttpsDispatcher dispatcher = new HttpsDispatcher(new HttpHost(uri),
                new BasicHttpContext());
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        AuthScope authScope = new AuthScope(dispatcher.host.getHostName(), dispatcher.host.getPort());
        credsProvider.setCredentials(authScope, credentials);
        ((AbstractHttpClient) dispatcher.client).getCredentialsProvider().setCredentials(
                authScope, credentials);
        return dispatcher;
    }
 

@Test
public void testSendExportOk() throws Exception {
  slaveServer.setUsername( "uname" );
  slaveServer.setPassword( "passw" );
  slaveServer.setHostname( "hname" );
  slaveServer.setPort( "1111" );
  HttpPost httpPostMock = mock( HttpPost.class );
  URI uriMock = new URI( "fake" );
  final String responseContent = "baah";
  when( httpPostMock.getURI() ).thenReturn( uriMock );
  doReturn( uriMock ).when( httpPostMock ).getURI();

  HttpClient client = mock( HttpClient.class );
  when( client.execute( any(), any( HttpContext.class ) ) ).then( new Answer<HttpResponse>() {
    @Override
    public HttpResponse answer( InvocationOnMock invocation ) throws Throwable {
      HttpClientContext context = invocation.getArgumentAt( 1, HttpClientContext.class );
      Credentials cred = context.getCredentialsProvider().getCredentials( new AuthScope( "hname", 1111 ) );
      assertEquals( "uname", cred.getUserPrincipal().getName() );
      return mockResponse( 200, responseContent );
    }
  } );
  // override init
  when( slaveServer.getHttpClient() ).thenReturn( client );
  when( slaveServer.getResponseBodyAsString( any() ) ).thenCallRealMethod();

  doReturn( httpPostMock ).when( slaveServer ).buildSendExportMethod( anyString(), anyString(), any(
      InputStream.class ) );
  File tempFile;
  tempFile = File.createTempFile( "PDI-", "tmp" );
  tempFile.deleteOnExit();
  String result = slaveServer.sendExport( tempFile.getAbsolutePath(), null, null );
  assertEquals( responseContent, result );
}
 

public static void upload(URI uri, Credentials auth, File src, String description) throws IOException {
   String cred = auth.getUserPrincipal().getName()+":"+auth.getPassword();
   String encoding = Base64.encodeBase64String(cred.getBytes());
   HttpPost httppost = new HttpPost(uri);
   // Add in authentication
   httppost.setHeader("Authorization", "Basic " + encoding);
   FileBody data = new FileBody(src);
   StringBody text = new StringBody(description, ContentType.TEXT_PLAIN);

   // Build up multi-part form
   HttpEntity reqEntity = MultipartEntityBuilder.create()
           .addPart("upload", data)
           .addPart("comment", text)
           .setMode(HttpMultipartMode.BROWSER_COMPATIBLE)
           .build();
   httppost.setEntity(reqEntity);

   // Execute post and get response
   CloseableHttpClient client = get();
   CloseableHttpResponse response = client.execute(httppost);
   try {
       HttpEntity resEntity = response.getEntity();
       EntityUtils.consume(resEntity);
   } finally {
       response.close();
   }
}