feat: add model groups, verified registration and CNY credit grants
This commit is contained in:
1 parent
f5ba6cb255
commit
7a18db2123
40 files changed
+1980
-263
No files matched your search
+202
@@ -0,0 +1,202 @@
|
||||
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<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();
|
||||
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<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"));
|
||||
}
|
||||
}
|
||||
@@ -64,7 +64,7 @@ class AuthPostgresTest {
|
||||
assertThrows(DataIntegrityViolationException.class, () -> jdbc.update("UPDATE users SET role = 'super_admin' WHERE id = ?", operatorId));
|
||||
assertThrows(IllegalStateException.class, () -> auth.ensureAdmin("operator", "test-password", "Other"));
|
||||
|
||||
MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth, 168, true))
|
||||
MockMvc http = MockMvcBuilders.standaloneSetup(new AuthController(auth, org.mockito.Mockito.mock(VerificationService.class), 168, true))
|
||||
.setControllerAdvice(new ApiExceptionHandler()).build();
|
||||
var ownerCookie = login(http, "adimin", "super_admin");
|
||||
var operatorCookie = login(http, "operator", "admin");
|
||||
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
package com.moyi.controlplane.auth;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PasswordHasherInteropTest {
|
||||
@Test
|
||||
void acceptsMaintenanceScriptPbkdf2HashesIncludingUnicode() {
|
||||
PasswordHasher hasher = new PasswordHasher("local-test-pepper");
|
||||
// Python hashlib fixtures with salt bytes 0..15; no real credentials.
|
||||
String ascii = "pbkdf2$210000$AAECAwQFBgcICQoLDA0ODw$_ZW4zVJDiheXQ51WuP_SSr_f8xjYJXBHvjkzLlPtFHo";
|
||||
String unicode = "pbkdf2$210000$AAECAwQFBgcICQoLDA0ODw$qZ4RLM7vU3k0rCJtetdh8uSbnAkWbxFYR7sD4GYRmb8";
|
||||
assertTrue(hasher.matches("Qa-Test42!", ascii));
|
||||
assertTrue(hasher.matches("\u6d4b\u8bd5A1!", unicode));
|
||||
assertFalse(hasher.matches("wrong-password", ascii));
|
||||
assertFalse(new PasswordHasher("wrong-pepper").matches("Qa-Test42!", ascii));
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user