统一修改ruoyi->bms

2026-09-28 10:02:38 +08:00
parent 341afc4111
commit 0408b6c35e
639 changed files with 2776 additions and 2807 deletions
@@ -0,0 +1,271 @@
+//package com.bms.customer.customermoney.api;
+//
+//import java.math.BigDecimal;
+//import java.math.RoundingMode;
+//import java.util.ArrayList;
+//import java.util.Collections;
+//import java.util.List;
+//import java.util.concurrent.CountDownLatch;
+//import java.util.concurrent.ExecutorService;
+//import java.util.concurrent.Executors;
+//import java.util.concurrent.TimeUnit;
+//import java.util.concurrent.atomic.AtomicInteger;
+//
+//import org.junit.jupiter.api.AfterEach;
+//import org.junit.jupiter.api.BeforeEach;
+//import org.junit.jupiter.api.Test;
+//import org.springframework.beans.factory.annotation.Autowired;
+//import org.springframework.boot.test.context.SpringBootTest;
+//import org.springframework.jdbc.core.JdbcTemplate;
+//import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+//import org.springframework.security.core.Authentication;
+//import org.springframework.security.core.context.SecurityContextHolder;
+//
+//import com.bms.common.core.domain.entity.SysUser;
+//import com.bms.common.core.domain.model.LoginUser;
+//import com.bms.customer.customermoney.domain.CustomerCreditFlow;
+//
+//import static org.junit.jupiter.api.Assertions.assertEquals;
+//import static org.junit.jupiter.api.Assertions.assertTrue;
+//
+///**
+// * 客户授信额度「并发占用超额不透支」集成测试。
+// *
+// * <p>通过限制总额度后让 N 个线程同时占用额度，验证：
+// * <ol>
+// *   <li>已用额度 never 超过「总额度 + 临时额度」（不透支，靠 {@code select ... for update} 行锁串行）；
+// *   <li>只有最先抢到锁且额度足够的占用能成功，其余抛「可用额度不足」（靠行锁内重读最新已用额度，非乐观锁兜底的丢失更新）；
+// *   <li>额度充足场景并发占用不丢失任何一笔更新（累计正确）。
+// * </ol></p>
+// *
+// * <p>注意：这是针对真实开发库的集成测试，{@code setUp} 会把指定测试客户的 CNY 账户重置为受控额度，
+// * {@code tearDown} 恢复原值并物理删除测试产生的额度流水。请将 {@code CUSTOMER_ID} 换成专用测试客户ID。</p>
+// *
+// * @author bms
+// * @date 2026-09-17
+// */
+//@SpringBootTest
+//public class CustomerAccountOccupyConcurrencyTest
+//{
+//    /** 请替换为专用测试客户ID，切勿使用正在营业的真实客户 */
+//    private static final Long CUSTOMER_ID = 1L;
+//
+//    private static final String CURRENCY = "CNY";
+//
+//    /** 并发线程数 */
+//    private static final int THREADS = 10;
+//
+//    /** 单线程占用金额 */
+//    private static final BigDecimal AMOUNT = new BigDecimal("100");
+//
+//    /** 测试捏造的总额度（使 10*100 超限，最多只能成功 1 笔） */
+//    private static final BigDecimal TEST_TOTAL = new BigDecimal("150");
+//
+//    @Autowired
+//    private ICustomerAccountApi accountApi;
+//
+//    @Autowired
+//    private JdbcTemplate jdbc;
+//
+//    /** 每个 worker 线程复用的登录态（SecurityContextHolder 为线程本地，各线程独立 set） */
+//    private Authentication authentication;
+//
+//    /** 本次测试由 occupyCredit 返回并落库的额度流水ID，用于 tearDown 清理 */
+//    private final List<Long> createdFlowIds = Collections.synchronizedList(new ArrayList<>());
+//
+//    /** 客户账户被改写前的原值，tearDown 恢复用 */
+//    private BigDecimal origTotal;
+//    private BigDecimal origUsed;
+//    private BigDecimal origExtra;
+//
+//    @BeforeEach
+//    void setUp()
+//    {
+//        // 1) 若账户不存在则先创建（总额度=TEST_TOTAL，余额/已用/临时均为0），保证后续 update 有行可改
+//        jdbc.update("INSERT INTO ctr_customer_account "
+//                + "(customer_id, currency, balance, frozen_balance, total_credit, extra_credit, used_credit, tax, version, del_flag, create_by, create_time) "
+//                + "SELECT ?, ?, 0, 0, ?, 0, 0, 0, 0, '0', '并发测试', now() "
+//                + "FROM DUAL WHERE NOT EXISTS "
+//                + "(SELECT 1 FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0')",
+//                CUSTOMER_ID, CURRENCY, TEST_TOTAL, CUSTOMER_ID, CURRENCY);
+//
+//        // 2) 快照账户原值（用于恢复）
+//        origTotal = queryAmount("SELECT total_credit FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0'");
+//        origUsed = queryAmount("SELECT used_credit FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0'");
+//        origExtra = queryAmount("SELECT extra_credit FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0'");
+//
+//        // 3) 重置为受控状态：总额度=TEST_TOTAL，已用=0，临时=0，并清掉历史额度流水（只清本客户，避免影响统计断言）
+//        jdbc.update("UPDATE ctr_customer_account SET total_credit = ?, used_credit = 0, extra_credit = 0, "
+//                + "extra_effective_date = NULL, extra_expire_date = NULL, version = version + 1 "
+//                + "WHERE customer_id = ? AND currency = ? AND del_flag = '0'",
+//                TEST_TOTAL, CUSTOMER_ID, CURRENCY);
+//        jdbc.update("DELETE FROM ctr_customer_credit_flow WHERE customer_id = ? AND create_by = '并发测试'",
+//                CUSTOMER_ID);
+//
+//        // 4) 构造登录态（occupyCredit 内部调用 SecurityUtils.getUsername()/getUserId()）
+//        SysUser user = new SysUser();
+//        user.setUserName("并发测试用户");
+//        LoginUser loginUser = new LoginUser(1L, null, user, null);
+//        authentication = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
+//    }
+//
+//    @AfterEach
+//    void tearDown()
+//    {
+//        // 1) 物理删除测试产生的额度流水
+//        for (Long id : createdFlowIds)
+//        {
+//            jdbc.update("DELETE FROM ctr_customer_credit_flow WHERE id = ?", id);
+//        }
+//        // 2) 恢复账户原值
+//        jdbc.update("UPDATE ctr_customer_account SET total_credit = ?, used_credit = ?, extra_credit = ? "
+//                + "WHERE customer_id = ? AND currency = ? AND del_flag = '0'",
+//                origTotal, origUsed, origExtra, CUSTOMER_ID, CURRENCY);
+//        // 3) 清理线程本地上下文，避免污染其他用例
+//        SecurityContextHolder.clearContext();
+//    }
+//
+//    /**
+//     * 核心场景：总额度150，10线程各占100。行锁串行后最多成功1笔（100<=150），
+//     * 其余9笔在重读最新已用额度后判定可用不足拒绝，已用额度恒不得透支。
+//     */
+//    @Test
+//    public void 并发占用超额_不透支且仅允许可容纳的成功()
+//            throws InterruptedException
+//    {
+//        RunResult result = runConcurrentOccupy(THREADS, AMOUNT);
+//
+//        // 不透支核验：已用额度 <= 总额度 + 临时额度（透支出此被判定失败）
+//        BigDecimal used = queryUsedCredit();
+//        BigDecimal limit = TEST_TOTAL.add(queryExtraCredit());
+//        assertTrue(used.compareTo(limit) <= 0,
+//                "发生透支！used=" + used + " > 可受理上限=" + limit);
+//
+//        // 每笔100，总额度150 → 最多1笔成功；行锁保证首笔成功，故必须恰好1笔
+//        assertEquals(1, result.successCount,
+//                "并发占用结果数异常，成功=" + result.successCount + " 失败=" + result.failureCount);
+//        assertEquals(new BigDecimal("100").setScale(2, RoundingMode.HALF_UP), used,
+//                "已用额度应为100（只有一笔成功）");
+//        assertTrue(result.hasInsufficientMessage(),
+//                "应至少有一个并发请求因『可用额度不足』被拒绝，实际错误=" + result.errorMessages);
+//    }
+//
+//    /**
+//     * 对照场景：总额度充足（5000），5线程各占100 → 全部成功，已用=500，且累计无丢失。
+//     */
+//    @Test
+//    public void 并发占用_额度充足时所有更新全部生效()
+//            throws InterruptedException
+//    {
+//        jdbc.update("UPDATE ctr_customer_account SET total_credit = 5000, used_credit = 0 "
+//                + "WHERE customer_id = ? AND currency = ? AND del_flag = '0'", CUSTOMER_ID, CURRENCY);
+//
+//        RunResult result = runConcurrentOccupy(5, AMOUNT);
+//
+//        assertEquals(5, result.successCount, "额度充足场景应5笔全部成功");
+//        BigDecimal used = queryUsedCredit();
+//        BigDecimal expected = new BigDecimal("500").setScale(2, RoundingMode.HALF_UP);
+//        assertEquals(expected, used, "已用额度应精确等于5*100=500，不允许任何丢失更新");
+//        assertTrue(used.compareTo(queryTotalCredit()) <= 0, "不应透支");
+//    }
+//
+//    /**
+//     * 并发执行占用：CountDownLatch 栅栏保证所有线程同时开跑，最大化争用同一把行锁。
+//     */
+//    private RunResult runConcurrentOccupy(int n, BigDecimal amount) throws InterruptedException
+//    {
+//        CountDownLatch ready = new CountDownLatch(n);
+//        CountDownLatch go = new CountDownLatch(1);
+//        CountDownLatch done = new CountDownLatch(n);
+//        ExecutorService pool = Executors.newFixedThreadPool(n);
+//        AtomicInteger success = new AtomicInteger();
+//        List<String> errorMessages = Collections.synchronizedList(new ArrayList<>());
+//
+//        for (int i = 0; i < n; i++)
+//        {
+//            pool.execute(() ->
+//            {
+//                try
+//                {
+//                    // SecurityContextHolder 线程本地：每个 worker 各自注入登录态
+//                    SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext());
+//                    SecurityContextHolder.getContext().setAuthentication(authentication);
+//                    ready.countDown();
+//                    go.await();
+//                    CreditUsageCommand cmd = new CreditUsageCommand();
+//                    cmd.setCustomerId(CUSTOMER_ID);
+//                    cmd.setCurrency(CURRENCY);
+//                    cmd.setBizType(CustomerFundBizType.ORDER);
+//                    cmd.setBizNo("并发测试-" + Thread.currentThread().getName());
+//                    cmd.setAmount(amount);
+//                    CustomerCreditFlow flow = accountApi.occupyCredit(cmd);
+//                    if (flow != null)
+//                    {
+//                        success.incrementAndGet();
+//                        createdFlowIds.add(flow.getId());
+//                    }
+//                }
+//                catch (Exception e)
+//                {
+//                    errorMessages.add(String.valueOf(e.getMessage()));
+//                }
+//                finally
+//                {
+//                    // 标记该线程真正结束，绝不让僵尸线程泄漏到下一个用例
+//                    done.countDown();
+//                }
+//            });
+//        }
+//
+//        ready.await();
+//        go.countDown();
+//        // 必等所有 n 个任务真正执行完毕才返回，超时直接判失败（而不是泄漏继续跑）
+//        boolean finished = done.await(300, TimeUnit.SECONDS);
+//        pool.shutdownNow();
+//        pool.awaitTermination(30, TimeUnit.SECONDS);
+//        assertTrue(finished, "并发任务未在限定时间内全部结束，可能已泄漏到下一用例");
+//
+//        return new RunResult(success.get(), errorMessages);
+//    }
+//
+//    private BigDecimal queryUsedCredit()
+//    {
+//        return queryAmount("SELECT used_credit FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0'");
+//    }
+//
+//    private BigDecimal queryTotalCredit()
+//    {
+//        return queryAmount("SELECT total_credit FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0'");
+//    }
+//
+//    private BigDecimal queryExtraCredit()
+//    {
+//        return queryAmount("SELECT extra_credit FROM ctr_customer_account WHERE customer_id = ? AND currency = ? AND del_flag = '0'");
+//    }
+//
+//    private BigDecimal queryAmount(String sql)
+//    {
+//        BigDecimal value = jdbc.queryForObject(sql, BigDecimal.class, CUSTOMER_ID, CURRENCY);
+//        return value == null ? BigDecimal.ZERO : value;
+//    }
+//
+//    /** 一次并发运行的汇总结果 */
+//    private static class RunResult
+//    {
+//        final int successCount;
+//        final int failureCount;
+//        final List<String> errorMessages;
+//
+//        RunResult(int success, List<String> errors)
+//        {
+//            this.successCount = success;
+//            this.failureCount = errors.size();
+//            this.errorMessages = errors;
+//        }
+//
+//        boolean hasInsufficientMessage()
+//        {
+//            return errorMessages.stream().anyMatch(m -> m != null && m.contains("可用额度不足"));
+//        }
+//    }
+//}