暂存提交

2026-07-31 16:53:07 +08:00
parent 45358ef40f
commit 704cb15ccf
98 changed files with 1944 additions and 134 deletions
@@ -1,6 +1,7 @@
 package com.baiyue.warehouse.controller;

 import io.swagger.v3.oas.annotations.Operation;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -13,9 +14,11 @@ import java.lang.reflect.Method;

 import static org.assertj.core.api.Assertions.assertThat;

+@DisplayName("平台主数据控制器契约")
 class PlatformMasterDataControllerContractTest {
    @Test
-    void 往来单位分页路径权限和接口说明完整() throws Exception {
+    @DisplayName("往来单位分页路径权限和接口说明完整")
+    void shouldDeclareCompletePartnerListContract() throws Exception {
        assertContract(PlatformPartnerController.class, "platform:counterparty:list", "/api/platform/v1/partners");
        assertMethod(PlatformPartnerController.class, "detail", GetMapping.class, "platform:counterparty:list");
        assertMethod(PlatformPartnerController.class, "create", PostMapping.class, "platform:counterparty:create");
@@ -24,7 +27,8 @@ class PlatformMasterDataControllerContractTest {
    }

    @Test
-    void 快递公司分页路径权限和接口说明完整() throws Exception {
+    @DisplayName("快递公司分页路径权限和接口说明完整")
+    void shouldDeclareCompleteExpressCompanyListContract() throws Exception {
        assertContract(PlatformExpressCompanyController.class, "platform:express:list", "/api/platform/v1/express-companies");
        assertMethod(PlatformExpressCompanyController.class, "detail", GetMapping.class, "platform:express:list");
        assertMethod(PlatformExpressCompanyController.class, "create", PostMapping.class, "platform:express:create");
@@ -0,0 +1,30 @@
+package com.baiyue.warehouse.controller;
+
+import com.baiyue.common.core.api.ResultCode;
+import jakarta.servlet.http.HttpServletRequest;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.dao.DataAccessResourceFailureException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@DisplayName("仓库数据访问异常处理器")
+class WarehouseDataAccessExceptionHandlerTest {
+    @Test
+    @DisplayName("数据源故障统一返回503并保留请求标识")
+    void shouldReturnServiceUnavailableAndPreserveRequestIdsForDataSourceFailure() {
+        HttpServletRequest request = mock(HttpServletRequest.class);
+        when(request.getAttribute("requestId")).thenReturn("request-1");
+        when(request.getAttribute("traceId")).thenReturn("trace-1");
+
+        var response = new WarehouseDataAccessExceptionHandler().handle(
+            new DataAccessResourceFailureException("database unavailable"), request);
+
+        assertThat(response.getStatusCode().value()).isEqualTo(503);
+        assertThat(response.getBody()).isNotNull();
+        assertThat(response.getBody().code()).isEqualTo(ResultCode.SERVICE_UNAVAILABLE.code());
+        assertThat(response.getBody().message()).contains("数据库");
+    }
+}
@@ -0,0 +1,26 @@
+package com.baiyue.warehouse.controller;
+
+import com.baiyue.warehouse.service.WarehouseSchemaReadinessService;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@DisplayName("仓库健康检查控制器")
+class WarehouseHealthControllerTest {
+    @Test
+    @DisplayName("表结构漂移时状态接口返回503")
+    void shouldReturnServiceUnavailableWhenSchemaDrifts() {
+        WarehouseSchemaReadinessService service = mock(WarehouseSchemaReadinessService.class);
+        when(service.readiness()).thenReturn(
+            new WarehouseSchemaReadinessService.Readiness(false, "DEGRADED", "需要执行迁移"));
+
+        var response = new WarehouseHealthController(service).status();
+
+        assertThat(response.getStatusCode().value()).isEqualTo(503);
+        assertThat(response.getBody()).isNotNull();
+        assertThat(response.getBody().data()).containsEntry("status", "DEGRADED");
+    }
+}
@@ -9,6 +9,7 @@ import com.baiyue.warehouse.mapper.ExpressCompanyMapper;
 import org.apache.ibatis.builder.MapperBuilderAssistant;
 import org.apache.ibatis.session.Configuration;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;

@@ -18,14 +19,16 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

+@DisplayName("快递公司仓储")
 class ExpressCompanyRepositoryTest {
    @BeforeAll
-    static void 初始化实体字段缓存() {
+    static void initializeEntityFieldCache() {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new Configuration(), "test"), ExpressCompanyEntity.class);
    }

    @Test
-    void 平台分页强制租户并支持筛选() {
+    @DisplayName("平台分页强制租户并支持筛选")
+    void shouldEnforceTenantAndSupportFilteringForPlatformPage() {
        ExpressCompanyMapper mapper = mock(ExpressCompanyMapper.class);
        when(mapper.selectPage(any(Page.class), any())).thenAnswer(invocation -> invocation.getArgument(0));

@@ -3,6 +3,7 @@ package com.baiyue.warehouse.repository;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baiyue.warehouse.entity.PartnerEntity;
 import com.baiyue.warehouse.mapper.PartnerMapper;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.BeforeAll;
 import org.mockito.ArgumentCaptor;
@@ -16,18 +17,23 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;

+@DisplayName("往来单位仓储")
 class PartnerRepositoryTest {
-    @BeforeAll static void 初始化实体字段缓存() {
+    @BeforeAll static void initializeEntityFieldCache() {
        TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new Configuration(), "test"), PartnerEntity.class);
    }
-    @Test void 候选查询强制租户和启用状态() {
+    @Test
+    @DisplayName("候选查询强制租户和启用状态")
+    void shouldEnforceTenantAndActiveStatusForCandidateQuery() {
        PartnerMapper mapper=mock(PartnerMapper.class); when(mapper.selectList(any())).thenReturn(List.of());
        new PartnerRepository(mapper).activeCandidates(10001,"示例","CUSTOMER");
        @SuppressWarnings("unchecked") ArgumentCaptor<LambdaQueryWrapper<PartnerEntity>> c=ArgumentCaptor.forClass(LambdaQueryWrapper.class);
        verify(mapper).selectList(c.capture()); c.getValue().getSqlSegment();
        assertThat(c.getValue().getParamNameValuePairs().values()).contains(10001L,"ACTIVE","CUSTOMER");
    }
-    @Test void 详情查询强制租户和启用状态() {
+    @Test
+    @DisplayName("详情查询强制租户和启用状态")
+    void shouldEnforceTenantAndActiveStatusForDetailQuery() {
        PartnerMapper mapper=mock(PartnerMapper.class); when(mapper.selectOne(any())).thenReturn(null);
        new PartnerRepository(mapper).findActive(10002,9);
        @SuppressWarnings("unchecked") ArgumentCaptor<LambdaQueryWrapper<PartnerEntity>> c=ArgumentCaptor.forClass(LambdaQueryWrapper.class);
@@ -35,7 +41,9 @@ class PartnerRepositoryTest {
        assertThat(c.getValue().getParamNameValuePairs().values()).contains(10002L,9L,"ACTIVE");
    }

-    @Test void 平台分页强制租户并支持筛选() {
+    @Test
+    @DisplayName("平台分页强制租户并支持筛选")
+    void shouldEnforceTenantAndSupportFilteringForPlatformPage() {
        PartnerMapper mapper=mock(PartnerMapper.class);
        when(mapper.selectPage(any(Page.class), any())).thenAnswer(invocation -> invocation.getArgument(0));

@@ -1,5 +1,6 @@
 package com.baiyue.warehouse.repository;

+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;

 import java.io.IOException;
@@ -8,9 +9,11 @@ import java.nio.file.Path;

 import static org.assertj.core.api.Assertions.assertThat;

+@DisplayName("仓库数据库结构契约")
 class WarehouseSchemaContractTest {
    @Test
-    void 仓库三张表包含实体全部持久化字段() throws IOException {
+    @DisplayName("仓库三张表包含实体全部持久化字段")
+    void shouldContainAllPersistentFieldsInWarehouseTables() throws IOException {
        String sql = read("warehouse.sql");
        assertColumns(sql, "wh_warehouse", "warehouse_code", "warehouse_name", "warehouse_type", "country_code",
            "timezone", "contact_name", "contact_phone", "contact_email", "status", "remark");
@@ -22,7 +25,8 @@ class WarehouseSchemaContractTest {
    }

    @Test
-    void 往来单位表包含实体全部持久化字段() throws IOException {
+    @DisplayName("往来单位表包含实体全部持久化字段")
+    void shouldContainAllPersistentFieldsInPartnerTable() throws IOException {
        String sql = read("warehouse-partner.sql");
        assertColumns(sql, "wh_partner", "partner_code", "partner_name", "partner_type", "contact_name",
            "contact_phone", "contact_email", "country_code", "province", "city", "district", "address_line",
@@ -31,13 +35,32 @@ class WarehouseSchemaContractTest {
    }

    @Test
-    void 快递公司表包含实体全部持久化字段() throws IOException {
+    @DisplayName("快递公司表包含实体全部持久化字段")
+    void shouldContainAllPersistentFieldsInExpressCompanyTable() throws IOException {
        String sql = read("warehouse-express-company.sql");
        assertColumns(sql, "wh_express_company", "company_code", "company_name", "service_phone", "website",
            "tracking_url_template", "status", "remark");
        assertBaseColumns(sql);
    }

+    @Test
+    @DisplayName("既有库增量迁移覆盖全部仓储实体表和列表索引")
+    void shouldCoverAllWarehouseTablesAndListIndexesInIncrementalMigration() throws IOException {
+        String sql = read("phase1-warehouse-schema-migration.sql");
+        assertThat(sql).contains("FROM information_schema.columns")
+            .contains("CREATE PROCEDURE add_column_if_missing")
+            .contains("CALL add_column_if_missing('wh_warehouse'")
+            .contains("CALL add_column_if_missing('wh_warehouse_address'")
+            .contains("CALL add_column_if_missing('wh_service_capability'")
+            .contains("CALL add_column_if_missing('wh_partner'")
+            .contains("CALL add_column_if_missing('wh_express_company'")
+            .contains("DROP PROCEDURE IF EXISTS add_column_if_missing")
+            .doesNotContain("ADD COLUMN IF NOT EXISTS")
+            .contains("idx_wh_tenant_status")
+            .contains("idx_wh_partner_tenant_status")
+            .contains("idx_wh_express_tenant_status");
+    }
+
    private static String read(String file) throws IOException {
        return Files.readString(Path.of("src/main/resources/db", file));
    }
@@ -7,6 +7,7 @@ import com.baiyue.warehouse.entity.ExpressCompanyEntity;
 import com.baiyue.warehouse.entity.PartnerEntity;
 import com.baiyue.warehouse.repository.ExpressCompanyRepository;
 import com.baiyue.warehouse.repository.PartnerRepository;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.dao.DataIntegrityViolationException;

@@ -20,9 +21,11 @@ import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;

+@DisplayName("平台主数据维护服务")
 class PlatformMasterDataManagementServiceTest {
    @Test
-    void 往来单位详情强制租户隔离() {
+    @DisplayName("往来单位详情强制租户隔离")
+    void shouldEnforceTenantIsolationForPartnerDetail() {
        PartnerRepository repository = mock(PartnerRepository.class);
        PlatformPartnerQueryService service = new PlatformPartnerQueryService(repository);

@@ -31,7 +34,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 往来单位编码在租户内必须唯一() {
+    @DisplayName("往来单位编码在租户内必须唯一")
+    void shouldRequireUniquePartnerCodeWithinTenant() {
        PartnerRepository repository = mock(PartnerRepository.class);
        when(repository.existsCode(10001L, "CUS-001", null)).thenReturn(true);
        PlatformPartnerQueryService service = new PlatformPartnerQueryService(repository);
@@ -42,7 +46,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 往来单位并发重复编码统一返回业务冲突() {
+    @DisplayName("往来单位并发重复编码统一返回业务冲突")
+    void shouldReturnBusinessConflictForConcurrentDuplicatePartnerCode() {
        PartnerRepository repository = mock(PartnerRepository.class);
        doThrow(new DataIntegrityViolationException("duplicate")).when(repository).insert(any());
        PlatformPartnerQueryService service = new PlatformPartnerQueryService(repository);
@@ -52,7 +57,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 往来单位新增写入租户和请求字段() {
+    @DisplayName("往来单位新增写入租户和请求字段")
+    void shouldPersistTenantAndRequestFieldsWhenCreatingPartner() {
        PartnerRepository repository = mock(PartnerRepository.class);
        doAnswer(invocation -> {
            PartnerEntity entity = invocation.getArgument(0);
@@ -71,7 +77,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 往来单位编辑保留归属并更新字段() {
+    @DisplayName("往来单位编辑保留归属并更新字段")
+    void shouldPreserveOwnershipAndUpdateFieldsWhenEditingPartner() {
        PartnerRepository repository = mock(PartnerRepository.class);
        PartnerEntity entity = new PartnerEntity();
        entity.setId(19L);
@@ -87,7 +94,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 往来单位停用保留主数据() {
+    @DisplayName("往来单位停用保留主数据")
+    void shouldPreservePartnerMasterDataWhenDeactivating() {
        PartnerRepository repository = mock(PartnerRepository.class);
        PartnerEntity entity = new PartnerEntity();
        entity.setId(8L);
@@ -103,7 +111,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 快递公司详情强制租户隔离() {
+    @DisplayName("快递公司详情强制租户隔离")
+    void shouldEnforceTenantIsolationForExpressCompanyDetail() {
        ExpressCompanyRepository repository = mock(ExpressCompanyRepository.class);
        ExpressCompanyQueryService service = new ExpressCompanyQueryService(repository);

@@ -112,7 +121,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 快递公司编码在租户内必须唯一() {
+    @DisplayName("快递公司编码在租户内必须唯一")
+    void shouldRequireUniqueExpressCompanyCodeWithinTenant() {
        ExpressCompanyRepository repository = mock(ExpressCompanyRepository.class);
        when(repository.existsCode(10001L, "SF", null)).thenReturn(true);
        ExpressCompanyQueryService service = new ExpressCompanyQueryService(repository);
@@ -123,7 +133,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 快递公司并发重复编码统一返回业务冲突() {
+    @DisplayName("快递公司并发重复编码统一返回业务冲突")
+    void shouldReturnBusinessConflictForConcurrentDuplicateExpressCompanyCode() {
        ExpressCompanyRepository repository = mock(ExpressCompanyRepository.class);
        doThrow(new DataIntegrityViolationException("duplicate")).when(repository).insert(any());
        ExpressCompanyQueryService service = new ExpressCompanyQueryService(repository);
@@ -133,7 +144,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 快递公司新增写入租户和请求字段() {
+    @DisplayName("快递公司新增写入租户和请求字段")
+    void shouldPersistTenantAndRequestFieldsWhenCreatingExpressCompany() {
        ExpressCompanyRepository repository = mock(ExpressCompanyRepository.class);
        doAnswer(invocation -> {
            ExpressCompanyEntity entity = invocation.getArgument(0);
@@ -153,7 +165,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 快递公司编辑保留归属并更新字段() {
+    @DisplayName("快递公司编辑保留归属并更新字段")
+    void shouldPreserveOwnershipAndUpdateFieldsWhenEditingExpressCompany() {
        ExpressCompanyRepository repository = mock(ExpressCompanyRepository.class);
        ExpressCompanyEntity entity = new ExpressCompanyEntity();
        entity.setId(29L);
@@ -169,7 +182,8 @@ class PlatformMasterDataManagementServiceTest {
    }

    @Test
-    void 快递公司停用保留主数据() {
+    @DisplayName("快递公司停用保留主数据")
+    void shouldPreserveExpressCompanyMasterDataWhenDeactivating() {
        ExpressCompanyRepository repository = mock(ExpressCompanyRepository.class);
        ExpressCompanyEntity entity = new ExpressCompanyEntity();
        entity.setId(9L);
@@ -3,14 +3,17 @@ package com.baiyue.warehouse.service;
 import com.baiyue.common.core.exception.BizException;
 import com.baiyue.warehouse.entity.WarehouseEntity;
 import com.baiyue.warehouse.repository.WarehouseRepository;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.test.util.ReflectionTestUtils;
 import static org.assertj.core.api.Assertions.*;
 import static org.mockito.Mockito.*;

+@DisplayName("仓库应用服务")
 class WarehouseApplicationServiceTest {
    @Test
-    void 商户详情只返回启用且属于租户的仓库() {
+    @DisplayName("商户详情只返回启用且属于租户的仓库")
+    void shouldReturnOnlyActiveTenantOwnedWarehouseForMerchantDetail() {
        WarehouseRepository repository=mock(WarehouseRepository.class);
        WarehouseEntity warehouse=new WarehouseEntity(); warehouse.setId(1L); warehouse.setTenantId(10001L); warehouse.setStatus("ACTIVE");
        when(repository.findActiveOwned(10001,1)).thenReturn(warehouse);
@@ -21,7 +24,8 @@ class WarehouseApplicationServiceTest {
        verify(repository).findActiveOwned(10001,1);
    }
    @Test
-    void 停用或跨租户仓库按不存在处理() {
+    @DisplayName("停用或跨租户仓库按不存在处理")
+    void shouldTreatInactiveOrCrossTenantWarehouseAsNotFound() {
        WarehouseRepository repository=mock(WarehouseRepository.class);
        WarehouseApplicationService service=new WarehouseApplicationService(); ReflectionTestUtils.setField(service,"repository",repository);
        assertThatThrownBy(() -> service.activeDetail(10002,1)).isInstanceOf(BizException.class)
@@ -0,0 +1,43 @@
+package com.baiyue.warehouse.service;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.BadSqlGrammarException;
+
+import java.sql.SQLException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+@DisplayName("仓库表结构就绪检查服务")
+class WarehouseSchemaReadinessServiceTest {
+    @Test
+    @DisplayName("全部表字段可查询时返回就绪")
+    void shouldReportUpWhenAllTablesAndColumnsAreQueryable() {
+        JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
+
+        var readiness = new WarehouseSchemaReadinessService(jdbcTemplate).readiness();
+
+        assertThat(readiness.ready()).isTrue();
+        assertThat(readiness.status()).isEqualTo("UP");
+        verify(jdbcTemplate).execute(org.mockito.ArgumentMatchers.contains("wh_express_company"));
+    }
+
+    @Test
+    @DisplayName("缺表或缺列时返回降级而不是伪报正常")
+    void shouldReportDegradedWhenTableOrColumnIsMissing() {
+        JdbcTemplate jdbcTemplate = mock(JdbcTemplate.class);
+        doThrow(new BadSqlGrammarException("probe", "SELECT", new SQLException("missing")))
+            .when(jdbcTemplate).execute(anyString());
+
+        var readiness = new WarehouseSchemaReadinessService(jdbcTemplate).readiness();
+
+        assertThat(readiness.ready()).isFalse();
+        assertThat(readiness.status()).isEqualTo("DEGRADED");
+        assertThat(readiness.message()).contains("迁移");
+    }
+}