Rest Assured中POST请求重定向的专业处理策略

Response resp1 = given()
    .contentType(ContentType.URLENC) // 示例：根据实际请求体类型设置
    .body("AUTH_TOKEN=&j_username=" + encodedUsername + "&j_password=" + password + "&userName=&AUTH_TOKEN=") // 示例：请求体
    .redirects().follow(false) // 禁用自动重定向
.expect()
    .statusCode(302) // 预期收到重定向状态码，例如302或307
.when()
    .post("/authenticate/j_spring_security_check"); // 原始POST请求的端点

String headerLocationValue = resp1.getHeader("Location");

Response resp2 = given()
    .cookie(resp1.getDetailedCookie("JSESSIONID")) // 示例：传递会话Cookie
.expect()
    .statusCode(200) // 预期最终请求成功，状态码为200
.when()
    .get(headerLocationValue); // 发送GET请求到重定向目标

import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import io.restassured.specification.RequestSpecification;
import org.junit.BeforeClass;
import org.junit.Test;

import java.io.File;

import static io.restassured.RestAssured.given;
import static io.restassured.RestAssured.baseURI;
// 假设ConfigReader和body文件已定义

public class RedirectHandlingExample {

    static {
        // baseURI = ConfigReader.getProperty("url"); // 确保baseURI已设置
        baseURI = "http://your.api.base.url"; // 示例URL
    }

    RequestSpecification requestSpecification;
    String accessToken;

    @BeforeClass
    public static void setup() {
        // 可以放置一些全局的RestAssured配置，例如信任所有证书等
        // RestAssured.useRelaxedHTTPSValidation();
    }

    // 模拟获取AccessToken的步骤
    @Test
    public void getAccessTokenAndHandlePostRedirect() {
        String username = "testuser"; // ConfigReader.getProperty("username");
        String password = "testpassword"; // ConfigReader.getProperty("password");
        String authEndpoint = "/auth/login"; // 您的认证端点

        // 步骤1: 发送认证POST请求，禁用自动重定向
        Response authResponse = given().log().all()
                .header("Content-Type", "application/json")
                .body("{\n" +
                        " \"username\": \"" + username + "\",\n" +
                        "\"password\": \"" + password + "\" \n" +
                        "}")
                .redirects().follow(false) // 禁用自动重定向
                .post(authEndpoint);

        // 检查是否收到重定向
        if (authResponse.getStatusCode() == 307 || authResponse.getStatusCode() == 302) {
            System.out.println("Received redirect status: " + authResponse.getStatusCode());
            String redirectLocation = authResponse.getHeader("Location");
            System.out.println("Redirecting to: " + redirectLocation);

            // 步骤2: 提取Location头，并准备后续请求
            // 假设认证成功后会有一个AccessToken在原始响应体中，或者重定向后需要再次获取
            // 这里的处理取决于您的API设计。如果AccessToken在307的响应体中，直接解析。
            // 如果AccessToken在重定向后的最终响应中，则需要发送后续请求。
            // 示例假设AccessToken在原始POST响应体中，即使是307，但这通常不常见。
            // 更常见的是，307响应体为空，需要重定向后才能获取。
            // 这里我们假设如果重定向，那么AccessToken可能需要在重定向后的响应中获取，
            // 或者认证成功后直接返回，但后续请求需要保持会话。

            // 假设重定向后需要再次发送POST请求，或者是一个GET请求来获取资源
            // 这里我们以GET为例，并传递JSESSIONID（如果存在）
            String jsessionId = authResponse.getDetailedCookie("JSESSIONID") != null ?
                                authResponse.getDetailedCookie("JSESSIONID").getValue() : null;

            RequestSpecification finalRequestSpec = given();
            if (jsessionId != null) {
                finalRequestSpec.cookie("JSESSIONID", jsessionId);
            }

            Response finalAuthResponse = finalRequestSpec
                .get(redirectLocation); // 假设重定向到GET请求

            // 从最终响应中获取AccessToken
            String jsonString = finalAuthResponse.asString();
            accessToken = JsonPath.from(jsonString).get("AccessToken");
            System.out.println("Access Token: " + accessToken);

            // 后续请求可以使用这个accessToken
            // requestSpecification = given().header("Authorization", "Bearer " + accessToken);
            // ...
        } else if (authResponse.getStatusCode() == 200) {
            // 如果直接成功，没有重定向
            String jsonString = authResponse.asString();
            accessToken = JsonPath.from(jsonString).get("AccessToken");
            System.out.println("Access Token: " + accessToken);
        } else {
            // 处理其他错误状态
            System.err.println("Authentication failed with status: " + authResponse.getStatusCode());
            System.err.println("Response body: " + authResponse.asString());
        }
    }

    // 假设这是一个后续的POST请求，需要用到accessToken
    @Test
    public void sendPostRequestWithRedirectHandling() {
        // 确保accessToken已通过getAccessTokenAndHandlePostRedirect方法获取
        // 实际测试中，可能需要先调用getAccessTokenAndHandlePostRedirect方法
        // 或者在@BeforeMethod中处理认证
        accessToken = "your_valid_access_token"; // 替换为实际获取到的token

        String key = "Authorization"; // 示例header key
        String value = "Bearer " + accessToken; // 示例header value
        String postEndpoint = "/api/resource"; // 您的目标POST端点
        File requestBodyFile = new File("src/test/resources/body.json"); // 您的请求体文件

        requestSpecification = given()
                .header(key, value)
                .header("AccessToken", accessToken); // 原始问题中的AccessToken头

        // 发送带body的POST请求
        Response postResponse = requestSpecification
                .body(requestBodyFile)
                .redirects().follow(false) // 再次禁用自动重定向，以防此POST也有重定向
                .post(postEndpoint);

        // 处理可能的重定向
        if (postResponse.getStatusCode() == 307 || postResponse.getStatusCode() == 302) {
            System.out.println("Received redirect for POST request: " + postResponse.getStatusCode());
            String redirectLocation = postResponse.getHeader("Location");
            System.out.println("Redirecting POST to: " + redirectLocation);

            // 根据HTTP规范，307应使用相同方法（POST）和请求体重发
            // 303通常是重定向到GET
            // 这里我们模拟一个307的情况，重新发送POST请求
            // 注意：如果重定向目标是GET，则应使用GET方法
            Response finalPostResponse = given()
                .header(key, value)
                .header("AccessToken", accessToken)
                .contentType(postResponse.getContentType()) // 保持原始内容类型
                .body(requestBodyFile) // 重新发送原始请求体
                .post(redirectLocation); // 发送到重定向URL

            finalPostResponse.then().log().all().statusCode(200);
        } else {
            // 如果没有重定向，直接验证最终状态
            postResponse.then().log().all().statusCode(200);
        }
    }
}