IntegrationPropertyTest.java

package com.github.mrbox.easyhttp.client.httpclient;

import com.github.mrbox.easyhttp.client.apache.PoolingHttpClientExecutor;
import com.github.tomakehurst.wiremock.WireMockServer;
import com.github.tomakehurst.wiremock.client.WireMock;
import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
import com.github.mrbox.easyhttp.config.HttpConfig;
import com.github.mrbox.easyhttp.core.HttpMethod;
import com.github.mrbox.easyhttp.core.HttpRequest;
import com.github.mrbox.easyhttp.core.HttpResponse;
import com.github.mrbox.easyhttp.core.RequestBodyType;
import net.jqwik.api.*;
import net.jqwik.api.constraints.IntRange;
import net.jqwik.api.constraints.NotBlank;
import net.jqwik.api.constraints.Size;
import net.jqwik.api.lifecycle.AfterProperty;
import net.jqwik.api.lifecycle.BeforeProperty;
import net.jqwik.api.lifecycle.BeforeTry;

import java.time.Duration;
import java.util.Arrays;

import static com.github.tomakehurst.wiremock.client.WireMock.*;
import static org.junit.Assert.*;

/**
 * 集成属性测试
 * <p>使用 WireMock 模拟 HTTP 服务器进行端到端测试
 *
 * @author Zwk
 */
public class IntegrationPropertyTest {

    private WireMockServer wireMockServer;
    private PoolingHttpClientExecutor executor;

    @BeforeProperty
    void setUp() {
        wireMockServer = new WireMockServer(WireMockConfiguration.options().dynamicPort());
        wireMockServer.start();
        WireMock.configureFor("localhost", wireMockServer.port());

        HttpConfig config = HttpConfig.builder()
                .connectTimeout(Duration.ofSeconds(5))
                .readTimeout(Duration.ofSeconds(10))
                .build();
        executor = new PoolingHttpClientExecutor(config);
    }

    @AfterProperty
    void tearDown() {
        if (executor != null) {
            executor.close();
        }
        if (wireMockServer != null) {
            wireMockServer.stop();
        }
    }

    @BeforeTry
    void resetStubs() {
        // Reset WireMock stubs before each try
        if (wireMockServer != null) {
            wireMockServer.resetAll();
        }
    }

    /**
     * Feature: http-executor-enhancement, Property 13: Backward Compatibility
     * Validates: Requirements 6.1, 6.2, 6.4
     *
     * For any HttpRequest built using only the original API (url, method, headers, body),
     * the execution behavior SHALL be identical to the original implementation.
     */
    @Property(tries = 100)
    void backwardCompatibility_getRequest(@ForAll @NotBlank @Size(max = 100) String responseBody) {
        // Setup mock server
        wireMockServer.stubFor(get(urlEqualTo("/test"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody(responseBody)));

        // Build request using original API only
        HttpRequest request = HttpRequest.builder()
                .url(baseUrl() + "/test")
                .method(HttpMethod.GET)
                .build();

        // Verify original behavior
        assertEquals("Should default to NONE body type", RequestBodyType.NONE, request.getBodyType());
        assertTrue("QueryParams should be empty", request.getQueryParams().isEmpty());
        assertTrue("FormParams should be empty", request.getFormParams().isEmpty());
        assertNull("MultipartBody should be null", request.getMultipartBody());

        // Execute and verify response
        HttpResponse response = executor.execute(request);
        assertEquals("Status should be 200", 200, response.getStatusCode());
        assertEquals("Body should match", responseBody, response.getBodyAsString());
        assertNotNull("BodyBytes should not be null", response.getBodyAsBytes());
    }

    @Provide
    Arbitrary<String> asciiStrings() {
        return Arbitraries.strings()
                .alpha()
                .numeric()
                .withChars(' ', '-', '_', '.', ',', '!', '?')
                .ofMinLength(1)
                .ofMaxLength(100);
    }

    @Property(tries = 100)
    void backwardCompatibility_postWithBody(
            @ForAll("asciiStrings") String requestBody,
            @ForAll("asciiStrings") String responseBody) {

        // Setup mock server - match any POST to /test
        wireMockServer.stubFor(post(urlEqualTo("/test"))
                .willReturn(aResponse()
                        .withStatus(201)
                        .withBody(responseBody)));

        // Build request using original API only
        HttpRequest request = HttpRequest.builder()
                .url(baseUrl() + "/test")
                .method(HttpMethod.POST)
                .header("Content-Type", "application/json")
                .body(requestBody)
                .build();

        // Verify original behavior
        assertEquals("Should be RAW body type", RequestBodyType.RAW, request.getBodyType());
        assertEquals("Body should be set", requestBody, request.getBody());

        // Execute and verify response
        HttpResponse response = executor.execute(request);
        assertEquals("Status should be 201", 201, response.getStatusCode());
        assertEquals("Body should match", responseBody, response.getBodyAsString());
    }

    @Property(tries = 100)
    void backwardCompatibility_withHeaders(
            @ForAll("asciiStrings") String headerValue,
            @ForAll("asciiStrings") String responseBody) {

        // Setup mock server - match any GET to /test with the header
        wireMockServer.stubFor(get(urlEqualTo("/test"))
                .withHeader("X-Custom-Header", matching(".*"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withHeader("X-Response-Header", "test-value")
                        .withBody(responseBody)));

        // Build request using original API only
        HttpRequest request = HttpRequest.builder()
                .url(baseUrl() + "/test")
                .method(HttpMethod.GET)
                .header("X-Custom-Header", headerValue)
                .build();

        // Execute and verify response
        HttpResponse response = executor.execute(request);
        assertEquals("Status should be 200", 200, response.getStatusCode());
        assertEquals("Body should match", responseBody, response.getBodyAsString());
        assertEquals("Response header should be present", "test-value", response.getHeaders().get("X-Response-Header"));
    }

    /**
     * Feature: http-executor-enhancement, Property 9: Byte Response Round-Trip
     * Validates: Requirements 4.2
     *
     * For any HTTP response with binary content,
     * HttpResponse.getBodyAsBytes() SHALL return the exact bytes received from the server.
     */
    @Property(tries = 100)
    void byteResponseRoundTrip(@ForAll @Size(min = 1, max = 1000) byte[] binaryContent) {
        // Setup mock server with binary response
        wireMockServer.stubFor(get(urlEqualTo("/binary"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withHeader("Content-Type", "application/octet-stream")
                        .withBody(binaryContent)));

        // Build request
        HttpRequest request = HttpRequest.builder()
                .url(baseUrl() + "/binary")
                .method(HttpMethod.GET)
                .build();

        // Execute and verify response
        HttpResponse response = executor.execute(request);
        assertEquals("Status should be 200", 200, response.getStatusCode());
        assertNotNull("BodyBytes should not be null", response.getBodyAsBytes());
        assertTrue("Bytes should match exactly", Arrays.equals(binaryContent, response.getBodyAsBytes()));
    }

    @Property(tries = 100)
    void byteResponseIdempotence(@ForAll @Size(min = 1, max = 500) byte[] binaryContent) {
        // Setup mock server
        wireMockServer.stubFor(get(urlEqualTo("/binary"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody(binaryContent)));

        // Build request
        HttpRequest request = HttpRequest.builder()
                .url(baseUrl() + "/binary")
                .method(HttpMethod.GET)
                .build();

        // Execute
        HttpResponse response = executor.execute(request);

        // Multiple calls should return same cached value
        byte[] firstCall = response.getBodyAsBytes();
        byte[] secondCall = response.getBodyAsBytes();
        byte[] thirdCall = response.getBodyAsBytes();

        assertSame("Multiple calls should return same array instance", firstCall, secondCall);
        assertSame("Multiple calls should return same array instance", secondCall, thirdCall);
        assertTrue("Content should match original", Arrays.equals(binaryContent, firstCall));
    }

    private String baseUrl() {
        return "http://localhost:" + wireMockServer.port();
    }

    // ==================== Proxy Configuration Tests ====================

    /**
     * Test proxy configuration with different hosts and ports
     * Validates: Proxy configuration functionality
     */
    @Property(tries = 20)
    void proxyConfiguration_basic(@ForAll @NotBlank @Size(max = 50) String proxyHost,
                                  @ForAll @IntRange(min = 1, max = 65535) int proxyPort) {
        // Just test that the config can be created without throwing exceptions
        // We can't actually test the proxy functionality without a real proxy server
        try {
            HttpConfig config = HttpConfig.builder()
                    .proxyConfig(new HttpConfig.ProxyConfig(proxyHost, proxyPort))
                    .build();

            assertTrue("Config should have proxy config", config.hasProxyConfig());
            assertEquals("Proxy host should match", proxyHost, config.getProxyConfig().getHost());
            assertEquals("Proxy port should match", proxyPort, config.getProxyConfig().getPort());
        } catch (Exception e) {
            fail("Proxy configuration should not throw exception: " + e.getMessage());
        }
    }

    /**
     * Test proxy configuration with authentication
     * Validates: Proxy authentication functionality
     */
    @Property(tries = 20)
    void proxyConfiguration_withAuth(@ForAll @NotBlank @Size(max = 20) String proxyHost,
                                     @ForAll @IntRange(min = 1, max = 65535) int proxyPort,
                                     @ForAll @NotBlank @Size(max = 20) String username,
                                     @ForAll @NotBlank @Size(max = 20) String password) {
        try {
            HttpConfig config = HttpConfig.builder()
                    .proxyConfig(new HttpConfig.ProxyConfig(proxyHost, proxyPort, username, password))
                    .build();

            assertTrue("Config should have proxy config", config.hasProxyConfig());
            assertEquals("Proxy host should match", proxyHost, config.getProxyConfig().getHost());
            assertEquals("Proxy port should match", proxyPort, config.getProxyConfig().getPort());
            assertTrue("Config should have authentication", config.getProxyConfig().hasAuthentication());
            assertEquals("Username should match", username, config.getProxyConfig().getUsername());
            assertEquals("Password should match", password, config.getProxyConfig().getPassword());
        } catch (Exception e) {
            fail("Proxy configuration with auth should not throw exception: " + e.getMessage());
        }
    }

    /**
     * Test proxy configuration with scheme
     * Validates: Proxy scheme functionality
     */
    @Property(tries = 10)
    void proxyConfiguration_withScheme(@ForAll @NotBlank @Size(max = 10) String proxyHost,
                                       @ForAll @IntRange(min = 1, max = 65535) int proxyPort,
                                       @ForAll @Size(max = 10) String scheme) {
        try {
            // Use only valid schemes for testing
            String validScheme = scheme.replaceAll("[^a-zA-Z]", "").toLowerCase();
            if (validScheme.isEmpty()) {
                validScheme = "http";
            }

            HttpConfig config = HttpConfig.builder()
                    .proxyConfig(new HttpConfig.ProxyConfig(proxyHost, proxyPort, validScheme))
                    .build();

            assertTrue("Config should have proxy config", config.hasProxyConfig());
            assertEquals("Proxy host should match", proxyHost, config.getProxyConfig().getHost());
            assertEquals("Proxy port should match", proxyPort, config.getProxyConfig().getPort());
            assertEquals("Proxy scheme should match", validScheme, config.getProxyConfig().getScheme());
        } catch (Exception e) {
            fail("Proxy configuration with scheme should not throw exception: " + e.getMessage());
        }
    }

    /**
     * Test proxy configuration using ProxyConfig object directly
     * Validates: Direct ProxyConfig instantiation
     */
    @Property(tries = 20)
    void proxyConfiguration_directProxyConfig(@ForAll @NotBlank @Size(max = 50) String proxyHost,
                                              @ForAll @IntRange(min = 1, max = 65535) int proxyPort,
                                              @ForAll @NotBlank @Size(max = 20) String username,
                                              @ForAll @NotBlank @Size(max = 20) String password,
                                              @ForAll @Size(max = 10) String scheme) {
        try {
            String validScheme = scheme.replaceAll("[^a-zA-Z]", "").toLowerCase();
            if (validScheme.isEmpty()) {
                validScheme = "http";
            }

            HttpConfig.ProxyConfig proxyConfig = new HttpConfig.ProxyConfig(
                    proxyHost, proxyPort, username, password, validScheme);

            HttpConfig config = HttpConfig.builder()
                    .proxyConfig(proxyConfig)
                    .build();

            assertTrue("Config should have proxy config", config.hasProxyConfig());
            assertEquals("Proxy host should match", proxyHost, config.getProxyConfig().getHost());
            assertEquals("Proxy port should match", proxyPort, config.getProxyConfig().getPort());
            assertEquals("Proxy scheme should match", validScheme, config.getProxyConfig().getScheme());
            assertTrue("Config should have authentication", config.getProxyConfig().hasAuthentication());
            assertEquals("Username should match", username, config.getProxyConfig().getUsername());
            assertEquals("Password should match", password, config.getProxyConfig().getPassword());
        } catch (Exception e) {
            fail("Direct proxy config should not throw exception: " + e.getMessage());
        }
    }

    // ==================== File Download Integration Tests ====================

    /**
     * Test executeAndSaveTo() method
     * Validates: Requirements 4.3
     */
    @Property(tries = 50)
    void fileDownload_executeAndSaveTo(@ForAll @Size(min = 1, max = 5000) byte[] content) throws Exception {
        // Setup mock server
        wireMockServer.stubFor(get(urlEqualTo("/download"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withHeader("Content-Type", "application/octet-stream")
                        .withHeader("Content-Length", String.valueOf(content.length))
                        .withBody(content)));

        // Create temp file
        java.io.File tempFile = java.io.File.createTempFile("download-test-", ".bin");
        tempFile.deleteOnExit();

        try {
            // Build request
            HttpRequest request = HttpRequest.builder()
                    .url(baseUrl() + "/download")
                    .method(HttpMethod.GET)

                    .build();

            // Execute download
            HttpResponse response = executor.executeAndSaveTo(request, tempFile);

            // Verify response
            assertEquals("Status should be 200", 200, response.getStatusCode());

            // Verify file content
            assertTrue("File should exist", tempFile.exists());
            byte[] fileContent = java.nio.file.Files.readAllBytes(tempFile.toPath());
            assertTrue("File content should match", Arrays.equals(content, fileContent));
        } finally {
            tempFile.delete();
        }
    }

    /**
     * Test directory auto-creation
     * Validates: Requirements 4.6
     */
    @Property(tries = 20)
    void fileDownload_autoCreateDirectory(@ForAll @Size(min = 1, max = 1000) byte[] content) throws Exception {
        // Setup mock server
        wireMockServer.stubFor(get(urlEqualTo("/download"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody(content)));

        // Create temp directory path that doesn't exist
        java.io.File tempDir = new java.io.File(System.getProperty("java.io.tmpdir"),
                "download-test-" + System.nanoTime() + "/subdir/nested");
        java.io.File tempFile = new java.io.File(tempDir, "test.bin");

        try {
            assertFalse("Directory should not exist initially", tempDir.exists());

            // Build request
            HttpRequest request = HttpRequest.builder()
                    .url(baseUrl() + "/download")
                    .method(HttpMethod.GET)

                    .build();

            // Execute download
            HttpResponse response = executor.executeAndSaveTo(request, tempFile);

            // Verify directory was created
            assertTrue("Directory should be created", tempDir.exists());
            assertTrue("File should exist", tempFile.exists());

            // Verify content
            byte[] fileContent = java.nio.file.Files.readAllBytes(tempFile.toPath());
            assertTrue("File content should match", Arrays.equals(content, fileContent));
        } finally {
            // Cleanup
            if (tempFile.exists()) tempFile.delete();
            deleteDirectory(tempDir);
        }
    }

    /**
     * Test executeAndWriteTo() method
     * Validates: Requirements 4.4
     */
    @Property(tries = 50)
    void fileDownload_executeAndWriteTo(@ForAll @Size(min = 1, max = 5000) byte[] content) throws Exception {
        // Setup mock server
        wireMockServer.stubFor(get(urlEqualTo("/download"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody(content)));

        // Build request
        HttpRequest request = HttpRequest.builder()
                .url(baseUrl() + "/download")
                .method(HttpMethod.GET)

                .build();

        // Execute with ByteArrayOutputStream
        java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
        HttpResponse response = executor.executeAndWriteTo(request, outputStream);

        // Verify response
        assertEquals("Status should be 200", 200, response.getStatusCode());

        // Verify content
        byte[] receivedContent = outputStream.toByteArray();
        assertTrue("Content should match", Arrays.equals(content, receivedContent));
    }

    /**
     * Helper method to delete directory recursively
     */
    private void deleteDirectory(java.io.File dir) {
        if (dir == null || !dir.exists()) return;

        java.io.File[] files = dir.listFiles();
        if (files != null) {
            for (java.io.File file : files) {
                if (file.isDirectory()) {
                    deleteDirectory(file);
                } else {
                    file.delete();
                }
            }
        }
        dir.delete();

        // Also try to delete parent directories up to temp dir
        java.io.File parent = dir.getParentFile();
        String tempDir = System.getProperty("java.io.tmpdir");
        while (parent != null && !parent.getAbsolutePath().equals(tempDir)) {
            if (parent.list() != null && parent.list().length == 0) {
                parent.delete();
                parent = parent.getParentFile();
            } else {
                break;
            }
        }
    }
}