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 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 { 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(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 key, Map 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 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 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"); } } }