generator-jhipster 7.2.0 → 7.4.1

package/generators/server/templates/src/main/java/package/security/oauth2/CustomClaimConverter.java.ejs

@@ -34,6 +34,7 @@ import org.springframework.web.client.RestTemplate;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -62,7 +63,7 @@ public class CustomClaimConverter implements Converter<Map<String, Object>, Map<
 
     public Map<String, Object> convert(Map<String, Object> claims) {
         Map<String, Object> convertedClaims = this.delegate.convert(claims);
-        if (RequestContextHolder.getRequestAttributes() != null) {
+        if (RequestContextHolder.getRequestAttributes() != null && ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()) != null) {
             // Retrieve and set the token
             String token = bearerTokenResolver.resolve(((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest());
             HttpHeaders headers = new HttpHeaders();
@@ -83,20 +84,31 @@ public class CustomClaimConverter implements Converter<Map<String, Object>, Map<
                 if (user.has("family_name")) {
                     convertedClaims.put("family_name", user.get("family_name").asText());
                 }
+                if (user.has("email")) {
+                    convertedClaims.put("email", user.get("email").asText());
+                }
+                // Allow full name in a name claim - happens with Auth0
+                if (user.has("name")) {
+                    String[] name = user.get("name").asText().split("\\s+");
+                    if (name.length > 0) {
+                        convertedClaims.put("given_name", name[0]);
+                        convertedClaims.put("family_name",
+                            String.join(" ", Arrays.copyOfRange(name, 1, name.length)));
+                    }
+                }
                 if (user.has("groups")) {
                     List<String> groups = StreamSupport.stream(user.get("groups").spliterator(), false)
                         .map(JsonNode::asText)
                         .collect(Collectors.toList());
                     convertedClaims.put("groups", groups);
                 }
-            }
-
-            if (user.has(SecurityUtils.CLAIMS_NAMESPACE + "roles")) {
-                List<String> roles = StreamSupport
-                    .stream(user.get(SecurityUtils.CLAIMS_NAMESPACE + "roles").spliterator(), false)
-                    .map(JsonNode::asText)
-                    .collect(Collectors.toList());
-                convertedClaims.put("roles", roles);
+                if (user.has(SecurityUtils.CLAIMS_NAMESPACE + "roles")) {
+                    List<String> roles = StreamSupport
+                        .stream(user.get(SecurityUtils.CLAIMS_NAMESPACE + "roles").spliterator(), false)
+                        .map(JsonNode::asText)
+                        .collect(Collectors.toList());
+                    convertedClaims.put("roles", roles);
+                }
             }
         }
         return convertedClaims;

package/generators/server/templates/src/main/java/package/service/UserService.java.ejs

@@ -1017,15 +1017,20 @@ public class UserService {
     private static <%= databaseTypeNo ? asDto('AdminUser') : asEntity('User') %> getUser(Map<String, Object> details) {
         <%= databaseTypeNo ? asDto('AdminUser') : asEntity('User') %> user = new <%= databaseTypeNo ? asDto('AdminUser') : asEntity('User') %>();
         Boolean activated = Boolean.TRUE;
+        String sub = String.valueOf(details.get("sub"));
+        String username = null;
+        if (details.get("preferred_username") != null) {
+            username = ((String) details.get("preferred_username")).toLowerCase();
+        }
         // handle resource server JWT, where sub claim is email and uid is ID
         if (details.get("uid") != null) {
             user.setId((String) details.get("uid"));
-            user.setLogin((String) details.get("sub"));
+            user.setLogin(sub);
         } else {
-            user.setId((String) details.get("sub"));
+            user.setId(sub);
         }
-        if (details.get("preferred_username") != null) {
-            user.setLogin(((String) details.get("preferred_username")).toLowerCase());
+        if (username != null) {
+            user.setLogin(username);
         } else if (user.getLogin() == null) {
             user.setLogin(user.getId());
         }
@@ -1042,8 +1047,11 @@ public class UserService {
         }
         if (details.get("email") != null) {
             user.setEmail(((String) details.get("email")).toLowerCase());
+        } else if (sub.contains("|") && (username != null && username.contains("@"))) {
+            // special handling for Auth0
+            user.setEmail(username);
         } else {
-            user.setEmail((String) details.get("sub"));
+            user.setEmail(sub);
         }
         if (details.get("langKey") != null) {
             user.setLangKey((String) details.get("langKey"));

package/generators/server/templates/src/main/resources/config/application-dev.yml.ejs

@@ -357,7 +357,7 @@ jhipster:
   # CORS is only enabled by default with the "dev" profile
   cors:
     # Allow Ionic for JHipster by default (* no longer allowed in Spring Boot 2.4+)
-    allowed-origins: "http://localhost:8100,https://localhost:8100,http://localhost:9000,https://localhost:9000<%_ if (!skipClient) { _%>,http://localhost:<%= devServerPort %>,https://localhost:<%= devServerPort %><%_ } _%>"
+    allowed-origins: "http://localhost:8100,https://localhost:8100,http://localhost:9000,https://localhost:9000<%_ if (!skipClient) { _%>,http://localhost:<%= devServerPort %>,https://localhost:<%= devServerPort %><%_ if (applicationTypeGateway && microfrontend) { for ({applicationIndex, devServerPort: microserviceDevServerPort = devServerPort + applicationIndex} of Object.values(jhipsterConfig.applications || {})) { _%>,http://localhost:<%= microserviceDevServerPort %>,https://localhost:<%= microserviceDevServerPort %><%_ } } _%><%_ } _%>"
     allowed-methods: "*"
     allowed-headers: "*"
   <%_ if (authenticationTypeSession) { _%>

package/generators/server/templates/src/main/resources/config/application-prod.yml.ejs

@@ -251,7 +251,7 @@ server:
   shutdown: graceful # see https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-graceful-shutdown
   compression:
     enabled: true
-    mime-types: text/html,text/xml,text/plain,text/css, application/javascript, application/json
+    mime-types: text/html,text/xml,text/plain,text/css,application/javascript,application/json,image/svg+xml
     min-response-size: 1024
 
 # ===================================================================

package/generators/server/templates/src/main/resources/config/application.yml.ejs

@@ -92,17 +92,17 @@ management:
       roles: "ROLE_ADMIN"
       probes:
         enabled: true
+      group:
+        liveness:
+          include: livenessState
+        readiness:
+          include: readinessState<% if (databaseTypeSql) { %>,db<% } %>
     jhimetrics:
       enabled: true
   info:
     git:
       mode: full
   health:
-    group:
-      liveness:
-        include: livenessState
-      readiness:
-        include: readinessState<% if (databaseTypeSql) { %>,db<% } %>
     mail:
       enabled: false # When using the MailService, configure an SMTP server and set this to true
   metrics:
@@ -320,8 +320,8 @@ jhipster:
   api-docs:
     default-include-pattern: ${server.servlet.context-path:}/api/.*
     management-include-pattern: ${server.servlet.context-path:}/management/.*
-    title: <%= baseName %> API
-    description: <%= baseName %> API documentation
+    title: <%= humanizedBaseName %> API
+    description: <%= humanizedBaseName %> API documentation
     version: 0.0.1
     terms-of-service-url:
     contact-name:

package/generators/server/templates/src/main/resources/static/microservices_index.html.ejs

@@ -78,7 +78,7 @@
 
   <ul>
 <%_ if (microfrontend) { %>
-    <li>Microfrontends packages don't provide a stand-alone front-end. Packaged microfrontend should be accessed through a JHipster gateway.</li>
+    <li>JHipster's microfrontends implementation doesn't provide a stand-alone UI. Packaged microfrontends should be accessed through a JHipster gateway.</li>
     <li>Stand-alone development server can be started by `npm start`.</li>
 <%_ } else { %>
     <li>It does not have a front-end. The front-end should be generated on a JHipster gateway.</li>

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/security/jwt/JWTFilterTest.java.ejs

@@ -18,8 +18,10 @@
 -%>
 package <%= packageName %>.security.jwt;
 
+import <%= packageName %>.management.SecurityMetersService;
 import <%= packageName %>.security.AuthoritiesConstants;
 import tech.jhipster.config.JHipsterProperties;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
 import io.jsonwebtoken.io.Decoders;
 import io.jsonwebtoken.security.Keys;
 
@@ -63,7 +65,10 @@ class JWTFilterTest {
         JHipsterProperties jHipsterProperties = new JHipsterProperties();
         String base64Secret = "fd54a45s65fds737b9aafcb3412e07ed99b267f33413274720ddbb7f6c5e64e9f14075f2d7ed041592f0b7657baf8";
         jHipsterProperties.getSecurity().getAuthentication().getJwt().setBase64Secret(base64Secret);
-        tokenProvider = new TokenProvider(jHipsterProperties);
+
+        SecurityMetersService securityMetersService = new SecurityMetersService(new SimpleMeterRegistry());
+
+        tokenProvider = new TokenProvider(jHipsterProperties, securityMetersService);
         ReflectionTestUtils.setField(tokenProvider, "key", Keys.hmacShaKeyFor(Decoders.BASE64.decode(base64Secret)));
 
         ReflectionTestUtils.setField(tokenProvider, "tokenValidityInMilliseconds", 60000);

package/generators/server/templates/src/test/java/package/security/jwt/TokenProviderSecurityMetersTests.java.ejs

@@ -0,0 +1,198 @@
+<%#
+ 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 %>.security.jwt;
+
+import <%= packageName %>.security.AuthoritiesConstants;
+import <%= packageName %>.management.SecurityMetersService;
+
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.io.Decoders;
+import io.jsonwebtoken.security.Keys;
+
+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 org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.test.util.ReflectionTestUtils;
+import tech.jhipster.config.JHipsterProperties;
+
+import java.security.Key;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class TokenProviderSecurityMetersTests {
+
+    private static final long ONE_MINUTE = 60000;
+    private static final String INVALID_TOKENS_METER_EXPECTED_NAME = "security.authentication.invalid-tokens";
+
+    private MeterRegistry meterRegistry;
+
+    private TokenProvider tokenProvider;
+
+    @BeforeEach
+    public void setup() {
+        JHipsterProperties jHipsterProperties = new JHipsterProperties();
+        String base64Secret = "fd54a45s65fds737b9aafcb3412e07ed99b267f33413274720ddbb7f6c5e64e9f14075f2d7ed041592f0b7657baf8";
+        jHipsterProperties.getSecurity().getAuthentication().getJwt().setBase64Secret(base64Secret);
+
+        meterRegistry = new SimpleMeterRegistry();
+
+        SecurityMetersService securityMetersService = new SecurityMetersService(meterRegistry);
+
+        tokenProvider = new TokenProvider(jHipsterProperties, securityMetersService);
+        Key key = Keys.hmacShaKeyFor(Decoders.BASE64.decode(base64Secret));
+
+        ReflectionTestUtils.setField(tokenProvider, "key", key);
+        ReflectionTestUtils.setField(tokenProvider, "tokenValidityInMilliseconds", ONE_MINUTE);
+    }
+
+    @Test
+    public void testValidTokenShouldNotCountAnything() {
+        Collection<Counter> counters = meterRegistry.find(INVALID_TOKENS_METER_EXPECTED_NAME).counters();
+
+        assertThat(aggregate(counters)).isEqualTo(0);
+
+        String validToken = createValidToken();
+
+        tokenProvider.validateToken(validToken);
+
+        assertThat(aggregate(counters)).isEqualTo(0);
+    }
+
+    @Test
+    public void testTokenExpiredCount() {
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "expired")
+            .counter().count()).isEqualTo(0);
+
+        String expiredToken = createExpiredToken();
+
+        tokenProvider.validateToken(expiredToken);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "expired")
+            .counter().count()).isEqualTo(1);
+    }
+
+    @Test
+    void testTokenUnsupportedCount() {
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "unsupported")
+            .counter().count()).isEqualTo(0);
+
+        String unsupportedToken = createUnsupportedToken();
+
+        tokenProvider.validateToken(unsupportedToken);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "unsupported")
+            .counter().count()).isEqualTo(1);
+    }
+
+    @Test
+    public void testTokenSignatureInvalidCount() {
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "invalid-signature")
+            .counter().count()).isEqualTo(0);
+
+        String tokenWithDifferentSignature = createTokenWithDifferentSignature();
+
+        tokenProvider.validateToken(tokenWithDifferentSignature);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "invalid-signature")
+            .counter().count()).isEqualTo(1);
+    }
+
+    @Test
+    public void testTokenMalformedCount() {
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "malformed")
+            .counter().count()).isEqualTo(0);
+
+        String malformedToken = createMalformedToken();
+
+        tokenProvider.validateToken(malformedToken);
+
+        assertThat(meterRegistry.get(INVALID_TOKENS_METER_EXPECTED_NAME)
+            .tag("cause", "malformed")
+            .counter().count()).isEqualTo(1);
+    }
+
+    private String createValidToken() {
+        Authentication authentication = createAuthentication();
+
+        return tokenProvider.createToken(authentication, false);
+    }
+
+    private String createExpiredToken() {
+        ReflectionTestUtils.setField(tokenProvider, "tokenValidityInMilliseconds", -ONE_MINUTE);
+
+        Authentication authentication = createAuthentication();
+
+        return tokenProvider.createToken(authentication, false);
+    }
+
+    private Authentication createAuthentication() {
+        Collection<GrantedAuthority> authorities = new ArrayList<>();
+        authorities.add(new SimpleGrantedAuthority(AuthoritiesConstants.ANONYMOUS));
+        return new UsernamePasswordAuthenticationToken("anonymous", "anonymous", authorities);
+    }
+
+    private String createUnsupportedToken() {
+        Key key = (Key) ReflectionTestUtils.getField(tokenProvider, "key");
+
+        return Jwts.builder().setPayload("payload").signWith(key, SignatureAlgorithm.HS256).compact();
+    }
+
+    private String createMalformedToken() {
+        String validToken = createValidToken();
+
+        return "X" + validToken;
+    }
+
+    private String createTokenWithDifferentSignature() {
+        Key otherKey = Keys.hmacShaKeyFor(
+            Decoders.BASE64.decode("Xfd54a45s65fds737b9aafcb3412e07ed99b267f33413274720ddbb7f6c5e64e9f14075f2d7ed041592f0b7657baf8")
+        );
+
+        return Jwts
+            .builder()
+            .setSubject("anonymous")
+            .signWith(otherKey, SignatureAlgorithm.HS512)
+            .setExpiration(new Date(new Date().getTime() + ONE_MINUTE))
+            .compact();
+    }
+
+    private double aggregate(Collection<Counter> counters) {
+        return counters.stream().mapToDouble(Counter::count).sum();
+    }
+
+}

package/generators/server/templates/src/test/java/package/security/jwt/TokenProviderTest.java.ejs

@@ -19,6 +19,7 @@
 package <%= packageName %>.security.jwt;
 
 import <%= packageName %>.security.AuthoritiesConstants;
+import <%= packageName %>.management.SecurityMetersService;
 
 import java.security.Key;
 import java.util.*;
@@ -31,6 +32,8 @@ import org.springframework.security.core.GrantedAuthority;
 import org.springframework.security.core.authority.SimpleGrantedAuthority;
 import org.springframework.test.util.ReflectionTestUtils;
 
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+
 import tech.jhipster.config.JHipsterProperties;
 import io.jsonwebtoken.Jwts;
 import io.jsonwebtoken.SignatureAlgorithm;
@@ -53,7 +56,10 @@ class TokenProviderTest {
         JHipsterProperties jHipsterProperties = new JHipsterProperties();
         String base64Secret = "fd54a45s65fds737b9aafcb3412e07ed99b267f33413274720ddbb7f6c5e64e9f14075f2d7ed041592f0b7657baf8";
         jHipsterProperties.getSecurity().getAuthentication().getJwt().setBase64Secret(base64Secret);
-        tokenProvider = new TokenProvider(jHipsterProperties);
+
+        SecurityMetersService securityMetersService = new SecurityMetersService(new SimpleMeterRegistry());
+
+        tokenProvider = new TokenProvider(jHipsterProperties, securityMetersService);
         key = Keys.hmacShaKeyFor(Decoders.BASE64.decode(base64Secret));
 
         ReflectionTestUtils.setField(tokenProvider, "key", key);
@@ -111,7 +117,9 @@ class TokenProviderTest {
         JHipsterProperties jHipsterProperties = new JHipsterProperties();
         jHipsterProperties.getSecurity().getAuthentication().getJwt().setSecret(secret);
 
-        TokenProvider tokenProvider = new TokenProvider(jHipsterProperties);
+        SecurityMetersService securityMetersService = new SecurityMetersService(new SimpleMeterRegistry());
+
+        TokenProvider tokenProvider = new TokenProvider(jHipsterProperties, securityMetersService);
 
         Key key = (Key) ReflectionTestUtils.getField(tokenProvider, "key");
         assertThat(key).isNotNull().isEqualTo(Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8)));
@@ -123,7 +131,9 @@ class TokenProviderTest {
         JHipsterProperties jHipsterProperties = new JHipsterProperties();
         jHipsterProperties.getSecurity().getAuthentication().getJwt().setBase64Secret(base64Secret);
 
-        TokenProvider tokenProvider = new TokenProvider(jHipsterProperties);
+        SecurityMetersService securityMetersService = new SecurityMetersService(new SimpleMeterRegistry());
+
+        TokenProvider tokenProvider = new TokenProvider(jHipsterProperties, securityMetersService);
 
         Key key = (Key) ReflectionTestUtils.getField(tokenProvider, "key");
         assertThat(key).isNotNull().isEqualTo(Keys.hmacShaKeyFor(Decoders.BASE64.decode(base64Secret)));

package/generators/server/templates/src/test/java/package/security/oauth2/AuthorizationHeaderUtilTest.java.ejs

@@ -50,6 +50,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.mockito.ArgumentMatchers.*;
 import static org.mockito.Mockito.*;
 
@@ -179,6 +180,20 @@ class AuthorizationHeaderUtilTest {
     }
 
     private OAuth2AuthorizedClient getTestOAuth2AuthorizedClient(boolean accessTokenExpired) {
+        Instant issuedAt = Instant.now();
+        Instant expiresAt;
+        if (accessTokenExpired) {
+            expiresAt = issuedAt.plus(Duration.ofNanos(1));
+            try {
+                Thread.sleep(1);
+            } catch (Exception e) {
+                fail("Error in Thread.sleep(1) : " + e.getMessage());
+            }
+        } else {
+            expiresAt = issuedAt.plus(Duration.ofMinutes(3));
+        }
+        OAuth2AccessToken token = new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "tokenVal", issuedAt, expiresAt);
+
         return new OAuth2AuthorizedClient(
             ClientRegistration.withRegistrationId(VALID_REGISTRATION_ID)
                 .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
@@ -189,8 +204,7 @@ class AuthorizationHeaderUtilTest {
                 .tokenUri("https://localhost:8080/auth/realms/master/protocol/openid-connect/token")
                 .build(),
             "sub",
-            new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "tokenVal", Instant.now(),
-                accessTokenExpired ? Instant.now() : Instant.now().plus(Duration.ofMinutes(3))),
+            token,
             new OAuth2RefreshToken("refreshVal", Instant.now()));
     }
 

package/generators/server/templates/src/test/java/package/security/oauth2/CustomClaimConverterIT.java.ejs

@@ -50,6 +50,9 @@ class CustomClaimConverterIT {
     private static final String USERNAME = "admin";
     private static final String NAME = "John";
     private static final String FAMILY_NAME = "Doe";
+    private static final String FULL_NAME = NAME + " " + FAMILY_NAME;
+    private static final String NAME_SUFFIX = "Sr.";
+    private static final String EMAIL = "john.doe@gmail.com";
 
     private final ObjectMapper mapper = new ObjectMapper();
 
@@ -161,4 +164,64 @@ class CustomClaimConverterIT {
                 .doesNotContainKeys("given_name", "family_name");
         }).doesNotThrowAnyException();
     }
+
+    @Test
+    void testConvert_withName() {
+        // GIVEN
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("sub", "123");
+        // AND
+        ObjectNode user = mapper.createObjectNode();
+        user.put("preferred_username", USERNAME);
+        user.put("name", FULL_NAME);
+        mockHttpGetUserInfo(user);
+
+        assertThatCode(() ->  {
+            Map<String, Object> convertedClaims = customClaimConverter.convert(claims);
+            assertThat(convertedClaims)
+                .containsEntry("preferred_username", USERNAME)
+                .containsEntry("given_name", NAME)
+                .containsEntry("family_name", FAMILY_NAME);
+        }).doesNotThrowAnyException();
+    }
+
+    @Test
+    void testConvert_withLastNameMultipleWords() {
+        // GIVEN
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("sub", "123");
+        // AND
+        ObjectNode user = mapper.createObjectNode();
+        user.put("preferred_username", USERNAME);
+        user.put("name", FULL_NAME + " " + NAME_SUFFIX);
+        mockHttpGetUserInfo(user);
+
+        assertThatCode(() ->  {
+            Map<String, Object> convertedClaims = customClaimConverter.convert(claims);
+            System.out.println(convertedClaims);
+            assertThat(convertedClaims)
+                .containsEntry("preferred_username", USERNAME)
+                .containsEntry("given_name", NAME)
+                .containsEntry("family_name", FAMILY_NAME + " " + NAME_SUFFIX);
+        }).doesNotThrowAnyException();
+    }
+
+    @Test
+    void testConvert_withEmail() {
+        // GIVEN
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("sub", "123");
+        // AND
+        ObjectNode user = mapper.createObjectNode();
+        user.put("preferred_username", USERNAME);
+        user.put("email", EMAIL);
+        mockHttpGetUserInfo(user);
+
+        assertThatCode(() ->  {
+            Map<String, Object> convertedClaims = customClaimConverter.convert(claims);
+            assertThat(convertedClaims)
+                .containsEntry("preferred_username", USERNAME)
+                .containsEntry("email", EMAIL);
+        }).doesNotThrowAnyException();
+    }
 }