generator-jhipster 8.0.0-beta.3 → 8.0.0-rc.1

package/dist/generators/server/templates/src/test/java/_package_/service/mapper/UserMapperTest.java.ejs

@@ -0,0 +1,182 @@
+<%#
+ Copyright 2013-2023 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 %>.service.mapper;
+
+import <%= user.entityAbsoluteClass %>;
+import <%= packageName %>.service.dto.<%= user.adminUserDto %>;
+import <%= packageName %>.service.dto.<%= user.dtoClass %>;
+<%_ if (!authenticationTypeOauth2) { _%>
+import org.apache.commons.lang3.RandomStringUtils;
+<%_ } _%>
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+<%_ if (user.primaryKey.hasUUID) { _%>
+import java.util.UUID;
+<%_ } _%>
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for {@link UserMapper}.
+ */
+class UserMapperTest {
+
+    private static final String DEFAULT_LOGIN = "johndoe";
+<%_ if (databaseTypeCouchbase) { _%>
+    private static final String DEFAULT_ID = DEFAULT_LOGIN;
+<%_ } else { _%>
+    private static final <%= user.primaryKey.type %> DEFAULT_ID = <%- this.getPrimaryKeyValue(user.primaryKey.type) %>;
+<%_ } _%>
+
+    private UserMapper userMapper;
+    private <%= user.persistClass %> user;
+    private <%= user.adminUserDto %> userDto;
+
+    @BeforeEach
+    public void init() {
+        userMapper = new UserMapper();
+        user = new <%= user.persistClass %>();
+        user.setLogin(DEFAULT_LOGIN);
+<%_ if (!authenticationTypeOauth2) { _%>
+        user.setPassword(RandomStringUtils.randomAlphanumeric(60));
+<%_ } _%>
+        user.setActivated(true);
+        user.setEmail("johndoe@localhost");
+        user.setFirstName("john");
+        user.setLastName("doe");
+<%_ if (!databaseTypeCassandra) { _%>
+        user.setImageUrl("image_url");
+<%_ } _%>
+        user.setLangKey("en");
+
+        userDto = new <%= user.adminUserDto %>(user);
+    }
+
+    @Test
+    void usersToUserDTOsShouldMapOnlyNonNullUsers() {
+        List<<%= user.persistClass %>> users = new ArrayList<>();
+        users.add(user);
+        users.add(null);
+
+        List<<%= user.dtoClass %>> userDTOS = userMapper.usersToUserDTOs(users);
+
+        assertThat(userDTOS)
+          .isNotEmpty()
+          .size().isEqualTo(1);
+    }
+
+    @Test
+    void userDTOsToUsersShouldMapOnlyNonNullUsers() {
+        List<<%= user.adminUserDto %>> usersDto = new ArrayList<>();
+        usersDto.add(userDto);
+        usersDto.add(null);
+
+        List<<%= user.persistClass %>> users = userMapper.userDTOsToUsers(usersDto);
+
+        assertThat(users)
+          .isNotEmpty()
+          .size().isEqualTo(1);
+    }
+
+    @Test
+    void userDTOsToUsersWithAuthoritiesStringShouldMapToUsersWithAuthoritiesDomain() {
+        Set<String> authoritiesAsString = new HashSet<>();
+        authoritiesAsString.add("ADMIN");
+        userDto.setAuthorities(authoritiesAsString);
+
+        List<<%= user.adminUserDto %>> usersDto = new ArrayList<>();
+        usersDto.add(userDto);
+
+        List<<%= user.persistClass %>> users = userMapper.userDTOsToUsers(usersDto);
+
+        assertThat(users)
+          .isNotEmpty()
+          .size().isEqualTo(1);
+        assertThat(users.get(0).getAuthorities()).isNotNull();
+        assertThat(users.get(0).getAuthorities()).isNotEmpty();
+<%_ if (databaseTypeSql || databaseTypeMongodb) { _%>
+        assertThat(users.get(0).getAuthorities().iterator().next().getName()).isEqualTo("ADMIN");
+<%_ } _%>
+<%_ if (databaseTypeCassandra || databaseTypeCouchbase) { _%>
+        assertThat(users.get(0).getAuthorities().iterator().next()).isEqualTo("ADMIN");
+<%_ } _%>
+    }
+
+    @Test
+    void userDTOsToUsersMapWithNullAuthoritiesStringShouldReturnUserWithEmptyAuthorities() {
+        userDto.setAuthorities(null);
+
+        List<<%= user.adminUserDto %>> usersDto = new ArrayList<>();
+        usersDto.add(userDto);
+
+        List<<%= user.persistClass %>> users = userMapper.userDTOsToUsers(usersDto);
+
+        assertThat(users)
+          .isNotEmpty()
+          .size().isEqualTo(1);
+        assertThat(users.get(0).getAuthorities()).isNotNull();
+        assertThat(users.get(0).getAuthorities()).isEmpty();
+    }
+
+    @Test
+    void userDTOToUserMapWithAuthoritiesStringShouldReturnUserWithAuthorities() {
+        Set<String> authoritiesAsString = new HashSet<>();
+        authoritiesAsString.add("ADMIN");
+        userDto.setAuthorities(authoritiesAsString);
+
+        <%= user.persistClass %> user = userMapper.userDTOToUser(userDto);
+
+        assertThat(user).isNotNull();
+        assertThat(user.getAuthorities()).isNotNull();
+        assertThat(user.getAuthorities()).isNotEmpty();
+<%_ if (databaseTypeSql || databaseTypeMongodb) { _%>
+        assertThat(user.getAuthorities().iterator().next().getName()).isEqualTo("ADMIN");
+<%_ } _%>
+<%_ if (databaseTypeCassandra || databaseTypeCouchbase) { _%>
+        assertThat(user.getAuthorities().iterator().next()).isEqualTo("ADMIN");
+<%_ } _%>
+    }
+
+    @Test
+    void userDTOToUserMapWithNullAuthoritiesStringShouldReturnUserWithEmptyAuthorities() {
+        userDto.setAuthorities(null);
+
+        <%= user.persistClass %> user = userMapper.userDTOToUser(userDto);
+
+        assertThat(user).isNotNull();
+        assertThat(user.getAuthorities()).isNotNull();
+        assertThat(user.getAuthorities()).isEmpty();
+    }
+
+    @Test
+    void userDTOToUserMapWithNullUserShouldReturnNull() {
+        assertThat(userMapper.userDTOToUser(null)).isNull();
+    }
+
+    @Test
+    void testUserFromId() {
+        assertThat(userMapper.userFromId(DEFAULT_ID).getId()).isEqualTo(DEFAULT_ID);
+        assertThat(userMapper.userFromId(null)).isNull();
+    }
+}

package/dist/generators/server/templates/src/test/java/_package_/test/util/OAuth2TestUtil.java.ejs

@@ -0,0 +1,104 @@
+<%#
+ Copyright 2013-2023 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.
+-%>
+<%_ const reactivePrefix = reactive ? 'Reactive' : ''; _%>
+package <%= packageName %>.test.util;
+
+import <%= packageName %>.security.AuthoritiesConstants;
+import <%= packageName %>.security.SecurityUtils;
+
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.<%= reactivePrefix %>OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.security.oauth2.client.registration.ClientRegistration;
+import org.springframework.security.oauth2.core.OAuth2AccessToken;
+import org.springframework.security.oauth2.core.OAuth2AccessToken.TokenType;
+import org.springframework.security.oauth2.core.oidc.OidcIdToken;
+import org.springframework.security.oauth2.core.oidc.OidcUserInfo;
+import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
+
+public class OAuth2TestUtil {
+    public static final String TEST_USER_LOGIN = "test";
+
+    public static final String ID_TOKEN =
+        "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9" +
+        ".eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsIm" +
+        "p0aSI6ImQzNWRmMTRkLTA5ZjYtNDhmZi04YTkzLTdjNmYwMzM5MzE1OSIsImlhdCI6MTU0M" +
+        "Tk3MTU4MywiZXhwIjoxNTQxOTc1MTgzfQ.QaQOarmV8xEUYV7yvWzX3cUE_4W1luMcWCwpr" +
+        "oqqUrg";
+
+    public static OAuth2AuthenticationToken testAuthenticationToken() {
+        Map<String, Object> claims = new HashMap<>();
+        claims.put("sub", TEST_USER_LOGIN);
+        claims.put("preferred_username", TEST_USER_LOGIN);
+        claims.put("email", "john.doe@jhipster.com");
+        claims.put("roles", Collections.singletonList(AuthoritiesConstants.ADMIN));
+
+        return authenticationToken(claims);
+    }
+
+    public static OAuth2AuthenticationToken authenticationToken(Map<String, Object> claims) {
+        Instant issuedAt = Instant.now();
+        Instant expiresAt = Instant.now().plus(1, ChronoUnit.DAYS);
+        if (!claims.containsKey("sub")) {
+            claims.put("sub", "jane");
+        }
+        if (!claims.containsKey("preferred_username")) {
+            claims.put("preferred_username", "jane");
+        }
+        if (!claims.containsKey("email")) {
+            claims.put("email", "jane.doe@jhipster.com");
+        }
+        if (claims.containsKey("auth_time")) {
+            issuedAt = (Instant) claims.get("auth_time");
+        } else {
+            claims.put("auth_time", issuedAt);
+        }
+        if (claims.containsKey("exp")) {
+            expiresAt = (Instant) claims.get("exp");
+        } else {
+            claims.put("exp", expiresAt);
+        }
+        Collection<GrantedAuthority> authorities = SecurityUtils.extractAuthorityFromClaims(claims);
+        OidcIdToken token = new OidcIdToken(ID_TOKEN, issuedAt, expiresAt, claims);
+        OidcUserInfo userInfo = new OidcUserInfo(claims);
+        DefaultOidcUser user = new DefaultOidcUser(authorities, token, userInfo, "preferred_username");
+        return new OAuth2AuthenticationToken(user, user.getAuthorities(), "oidc");
+    }
+
+    public static OAuth2AuthenticationToken registerAuthenticationToken(<%= reactivePrefix %>OAuth2AuthorizedClientService authorizedClientService, ClientRegistration clientRegistration, OAuth2AuthenticationToken authentication) {
+        Map<String, Object> userDetails = authentication.getPrincipal().getAttributes();
+
+        OAuth2AccessToken token = new OAuth2AccessToken(TokenType.BEARER, "Token", (Instant)userDetails.get("auth_time"), (Instant)userDetails.get("exp"));
+
+        authorizedClientService.saveAuthorizedClient(
+            new OAuth2AuthorizedClient(clientRegistration, authentication.getName(), token),
+            authentication
+        )<% if (reactive) { %>.block()<% } %>;
+
+        return authentication;
+    }
+}

package/dist/generators/server/templates/src/test/java/_package_/web/filter/ModifyServersOpenApiFilterTest.java.ejs

@@ -0,0 +1,150 @@
+package <%= packageName %>.web.filter;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.zip.GZIPOutputStream;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.cloud.gateway.filter.GatewayFilterChain;
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.http.HttpHeaders;
+import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
+import org.springframework.mock.web.server.MockServerWebExchange;
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+class ModifyServersOpenApiFilterTest {
+
+    private static final Logger log = LoggerFactory.getLogger(ModifyServersOpenApiFilterTest.class);
+    private final GatewayFilterChain filterChain = mock(GatewayFilterChain.class);
+    private final ArgumentCaptor<ServerWebExchange> captor = ArgumentCaptor.forClass(ServerWebExchange.class);
+
+    @BeforeEach
+    void setup() {
+        when(filterChain.filter(captor.capture())).thenReturn(Mono.empty());
+    }
+
+    @Test
+    void shouldCallCreateModifyServersOpenApiInterceptorWhenGetOpenApiSpec() {
+        // dummy api url to filter
+        String sample_url = "/services/service-test/instance-test/v3/api-docs";
+
+        // create request
+        MockServerHttpRequest request = MockServerHttpRequest.get(sample_url).build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        // apply the filter to the request
+        ModifyServersOpenApiFilter modifyServersOpenApiFilter = spy(new ModifyServersOpenApiFilter());
+        modifyServersOpenApiFilter.filter(exchange, filterChain).subscribe();
+
+        verify(modifyServersOpenApiFilter, times(1))
+            .createModifyServersOpenApiInterceptor(sample_url, exchange.getResponse(), exchange.getResponse().bufferFactory());
+    }
+
+    @Test
+    void shouldNotCallCreateModifyServersOpenApiInterceptorWhenNotGetOpenApiSpec() {
+        // dummy api url to filter
+        String sample_url = "/services/service-test/instance-test/api";
+
+        // create request
+        MockServerHttpRequest request = MockServerHttpRequest.get(sample_url).build();
+        ServerWebExchange exchange = MockServerWebExchange.from(request);
+
+        // apply the filter to the request
+        ModifyServersOpenApiFilter modifyServersOpenApiFilter = spy(new ModifyServersOpenApiFilter());
+        modifyServersOpenApiFilter.filter(exchange, filterChain).subscribe();
+
+        verify(modifyServersOpenApiFilter, times(0))
+            .createModifyServersOpenApiInterceptor(sample_url, exchange.getResponse(), exchange.getResponse().bufferFactory());
+    }
+
+    @Test
+    void shouldOrderToMinusOne() {
+        ModifyServersOpenApiFilter modifyServersOpenApiFilter = new ModifyServersOpenApiFilter();
+        assertEquals(modifyServersOpenApiFilter.getOrder(), -1);
+    }
+
+    @Nested
+    class ModifyServersOpenApiInterceptorTest {
+
+        private final String path = "/services/service-test/instance-test/v3/api-docs";
+        private final MockServerHttpRequest request = MockServerHttpRequest.get(path).build();
+        private final ServerWebExchange exchange = MockServerWebExchange.from(request);
+        private final ModifyServersOpenApiFilter modifyServersOpenApiFilter = new ModifyServersOpenApiFilter();
+
+        @Test
+        void shouldRewriteBodyWhenBodyIsFluxAndResponseIsNotZipped() {
+            ModifyServersOpenApiFilter.ModifyServersOpenApiInterceptor interceptor = modifyServersOpenApiFilter.createModifyServersOpenApiInterceptor(
+                    path,
+                    exchange.getResponse(),
+                    exchange.getResponse().bufferFactory()
+                );
+
+            byte[] bytes = "{}".getBytes();
+            DataBuffer body = exchange.getResponse().bufferFactory().wrap(bytes);
+            interceptor.writeWith(Flux.just(body)).subscribe();
+            assertThat(
+                interceptor
+                    .getRewritedBody()
+                    .contains("\"servers\":[{\"url\":\"/services/service-test/instance-test\",\"description\":\"added by global filter\"}]")
+            ).isTrue();
+        }
+
+        @Test
+        void shouldRewriteBodyWhenBodyIsFluxAndResponseIsZipped() {
+            exchange.getResponse().getHeaders().set(HttpHeaders.CONTENT_ENCODING, "gzip");
+            ModifyServersOpenApiFilter.ModifyServersOpenApiInterceptor interceptor = modifyServersOpenApiFilter.createModifyServersOpenApiInterceptor(
+                    path,
+                    exchange.getResponse(),
+                    exchange.getResponse().bufferFactory()
+                );
+
+            byte[] bytes = zipContent();
+            DataBuffer body = exchange.getResponse().bufferFactory().wrap(bytes);
+            interceptor.writeWith(Flux.just(body)).subscribe();
+            assertThat(
+                interceptor
+                    .getRewritedBody()
+                    .contains("\"servers\":[{\"url\":\"/services/service-test/instance-test\",\"description\":\"added by global filter\"}]")
+            ).isTrue();
+        }
+
+        @Test
+        void shouldNotRewriteBodyWhenBodyIsNotFlux() {
+            ModifyServersOpenApiFilter.ModifyServersOpenApiInterceptor interceptor = modifyServersOpenApiFilter.createModifyServersOpenApiInterceptor(
+                    path,
+                    exchange.getResponse(),
+                    exchange.getResponse().bufferFactory()
+                );
+
+            byte[] bytes = "{}".getBytes();
+            DataBuffer body = exchange.getResponse().bufferFactory().wrap(bytes);
+            interceptor.writeWith(Mono.just(body)).subscribe();
+            assertThat(interceptor.getRewritedBody()).isEmpty();
+        }
+
+        private byte[] zipContent() {
+            try {
+                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream("{}".length());
+                GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
+                gzipOutputStream.write("{}".getBytes(StandardCharsets.UTF_8));
+                gzipOutputStream.flush();
+                gzipOutputStream.close();
+                return byteArrayOutputStream.toByteArray();
+            } catch (IOException e) {
+                log.error("Error in test when zip content during modify servers from api-doc of {}: {}", path, e.getMessage());
+            }
+            return "{}".getBytes();
+        }
+    }
+}

package/dist/generators/server/templates/src/test/java/_package_/web/filter/SpaWebFilterIT_imperative.java.ejs

@@ -0,0 +1,107 @@
+package <%= packageName %>.web.filter;
+
+import <%= packageName %>.IntegrationTest;
+import <%= packageName %>.security.AuthoritiesConstants;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.forwardedUrl;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@AutoConfigureMockMvc
+@WithMockUser
+@IntegrationTest
+class SpaWebFilterIT {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Test
+    void testFilterForwardsToIndex() throws Exception {
+        mockMvc.perform(get("/"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl("/index.html"));
+    }
+<%_ if (!skipUserManagement) { _%>
+
+    @Test
+    void testFilterDoesNotForwardToIndexForApi() throws Exception {
+        mockMvc.perform(get("/api/<% if (!applicationTypeMicroservice) { %>authenticate<% } else { %>users<% } %>"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl(null));
+    }
+<%_ } _%>
+
+    @Test
+    @WithMockUser(authorities = AuthoritiesConstants.ADMIN)
+    void testFilterDoesNotForwardToIndexForV3ApiDocs() throws Exception {
+        mockMvc.perform(get("/v3/api-docs"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl(null));
+    }
+
+    @Test
+    void testFilterDoesNotForwardToIndexForDotFile() throws Exception {
+        mockMvc.perform(get("/file.js"))
+            .andExpect(status().isNotFound());
+    }
+
+    @Test
+    void getBackendEndpoint() throws Exception {
+        mockMvc.perform(get("/test"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl("/index.html"));
+    }
+
+    @Test
+    void forwardUnmappedFirstLevelMapping() throws Exception {
+        mockMvc.perform(get("/first-level"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl("/index.html"));
+    }
+
+    @Test
+    void forwardUnmappedSecondLevelMapping() throws Exception {
+        mockMvc.perform(get("/first-level/second-level"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl("/index.html"));
+    }
+
+    @Test
+    void forwardUnmappedThirdLevelMapping() throws Exception {
+        mockMvc.perform(get("/first-level/second-level/third-level"))
+            .andExpect(status().isOk())
+            .andExpect(forwardedUrl("/index.html"));
+    }
+
+    @Test
+    void forwardUnmappedDeepMapping() throws Exception {
+        mockMvc.perform(get("/1/2/3/4/5/6/7/8/9/10"))
+            .andExpect(forwardedUrl("/index.html"));
+    }
+
+    @Test
+    void getUnmappedFirstLevelFile() throws Exception {
+        mockMvc.perform(get("/foo.js"))
+            .andExpect(status().isNotFound());
+    }
+
+    /**
+     * This test verifies that any files that aren't permitted by Spring Security will be forbidden.
+     * If you want to change this to return isNotFound(), you need to add a request mapping that
+     * allows this file in SecurityConfiguration.
+     */
+    @Test
+    void getUnmappedSecondLevelFile() throws Exception {
+        mockMvc.perform(get("/foo/bar.js")).andExpect(status().isForbidden());
+    }
+
+    @Test
+    void getUnmappedThirdLevelFile() throws Exception {
+        mockMvc.perform(get("/foo/another/bar.js")).andExpect(status().isForbidden());
+    }
+}