Files
moyi-model-intelligence-hub/control-plane-java/src/test/java/com/moyi/controlplane/PlatformAdminPostgresTest.java
T

597 lines
51 KiB
Java
Raw Normal View History

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 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(VerificationService.class, () -> new VerificationService(jdbc, sender, "test-pepper"));
context.refresh();
auth = context.getBean(AuthService.class);
catalog = context.getBean(CatalogService.class);
wallet = context.getBean(WalletService.class);
verification = context.getBean(VerificationService.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));
var edited = catalog.updateProvider(channelId,Map.of("name","Relay Updated","baseUrl","https://example.test/v2","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.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());
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 {
MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth,verification,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));
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"));
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");
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;
assertThrows(ApiException.class, () -> verification.send("failed@example.test",invite,"127.0.0.1"));
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 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");
}
}
}