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

package/dist/generators/server/templates/src/test/java/_package_/web/rest/WithUnauthenticatedMockUser.java.ejs

@@ -0,0 +1,42 @@
+<%#
+ 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 %>.web.rest;
+
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.test.context.support.WithSecurityContext;
+import org.springframework.security.test.context.support.WithSecurityContextFactory;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@WithSecurityContext(factory = WithUnauthenticatedMockUser.Factory.class)
+public @interface WithUnauthenticatedMockUser {
+
+    class Factory implements WithSecurityContextFactory<WithUnauthenticatedMockUser> {
+        @Override
+        public SecurityContext createSecurityContext(WithUnauthenticatedMockUser annotation) {
+            return SecurityContextHolder.createEmptyContext();
+        }
+    }
+}

package/dist/generators/server/templates/src/test/java/_package_/web/rest/errors/ExceptionTranslatorIT_imperative.java.ejs

@@ -0,0 +1,134 @@
+<%#
+ 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 %>.web.rest.errors;
+
+import <%= packageName %>.IntegrationTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.test.context.support.WithMockUser;
+
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+  <%_ if (authenticationUsesCsrf) { _%>
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+  <%_ } _%>
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+/**
+ * Integration tests {@link ExceptionTranslator} controller advice.
+ */
+@WithMockUser
+@AutoConfigureMockMvc
+@IntegrationTest
+class ExceptionTranslatorIT {
+
+    @Autowired
+    private MockMvc mockMvc;
+<%_ if (!databaseTypeNo && !databaseTypeCassandra) { _%>
+
+    @Test
+    void testConcurrencyFailure() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/concurrency-failure")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isConflict())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value(ErrorConstants.ERR_CONCURRENCY_FAILURE));
+    }
+<%_ } _%>
+
+    @Test
+    void testMethodArgumentNotValid() throws Exception {
+         mockMvc.perform(post("/api/exception-translator-test/method-argument").content("{}").contentType(MediaType.APPLICATION_JSON)<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+             .andExpect(status().isBadRequest())
+             .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+             .andExpect(jsonPath("$.message").value(ErrorConstants.ERR_VALIDATION))
+             .andExpect(jsonPath("$.fieldErrors.[0].objectName").value("test"))
+             .andExpect(jsonPath("$.fieldErrors.[0].field").value("test"))
+             .andExpect(jsonPath("$.fieldErrors.[0].message").value("must not be null"));
+    }
+
+    @Test
+    void testMissingServletRequestPartException() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/missing-servlet-request-part")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isBadRequest())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.400"));
+    }
+
+    @Test
+    void testMissingServletRequestParameterException() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/missing-servlet-request-parameter")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isBadRequest())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.400"));
+    }
+
+    @Test
+    void testAccessDenied() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/access-denied")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isForbidden())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.403"))
+            .andExpect(jsonPath("$.detail").value("test access denied!"));
+    }
+
+    @Test
+    void testUnauthorized() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/unauthorized")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isUnauthorized())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.401"))
+            .andExpect(jsonPath("$.path").value("/api/exception-translator-test/unauthorized"))
+            .andExpect(jsonPath("$.detail").value("test authentication failed!"));
+    }
+
+    @Test
+    void testMethodNotSupported() throws Exception {
+        mockMvc.perform(post("/api/exception-translator-test/access-denied")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isMethodNotAllowed())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.405"))
+            .andExpect(jsonPath("$.detail").value("Request method 'POST' is not supported"));
+    }
+
+    @Test
+    void testExceptionWithResponseStatus() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/response-status")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isBadRequest())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.400"))
+            .andExpect(jsonPath("$.title").value("test response status"));
+    }
+
+    @Test
+    void testInternalServerError() throws Exception {
+        mockMvc.perform(get("/api/exception-translator-test/internal-server-error")<% if (authenticationUsesCsrf) { %>.with(csrf())<% } %>)
+            .andExpect(status().isInternalServerError())
+            .andExpect(content().contentType(MediaType.APPLICATION_PROBLEM_JSON))
+            .andExpect(jsonPath("$.message").value("error.http.500"))
+            .andExpect(jsonPath("$.title").value("Internal Server Error"));
+    }
+
+}

package/dist/generators/server/templates/src/test/java/_package_/web/rest/errors/ExceptionTranslatorIT_reactive.java.ejs

@@ -0,0 +1,161 @@
+<%#
+ 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 %>.web.rest.errors;
+
+import <%= packageName %>.IntegrationTest;
+import org.hamcrest.core.AnyOf;
+import org.hamcrest.core.IsEqual;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.security.test.context.support.WithMockUser;
+<%_ if (authenticationUsesCsrf) { _%>
+import org.junit.jupiter.api.BeforeEach;
+
+<%_ } _%>
+import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.reactive.server.WebTestClient;
+<%_ if (authenticationUsesCsrf) { _%>
+
+import static org.springframework.security.test.web.reactive.server.SecurityMockServerConfigurers.csrf;
+<%_ } _%>
+
+/**
+ * Integration tests {@link ExceptionTranslator} controller advice.
+ */
+@WithMockUser
+@AutoConfigureWebTestClient(timeout = IntegrationTest.DEFAULT_TIMEOUT)
+@IntegrationTest
+class ExceptionTranslatorIT {
+
+    @Autowired
+    private WebTestClient webTestClient;
+<%_ if (authenticationUsesCsrf) { _%>
+
+    @BeforeEach
+    public void setupCsrf() {
+        webTestClient = webTestClient.mutateWith(csrf());
+    }
+<%_ } _%>
+<%_ if (!databaseTypeNo && !databaseTypeCassandra) { _%>
+
+    @Test
+    void testConcurrencyFailure() {
+        webTestClient.get().uri("/api/exception-translator-test/concurrency-failure")
+            .exchange()
+            .expectStatus().isEqualTo(HttpStatus.CONFLICT)
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo(ErrorConstants.ERR_CONCURRENCY_FAILURE);
+    }
+<%_ } _%>
+
+    @Test
+    void testMethodArgumentNotValid() {
+         webTestClient.post().uri("/api/exception-translator-test/method-argument")
+             .contentType(MediaType.APPLICATION_JSON)
+             .bodyValue("{}")
+             .exchange()
+             .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+             .expectBody()
+             .jsonPath("$.message").isEqualTo(ErrorConstants.ERR_VALIDATION)
+             .jsonPath("$.fieldErrors.[0].objectName").isEqualTo("test")
+             .jsonPath("$.fieldErrors.[0].field").isEqualTo("test")
+             .jsonPath("$.fieldErrors.[0].message").isEqualTo("must not be null");
+    }
+
+    @Test
+    void testMissingRequestPart() {
+        webTestClient.get().uri("/api/exception-translator-test/missing-servlet-request-part")
+            .exchange()
+            .expectStatus().isBadRequest()
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.400");
+    }
+
+    @Test
+    void testMissingRequestParameter() {
+        webTestClient.get().uri("/api/exception-translator-test/missing-servlet-request-parameter")
+            .exchange()
+            .expectStatus().isBadRequest()
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.400");
+    }
+
+    @Test
+    void testAccessDenied() {
+        webTestClient.get().uri("/api/exception-translator-test/access-denied")
+            .exchange()
+            .expectStatus().isForbidden()
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.403")
+            .jsonPath("$.detail").isEqualTo("test access denied!");
+    }
+
+    @Test
+    void testUnauthorized() {
+        webTestClient.get().uri("/api/exception-translator-test/unauthorized")
+            .exchange()
+            .expectStatus().isUnauthorized()
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.401")
+            .jsonPath("$.path").isEqualTo("/api/exception-translator-test/unauthorized")
+            .jsonPath("$.detail")
+            .value(AnyOf.anyOf(IsEqual.equalTo("test authentication failed!"), IsEqual.equalTo("Invalid credentials")));
+    }
+
+    @Test
+    void testMethodNotSupported() {
+        webTestClient.post().uri("/api/exception-translator-test/access-denied")
+            .exchange()
+            .expectStatus().isEqualTo(HttpStatus.METHOD_NOT_ALLOWED)
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.405")
+            .jsonPath("$.detail").isEqualTo("405 METHOD_NOT_ALLOWED \"Request method 'POST' is not supported.\"");
+    }
+
+    @Test
+    void testExceptionWithResponseStatus() {
+        webTestClient.get().uri("/api/exception-translator-test/response-status")
+            .exchange()
+            .expectStatus().isBadRequest()
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.400")
+            .jsonPath("$.title").isEqualTo("test response status");
+    }
+
+    @Test
+    void testInternalServerError() {
+        webTestClient.get().uri("/api/exception-translator-test/internal-server-error")
+            .exchange()
+            .expectHeader().contentType(MediaType.APPLICATION_PROBLEM_JSON)
+            .expectBody()
+            .jsonPath("$.message").isEqualTo("error.http.500")
+            .jsonPath("$.title").isEqualTo("Internal Server Error");
+    }
+
+}

package/dist/generators/server/templates/src/test/java/_package_/web/rest/errors/ExceptionTranslatorTestController.java.ejs

@@ -0,0 +1,94 @@
+<%#
+ 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 %>.web.rest.errors;
+
+<%_ if (!databaseTypeNo && !databaseTypeCassandra) { _%>
+import org.springframework.dao.ConcurrencyFailureException;
+<%_ } _%>
+import org.springframework.http.HttpStatus;
+import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.authentication.BadCredentialsException;
+import org.springframework.web.bind.annotation.*;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotNull;
+
+@RestController
+@RequestMapping("/api/exception-translator-test")
+public class ExceptionTranslatorTestController {
+<%_ if (!databaseTypeNo && !databaseTypeCassandra) { _%>
+
+    @GetMapping("/concurrency-failure")
+    public void concurrencyFailure() {
+        throw new ConcurrencyFailureException("test concurrency failure");
+    }
+<%_ } _%>
+
+    @PostMapping("/method-argument")
+    public void methodArgument(@Valid @RequestBody Test<%= dtoSuffix %> test<%= dtoSuffix %>) {
+    }
+
+    @GetMapping("/missing-servlet-request-part")
+    public void missingServletRequestPartException(@RequestPart String part) {
+    }
+
+    @GetMapping("/missing-servlet-request-parameter")
+    public void missingServletRequestParameterException(@RequestParam String param) {
+    }
+
+    @GetMapping("/access-denied")
+    public void accessdenied() {
+        throw new AccessDeniedException("test access denied!");
+    }
+
+    @GetMapping("/unauthorized")
+    public void unauthorized() {
+        throw new BadCredentialsException("test authentication failed!");
+    }
+
+    @GetMapping("/response-status")
+    public void exceptionWithResponseStatus() {
+        throw new TestResponseStatusException();
+    }
+
+    @GetMapping("/internal-server-error")
+    public void internalServerError() {
+        throw new RuntimeException();
+    }
+
+    public static class Test<%= dtoSuffix %> {
+
+        @NotNull<% if (reactive) { %>(message = "must not be null")<% } %>
+        private String test;
+
+        public String getTest() {
+            return test;
+        }
+
+        public void setTest(String test) {
+            this.test = test;
+        }
+    }
+
+    @ResponseStatus(value = HttpStatus.BAD_REQUEST, reason = "test response status")
+    @SuppressWarnings("serial")
+    public static class TestResponseStatusException extends RuntimeException {
+    }
+
+}

package/dist/generators/server/templates/src/test/resources/logback.xml.ejs

@@ -100,7 +100,7 @@
 <%_ if (cacheProviderMemcached) { _%>
     <logger name="net.rubyeye.xmemcached" level="INFO"/>
 <%_ } _%>
-<%_ if (prodDatabaseTypePostgres) { _%>
+<%_ if (prodDatabaseTypePostgresql) { _%>
     <logger name="org.postgresql.jdbc" level="WARN"/>
 <%_ } _%>
     <logger name="org.springframework" level="WARN"/>

package/dist/generators/spring-cache/files.mjs

@@ -7,19 +7,19 @@ const files = {
             templates: ['gradle/cache.gradle'],
         },
         {
-            path: `${SERVER_MAIN_SRC_DIR}package/`,
+            path: `${SERVER_MAIN_SRC_DIR}_package_/`,
             renameTo: moveToJavaPackageSrcDir,
             templates: ['config/CacheConfiguration.java'],
         },
         {
             condition: data => data.cacheProviderInfinispan,
-            path: `${SERVER_MAIN_SRC_DIR}package/`,
+            path: `${SERVER_MAIN_SRC_DIR}_package_/`,
             renameTo: moveToJavaPackageSrcDir,
             templates: ['config/CacheFactoryConfiguration.java'],
         },
         {
             condition: data => data.cacheProviderRedis,
-            path: `${SERVER_TEST_SRC_DIR}package/`,
+            path: `${SERVER_TEST_SRC_DIR}_package_/`,
             renameTo: moveToJavaPackageTestDir,
             templates: [
                 'config/EmbeddedRedis.java',

package/dist/generators/spring-cache/generator.mjs

@@ -24,10 +24,12 @@ import { createNeedleCallback } from '../base/support/needles.mjs';
 import { getCacheProviderMavenDefinition } from './internal/dependencies.mjs';
 export default class SpringCacheGenerator extends BaseApplicationGenerator {
     async beforeQueue() {
-        await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION);
         if (!this.fromBlueprint) {
             await this.composeWithBlueprints(GENERATOR_SPRING_CACHE);
         }
+        if (!this.delegateToBlueprint) {
+            await this.dependsOnJHipster(GENERATOR_BOOTSTRAP_APPLICATION);
+        }
     }
     get preparing() {
         return this.asPreparingTaskGroup({