• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

box / box-java-sdk / #7745

18 Nov 2026 05:48PM UTC coverage: 33.823% (+0.2%) from 33.622%
#7745

push

github

web-flow
chore: release version 10.22.0

1 of 1 new or added line in 1 file covered. (100.0%)

136 existing lines in 6 files now uncovered.

21964 of 64938 relevant lines covered (33.82%)

0.34 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.99
/src/main/java/com/box/sdkgen/networking/boxnetworkclient/BoxNetworkClient.java
1
package com.box.sdkgen.networking.boxnetworkclient;
2

3
import static com.box.sdkgen.box.BoxConstants.USER_AGENT_HEADER;
4
import static com.box.sdkgen.box.BoxConstants.X_BOX_UA_HEADER;
5
import static com.box.sdkgen.internal.utils.UtilsManager.readByteStream;
6
import static com.box.sdkgen.serialization.json.JsonManager.jsonToSerializedData;
7
import static com.box.sdkgen.serialization.json.JsonManager.sdToJson;
8
import static com.box.sdkgen.serialization.json.JsonManager.sdToUrlParams;
9
import static java.util.Collections.singletonList;
10
import static okhttp3.ConnectionSpec.MODERN_TLS;
11

12
import com.box.sdkgen.box.errors.BoxAPIError;
13
import com.box.sdkgen.box.errors.BoxSDKError;
14
import com.box.sdkgen.internal.logging.DataSanitizer;
15
import com.box.sdkgen.networking.fetchoptions.FetchOptions;
16
import com.box.sdkgen.networking.fetchoptions.MultipartItem;
17
import com.box.sdkgen.networking.fetchoptions.ResponseFormat;
18
import com.box.sdkgen.networking.fetchresponse.FetchResponse;
19
import com.box.sdkgen.networking.inputstreamrequestbody.InputStreamRequestBody;
20
import com.box.sdkgen.networking.network.NetworkSession;
21
import com.box.sdkgen.networking.networkclient.NetworkClient;
22
import com.box.sdkgen.networking.proxyconfig.ProxyConfig;
23
import com.box.sdkgen.networking.timeoutconfig.TimeoutConfig;
24
import com.fasterxml.jackson.databind.JsonNode;
25
import java.io.IOException;
26
import java.io.InputStream;
27
import java.net.InetSocketAddress;
28
import java.net.Proxy;
29
import java.net.URI;
30
import java.nio.charset.StandardCharsets;
31
import java.util.Locale;
32
import java.util.Map;
33
import java.util.Objects;
34
import java.util.Optional;
35
import java.util.TreeMap;
36
import java.util.concurrent.TimeUnit;
37
import java.util.stream.Collectors;
38
import okhttp3.Call;
39
import okhttp3.Credentials;
40
import okhttp3.Headers;
41
import okhttp3.HttpUrl;
42
import okhttp3.MediaType;
43
import okhttp3.MultipartBody;
44
import okhttp3.OkHttpClient;
45
import okhttp3.Request;
46
import okhttp3.RequestBody;
47
import okhttp3.Response;
48

49
public class BoxNetworkClient implements NetworkClient {
50

51
  private static final int BASE_TIMEOUT = 1;
52
  private static final double RANDOM_FACTOR = 0.5;
53
  private static final int DEFAULT_HTTP_PORT = 80;
54
  private static final int DEFAULT_HTTPS_PORT = 443;
55

56
  protected OkHttpClient httpClient;
57

58
  public BoxNetworkClient(OkHttpClient httpClient) {
1 ✔
59
    this.httpClient = httpClient;
1 ✔
60
  }
1 ✔
61

62
  public BoxNetworkClient() {
1 ✔
63
    httpClient = getDefaultOkHttpClientBuilder().build();
1 ✔
64
  }
1 ✔
65

66
  public OkHttpClient getHttpClient() {
UNCOV
67
    return httpClient;
×
68
  }
69

70
  public BoxNetworkClient withProxy(ProxyConfig config) {
UNCOV
71
    URI uri = URI.create(config.getUrl());
×
72
    String host = Objects.requireNonNull(uri.getHost(), "Invalid Proxy URL");
×
73

UNCOV
74
    String scheme =
×
75
        Optional.ofNullable(uri.getScheme())
×
76
            .filter(schema -> schema.startsWith("http"))
×
77
            .orElseThrow(() -> new IllegalArgumentException("Invalid Proxy URL: " + uri));
×
78

UNCOV
79
    int port =
×
UNCOV
80
        (uri.getPort() != -1)
×
81
            ? uri.getPort()
×
82
            : ("https".equalsIgnoreCase(scheme) ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT);
×
83

UNCOV
84
    OkHttpClient.Builder clientBuilder =
×
85
        httpClient
UNCOV
86
            .newBuilder()
×
87
            .proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress(host, port)));
×
88

UNCOV
89
    String username = config.getUsername();
×
90
    String password = config.getPassword();
×
91
    if (username != null && !username.trim().isEmpty() && password != null) {
×
92
      String basic = Credentials.basic(username, password, StandardCharsets.UTF_8);
×
93
      clientBuilder.proxyAuthenticator(
×
94
          (route, resp) ->
UNCOV
95
              resp.request().newBuilder().header("Proxy-Authorization", basic).build());
×
96
    }
UNCOV
97
    return new BoxNetworkClient(clientBuilder.build());
×
98
  }
99

100
  public BoxNetworkClient withTimeoutConfig(TimeoutConfig config) {
101
    if (config == null) {
1 ✔
UNCOV
102
      throw new IllegalArgumentException("TimeoutConfig cannot be null");
×
103
    }
104

105
    OkHttpClient.Builder clientBuilder = httpClient.newBuilder();
1 ✔
106

107
    Long connectionTimeoutMs = config.getConnectionTimeoutMs();
1 ✔
108
    if (connectionTimeoutMs != null) {
1 ✔
109
      if (connectionTimeoutMs < 0) {
1 ✔
UNCOV
110
        throw new IllegalArgumentException("connectionTimeoutMs cannot be negative");
×
111
      }
112
      clientBuilder.connectTimeout(connectionTimeoutMs.longValue(), TimeUnit.MILLISECONDS);
1 ✔
113
    }
114

115
    Long readTimeoutMs = config.getReadTimeoutMs();
1 ✔
116
    if (readTimeoutMs != null) {
1 ✔
117
      if (readTimeoutMs < 0) {
1 ✔
UNCOV
118
        throw new IllegalArgumentException("readTimeoutMs cannot be negative");
×
119
      }
120
      clientBuilder.readTimeout(readTimeoutMs.longValue(), TimeUnit.MILLISECONDS);
1 ✔
121
    }
122

123
    Long requestTimeoutMs = config.getRequestTimeoutMs();
1 ✔
124
    if (requestTimeoutMs != null) {
1 ✔
125
      if (requestTimeoutMs < 0) {
1 ✔
UNCOV
126
        throw new IllegalArgumentException("requestTimeoutMs cannot be negative");
×
127
      }
128
      clientBuilder.callTimeout(requestTimeoutMs.longValue(), TimeUnit.MILLISECONDS);
1 ✔
129
    }
130
    return new BoxNetworkClient(clientBuilder.build());
1 ✔
131
  }
132

133
  public FetchResponse fetch(FetchOptions options) {
134
    try {
135
      return fetchWithRetries(options);
1 ✔
136
    } finally {
137
      closeFileStreams(options);
1 ✔
138
    }
139
  }
140

141
  private FetchResponse fetchWithRetries(FetchOptions options) {
142
    NetworkSession networkSession =
1 ✔
143
        options.getNetworkSession() == null ? new NetworkSession() : options.getNetworkSession();
1 ✔
144

145
    boolean authenticationNeeded = false;
1 ✔
146
    Request request;
147
    RequestBody body = null;
1 ✔
148
    FetchResponse fetchResponse = new FetchResponse.Builder(0, new TreeMap<>()).build();
1 ✔
149
    Exception exceptionThrown = null;
1 ✔
150

151
    int attemptNumber = 1;
1 ✔
152
    int numberOfRetriesOnException = 0;
1 ✔
153
    int attemptForRetry = 0;
1 ✔
154
    boolean shouldRetry = false;
1 ✔
155

156
    while (true) {
157
      boolean isFirstAttempt = attemptNumber == 1 && numberOfRetriesOnException == 0;
1 ✔
158
      FetchOptions fetchOptions = applyInterceptors(options, networkSession);
1 ✔
159
      if (fetchOptions.getDataFactory() != null
1 ✔
160
          && (!isFirstAttempt || fetchOptions.getData() == null)) {
1 ✔
161
        fetchOptions = withData(fetchOptions, fetchOptions.getDataFactory().create());
1 ✔
162
      }
163

164
      if (isFirstAttempt || !containsFileStream(fetchOptions)) {
1 ✔
165
        body = prepareRequestBody(fetchOptions);
1 ✔
166
      }
167
      request = prepareRequest(fetchOptions, body, authenticationNeeded, networkSession);
1 ✔
168

169
      Response response = null;
1 ✔
170
      String rawResponseBody = null;
1 ✔
171

172
      try {
173
        response = executeOnClient(request);
1 ✔
174

175
        Map<String, String> headersMap =
1 ✔
176
            response.headers().toMultimap().entrySet().stream()
1 ✔
177
                .collect(
1 ✔
178
                    Collectors.toMap(
1 ✔
179
                        Map.Entry::getKey,
180
                        e -> e.getValue().get(0),
1 ✔
UNCOV
181
                        (existing, replacement) -> existing,
×
182
                        () -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER)));
1 ✔
183

184
        String responseUrl =
1 ✔
185
            response.networkResponse() != null
1 ✔
186
                ? response.networkResponse().request().url().toString()
1 ✔
187
                : response.request().url().toString();
1 ✔
188

189
        attemptForRetry = attemptNumber;
1 ✔
190

191
        if (Objects.equals(
1 ✔
192
            fetchOptions.getResponseFormat().getEnumValue(), ResponseFormat.BINARY)) {
1 ✔
193
          fetchResponse =
1 ✔
194
              new FetchResponse.Builder(response.code(), headersMap)
1 ✔
195
                  .content(response.body().byteStream())
1 ✔
196
                  .url(responseUrl)
1 ✔
197
                  .build();
1 ✔
198
        } else {
199
          rawResponseBody = response.body() != null ? response.body().string() : null;
1 ✔
200
          fetchResponse =
1 ✔
201
              new FetchResponse.Builder(response.code(), headersMap)
1 ✔
202
                  .data(readJsonFromRawBody(rawResponseBody))
1 ✔
203
                  .url(responseUrl)
1 ✔
204
                  .build();
1 ✔
205
        }
206

207
        fetchResponse =
1 ✔
208
            networkSession.getInterceptors().stream()
1 ✔
209
                .reduce(
1 ✔
210
                    fetchResponse,
211
                    (modifiedResponse, interceptor) -> interceptor.afterRequest(modifiedResponse),
1 ✔
UNCOV
212
                    (o1, o2) -> o2);
×
213

214
      } catch (Exception e) {
1 ✔
215
        exceptionThrown = e;
1 ✔
216
        numberOfRetriesOnException++;
1 ✔
217
        attemptForRetry = numberOfRetriesOnException;
1 ✔
218
        fetchResponse = new FetchResponse.Builder(0, new TreeMap<>()).build();
1 ✔
219
        rawResponseBody = null;
1 ✔
220
        if (response != null) {
1 ✔
UNCOV
221
          response.close();
×
222
        }
223
      }
1 ✔
224

225
      shouldRetry =
1 ✔
226
          networkSession
227
              .getRetryStrategy()
1 ✔
228
              .shouldRetry(fetchOptions, fetchResponse, attemptForRetry);
1 ✔
229
      boolean isRetryable = canBeResent(body);
1 ✔
230

231
      if (shouldRetry && isRetryable) {
1 ✔
232
        double retryDelay =
1 ✔
233
            networkSession
234
                .getRetryStrategy()
1 ✔
235
                .retryAfter(fetchOptions, fetchResponse, attemptForRetry);
1 ✔
236
        if (retryDelay > 0) {
1 ✔
237
          try {
238
            TimeUnit.SECONDS.sleep((long) retryDelay);
1 ✔
UNCOV
239
          } catch (InterruptedException ie) {
×
UNCOV
240
            Thread.currentThread().interrupt();
×
UNCOV
241
            throw new BoxSDKError("Retry interrupted", ie);
×
242
          }
1 ✔
243
        }
244
        attemptNumber++;
1 ✔
245
        continue;
1 ✔
246
      }
247

248
      if (fetchResponse.getStatus() >= 300
1 ✔
249
          && fetchResponse.getStatus() < 400
1 ✔
250
          && fetchOptions.followRedirects) {
1 ✔
251
        if (!fetchResponse.getHeaders().containsKey("Location")) {
1 ✔
252
          throw new BoxSDKError(
1 ✔
253
              "Redirect response missing Location header for " + fetchOptions.getUrl());
1 ✔
254
        }
255
        URI originalUri = URI.create(fetchOptions.getUrl());
1 ✔
256
        URI redirectUri = URI.create(fetchResponse.getHeaders().get("Location"));
1 ✔
257
        boolean sameOrigin =
1 ✔
258
            originalUri.getHost().equals(redirectUri.getHost())
1 ✔
UNCOV
259
                && originalUri.getPort() == redirectUri.getPort()
×
260
                && originalUri.getScheme().equals(redirectUri.getScheme());
1 ✔
261
        return fetch(
1 ✔
262
            new FetchOptions.Builder(fetchResponse.getHeaders().get("Location"), "GET")
1 ✔
263
                .responseFormat(fetchOptions.getResponseFormat())
1 ✔
264
                .auth(sameOrigin ? fetchOptions.getAuth() : null)
1 ✔
265
                .networkSession(networkSession)
1 ✔
266
                .build());
1 ✔
267
      }
268

269
      if (fetchResponse.getStatus() >= 200 && fetchResponse.getStatus() < 400) {
1 ✔
270
        return fetchResponse;
1 ✔
271
      }
272

273
      throwOnUnsuccessfulResponse(
1 ✔
274
          request,
275
          fetchResponse,
276
          rawResponseBody,
277
          exceptionThrown,
278
          fetchOptions.getContentType(),
1 ✔
279
          networkSession.getDataSanitizer());
1 ✔
UNCOV
280
    }
×
281
  }
282

283
  private static FetchOptions applyInterceptors(
284
      FetchOptions options, NetworkSession networkSession) {
285
    return networkSession.getInterceptors().stream()
1 ✔
286
        .reduce(
1 ✔
287
            options,
288
            (modifiedOptions, interceptor) -> interceptor.beforeRequest(modifiedOptions),
1 ✔
UNCOV
289
            (o1, o2) -> o2);
×
290
  }
291

292
  private static FetchOptions withData(FetchOptions options, JsonNode data) {
293
    return new FetchOptions.Builder(options.getUrl(), options.getMethod())
1 ✔
294
        .params(options.getParams())
1 ✔
295
        .headers(options.getHeaders())
1 ✔
296
        .data(data)
1 ✔
297
        .dataFactory(options.getDataFactory())
1 ✔
298
        .fileStream(options.getFileStream())
1 ✔
299
        .multipartData(options.getMultipartData())
1 ✔
300
        .contentType(options.getContentType())
1 ✔
301
        .responseFormat(options.getResponseFormat())
1 ✔
302
        .auth(options.getAuth())
1 ✔
303
        .networkSession(options.getNetworkSession())
1 ✔
304
        .followRedirects(options.getFollowRedirects())
1 ✔
305
        .build();
1 ✔
306
  }
307

308
  private static Request prepareRequest(
309
      FetchOptions options,
310
      RequestBody body,
311
      boolean reauthenticate,
312
      NetworkSession networkSession) {
313
    Request.Builder requestBuilder = new Request.Builder().url(options.getUrl());
1 ✔
314
    Headers headers = prepareHeaders(options, reauthenticate, networkSession);
1 ✔
315
    HttpUrl url = prepareUrl(options);
1 ✔
316

317
    requestBuilder.headers(headers);
1 ✔
318
    requestBuilder.url(url);
1 ✔
319
    requestBuilder.method(options.getMethod().toUpperCase(Locale.ROOT), body);
1 ✔
320
    return requestBuilder.build();
1 ✔
321
  }
322

323
  private static Headers prepareHeaders(
324
      FetchOptions options, boolean reauthenticate, NetworkSession networkSession) {
325
    Headers.Builder headersBuilder = new Headers.Builder();
1 ✔
326

327
    networkSession.getAdditionalHeaders().forEach(headersBuilder::add);
1 ✔
328

329
    if (options.getHeaders() != null) {
1 ✔
330
      options.getHeaders().forEach(headersBuilder::add);
1 ✔
331
    }
332
    if (options.getAuth() != null) {
1 ✔
333
      if (reauthenticate) {
1 ✔
UNCOV
334
        options.getAuth().refreshToken(networkSession);
×
335
      }
336
      headersBuilder.add(
1 ✔
337
          "Authorization", options.getAuth().retrieveAuthorizationHeader(networkSession));
1 ✔
338
    }
339
    headersBuilder.add("User-Agent", USER_AGENT_HEADER);
1 ✔
340
    headersBuilder.add("X-Box-UA", X_BOX_UA_HEADER);
1 ✔
341
    return headersBuilder.build();
1 ✔
342
  }
343

344
  private static HttpUrl prepareUrl(FetchOptions options) {
345

346
    HttpUrl baseUrl = HttpUrl.parse(options.getUrl());
1 ✔
347
    if (baseUrl == null) {
1 ✔
UNCOV
348
      throw new IllegalArgumentException("Invalid URL " + options.getUrl());
×
349
    }
350
    HttpUrl.Builder urlBuilder = baseUrl.newBuilder();
1 ✔
351
    if (options.getParams() != null) {
1 ✔
352
      options.getParams().forEach(urlBuilder::addQueryParameter);
1 ✔
353
    }
354
    return urlBuilder.build();
1 ✔
355
  }
356

357
  private static RequestBody prepareRequestBody(FetchOptions options) {
358
    if (options.getMethod().equalsIgnoreCase("GET")) {
1 ✔
359
      return null;
1 ✔
360
    }
361
    String contentType = options.getContentType();
1 ✔
362
    MediaType mediaType = MediaType.parse(contentType);
1 ✔
363
    switch (contentType) {
1 ✔
364
      case "application/json":
365
      case "application/json-patch+json":
366
        return options.getData() != null
1 ✔
367
            ? RequestBody.create(sdToJson(options.getData()), mediaType)
1 ✔
368
            : RequestBody.create("", mediaType);
1 ✔
369
      case "application/x-www-form-urlencoded":
370
        return options.getData() != null
1 ✔
371
            ? RequestBody.create(sdToUrlParams(options.getData()), mediaType)
1 ✔
UNCOV
372
            : RequestBody.create("", mediaType);
×
373
      case "multipart/form-data":
374
        MultipartBody.Builder bodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
1 ✔
375
        for (MultipartItem part : options.multipartData) {
1 ✔
376
          if (part.getData() != null) {
1 ✔
377
            bodyBuilder.addFormDataPart(part.getPartName(), sdToJson(part.getData()));
1 ✔
378
          } else {
379
            bodyBuilder.addFormDataPart(
1 ✔
380
                part.getPartName(),
1 ✔
381
                part.getFileName() != null ? part.getFileName() : "file",
1 ✔
382
                createMultipartRequestBody(part));
1 ✔
383
          }
384
        }
1 ✔
385
        return bodyBuilder.build();
1 ✔
386
      case "application/octet-stream":
387
        return RequestBody.create(readByteStream(options.getFileStream()), mediaType);
1 ✔
388
      default:
UNCOV
389
        throw new IllegalArgumentException("Unsupported content type " + contentType);
×
390
    }
391
  }
392

393
  protected Call createNewCall(Request request) {
394
    return this.httpClient.newCall(request);
1 ✔
395
  }
396

397
  private Response executeOnClient(Request request) throws IOException {
398
    return createNewCall(request).execute();
1 ✔
399
  }
400

401
  private static JsonNode readJsonFromRawBody(String rawResponseBody) {
402
    if (rawResponseBody == null) {
1 ✔
403
      return null;
×
404
    }
405

406
    try {
407
      return jsonToSerializedData(rawResponseBody);
1 ✔
408
    } catch (Exception e) {
1 ✔
409
      return null;
1 ✔
410
    }
411
  }
412

413
  private static void throwOnUnsuccessfulResponse(
414
      Request request,
415
      FetchResponse fetchResponse,
416
      String rawResponseBody,
417
      Exception exceptionThrown,
418
      String contentType,
419
      DataSanitizer dataSanitizer) {
420
    if (fetchResponse.getStatus() == 0 && exceptionThrown != null) {
1 ✔
421
      throw new BoxSDKError(exceptionThrown.getMessage(), exceptionThrown);
1 ✔
422
    }
423
    try {
424
      throw BoxAPIError.fromAPICall(
1 ✔
425
          request, fetchResponse, rawResponseBody, dataSanitizer, contentType);
426
    } finally {
427
      try {
428
        if (fetchResponse.getContent() != null) {
1 ✔
429
          fetchResponse.getContent().close();
1 ✔
430
        }
UNCOV
431
      } catch (IOException ignored) {
×
432
      }
1 ✔
433
    }
434
  }
435

436
  private static int getRetryAfterTimeInSeconds(int attemptNumber, String retryAfterHeader) {
437

UNCOV
438
    if (retryAfterHeader != null) {
×
UNCOV
439
      return Integer.parseInt(retryAfterHeader);
×
440
    }
441

UNCOV
442
    double minWindow = 1 - RANDOM_FACTOR;
×
UNCOV
443
    double maxWindow = 1 + RANDOM_FACTOR;
×
UNCOV
444
    double jitter = (Math.random() * (maxWindow - minWindow)) + minWindow;
×
UNCOV
445
    return (int) (Math.pow(2, attemptNumber) * BASE_TIMEOUT * jitter);
×
446
  }
447

448
  /**
449
   * Returns whether the request body reads a file stream. Such a body is built once and reused on
450
   * retries, because rebuilding it would read the stream from where the previous attempt stopped.
451
   */
452
  private static boolean containsFileStream(FetchOptions options) {
453
    return options.getFileStream() != null
1 ✔
454
        || (options.getMultipartData() != null
1 ✔
455
            && options.getMultipartData().stream().anyMatch(part -> part.getFileStream() != null));
1 ✔
456
  }
457

458
  private static void closeFileStreams(FetchOptions options) {
459
    if (options.getFileStream() != null) {
1 ✔
460
      closeQuietly(options.getFileStream());
1 ✔
461
    }
462
    if (options.getMultipartData() != null) {
1 ✔
463
      options.getMultipartData().stream()
1 ✔
464
          .map(MultipartItem::getFileStream)
1 ✔
465
          .filter(Objects::nonNull)
1 ✔
466
          .forEach(BoxNetworkClient::closeQuietly);
1 ✔
467
    }
468
  }
1 ✔
469

470
  /** A failure to close a stream must not replace the result or the error of the request. */
471
  private static void closeQuietly(InputStream stream) {
472
    try {
473
      stream.close();
1 ✔
UNCOV
474
    } catch (IOException ignored) {
×
475
    }
1 ✔
476
  }
1 ✔
477

478
  private static boolean canBeResent(RequestBody body) {
479
    if (body instanceof MultipartBody) {
1 ✔
480
      return ((MultipartBody) body).parts().stream().allMatch(part -> canBeResent(part.body()));
1 ✔
481
    }
482
    return !(body instanceof InputStreamRequestBody)
1 ✔
483
        || ((InputStreamRequestBody) body).canBeResent();
1 ✔
484
  }
485

486
  public static RequestBody createMultipartRequestBody(MultipartItem part) {
487
    MediaType contentType =
1 ✔
488
        MediaType.parse(part.contentType != null ? part.contentType : "application/octet-stream");
1 ✔
489
    return new InputStreamRequestBody(part.getFileStream(), contentType);
1 ✔
490
  }
491

492
  public static OkHttpClient.Builder getDefaultOkHttpClientBuilder() {
493
    return new OkHttpClient.Builder()
1 ✔
494
        .followSslRedirects(true)
1 ✔
495
        .followRedirects(false)
1 ✔
496
        .connectionSpecs(singletonList(MODERN_TLS))
1 ✔
497
        .retryOnConnectionFailure(false);
1 ✔
498
  }
499
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc