wenzi/src/test/java/com/mosquito/project/integration/SimpleApiIntegrationTest.java

package com.mosquito.project.integration;

import com.mosquito.project.dto.CreateActivityRequest;
import com.mosquito.project.dto.CreateApiKeyRequest;
import com.mosquito.project.persistence.entity.ActivityEntity;
import com.mosquito.project.persistence.repository.ActivityRepository;
import com.mosquito.project.service.ActivityService;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.*;

import java.time.ZonedDateTime;

import static org.junit.jupiter.api.Assertions.*;

/**
 * 简化的API集成测试
 * 专注于基本的API流程和数据库操作
 */
class SimpleApiIntegrationTest extends AbstractIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Autowired
    private ActivityService activityService;

    @Autowired
    private ActivityRepository activityRepository;

    private String apiKey;

    @BeforeEach
    void setUpApiKey() {
        ensureApiKey();
    }

    @Test
    @DisplayName("活动创建API集成测试")
    void shouldCreateActivitySuccessfully_IntegrationTest() {
        // Given
        CreateActivityRequest request = new CreateActivityRequest();
        request.setName("集成测试活动");
        request.setStartTime(ZonedDateTime.now().plusHours(1));
        request.setEndTime(ZonedDateTime.now().plusDays(7));

        HttpHeaders headers = apiHeaders();
        HttpEntity<CreateActivityRequest> entity = new HttpEntity<>(request, headers);

        // When
        ResponseEntity<String> response = restTemplate.postForEntity(
            "/api/v1/activities", entity, String.class);

        // Then
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        assertNotNull(response.getBody());
    }

    @Test
    @DisplayName("活动查询API集成测试")
    void shouldGetActivities_IntegrationTest() {
        // Given - 先创建一个活动
        CreateActivityRequest request = new CreateActivityRequest();
        request.setName("查询测试活动");
        request.setStartTime(ZonedDateTime.now().plusHours(1));
        request.setEndTime(ZonedDateTime.now().plusDays(7));

        HttpHeaders headers = apiHeaders();
        HttpEntity<CreateActivityRequest> entity = new HttpEntity<>(request, headers);
        restTemplate.postForEntity("/api/v1/activities", entity, String.class);

        // When - 查询活动列表
        ResponseEntity<String> response = restTemplate.exchange(
            "/api/v1/activities", HttpMethod.GET, new HttpEntity<>(headers), String.class);

        // Then
        assertStatus(response, HttpStatus.OK);
        assertNotNull(response.getBody());
    }

    @Test
    @DisplayName("数据库集成验证测试")
    void shouldVerifyDatabasePersistence_IntegrationTest() {
        // Given
        long initialCount = activityRepository.count();
        
        CreateActivityRequest request = new CreateActivityRequest();
        request.setName("数据库验证活动");
        request.setStartTime(ZonedDateTime.now().plusHours(1));
        request.setEndTime(ZonedDateTime.now().plusDays(7));

        // When
        ResponseEntity<String> response = restTemplate.postForEntity(
            "/api/v1/activities", new HttpEntity<>(request, apiHeaders()), String.class);

        // Then
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        
        long finalCount = activityRepository.count();
        assertTrue(finalCount > initialCount, "数据库中应该有新的活动记录");
        
        // 验证数据库中的数据
        Iterable<ActivityEntity> activities = activityRepository.findAll();
        boolean found = false;
        for (ActivityEntity activity : activities) {
            if ("数据库验证活动".equals(activity.getName())) {
                found = true;
                break;
            }
        }
        assertTrue(found, "应该能在数据库中找到创建的活动");
    }

    @Test
    @DisplayName("无效请求处理集成测试")
    void shouldHandleInvalidRequests_IntegrationTest() {
        // Given
        CreateActivityRequest invalidRequest = new CreateActivityRequest();
        // 不设置必需字段

        HttpHeaders headers = apiHeaders();
        HttpEntity<CreateActivityRequest> entity = new HttpEntity<>(invalidRequest, headers);

        // When
        ResponseEntity<String> response = restTemplate.postForEntity(
            "/api/v1/activities", entity, String.class);

        // Then
        assertStatus(response, HttpStatus.BAD_REQUEST);
    }

    @Test
    @DisplayName("并发操作集成测试")
    void shouldHandleConcurrentOperations_IntegrationTest() {
        // Given
        int threadCount = 3;
        long initialCount = activityRepository.count();

        // When - 并发创建活动
        for (int i = 0; i < threadCount; i++) {
            CreateActivityRequest request = new CreateActivityRequest();
            request.setName("并发测试活动-" + i);
            request.setStartTime(ZonedDateTime.now().plusHours(1));
            request.setEndTime(ZonedDateTime.now().plusDays(7));

            ResponseEntity<String> response = restTemplate.postForEntity(
                "/api/v1/activities", new HttpEntity<>(request, apiHeaders()), String.class);
            
            assertEquals(HttpStatus.CREATED, response.getStatusCode());
        }

        // Then - 验证数据库状态
        long finalCount = activityRepository.count();
        assertEquals(initialCount + threadCount, finalCount, "应该成功创建" + threadCount + "个活动");
    }

    @Test
    @DisplayName("缓存验证集成测试")
    void shouldVerifyCaching_IntegrationTest() {
        // Given
        CreateActivityRequest request = new CreateActivityRequest();
        request.setName("缓存测试活动");
        request.setStartTime(ZonedDateTime.now().plusHours(1));
        request.setEndTime(ZonedDateTime.now().plusDays(7));

        HttpHeaders headers = apiHeaders();
        HttpEntity<CreateActivityRequest> entity = new HttpEntity<>(request, headers);

        // When - 创建活动
        ResponseEntity<String> createResponse = restTemplate.postForEntity(
            "/api/v1/activities", entity, String.class);
        assertStatus(createResponse, HttpStatus.CREATED);

        // 第一次查询
        long startTime1 = System.currentTimeMillis();
        ResponseEntity<String> queryResponse1 = restTemplate.exchange(
            "/api/v1/activities", HttpMethod.GET, new HttpEntity<>(headers), String.class);
        long queryTime1 = System.currentTimeMillis() - startTime1;
        assertStatus(queryResponse1, HttpStatus.OK);

        // 第二次查询（应该被缓存）
        long startTime2 = System.currentTimeMillis();
        ResponseEntity<String> queryResponse2 = restTemplate.exchange(
            "/api/v1/activities", HttpMethod.GET, new HttpEntity<>(headers), String.class);
        long queryTime2 = System.currentTimeMillis() - startTime2;
        assertStatus(queryResponse2, HttpStatus.OK);

        // Then - 验证缓存效果（第二次查询应该更快或相似）
        assertNotNull(queryResponse1.getBody());
        assertNotNull(queryResponse2.getBody());
        // 缓存效果可能不明显，但至少验证查询正常工作
        assertTrue(queryTime2 < 1000, "查询时间应该合理");
    }

    private HttpHeaders apiHeaders() {
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.set("X-API-Key", apiKey);
        headers.set(HttpHeaders.AUTHORIZATION, "Bearer test-token");
        return headers;
    }

    private void ensureApiKey() {
        if (apiKey != null) {
            return;
        }
        CreateActivityRequest request = new CreateActivityRequest();
        request.setName("API密钥初始化活动");
        request.setStartTime(ZonedDateTime.now().plusHours(1));
        request.setEndTime(ZonedDateTime.now().plusDays(7));

        Long activityId = activityService.createActivity(request).getId();
        CreateApiKeyRequest apiKeyRequest = new CreateApiKeyRequest();
        apiKeyRequest.setActivityId(activityId);
        apiKeyRequest.setName("集成测试密钥");
        apiKey = activityService.generateApiKey(apiKeyRequest);
    }

    private void assertStatus(ResponseEntity<String> response, HttpStatus expected) {
        if (!expected.equals(response.getStatusCode())) {
            System.out.println("Unexpected status: " + response.getStatusCode());
            System.out.println("Response body: " + response.getBody());
        }
        assertEquals(expected, response.getStatusCode());
    }
}