generator-jhipster 8.0.0-rc.1 → 8.1.0

package/dist/generators/feign-client/templates/src/test/java/_package_/client/AuthorizationHeaderUtilTest.java.ejs

@@ -0,0 +1,263 @@
+<%#
+ 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 %>.client;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.http.RequestEntity;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClient;
+import org.springframework.security.oauth2.client.OAuth2AuthorizedClientService;
+import org.springframework.security.oauth2.client.authentication.OAuth2AuthenticationToken;
+import org.springframework.security.oauth2.client.registration.ClientRegistration;
+import org.springframework.security.oauth2.core.*;
+import org.springframework.security.oauth2.core.oidc.OidcIdToken;
+import org.springframework.security.oauth2.core.oidc.user.DefaultOidcUser;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
+import org.springframework.web.client.ResponseErrorHandler;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * Test class for the {@link AuthorizationHeaderUtil} utility class.
+ */
+@ExtendWith(MockitoExtension.class)
+class AuthorizationHeaderUtilTest {
+
+    public static final String VALID_REGISTRATION_ID = "OIDC";
+    public static final String SUB_VALUE = "123456";
+
+    @Mock
+    private OAuth2AuthorizedClientService clientService;
+
+    @Mock
+    private RestTemplateBuilder restTemplateBuilder;
+
+    @Mock
+    private SecurityContext securityContext;
+
+    @InjectMocks
+    private AuthorizationHeaderUtil authorizationHeaderUtil;
+
+    @BeforeEach
+    public void setup() {
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    @Test
+    void getAuthorizationHeader_Authentication() {
+        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken("principal", "credentials");
+        doReturn(authenticationToken).when(securityContext).getAuthentication();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+
+        Assertions.assertThat(header).isNotNull().isEmpty();
+    }
+
+    @Test
+    void getAuthorizationHeader_JwtAuthentication() {
+        JwtAuthenticationToken jwtToken = new JwtAuthenticationToken(
+            new Jwt("tokenVal", Instant.now(), Instant.now().plus(Duration.ofMinutes(3)), Map.of("alg", "HS256"), Map.of("sub", SUB_VALUE))
+        );
+        doReturn(jwtToken).when(securityContext).getAuthentication();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_InvalidClient() {
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken("INVALID");
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+
+        Assertions
+            .assertThatThrownBy(() -> {
+                authorizationHeaderUtil.getAuthorizationHeader();
+            })
+            .isInstanceOf(OAuth2AuthorizationException.class)
+            .hasMessageContaining("[access_denied] The token is expired");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication() {
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient();
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_RefreshToken() {
+        doReturn(restTemplateBuilder)
+            .when(restTemplateBuilder)
+            .additionalMessageConverters(any(HttpMessageConverter.class), any(HttpMessageConverter.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).errorHandler(any(ResponseErrorHandler.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).basicAuthentication(anyString(), anyString());
+
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient(true);
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        RestTemplate restTemplate = mock(RestTemplate.class);
+        ResponseEntity<OAuthIdpTokenResponseDTO> refreshResponse = ResponseEntity.of(getTestOAuthIdpTokenResponseDTO(true));
+        doReturn(refreshResponse).when(restTemplate).exchange(any(RequestEntity.class), eq(OAuthIdpTokenResponseDTO.class));
+        doReturn(restTemplate).when(restTemplateBuilder).build();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_RefreshToken_NoRefreshToken() {
+        doReturn(restTemplateBuilder)
+            .when(restTemplateBuilder)
+            .additionalMessageConverters(any(HttpMessageConverter.class), any(HttpMessageConverter.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).errorHandler(any(ResponseErrorHandler.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).basicAuthentication(anyString(), anyString());
+
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient(true);
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        RestTemplate restTemplate = mock(RestTemplate.class);
+        ResponseEntity<OAuthIdpTokenResponseDTO> refreshResponse = ResponseEntity.of(getTestOAuthIdpTokenResponseDTO(false));
+        doReturn(refreshResponse).when(restTemplate).exchange(any(RequestEntity.class), eq(OAuthIdpTokenResponseDTO.class));
+        doReturn(restTemplate).when(restTemplateBuilder).build();
+
+        Optional<String> header = authorizationHeaderUtil.getAuthorizationHeader();
+        Assertions.assertThat(header).isNotNull().isNotEmpty().get().isEqualTo("Bearer tokenVal");
+    }
+
+    @Test
+    void getAuthorizationHeader_OAuth2Authentication_RefreshTokenFails() {
+        doReturn(restTemplateBuilder)
+            .when(restTemplateBuilder)
+            .additionalMessageConverters(any(HttpMessageConverter.class), any(HttpMessageConverter.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).errorHandler(any(ResponseErrorHandler.class));
+        doReturn(restTemplateBuilder).when(restTemplateBuilder).basicAuthentication(anyString(), anyString());
+
+        OAuth2AuthenticationToken oauth2Token = getTestOAuth2AuthenticationToken(VALID_REGISTRATION_ID);
+        OAuth2AuthorizedClient authorizedClient = getTestOAuth2AuthorizedClient(true);
+
+        doReturn(oauth2Token).when(securityContext).getAuthentication();
+        doReturn(authorizedClient).when(clientService).loadAuthorizedClient(eq(VALID_REGISTRATION_ID), eq(SUB_VALUE));
+
+        RestTemplate restTemplate = mock(RestTemplate.class);
+        doThrow(new OAuth2AuthorizationException(new OAuth2Error("E"), "error"))
+            .when(restTemplate)
+            .exchange(any(RequestEntity.class), eq(OAuthIdpTokenResponseDTO.class));
+        doReturn(restTemplate).when(restTemplateBuilder).build();
+
+        Assertions
+            .assertThatThrownBy(() -> {
+                authorizationHeaderUtil.getAuthorizationHeader();
+            })
+            .isInstanceOf(OAuth2AuthenticationException.class)
+            .hasMessageContaining("error");
+    }
+
+    private OAuth2AuthorizedClient getTestOAuth2AuthorizedClient() {
+        return getTestOAuth2AuthorizedClient(false);
+    }
+
+    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)
+                .clientId("web-app")
+                .clientSecret("secret")
+                .redirectUri("/login/oauth2/code/oidc")
+                .authorizationUri("http://localhost:8080/auth/realms/master/protocol/openid-connect/auth")
+                .tokenUri("https://localhost:8080/auth/realms/master/protocol/openid-connect/token")
+                .build(),
+            "sub",
+            token,
+            new OAuth2RefreshToken("refreshVal", Instant.now())
+        );
+    }
+
+    private OAuth2AuthenticationToken getTestOAuth2AuthenticationToken(String registrationId) {
+        return new OAuth2AuthenticationToken(
+            new DefaultOidcUser(
+                List.of(new SimpleGrantedAuthority("USER")),
+                OidcIdToken.withTokenValue("tokenVal").claim("sub", SUB_VALUE).build()
+            ),
+            List.of(new SimpleGrantedAuthority("USER")),
+            registrationId
+        );
+    }
+
+    private Optional<OAuthIdpTokenResponseDTO> getTestOAuthIdpTokenResponseDTO(boolean hasRefreshToken) {
+        OAuthIdpTokenResponseDTO dto = new OAuthIdpTokenResponseDTO();
+        dto.setAccessToken("tokenVal");
+        dto.setIdToken("tokenVal");
+        dto.setNotBefore(0l);
+        dto.setRefreshExpiresIn("1800");
+        dto.setSessionState("ccea4a55");
+        dto.setExpiresIn(300l);
+        dto.setRefreshToken(hasRefreshToken ? "tokenVal" : null);
+        dto.setScope("openid email profile offline_access");
+        return Optional.of(dto);
+    }
+}

package/dist/generators/generate-blueprint/command.mjs

@@ -22,7 +22,7 @@ const command = {
             scope: 'storage',
         },
         [DYNAMIC]: {
-            description: 'Genate dynamic generators (advanced)',
+            description: 'Generate dynamic generators (advanced)',
             type: Boolean,
             scope: 'storage',
         },

package/dist/generators/generate-blueprint/resources/package.json

@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "vitest": "0.34.6"
+    "vitest": "1.0.2"
   }
 }

package/dist/generators/generate-blueprint/templates/vitest.config.ts.ejs

@@ -2,7 +2,7 @@ import { defineConfig, defaultExclude } from 'vitest/config';
 
 export default defineConfig({
   test: {
-    threads: false,
+    pool: 'forks',
     hookTimeout: 20000,
     exclude: [...defaultExclude.filter(val => val !== '**/cypress/**'), '**/templates/**', '**/resources/**'],
   },

package/dist/generators/generator-constants.mjs

@@ -18,36 +18,40 @@
  */
 export const BLUEPRINT_API_VERSION = 'jhipster-8';
 // jhipster-bom version
-export const JHIPSTER_DEPENDENCIES_VERSION = '8.0.0-rc.1';
+export const JHIPSTER_DEPENDENCIES_VERSION = '8.1.0';
 // Version of Java
 export const JAVA_VERSION = '17';
 export const JAVA_COMPATIBLE_VERSIONS = ['17', '18', '19', '20', '21'];
 // Force spring milestone repository. Spring Boot milestones are detected.
 export const ADD_SPRING_MILESTONE_REPOSITORY = false;
 // Version of Node, NPM
-export const NODE_VERSION = '18.18.1';
+export const NODE_VERSION = '18.18.2';
 export const OPENAPI_GENERATOR_CLI_VERSION = '2.7.0';
+/**
+ * @type {Record<string, string>}
+ */
 export const javaDependencies = {
     /**
      * spring-boot version should match the one managed by https://mvnrepository.com/artifact/tech.jhipster/jhipster-dependencies/JHIPSTER_DEPENDENCIES_VERSION
      */
-    'spring-boot': '3.1.4',
+    'spring-boot': '3.2.0',
     /*
      * hibernate version should match the one managed by https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies/SPRING_BOOT_VERSION
      * Required due to hibernate-jpamodelgen annotation processor.
      */
-    hibernate: '6.2.9.Final',
+    hibernate: '6.3.1.Final',
     /*
      * cassandra driver version should match the one managed by https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies/SPRING_BOOT_VERSION
      * Required due to java-driver-mapper-processor annotation processor.
      */
-    cassandra: '4.15.0',
+    cassandra: '4.17.0',
 };
 Object.freeze(javaDependencies);
 // The version should be coherent with the one from spring-data-elasticsearch project
-export const ELASTICSEARCH_TAG = '8.7.1';
+export const ELASTICSEARCH_TAG = '8.10.4';
 export const ELASTICSEARCH_IMAGE = 'docker.elastic.co/elasticsearch/elasticsearch';
 /**
+ * @type {Record<string, string>}
  * Manually updated docker containers
  */
 export const dockerContainers = {
@@ -98,4 +102,4 @@ export const SERVER_MAIN_SRC_DIR = `${MAIN_DIR}java/`;
 export const SERVER_MAIN_RES_DIR = `${MAIN_DIR}resources/`;
 export const SERVER_TEST_SRC_DIR = `${TEST_DIR}java/`;
 export const SERVER_TEST_RES_DIR = `${TEST_DIR}resources/`;
-export const PRETTIER_EXTENSIONS = 'md,json,yml,html,cjs,mjs,js,ts,tsx,css,scss,vue,svelte,java';
+export const PRETTIER_EXTENSIONS = 'md,json,yml,html,cjs,mjs,js,ts,tsx,css,scss,vue,java';

package/dist/generators/generator-list.mjs

@@ -39,6 +39,7 @@ export const GENERATOR_DOCKER_COMPOSE = 'docker-compose';
 export const GENERATOR_ENTITIES = 'entities';
 export const GENERATOR_ENTITY = 'entity';
 export const GENERATOR_EXPORT_JDL = 'export-jdl';
+export const GENERATOR_FEIGN_CLIENT = 'feign-client';
 export const GENERATOR_GATLING = 'gatling';
 export const GENERATOR_GENERATE_BLUEPRINT = 'generate-blueprint';
 export const GENERATOR_GIT = 'git';

package/dist/generators/git/generator.mjs

@@ -19,7 +19,7 @@
 /* eslint-disable consistent-return */
 import chalk from 'chalk';
 import BaseGenerator from '../base/index.mjs';
-import { GENERATOR_GIT, GENERATOR_PROJECT_NAME } from '../generator-list.mjs';
+import { GENERATOR_GIT } from '../generator-list.mjs';
 import { files } from './files.mjs';
 import command from './command.mjs';
 /**
@@ -34,9 +34,6 @@ export default class InitGenerator extends BaseGenerator {
         if (!this.fromBlueprint) {
             await this.composeWithBlueprints(GENERATOR_GIT);
         }
-        if (!this.delegateToBlueprint) {
-            await this.dependsOnJHipster(GENERATOR_PROJECT_NAME);
-        }
     }
     get initializing() {
         return this.asInitializingTaskGroup({
@@ -74,7 +71,7 @@ export default class InitGenerator extends BaseGenerator {
     }
     get postWriting() {
         return this.asPostWritingTaskGroup({
-            /** Husky commit hook install at install priority requires git to be initilized */
+            /** Husky commit hook install at install priority requires git to be initialized */
             async initGitRepo() {
                 if (!this.skipGit && !this.jhipsterConfig.monorepository) {
                     await this.initializeGitRepository();
@@ -122,6 +119,7 @@ export default class InitGenerator extends BaseGenerator {
                         this.log.warn(chalk.red.bold(`Application commit to Git failed from ${repositoryRoot}. Try to commit manually. (${e.message})`));
                     }
                 };
+                // @ts-expect-error keep compatibility with other adapters
                 if (this.env.adapter.queue) {
                     await this.env.adapter.queue(commitFiles);
                 }

package/dist/generators/gradle/constants.mjs

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export const GRADLE_VERSION = '8.4';
+export const GRADLE_VERSION = '8.5';
 export const GRADLE = 'gradle';
 export const GRADLE_DESCRIPTION = 'Gradle';
 export const BUILD_DESTINATION_VALUE = 'build';