generator-jhipster 7.1.0 → 7.4.0

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,14 +65,17 @@ 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);
         jwtFilter = new JWTFilter(tokenProvider);
-        <%_ if (!reactive) { _%>
+<%_ if (!reactive) { _%>
         SecurityContextHolder.getContext().setAuthentication(null);
-        <%_ } _%>
+<%_ } _%>
     }
 
     @Test
@@ -81,7 +86,7 @@ class JWTFilterTest {
             Collections.singletonList(new SimpleGrantedAuthority(AuthoritiesConstants.USER))
         );
         String jwt = tokenProvider.createToken(authentication, false);
-        <%_ if (!reactive) { _%>
+<%_ if (!reactive) { _%>
         MockHttpServletRequest request = new MockHttpServletRequest();
         request.addHeader(JWTFilter.AUTHORIZATION_HEADER, "Bearer " + jwt);
         request.setRequestURI("/api/test");
@@ -91,7 +96,7 @@ class JWTFilterTest {
         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
         assertThat(SecurityContextHolder.getContext().getAuthentication().getName()).isEqualTo("test-user");
         assertThat(SecurityContextHolder.getContext().getAuthentication().getCredentials()).hasToString(jwt);
-        <%_ } else { _%>
+<%_ } else { _%>
         MockServerHttpRequest.BaseBuilder request = MockServerHttpRequest
             .get("/api/test")
             .header(JWTFilter.AUTHORIZATION_HEADER, "Bearer " + jwt);
@@ -105,13 +110,13 @@ class JWTFilterTest {
                 .doOnSuccess(auth -> assertThat(auth.getCredentials().toString()).hasToString(jwt))
                 .then()
         ).block();
-        <%_ } _%>
+<%_ } _%>
     }
 
     @Test
     void testJWTFilterInvalidToken()<% if (!reactive) { %> throws Exception<% } %> {
         String jwt = "wrong_jwt";
-        <%_ if (!reactive) { _%>
+<%_ if (!reactive) { _%>
         MockHttpServletRequest request = new MockHttpServletRequest();
         request.addHeader(JWTFilter.AUTHORIZATION_HEADER, "Bearer " + jwt);
         request.setRequestURI("/api/test");
@@ -120,7 +125,7 @@ class JWTFilterTest {
         jwtFilter.doFilter(request, response, filterChain);
         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
         assertThat(SecurityContextHolder.getContext().getAuthentication()).isNull();
-        <%_ } else { _%>
+<%_ } else { _%>
         MockServerHttpRequest.BaseBuilder request = MockServerHttpRequest
             .get("/api/test")
             .header(JWTFilter.AUTHORIZATION_HEADER, "Bearer " + jwt);
@@ -133,12 +138,12 @@ class JWTFilterTest {
                 .doOnSuccess(auth -> assertThat(auth).isNull())
                 .then()
         ).block();
-        <%_ } _%>
+<%_ } _%>
     }
 
     @Test
     void testJWTFilterMissingAuthorization()<% if (!reactive) { %> throws Exception<% } %> {
-        <%_ if (!reactive) { _%>
+<%_ if (!reactive) { _%>
         MockHttpServletRequest request = new MockHttpServletRequest();
         request.setRequestURI("/api/test");
         MockHttpServletResponse response = new MockHttpServletResponse();
@@ -146,7 +151,7 @@ class JWTFilterTest {
         jwtFilter.doFilter(request, response, filterChain);
         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
         assertThat(SecurityContextHolder.getContext().getAuthentication()).isNull();
-        <%_ } else { _%>
+<%_ } else { _%>
         MockServerHttpRequest.BaseBuilder request = MockServerHttpRequest
             .get("/api/test");
         MockServerWebExchange exchange = MockServerWebExchange.from(request);
@@ -158,12 +163,12 @@ class JWTFilterTest {
                 .doOnSuccess(auth -> assertThat(auth).isNull())
                 .then()
         ).block();
-        <%_ } _%>
+<%_ } _%>
     }
 
     @Test
     void testJWTFilterMissingToken()<% if (!reactive) { %> throws Exception<% } %> {
-        <%_ if (!reactive) { _%>
+<%_ if (!reactive) { _%>
         MockHttpServletRequest request = new MockHttpServletRequest();
         request.addHeader(JWTFilter.AUTHORIZATION_HEADER, "Bearer ");
         request.setRequestURI("/api/test");
@@ -172,7 +177,7 @@ class JWTFilterTest {
         jwtFilter.doFilter(request, response, filterChain);
         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
         assertThat(SecurityContextHolder.getContext().getAuthentication()).isNull();
-        <%_ } else { _%>
+<%_ } else { _%>
         MockServerHttpRequest.BaseBuilder request = MockServerHttpRequest
             .get("/api/test")
             .header(JWTFilter.AUTHORIZATION_HEADER, "Bearer ");
@@ -185,7 +190,7 @@ class JWTFilterTest {
                 .doOnSuccess(auth -> assertThat(auth).isNull())
                 .then()
         ).block();
-        <%_ } _%>
+<%_ } _%>
     }
 
     @Test
@@ -196,7 +201,7 @@ class JWTFilterTest {
             Collections.singletonList(new SimpleGrantedAuthority(AuthoritiesConstants.USER))
         );
         String jwt = tokenProvider.createToken(authentication, false);
-        <%_ if (!reactive) { _%>
+<%_ if (!reactive) { _%>
         MockHttpServletRequest request = new MockHttpServletRequest();
         request.addHeader(JWTFilter.AUTHORIZATION_HEADER, "Basic " + jwt);
         request.setRequestURI("/api/test");
@@ -205,7 +210,7 @@ class JWTFilterTest {
         jwtFilter.doFilter(request, response, filterChain);
         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
         assertThat(SecurityContextHolder.getContext().getAuthentication()).isNull();
-        <%_ } else { _%>
+<%_ } else { _%>
         MockServerHttpRequest.BaseBuilder request = MockServerHttpRequest
             .get("/api/test")
             .header(JWTFilter.AUTHORIZATION_HEADER, "Basic " + jwt);
@@ -218,7 +223,7 @@ class JWTFilterTest {
                 .doOnSuccess(auth -> assertThat(auth).isNull())
                 .then()
         ).block();
-        <%_ } _%>
+<%_ } _%>
     }
 
 }

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

@@ -8,7 +8,7 @@
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
 
-      http://www.apache.org/licenses/LICENSE-2.0
+      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,
@@ -20,9 +20,8 @@ package <%= packageName %>.security.oauth2;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ObjectNode;
-import <%= packageName %>.<%= mainClass %>;
-import <%= packageName %>.config.TestSecurityConfiguration;
 import <%= packageName %>.security.AuthoritiesConstants;
+import <%= packageName %>.security.SecurityUtils;
 import <%= packageName %>.IntegrationTest;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -37,7 +36,6 @@ import org.springframework.web.client.RestTemplate;
 
 import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -52,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();
 
@@ -120,4 +121,107 @@ class CustomClaimConverterIT {
         // WHEN
         assertThatCode(() -> customClaimConverter.convert(claims)).doesNotThrowAnyException();
     }
+
+    @Test
+    void testConvert_withNamespacedRoles() {
+        // GIVEN
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("sub", "123");
+        // AND
+        ObjectNode user = mapper.createObjectNode();
+        user.put("preferred_username", USERNAME);
+        user.put("given_name", NAME);
+        user.put("family_name", FAMILY_NAME);
+        user.putArray(SecurityUtils.CLAIMS_NAMESPACE + "roles").add(AuthoritiesConstants.ADMIN).add(AuthoritiesConstants.USER);
+        mockHttpGetUserInfo(user);
+
+        // WHEN
+        Map<String, Object> convertedClaims = customClaimConverter.convert(claims);
+
+        // THEN
+        assertThat(convertedClaims)
+            .containsEntry("sub", "123")
+            .containsEntry("preferred_username", USERNAME)
+            .containsEntry("given_name", NAME)
+            .containsEntry("family_name", FAMILY_NAME)
+            .containsEntry("roles", Arrays.asList(AuthoritiesConstants.ADMIN, AuthoritiesConstants.USER));
+    }
+
+    @Test
+    void testConvert_withoutFirstAndLastName() {
+        // GIVEN
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("sub", "123");
+        // AND
+        ObjectNode user = mapper.createObjectNode();
+        user.put("preferred_username", USERNAME);
+        mockHttpGetUserInfo(user);
+
+        assertThatCode(() ->  {
+            Map<String, Object> convertedClaims = customClaimConverter.convert(claims);
+            assertThat(convertedClaims)
+                .containsEntry("preferred_username", USERNAME)
+                .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();
+    }
 }

package/generators/server/templates/src/test/java/package/service/MailServiceIT.java.ejs

@@ -19,7 +19,7 @@
 package <%= packageName %>.service;
 
 import <%= packageName %>.config.Constants;
-<% if (databaseType === 'cassandra') { %>
+<% if (databaseTypeCassandra) { %>
 import <%= packageName %>.AbstractCassandraTest;<% } %>
 import <%= packageName %>.IntegrationTest;
 import <%= packageName %>.domain.<%= asEntity('User') %>;
@@ -59,7 +59,7 @@ import static org.mockito.Mockito.*;
  * Integration tests for {@link MailService}.
  */
 @IntegrationTest
-class MailServiceIT <% if (databaseType === 'cassandra') { %>extends AbstractCassandraTest <% } %>{
+class MailServiceIT <% if (databaseTypeCassandra) { %>extends AbstractCassandraTest <% } %>{
 
     private static final String[] languages = {
         // jhipster-needle-i18n-language-constant - JHipster will add/remove languages in this array
@@ -166,7 +166,7 @@ class MailServiceIT <% if (databaseType === 'cassandra') { %>extends AbstractCas
         assertThat(message.getContent().toString()).isEqualToNormalizingNewlines("<html>test title, http://127.0.0.1:8080, john</html>\n");
         assertThat(message.getDataHandler().getContentType()).isEqualTo("text/html;charset=UTF-8");
     }
-    <%_ if (authenticationType !== 'oauth2') { _%>
+<%_ if (!authenticationTypeOauth2) { _%>
 
     @Test
     void testSendActivationEmail() throws Exception {
@@ -212,7 +212,7 @@ class MailServiceIT <% if (databaseType === 'cassandra') { %>extends AbstractCas
         assertThat(message.getContent().toString()).isNotEmpty();
         assertThat(message.getDataHandler().getContentType()).isEqualTo("text/html;charset=UTF-8");
     }
-    <%_ } _%>
+<%_ } _%>
 
     @Test
     void testSendEmailWithException() {