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 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(); assertEquals(legacyIds, jdbc.queryForList("SELECT id FROM model_catalog ORDER BY id", String.class)); assertEquals(legacyIds, jdbc.queryForList("SELECT logical_model_id FROM model_catalog ORDER BY id", String.class)); 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(CatalogService.class, () -> new CatalogService(jdbc, json, new SecretCipher("test-encryption"))); context.registerBean(WalletService.class, () -> new WalletService(jdbc, context.getBean(AuthService.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","type","text","mode","sync"),ownerToken,auth); String modelId = model.get("id").toString(); 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 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 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(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")); } }