Upgrade to Spring Boot 3.4.0-M3

Signed-off-by: JohnNiang <johnniang@foxmail.com>

application/src/main/java/run/halo/app/theme/dialect/EvaluationContextEnhancer.java

@@ -12,6 +12,7 @@
 import org.springframework.expression.MethodResolver;
 import org.springframework.expression.PropertyAccessor;
 import org.springframework.expression.TypedValue;
+import org.springframework.expression.spel.CompilablePropertyAccessor;
 import org.springframework.expression.spel.support.ReflectivePropertyAccessor;
 import org.springframework.integration.json.JsonPropertyAccessor;
 import org.springframework.lang.Nullable;
@@ -122,7 +123,7 @@ public Class<?>[] getSpecificTargetClasses() {
         public PropertyAccessor createOptimalAccessor(EvaluationContext context, Object target,
             String name) {
             var optimalAccessor = delegate.createOptimalAccessor(context, target, name);
-            if (optimalAccessor instanceof OptimalPropertyAccessor optimalPropertyAccessor) {
+            if (optimalAccessor instanceof CompilablePropertyAccessor optimalPropertyAccessor) {
                 if (ReactiveUtils.isReactiveType(optimalPropertyAccessor.getPropertyType())) {
                     return this;
                 }

application/src/test/java/run/halo/app/content/comment/CommentServiceImplTest.java

@@ -2,7 +2,6 @@
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.lenient;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -12,7 +11,6 @@
 import java.util.Map;
 import java.util.Set;
 import org.json.JSONException;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.ArgumentCaptor;
@@ -61,53 +59,25 @@
 class CommentServiceImplTest {
 
     @Mock
-    private SystemConfigurableEnvironmentFetcher environmentFetcher;
+    SystemConfigurableEnvironmentFetcher environmentFetcher;
 
     @Mock
-    private ReactiveExtensionClient client;
+    ReactiveExtensionClient client;
 
     @Mock
-    private UserService userService;
+    UserService userService;
 
     @Mock
-    private RoleService roleService;
+    RoleService roleService;
 
     @Mock
-    private ExtensionGetter extensionGetter;
+    ExtensionGetter extensionGetter;
 
     @InjectMocks
-    private CommentServiceImpl commentService;
+    CommentServiceImpl commentService;
 
     @Mock
-    private CounterService counterService;
-
-    @BeforeEach
-    void setUp() {
-        SystemSetting.Comment commentSetting = getCommentSetting();
-        lenient().when(environmentFetcher.fetchComment()).thenReturn(Mono.just(commentSetting));
-
-        ListResult<Comment> comments = new ListResult<>(1, 10, 3, comments());
-        when(client.listBy(eq(Comment.class), any(ListOptions.class), any(PageRequest.class)))
-            .thenReturn(Mono.just(comments));
-
-        when(userService.getUserOrGhost(eq("A-owner")))
-            .thenReturn(Mono.just(createUser("A-owner")));
-        when(userService.getUserOrGhost(eq("B-owner")))
-            .thenReturn(Mono.just(createUser("B-owner")));
-        when(client.fetch(eq(User.class), eq("C-owner")))
-            .thenReturn(Mono.empty());
-
-        when(roleService.contains(Set.of("USER"),
-            Set.of(AuthorityUtils.COMMENT_MANAGEMENT_ROLE_NAME)))
-            .thenReturn(Mono.just(false));
-
-        PostCommentSubject postCommentSubject = Mockito.mock(PostCommentSubject.class);
-        when(extensionGetter.getExtensions(CommentSubject.class))
-            .thenReturn(Flux.just(postCommentSubject));
-
-        when(postCommentSubject.supports(any())).thenReturn(true);
-        when(postCommentSubject.get(eq("fake-post"))).thenReturn(Mono.just(post()));
-    }
+    CounterService counterService;
 
     private static User createUser(String name) {
         User user = new User();
@@ -122,10 +92,21 @@ private static User createUser(String name) {
 
     @Test
     void listComment() {
+        var comments = new ListResult<Comment>(1, 10, 3, comments());
+        when(client.listBy(eq(Comment.class), any(ListOptions.class), any(PageRequest.class)))
+            .thenReturn(Mono.just(comments));
+
+        PostCommentSubject postCommentSubject = Mockito.mock(PostCommentSubject.class);
+        when(extensionGetter.getExtensions(CommentSubject.class))
+            .thenReturn(Flux.just(postCommentSubject));
+
+        when(postCommentSubject.supports(any())).thenReturn(true);
+        when(postCommentSubject.get(eq("fake-post"))).thenReturn(Mono.just(post()));
+
         when(userService.getUserOrGhost(any()))
             .thenReturn(Mono.just(ghostUser()));
-        when(userService.getUserOrGhost("A-owner"))
-            .thenReturn(Mono.just(createUser("A-owner")));
+        // when(userService.getUserOrGhost("A-owner"))
+        //     .thenReturn(Mono.just(createUser("A-owner")));
         when(userService.getUserOrGhost("B-owner"))
             .thenReturn(Mono.just(createUser("B-owner")));
 
@@ -170,6 +151,12 @@ void listComment() {
     @Test
     @WithMockUser(username = "B-owner")
     void create() throws JSONException {
+        var commentSetting = getCommentSetting();
+        when(environmentFetcher.fetchComment()).thenReturn(Mono.just(commentSetting));
+        when(roleService.contains(Set.of("USER"),
+            Set.of(AuthorityUtils.COMMENT_MANAGEMENT_ROLE_NAME)))
+            .thenReturn(Mono.just(false));
+
         CommentRequest commentRequest = new CommentRequest();
         commentRequest.setRaw("fake-raw");
         commentRequest.setContent("fake-content");

application/src/test/java/run/halo/app/core/endpoint/console/EmailVerificationCodeTest.java

@@ -1,15 +1,11 @@
 package run.halo.app.core.endpoint.console;
 
 import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
-import static org.springframework.security.test.web.reactive.server.SecurityMockServerConfigurers.csrf;
+import static org.springframework.security.test.web.reactive.server.SecurityMockServerConfigurers.springSecurity;
 
 import io.github.resilience4j.ratelimiter.RateLimiterConfig;
 import io.github.resilience4j.ratelimiter.RateLimiterRegistry;
-import io.github.resilience4j.reactor.ratelimiter.operator.RateLimiterOperator;
 import java.time.Duration;
 import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
@@ -39,47 +35,49 @@
 @ExtendWith(SpringExtension.class)
 @WithMockUser(username = "fake-user", password = "fake-password")
 class EmailVerificationCodeTest {
+
     WebTestClient webClient;
+
     @Mock
     ReactiveExtensionClient client;
+
     @Mock
     EmailVerificationService emailVerificationService;
 
     @Mock
     UserService userService;
 
+    @Mock
+    RateLimiterRegistry rateLimiterRegistry;
+
     @InjectMocks
     UserEndpoint endpoint;
 
     @BeforeEach
     void setUp() {
-        var spyUserEndpoint = spy(endpoint);
+        webClient = WebTestClient.bindToRouterFunction(endpoint.endpoint())
+            .apply(springSecurity())
+            .build();
+    }
+
+    @Test
+    void sendEmailVerificationCode() {
         var config = RateLimiterConfig.custom()
             .limitRefreshPeriod(Duration.ofSeconds(10))
             .limitForPeriod(1)
             .build();
         var sendCodeRateLimiter = RateLimiterRegistry.of(config)
             .rateLimiter("send-email-verification-code-fake-user:hi@halo.run");
-        doReturn(RateLimiterOperator.of(sendCodeRateLimiter)).when(spyUserEndpoint)
-            .sendEmailVerificationCodeRateLimiter(eq("fake-user"), eq("hi@halo.run"));
-
-        var verifyEmailRateLimiter = RateLimiterRegistry.of(config)
-            .rateLimiter("verify-email-fake-user");
-        doReturn(RateLimiterOperator.of(verifyEmailRateLimiter)).when(spyUserEndpoint)
-            .verificationEmailRateLimiter(eq("fake-user"));
+        when(rateLimiterRegistry.rateLimiter(
+            "send-email-verification-code-fake-user:hi@halo.run",
+            "send-email-verification-code")
+        ).thenReturn(sendCodeRateLimiter);
 
-        webClient = WebTestClient.bindToRouterFunction(spyUserEndpoint.endpoint()).build()
-            .mutateWith(csrf());
-    }
-
-    @Test
-    void sendEmailVerificationCode() {
         var user = new User();
         user.setMetadata(new Metadata());
         user.getMetadata().setName("fake-user");
         user.setSpec(new User.UserSpec());
         user.getSpec().setEmail("hi@halo.run");
-        when(client.get(eq(User.class), eq("fake-user"))).thenReturn(Mono.just(user));
         when(emailVerificationService.sendVerificationCode(anyString(), anyString()))
             .thenReturn(Mono.empty());
         webClient.post()
@@ -100,6 +98,16 @@ void sendEmailVerificationCode() {
 
     @Test
     void verifyEmail() {
+        var config = RateLimiterConfig.custom()
+            .limitRefreshPeriod(Duration.ofSeconds(10))
+            .limitForPeriod(1)
+            .build();
+
+        var verifyEmailRateLimiter = RateLimiterRegistry.of(config)
+            .rateLimiter("verify-email-fake-user");
+        when(rateLimiterRegistry.rateLimiter("verify-email-fake-user", "verify-email"))
+            .thenReturn(verifyEmailRateLimiter);
+
         when(emailVerificationService.verify(anyString(), anyString()))
             .thenReturn(Mono.empty());
         when(userService.confirmPassword(anyString(), anyString()))

application/src/test/java/run/halo/app/security/AuthProviderServiceImplTest.java

@@ -37,11 +37,12 @@
  */
 @ExtendWith(SpringExtension.class)
 class AuthProviderServiceImplTest {
+
     @Mock
-    private ReactiveExtensionClient client;
+    ReactiveExtensionClient client;
 
     @InjectMocks
-    private AuthProviderServiceImpl authProviderService;
+    AuthProviderServiceImpl authProviderService;
 
     @Test
     void testEnable() {
@@ -57,14 +58,12 @@ void testEnable() {
         when(client.fetch(eq(ConfigMap.class), eq(SystemSetting.SYSTEM_CONFIG)))
             .thenReturn(Mono.just(configMap));
 
-        AuthProvider local = createAuthProvider("local");
-        local.getMetadata().getLabels().put(AuthProvider.PRIVILEGED_LABEL, "true");
-        when(client.list(eq(AuthProvider.class), any(), any())).thenReturn(Flux.just(local));
-
         // Call the method being tested
-        Mono<AuthProvider> result = authProviderService.enable("github");
+        authProviderService.enable("github")
+            .as(StepVerifier::create)
+            .expectNext(authProvider)
+            .verifyComplete();
 
-        assertEquals(authProvider, result.block());
         ConfigMap value = captor.getValue();
         String providerSettingStr = value.getData().get(SystemSetting.AuthProvider.GROUP);
         Set<String> enabled =
@@ -84,7 +83,7 @@ void testDisable() {
 
         AuthProvider local = createAuthProvider("local");
         local.getMetadata().getLabels().put(AuthProvider.PRIVILEGED_LABEL, "true");
-        when(client.list(eq(AuthProvider.class), any(), any())).thenReturn(Flux.just(local));
+        // when(client.list(eq(AuthProvider.class), any(), any())).thenReturn(Flux.just(local));
 
         ArgumentCaptor<ConfigMap> captor = ArgumentCaptor.forClass(ConfigMap.class);
         when(client.update(captor.capture())).thenReturn(Mono.empty());
@@ -155,7 +154,7 @@ void listAll() {
                                 "supportsBinding": false,
                                 "privileged": false
                             },{
-                                                        
+                            
                                 "name": "gitee",
                                 "displayName": "gitee",
                                 "enabled": false,

application/src/test/java/run/halo/app/theme/ViewNameResolverTest.java

@@ -2,14 +2,13 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
-import java.io.File;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.file.Files;
+import java.nio.file.Path;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -35,40 +34,41 @@
 class ViewNameResolverTest {
 
     @Mock
-    private ThemeResolver themeResolver;
+    ThemeResolver themeResolver;
 
     @Mock
-    private ThymeleafProperties thymeleafProperties;
+    ThymeleafProperties thymeleafProperties;
 
     @InjectMocks
-    private DefaultViewNameResolver viewNameResolver;
+    DefaultViewNameResolver viewNameResolver;
 
     @TempDir
-    private File themePath;
+    Path themePath;
 
     @BeforeEach
     void setUp() throws IOException {
         when(thymeleafProperties.getSuffix()).thenReturn(ThymeleafProperties.DEFAULT_SUFFIX);
+    }
 
-        var templatesPath = themePath.toPath().resolve("templates");
+    @Test
+    void resolveViewNameOrDefault() throws URISyntaxException, IOException {
+        var templatesPath = themePath.resolve("templates");
         if (!Files.exists(templatesPath)) {
             Files.createDirectory(templatesPath);
         }
         Files.createFile(templatesPath.resolve("post_news.html"));
         Files.createFile(templatesPath.resolve("post_docs.html"));
 
-        when(themeResolver.getTheme(any()))
+
+        var exchange = Mockito.mock(ServerWebExchange.class);
+        when(themeResolver.getTheme(exchange))
             .thenReturn(Mono.fromSupplier(() -> ThemeContext.builder()
                 .name("fake-theme")
-                .path(themePath.toPath())
+                .path(themePath)
                 .active(true)
                 .build())
             );
-    }
 
-    @Test
-    void resolveViewNameOrDefault() throws URISyntaxException {
-        ServerWebExchange exchange = Mockito.mock(ServerWebExchange.class);
         MockServerRequest request = MockServerRequest.builder()
             .uri(new URI("/")).method(HttpMethod.GET)
             .exchange(exchange)

application/src/test/java/run/halo/app/theme/finders/impl/CommentPublicQueryServiceImplTest.java

@@ -44,21 +44,19 @@
 class CommentPublicQueryServiceImplTest {
 
     @Mock
-    private ReactiveExtensionClient client;
+    ReactiveExtensionClient client;
+
     @Mock
-    private UserService userService;
+    UserService userService;
 
     @Mock
-    private CounterService counterService;
+    CounterService counterService;
 
     @InjectMocks
-    private CommentPublicQueryServiceImpl commentPublicQueryService;
+    CommentPublicQueryServiceImpl commentPublicQueryService;
 
     @BeforeEach
     void setUp() {
-        User ghost = createUser();
-        ghost.getMetadata().setName("ghost");
-        when(userService.getUserOrGhost(eq("ghost"))).thenReturn(Mono.just(ghost));
         when(userService.getUserOrGhost(eq("fake-user"))).thenReturn(Mono.just(createUser()));
     }