- OpenAiCompatibleProvider:总期限上限 3600 秒(默认仍 90),新增首字节与空闲超时,流式有数据即重置空闲窗口 - GatewayRequestExecutionService:调用期间定时续期钱包预留与 Redis 租约,结束即停 - ChatBillingService.renew 只延长 pending 预留;GatewayGuard 只续仍持有的租约,丢失不重建 - 新增本地 Docker 启动覆盖文件(预编译产物,仅监听 127.0.0.1) - 新增流式空闲/长流、续期、过期恢复不释放运行中调用、租约续期回归 验证:mvn -B -o clean verify 409 项通过(独立 PostgreSQL/Redis) Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
632 lines
54 KiB
Java
632 lines
54 KiB
Java
package com.moyi.controlplane;
|
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import com.moyi.controlplane.auth.*;
|
|
import com.moyi.controlplane.catalog.CatalogService;
|
|
import com.moyi.controlplane.common.ApiException;
|
|
import com.moyi.controlplane.common.ApiExceptionHandler;
|
|
import com.moyi.controlplane.security.SecretCipher;
|
|
import com.moyi.controlplane.wallet.WalletService;
|
|
import com.moyi.controlplane.wallet.ChatBillingService;
|
|
import com.moyi.controlplane.gateway.ChatMeter;
|
|
import com.moyi.controlplane.catalog.CatalogController;
|
|
import com.moyi.controlplane.usage.*;
|
|
import jakarta.servlet.http.Cookie;
|
|
import java.math.BigDecimal;
|
|
import java.util.*;
|
|
import java.util.concurrent.*;
|
|
import javax.sql.DataSource;
|
|
import org.flywaydb.core.Flyway;
|
|
import org.junit.jupiter.api.*;
|
|
import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
|
|
import org.springframework.context.annotation.*;
|
|
import org.springframework.jdbc.core.JdbcTemplate;
|
|
import org.springframework.jdbc.datasource.*;
|
|
import org.springframework.test.web.servlet.MockMvc;
|
|
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
|
|
import org.springframework.transaction.annotation.EnableTransactionManagement;
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
|
|
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
|
|
|
|
@EnabledIfEnvironmentVariable(named="MOYI_AUTH_TEST_JDBC_URL", matches="jdbc:postgresql://127\\.0\\.0\\.1:[0-9]+/.+")
|
|
class PlatformAdminPostgresTest {
|
|
@Configuration @EnableTransactionManagement(proxyTargetClass=true)
|
|
static class Transactions {}
|
|
static class TestSender implements VerificationSender {
|
|
final Map<String,String> codes = new ConcurrentHashMap<>();
|
|
boolean enabled = true;
|
|
boolean fail = false;
|
|
public boolean available(String channel) { return enabled; }
|
|
public void send(String channel, String account, String code) {
|
|
if (fail) throw new ApiException("VERIFICATION_SEND_FAILED", "Test sender unavailable", 502);
|
|
codes.put(account, code);
|
|
}
|
|
}
|
|
private final ObjectMapper json = new ObjectMapper().findAndRegisterModules();
|
|
private final AuthService.RequestMeta meta = new AuthService.RequestMeta("127.0.0.1", "isolated-test");
|
|
private DriverManagerDataSource base;
|
|
private AnnotationConfigApplicationContext context;
|
|
private JdbcTemplate jdbc;
|
|
private String schema, ownerToken, memberToken;
|
|
private UUID memberId;
|
|
private AuthService auth;
|
|
private CatalogService catalog;
|
|
private WalletService wallet;
|
|
private VerificationService verification;
|
|
private VerificationDispatchService dispatch;
|
|
private TestSender sender;
|
|
|
|
@BeforeEach void setup() throws Exception {
|
|
String url = System.getenv("MOYI_AUTH_TEST_JDBC_URL");
|
|
schema = "platform_test_" + UUID.randomUUID().toString().replace("-", "");
|
|
base = new DriverManagerDataSource(url, "moyi_role_test", "");
|
|
var source = new DriverManagerDataSource(url + "?currentSchema=" + schema, "moyi_role_test", "");
|
|
jdbc = new JdbcTemplate(source);
|
|
Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).target("9").load().migrate();
|
|
var legacyIds = jdbc.queryForList("SELECT id FROM model_catalog ORDER BY id", String.class);
|
|
UUID legacyUser = UUID.randomUUID(), legacyKey = UUID.randomUUID();
|
|
String legacyGrants = json.writeValueAsString(List.of(legacyIds.getFirst()));
|
|
jdbc.update("INSERT INTO users(id,account,account_kind,password_hash,display_name) VALUES (?,'legacy_member','username','not-a-login-hash','Legacy Member')", legacyUser);
|
|
jdbc.update("INSERT INTO platform_api_keys(id,user_id,name,key_prefix,key_hash,model_ids) VALUES (?,?,'Legacy Key','test-prefix',?,?::jsonb)", legacyKey, legacyUser, "a".repeat(64), legacyGrants);
|
|
Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).load().migrate();
|
|
// V14 adds relay definitions/routes. Existing legacy routes and grants must survive
|
|
// alongside the expanded catalog rather than making the catalog remain seven rows.
|
|
assertTrue(jdbc.queryForList("SELECT id FROM model_catalog ORDER BY id", String.class).containsAll(legacyIds));
|
|
for (String legacyId : legacyIds) {
|
|
assertEquals(legacyId, jdbc.queryForObject("SELECT logical_model_id FROM model_catalog WHERE id=?", String.class, legacyId));
|
|
}
|
|
assertEquals(json.readTree(legacyGrants), json.readTree(jdbc.queryForObject("SELECT model_ids::text FROM platform_api_keys WHERE id=?", String.class, legacyKey)));
|
|
context = new AnnotationConfigApplicationContext();
|
|
sender = new TestSender();
|
|
context.register(Transactions.class);
|
|
context.registerBean(DataSource.class, () -> source);
|
|
context.registerBean(DataSourceTransactionManager.class, () -> new DataSourceTransactionManager(source));
|
|
context.registerBean(AuthService.class, () -> new AuthService(jdbc, new PasswordHasher("test-pepper"), json, 168));
|
|
context.registerBean(TotpService.class, () -> new TotpService(jdbc,new SecretCipher("test-mfa")));
|
|
context.registerBean(CatalogService.class, () -> new CatalogService(jdbc, json, new SecretCipher("test-encryption")));
|
|
context.registerBean(WalletService.class, () -> new WalletService(jdbc, context.getBean(AuthService.class)));
|
|
context.registerBean(UsageAuditService.class, () -> new UsageAuditService(jdbc,json));
|
|
context.registerBean(ChatBillingService.class, () -> new ChatBillingService(jdbc,json,context.getBean(UsageAuditService.class)));
|
|
context.registerBean(VerificationDispatchService.class, () -> new VerificationDispatchService(jdbc,sender,new SecretCipher("test-delivery-encryption"),json,context.getBean(DataSourceTransactionManager.class)));
|
|
context.registerBean(VerificationService.class, () -> new VerificationService(jdbc, context.getBean(VerificationDispatchService.class), "test-pepper"));
|
|
context.refresh();
|
|
auth = context.getBean(AuthService.class);
|
|
catalog = context.getBean(CatalogService.class);
|
|
wallet = context.getBean(WalletService.class);
|
|
verification = context.getBean(VerificationService.class);
|
|
dispatch = context.getBean(VerificationDispatchService.class);
|
|
auth.ensureAdmin("test_owner", "local-password", "Test Owner");
|
|
ownerToken = auth.login("test_owner", "local-password", meta).token();
|
|
memberId = auth.createUser(ownerToken, "test_member", "local-password", "Test Member", meta).id();
|
|
memberToken = auth.login("test_member", "local-password", meta).token();
|
|
}
|
|
@AfterEach void cleanup() {
|
|
if (context != null) context.close();
|
|
// Only the random schema created by this isolated test is removed.
|
|
if (base != null && schema != null) new JdbcTemplate(base).execute("DROP SCHEMA IF EXISTS " + schema + " CASCADE");
|
|
}
|
|
@Test void modelGroupsKeepExactKeyGrantsAndEditableChannels() {
|
|
var channel = catalog.createProvider(Map.of("code","test-relay","name","Relay","protocol","openai-compatible","sourceType","relay","baseUrl","https://example.test/v1","credentialType","api-key","credentialSecret","only-a-test-secret"), ownerToken, auth);
|
|
String channelId = channel.get("id").toString();
|
|
String cipher = jdbc.queryForObject("SELECT credential_ciphertext FROM model_providers WHERE id=?", String.class, channelId);
|
|
var model = catalog.saveDefinition(null,Map.of("publicName","Test Model","vendorName","OpenAI","type","text","mode","sync"),ownerToken,auth);
|
|
String modelId = model.get("id").toString();
|
|
assertEquals("OpenAI", model.get("vendorName"));
|
|
var first = catalog.createModel(Map.of("logicalModelId",modelId,"providerId",channelId,"sourceLabel","Primary","upstreamModel","upstream-a"),ownerToken,auth);
|
|
String firstId = first.get("id").toString();
|
|
var second = catalog.createModel(Map.of("logicalModelId",modelId,"providerId",channelId,"sourceLabel","Backup","upstreamModel","upstream-b"),ownerToken,auth);
|
|
String secondId = second.get("id").toString();
|
|
var keyResult = catalog.createKey(memberToken,Map.of("modelIds",List.of(firstId)),auth);
|
|
String plaintext = keyResult.get("key").toString();
|
|
var key = catalog.authenticateKey(plaintext);
|
|
String keyId = key.get("id").toString();
|
|
assertTrue(catalog.keyCanInvoke(key,firstId));
|
|
assertFalse(catalog.keyCanInvoke(key,secondId));
|
|
assertFalse(catalog.keyCanInvoke(key,modelId));
|
|
assertThrows(ApiException.class, () -> catalog.updateKeyModels(ownerToken,keyId,List.of(secondId),auth));
|
|
// The stored key must never follow a changed endpoint without being re-entered.
|
|
assertEquals("CREDENTIAL_REENTRY_REQUIRED", assertThrows(ApiException.class, () -> catalog.updateProvider(channelId,Map.of("baseUrl","https://attacker.test/v1","credentialSecret",""),ownerToken,auth)).getCode());
|
|
assertEquals("https://example.test/v1",jdbc.queryForObject("SELECT base_url FROM model_providers WHERE id=?",String.class,channelId));
|
|
var edited = catalog.updateProvider(channelId,Map.of("name","Relay Updated","baseUrl","https://example.test/v1/","credentialSecret",""),ownerToken,auth);
|
|
assertEquals("Relay Updated",edited.get("name"));
|
|
assertFalse(edited.containsKey("credentialSecret"));
|
|
assertEquals(cipher,jdbc.queryForObject("SELECT credential_ciphertext FROM model_providers WHERE id=?",String.class,channelId));
|
|
catalog.updateProvider(channelId,Map.of("baseUrl","https://example.test/v2","credentialSecret","replacement-test-secret"),ownerToken,auth);
|
|
assertNotEquals(cipher,jdbc.queryForObject("SELECT credential_ciphertext FROM model_providers WHERE id=?",String.class,channelId));
|
|
assertTrue(jdbc.queryForObject("SELECT string_agg(details::text,' ') FROM auth_audit_log WHERE event_type='provider.updated'",String.class).contains("previousBaseUrl"));
|
|
catalog.saveDefinition(modelId,Map.of("publicName","Renamed"),ownerToken,auth);
|
|
assertEquals("Renamed",catalog.activeModel(firstId).get("publicName"));
|
|
catalog.updateModel(firstId,Map.of("sourceLabel","Edited Group","upstreamModel","upstream-c","maxConcurrency",2),ownerToken,auth);
|
|
assertEquals("upstream-c",catalog.activeModel(firstId).get("upstreamModel"));
|
|
assertTrue(catalog.keyCanInvoke(catalog.authenticateKey(plaintext),firstId));
|
|
catalog.updateProvider(channelId,Map.of("status","disabled"),ownerToken,auth);
|
|
assertNull(catalog.activeModel(firstId));
|
|
assertTrue(catalog.listModels(false).stream().noneMatch(row -> row.get("id").equals(firstId)));
|
|
catalog.updateKeyModels(memberToken,keyId,List.of(firstId),auth);
|
|
assertThrows(ApiException.class, () -> catalog.updateKeyModels(memberToken,keyId,List.of(firstId,secondId),auth));
|
|
catalog.updateProvider(channelId,Map.of("status","active"),ownerToken,auth);
|
|
catalog.saveDefinition(modelId,Map.of("status","disabled"),ownerToken,auth);
|
|
assertNull(catalog.activeModel(firstId));
|
|
catalog.saveDefinition(modelId,Map.of("status","active"),ownerToken,auth);
|
|
catalog.updateModel(firstId,Map.of("status","disabled"),ownerToken,auth);
|
|
assertNull(catalog.activeModel(firstId));
|
|
catalog.updateKeyModels(memberToken,keyId,List.of(),auth);
|
|
assertFalse(catalog.keyCanInvoke(catalog.authenticateKey(plaintext),firstId));
|
|
jdbc.update("UPDATE users SET status='disabled' WHERE id=?",memberId);
|
|
assertNull(catalog.authenticateKey(plaintext));
|
|
assertThrows(ApiException.class, () -> catalog.updateProvider(channelId,Map.of("name","bad"),memberToken,auth));
|
|
}
|
|
|
|
@Test void publicCatalogIncludesPendingModelsAndKeyCanKeepMultipleModelGrants() throws Exception {
|
|
var pending = catalog.saveDefinition(null,Map.of("publicName","Pending Catalog Model","type","text","mode","sync"),ownerToken,auth);
|
|
var first = catalog.listModels(false).getFirst();
|
|
var second = catalog.listModels(false).stream().filter(item -> !item.get("logicalModelId").equals(first.get("logicalModelId"))).findFirst().orElseThrow();
|
|
var mvc = MockMvcBuilders.standaloneSetup(new CatalogController(catalog,auth)).setControllerAdvice(new ApiExceptionHandler()).build();
|
|
var cookie = new Cookie("moyi_session",memberToken);
|
|
var response = mvc.perform(get("/api/models").cookie(cookie)).andExpect(status().isOk()).andReturn();
|
|
var payload = json.readTree(response.getResponse().getContentAsString());
|
|
// Members see channel identity only, never endpoints or credential hints.
|
|
assertTrue(payload.get("providers").size() > 0);
|
|
assertTrue(payload.get("providers").findValues("baseUrl").isEmpty());
|
|
assertTrue(payload.get("providers").findValues("credentialMasked").isEmpty());
|
|
assertEquals(catalog.listDefinitions(false).size(),payload.get("logicalModels").size());
|
|
assertTrue(payload.get("logicalModels").size() > 250);
|
|
assertTrue(payload.get("logicalModels").findValuesAsText("id").contains(pending.get("id")));
|
|
assertFalse(payload.get("models").findValuesAsText("logicalModelId").contains(pending.get("id")));
|
|
var created = catalog.createKey(memberToken,Map.of("name","Multiple models"),auth);
|
|
var keyId = ((Map<?,?>)created.get("apiKey")).get("id").toString();
|
|
var ids = List.of(first.get("id").toString(),second.get("id").toString());
|
|
mvc.perform(post("/api/keys/"+keyId+"/models").cookie(cookie).contentType("application/json").content(json.writeValueAsString(Map.of("modelIds",ids))))
|
|
.andExpect(status().isOk()).andExpect(jsonPath("$.apiKey.modelIds.length()").value(2));
|
|
assertEquals(ids, catalog.listKeys(memberToken,auth).stream().filter(key -> keyId.equals(key.get("id").toString())).findFirst().orElseThrow().get("modelIds"));
|
|
var authenticated = catalog.authenticateKey(created.get("key").toString());
|
|
for (String id : ids) assertTrue(catalog.keyCanInvoke(authenticated,id));
|
|
assertThrows(ApiException.class, () -> catalog.updateKeyModels(memberToken,keyId,List.of(pending.get("id").toString()),auth));
|
|
catalog.updateKeyModels(memberToken,keyId,List.of(ids.get(1)),auth);
|
|
assertEquals(List.of(ids.get(1)),catalog.listKeys(memberToken,auth).stream().filter(key -> keyId.equals(key.get("id").toString())).findFirst().orElseThrow().get("modelIds"));
|
|
}
|
|
|
|
@Test void grantsAreExactAuditedIdempotentAndConcurrent() throws Exception {
|
|
assertThrows(ApiException.class, () -> wallet.grant(memberToken,memberId,UUID.randomUUID(),"1","unauthorized",meta));
|
|
for (String invalid : List.of("0","-1","1.001","NaN","1000000.01")) assertThrows(ApiException.class, () -> wallet.grant(ownerToken,memberId,UUID.randomUUID(),invalid,"invalid",meta));
|
|
UUID request = UUID.randomUUID();
|
|
try (var pool = Executors.newFixedThreadPool(4)) {
|
|
var one = pool.submit(() -> wallet.grant(ownerToken,memberId,request,"12.30","test grant",meta));
|
|
var retry = pool.submit(() -> wallet.grant(ownerToken,memberId,request,"12.30","test grant",meta));
|
|
assertEquals(one.get(10,TimeUnit.SECONDS).get("id"),retry.get(10,TimeUnit.SECONDS).get("id"));
|
|
var two = pool.submit(() -> wallet.grant(ownerToken,memberId,UUID.randomUUID(),"0.10","second",meta));
|
|
var three = pool.submit(() -> wallet.grant(ownerToken,memberId,UUID.randomUUID(),"0.20","third",meta));
|
|
two.get(10,TimeUnit.SECONDS); three.get(10,TimeUnit.SECONDS);
|
|
}
|
|
assertThrows(ApiException.class, () -> wallet.grant(ownerToken,memberId,request,"99","test grant",meta));
|
|
assertEquals(0,new BigDecimal("12.60").compareTo(jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId)));
|
|
assertEquals(3,wallet.entries(ownerToken,memberId).size());
|
|
assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM auth_audit_log WHERE event_type='wallet.credit_granted'",Integer.class));
|
|
assertEquals(0,new BigDecimal("12.60").compareTo((BigDecimal)catalog.overview(memberToken,auth).get("availableCredit")));
|
|
}
|
|
|
|
@Test void deletedCatalogAndKeysCannotReturnButHistorySurvives() throws Exception {
|
|
var channel=catalog.createProvider(Map.of("code","lifecycle-channel","name","Lifecycle Channel"),ownerToken,auth);
|
|
String channelId=channel.get("id").toString();
|
|
var model=catalog.saveDefinition(null,Map.of("publicName","Lifecycle Model","type","text","mode","sync"),ownerToken,auth);
|
|
String modelId=model.get("id").toString();
|
|
var group=catalog.createModel(Map.of("logicalModelId",modelId,"providerId",channelId,"sourceLabel","Primary","upstreamModel","test"),ownerToken,auth);
|
|
String groupId=group.get("id").toString();
|
|
var created=catalog.createKey(memberToken,Map.of("name","History Key","modelIds",List.of(groupId)),auth);
|
|
String secret=created.get("key").toString();
|
|
UUID keyId=(UUID)catalog.authenticateKey(secret).get("id");
|
|
MockMvc http=MockMvcBuilders.standaloneSetup(new CatalogController(catalog,auth)).setControllerAdvice(new ApiExceptionHandler()).build();
|
|
http.perform(delete("/api/keys/"+keyId).cookie(new Cookie("moyi_session",memberToken))).andExpect(status().isConflict());
|
|
http.perform(patch("/api/keys/"+keyId+"/status").cookie(new Cookie("moyi_session",ownerToken)).contentType("application/json").content("{\"status\":\"disabled\"}")).andExpect(status().isNotFound());
|
|
catalog.revokeKey(memberToken,keyId.toString(),auth);
|
|
assertNull(catalog.authenticateKey(secret));
|
|
catalog.setKeyStatus(memberToken,keyId.toString(),"active",auth);
|
|
assertNotNull(catalog.authenticateKey(secret));
|
|
new UsageAuditService(jdbc,json).recordCall(memberId,keyId,groupId,channelId,"succeeded",120,10,20,Map.of("messages",List.of(Map.of("role","user","content","history prompt"))),Map.of("reply","saved response"),null,null);
|
|
jdbc.update("INSERT INTO model_tasks(id,user_id,api_key_id,model_id,task_type,status,prompt) VALUES ('history-task',?,?,?,'3d','succeeded','test')",memberId,keyId,groupId);
|
|
catalog.revokeKey(memberToken,keyId.toString(),auth);
|
|
http.perform(delete("/api/keys/"+keyId).cookie(new Cookie("moyi_session",memberToken))).andExpect(status().isNoContent());
|
|
assertTrue(catalog.listKeys(memberToken,auth).isEmpty());
|
|
assertNull(catalog.authenticateKey(secret));
|
|
assertThrows(ApiException.class,()->catalog.setKeyStatus(memberToken,keyId.toString(),"active",auth));
|
|
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM model_tasks WHERE id='history-task'",Integer.class));
|
|
assertThrows(ApiException.class,()->catalog.deleteCatalog("model",modelId,memberToken,auth));
|
|
assertEquals("CHANNEL_IN_USE",assertThrows(ApiException.class,()->catalog.deleteCatalog("channel",channelId,ownerToken,auth)).getCode());
|
|
catalog.deleteCatalog("group",groupId,ownerToken,auth);
|
|
assertNull(catalog.activeModel(groupId));
|
|
assertThrows(ApiException.class,()->catalog.updateModel(groupId,Map.of("status","active"),ownerToken,auth));
|
|
// The removed name can be reused without granting the replacement to existing keys.
|
|
var replacement=catalog.createModel(Map.of("logicalModelId",modelId,"providerId",channelId,"sourceLabel","Primary","upstreamModel","test"),ownerToken,auth);
|
|
catalog.deleteCatalog("model",modelId,ownerToken,auth);
|
|
assertNull(catalog.activeModel(replacement.get("id").toString()));
|
|
catalog.deleteCatalog("channel",channelId,ownerToken,auth);
|
|
assertThrows(ApiException.class,()->catalog.updateProvider(channelId,Map.of("status","active"),ownerToken,auth));
|
|
assertDoesNotThrow(()->catalog.createProvider(Map.of("code","lifecycle-channel","name","New Channel"),ownerToken,auth));
|
|
var history=new UserUsageService(jdbc,auth,json);
|
|
UUID usageId=jdbc.queryForObject("SELECT id FROM usage_events WHERE user_id=?",UUID.class,memberId);
|
|
var detail=history.detail(memberToken,usageId);
|
|
assertEquals("History Key",detail.get("keyName"));
|
|
assertEquals("Lifecycle Model",detail.get("modelName"));
|
|
assertEquals("Lifecycle Channel",detail.get("providerName"));
|
|
assertEquals("saved response",json.valueToTree(detail.get("output")).get("reply").asText());
|
|
}
|
|
|
|
@Test void walletAdjustmentsSerializeAndCannotOverdrawOrReplayTwice() throws Exception {
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"100","initial",meta);
|
|
UUID request=UUID.randomUUID();
|
|
try(var pool=Executors.newFixedThreadPool(2)) {
|
|
var a=pool.submit(()->wallet.adjust(ownerToken,memberId,request,"decrease","20","correction","100",meta));
|
|
var b=pool.submit(()->wallet.adjust(ownerToken,memberId,request,"decrease","20","correction","100",meta));
|
|
assertEquals(a.get(10,TimeUnit.SECONDS).get("id"),b.get(10,TimeUnit.SECONDS).get("id"));
|
|
}
|
|
assertEquals("BALANCE_CHANGED",assertThrows(ApiException.class,()->wallet.adjust(ownerToken,memberId,UUID.randomUUID(),"set","50","stale","100",meta)).getCode());
|
|
assertEquals("INSUFFICIENT_BALANCE",assertThrows(ApiException.class,()->wallet.adjust(ownerToken,memberId,UUID.randomUUID(),"decrease","81","too much","80",meta)).getCode());
|
|
assertThrows(ApiException.class,()->wallet.adjust(memberToken,memberId,UUID.randomUUID(),"set","10","forbidden","80",meta));
|
|
wallet.adjust(ownerToken,memberId,UUID.randomUUID(),"set","0","reset","80",meta);
|
|
assertEquals(0,BigDecimal.ZERO.compareTo(jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId)));
|
|
assertEquals(3,wallet.entries(ownerToken,memberId).size());
|
|
assertEquals(0,BigDecimal.ZERO.compareTo(jdbc.queryForObject("SELECT SUM(amount) FROM wallet_entries WHERE user_id=?",BigDecimal.class,memberId)));
|
|
assertThrows(ApiException.class,()->wallet.adjust(ownerToken,memberId,request,"increase","20","correction","100",meta));
|
|
}
|
|
|
|
@Test void usageFiltersSummaryDetailsAndExportsStayWithinTheSessionOwner() throws Exception {
|
|
var key=catalog.createKey(memberToken,Map.of("name","=formula key"),auth);
|
|
UUID keyId=(UUID)catalog.authenticateKey(key.get("key").toString()).get("id");
|
|
String groupId=jdbc.queryForObject("SELECT id FROM model_catalog ORDER BY id LIMIT 1",String.class);
|
|
String modelId=jdbc.queryForObject("SELECT logical_model_id FROM model_catalog WHERE id=?",String.class,groupId);
|
|
String providerId=jdbc.queryForObject("SELECT provider_id FROM model_catalog WHERE id=?",String.class,groupId);
|
|
var audit=new UsageAuditService(jdbc,json);
|
|
for(int i=0;i<23;i++) audit.recordCall(memberId,keyId,groupId,providerId,"succeeded",100,10,20,Map.of("prompt","member only","api_key","hidden"),Map.of("reply","saved"),null,null);
|
|
UUID other=auth.requireUser(ownerToken).id();
|
|
audit.recordCall(other,null,groupId,providerId,"failed",900,1000,1000,Map.of("prompt","owner confidential"),null,"ERR","internal");
|
|
jdbc.update("UPDATE usage_events SET user_agent='Test Client', request_source='playground', endpoint='/v1/chat/completions', cost_amount=0.5, cached_input_units=2 WHERE user_id=?",memberId);
|
|
jdbc.update("UPDATE usage_events SET admin_note='admin private note' WHERE user_id=?",memberId);
|
|
var service=new UserUsageService(jdbc,auth,json);
|
|
var f=new UserUsageService.Filters(keyId.toString(),modelId,groupId,"succeeded","call","sync","playground","recorded","Client",null,null,2,20,"time","desc");
|
|
var result=service.list(memberToken,f);
|
|
assertEquals(23L,result.get("total")); assertEquals(3,((List<?>)result.get("records")).size());
|
|
var summary=(Map<?,?>)result.get("summary");
|
|
assertEquals(0,new BigDecimal("11.5").compareTo((BigDecimal)summary.get("totalCost")));
|
|
assertEquals(0,new BigDecimal("230").compareTo((BigDecimal)summary.get("inputUnits")));
|
|
var csv=service.exportCsv(memberToken,f);
|
|
assertEquals(24,csv.lines().count()); assertTrue(csv.contains("'=formula key")); assertFalse(csv.contains("owner confidential"));
|
|
UUID otherId=jdbc.queryForObject("SELECT id FROM usage_events WHERE user_id=?",UUID.class,other);
|
|
assertThrows(ApiException.class,()->service.detail(memberToken,otherId));
|
|
UUID ownId=jdbc.queryForObject("SELECT id FROM usage_events WHERE user_id=? LIMIT 1",UUID.class,memberId);
|
|
var detail=service.detail(memberToken,ownId);
|
|
assertFalse(detail.containsKey("adminNote")); assertFalse(detail.containsKey("sourceIp"));
|
|
assertEquals("[REDACTED]",json.valueToTree(detail.get("input")).get("api_key").asText());
|
|
MockMvc http=MockMvcBuilders.standaloneSetup(new UserUsageController(service)).setControllerAdvice(new ApiExceptionHandler()).build();
|
|
http.perform(get("/api/usage").cookie(new Cookie("moyi_session",memberToken)).param("keyId",keyId.toString()).param("page","2").param("size","20"))
|
|
.andExpect(status().isOk()).andExpect(jsonPath("$.total").value(23)).andExpect(jsonPath("$.records.length()").value(3));
|
|
http.perform(get("/api/usage/"+otherId).cookie(new Cookie("moyi_session",memberToken))).andExpect(status().isNotFound());
|
|
http.perform(get("/api/usage/options").cookie(new Cookie("moyi_session",memberToken))).andExpect(status().isOk());
|
|
http.perform(get("/api/usage/export").cookie(new Cookie("moyi_session",memberToken)).param("status","failed"))
|
|
.andExpect(status().isOk()).andExpect(content().string(org.hamcrest.Matchers.not(org.hamcrest.Matchers.containsString("owner confidential"))));
|
|
}
|
|
|
|
@Test void requestMetadataAndCacheUsageAreRecordedWithoutExposingSecrets() throws Exception {
|
|
String groupId=jdbc.queryForObject("SELECT id FROM model_catalog ORDER BY id LIMIT 1",String.class);
|
|
String providerId=jdbc.queryForObject("SELECT provider_id FROM model_catalog WHERE id=?",String.class,groupId);
|
|
var audit=new UsageAuditService(jdbc,json);
|
|
var request=new org.springframework.mock.web.MockHttpServletRequest("POST","/v1/chat/completions");
|
|
request.addHeader("X-Moyi-Source","playground");
|
|
request.addHeader("User-Agent","Local test browser");
|
|
org.springframework.web.context.request.RequestContextHolder.setRequestAttributes(new org.springframework.web.context.request.ServletRequestAttributes(request));
|
|
try {
|
|
audit.recordCall(memberId,null,groupId,providerId,"succeeded",200,100,20,
|
|
Map.of("prompt","hello","authorization","hidden","accessToken","hidden","refresh_token","hidden","prompt_tokens","hidden"),
|
|
Map.of("usage",Map.of("prompt_tokens_details",Map.of("cached_tokens",80),"cache_creation_input_tokens",5)),null,null);
|
|
} finally { org.springframework.web.context.request.RequestContextHolder.resetRequestAttributes(); }
|
|
var saved=jdbc.queryForMap("SELECT * FROM usage_events WHERE user_id=?",memberId);
|
|
assertEquals("/v1/chat/completions",saved.get("endpoint"));
|
|
assertEquals("api",saved.get("request_source"),"a caller-supplied source header must not reclassify a public API request");
|
|
assertEquals("Local test browser",saved.get("user_agent"));
|
|
assertEquals(80L,saved.get("cached_input_units"));
|
|
assertEquals(5L,saved.get("cache_write_units"));
|
|
assertNull(saved.get("cost_amount"));
|
|
assertNull(saved.get("first_token_ms"));
|
|
assertFalse(saved.get("input_payload").toString().contains("hidden"));
|
|
assertEquals(80,json.readTree(saved.get("output_payload").toString()).path("usage").path("prompt_tokens_details").path("cached_tokens").asInt());
|
|
audit.recordTask(memberId,null,groupId,providerId,"local-timing-task","queued",Map.of("prompt","hello"),null,null,null);
|
|
jdbc.update("UPDATE usage_events SET created_at=now()-interval '2 seconds' WHERE provider_task_id='local-timing-task'");
|
|
audit.updateTask("local-timing-task","succeeded",Map.of("url","https://example.test/result"),null,null);
|
|
assertTrue(jdbc.queryForObject("SELECT latency_ms>=2000 FROM usage_events WHERE provider_task_id='local-timing-task'",Boolean.class));
|
|
}
|
|
|
|
@Test void directCreationCannotEscalateAndOtpIsRequiredOnBothChannels() throws Exception {
|
|
var verifiedAccounts = new VerifiedAccountService(auth, verification, context.getBean(DataSourceTransactionManager.class));
|
|
MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth,verification,verifiedAccounts,168,false)).setControllerAdvice(new ApiExceptionHandler()).build();
|
|
http.perform(post("/api/admin/users").cookie(new Cookie("moyi_session",ownerToken)).contentType("application/json").content("{\"account\":\"created_user\",\"password\":\"test-password\",\"role\":\"super_admin\"}"))
|
|
.andExpect(status().isCreated()).andExpect(jsonPath("$.user.role").value("user")).andExpect(jsonPath("$.user.password").doesNotExist());
|
|
http.perform(post("/api/admin/users").cookie(new Cookie("moyi_session",memberToken)).contentType("application/json").content("{\"account\":\"bad_user\",\"password\":\"test-password\"}"))
|
|
.andExpect(status().isForbidden());
|
|
String invite = auth.createInvitation(ownerToken,"otp test",10,null,meta).get("code").toString();
|
|
for (String account : List.of("otp@example.test","13800000000")) {
|
|
var input = new LinkedHashMap<String,String>(Map.of("account",account,"password","test-password","invitationCode",invite));
|
|
http.perform(post("/api/auth/register").contentType("application/json").content(json.writeValueAsBytes(input))).andExpect(status().isBadRequest());
|
|
http.perform(post("/api/auth/verification").contentType("application/json").content(json.writeValueAsBytes(input)))
|
|
.andExpect(status().isOk()).andExpect(jsonPath("$.code").doesNotExist()).andExpect(jsonPath("$.sent").value(true));
|
|
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
|
|
String code = sender.codes.get(account);
|
|
assertNotEquals(code,jdbc.queryForObject("SELECT code_hash FROM registration_codes WHERE account=?",String.class,account));
|
|
input.put("verificationCode",code);
|
|
http.perform(post("/api/auth/register").contentType("application/json").content(json.writeValueAsBytes(input)))
|
|
.andExpect(status().isCreated()).andExpect(jsonPath("$.user.role").value("user"));
|
|
assertThrows(ApiException.class, () -> verification.consume(account,code));
|
|
}
|
|
}
|
|
|
|
@Test void otpLimitsExpiryAndFailedSendsPersistAcrossTransactions() {
|
|
String invite = auth.createInvitation(ownerToken,"otp limits",20,null,meta).get("code").toString();
|
|
String account="limits@example.test";
|
|
assertThrows(ApiException.class, () -> verification.send(account,"bad-invite","127.0.0.1"));
|
|
verification.send(account,invite,"127.0.0.1");
|
|
assertThrows(ApiException.class, () -> verification.send(account,invite,"127.0.0.1"));
|
|
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
|
|
String correct=sender.codes.get(account);
|
|
String wrong=correct.equals("000000")?"111111":"000000";
|
|
for(int i=0;i<5;i++) assertThrows(ApiException.class, () -> verification.consume(account,wrong));
|
|
assertEquals(5,jdbc.queryForObject("SELECT attempts FROM registration_codes WHERE account=?",Integer.class,account));
|
|
assertThrows(ApiException.class, () -> verification.consume(account,correct));
|
|
verification.send("expired@example.test",invite,"127.0.0.1");
|
|
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
|
|
jdbc.update("UPDATE registration_codes SET expires_at=now()-interval '1 second' WHERE account='expired@example.test'");
|
|
assertThrows(ApiException.class, () -> verification.consume("expired@example.test",sender.codes.get("expired@example.test")));
|
|
sender.fail=true;
|
|
assertEquals(true,verification.send("failed@example.test",invite,"127.0.0.1").get("sent"));
|
|
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
|
|
assertTrue(jdbc.queryForObject("SELECT consumed FROM registration_codes WHERE account='failed@example.test'",Boolean.class));
|
|
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account='failed@example.test'",Integer.class));
|
|
sender.enabled=false;
|
|
assertFalse(verification.capabilities().containsValue(true));
|
|
assertThrows(ApiException.class, () -> verification.send("unavailable@example.test",invite,"127.0.0.1"));
|
|
}
|
|
|
|
record ChatFixture(ChatBillingService billing, Map<String,Object> key, Map<String,Object> model, ChatMeter.Request request) {
|
|
ChatBillingService.Ticket reserve(String idem) { return billing.reserve(key,model,request,idem); }
|
|
}
|
|
ChatFixture chatFixture() {
|
|
var model=new LinkedHashMap<>(catalog.listModels(false).stream().filter(m -> "provider-deepseek".equals(m.get("providerId"))).findFirst().orElseThrow());
|
|
model.put("pricing",Map.of("input",2,"output",4,"cachedInput",1,"unit","CNY / 1M tokens"));
|
|
jdbc.update("UPDATE model_catalog SET pricing='{"+"\"input\":2,\"output\":4,\"cachedInput\":1,\"unit\":\"CNY / 1M tokens\"}'::jsonb WHERE id=?",model.get("id"));
|
|
var created=catalog.createKey(memberToken,Map.of("name","Local billing test","modelIds",List.of(model.get("id"))),auth);
|
|
var key=catalog.authenticateKey(created.get("key").toString());
|
|
var input=ChatMeter.request(Map.of("model",model.get("id"),"messages",List.of(Map.of("role","user","content","你好")),"max_tokens",16),json);
|
|
return new ChatFixture(context.getBean(ChatBillingService.class),key,model,input);
|
|
}
|
|
Map<String,Object> meteredResult() {
|
|
return Map.of("choices",List.of(Map.of("message",Map.of("content","OK"),"finish_reason","stop")),"usage",Map.of("prompt_tokens",100,"completion_tokens",50,"prompt_tokens_details",Map.of("cached_tokens",60)));
|
|
}
|
|
@Test void actualUsageSettlesOnceWithSnapshotAndAtomicHistory() throws Exception {
|
|
var f=chatFixture();
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","billing test",meta);
|
|
var ticket=f.reserve("same-call");
|
|
var held=jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId);
|
|
assertTrue(held.signum()>0);
|
|
assertEquals("DUPLICATE_REQUEST",assertThrows(ApiException.class,()->f.reserve("same-call")).getCode());
|
|
f.model().put("pricing",Map.of("input",999,"output",999,"unit","CNY / 1M tokens"));
|
|
try(var executor=Executors.newFixedThreadPool(2)) {
|
|
var a=executor.submit(()->f.billing().settle(ticket,meteredResult(),20,5));
|
|
var b=executor.submit(()->f.billing().settle(ticket,meteredResult(),20,5));
|
|
assertEquals(new BigDecimal("0.00034000"),a.get()); assertEquals(a.get(),b.get());
|
|
}
|
|
f.billing().fail(ticket,"LATE_FAILURE","Client closed after settlement",20);
|
|
assertEquals(new BigDecimal("0.99966000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(0,jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum());
|
|
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE request_id=?",Integer.class,ticket.id()));
|
|
assertEquals(new BigDecimal("0.00034000"),jdbc.queryForObject("SELECT cost_amount FROM usage_events WHERE id=?",BigDecimal.class,ticket.id()));
|
|
assertEquals(ticket.id().toString(),jdbc.queryForObject("SELECT request_id FROM usage_events WHERE id=?",String.class,ticket.id()));
|
|
assertEquals(100,json.readTree(jdbc.queryForObject("SELECT output_payload::text FROM usage_events WHERE id=?",String.class,ticket.id())).at("/usage/prompt_tokens").intValue());
|
|
assertEquals(2,wallet.entries(ownerToken,memberId).size());
|
|
}
|
|
@Test void reservationBlocksConcurrentSpendingAndAdminWithdrawals() throws Exception {
|
|
var f=chatFixture();
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","billing test",meta);
|
|
jdbc.update("UPDATE user_wallets SET balance=0.004 WHERE user_id=?",memberId);
|
|
try(var executor=Executors.newFixedThreadPool(2)) {
|
|
var ready=new CountDownLatch(1);
|
|
Callable<Object> attempt=()->{ ready.await(); try { return f.reserve(null); } catch(ApiException e) { return e.getCode(); } };
|
|
var a=executor.submit(attempt); var b=executor.submit(attempt); ready.countDown();
|
|
var results=List.of(a.get(),b.get());
|
|
assertEquals(1,results.stream().filter(x -> x instanceof ChatBillingService.Ticket).count());
|
|
assertTrue(results.contains("INSUFFICIENT_BALANCE"));
|
|
}
|
|
assertEquals("INSUFFICIENT_BALANCE",assertThrows(ApiException.class,()->wallet.adjust(ownerToken,memberId,UUID.randomUUID(),"set","0","reserved balance test","0.004",meta)).getCode());
|
|
}
|
|
@Test void invalidUsageAndInterruptedCallsReleaseWithoutCharging() {
|
|
var f=chatFixture();
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","billing test",meta);
|
|
var ticket=f.reserve(null);
|
|
assertEquals("UPSTREAM_USAGE_MISSING",assertThrows(ApiException.class,()->f.billing().settle(ticket,Map.of(),1,null)).getCode());
|
|
f.billing().fail(ticket,"UPSTREAM_USAGE_MISSING","No actual usage",1);
|
|
f.billing().fail(ticket,"RETRY","Already released",1);
|
|
var abandoned=f.reserve(null);
|
|
jdbc.update("UPDATE chat_billing_requests SET expires_at=now()-interval '1 second' WHERE id=?",abandoned.id());
|
|
f.billing().recoverExpired(); f.billing().recoverExpired();
|
|
assertEquals(new BigDecimal("1.00000000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(0,jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum());
|
|
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE operation='usage'",Integer.class));
|
|
assertEquals(2,jdbc.queryForObject("SELECT count(*) FROM usage_events WHERE status='failed' AND cost_amount=0",Integer.class));
|
|
}
|
|
@Test void renewedRunningCallIsNotReleasedByExpiryRecovery() {
|
|
var f=chatFixture();
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","renewal test",meta);
|
|
var running=f.reserve(null);
|
|
jdbc.update("UPDATE chat_billing_requests SET expires_at=now()+interval '5 seconds' WHERE id=?",running.id());
|
|
assertTrue(f.billing().renew(running.id(),1_800_000));
|
|
assertTrue(jdbc.queryForObject("SELECT expires_at>now()+interval '29 minutes' FROM chat_billing_requests WHERE id=?",Boolean.class,running.id()));
|
|
// Renewal never shortens an existing hold.
|
|
assertTrue(f.billing().renew(running.id(),60_000));
|
|
assertTrue(jdbc.queryForObject("SELECT expires_at>now()+interval '29 minutes' FROM chat_billing_requests WHERE id=?",Boolean.class,running.id()));
|
|
f.billing().recoverExpired();
|
|
assertEquals("pending",jdbc.queryForObject("SELECT status FROM chat_billing_requests WHERE id=?",String.class,running.id()));
|
|
assertTrue(jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum()>0);
|
|
f.billing().fail(running,"TEST_DONE","done",1);
|
|
assertFalse(f.billing().renew(running.id(),1_800_000));
|
|
}
|
|
@Test void unexpectedProviderOverrunIsRecordedAsDebtAndBlocksNewCalls() {
|
|
var f=chatFixture();
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","billing test",meta);
|
|
var ticket=f.reserve(null);
|
|
f.billing().settle(ticket,Map.of("usage",Map.of("prompt_tokens",1_000_000,"completion_tokens",0)),10,null);
|
|
assertEquals(new BigDecimal("-1.00000000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals("INSUFFICIENT_BALANCE",assertThrows(ApiException.class,()->f.reserve(null)).getCode());
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"0.50","partial debt repayment",meta);
|
|
assertEquals(new BigDecimal("-0.50000000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
}
|
|
@Test void unpricedRoutesAndEmptyBalancesFailBeforeCreatingHolds() {
|
|
var f=chatFixture();
|
|
assertEquals("INSUFFICIENT_BALANCE",assertThrows(ApiException.class,()->f.reserve(null)).getCode());
|
|
f.model().remove("pricing");
|
|
jdbc.update("UPDATE model_catalog SET pricing=NULL WHERE id=?",f.model().get("id"));
|
|
assertEquals("MODEL_NOT_PRICED",assertThrows(ApiException.class,()->f.reserve(null)).getCode());
|
|
f.model().put("pricing",Map.of("input",1,"output",2,"unit","USD / 1M tokens"));
|
|
jdbc.update("UPDATE model_catalog SET pricing='{"+"\"input\":1,\"output\":2,\"unit\":\"USD / 1M tokens\"}'::jsonb WHERE id=?",f.model().get("id"));
|
|
assertEquals("BILLING_UNIT_UNSUPPORTED",assertThrows(ApiException.class,()->f.reserve(null)).getCode());
|
|
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM chat_billing_requests",Integer.class));
|
|
}
|
|
|
|
@Test void gatewaySyncAndStreamRecordTheSameChargeAndPropagateFailures() throws Exception {
|
|
var f=chatFixture();
|
|
wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","gateway acceptance",meta);
|
|
jdbc.update("UPDATE model_catalog SET pricing=?::jsonb WHERE id=?",json.writeValueAsString(f.model().get("pricing")),f.model().get("id"));
|
|
String key=catalog.createKey(memberToken,Map.of("name","Local gateway test","modelIds",List.of(f.model().get("id"))),auth).get("key").toString();
|
|
var upstream=com.sun.net.httpserver.HttpServer.create(new java.net.InetSocketAddress("127.0.0.1",0),0);
|
|
var mode=new java.util.concurrent.atomic.AtomicReference<>("ok");
|
|
var count=new java.util.concurrent.atomic.AtomicInteger();
|
|
upstream.createContext("/v1/chat/completions",exchange->{
|
|
count.incrementAndGet();
|
|
var input=json.readTree(exchange.getRequestBody());
|
|
if(mode.get().equals("http-error")) { exchange.sendResponseHeaders(500,-1); exchange.close(); return; }
|
|
if(input.path("stream").asBoolean()) {
|
|
exchange.getResponseHeaders().set("Content-Type","text/event-stream"); exchange.sendResponseHeaders(200,0);
|
|
try(var out=exchange.getResponseBody()) {
|
|
String frames="data: {\"model\":\"private-alias\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"OK\"},\"finish_reason\":\"stop\"}]}\n\n";
|
|
if(!mode.get().equals("no-usage")) frames+="data: "+json.writeValueAsString(Map.of("choices",List.of(),"usage",meteredResult().get("usage")))+"\n\n";
|
|
out.write((frames+"data: [DONE]\n\n").getBytes(java.nio.charset.StandardCharsets.UTF_8));
|
|
}
|
|
} else {
|
|
byte[] body=json.writeValueAsBytes(meteredResult()); exchange.getResponseHeaders().set("Content-Type","application/json"); exchange.sendResponseHeaders(200,body.length);
|
|
try(var out=exchange.getResponseBody()) { out.write(body); }
|
|
}
|
|
}); upstream.start();
|
|
var environment=new org.springframework.mock.env.MockEnvironment().withProperty("moyi.providers.deepseek.api-key","local-fake")
|
|
.withProperty("moyi.providers.deepseek.base-url","http://127.0.0.1:"+upstream.getAddress().getPort()+"/v1");
|
|
var provider=new com.moyi.controlplane.provider.OpenAiCompatibleProvider(json,environment,jdbc,new SecretCipher("local-test"));
|
|
try {
|
|
var guard=org.mockito.Mockito.mock(com.moyi.controlplane.gateway.GatewayGuard.class);
|
|
org.mockito.Mockito.doReturn(org.mockito.Mockito.mock(com.moyi.controlplane.gateway.GatewayGuard.Admission.class))
|
|
.when(guard).acquire(org.mockito.ArgumentMatchers.anyMap(),org.mockito.ArgumentMatchers.any(java.util.UUID.class),org.mockito.ArgumentMatchers.anyLong());
|
|
var requestExecution=new com.moyi.controlplane.gateway.request.GatewayRequestExecutionService(
|
|
f.billing(),new com.moyi.controlplane.gateway.request.ApiRequestRiskPolicy(
|
|
com.moyi.controlplane.gateway.request.ApiRequestRiskEngine.allowAll()));
|
|
var controller=new com.moyi.controlplane.gateway.GatewayController(catalog,provider,guard,requestExecution,json);
|
|
var http=MockMvcBuilders.standaloneSetup(controller).setControllerAdvice(new ApiExceptionHandler()).build();
|
|
var input=new LinkedHashMap<>(f.request().body());
|
|
http.perform(post("/v1/chat/completions").header("Authorization","Bearer "+key).header("Idempotency-Key","retry-test").contentType("application/json").content(json.writeValueAsBytes(input)))
|
|
.andExpect(status().isOk()).andExpect(header().string("X-Moyi-Cost-CNY","0.00034000")).andExpect(jsonPath("$.model").value(f.model().get("id")));
|
|
http.perform(post("/v1/chat/completions").header("Authorization","Bearer "+key).header("Idempotency-Key","retry-test").contentType("application/json").content(json.writeValueAsBytes(input))).andExpect(status().isConflict());
|
|
assertEquals(1,count.get());
|
|
input.put("stream",true);
|
|
var streamed=http.perform(post("/v1/chat/completions").header("Authorization","Bearer "+key).header("X-Moyi-Source","playground").contentType("application/json").content(json.writeValueAsBytes(input)))
|
|
.andExpect(status().isOk()).andExpect(content().contentTypeCompatibleWith("text/event-stream")).andReturn().getResponse().getContentAsString();
|
|
assertTrue(streamed.endsWith("data: [DONE]\n\n")); assertFalse(streamed.contains("private-alias"));
|
|
assertEquals(new BigDecimal("0.99932000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM usage_events WHERE call_mode='stream' AND request_source='api' AND cost_amount=0.00034 AND first_token_ms IS NOT NULL",Integer.class));
|
|
mode.set("no-usage");
|
|
var failed=http.perform(post("/v1/chat/completions").header("Authorization","Bearer "+key).contentType("application/json").content(json.writeValueAsBytes(input))).andReturn().getResponse().getContentAsString();
|
|
assertTrue(failed.contains("UPSTREAM_USAGE_MISSING"));
|
|
mode.set("http-error");
|
|
http.perform(post("/v1/chat/completions").header("Authorization","Bearer "+key).contentType("application/json").content(json.writeValueAsBytes(input))).andExpect(status().isBadGateway());
|
|
assertEquals(new BigDecimal("0.99932000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(0,jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum());
|
|
mode.set("ok");
|
|
var disconnected=new org.springframework.mock.web.MockHttpServletResponse() {
|
|
@Override public jakarta.servlet.ServletOutputStream getOutputStream() {
|
|
return new jakarta.servlet.ServletOutputStream() {
|
|
@Override public boolean isReady() { return true; }
|
|
@Override public void setWriteListener(jakarta.servlet.WriteListener listener) { }
|
|
@Override public void write(int b) throws java.io.IOException { throw new java.io.IOException("Browser closed"); }
|
|
};
|
|
}
|
|
};
|
|
controller.chatCompletions("Bearer "+key,input,"closed-browser",disconnected);
|
|
assertEquals(new BigDecimal("0.99898000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE user_id=? AND operation='usage'",Integer.class,memberId));
|
|
assertEquals(new BigDecimal("0.00102000"),catalog.overview(memberToken,auth).get("costThisMonth"));
|
|
} finally { provider.close(); upstream.stop(0); }
|
|
}
|
|
|
|
@Test void failedLedgerTransactionCannotPartiallyDebitTheWallet() {
|
|
var f=chatFixture(); wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","atomicity test",meta);
|
|
var ticket=f.reserve(null);
|
|
jdbc.execute("ALTER TABLE usage_events ADD CONSTRAINT test_reject_cost CHECK (cost_amount IS NULL OR cost_amount=0)");
|
|
assertThrows(org.springframework.dao.DataIntegrityViolationException.class,()->f.billing().settle(ticket,meteredResult(),5,null));
|
|
assertEquals(new BigDecimal("1.00000000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE operation='usage'",Integer.class));
|
|
assertEquals("pending",jdbc.queryForObject("SELECT status FROM chat_billing_requests WHERE id=?",String.class,ticket.id()));
|
|
f.billing().fail(ticket,"SETTLEMENT_FAILED","Test rollback",5);
|
|
assertEquals(0,jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum());
|
|
}
|
|
|
|
@Test void explicitRequestMetadataPersistsWithoutThreadLocalHttpContext() {
|
|
var f=chatFixture(); wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","metadata test",meta);
|
|
var metadata=com.moyi.controlplane.gateway.request.ApiRequestMetadata.playground("198.51.100.7");
|
|
var ticket=f.billing().reserve(f.key(),f.model(),f.request(),"metadata",metadata);
|
|
var saved=jdbc.queryForMap("SELECT request_source,host(source_ip) AS client_ip FROM usage_events WHERE id=?",ticket.id());
|
|
assertEquals("playground",saved.get("request_source"));
|
|
assertEquals("198.51.100.7",saved.get("client_ip"));
|
|
f.billing().fail(ticket,"TEST_COMPLETE","metadata fixture",1);
|
|
|
|
var audit=context.getBean(UsageAuditService.class);
|
|
audit.recordTask(memberId,UUID.fromString(String.valueOf(f.key().get("id"))),String.valueOf(f.model().get("id")),
|
|
String.valueOf(f.model().get("providerId")),"metadata-task","queued",Map.of(),null,null,null,
|
|
com.moyi.controlplane.gateway.request.ApiRequestMetadata.fromHttp("203.0.113.8"));
|
|
saved=jdbc.queryForMap("SELECT request_source,host(source_ip) AS client_ip FROM usage_events WHERE provider_task_id='metadata-task'");
|
|
assertEquals("api",saved.get("request_source"));
|
|
assertEquals("203.0.113.8",saved.get("client_ip"));
|
|
}
|
|
|
|
@Test void gatewaySettlementFailureKeepsDurableMeterAndRecoversExactlyOnce() {
|
|
var f=chatFixture(); wallet.grant(ownerToken,memberId,UUID.randomUUID(),"1","recoverable settlement test",meta);
|
|
var billing=f.billing();
|
|
var execution=new com.moyi.controlplane.gateway.request.GatewayRequestExecutionService(billing,
|
|
new com.moyi.controlplane.gateway.request.ApiRequestRiskPolicy(
|
|
com.moyi.controlplane.gateway.request.ApiRequestRiskEngine.allowAll()));
|
|
var requestContext=new com.moyi.controlplane.gateway.request.ApiRequestContext(memberId,
|
|
UUID.fromString(String.valueOf(f.key().get("id"))),
|
|
com.moyi.controlplane.gateway.request.ApiRequestProtocol.CHAT_COMPLETIONS,
|
|
String.valueOf(f.model().get("id")),String.valueOf(f.model().get("id")),false,
|
|
f.request().reservedInputTokens(),f.request().maxOutputTokens(),
|
|
com.moyi.controlplane.gateway.request.ApiRequestMetadata.internal(),System.nanoTime());
|
|
jdbc.execute("ALTER TABLE usage_events ADD CONSTRAINT test_reject_recoverable_cost CHECK (cost_amount IS NULL OR cost_amount=0)");
|
|
try {
|
|
String result=execution.execute(requestContext,f.key(),f.model(),f.request(),null,
|
|
() -> (com.moyi.controlplane.gateway.request.ApiRequestAdmission)()->{},
|
|
ticket -> { execution.settle(ticket,meteredResult(),5,null); return "unexpected"; },
|
|
failure -> failure instanceof ApiException api ? api : new ApiException("CALL_INTERRUPTED","interrupted",502),
|
|
ApiException::getCode);
|
|
assertEquals("SETTLEMENT_PENDING",result);
|
|
UUID ticketId=jdbc.queryForObject("SELECT id FROM chat_billing_requests WHERE user_id=? ORDER BY created_at DESC LIMIT 1",UUID.class,memberId);
|
|
assertEquals("pending",jdbc.queryForObject("SELECT status FROM chat_billing_requests WHERE id=?",String.class,ticketId));
|
|
assertNotNull(jdbc.queryForObject("SELECT settlement_usage FROM chat_billing_requests WHERE id=?",Object.class,ticketId));
|
|
assertTrue(jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum()>0);
|
|
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE request_id=?",Integer.class,ticketId));
|
|
|
|
jdbc.execute("ALTER TABLE usage_events DROP CONSTRAINT test_reject_recoverable_cost");
|
|
jdbc.update("UPDATE chat_billing_requests SET expires_at=now()-interval '1 second' WHERE id=?",ticketId);
|
|
billing.recoverExpired();
|
|
billing.recoverExpired();
|
|
|
|
assertEquals("succeeded",jdbc.queryForObject("SELECT status FROM chat_billing_requests WHERE id=?",String.class,ticketId));
|
|
assertEquals(new BigDecimal("0.99966000"),jdbc.queryForObject("SELECT balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId));
|
|
assertEquals(0,jdbc.queryForObject("SELECT reserved_balance FROM user_wallets WHERE user_id=?",BigDecimal.class,memberId).signum());
|
|
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM wallet_entries WHERE request_id=?",Integer.class,ticketId));
|
|
} finally {
|
|
jdbc.execute("ALTER TABLE usage_events DROP CONSTRAINT IF EXISTS test_reject_recoverable_cost");
|
|
}
|
|
}
|
|
}
|