com.squareup.okhttp.HttpUrl Java Examples

private HttpUrl resolveConfiguration(@Nullable String configurationDomain, @NonNull HttpUrl domainUrl) {
    HttpUrl url = ensureValidUrl(configurationDomain);
    if (url == null) {
        final String host = domainUrl.host();
        if (host.endsWith(DOT_AUTH0_DOT_COM)) {
            String[] parts = host.split("\\.");
            if (parts.length > 3) {
                url = HttpUrl.parse("https://cdn." + parts[parts.length - 3] + DOT_AUTH0_DOT_COM);
            } else {
                url = HttpUrl.parse(AUTH0_US_CDN_URL);
            }
        } else {
            url = domainUrl;
        }
    }
    return url;
}
 

/**
 * Requests new Credentials using a valid Refresh Token. The received token will have the same audience and scope as first requested. How the new Credentials are requested depends on the {@link Auth0#isOIDCConformant()} flag.
 * - If the instance is OIDC Conformant the endpoint will be /oauth/token with 'refresh_token' grant, and the response will include an id_token and an access_token if 'openid' scope was requested when the refresh_token was obtained.
 * In addition, if the application has Refresh Token Rotation configured, a new one-time use refresh token will also be included in the response.
 * - If the instance is not OIDC Conformant the endpoint will be /delegation with 'urn:ietf:params:oauth:grant-type:jwt-bearer' grant, and the response will include an id_token.
 * Example usage:
 * <pre>
 * {@code
 * client.renewAuth("{refresh_token}")
 *      .addParameter("scope", "openid profile email")
 *      .start(new BaseCallback<Credentials>() {
 *          {@literal}Override
 *          public void onSuccess(Credentials payload) { }
 *
 *          {@literal}@Override
 *          public void onFailure(AuthenticationException error) { }
 *      });
 * }
 * </pre>
 *
 * @param refreshToken used to fetch the new Credentials.
 * @return a request to start
 */
@SuppressWarnings("WeakerAccess")
public ParameterizableRequest<Credentials, AuthenticationException> renewAuth(@NonNull String refreshToken) {
    final Map<String, Object> parameters = ParameterBuilder.newBuilder()
            .setClientId(getClientId())
            .setRefreshToken(refreshToken)
            .setGrantType(auth0.isOIDCConformant() ? ParameterBuilder.GRANT_TYPE_REFRESH_TOKEN : ParameterBuilder.GRANT_TYPE_JWT)
            .asDictionary();

    HttpUrl url;
    if (auth0.isOIDCConformant()) {
        url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
                .addPathSegment(OAUTH_PATH)
                .addPathSegment(TOKEN_PATH)
                .build();
    } else {
        url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
                .addPathSegment(DELEGATION_PATH)
                .build();
    }

    return factory.POST(url, client, gson, Credentials.class, authErrorBuilder)
            .addParameters(parameters);
}
 

public Session get() {
    String serverUrlString = getString(SERVER_URI);
    String userNameString = getString(USERNAME);
    String passwordString = getString(PASSWORD);

    HttpUrl serverUrl = null;
    if (serverUrlString != null) {
        serverUrl = HttpUrl.parse(serverUrlString);
    }

    Credentials credentials = null;
    if (userNameString != null && passwordString != null) {
        credentials = new Credentials(
                userNameString, passwordString
        );
    }
    return new Session(serverUrl, credentials);
}
 

public Optional<Response> saveIntegrationPluginOfType(SaveSCMPluginConfigRequest saveSCMPluginConfigRequest) throws JsonProcessingException {

        HttpUrl httpUrl = getSaveIntegrationPluginConfigURL(saveSCMPluginConfigRequest);
        MediaType mediaType = MediaType.parse("application/json");
        Request httpRequest = buildPutRequest(httpUrl, mediaType, saveSCMPluginConfigRequest.getRequestBody());
        try {
            Response response = client.newCall(httpRequest).execute();
            if(!response.isSuccessful()){
                log.error(String.format("Error when attempting to save %s plugin integration for API %s version %s", saveSCMPluginConfigRequest.getScmProvider(), saveSCMPluginConfigRequest.getApi(),saveSCMPluginConfigRequest.getVersion()));
                log.error("Error response: "+response.body().string());
                response.body().close();
            }
            return Optional.ofNullable(response);
        } catch (IOException e) {
            log.error(String.format("Error when attempting to save %s plugin integration for API %s. Error message %s", saveSCMPluginConfigRequest.getScmProvider(), saveSCMPluginConfigRequest.getApi(), e.getMessage()));
            return Optional.empty();
        }

    }
 

@Test
public void shouldWhiteListLegacyParametersOnNonLegacyEndpoints() throws Exception {
    HashMap<String, Object> parameters = new HashMap<>();
    parameters.put("extra", "value");
    parameters.put("connection", "my-connection");
    HttpUrl url = HttpUrl.parse(mockAPI.getDomain())
            .newBuilder()
            .addPathSegment(OAUTH_PATH)
            .addPathSegment(TOKEN_PATH)
            .build();
    AuthenticationRequest req = createRequest(url);
    mockAPI.willReturnSuccessfulLogin();
    req.addAuthenticationParameters(parameters)
            .execute();

    final RecordedRequest request = mockAPI.takeRequest();
    Map<String, String> body = bodyFromRequest(request);
    assertThat(body, hasEntry("extra", "value"));
    assertThat(body, not(hasKey("connection")));
}
 

@Test
public void shouldSetRealm() throws Exception {
    HttpUrl url = HttpUrl.parse(mockAPI.getDomain())
            .newBuilder()
            .addPathSegment(OAUTH_PATH)
            .addPathSegment(TOKEN_PATH)
            .build();
    AuthenticationRequest req = createRequest(url);
    mockAPI.willReturnSuccessfulLogin();
    req.setRealm("users")
            .execute();

    final RecordedRequest request = mockAPI.takeRequest();
    Map<String, String> body = bodyFromRequest(request);
    assertThat(body, hasEntry("realm", "users"));
}
 

private Request createHttpProxyRequest(InetSocketAddress address, String proxyUsername,
    String proxyPassword) {
  HttpUrl tunnelUrl = new HttpUrl.Builder()
      .scheme("https")
      .host(address.getHostName())
      .port(address.getPort())
      .build();
  Request.Builder request = new Request.Builder()
      .url(tunnelUrl)
      .header("Host", tunnelUrl.host() + ":" + tunnelUrl.port())
      .header("User-Agent", userAgent);

  // If we have proxy credentials, set them right away
  if (proxyUsername != null && proxyPassword != null) {
    request.header("Proxy-Authorization", Credentials.basic(proxyUsername, proxyPassword));
  }
  return request.build();
}
 

public void put(Session session) {
    isNull(session, "Session object must not be null");
    HttpUrl serverUrl = session.getServerUrl();
    Credentials credentials = session.getCredentials();

    String url = null;
    String username = null;
    String password = null;

    if (serverUrl != null) {
        url = serverUrl.toString();
    }

    if (credentials != null) {
        username = credentials.getUsername();
        password = credentials.getPassword();
    }

    putString(SERVER_URI, url);
    putString(USERNAME, username);
    putString(PASSWORD, password);
}
 

public ApiInterface getApiInterface(MockWebServer mockWebServer) throws IOException {
    mockWebServer.start();
    TestUtils testUtils = new TestUtils();
    final Dispatcher dispatcher = new Dispatcher() {

        @Override
        public MockResponse dispatch(RecordedRequest request) throws InterruptedException {

            if (request.getPath().equals("/users/" + TestConst.TEST_OWNER + "/repos")) {
                return new MockResponse().setResponseCode(200)
                        .setBody(testUtils.readString("json/repos.json"));
            } else if (request.getPath().equals("/repos/" + TestConst.TEST_OWNER + "/" + TestConst.TEST_REPO + "/branches")) {
                return new MockResponse().setResponseCode(200)
                        .setBody(testUtils.readString("json/branches.json"));
            } else if (request.getPath().equals("/repos/" + TestConst.TEST_OWNER + "/" + TestConst.TEST_REPO + "/contributors")) {
                return new MockResponse().setResponseCode(200)
                        .setBody(testUtils.readString("json/contributors.json"));
            }
            return new MockResponse().setResponseCode(404);
        }
    };

    mockWebServer.setDispatcher(dispatcher);
    HttpUrl baseUrl = mockWebServer.url("/");
    return ApiModule.getApiInterface(baseUrl.toString());
}
 

@Before
public void setup() {
    SDKSettings.setExternalExecutor(null);
    Robolectric.getBackgroundThreadScheduler().reset();
    Robolectric.getForegroundThreadScheduler().reset();
    ShadowLog.stream = System.out;
    activity = Robolectric.buildActivity(MockMainActivity.class).create().start().resume().visible().get();
    shadowOf(activity).grantPermissions("android.permission.INTERNET");
    server= new MockWebServer();
    try {
        server.start();
        HttpUrl url= server.url("/");
        UTConstants.REQUEST_BASE_URL_UT = url.toString();
        System.out.println(UTConstants.REQUEST_BASE_URL_UT);
        ShadowSettings.setTestURL(url.toString());
        TestResponsesUT.setTestURL(url.toString());
    } catch (IOException e) {
        System.out.print("IOException");
    }
    bgScheduler = Robolectric.getBackgroundThreadScheduler();
    uiScheduler = Robolectric.getForegroundThreadScheduler();
    Robolectric.flushBackgroundThreadScheduler();
    Robolectric.flushForegroundThreadScheduler();
    bgScheduler.pause();
    uiScheduler.pause();
}
 

public String getDefinition(SwaggerHubRequest swaggerHubRequest) throws GradleException {
    HttpUrl httpUrl = getDownloadUrl(swaggerHubRequest);
    MediaType mediaType = MediaType.parse("application/" + swaggerHubRequest.getFormat());

    Request requestBuilder = buildGetRequest(httpUrl, mediaType);

    final String jsonResponse;
    try {
        final Response response = client.newCall(requestBuilder).execute();
        if (!response.isSuccessful()) {
            throw new GradleException(String.format("Failed to download API definition: %s", response.body().string()));
        } else {
            jsonResponse = response.body().string();
        }
    } catch (IOException e) {
        throw new GradleException("Failed to download API definition", e);
    }
    return jsonResponse;
}
 

@Test
public void shouldHandleNonAuth0Domain() {
    Auth0 auth0 = new Auth0(CLIENT_ID, "mydomain.com");
    assertThat(auth0.getClientId(), equalTo(CLIENT_ID));
    assertThat(HttpUrl.parse(auth0.getDomainUrl()), equalTo(HttpUrl.parse("https://mydomain.com")));
    assertThat(HttpUrl.parse(auth0.getConfigurationUrl()), equalTo(HttpUrl.parse("https://mydomain.com")));
}
 

public MockRequest(HttpUrl url, OkHttpClient client, Gson gson, String method, ErrorBuilder<U> builder) {
    this.headers = new HashMap<>();
    this.url = url;
    this.client = client;
    this.gson = gson;
    this.method = method;
    this.builder = builder;
}
 

private Request buildPostRequest(HttpUrl httpUrl, MediaType mediaType, String content) {
    return new Request.Builder()
            .url(httpUrl)
            .addHeader("Content-Type", mediaType.toString())
            .addHeader("Authorization", token)
            .addHeader("User-Agent", "swaggerhub-maven-plugin")
            .post(RequestBody.create(mediaType, content))
            .build();
}
 

@Test
public void shouldBuildWithConfigurationDomainToo() {
    Auth0 auth0 = new Auth0(CLIENT_ID, DOMAIN, CONFIG_DOMAIN_CUSTOM);
    assertThat(auth0.getClientId(), equalTo(CLIENT_ID));
    assertThat(HttpUrl.parse(auth0.getDomainUrl()), equalTo(HttpUrl.parse("https://samples.auth0.com")));
    assertThat(HttpUrl.parse(auth0.getConfigurationUrl()), equalTo(HttpUrl.parse("https://config.mydomain.com")));
}
 

static void initWithInstanceCheck(Context ctx,
                                  @Nullable OauthBasicAuthCredentialsProvider oauthProvider) {
    if (instance != null) {
        log.w("Calling ParticleCloudSDK.init() more than once does not re-initialize the SDK.");
        return;
    }

    String asString = ctx.getString(R.string.api_base_uri);
    doInit(ctx, oauthProvider, HttpUrl.parse(asString));
}
 

public static DhisApi createService(HttpUrl serverUrl, Credentials credentials,
        final Context context) {
    RestAdapter restAdapter = new RestAdapter.Builder()
            .setEndpoint(provideServerUrl(serverUrl))
            .setConverter(provideJacksonConverter())
            .setClient(provideOkClient(credentials, context))
            .setErrorHandler(new RetrofitErrorHandler())
            .setLogLevel(RestAdapter.LogLevel.BASIC)
            .setRequestInterceptor(new ConnectionInterceptor(context))
            .build();
    return restAdapter.create(DhisApi.class);
}
 

@Override
String toHost(Object target) {
    if (target instanceof HttpUrlGetter) {
        final HttpUrl url = ((HttpUrlGetter) target)._$PINPOINT$_getHttpUrl();
        return getDestinationId(url);
    }
    return null;
}
 

private static void doInit(Context ctx,
                           @Nullable OauthBasicAuthCredentialsProvider oauthProvider,
                           HttpUrl uri) {
    Context appContext = ctx.getApplicationContext();
    SDKProvider sdkProvider = new SDKProvider(appContext, oauthProvider, uri);
    instance = new ParticleCloudSDK(sdkProvider);
}
 

private <T> ParameterizableRequest<T, AuthenticationException> delegation(Class<T> clazz) {
    HttpUrl url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
            .addPathSegment(DELEGATION_PATH)
            .build();

    final Map<String, Object> parameters = ParameterBuilder.newBuilder()
            .setClientId(getClientId())
            .setGrantType(ParameterBuilder.GRANT_TYPE_JWT)
            .asDictionary();

    return factory.POST(url, client, gson, clazz, authErrorBuilder)
            .addParameters(parameters);
}
 

/**
 * Start a custom passwordless flow
 *
 * @return a request to configure and start
 */
@SuppressWarnings("WeakerAccess")
private ParameterizableRequest<Void, AuthenticationException> passwordless() {
    HttpUrl url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
            .addPathSegment(PASSWORDLESS_PATH)
            .addPathSegment(START_PATH)
            .build();

    final Map<String, Object> parameters = ParameterBuilder.newBuilder()
            .setClientId(getClientId())
            .asDictionary();

    return factory.POST(url, client, gson, authErrorBuilder)
            .addParameters(parameters);
}
 

/**
 * Creates a new Request to obtain the JSON Web Keys associated with the Auth0 account under the given domain.
 * Only supports RSA keys used for signatures (Public Keys).
 *
 * @return a request to obtain the JSON Web Keys associated with this Auth0 account.
 */
public Request<Map<String, PublicKey>, AuthenticationException> fetchJsonWebKeys() {
    HttpUrl url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
            .addPathSegment(WELL_KNOWN_PATH)
            .addPathSegment(JWKS_FILE_PATH)
            .build();
    TypeToken<Map<String, PublicKey>> jwksType = new TypeToken<Map<String, PublicKey>>() {
    };
    return factory.GET(url, client, gson, jwksType, authErrorBuilder);
}
 

private AuthenticationRequest loginWithToken(Map<String, Object> parameters) {
    HttpUrl url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
            .addPathSegment(OAUTH_PATH)
            .addPathSegment(TOKEN_PATH)
            .build();

    final Map<String, Object> requestParameters = ParameterBuilder.newBuilder()
            .setClientId(getClientId())
            .addAll(parameters)
            .asDictionary();
    return factory.authenticationPOST(url, client, gson)
            .addAuthenticationParameters(requestParameters);
}
 

private ParameterizableRequest<UserProfile, AuthenticationException> profileRequest() {
    HttpUrl url = HttpUrl.parse(auth0.getDomainUrl()).newBuilder()
            .addPathSegment(USER_INFO_PATH)
            .build();

    return factory.GET(url, client, gson, UserProfile.class, authErrorBuilder);
}
 

@Test
public void shouldHandleEUInstance() {
    Auth0 auth0 = new Auth0(CLIENT_ID, EU_DOMAIN);
    assertThat(auth0.getClientId(), equalTo(CLIENT_ID));
    assertThat(HttpUrl.parse(auth0.getDomainUrl()), equalTo(HttpUrl.parse("https://samples.eu.auth0.com")));
    assertThat(HttpUrl.parse(auth0.getConfigurationUrl()), equalTo(HttpUrl.parse("https://cdn.eu.auth0.com")));
}
 

@Test
public void shouldReturnLogoutUrl() {
    Auth0 auth0 = new Auth0(CLIENT_ID, DOMAIN);

    final HttpUrl url = HttpUrl.parse(auth0.getLogoutUrl());
    assertThat(url, hasScheme("https"));
    assertThat(url, hasHost(DOMAIN));
    assertThat(url, hasPath("v2", "logout"));
}
 

private HttpUrl ensureValidUrl(String url) {
    if (url == null) {
        return null;
    }
    String safeUrl = url.startsWith("http") ? url : "https://" + url;
    return HttpUrl.parse(safeUrl);
}
 

public MockAuthenticationRequest(HttpUrl url, OkHttpClient client, Gson gson, String method) {
    this.headers = new HashMap<>();
    this.url = url;
    this.client = client;
    this.gson = gson;
    this.method = method;
}
 

@BeforeMethod
public final void setUp() throws Exception {
    mockWebServer = new MockWebServer();
    HttpUrl serverUrl = mockWebServer.url("/");

    // Override factory endpoint
    getProxy().setHost(serverUrl.host());
    getProxy().setPort(serverUrl.port());
}
 

@Before
public void setUp() throws Exception {
    mockAPI = new AuthenticationAPI();
    gson = GsonProvider.buildGson();
    HttpUrl url = HttpUrl.parse(mockAPI.getDomain())
            .newBuilder()
            .addPathSegment(OAUTH_PATH)
            .addPathSegment(RESOURCE_OWNER_PATH)
            .build();
    request = createRequest(url);
}