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;
}
 

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();
        }

    }
 

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();
}
 

@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")));
}
 

/**
 * 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);
}
 

@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 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;
}
 

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 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);
}
 

@Advice.OnMethodEnter(suppress = Throwable.class)
private static void onBeforeExecute(@Advice.FieldValue(value = "originalRequest", typing = Assigner.Typing.DYNAMIC, readOnly = false) @Nullable Object originalRequest,
                                    @Advice.Local("span") Span span) {

    if (tracer == null || tracer.getActive() == null) {
        return;
    }
    final AbstractSpan<?> parent = tracer.getActive();

    if (originalRequest == null) {
        return;
    }

    if (originalRequest instanceof com.squareup.okhttp.Request) {
        com.squareup.okhttp.Request request = (com.squareup.okhttp.Request) originalRequest;
        HttpUrl httpUrl = request.httpUrl();
        span = HttpClientHelper.startHttpClientSpan(parent, request.method(), httpUrl.toString(), httpUrl.scheme(),
            OkHttpClientHelper.computeHostName(httpUrl.host()), httpUrl.port());
        if (span != null) {
            span.activate();
            if (headerSetterHelperManager != null) {
                TextHeaderSetter<Request.Builder> headerSetter = headerSetterHelperManager.getForClassLoaderOfClass(Request.class);
                if (headerSetter != null) {
                    Request.Builder builder = ((com.squareup.okhttp.Request) originalRequest).newBuilder();
                    span.propagateTraceContext(builder, headerSetter);
                    originalRequest = builder.build();
                }
            }
        }
    }
}
 

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-gradle-plugin")
            .post(RequestBody.create(mediaType, content))
            .build();
}
 

private HttpUrl getUploadUrl(SwaggerHubRequest swaggerHubRequest) {
    return getBaseUrl(swaggerHubRequest.getOwner(), swaggerHubRequest.getApi())
            .addEncodedQueryParameter("version", swaggerHubRequest.getVersion())
            .addEncodedQueryParameter("isPrivate", Boolean.toString(swaggerHubRequest.isPrivate()))
            .addEncodedQueryParameter("oas", swaggerHubRequest.getOas())
            .build();
}
 

private HttpUrl.Builder getBaseUrl(String owner, String api) {
    return new HttpUrl.Builder()
            .scheme(protocol)
            .host(host)
            .port(port)
            .addPathSegment(APIS)
            .addEncodedPathSegment(owner)
            .addEncodedPathSegment(api);
}
 

@Test
public void testExport() throws Exception {
  server.enqueue(new MockResponse().setBody(CALENDARS_RESPONSE));
  server.enqueue(new MockResponse().setBody(CALENDAR1_EVENTS_RESPONSE));
  server.enqueue(new MockResponse().setBody(CALENDAR2_EVENTS_RESPONSE));

  server.start();

  HttpUrl baseUrl = server.url("");
  MicrosoftCalendarExporter exporter =
      new MicrosoftCalendarExporter(baseUrl.toString(), client, mapper, transformerService);

  ExportResult<CalendarContainerResource> resource = exporter
      .export(UUID.randomUUID(), token, Optional.empty());

  CalendarContainerResource calendarResource = resource.getExportedData();

  Assert.assertEquals(2, calendarResource.getCalendars().size());
  Assert.assertFalse(
      calendarResource
          .getCalendars()
          .stream()
          .anyMatch(c -> "Calendar1".equals(c.getId()) && "Calendar2".equals(c.getId())));

  Assert.assertEquals(2, calendarResource.getEvents().size());
  Assert.assertFalse(
      calendarResource
          .getEvents()
          .stream()
          .anyMatch(
              e ->
                  "Test Appointment 1".equals(e.getTitle())
                      && "Test Appointment 2".equals(e.getTitle())));
}
 

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;
}
 

@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")));
}
 

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();
}
 

private Request buildPutRequest(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")
            .put(RequestBody.create(mediaType, content))
            .build();
}
 

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

private HttpUrl getUploadUrl(SwaggerHubRequest swaggerHubRequest) {
    return getBaseUrl(swaggerHubRequest.getDefinitionType(), swaggerHubRequest.getOwner(), swaggerHubRequest.getApi())
            .addEncodedQueryParameter("version", swaggerHubRequest.getVersion())
            .addEncodedQueryParameter("isPrivate", Boolean.toString(swaggerHubRequest.isPrivate()))
            .addEncodedQueryParameter("oas", swaggerHubRequest.getOas())
            .build();
}
 

private HttpUrl getSaveIntegrationPluginConfigURL(SaveSCMPluginConfigRequest saveSCMPluginConfigRequest) {
    HttpUrl.Builder httpUrlBuilder = new HttpUrl.Builder()
            .scheme(protocol)
            .host(host)
            .port(port);
            return addOptionalPathSegment(httpUrlBuilder, basePath)
            .addPathSegment("plugins")
            .addPathSegment("configurations")
            .addEncodedPathSegment(saveSCMPluginConfigRequest.getOwner())
            .addEncodedPathSegment(saveSCMPluginConfigRequest.getApi())
            .addEncodedPathSegment(saveSCMPluginConfigRequest.getVersion())
            .addEncodedPathSegment(saveSCMPluginConfigRequest.getScmProvider())
            .addEncodedQueryParameter("oas", saveSCMPluginConfigRequest.getOas())
            .build();
}
 

@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")));
}
 

@Test
public void shouldNotSetConnectionOnNonLegacyEndpoints() {
    exception.expect(IllegalArgumentException.class);
    exception.expectMessage("method POST must have a request body.");
    //no body was sent

    HttpUrl url = HttpUrl.parse(mockAPI.getDomain())
            .newBuilder()
            .addPathSegment(OAUTH_PATH)
            .addPathSegment(TOKEN_PATH)
            .build();
    AuthenticationRequest req = createRequest(url);
    req.setConnection("my-connection")
            .execute();
}
 

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));
}
 

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);
}
 

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

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);
}