feat(用户密钥): 龙抬头余额按人民币口径上界面——credits 查询+用户端/后管两个读取面

上游事实(官方文档+2026-11-05 从主机B 直打实测):`GET /v1/skills/balance` 顶层 balance 是美元串("$12.345678"),
站内 ⚡=人民币口径在 credits 块(⚡ = 美元 × credits.per_usd)。要跟网页/账单对上必须取 credits,Java 里
不得出现任何汇率字面量。四条硬规则落在 LongtaitouBalanceClient:① 只认 credits.balance/available/frozen,
且 credits.unit 必须为 CREDIT、per_usd>0;② 顶层 $… 与 currency:USD 只作交叉校验(偏差 >0.5% 打 WARN),永不进展示;
③ credits 缺失/不可解析时不回落美元——把 12.34 当 ¥12.34 显示就是"美元当人民币"的假绿;④ 错误体
{error:{code,message,type}} 与 4xx/5xx 一律 available=false + message 原样透出,绝不抛、也不显示成 ¥0。
URL 由 LlmChannel.LONGTAITOU.host() 派生(配置键留空即用域名唯一正本),响应体限读 1MB。

不复用 UserApiSecretBalanceVo:那个类的 surplus/scope/low 语义全是 jikip 代理的,LLM 塞进去会让注释撒谎并
诱导下一个人在 useProxyBalance 里加分支(铁律 25「口径不得借」)。新建 UserLlmBalanceVo + 平行新建
UserLlmBalanceService(不扩 UserProxyBalanceService),缓存键 (userId,moduleKey) 5 分钟;渠道分档:t8star 不打
上游、available=false +「不提供余额查询」(贞贞有没有余额接口在册无判据,不许猜端点、更不许借龙抬头的数)。

后管走实时查、不落库(本窗零 Schema、零迁移):POST /api/admin/user-secrets/balances,requireAdmin +
DataReadScope 逐个剔除越权 userId(不信任前端给的列表)。三条护栏是这条路线不被点爆的唯一防线:单次 ≤20 行
(越限 BusinessException,不静默截断)、固定线程池 adminBalanceConcurrency=4 + 整请求 deadline 10s(到点的行
按「上游未在本轮时间预算内应答」降级并记进 timedOutUserIds 如实上报,不读成 0)、只对真能查的行打上游
(LLM 仅 longtaitou、代理仅 detectFromUrl==JIKIP;t8star/青果零 HTTP),一页 15 行通常只剩 3–8 次调用。
用户端 GET /api/user-secrets/llm-balance?moduleKey= 与既有 proxy-balance 同款 requireUser。

保存/清空密钥与后台代填/清空时代际失效两侧余额缓存:换一把钥匙还挂着上一把的钱就是串档。
配置三键同步 application.yml 与 application-local.example.yml(铁律 3)。

测试:LongtaitouBalanceClientTest 11(官方样例断言 balance=="88.888882"/surplus=="85.288882" 且 12.34/11.84/0.50/$
一律不出现;缺 credits、per_usd<=0、unit≠CREDIT、缺 available 四种坏形状各自 available=false + balance=null;
现网实测 401 missing_api_key / invalid_api_key 形状入夹具——钉的是测过的读数不是猜的错误体)、
UserLlmBalanceServiceTest 10(贞贞 never() 打上游、三态不伪装成 0、缓存命中不二次查询、两模块各回各值)、
UserSecretBalanceAdminServiceTest 7(越上限拒、越权剔、超时行 available=false 而非 0、只有可查行产生 HTTP)。
三支已登记进 ops scripts/score_ratchet.py 的 suites(不入册=闸门永远跑不到)。
catch 棘轮五枚新增全是 NOT_RETHROW(LOG_ONLY/EMPTY 一格没涨),逐处记名抬 STRICT_TOTAL 1065→1069、
notRethrow 604→608。未证事项按 BACKLOG B83-01 如实挂:真 sk- 下 credits 字段逐字核对、后管实时查的现网
并发表现、jikip find-balance 对用户自有套餐 key;本窗代码未随任何 jar 发版。
This commit is contained in:
2026-11-05 12:02:33 +08:00
parent b231a67dd7
commit 609ad396a6
15 changed files with 1381 additions and 6 deletions
@@ -65,7 +65,9 @@ class CatchSilenceRatchetTest {
// 10-31 CR 消项:证据保留期清理失败 WARN 兜底 + 任务号溢出回落 task_no,新增 2 处非抛分支,600 -> 602。
// 11-01 失败任务原任务重试:TaskInPlaceRetryService 的 clearResultError / resetAssembleJob
// 两处 WARN 兜底,602 -> 604(logOnly 249 -> 251;严格格 STRICT_LOG_ONLY 190 -> 192)。
static final int GIVEN_NOT_RETHROW = 604;
// 11-05 密钥余额三面(龙抬头 credits/后管实时查)抬 604 -> 608:五枚新增**全是 NOT_RETHROW**,
// LOG_ONLY 与 EMPTY 一格没涨(逐处记名见 STRICT_TOTAL 上方注释)——改的是"查不到"怎么表达,不是把它藏起来。
static final int GIVEN_NOT_RETHROW = 608;
static final int GIVEN_LOG_ONLY = 251;
static final int GIVEN_EMPTY = 56;
@@ -291,7 +293,18 @@ class CatchSilenceRatchetTest {
// ② resetAssembleJob:复位组装作业失败只 WARN——同理,任务已复位,作业复位失败由
// stuck 扫描兜底,不该阻断用户点出来的这次重试。
// 反向对照:两处都不能改成「吞掉」——WARN 里带 taskId 与异常消息,出问题看得见。
static final int STRICT_TOTAL = 1065;
// 11-05 密钥余额三面(龙抬头人民币余额 client/后管实时查余额)抬 1065 -> 1069,五枚全部 NOT_RETHROW,
// LOG_ONLY 与 EMPTY **一格没涨**——每一枚都把"这次没查到"换成界面读得出的状态,而不是只留一行日志:
// ① `LongtaitouBalanceClient.fetch`:网络/上游异常 ⇒ available=false +「余额查询失败」人话 + WARN。
// 反向对照:改成往外抛=一次余额查询把设置页打成 500;改成静默 return=界面显示 ¥0(假绿)。
// ② `LongtaitouBalanceClient.numberOrNull`:金额串(含 `$`/千分位)解析失败 ⇒ 返回 null ⇒
// 上游 credits 不可解析就当"查不到"。这一枚是"美元当人民币"的闸门:回落顶层数字才是真事故。
// ③ `LongtaitouBalanceClient.parseJson`:应答不是可解析 JSON ⇒ null,调用方给「返回的不是可解析的 JSON」。
// ④ `UserSecretBalanceAdminService` 行等待 `TimeoutException`:cancel 该行的 future、该行按
// 「上游未在本轮时间预算内应答」降级,并把 userId 记进 timedOutUserIds 如实上报(不得读成 0)。
// ⑤ 同处 `ExecutionException | InterruptedException`:先复位中断位,再同样按"未应答"降级+记账+WARN。
// 反向对照:④⑤ 若改成"超时给 0"或"catch 后什么都不记",后管那一列就会把"没问到"卖成"没钱"。
static final int STRICT_TOTAL = 1069;
/**
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
@@ -417,7 +430,9 @@ class CatchSilenceRatchetTest {
// 10-31 Phase 5.1:同 GIVEN_NOT_RETHROW,证据登记补偿回收失败只 WARN,599 -> 600。
// 11-01 失败任务原任务重试:TaskInPlaceRetryService 两处 WARN 兜底(clearResultError /
// resetAssembleJob),严格口径实测 602 -> 604;出处见 STRICT_TOTAL 上方注释。
static final int STRICT_NOT_RETHROW = 604;
// 11-05 密钥余额三面:五枚 NOT_RETHROW(1065->1069 那批),严格口径实测 603 -> 608;
// 上一格 604 是**上限**而实测量一直低它一枚,这次新增把那一枚额度用掉又超上去——逐处见 STRICT_TOTAL 上方。
static final int STRICT_NOT_RETHROW = 608;
/**
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
@@ -0,0 +1,180 @@
package com.nanri.aiimage.modules.usersecret.client;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.nanri.aiimage.config.UserSecretProperties;
import com.nanri.aiimage.modules.usersecret.model.vo.UserLlmBalanceVo;
import com.nanri.aiimage.modules.usersecret.support.LlmChannel;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 龙抬头余额的口径判据(B83:密钥设置与后台列表显示人民币余额)。
*
* <p>这一格要守的是<b>「两套口径里挑了哪一套」</b>。上游同一份响应给了美元串(顶层
* {@code balance="$12.345678"})和 ⚡=人民币({@code credits.balance=88.888882}),
* 取错那一套不会报错、不会返空,只会<b>安静地显示一个差 7.2 倍的数字</b>——用户拿去对账单才发现。
* 所以除了正向断言,这里还反向钉住「美元数字一个都不许出现在返回体里」。</p>
*/
class LongtaitouBalanceClientTest {
/** 官方文档 2026-10-19 那份 {@code GET /v1/skills/balance} 的响应样例,逐字照抄。 */
private static final String OFFICIAL_SAMPLE = """
{
"balance": "$12.345678",
"frozen": "$0.500000",
"available_balance": "$11.845678",
"currency": "USD",
"unit": "USD",
"credits": {
"balance": 88.888882,
"frozen": 3.6,
"available": 85.288882,
"unit": "CREDIT",
"per_usd": 7.2
}
}
""";
private final UserSecretProperties properties = new UserSecretProperties();
private final LongtaitouBalanceClient client =
new LongtaitouBalanceClient(properties, new ObjectMapper());
@Test
void 人民币余额只取credits块不取顶层美元串() {
UserLlmBalanceVo vo = client.parseResponse(newVo(), 200, OFFICIAL_SAMPLE);
assertThat(vo.getAvailable()).isTrue();
assertThat(vo.getBalance()).isEqualTo("88.888882");
assertThat(vo.getAvailableBalance()).isEqualTo("85.288882");
assertThat(vo.getFrozen()).isEqualTo("3.6");
assertThat(vo.getUnit()).isEqualTo("CREDIT");
assertThat(vo.getCheckedAt()).isNotNull();
}
@Test
void 美元数字一个都不许进返回体() {
UserLlmBalanceVo vo = client.parseResponse(newVo(), 200, OFFICIAL_SAMPLE);
// 界面上的 ¥ 后面挂上美元数=差 7.2 倍的假读数;这里把三个美元值全钉成「不许出现」
assertThat(vo.getBalance()).doesNotContain("$").doesNotContain("12.34");
assertThat(vo.getAvailableBalance()).doesNotContain("$").doesNotContain("11.84");
assertThat(vo.getFrozen()).doesNotContain("$").doesNotContain("0.50");
}
@Test
void credits块缺失时宁可不显示也不回落美元() {
String onlyUsd = """
{"balance": "$12.345678", "available_balance": "$11.845678", "currency": "USD"}
""";
UserLlmBalanceVo vo = client.parseResponse(newVo(), 200, onlyUsd);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getBalance()).isNull();
assertThat(vo.getAvailableBalance()).isNull();
assertThat(vo.getMessage()).as("说清为什么不给数字,而不是留一格空白让人以为是 0")
.contains("人民币").contains("不给金额");
}
@Test
void per_usd不为正时按口径不合格处理() {
String badPerUsd = """
{"credits": {"balance": 88.888882, "available": 85.288882, "unit": "CREDIT", "per_usd": 0}}
""";
assertThat(client.parseResponse(newVo(), 200, badPerUsd).getAvailable()).isFalse();
}
@Test
void credits单位不是CREDIT时不认这套口径() {
String otherUnit = """
{"credits": {"balance": 88.888882, "available": 85.288882, "unit": "POINT", "per_usd": 7.2}}
""";
UserLlmBalanceVo vo = client.parseResponse(newVo(), 200, otherUnit);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getUnit()).isNull();
}
@Test
void credits缺available时不半显示() {
String half = """
{"credits": {"balance": 88.888882, "unit": "CREDIT", "per_usd": 7.2}}
""";
assertThat(client.parseResponse(newVo(), 200, half).getAvailable()).isFalse();
}
@Test
void 上游拒绝时原样带出原因且不抛异常() {
String denied = """
{"error": {"code": "insufficient_permissions", "message": "该密钥没有账务权限", "type": "auth"}}
""";
UserLlmBalanceVo vo = client.parseResponse(newVo(), 403, denied);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getMessage()).contains("该密钥没有账务权限").contains("insufficient_permissions");
assertThat(vo.getBalance()).isNull();
}
/**
* 现网实测形状(2026-11-05 从主机 B 直打 {@code longtaitou.token6688.com},不带任何真密钥):
* 无 Authorization ⇒ 401 {@code missing_api_key};带假 key ⇒ 401 {@code invalid_api_key};
* 路径写错才是 404 {@code unknown_url}。这条格把"URL 派生对不对"与"被拒时说什么话"一起钉在实测读数上,
* 而不是钉在猜的错误体上——同一把尺子的 ④⑤ 两支若与这里冲突,以现网为准。
*/
@Test
void 现网实测的401形状按查不到处理并把上游原话带出来() {
String missing = """
{"error":{"code":"401","message":"Authorization header with Bearer token is required","type":"missing_api_key"}}
""";
String invalid = """
{"error":{"code":"401","message":"Invalid API Key","type":"invalid_api_key"}}
""";
assertThat(client.parseResponse(newVo(), 401, missing).getMessage())
.contains("Authorization header with Bearer token is required").contains("401");
UserLlmBalanceVo vo = client.parseResponse(newVo(), 401, invalid);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getMessage()).contains("Invalid API Key");
assertThat(vo.getBalance()).isNull();
}
@Test
void 非JSON应答按查不到处理() {
UserLlmBalanceVo vo = client.parseResponse(newVo(), 200, "<html>网关错误</html>");
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getMessage()).contains("JSON");
}
@Test
void 余额地址按渠道主机派生配置项只作覆盖() {
assertThat(client.balanceUrl())
.isEqualTo(LlmChannel.LONGTAITOU.host() + "/v1/skills/balance");
properties.setLongtaitouBalanceUrl("https://mirror.example.com/v1/skills/balance");
assertThat(client.balanceUrl()).isEqualTo("https://mirror.example.com/v1/skills/balance");
}
@Test
void 没有密钥时不调上游直接说未配置() {
assertThat(client.fetch(null).getAvailable()).isFalse();
UserLlmBalanceVo vo = client.fetch(" ");
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getMessage()).contains("未配置");
// 上面两枚都必须在本方法里返回:真打了上游才会走到网络异常分支
assertThat(vo.getChannel()).isEqualTo(LlmChannel.LONGTAITOU.key());
}
private static UserLlmBalanceVo newVo() {
UserLlmBalanceVo vo = new UserLlmBalanceVo();
vo.setChannel(LlmChannel.LONGTAITOU.key());
vo.setChannelLabel(LlmChannel.LONGTAITOU.label());
return vo;
}
}
@@ -0,0 +1,189 @@
package com.nanri.aiimage.modules.usersecret.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.modules.usersecret.client.LongtaitouBalanceClient;
import com.nanri.aiimage.modules.usersecret.model.vo.UserLlmBalanceVo;
import com.nanri.aiimage.modules.usersecret.support.LlmChannel;
import com.nanri.aiimage.modules.usersecret.support.UserSecretModule;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* LLM 余额服务的分档、缓存与「三态不许伪装成 0」判据(B83)。
*
* <p>形状照 {@link UserProxyBalanceServiceTest}:mock 协作者服务、不连库,
* 拒绝分支一律 {@code verifyNoInteractions} 钉住「一次上游都不打」。</p>
*/
class UserLlmBalanceServiceTest {
private static final long USER_ID = 7L;
private static final String AP = UserSecretModule.APPEARANCE_PATENT.key();
private static final String SA = UserSecretModule.SIMILAR_ASIN.key();
private UserApiSecretService userApiSecretService;
private LongtaitouBalanceClient balanceClient;
private UserLlmBalanceService service;
@BeforeEach
void setUp() {
userApiSecretService = mock(UserApiSecretService.class);
balanceClient = mock(LongtaitouBalanceClient.class);
service = new UserLlmBalanceService(userApiSecretService, balanceClient);
}
@Test
void 贞贞渠道不打龙抬头接口也不借它的数字() {
when(userApiSecretService.findChannel(USER_ID, AP)).thenReturn(LlmChannel.T8STAR.key());
UserLlmBalanceVo vo = service.balance(USER_ID, AP);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getBalance()).as("查不了就说查不了,一格空白或 0 都会被读成「没钱了」").isNull();
assertThat(vo.getMessage()).contains(LlmChannel.T8STAR.label()).contains("不提供余额查询");
verifyNoInteractions(balanceClient);
}
@Test
void 渠道读的是任务执行同一个源不另解析一次() {
when(userApiSecretService.findChannel(USER_ID, AP)).thenReturn(LlmChannel.LONGTAITOU.key());
when(userApiSecretService.findPlainValue(USER_ID, AP)).thenReturn("sk-ap");
when(balanceClient.fetch("sk-ap")).thenReturn(fetched("88.888882", "85.288882"));
UserLlmBalanceVo vo = service.balance(USER_ID, AP);
assertThat(vo.getChannel()).isEqualTo(LlmChannel.LONGTAITOU.key());
assertThat(vo.getModuleKey()).isEqualTo(AP);
assertThat(vo.getModuleLabel()).isEqualTo(UserSecretModule.APPEARANCE_PATENT.label());
assertThat(vo.getBalance()).isEqualTo("88.888882");
verify(userApiSecretService).findChannel(USER_ID, AP);
}
@Test
void 龙抬头渠道但没存密钥时说未配置而不是零() {
when(userApiSecretService.findChannel(USER_ID, AP)).thenReturn(LlmChannel.LONGTAITOU.key());
when(userApiSecretService.findPlainValue(USER_ID, AP)).thenReturn("");
UserLlmBalanceVo vo = service.balance(USER_ID, AP);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getMessage()).contains("还没配置");
assertThat(vo.getBalance()).isNull();
verifyNoInteractions(balanceClient);
}
@Test
void 五分钟缓存内不重复打上游() {
stubLongtaitou(AP, "sk-ap", "88.888882", "85.288882");
service.balance(USER_ID, AP);
service.balance(USER_ID, AP);
verify(balanceClient, times(1)).fetch("sk-ap");
}
@Test
void 改密钥后按userId整批失效下一次重打上游() {
stubLongtaitou(AP, "sk-ap", "88.888882", "85.288882");
stubLongtaitou(SA, "sk-sa", "10.5", "9.5");
service.balance(USER_ID, AP);
service.balance(USER_ID, SA);
service.invalidate(USER_ID);
service.balance(USER_ID, AP);
service.balance(USER_ID, SA);
verify(balanceClient, times(2)).fetch("sk-ap");
verify(balanceClient, times(2)).fetch("sk-sa");
}
@Test
void 失效只影响该用户不动别人的缓存() {
stubLongtaitou(AP, "sk-ap", "88.888882", "85.288882");
service.balance(USER_ID, AP);
service.invalidate(99L);
service.balance(USER_ID, AP);
verify(balanceClient, times(1)).fetch("sk-ap");
}
@Test
void 两张卡各回各的钱A的数字不许出现在B行() {
stubLongtaitou(AP, "sk-ap", "88.888882", "85.288882");
stubLongtaitou(SA, "sk-sa", "12.500000", "10.000000");
List<UserLlmBalanceVo> items = service.bundle(USER_ID);
assertThat(items).hasSize(UserSecretModule.requiredModules().size());
assertThat(items).extracting(UserLlmBalanceVo::getModuleKey).containsExactly(AP, SA);
assertThat(itemOf(items, AP).getBalance()).isEqualTo("88.888882");
assertThat(itemOf(items, SA).getBalance()).isEqualTo("12.500000");
assertThat(itemOf(items, SA).getBalance()).doesNotContain("88.88");
}
@Test
void 代理模块问LLM余额当场拒而不是回一格假数() {
assertThatThrownBy(() -> service.balance(USER_ID, UserSecretModule.PROXY.key()))
.isInstanceOf(BusinessException.class)
.hasMessageContaining("代理");
}
@Test
void 未知模块与非法用户ID直接拒() {
assertThatThrownBy(() -> service.balance(USER_ID, "zhuan利汇"))
.isInstanceOf(BusinessException.class);
assertThatThrownBy(() -> service.balance(null, AP)).isInstanceOf(BusinessException.class);
assertThatThrownBy(() -> service.balance(0L, AP)).isInstanceOf(BusinessException.class);
verify(balanceClient, never()).fetch(any());
}
@Test
void 上游降级时服务不二次包装直接透传() {
UserLlmBalanceVo degraded = new UserLlmBalanceVo();
degraded.setAvailable(false);
degraded.setMessage("龙抬头没有返回人民币(⚡)口径的余额块,为避免把美元数字当人民币显示,这里不给金额");
when(userApiSecretService.findChannel(anyLong(), eq(AP))).thenReturn(LlmChannel.LONGTAITOU.key());
when(userApiSecretService.findPlainValue(USER_ID, AP)).thenReturn("sk-ap");
when(balanceClient.fetch("sk-ap")).thenReturn(degraded);
UserLlmBalanceVo vo = service.balance(USER_ID, AP);
assertThat(vo.getAvailable()).isFalse();
assertThat(vo.getMessage()).isEqualTo(degraded.getMessage());
assertThat(vo.getModuleKey()).isEqualTo(AP);
}
private void stubLongtaitou(String moduleKey, String plain, String balance, String available) {
when(userApiSecretService.findChannel(USER_ID, moduleKey)).thenReturn(LlmChannel.LONGTAITOU.key());
when(userApiSecretService.findPlainValue(USER_ID, moduleKey)).thenReturn(plain);
when(balanceClient.fetch(plain)).thenReturn(fetched(balance, available));
}
private static UserLlmBalanceVo fetched(String balance, String available) {
UserLlmBalanceVo vo = new UserLlmBalanceVo();
vo.setChannel(LlmChannel.LONGTAITOU.key());
vo.setChannelLabel(LlmChannel.LONGTAITOU.label());
vo.setAvailable(true);
vo.setBalance(balance);
vo.setAvailableBalance(available);
vo.setUnit("CREDIT");
return vo;
}
private static UserLlmBalanceVo itemOf(List<UserLlmBalanceVo> items, String moduleKey) {
return items.stream().filter(item -> moduleKey.equals(item.getModuleKey())).findFirst().orElseThrow();
}
}
@@ -0,0 +1,195 @@
package com.nanri.aiimage.modules.usersecret.service;
import com.nanri.aiimage.common.exception.BusinessException;
import com.nanri.aiimage.common.model.entity.AdminUserEntity;
import com.nanri.aiimage.common.service.DataReadScope;
import com.nanri.aiimage.common.service.ReadScope;
import com.nanri.aiimage.config.UserSecretProperties;
import com.nanri.aiimage.modules.usersecret.model.dto.AdminUserSecretBalanceQuery;
import com.nanri.aiimage.modules.usersecret.model.vo.AdminUserSecretBalancesVo;
import com.nanri.aiimage.modules.usersecret.model.vo.UserApiSecretBalanceVo;
import com.nanri.aiimage.modules.usersecret.model.vo.UserLlmBalanceVo;
import com.nanri.aiimage.modules.usersecret.support.UserSecretModule;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 后台余额侧写的三条护栏判据(B83:用户拍板「实时查上游、不落库」)。
*
* <p>实时这条路的风险不是「查不到」,而是<b>拿后管翻页去压上游</b>和<b>把超时读成没钱</b>。
* 所以三格各钉一个方向:上限必须当场拒(静默截断会让管理员以为整页都刷过了)、
* 越权 userId 必须剔掉并回传(前端给的列表不是安全边界)、
* 超预算的行必须报「未应答」且 {@code balance} 为空(一格 0 就是欠费假警报)。</p>
*/
class UserSecretBalanceAdminServiceTest {
private static final long USER_A = 1L;
private static final long USER_B = 2L;
private static final String AP = UserSecretModule.APPEARANCE_PATENT.key();
private UserLlmBalanceService llmBalanceService;
private UserProxyBalanceService proxyBalanceService;
private DataReadScope dataReadScope;
private UserSecretProperties properties;
private UserSecretBalanceAdminService service;
private final AdminUserEntity operator = new AdminUserEntity();
@BeforeEach
void setUp() {
llmBalanceService = mock(UserLlmBalanceService.class);
proxyBalanceService = mock(UserProxyBalanceService.class);
dataReadScope = mock(DataReadScope.class);
properties = new UserSecretProperties();
service = new UserSecretBalanceAdminService(
llmBalanceService, proxyBalanceService, dataReadScope, properties);
}
@Test
void 超过单次上限当场拒而不是静默截断() {
List<Long> ids = new ArrayList<>();
for (long i = 1; i <= UserSecretBalanceAdminService.MAX_ROWS_PER_CALL + 1; i++) {
ids.add(i);
}
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
assertThatThrownBy(() -> service.balances(operator, query(ids)))
.isInstanceOf(BusinessException.class)
.hasMessageContaining(String.valueOf(UserSecretBalanceAdminService.MAX_ROWS_PER_CALL))
.hasMessageContaining("每页数量");
verifyNoInteractions(llmBalanceService, proxyBalanceService);
}
@Test
void 越权userId不查并如实回传denied() {
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.users(List.of(USER_A)));
stubFast(USER_A);
AdminUserSecretBalancesVo vo = service.balances(operator, query(List.of(USER_A, USER_B)));
assertThat(vo.getItems()).extracting(AdminUserSecretBalancesVo.Item::getUserId)
.containsExactly(USER_A);
assertThat(vo.getDeniedUserIds()).containsExactly(USER_B);
verify(llmBalanceService, never()).balance(eq(USER_B), any());
verify(proxyBalanceService, never()).balance(USER_B);
}
@Test
void 超预算的行报未应答且余额为空() {
properties.setAdminBalanceDeadlineMillis(1000L);
properties.setAdminBalanceConcurrency(4);
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
when(llmBalanceService.balance(anyLong(), any())).thenAnswer(invocation -> {
Thread.sleep(4000L);
return llm("88.888882");
});
when(proxyBalanceService.balance(USER_A)).thenAnswer(invocation -> {
Thread.sleep(4000L);
return proxy("1234");
});
AdminUserSecretBalancesVo vo = service.balances(operator, query(List.of(USER_A)));
AdminUserSecretBalancesVo.Item item = vo.getItems().get(0);
assertThat(item.getLlm()).hasSize(UserSecretModule.requiredModules().size());
UserLlmBalanceVo llmRow = item.getLlm().get(0);
assertThat(llmRow.getAvailable()).isFalse();
assertThat(llmRow.getBalance()).as("超时绝不是 0:一格 0 会被读成「欠费了」").isNull();
assertThat(llmRow.getMessage()).contains("时间预算").contains("不代表余额为 0");
assertThat(item.getProxy().getAvailable()).isFalse();
assertThat(item.getProxy().getBalance()).isNull();
assertThat(item.getProxy().getSurplus()).isNull();
assertThat(vo.getTimedOutUserIds()).containsExactly(USER_A);
}
@Test
void 正常行逐格带上数与代理侧写() {
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
stubFast(USER_A);
AdminUserSecretBalancesVo vo = service.balances(operator, query(List.of(USER_A)));
AdminUserSecretBalancesVo.Item item = vo.getItems().get(0);
assertThat(item.getLlm()).extracting(UserLlmBalanceVo::getBalance)
.containsOnly("88.888882");
assertThat(item.getProxy().getAvailable()).isTrue();
assertThat(item.getProxy().getSurplus()).isEqualTo("1234");
assertThat(vo.getTimedOutUserIds()).isEmpty();
assertThat(vo.getDeniedUserIds()).isEmpty();
}
@Test
void 空请求与脏id不打上游() {
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
assertThat(service.balances(operator, query(List.of())).getItems()).isEmpty();
// List.of 不吃 null,这里必须用 Arrays.asList 才造得出「前端塞了脏 id」那一形状
assertThat(service.balances(operator, query(Arrays.asList(0L, -3L, null))).getItems()).isEmpty();
assertThat(service.balances(operator, new AdminUserSecretBalanceQuery()).getItems()).isEmpty();
verifyNoInteractions(llmBalanceService, proxyBalanceService);
}
@Test
void 重复的userId去重后只查一轮() {
when(dataReadScope.readScope(any(), any())).thenReturn(ReadScope.unfiltered());
stubFast(USER_A);
AdminUserSecretBalancesVo vo = service.balances(operator, query(List.of(USER_A, USER_A, USER_A)));
assertThat(vo.getItems()).hasSize(1);
// 三行重复 id 若没去重,这里会变成 6 次 LLM + 3 次代理=拿后管页自己造洪水
verify(llmBalanceService, times(UserSecretModule.requiredModules().size()))
.balance(eq(USER_A), any());
verify(proxyBalanceService, times(1)).balance(USER_A);
}
@Test
void 代填或清空后两族缓存一起丢() {
service.invalidate(USER_A);
verify(llmBalanceService).invalidate(USER_A);
verify(proxyBalanceService).invalidate(USER_A);
}
private void stubFast(long userId) {
when(llmBalanceService.balance(eq(userId), any())).thenReturn(llm("88.888882"));
when(proxyBalanceService.balance(userId)).thenReturn(proxy("1234"));
}
private static UserLlmBalanceVo llm(String balance) {
UserLlmBalanceVo vo = new UserLlmBalanceVo();
vo.setAvailable(true);
vo.setBalance(balance);
vo.setUnit("CREDIT");
return vo;
}
private static UserApiSecretBalanceVo proxy(String surplus) {
UserApiSecretBalanceVo vo = new UserApiSecretBalanceVo();
vo.setAvailable(true);
vo.setSurplus(surplus);
vo.setScope("user");
return vo;
}
private static AdminUserSecretBalanceQuery query(List<Long> userIds) {
AdminUserSecretBalanceQuery query = new AdminUserSecretBalanceQuery();
query.setUserIds(userIds);
return query;
}
}