Skip to content

Commit

Permalink
Merge pull request #3288 from DamnClin/remove-mockito-inline
Browse files Browse the repository at this point in the history
Remove mockito inline
  • Loading branch information
pascalgrimaud authored Aug 30, 2022
2 parents 8146e2f + 549a113 commit 306f17f
Show file tree
Hide file tree
Showing 29 changed files with 755 additions and 997 deletions.
161 changes: 161 additions & 0 deletions src/main/java/tech/jhipster/lite/ApplicationStartupTraces.java
Original file line number Diff line number Diff line change
@@ -0,0 +1,161 @@
package tech.jhipster.lite;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.env.Environment;
import tech.jhipster.lite.common.domain.Generated;
import tech.jhipster.lite.error.domain.Assert;

final class ApplicationStartupTraces {

private static final String SEPARATOR = "-".repeat(58);
private static final String BREAK = "\n";

private static final Logger log = LoggerFactory.getLogger(ApplicationStartupTraces.class);

private ApplicationStartupTraces() {}

static String of(Environment environment) {
Assert.notNull("environment", environment);

return new ApplicationStartupTracesBuilder()
.append(BREAK)
.appendSeparator()
.append(applicationRunningTrace(environment))
.append(localUrl(environment))
.append(externalUrl(environment))
.append(profilesTrace(environment))
.appendSeparator()
.append(configServer(environment))
.build();
}

private static String applicationRunningTrace(Environment environment) {
String applicationName = environment.getProperty("spring.application.name");

if (StringUtils.isBlank(applicationName)) {
return "Application is running!";
}

return new StringBuilder().append("Application '").append(applicationName).append("' is running!").toString();
}

private static String localUrl(Environment environment) {
return url("Local", "localhost", environment);
}

private static String externalUrl(Environment environment) {
return url("External", hostAddress(), environment);
}

private static String url(String type, String host, Environment environment) {
if (notWebEnvironment(environment)) {
return null;
}

return new StringBuilder()
.append(type)
.append(": \t")
.append(protocol(environment))
.append("://")
.append(host)
.append(":")
.append(port(environment))
.append(contextPath(environment))
.toString();
}

private static boolean notWebEnvironment(Environment environment) {
return StringUtils.isBlank(environment.getProperty("server.port"));
}

private static String protocol(Environment environment) {
if (noKeyStore(environment)) {
return "http";
}

return "https";
}

private static boolean noKeyStore(Environment environment) {
return StringUtils.isBlank(environment.getProperty("server.ssl.key-store"));
}

private static String port(Environment environment) {
return environment.getProperty("server.port");
}

private static String profilesTrace(Environment environment) {
String[] profiles = environment.getActiveProfiles();

if (ArrayUtils.isEmpty(profiles)) {
return null;
}

return new StringBuilder().append("Profile(s): \t").append(Stream.of(profiles).collect(Collectors.joining(", "))).toString();
}

@Generated(reason = "Hard to test implement detail error management")
private static String hostAddress() {
try {
return InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
log.warn("The host name could not be determined, using `localhost` as fallback");
}

return "localhost";
}

private static String contextPath(Environment environment) {
String contextPath = environment.getProperty("server.servlet.context-path");

if (StringUtils.isBlank(contextPath)) {
return "/";
}

return contextPath;
}

private static String configServer(Environment environment) {
String configServer = environment.getProperty("configserver.status");

if (StringUtils.isBlank(configServer)) {
return null;
}

return new StringBuilder().append("Config Server: ").append(configServer).append(BREAK).append(SEPARATOR).append(BREAK).toString();
}

private static class ApplicationStartupTracesBuilder {

private static final String SPACER = " ";

private final StringBuilder trace = new StringBuilder();

public ApplicationStartupTracesBuilder appendSeparator() {
trace.append(SEPARATOR).append(BREAK);

return this;
}

public ApplicationStartupTracesBuilder append(String line) {
if (line == null) {
return this;
}

trace.append(SPACER).append(line).append(BREAK);

return this;
}

public String build() {
return trace.toString();
}
}
}
79 changes: 3 additions & 76 deletions src/main/java/tech/jhipster/lite/JHLiteApp.java
Original file line number Diff line number Diff line change
@@ -1,10 +1,5 @@
package tech.jhipster.lite;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Optional;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
Expand All @@ -14,85 +9,17 @@
import org.springframework.core.env.Environment;
import tech.jhipster.lite.common.domain.Generated;

@Generated(reason = "Not interesting and hard to test")
@Generated(reason = "Not testing logs")
@SpringBootApplication(exclude = { MongoAutoConfiguration.class, MongoDataAutoConfiguration.class })
public class JHLiteApp {

private static final Logger log = LoggerFactory.getLogger(JHLiteApp.class);

private static final String SEPARATOR = "----------------------------------------------------------";
protected static final String LF = "\n";

public static void main(String[] args) {
Environment env = SpringApplication.run(JHLiteApp.class, args).getEnvironment();
logApplicationStartup(env);
}

private static void logApplicationStartup(Environment env) {
String protocol = getProtocol(env.getProperty("server.ssl.key-store"));
String serverPort = env.getProperty("server.port");
String contextPath = getContextPath(env.getProperty("server.servlet.context-path"));
String hostAddress = getHostAddress();

String welcomeMessage = new StringBuilder()
.append(LF)
.append(SEPARATOR)
.append(LF)
.append(applicationRunning(env.getProperty("spring.application.name")))
.append(accessUrlLocal(protocol, serverPort, contextPath))
.append(accessUrlExternal(protocol, hostAddress, serverPort, contextPath))
.append(profile(Arrays.toString(env.getActiveProfiles())))
.append(SEPARATOR)
.append(configServer(env.getProperty("configserver.status")))
.toString();

log.info(welcomeMessage);
}

private static String applicationRunning(String value) {
return String.format(" Application '%s' is running!", value) + LF;
}

private static String accessUrlLocal(String protocol, String serverPort, String contextPath) {
if (StringUtils.isBlank(serverPort)) {
return "";
}
return String.format(" Local: \t%s://localhost:%s%s", protocol, serverPort, contextPath) + LF;
}

private static String accessUrlExternal(String protocol, String hostAddress, String serverPort, String contextPath) {
if (StringUtils.isBlank(serverPort)) {
return "";
}
return String.format(" External: \t%s://%s:%s%s", protocol, hostAddress, serverPort, contextPath) + LF;
}

private static String profile(String profiles) {
return String.format(" Profile(s): \t%s", profiles) + LF;
}

private static String configServer(String configServerStatus) {
if (StringUtils.isBlank(configServerStatus)) {
return "";
}
return LF + String.format(" Config Server: %s", configServerStatus) + LF + SEPARATOR + LF;
}

private static String getProtocol(String value) {
return Optional.ofNullable(value).map(key -> "https").orElse("http");
}

private static String getContextPath(String value) {
return Optional.ofNullable(value).filter(StringUtils::isNotBlank).orElse("/");
}

private static String getHostAddress() {
String hostAddress = "localhost";
try {
hostAddress = InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
log.warn("The host name could not be determined, using `localhost` as fallback");
if (log.isInfoEnabled()) {
log.info(ApplicationStartupTraces.of(env));
}
return hostAddress;
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -64,14 +64,15 @@ public JHipsterModule buildModule(JHipsterModuleProperties properties) {
.and()
.files()
.add(SOURCE.template("MainApp.java"), toSrcMainJava().append(packagePath).append(mainClassName + "App.java"))
.add(SOURCE.template("MainAppTest.java"), testDestination.append(mainClassName + "AppTest.java"))
.add(SOURCE.template("ApplicationStartupTraces.java"), toSrcMainJava().append(packagePath).append("ApplicationStartupTraces.java"))
.add(SOURCE.template("IntegrationTest.java"), testDestination.append("IntegrationTest.java"))
.add(SOURCE.template(APPLICATION_PROPERTIES), MAIN_CONFIG_DESTINATION.append(APPLICATION_PROPERTIES))
.add(SOURCE.template("application-local.properties"), MAIN_CONFIG_DESTINATION.append("application-local.properties"))
.add(SOURCE.template("application-test.properties"), TEST_CONFIG_DESTINATION.append(APPLICATION_PROPERTIES))
.add(SOURCE.template("logback-spring.xml"), MAIN_RESOURCE_DESTINATION.append("logback-spring.xml"))
.add(SOURCE.template("logback.xml"), TEST_RESOURCES_DESTINATION.append("logback.xml"))
.add(SOURCE.template("LogsSpy.java"), toSrcTestJava().append(properties.packagePath()).append("LogsSpy.java"))
.add(SOURCE.template("ApplicationStartupTracesTest.java"), toSrcTestJava().append(packagePath).append("ApplicationStartupTracesTest.java"))
.and()
.optionalReplacements()
.in("pom.xml")
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -85,11 +85,10 @@ private void appendJavaFiles(JHipsterModuleBuilder builder, JHipsterModuleProper
.addTemplate("AuthenticatedUserTest.java")

.addTemplate("ClaimsTest.java")
.addTemplate("CustomClaimConverterIT.java")
.addTemplate("CustomClaimConverterTest.java")
.addTemplate("FakeRequestAttributes.java")
.addTemplate("JwtGrantedAuthorityConverterTest.java")
.addTemplate("SecurityConfigurationIT.java")
.addTemplate("SecurityConfigurationTest.java")
.addTemplate("TestSecurityConfiguration.java")
.addTemplate("WithUnauthenticatedMockUser.java");
//@formatter:on
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -112,7 +112,7 @@ private String getMessage(FieldError f) {

@ExceptionHandler
public ResponseEntity<Problem> handleBadRequestAlertException(BadRequestAlertException ex, NativeWebRequest request) {
return create(ex, request, HeaderUtil.createFailureAlert(applicationName, true, ex.getEntityName(), ex.getErrorKey(), ex.getMessage()));
return create(ex, request, HeaderUtil.createFailureAlert(applicationName, ex.getEntityName(), ex.getErrorKey()));
}

@ExceptionHandler
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -17,26 +17,18 @@ private HeaderUtil() {}
* <p>createFailureAlert.</p>
*
* @param applicationName a {@link String} object.
* @param enableTranslation a boolean.
* @param entityName a {@link String} object.
* @param errorKey a {@link String} object.
* @param defaultMessage a {@link String} object.
* @return a {@link HttpHeaders} object.
*/
public static HttpHeaders createFailureAlert(
String applicationName,
boolean enableTranslation,
String entityName,
String errorKey,
String defaultMessage
) {
log.error("Entity processing failed, {}", defaultMessage);

String message = enableTranslation ? "error." + errorKey : defaultMessage;
public static HttpHeaders createFailureAlert(String applicationName, String entityName, String errorKey) {
String message = "error." + errorKey;
log.error("Entity processing failed, {}", message);

HttpHeaders headers = new HttpHeaders();
headers.add("X-" + applicationName + "-error", message);
headers.add("X-" + applicationName + "-params", entityName);

return headers;
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,6 @@ dependencies {
testImplementation("org.junit.jupiter:junit-jupiter-params:${property("junit-jupiter.version")}")
testImplementation("org.assertj:assertj-core:${property("assertj.version")}")
testImplementation("org.mockito:mockito-junit-jupiter:${property("mockito.version")}")
testImplementation("org.mockito:mockito-inline:${property("mockito.version")}")
// jhipster-needle-gradle-add-dependency-test
}

Expand Down
6 changes: 0 additions & 6 deletions src/main/resources/generator/buildtool/maven/pom.xml.mustache
Original file line number Diff line number Diff line change
Expand Up @@ -50,12 +50,6 @@
<version>${mockito.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-inline</artifactId>
<version>${mockito.version}</version>
<scope>test</scope>
</dependency>
</dependencies>

<build>
Expand Down
Loading

0 comments on commit 306f17f

Please sign in to comment.