HttpClientTest.java

package com.stripe.net;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.withSettings;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.stripe.BaseStripeTest;
import com.stripe.Stripe;
import com.stripe.exception.ApiConnectionException;
import com.stripe.exception.StripeException;
import java.net.ConnectException;
import java.net.SocketTimeoutException;
import java.util.Collections;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

public class HttpClientTest extends BaseStripeTest {
  private HttpClient client;

  private StripeRequest request;

  private HttpHeaders emptyHeaders = HttpHeaders.of(Collections.emptyMap());

  @BeforeEach
  public void setUpFixtures() throws StripeException {
    this.client =
        Mockito.mock(
            HttpClient.class,
            withSettings().useConstructor().defaultAnswer(Mockito.CALLS_REAL_METHODS));
    this.client.networkRetriesSleep = false;

    this.request =
        StripeRequest.create(
            ApiResource.RequestMethod.GET,
            "http://example.com/get",
            null,
            RequestOptions.builder().setApiKey("sk_test_123").setMaxNetworkRetries(2).build(),
            ApiMode.V1);
  }

  @Test
  public void testRequestWithRetriesConnectException() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenThrow(new ApiConnectionException("foo", new ConnectException("timeout or something")))
        .thenReturn(new StripeResponse(200, emptyHeaders, "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(200, response.code());
    assertEquals(1, response.numRetries());
  }

  @Test
  public void testRequestWithRetriesConnectExceptionRethrowAfterAllAttempts()
      throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenThrow(new ApiConnectionException("1", new ConnectException("timeout 1")))
        .thenThrow(new ApiConnectionException("2", new ConnectException("timeout 2")))
        .thenThrow(new ApiConnectionException("3", new ConnectException("timeout 3")));

    ApiConnectionException e =
        assertThrows(
            ApiConnectionException.class,
            () -> {
              this.client.requestWithRetries(this.request);
            });
    assertEquals("3", e.getMessage());
    assertNotNull(e.getCause());
    assertTrue(e.getCause() instanceof ConnectException);
    assertEquals("timeout 3", e.getCause().getMessage());
  }

  @Test
  public void testRequestWithRetriesSocketTimeoutException() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenThrow(
            new ApiConnectionException("foo", new SocketTimeoutException("timeout or something")))
        .thenReturn(new StripeResponse(200, emptyHeaders, "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(200, response.code());
    assertEquals(1, response.numRetries());
  }

  @Test
  public void testRequestWithRetriesSocketTimeoutExceptionRethrowAfterAllAttempts()
      throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenThrow(new ApiConnectionException("1", new SocketTimeoutException("timeout 1")))
        .thenThrow(new ApiConnectionException("2", new SocketTimeoutException("timeout 2")))
        .thenThrow(new ApiConnectionException("3", new SocketTimeoutException("timeout 3")));

    ApiConnectionException e =
        assertThrows(
            ApiConnectionException.class,
            () -> {
              this.client.requestWithRetries(this.request);
            });
    assertEquals("3", e.getMessage());
    assertNotNull(e.getCause());
    assertTrue(e.getCause() instanceof SocketTimeoutException);
    assertEquals("timeout 3", e.getCause().getMessage());
  }

  @Test
  public void testRequestWithRetriesStripeShouldRetryTrue() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenReturn(
            new StripeResponse(
                400,
                HttpHeaders.of(ImmutableMap.of("Stripe-Should-Retry", ImmutableList.of("true"))),
                "{}"))
        .thenReturn(new StripeResponse(200, emptyHeaders, "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(200, response.code());
    assertEquals(1, response.numRetries());
  }

  @Test
  public void testRequestWithRetriesStripeShouldRetryFalse() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenReturn(
            new StripeResponse(
                400,
                HttpHeaders.of(ImmutableMap.of("Stripe-Should-Retry", ImmutableList.of("false"))),
                "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(400, response.code());
    assertEquals(0, response.numRetries());
  }

  @Test
  public void testRequestWithRetriesConflict() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenReturn(new StripeResponse(409, emptyHeaders, "{}"))
        .thenReturn(new StripeResponse(200, emptyHeaders, "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(200, response.code());
    assertEquals(1, response.numRetries());
  }

  @Test
  public void testRequestWithRetriesConflictServiceUnavailable() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenReturn(new StripeResponse(503, emptyHeaders, "{}"))
        .thenReturn(new StripeResponse(200, emptyHeaders, "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(200, response.code());
    assertEquals(1, response.numRetries());
  }

  @Test
  public void testRequestWithRetriesConflictInternalServerError() throws StripeException {
    Mockito.when(this.client.request(this.request))
        .thenReturn(new StripeResponse(500, emptyHeaders, "{}"))
        .thenReturn(new StripeResponse(200, emptyHeaders, "{}"));

    StripeResponse response = this.client.requestWithRetries(this.request);

    assertNotNull(response);
    assertEquals(200, response.code());
    assertEquals(1, response.numRetries());
  }

  @Test
  public void testV1RequestSetsCorrectUserAgent() throws StripeException {
    StripeRequest request =
        StripeRequest.create(
            ApiResource.RequestMethod.GET,
            "http://example.com/get",
            null,
            RequestOptions.builder().setApiKey("sk_test_123").setMaxNetworkRetries(2).build(),
            ApiMode.V1);

    String userAgent = HttpClient.buildUserAgentString(request);
    assertTrue(userAgent.startsWith(String.format("Stripe/v1 JavaBindings/%s", Stripe.VERSION)));
  }

  @Test
  public void testV2RequestSetsCorrectUserAgent() throws StripeException {
    StripeRequest request =
        StripeRequest.create(
            ApiResource.RequestMethod.GET,
            "http://example.com/get",
            null,
            RequestOptions.builder().setApiKey("sk_test_123").setMaxNetworkRetries(2).build(),
            ApiMode.V2);

    String userAgent = HttpClient.buildUserAgentString(request);
    assertTrue(userAgent.startsWith(String.format("Stripe/v2 JavaBindings/%s", Stripe.VERSION)));
  }

  @Test
  public void testDetectAIAgent() {
    String agent = HttpClient.detectAIAgent(key -> key.equals("CLAUDECODE") ? "1" : null);
    assertEquals("claude_code", agent);
  }

  @Test
  public void testDetectAIAgentNoEnv() {
    String agent = HttpClient.detectAIAgent(key -> null);
    assertEquals("", agent);
  }

  @Test
  public void testDetectAIAgentFirstMatchWins() {
    String agent =
        HttpClient.detectAIAgent(
            key -> {
              if (key.equals("CURSOR_AGENT") || key.equals("OPENCODE")) return "1";
              return null;
            });
    assertEquals("cursor", agent);
  }

  @Test
  public void testBuildUserAgentStringWithAIAgent() throws StripeException {
    StripeRequest request =
        StripeRequest.create(
            ApiResource.RequestMethod.GET,
            "http://example.com/get",
            null,
            RequestOptions.builder().setApiKey("sk_test_123").build(),
            ApiMode.V1);

    String userAgent = HttpClient.buildUserAgentString(request, "cursor");
    assertTrue(userAgent.contains("AIAgent/cursor"));
  }

  @Test
  public void testBuildXStripeClientUserAgentStringWithAIAgent() {
    String json = HttpClient.buildXStripeClientUserAgentString("cursor");
    com.google.gson.JsonObject parsed =
        com.google.gson.JsonParser.parseString(json).getAsJsonObject();
    assertEquals("cursor", parsed.get("ai_agent").getAsString());
  }

  @Test
  public void testBuildXStripeClientUserAgentStringOmitsPublisherAndOsKeys() {
    String json = HttpClient.buildXStripeClientUserAgentString("");
    com.google.gson.JsonObject parsed =
        com.google.gson.JsonParser.parseString(json).getAsJsonObject();
    assertTrue(!parsed.has("publisher"));
    assertTrue(!parsed.has("os.name"));
    assertTrue(!parsed.has("os.version"));
    assertTrue(!parsed.has("os.arch"));
  }

  @Test
  public void testBuildXStripeClientUserAgentStringPlatformWithTelemetry() {
    boolean originalTelemetry = Stripe.enableTelemetry;
    try {
      Stripe.enableTelemetry = true;
      String json = HttpClient.buildXStripeClientUserAgentString("");
      com.google.gson.JsonObject parsed =
          com.google.gson.JsonParser.parseString(json).getAsJsonObject();
      assertTrue(parsed.has("platform"));
      String platform = parsed.get("platform").getAsString();
      assertTrue(platform.contains(System.getProperty("os.name")));
    } finally {
      Stripe.enableTelemetry = originalTelemetry;
    }
  }

  @Test
  public void testBuildXStripeClientUserAgentStringNoPlatformWithoutTelemetry() {
    boolean originalTelemetry = Stripe.enableTelemetry;
    try {
      Stripe.enableTelemetry = false;
      String json = HttpClient.buildXStripeClientUserAgentString("");
      com.google.gson.JsonObject parsed =
          com.google.gson.JsonParser.parseString(json).getAsJsonObject();
      assertTrue(!parsed.has("platform"));
    } finally {
      Stripe.enableTelemetry = originalTelemetry;
    }
  }

  @Test
  public void testBuildXStripeClientUserAgentStringIncludesSource() {
    String json = HttpClient.buildXStripeClientUserAgentString("");
    com.google.gson.JsonObject parsed =
        com.google.gson.JsonParser.parseString(json).getAsJsonObject();
    // "source" should be present and be a 32-character lowercase MD5 hex digest
    assertTrue(parsed.has("source"), "Expected 'source' field in X-Stripe-Client-User-Agent");
    String source = parsed.get("source").getAsString();
    assertTrue(
        source.matches("[0-9a-f]{32}"),
        "Expected 'source' to be a 32-character lowercase hex string, got: " + source);
  }

  @Test
  public void testBuildXStripeClientUserAgentStringOmitsSourceWhenEmpty() throws Exception {
    String savedHash = HttpClient.UNAME_HASH;
    try {
      HttpClient.UNAME_HASH = "";
      String userAgentString = HttpClient.buildXStripeClientUserAgentString("");
      com.google.gson.JsonObject userAgent =
          com.google.gson.JsonParser.parseString(userAgentString).getAsJsonObject();
      assertFalse(userAgent.has("source"));
    } finally {
      HttpClient.UNAME_HASH = savedHash;
    }
  }
}