generator-jhipster 7.1.0 → 7.4.0

package/generators/server/templates/src/test/java/package/config/TestSecurityConfiguration.java.ejs

@@ -16,48 +16,52 @@
  See the License for the specific language governing permissions and
  limitations under the License.
 -%>
+<%_ const reactivePrefix = reactive ? 'Reactive' : ''; _%>
 package <%= packageName %>.config;
 
+import static org.mockito.Mockito.mock;
+
+import java.util.HashMap;
+import java.util.Map;
 import org.springframework.boot.test.context.TestConfiguration;
 import org.springframework.context.annotation.Bean;
-import org.springframework.security.oauth2.client.InMemory<% if (reactive) { %>Reactive<% } %>OAuth2AuthorizedClientService;
-import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
-import org.springframework.security.oauth2.client.<% if (reactive) { %>Reactive<% } %>OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.InMemory<%= reactivePrefix %>OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.<%= reactivePrefix %>OAuth2AuthorizedClientService;
 import org.springframework.security.oauth2.client.registration.ClientRegistration;
-import org.springframework.security.oauth2.client.registration.<% if (reactive) { %>Reactive<% } %>ClientRegistrationRepository;
-import org.springframework.security.oauth2.client.registration.InMemory<% if (reactive) { %>Reactive<% } %>ClientRegistrationRepository;
-import org.springframework.security.oauth2.client.web.AuthenticatedPrincipalOAuth2AuthorizedClientRepository;
-import org.springframework.security.oauth2.client.web.OAuth2AuthorizedClientRepository;
+import org.springframework.security.oauth2.client.registration.<%= reactivePrefix %>ClientRegistrationRepository;
+import org.springframework.security.oauth2.client.registration.InMemory<%= reactivePrefix %>ClientRegistrationRepository;
 import org.springframework.security.oauth2.core.AuthorizationGrantType;
 import org.springframework.security.oauth2.core.ClientAuthenticationMethod;
-import org.springframework.security.oauth2.jwt.<% if (reactive) { %>Reactive<% } %>JwtDecoder;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.mockito.Mockito.mock;
+import org.springframework.security.oauth2.jwt.<%= reactivePrefix %>JwtDecoder;
+<%_ if (applicationTypeMonolith) { _%>
+import org.springframework.context.annotation.Import;
+<%_ } _%>
 
 /**
  * This class allows you to run unit and integration tests without an IdP.
  */
 @TestConfiguration
+<%_ if (applicationTypeMonolith) { _%>
+@Import(OAuth2Configuration.class)
+<%_ } _%>
 public class TestSecurityConfiguration {
-    private final ClientRegistration clientRegistration;
 
-    public TestSecurityConfiguration() {
-        this.clientRegistration = clientRegistration().build();
+    @Bean
+    ClientRegistration clientRegistration() {
+        return clientRegistrationBuilder().build();
     }
 
     @Bean
-    <% if (reactive) { %>Reactive<% } %>ClientRegistrationRepository clientRegistrationRepository() {
-        return new InMemory<% if (reactive) { %>Reactive<% } %>ClientRegistrationRepository(clientRegistration);
+    <%= reactivePrefix %>ClientRegistrationRepository clientRegistrationRepository(ClientRegistration clientRegistration) {
+        return new InMemory<%= reactivePrefix %>ClientRegistrationRepository(clientRegistration);
     }
 
-    private ClientRegistration.Builder clientRegistration() {
+    private ClientRegistration.Builder clientRegistrationBuilder() {
         Map<String, Object> metadata = new HashMap<>();
         metadata.put("end_session_endpoint", "https://jhipster.org/logout");
 
         return ClientRegistration.withRegistrationId("oidc")
+            .issuerUri("{baseUrl}")
             .redirectUri("{baseUrl}/{action}/oauth2/code/{registrationId}")
             .clientAuthenticationMethod(ClientAuthenticationMethod.BASIC)
             .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
@@ -74,17 +78,12 @@ public class TestSecurityConfiguration {
     }
 
     @Bean
-    <% if (reactive) { %>Reactive<% } %>JwtDecoder jwtDecoder() {
-        return mock(<% if (reactive) { %>Reactive<% } %>JwtDecoder.class);
-    }
-
-    @Bean
-    public <% if (reactive) { %>Reactive<% } %>OAuth2AuthorizedClientService authorizedClientService(<% if (reactive) { %>Reactive<% } %>ClientRegistrationRepository clientRegistrationRepository) {
-        return new InMemory<% if (reactive) { %>Reactive<% } %>OAuth2AuthorizedClientService(clientRegistrationRepository);
+    <%= reactivePrefix %>JwtDecoder jwtDecoder() {
+        return mock(<%= reactivePrefix %>JwtDecoder.class);
     }
 
     @Bean
-    public OAuth2AuthorizedClientRepository authorizedClientRepository(OAuth2AuthorizedClientService authorizedClientService) {
-        return new AuthenticatedPrincipalOAuth2AuthorizedClientRepository(authorizedClientService);
+    <%= reactivePrefix %>OAuth2AuthorizedClientService authorizedClientService(<%= reactivePrefix %>ClientRegistrationRepository clientRegistrationRepository) {
+        return new InMemory<%= reactivePrefix %>OAuth2AuthorizedClientService(clientRegistrationRepository);
     }
 }

package/generators/server/templates/src/test/java/package/config/WebConfigurerTest.java.ejs

@@ -20,7 +20,7 @@ package <%= packageName %>.config;
 
 import tech.jhipster.config.JHipsterConstants;
 import tech.jhipster.config.JHipsterProperties;
-<%_ if (devDatabaseType === 'h2Disk' || devDatabaseType === 'h2Memory') { _%>
+<%_ if (devDatabaseTypeH2Any) { _%>
 import org.h2.server.web.WebServlet;
 <%_ } _%>
 import org.junit.jupiter.api.BeforeEach;
@@ -84,9 +84,9 @@ class WebConfigurerTest {
         env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION);
 
         assertThatCode(() -> webConfigurer.onStartup(servletContext)).doesNotThrowAnyException();
-        <%_ if (devDatabaseType === 'h2Disk' || devDatabaseType === 'h2Memory') { _%>
+<%_ if (devDatabaseTypeH2Any) { _%>
         verify(servletContext, never()).addServlet(eq("H2Console"), any(WebServlet.class));
-        <%_ } _%>
+<%_ } _%>
     }
 
     @Test
@@ -94,9 +94,9 @@ class WebConfigurerTest {
         env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT);
 
         assertThatCode(() -> webConfigurer.onStartup(servletContext)).doesNotThrowAnyException();
-        <%_ if (devDatabaseType === 'h2Disk' || devDatabaseType === 'h2Memory') { _%>
+<%_ if (devDatabaseTypeH2Any) { _%>
         verify(servletContext).addServlet(eq("H2Console"), any(WebServlet.class));
-        <%_ } _%>
+<%_ } _%>
     }
 
 <%_ if (!skipClient) { _%>
@@ -108,11 +108,9 @@ class WebConfigurerTest {
         assertThat(container.getMimeMappings().get("abs")).isEqualTo("audio/x-mpeg");
         assertThat(container.getMimeMappings().get("html")).isEqualTo("text/html");
         assertThat(container.getMimeMappings().get("json")).isEqualTo("application/json");
-        <%_ if (!skipClient) { _%>
         if (container.getDocumentRoot() != null) {
             assertThat(container.getDocumentRoot()).isEqualTo(new File("<%= CLIENT_DIST_DIR %>"));
         }
-        <%_ } _%>
     }
 
 <%_ } _%>

package/generators/server/templates/src/test/java/package/cucumber/CucumberIT.java.ejs

@@ -20,10 +20,10 @@ package <%= packageName %>.cucumber;
 
 import org.junit.runner.RunWith;
 
-<%_ if (databaseType === 'cassandra') { _%>
+<%_ if (databaseTypeCassandra) { _%>
 import <%= packageName %>.AbstractCassandraTest;
 <%_ } _%>
-<%_ if (databaseType === 'neo4j') { _%>
+<%_ if (databaseTypeNeo4j) { _%>
 import <%= packageName %>.AbstractNeo4jIT;
 <%_ } _%>
 import io.cucumber.junit.CucumberOptions;
@@ -31,7 +31,9 @@ import io.cucumber.junit.Cucumber;
 
 @RunWith(Cucumber.class)
 @CucumberOptions(plugin = "pretty", features = "<%= TEST_DIR %>features")
-<% if (databaseType === 'neo4j') { %>@ExtendWith(AbstractNeo4jIT) <% } %>
-class CucumberIT <% if (databaseType === 'cassandra') { %>extends AbstractCassandraTest<% } %> {
+<%_ if (databaseTypeNeo4j) { _%>
+@ExtendWith(AbstractNeo4jIT)
+<%_ } _%>
+class CucumberIT <% if (databaseTypeCassandra) { %>extends AbstractCassandraTest<% } %> {
 
 }

package/generators/server/templates/src/test/java/package/management/SecurityMetersServiceTests.java.ejs

@@ -0,0 +1,113 @@
+<%#
+ Copyright 2013-2021 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.management;
+
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class SecurityMetersServiceTests {
+    private static final String INVALID_TOKENS_METER_EXPECTED_NAME = "security.authentication.invalid-tokens";
+
+    private MeterRegistry meterRegistry;
+
+    private SecurityMetersService securityMetersService;
+
+    @BeforeEach
+    public void setup() {
+        meterRegistry = new SimpleMeterRegistry();
+
+        securityMetersService = new SecurityMetersService(meterRegistry);
+    }
+
+    @Test
+    public void testInvalidTokensCountersByCauseAreCreated() {
+        meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME).counter();
+
+        meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "expired")
+            .counter();
+
+        meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "unsupported")
+            .counter();
+
+        meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "invalid-signature")
+            .counter();
+
+        meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "malformed")
+            .counter();
+
+        Collection<Counter> counters = meterRegistry.find(INVALID_TOKENS_METER_EXPECTED_NAME).counters();
+
+        assertThat(counters.size()).isEqualTo(4);
+    }
+
+    @Test
+    public void testCountMethodsShouldBeBoundToCorrectCounters() {
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "expired")
+            .counter().count()).isEqualTo(0);
+
+        securityMetersService.trackTokenExpired();
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "expired")
+            .counter().count()).isEqualTo(1);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "unsupported")
+            .counter().count()).isEqualTo(0);
+
+        securityMetersService.trackTokenUnsupported();
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "unsupported")
+            .counter().count()).isEqualTo(1);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "invalid-signature")
+            .counter().count()).isEqualTo(0);
+
+        securityMetersService.trackTokenInvalidSignature();
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "invalid-signature")
+            .counter().count()).isEqualTo(1);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "malformed")
+            .counter().count()).isEqualTo(0);
+
+        securityMetersService.trackTokenMalformed();
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "malformed")
+            .counter().count()).isEqualTo(1);
+    }
+
+}

package/generators/server/templates/src/test/java/package/repository/timezone/DateTimeWrapper.java.ejs

@@ -30,12 +30,12 @@ public class DateTimeWrapper implements Serializable {
     private static final long serialVersionUID = 1L;
 
     @Id
-    <%_ if (prodDatabaseType === 'mysql') { _%>
+<%_ if (prodDatabaseTypeMysql) { _%>
     @GeneratedValue(strategy = GenerationType.IDENTITY)
-    <%_ } else { _%>
+<%_ } else { _%>
     @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
     @SequenceGenerator(name = "sequenceGenerator")
-    <%_ } _%>
+<%_ } _%>
     private Long id;
 
     @Column(name = "instant")

package/generators/server/templates/src/test/java/package/security/DomainUserDetailsServiceIT.java.ejs

@@ -18,11 +18,11 @@
 -%>
 package <%= packageName %>.security;
 
-<%_ if (databaseType === 'cassandra') { _%>
+<%_ if (databaseTypeCassandra) { _%>
 import <%= packageName %>.AbstractCassandraTest;
 <%_ } _%>
 import <%= packageName %>.IntegrationTest;
-<%_ if (databaseType === 'sql' && reactive) { _%>
+<%_ if (databaseTypeSql && reactive) { _%>
 import <%= packageName %>.config.Constants;
 <%_ } _%>
 import <%= packageName %>.domain.<%= asEntity('User') %>;
@@ -39,14 +39,14 @@ import org.springframework.security.core.userdetails.UserDetails;
 <%_ if (!reactive) { _%>
 import org.springframework.security.core.userdetails.UserDetailsService;
 <%_ } _%>
-<%_ if (databaseType === 'couchbase') { _%>
+<%_ if (databaseTypeCouchbase) { _%>
 import org.springframework.security.test.context.support.WithMockUser;
 <%_ } _%>
-<%_ if (databaseType === 'sql' && !reactive) { _%>
+<%_ if (databaseTypeSql && !reactive) { _%>
 import org.springframework.transaction.annotation.Transactional;
 <%_ } _%>
 
-<%_ if (databaseType === 'cassandra') { _%>
+<%_ if (databaseTypeCassandra) { _%>
 import java.util.UUID;
 <%_ } _%>
 import java.util.Locale;
@@ -57,14 +57,14 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 /**
  * Integrations tests for {@link DomainUserDetailsService}.
  */
-<%_ if (databaseType === 'sql' && !reactive) { _%>
+<%_ if (databaseTypeSql && !reactive) { _%>
 @Transactional
 <%_ } _%>
-<%_ if (databaseType === 'couchbase') { _%>
+<%_ if (databaseTypeCouchbase) { _%>
 @WithMockUser("test-user-one")
 <%_ } _%>
 @IntegrationTest
-class DomainUserDetailsServiceIT <% if (databaseType === 'cassandra') { %>extends AbstractCassandraTest <% } %>{
+class DomainUserDetailsServiceIT <% if (databaseTypeCassandra) { %>extends AbstractCassandraTest <% } %>{
 
     private static final String USER_ONE_LOGIN = "test-user-one";
     private static final String USER_ONE_EMAIL = "test-user-one@localhost";
@@ -81,17 +81,17 @@ class DomainUserDetailsServiceIT <% if (databaseType === 'cassandra') { %>extend
 
     @BeforeEach
     public void init() {
-        <%_ if (databaseType === 'sql' && reactive) { _%>
+<%_ if (databaseTypeSql && reactive) { _%>
         userRepository.deleteAllUserAuthorities().block();
-        <%_ } _%>
-        <%_ if (databaseType !== 'sql' || reactive) { _%>
+<%_ } _%>
+<%_ if (!databaseTypeSql || reactive) { _%>
         userRepository.deleteAll()<% if (reactive) { %>.block()<% } %>;
 
-        <%_ } _%>
+<%_ } _%>
         <%= asEntity('User') %> userOne = new <%= asEntity('User') %>();
-        <%_ if (databaseType === 'cassandra') { _%>
+<%_ if (databaseTypeCassandra) { _%>
         userOne.setId(UUID.randomUUID().toString());
-        <%_ } _%>
+<%_ } _%>
         userOne.setLogin(USER_ONE_LOGIN);
         userOne.setPassword(RandomStringUtils.random(60));
         userOne.setActivated(true);
@@ -99,15 +99,15 @@ class DomainUserDetailsServiceIT <% if (databaseType === 'cassandra') { %>extend
         userOne.setFirstName("userOne");
         userOne.setLastName("doe");
         userOne.setLangKey("en");
-        <%_ if (databaseType === 'sql' && reactive) { _%>
+<%_ if (databaseTypeSql && reactive) { _%>
         userOne.setCreatedBy(Constants.SYSTEM);
-        <%_ } _%>
+<%_ } _%>
         userRepository.save(userOne)<% if (reactive) { %>.block()<% } %>;
 
         <%= asEntity('User') %> userTwo = new <%= asEntity('User') %>();
-        <%_ if (databaseType === 'cassandra') { _%>
+<%_ if (databaseTypeCassandra) { _%>
         userTwo.setId(UUID.randomUUID().toString());
-        <%_ } _%>
+<%_ } _%>
         userTwo.setLogin(USER_TWO_LOGIN);
         userTwo.setPassword(RandomStringUtils.random(60));
         userTwo.setActivated(true);
@@ -115,15 +115,15 @@ class DomainUserDetailsServiceIT <% if (databaseType === 'cassandra') { %>extend
         userTwo.setFirstName("userTwo");
         userTwo.setLastName("doe");
         userTwo.setLangKey("en");
-        <%_ if (databaseType === 'sql' && reactive) { _%>
+<%_ if (databaseTypeSql && reactive) { _%>
         userTwo.setCreatedBy(Constants.SYSTEM);
-        <%_ } _%>
+<%_ } _%>
         userRepository.save(userTwo)<% if (reactive) { %>.block()<% } %>;
 
         <%= asEntity('User') %> userThree = new <%= asEntity('User') %>();
-        <%_ if (databaseType === 'cassandra') { _%>
+<%_ if (databaseTypeCassandra) { _%>
         userThree.setId(UUID.randomUUID().toString());
-        <%_ } _%>
+<%_ } _%>
         userThree.setLogin(USER_THREE_LOGIN);
         userThree.setPassword(RandomStringUtils.random(60));
         userThree.setActivated(false);
@@ -131,9 +131,9 @@ class DomainUserDetailsServiceIT <% if (databaseType === 'cassandra') { %>extend
         userThree.setFirstName("userThree");
         userThree.setLastName("doe");
         userThree.setLangKey("en");
-        <%_ if (databaseType === 'sql' && reactive) { _%>
+<%_ if (databaseTypeSql && reactive) { _%>
         userThree.setCreatedBy(Constants.SYSTEM);
-        <%_ } _%>
+<%_ } _%>
         userRepository.save(userThree)<% if (reactive) { %>.block()<% } %>;
     }
 

package/generators/server/templates/src/test/java/package/security/SecurityUtilsUnitTest.java.ejs

@@ -30,15 +30,15 @@ import reactor.util.context.Context;
 <%_ } else { _%>
 import org.springframework.security.core.context.SecurityContext;
 import org.springframework.security.core.context.SecurityContextHolder;
-    <%_ if (authenticationType === 'oauth2') { _%>
+  <%_ if (authenticationTypeOauth2) { _%>
 import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
 import org.springframework.security.oauth2.core.oidc.OidcIdToken;
 import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
 import org.springframework.security.oauth2.core.oidc.user.OidcUser;
-    <%_ } _%>
+  <%_ } _%>
 <%_ } _%>
 
-<%_ if (authenticationType === 'oauth2') { _%>
+<%_ if (authenticationTypeOauth2) { _%>
 import java.time.Instant;
 import java.util.*;
 <%_ } else { _%>
@@ -50,7 +50,7 @@ import java.util.Optional;
 <%_ } _%>
 
 import static org.assertj.core.api.Assertions.assertThat;
-<%_ if (authenticationType === 'oauth2') { _%>
+<%_ if (authenticationTypeOauth2) { _%>
 import static org.springframework.security.oauth2.core.oidc.endpoint.OidcParameterNames.ID_TOKEN;
 <%_ } _%>
 
@@ -74,7 +74,7 @@ class SecurityUtilsUnitTest {
         Optional<String> login = SecurityUtils.getCurrentUserLogin();
         assertThat(login).contains("admin");
     }
-    <%_ if (authenticationType === 'oauth2') { _%>
+  <%_ if (authenticationTypeOauth2) { _%>
 
     @Test
     void testGetCurrentUserLoginForOAuth2() {
@@ -96,8 +96,35 @@ class SecurityUtilsUnitTest {
 
         assertThat(login).contains("admin");
     }
-    <%_ } _%>
-    <%_ if (authenticationType === 'jwt') { _%>
+
+    @Test
+    void testExtractAuthorityFromClaims() {
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("groups", Arrays.asList(AuthoritiesConstants.ADMIN, AuthoritiesConstants.USER));
+
+        List<GrantedAuthority> expectedAuthorities = Arrays.asList(new SimpleGrantedAuthority(AuthoritiesConstants.ADMIN), new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+
+        List<GrantedAuthority> authorities = SecurityUtils.extractAuthorityFromClaims(claims);
+
+        assertThat(authorities).isNotNull().isNotEmpty().hasSize(2)
+            .containsAll(expectedAuthorities);
+    }
+
+    @Test
+    void testExtractAuthorityFromClaims_NamespacedRoles() {
+        Map<String, Object> claims = new HashMap<>();
+        claims.put(SecurityUtils.CLAIMS_NAMESPACE + "roles", Arrays.asList(AuthoritiesConstants.ADMIN, AuthoritiesConstants.USER));
+
+        List<GrantedAuthority> expectedAuthorities = Arrays.asList(new SimpleGrantedAuthority(AuthoritiesConstants.ADMIN), new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+
+        List<GrantedAuthority> authorities = SecurityUtils.extractAuthorityFromClaims(claims);
+
+        assertThat(authorities).isNotNull().isNotEmpty().hasSize(2)
+            .containsAll(expectedAuthorities);
+    }
+
+  <%_ } _%>
+  <%_ if (authenticationTypeJwt) { _%>
 
     @Test
     void testGetCurrentUserJWT() {
@@ -107,7 +134,7 @@ class SecurityUtilsUnitTest {
         Optional<String> jwt = SecurityUtils.getCurrentUserJWT();
         assertThat(jwt).contains("token");
     }
-    <%_ } _%>
+  <%_ } _%>
 
     @Test
     void testIsAuthenticated() {
@@ -140,6 +167,30 @@ class SecurityUtilsUnitTest {
         assertThat(SecurityUtils.hasCurrentUserThisAuthority(AuthoritiesConstants.USER)).isTrue();
         assertThat(SecurityUtils.hasCurrentUserThisAuthority(AuthoritiesConstants.ADMIN)).isFalse();
     }
+
+    @Test
+    void testHasCurrentUserAnyOfAuthorities() {
+        SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
+        Collection<GrantedAuthority> authorities = new ArrayList<>();
+        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+        securityContext.setAuthentication(new UsernamePasswordAuthenticationToken("user", "user", authorities));
+        SecurityContextHolder.setContext(securityContext);
+
+        assertThat(SecurityUtils.hasCurrentUserAnyOfAuthorities(AuthoritiesConstants.USER, AuthoritiesConstants.ADMIN)).isTrue();
+        assertThat(SecurityUtils.hasCurrentUserAnyOfAuthorities(AuthoritiesConstants.ANONYMOUS, AuthoritiesConstants.ADMIN)).isFalse();
+    }
+
+    @Test
+    void testHasCurrentUserNoneOfAuthorities() {
+        SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
+        Collection<GrantedAuthority> authorities = new ArrayList<>();
+        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+        securityContext.setAuthentication(new UsernamePasswordAuthenticationToken("user", "user", authorities));
+        SecurityContextHolder.setContext(securityContext);
+
+        assertThat(SecurityUtils.hasCurrentUserNoneOfAuthorities(AuthoritiesConstants.USER, AuthoritiesConstants.ADMIN)).isFalse();
+        assertThat(SecurityUtils.hasCurrentUserNoneOfAuthorities(AuthoritiesConstants.ANONYMOUS, AuthoritiesConstants.ADMIN)).isTrue();
+    }
 <%_ } _%>
 <%_ if (reactive) { _%>
     @Test
@@ -153,7 +204,7 @@ class SecurityUtilsUnitTest {
             .block();
         assertThat(login).isEqualTo("admin");
     }
-    <%_ if (authenticationType === 'jwt') { _%>
+  <%_ if (authenticationTypeJwt) { _%>
 
     @Test
     void testgetCurrentUserJWT() {
@@ -166,7 +217,7 @@ class SecurityUtilsUnitTest {
             .block();
         assertThat(jwt).isEqualTo("token");
     }
-    <%_ } _%>
+  <%_ } _%>
 
     @Test
     void testIsAuthenticated() {
@@ -194,6 +245,42 @@ class SecurityUtilsUnitTest {
         assertThat(isAuthenticated).isFalse();
     }
 
+    @Test
+    void testHasCurrentUserAnyOfAuthorities() {
+        Collection<GrantedAuthority> authorities = new ArrayList<>();
+        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+        Context context = ReactiveSecurityContextHolder.withAuthentication(
+            new UsernamePasswordAuthenticationToken("admin", "admin", authorities)
+        );
+        Boolean hasCurrentUserThisAuthority = SecurityUtils.hasCurrentUserAnyOfAuthorities(AuthoritiesConstants.USER, AuthoritiesConstants.ADMIN)
+            .subscriberContext(context)
+            .block();
+        assertThat(hasCurrentUserThisAuthority).isTrue();
+
+        hasCurrentUserThisAuthority = SecurityUtils.hasCurrentUserAnyOfAuthorities(AuthoritiesConstants.ANONYMOUS, AuthoritiesConstants.ADMIN)
+            .subscriberContext(context)
+            .block();
+        assertThat(hasCurrentUserThisAuthority).isFalse();
+    }
+
+    @Test
+    void testHasCurrentUserNoneOfAuthorities() {
+        Collection<GrantedAuthority> authorities = new ArrayList<>();
+        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.USER));
+        Context context = ReactiveSecurityContextHolder.withAuthentication(
+            new UsernamePasswordAuthenticationToken("admin", "admin", authorities)
+        );
+        Boolean hasCurrentUserThisAuthority = SecurityUtils.hasCurrentUserNoneOfAuthorities(AuthoritiesConstants.USER, AuthoritiesConstants.ADMIN)
+            .subscriberContext(context)
+            .block();
+        assertThat(hasCurrentUserThisAuthority).isFalse();
+
+        hasCurrentUserThisAuthority = SecurityUtils.hasCurrentUserNoneOfAuthorities(AuthoritiesConstants.ANONYMOUS, AuthoritiesConstants.ADMIN)
+            .subscriberContext(context)
+            .block();
+        assertThat(hasCurrentUserThisAuthority).isTrue();
+    }
+
     @Test
     void testHasCurrentUserThisAuthority() {
         Collection<GrantedAuthority> authorities = new ArrayList<>();