chore(sql): 调整扩展脚本菜单 ID 段并新增 OIDC 扩展脚本

This commit is contained in:
tongtong committed 2026-11-04 14:29:47 +08:00
commit 95e8ef796d
188 files changed
+5990 -2372

No files matched your search

@@ -1,8 +1,9 @@
package com.youlai.boot;
package com.youlai.boot.architecture;
import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.lang.ArchRule;
import com.tngtech.archunit.core.importer.ImportOption;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.slices;
@@ -13,7 +14,7 @@ import static com.tngtech.archunit.library.dependencies.SlicesRuleDefinition.sli
* @author Ray.Hao
* @since 4.8.0
*/
@AnalyzeClasses(packages = "com.youlai.boot")
@AnalyzeClasses(packages = "com.youlai.boot", importOptions = ImportOption.DoNotIncludeTests.class)
class ArchitectureTest {
@ArchTest
@@ -1,33 +1,36 @@
package com.youlai.boot;
package com.youlai.boot.auth;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.youlai.boot.YouLaiBootApplication;
import tools.jackson.databind.JsonNode;
import tools.jackson.databind.json.JsonMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.webmvc.test.autoconfigure.AutoConfigureMockMvc;
import org.springframework.http.MediaType;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import static org.junit.jupiter.api.Assertions.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
/**
* 认证 + 当前用户接口单元测试
* 认证接口的外部环境集成测试,依赖 dev 配置中的数据库与 Redis
*
* @author Ray.Hao
* @since 4.6.0
*/
@SpringBootTest
@SpringBootTest(classes = YouLaiBootApplication.class)
@Tag("external")
@AutoConfigureMockMvc
@ActiveProfiles("dev")
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@@ -37,14 +40,14 @@ class AuthControllerTest {
private MockMvc mockMvc;
@Autowired
private ObjectMapper objectMapper;
private JsonMapper objectMapper;
private static String accessToken;
@Test
@Order(1)
@DisplayName("登录成功")
void loginSuccess() throws Exception {
void loginShouldReturnTokenPair() throws Exception {
String body = """
{
"username": "admin",
@@ -66,14 +69,13 @@ class AuthControllerTest {
JsonNode root = objectMapper.readTree(result.getResponse().getContentAsString());
accessToken = root.path("data").path("accessToken").asText();
assertNotNull(accessToken, "登录后应返回 accessToken");
assertFalse(accessToken.isBlank(), "accessToken 不能为空");
assertThat(accessToken).as("登录后应返回 accessToken").isNotBlank();
}
@Test
@Order(2)
@DisplayName("密码错误登录失败")
void loginWithWrongPassword() throws Exception {
void wrongPasswordLoginShouldFail() throws Exception {
String body = """
{
"username": "admin",
@@ -92,7 +94,7 @@ class AuthControllerTest {
@Test
@Order(3)
@DisplayName("空用户名登录失败")
void loginWithEmptyUsername() throws Exception {
void emptyUsernameLoginShouldFail() throws Exception {
String body = """
{
"username": "",
@@ -110,8 +112,8 @@ class AuthControllerTest {
@Test
@Order(4)
@DisplayName("登录后获取当前用户信息")
void getCurrentUserWithToken() throws Exception {
assertNotNull(accessToken, "accessToken 应由登录测试先行填充");
void authenticatedUserShouldGetProfile() throws Exception {
assertThat(accessToken).as("accessToken 应由登录测试先行填充").isNotBlank();
mockMvc.perform(get("/api/v1/users/me")
.header("Authorization", "Bearer " + accessToken))
@@ -127,7 +129,7 @@ class AuthControllerTest {
@Test
@Order(5)
@DisplayName("无 Token 请求 /me 返回令牌无效")
void getCurrentUserWithoutToken() throws Exception {
void missingTokenShouldBeRejected() throws Exception {
mockMvc.perform(get("/api/v1/users/me"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.code").value("A0230"))
@@ -137,7 +139,7 @@ class AuthControllerTest {
@Test
@Order(6)
@DisplayName("伪造 Token 请求 /me 返回令牌无效")
void getCurrentUserWithInvalidToken() throws Exception {
void forgedTokenShouldBeRejected() throws Exception {
mockMvc.perform(get("/api/v1/users/me")
.header("Authorization", "Bearer invalid_token_xxx"))
.andExpect(status().isOk())
@@ -0,0 +1,104 @@
package com.youlai.boot.support.realtime;
import com.youlai.boot.common.result.ResultCode;
import com.youlai.boot.support.realtime.config.RealtimeProperties;
import com.youlai.boot.support.realtime.controller.RealtimeController;
import com.youlai.boot.support.realtime.model.CreateRealtimeTicketRequest;
import com.youlai.boot.support.realtime.model.PresenceSnapshot;
import com.youlai.boot.support.realtime.security.RealtimeTicketService;
import jakarta.validation.Validation;
import org.junit.jupiter.api.Test;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 关闭实时通信与临时故障的响应语义
*
* @since 4.13.0
*/
class RealtimeControllerTest {
private final RealtimeTicketService tickets = mock(RealtimeTicketService.class);
private final RealtimeSessionManager sessions = mock(RealtimeSessionManager.class);
private final RealtimeProperties properties = new RealtimeProperties();
private final RealtimeController controller = new RealtimeController(tickets, sessions, properties);
private final CreateRealtimeTicketRequest request =
new CreateRealtimeTicketRequest("client-instance-01", "web", Set.of("notice"));
@Test
void disabledFeatureReturnsDedicatedCodeWithoutIssuingTicket() {
properties.setEnabled(false);
var response = controller.createTicket(request, "Bearer token");
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE);
assertThat(response.getBody().getCode()).isEqualTo("B0102");
assertThat(response.getHeaders().getCacheControl()).isEqualTo("no-store");
verifyNoInteractions(tickets);
}
@Test
void stoppingServerRemainsRetryable() {
when(sessions.isStopping()).thenReturn(true);
var response = controller.createTicket(request, "Bearer token");
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE);
assertThat(response.getBody().getCode()).isNotEqualTo(ResultCode.REALTIME_DISABLED.getCode());
verifyNoInteractions(tickets);
}
@Test
void storageFailureRemainsRetryable() {
when(tickets.create("token", request)).thenThrow(new DataAccessResourceFailureException("offline"));
var response = controller.createTicket(request, "Bearer token");
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE);
assertThat(response.getBody().getCode()).isNotEqualTo(ResultCode.REALTIME_DISABLED.getCode());
}
@Test
void missingCredentialIsUnauthorized() {
assertThat(controller.createTicket(request, null).getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
verifyNoInteractions(tickets);
}
@Test
void forbiddenTopicReturns403WithoutRetryableCode() {
when(tickets.create("token", request)).thenThrow(new AccessDeniedException("forbidden"));
var response = controller.createTicket(request, "Bearer token");
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.FORBIDDEN);
assertThat(response.getBody().getCode()).isEqualTo(ResultCode.ACCESS_UNAUTHORIZED.getCode());
}
@Test
void ticketTopicsAreRequiredAndLimitedToSupportedTopics() {
assertThatThrownBy(() -> new CreateRealtimeTicketRequest("client-instance-01", "web", Set.of("dict")))
.isInstanceOf(IllegalArgumentException.class);
assertThatThrownBy(() -> new CreateRealtimeTicketRequest("client-instance-01", "web", Set.of("notice", "unknown")))
.isInstanceOf(IllegalArgumentException.class);
try (var factory = Validation.buildDefaultValidatorFactory()) {
assertThat(factory.getValidator().validate(new CreateRealtimeTicketRequest("client-instance-01", "web", null)))
.isNotEmpty();
}
}
@Test
void disabledFeatureStillAllowsPresenceCalibration() {
properties.setEnabled(false);
var snapshot = new PresenceSnapshot(0, 0, "node-1", "2026-01-01T00:00:00Z");
when(sessions.presence()).thenReturn(snapshot);
var response = controller.getPresence();
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody().getData()).isEqualTo(snapshot);
}
}
@@ -0,0 +1,48 @@
package com.youlai.boot.support.realtime;
import com.youlai.boot.support.realtime.protocol.RealtimeMessageCodec;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
* 客户端协议的最小字段与输入边界
*
* @since 4.13.0
*/
class RealtimeMessageCodecTest {
private final RealtimeMessageCodec codec = new RealtimeMessageCodec();
@Test
void acceptsPongWithoutMessageIdOrTimestamp() {
var pingId = codec.decodePong("""
{"version":1,"type":"heartbeat.pong","payload":{"pingId":"ping-1"}}
""");
assertThat(pingId).isEqualTo("ping-1");
}
@ParameterizedTest
@ValueSource(strings = {
"null",
"[]",
"{\"version\":2,\"type\":\"heartbeat.pong\",\"payload\":{\"pingId\":\"p\"}}",
"{\"version\":1,\"type\":\"heartbeat.pong\",\"payload\":{}}",
"{\"version\":1,\"type\":\"heartbeat.pong\",\"payload\":{\"pingId\":\" \"}}",
"{\"version\":1,\"type\":\"session.revoked\",\"payload\":{}}",
"{\"version\":1,\"type\":\"subscription.replace\",\"payload\":{\"topics\":[\"notice\",\"dict\"]}}"
})
void rejectsInvalidMessages(String text) {
assertThatThrownBy(() -> codec.decodePong(text)).isInstanceOf(IllegalArgumentException.class);
}
@Test
void limitsUtf8BytesInsteadOfCharacterCount() {
String text = "{\"version\":1,\"type\":\"heartbeat.pong\",\"payload\":{\"pingId\":\"p\"},\"extra\":\""
+ "字".repeat(6_000) + "\"}";
assertThat(text.length()).isLessThan(RealtimeMessageCodec.MAX_MESSAGE_BYTES);
assertThatThrownBy(() -> codec.decodePong(text)).hasMessage("Message too large");
}
}
@@ -0,0 +1,104 @@
package com.youlai.boot.support.realtime;
import com.youlai.boot.support.realtime.config.RealtimeProperties;
import com.youlai.boot.support.realtime.protocol.RealtimeServerMessage;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.stream.LongStream;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyCollection;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 业务消息封装、游标分批与投递配额释放
*
* @since 4.13.0
*/
class RealtimeServiceTest {
private final RealtimeSessionManager sessions = mock(RealtimeSessionManager.class);
private final RealtimeProperties properties = new RealtimeProperties();
private final RealtimeService service = new RealtimeService(sessions, properties);
private final ArrayDeque<Runnable> tasks = new ArrayDeque<>();
@BeforeEach
void captureMaintenanceTasks() {
when(sessions.submitMaintenance(any())).thenAnswer(call -> tasks.offer(call.getArgument(0)));
}
@Test
void createsServerEnvelopeInsideService() {
Map<String, String> payload = Map.of("dictCode", "gender");
service.broadcast("dict", "dict.changed", payload);
tasks.remove().run();
var message = ArgumentCaptor.forClass(RealtimeServerMessage.class);
verify(sessions).broadcast(eq("dict"), message.capture());
assertThat(message.getValue().version()).isEqualTo(1);
assertThat(message.getValue().id()).isNotBlank();
assertThat(message.getValue().payload()).isSameAs(payload);
}
@Test
void passesBatchLimitAndAdvancesCursorBetweenTasks() {
List<Long> cursors = new ArrayList<>();
List<Integer> limits = new ArrayList<>();
service.sendBatches("notice.changed", Map.of("noticeId", "1"), (after, limit) -> {
cursors.add(after);
limits.add(limit);
return after == 0 ? LongStream.rangeClosed(1, limit).boxed().toList() : List.of(101L);
});
tasks.remove().run();
assertThat(cursors).containsExactly(0L);
assertThat(tasks).hasSize(1);
tasks.remove().run();
assertThat(cursors).containsExactly(0L, 100L);
assertThat(limits).containsExactly(100, 100);
assertThat(tasks).isEmpty();
verify(sessions, times(2)).sendToUsers(anyCollection(), any());
}
@Test
void releasesJobSlotAfterQueueRejectionOrLoaderFailure() {
doReturn(false).when(sessions).submitMaintenance(any());
service.sendBatches("notice.changed", Map.of(), (after, limit) -> List.of());
service.sendBatches("notice.changed", Map.of(), (after, limit) -> List.of());
when(sessions.submitMaintenance(any())).thenAnswer(call -> tasks.offer(call.getArgument(0)));
service.sendBatches("notice.changed", Map.of(), (after, limit) -> {
throw new IllegalStateException("query failed");
});
tasks.remove().run();
service.sendBatches("notice.changed", Map.of(), (after, limit) -> List.of());
service.sendBatches("notice.changed", Map.of(), (after, limit) -> List.of());
assertThat(tasks).hasSize(2);
}
@Test
void disabledFeatureDoesNotLoadRecipientsOrSubmitWork() {
properties.setEnabled(false);
BiFunction<Long, Integer, List<Long>> loader = (after, limit) -> {
throw new AssertionError("实时通信关闭时不应查询接收人");
};
service.broadcast("dict", "dict.changed", Map.of());
service.sendBatches("notice.changed", Map.of(), loader);
verify(sessions, never()).submitMaintenance(any());
}
}
@@ -0,0 +1,214 @@
package com.youlai.boot.support.realtime;
import com.youlai.boot.support.realtime.protocol.RealtimeMessageCodec;
import com.youlai.boot.support.realtime.security.RealtimeCredentialVerifier;
import com.youlai.boot.support.realtime.security.RealtimeCredentialVerifier.VerifiedIdentity;
import com.youlai.boot.support.realtime.security.RealtimeTicketService.TicketGrant;
import com.youlai.boot.support.realtime.security.RealtimeTicketService.VerifiedTicket;
import org.junit.jupiter.api.Test;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import tools.jackson.databind.json.JsonMapper;
import java.time.Instant;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;
/**
* 连接期限、权限复核、在线统计与配额生命周期
*
* @since 4.13.0
*/
class RealtimeSessionManagerTest {
private final RealtimeCredentialVerifier verifier = mock(RealtimeCredentialVerifier.class);
private final RealtimeMessageCodec codec = new RealtimeMessageCodec();
private final RealtimeMessageSender sender = new RealtimeMessageSender(Runnable::run);
private final RealtimeSessionManager sessions = new RealtimeSessionManager(sender, codec, verifier, Runnable::run);
private final JsonMapper mapper = JsonMapper.builder().build();
@Test
void registrationUsesVerifiedTicketAndSendsMinimalReady() throws Exception {
List<String> messages = new ArrayList<>();
var transport = transport("socket-1", messages);
Instant expiresAt = Instant.now().plusSeconds(3_600).truncatedTo(java.time.temporal.ChronoUnit.MILLIS);
sessions.register(transport, ticket(1L, "client-1", expiresAt, Set.of("notice")), sessions.reserve());
var ready = mapper.readTree(messages.get(0));
assertThat(ready.path("type").asText()).isEqualTo("connection.ready");
assertThat(ready.path("payload")).isEqualTo(mapper.readTree("{\"heartbeatTimeoutMs\":60000}"));
assertThat(ready.has("occurredAt")).isFalse();
assertThat(state("socket-1").authExpiresAt).isEqualTo(expiresAt);
verifyNoInteractions(verifier);
}
@Test
void presenceChangesWhenUserCountChangesWithSameConnectionCount() throws Exception {
List<String> messages = new ArrayList<>();
var first = transport("first", messages);
var second = transport("second", new ArrayList<>());
sessions.register(first, ticket(1L, "a", Instant.now().plusSeconds(3_600), Set.of("notice", "presence")), sessions.reserve());
sessions.register(second, ticket(1L, "b", Instant.now().plusSeconds(3_600), Set.of("notice")), sessions.reserve());
when(verifier.verify("token-1")).thenReturn(new VerifiedIdentity(1L, true, Instant.now().plusSeconds(3_600)));
sessions.maintain();
messages.clear();
sessions.terminated(second);
var replacement = transport("replacement", new ArrayList<>());
sessions.register(replacement, ticket(2L, "c", Instant.now().plusSeconds(3_600), Set.of("notice")), sessions.reserve());
ReflectionTestUtils.setField(sessions, "lastPresenceAt", System.nanoTime() - TimeUnit.SECONDS.toNanos(6));
sessions.maintain();
var snapshots = messages.stream().map(mapper::readTree)
.filter(message -> "presence.snapshot".equals(message.path("type").asText())).toList();
assertThat(snapshots).hasSize(1);
assertThat(snapshots.get(0).path("payload").path("onlineUsers").asInt()).isEqualTo(2);
assertThat(snapshots.get(0).path("payload").path("onlineConnections").asInt()).isEqualTo(2);
}
@Test
void periodicVerificationStillClosesRevokedCredentials() throws Exception {
var transport = transport("socket-1", new ArrayList<>());
sessions.register(transport, ticket(1L, "a", Instant.now().plusSeconds(3_600), Set.of("notice")), sessions.reserve());
state("socket-1").nextVerifyAt = 0;
when(verifier.verify("token-1")).thenThrow(new BadCredentialsException("revoked"));
sessions.maintain();
verify(transport).close(new CloseStatus(4001, "credential revoked"));
assertThat(sessions.presence().onlineConnections()).isZero();
assertThat(state("socket-1").accessToken()).isNull();
}
@Test
void periodicVerificationStillChecksPresencePermission() throws Exception {
var transport = transport("socket-1", new ArrayList<>());
sessions.register(transport, ticket(1L, "a", Instant.now().plusSeconds(3_600), Set.of("notice", "presence")), sessions.reserve());
when(verifier.verify("token-1")).thenReturn(new VerifiedIdentity(1L, false, Instant.now().plusSeconds(3_600)));
state("socket-1").nextVerifyAt = 0;
sessions.maintain();
verify(transport).close(new CloseStatus(4001, "credential revoked"));
}
@Test
void expiredCredentialsNeverReceiveReadyAndReleaseQuotaOnlyAfterTermination() throws Exception {
List<String> messages = new ArrayList<>();
var transport = transport("socket-1", messages);
var reservation = sessions.reserve();
sessions.register(transport, ticket(1L, "a", Instant.now().minusSeconds(1), Set.of("notice")), reservation);
List<RealtimeSessionManager.Reservation> otherReservations = new ArrayList<>();
for (int index = 0; index < 499; index++) {
otherReservations.add(sessions.reserve());
}
assertThat(messages).isEmpty();
assertThat(sessions.reserve()).isNull();
sessions.terminated(transport);
sessions.terminated(transport);
reservation.close();
var released = sessions.reserve();
assertThat(released).isNotNull();
assertThat(sessions.reserve()).isNull();
released.close();
otherReservations.forEach(RealtimeSessionManager.Reservation::close);
}
@Test
void keepsOneOutstandingPingUntilMatchingPongOrTimeout() throws Exception {
List<String> messages = new ArrayList<>();
var transport = transport("socket-1", messages);
sessions.register(transport, ticket(1L, "a", Instant.now().plusSeconds(3_600), Set.of("notice")), sessions.reserve());
RealtimeSession state = state("socket-1");
state.nextPingAt = 0;
sessions.maintain();
String pingId = state.pendingPingId;
assertThat(pingId).isNotBlank();
sessions.maintain();
sessions.handlePong(transport, "wrong-ping");
assertThat(state.pendingPingId).isEqualTo(pingId);
assertThat(messages).hasSize(2);
sessions.handlePong(transport, pingId);
assertThat(state.pendingPingId).isNull();
assertThat(state.nextPingAt - state.lastPongAt).isEqualTo(TimeUnit.SECONDS.toNanos(25));
state.lastPongAt = System.nanoTime() - TimeUnit.SECONDS.toNanos(61);
sessions.maintain();
verify(transport).close(new CloseStatus(4011, "heartbeat timeout"));
}
@Test
void queuedAndInflightFramesShareBudgetAndReleaseItOnce() throws Exception {
var tasks = new ArrayDeque<Runnable>();
var queuedSender = new RealtimeMessageSender(tasks::add);
var transport = mock(WebSocketSession.class);
var ticket = ticket(1L, "a", Instant.now().plusSeconds(3_600), Set.of("notice"));
var state = new RealtimeSession(transport, ticket.grant(), sessions.reserve(), ticket.credentialExpiresAt());
var frame = RealtimeMessageSender.Frame.of("x".repeat(16_384));
Runnable failure = () -> { throw new AssertionError("发送不应失败"); };
assertThat(queuedSender.enqueue(state, frame, failure)).isTrue();
assertThat(queuedSender.enqueue(state, frame, failure)).isTrue();
assertThat(queuedSender.enqueue(state, frame, failure)).isFalse();
assertThat(state.bufferedBytes).isEqualTo(32_768);
doAnswer(call -> {
state.closed = true;
queuedSender.discardQueued(state);
assertThat(state.bufferedBytes).isEqualTo(16_384);
assertThat(state.bufferedMessages).isEqualTo(1);
return null;
}).when(transport).sendMessage(any());
tasks.remove().run();
assertThat(state.bufferedBytes).isZero();
assertThat(state.bufferedMessages).isZero();
assertThat(state.queue).isEmpty();
state.reservation.close();
}
/**
* 创建握手完成的测试票据
*/
private VerifiedTicket ticket(long userId, String clientId, Instant expiresAt, Set<String> topics) {
var grant = new TicketGrant("token-" + userId, userId, clientId, "web",
topics, Instant.now().plusSeconds(30).toEpochMilli());
return new VerifiedTicket(grant, expiresAt);
}
/**
* 记录连接实际发送的文本帧
*/
private WebSocketSession transport(String id, List<String> messages) throws Exception {
var transport = mock(WebSocketSession.class);
when(transport.getId()).thenReturn(id);
doAnswer(call -> {
messages.add(((TextMessage) call.getArgument(0)).getPayload());
return null;
}).when(transport).sendMessage(any());
return transport;
}
/**
* 取得连接状态以推进测试时钟,不等待真实心跳间隔
*/
@SuppressWarnings("unchecked")
private RealtimeSession state(String id) {
return ((Map<String, RealtimeSession>) ReflectionTestUtils.getField(sessions, "transports")).get(id);
}
}
@@ -0,0 +1,282 @@
package com.youlai.boot.support.realtime;
import com.youlai.boot.support.realtime.config.RealtimeConfig;
import com.youlai.boot.support.realtime.model.CreateRealtimeTicketRequest;
import com.youlai.boot.support.realtime.protocol.RealtimeMessageCodec;
import com.youlai.boot.support.realtime.protocol.RealtimeServerMessage;
import com.youlai.boot.support.realtime.security.RealtimeCredentialVerifier;
import com.youlai.boot.support.realtime.security.RealtimeCredentialVerifier.VerifiedIdentity;
import com.youlai.boot.support.realtime.security.RealtimeHandshakeHandler;
import com.youlai.boot.support.realtime.security.RealtimeHandshakeInterceptor;
import com.youlai.boot.support.realtime.security.RealtimeTicketService;
import org.apache.tomcat.websocket.server.WsSci;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.tomcat.servlet.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.servlet.context.AnnotationConfigServletWebServerApplicationContext;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import tools.jackson.databind.JsonNode;
import tools.jackson.databind.json.JsonMapper;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.net.http.WebSocketHandshakeException;
import java.time.Duration;
import java.time.Instant;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.awaitility.Awaitility.await;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* 本地 Tomcat 上的票据授权、消息投递与心跳闭环,不连接外部存储
*
* @since 4.13.0
*/
class RealtimeWebSocketTest {
private AnnotationConfigServletWebServerApplicationContext context;
private final HttpClient http = HttpClient.newHttpClient();
private final JsonMapper mapper = JsonMapper.builder().build();
private final Instant expiresAt = Instant.now().plusSeconds(3_600).truncatedTo(java.time.temporal.ChronoUnit.MILLIS);
@BeforeEach
void startLocalServer() {
context = new AnnotationConfigServletWebServerApplicationContext(TestConfiguration.class);
when(context.getBean(RealtimeCredentialVerifier.class).verify("access-token"))
.thenReturn(new VerifiedIdentity(1L, true, expiresAt));
}
@AfterEach
void stopLocalServer() {
if (context != null) {
context.close();
}
}
@Test
void connectsWithTicketTopicsAndAnswersHeartbeat() throws Exception {
String ticket = createTicket();
var listener = new Messages();
WebSocket socket = connect(ticket, listener).get(5, TimeUnit.SECONDS);
try {
JsonNode ready = mapper.readTree(listener.next());
assertThat(ready.path("type").asText()).isEqualTo("connection.ready");
assertThat(ready.path("payload")).isEqualTo(mapper.readTree("{\"heartbeatTimeoutMs\":60000}"));
assertThat(ready.size()).isEqualTo(4);
verify(context.getBean(RealtimeCredentialVerifier.class), times(2)).verify("access-token");
var manager = context.getBean(RealtimeSessionManager.class);
manager.broadcast("dict", RealtimeServerMessage.create("dict.changed", Map.of("dictCode", "gender")));
assertThat(mapper.readTree(listener.next()).path("type").asText()).isEqualTo("dict.changed");
RealtimeSession state = currentSession(manager);
synchronized (state) {
state.nextPingAt = 0;
}
manager.maintain();
JsonNode ping = mapper.readTree(listener.next());
assertThat(ping.path("type").asText()).isEqualTo("heartbeat.ping");
socket.sendText("{\"version\":1,\"type\":\"heartbeat.pong\",\"payload\":{\"pingId\":\""
+ ping.path("id").asText() + "\"}}", true).get(5, TimeUnit.SECONDS);
await().atMost(Duration.ofSeconds(5)).until(() -> {
synchronized (state) {
return state.pendingPingId == null;
}
});
assertThatThrownBy(() -> connect(ticket, new Messages()).join())
.hasCauseInstanceOf(WebSocketHandshakeException.class)
.satisfies(failure -> assertThat(((WebSocketHandshakeException) failure.getCause())
.getResponse().statusCode()).isEqualTo(401));
assertThat(manager.presence().onlineConnections()).isEqualTo(1);
} finally {
socket.sendClose(WebSocket.NORMAL_CLOSURE, "done").get(5, TimeUnit.SECONDS);
}
await().atMost(Duration.ofSeconds(5))
.until(() -> context.getBean(RealtimeSessionManager.class).presence().onlineConnections() == 0);
}
@Test
void revokedCredentialRejectsHandshakeAndReleasesReservation() {
String ticket = createTicket();
when(context.getBean(RealtimeCredentialVerifier.class).verify("access-token"))
.thenThrow(new BadCredentialsException("revoked"));
assertThatThrownBy(() -> connect(ticket, new Messages()).join())
.hasCauseInstanceOf(WebSocketHandshakeException.class)
.satisfies(failure -> assertThat(((WebSocketHandshakeException) failure.getCause())
.getResponse().statusCode()).isEqualTo(401));
var manager = context.getBean(RealtimeSessionManager.class);
for (int index = 0; index < 500; index++) {
assertThat(manager.reserve()).isNotNull();
}
assertThat(manager.reserve()).isNull();
}
@Test
void ticketCreationRejectsUnauthorizedPresenceTopic() {
when(context.getBean(RealtimeCredentialVerifier.class).verify("access-token"))
.thenReturn(new VerifiedIdentity(1L, false, expiresAt));
assertThatThrownBy(() -> context.getBean(RealtimeTicketService.class).create("access-token",
new CreateRealtimeTicketRequest("client-instance-01", "web", Set.of("notice", "presence"))))
.isInstanceOf(AccessDeniedException.class);
}
@Test
void handshakeRechecksTopicPermissionAndConsumesRejectedTicket() {
String ticket = context.getBean(RealtimeTicketService.class).create("access-token",
new CreateRealtimeTicketRequest("client-instance-01", "web", Set.of("notice", "presence"))).ticket();
when(context.getBean(RealtimeCredentialVerifier.class).verify("access-token"))
.thenReturn(new VerifiedIdentity(1L, false, expiresAt));
assertThatThrownBy(() -> connect(ticket, new Messages()).join())
.hasCauseInstanceOf(WebSocketHandshakeException.class)
.satisfies(failure -> assertThat(((WebSocketHandshakeException) failure.getCause())
.getResponse().statusCode()).isEqualTo(403));
assertThatThrownBy(() -> connect(ticket, new Messages()).join())
.hasCauseInstanceOf(WebSocketHandshakeException.class)
.satisfies(failure -> assertThat(((WebSocketHandshakeException) failure.getCause())
.getResponse().statusCode()).isEqualTo(401));
}
/**
* 模拟已登录客户端领取一次性票据
*/
private String createTicket() {
return context.getBean(RealtimeTicketService.class)
.create("access-token", new CreateRealtimeTicketRequest("client-instance-01", "web", Set.of("notice", "dict")))
.ticket();
}
/**
* 使用真实 HTTP Upgrade 建立本地连接
*/
private java.util.concurrent.CompletableFuture<WebSocket> connect(String ticket, Messages listener) {
int port = context.getWebServer().getPort();
return http.newWebSocketBuilder().header("Origin", "http://localhost:" + port)
.connectTimeout(Duration.ofSeconds(5))
.buildAsync(URI.create("ws://localhost:" + port + "/api/v1/realtime/ws?ticket=" + ticket), listener);
}
/**
* 读取连接以推进心跳时钟,避免测试等待 25 秒
*/
@SuppressWarnings("unchecked")
private RealtimeSession currentSession(RealtimeSessionManager manager) {
return ((Map<String, RealtimeSession>) ReflectionTestUtils.getField(manager, "transports"))
.values().iterator().next();
}
/**
* 只注册实时通信与本地 Servlet 容器
*/
@Configuration(proxyBeanMethods = false)
@EnableWebMvc
@Import({RealtimeConfig.class, RealtimeWebSocketHandler.class, RealtimeSessionManager.class,
RealtimeMessageSender.class, RealtimeMessageCodec.class, RealtimeHandshakeHandler.class,
RealtimeHandshakeInterceptor.class, RealtimeTicketService.class})
static class TestConfiguration {
/**
* 使用随机本地端口启动带 WebSocket 支持的 Tomcat
*/
@Bean
TomcatServletWebServerFactory webServerFactory() {
var factory = new TomcatServletWebServerFactory(0);
factory.addContextCustomizers(servletContext ->
servletContext.addServletContainerInitializer(new WsSci(), Set.of()));
return factory;
}
/**
* 将请求交给测试上下文中的 Spring MVC
*/
@Bean
ServletRegistrationBean<DispatcherServlet> dispatcherServlet(WebApplicationContext applicationContext) {
return new ServletRegistrationBean<>(new DispatcherServlet(applicationContext), "/");
}
/**
* 提供可控制登录态的身份校验替身
*/
@Bean
RealtimeCredentialVerifier verifier() {
return mock(RealtimeCredentialVerifier.class);
}
/**
* 用内存 Map 模拟票据写入与原子消费,校验仍走真实 TicketService
*/
@Bean
@SuppressWarnings("unchecked")
StringRedisTemplate redis() {
var redis = mock(StringRedisTemplate.class);
ValueOperations<String, String> values = mock(ValueOperations.class);
Map<String, String> tickets = new ConcurrentHashMap<>();
when(redis.opsForValue()).thenReturn(values);
doAnswer(call -> {
tickets.put(call.getArgument(0), call.getArgument(1));
return null;
}).when(values).set(anyString(), anyString(), any(Duration.class));
when(redis.execute(any(RedisScript.class), anyList()))
.thenAnswer(call -> tickets.remove(((java.util.List<String>) call.getArgument(1)).get(0)));
return redis;
}
}
/**
* 收集完整文本帧,保留客户端流量控制
*/
private static class Messages implements WebSocket.Listener {
private final BlockingQueue<String> messages = new LinkedBlockingQueue<>();
private final StringBuilder partial = new StringBuilder();
@Override
public CompletionStage<?> onText(WebSocket socket, CharSequence data, boolean last) {
partial.append(data);
if (last) {
messages.add(partial.toString());
partial.setLength(0);
}
socket.request(1);
return null;
}
/**
* 等待一条完整消息,超时即失败
*/
String next() throws InterruptedException {
String message = messages.poll(5, TimeUnit.SECONDS);
assertThat(message).as("服务器应在超时前返回消息").isNotNull();
return message;
}
}
}
@@ -1,23 +1,26 @@
package com.youlai.boot.validation;
import com.youlai.boot.codegen.model.form.GenConfigForm;
import com.youlai.boot.module.form.model.form.FormDefinitionForm;
import com.youlai.boot.system.model.form.PasswordResetForm;
import com.youlai.boot.system.model.form.PasswordUpdateForm;
import com.youlai.boot.system.model.query.UserQuery;
import jakarta.validation.Valid;
import jakarta.validation.Validation;
import jakarta.validation.Validator;
import jakarta.validation.constraints.NotNull;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import jakarta.validation.Valid;
import org.springframework.validation.annotation.Validated;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
@@ -37,11 +40,12 @@ class ValidationTest {
}
@Test
@DisplayName("密码重置要求非空且长度达标")
void passwordResetFormShouldRejectBlankAndShortPassword() {
var blank = new com.youlai.boot.system.model.form.PasswordResetForm();
var blank = new PasswordResetForm();
assertThat(validator.validate(blank)).isNotEmpty();
var form = new com.youlai.boot.system.model.form.PasswordResetForm();
var form = new PasswordResetForm();
form.setPassword("12345");
assertThat(validator.validate(form)).isNotEmpty();
@@ -50,8 +54,9 @@ class ValidationTest {
}
@Test
@DisplayName("修改密码三个字段都必填")
void passwordUpdateFormShouldRequireAllThreeFields() {
var form = new com.youlai.boot.system.model.form.PasswordUpdateForm();
var form = new PasswordUpdateForm();
assertThat(validator.validate(form)).hasSize(3);
form.setOldPassword("123456");
@@ -61,8 +66,9 @@ class ValidationTest {
}
@Test
@DisplayName("分页参数超出范围被拒绝")
void baseQueryShouldRejectOutOfRangePaging() {
var query = new com.youlai.boot.system.model.query.UserQuery();
var query = new UserQuery();
assertThat(validator.validate(query)).isEmpty();
query.setPageNum(0);
@@ -73,16 +79,39 @@ class ValidationTest {
assertThat(validator.validate(query)).isNotEmpty();
query.setPageSize(200);
query.setOrder("DROP TABLE");
assertThat(validator.validate(query)).isNotEmpty();
query.setOrder("DESC");
assertThat(validator.validate(query)).isEmpty();
}
@Test
@DisplayName("表单定义按创建与更新分组校验")
void formDefinitionFormShouldValidateByCreateAndUpdateGroups() {
var form = new FormDefinitionForm();
// 创建:标识与名称为必填
assertThat(validator.validate(form, FormDefinitionForm.Create.class)).hasSize(2);
form.setFormKey("EmployeeOnboarding");
form.setFormName("入职信息采集");
// 标识格式非法仍被拦截
assertThat(validator.validate(form, FormDefinitionForm.Create.class)).hasSize(1);
form.setFormKey("employee_onboarding");
assertThat(validator.validate(form, FormDefinitionForm.Create.class)).isEmpty();
// 更新:只保存规则的部分更新载荷不触发必填校验
var ruleOnly = new FormDefinitionForm();
ruleOnly.setFormJson("[]");
ruleOnly.setOptionsJson("{}");
assertThat(validator.validate(ruleOnly, FormDefinitionForm.Update.class)).isEmpty();
// 更新:显式提交的字段格式仍被校验
ruleOnly.setFormName("x".repeat(101));
assertThat(validator.validate(ruleOnly, FormDefinitionForm.Update.class)).hasSize(1);
}
@Test
@DisplayName("代码生成配置要求核心字段")
void genConfigFormShouldRequireCoreFields() {
var form = new com.youlai.boot.codegen.model.form.GenConfigForm();
var form = new GenConfigForm();
assertThat(validator.validate(form)).isNotEmpty();
form.setTableName("sys_user");
@@ -94,8 +123,9 @@ class ValidationTest {
}
@Test
@DisplayName("每个 @RequestBody 参数都必须触发校验")
void everyRequestBodyParameterShouldTriggerValidation() throws Exception {
var scanner = new org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider(false);
var scanner = new ClassPathScanningCandidateComponentProvider(false);
scanner.addIncludeFilter(new AnnotationTypeFilter(RestController.class));
List<String> violations = new ArrayList<>();