chore(citrus-base): review and code cleanup

pr: #1224 citrus-base` module.
citrusframework · Oct 24, 2024 · 800d702 · 800d702
1 parent 0f41890
commit 800d702
Show file tree

Hide file tree

Showing 114 changed files with 715 additions and 826 deletions.
diff --git a/core/citrus-base/src/main/java/org/citrusframework/AbstractTestContainerBuilder.java b/core/citrus-base/src/main/java/org/citrusframework/AbstractTestContainerBuilder.java
@@ -16,16 +16,16 @@
 
 package org.citrusframework;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
 import org.citrusframework.actions.NoopTestAction;
 import org.citrusframework.container.TestActionContainer;
 import org.citrusframework.spi.ReferenceResolver;
 import org.citrusframework.spi.ReferenceResolverAware;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 /**
  * Abstract container builder takes care on calling the container runner when actions are placed in the container.
  */
@@ -129,7 +129,7 @@ public T doBuild() {
 
             @Override
             public T build() {
-                if (container.getActions().size() > 0) {
+                if (!container.getActions().isEmpty()) {
                     return container;
                 }
 

diff --git a/core/citrus-base/src/main/java/org/citrusframework/CitrusContextProvider.java b/core/citrus-base/src/main/java/org/citrusframework/CitrusContextProvider.java
@@ -16,15 +16,15 @@
 
 package org.citrusframework;
 
-import java.util.Map;
-import java.util.Optional;
-
 import org.citrusframework.exceptions.CitrusRuntimeException;
 import org.citrusframework.spi.ResourcePathTypeResolver;
 import org.citrusframework.spi.TypeResolver;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Map;
+import java.util.Optional;
+
 @FunctionalInterface
 public interface CitrusContextProvider {
 
@@ -85,7 +85,7 @@ static Optional<CitrusContextProvider> lookup(String name) {
             CitrusContextProvider instance = TYPE_RESOLVER.resolve(name);
             return Optional.of(instance);
         } catch (CitrusRuntimeException e) {
-            logger.warn(String.format("Failed to resolve Citrus context provider from resource '%s/%s'", RESOURCE_PATH, name));
+            logger.warn("Failed to resolve Citrus context provider from resource '{}/{}'", RESOURCE_PATH, name);
         }
 
         return Optional.empty();

diff --git a/core/citrus-base/src/main/java/org/citrusframework/TestCaseRunnerFactory.java b/core/citrus-base/src/main/java/org/citrusframework/TestCaseRunnerFactory.java
@@ -25,7 +25,7 @@
  * Citrus' built-in runner, but it also offers the flexibility to replace the default runner with a
  * custom implementation. To do this, it leverages the Citrus {@link ResourcePathTypeResolver}
  * mechanism.
- *
+ * <p>
  * To provide a custom runner, the following file needs to be added to the classpath:
  * <p>
  * <code>

diff --git a/core/citrus-base/src/main/java/org/citrusframework/actions/AntRunAction.java b/core/citrus-base/src/main/java/org/citrusframework/actions/AntRunAction.java
@@ -16,12 +16,6 @@
 
 package org.citrusframework.actions;
 
-import java.io.IOException;
-import java.io.PrintStream;
-import java.util.Map.Entry;
-import java.util.Properties;
-import java.util.Stack;
-
 import org.apache.tools.ant.BuildException;
 import org.apache.tools.ant.BuildListener;
 import org.apache.tools.ant.DefaultLogger;
@@ -38,10 +32,16 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.Map.Entry;
+import java.util.Properties;
+import java.util.Stack;
+
 /**
  * Action calls Apache ANT with given build file and runs ANT targets
  * as separate build. User can set and overwrite properties for the build.
- *
+ * <p>
  * Build logging output is forwarded to test run logger.
  *
  * @since 1.3
@@ -95,7 +95,7 @@ public void doExecute(TestContext context) {
 
             for (Entry<Object, Object> entry : properties.entrySet()) {
                 String propertyValue = entry.getValue() != null ? context.replaceDynamicContentInString(entry.getValue().toString()) : "";
-                logger.debug("Set build property: " + entry.getKey() + "=" + propertyValue);
+                logger.debug("Set build property: {}={}", entry.getKey(), propertyValue);
                 project.setProperty(entry.getKey().toString(), propertyValue);
             }
 
@@ -109,20 +109,20 @@ public void doExecute(TestContext context) {
 
             project.addBuildListener(consoleLogger);
 
-            logger.info("Executing ANT build: " + buildFileResource);
+            logger.info("Executing ANT build: {}", buildFileResource);
 
             if (StringUtils.hasText(targets)) {
-                logger.info("Executing ANT targets: " + targets);
+                logger.info("Executing ANT targets: {}", targets);
                 project.executeTargets(parseTargets());
             } else {
-                logger.info("Executing ANT target: " + target);
+                logger.info("Executing ANT target: {}", target);
                 project.executeTarget(target);
             }
         } catch (BuildException e) {
             throw new CitrusRuntimeException("Failed to run ANT build file", e);
         }
 
-        logger.info("Executed ANT build: " + buildFileResource);
+        logger.info("Executed ANT build: {}", buildFileResource);
     }
 
     private static DefaultLogger getDefaultConsoleLogger() {
@@ -166,18 +166,15 @@ private Stack<String> parseTargets() {
     private void loadBuildPropertyFile(Project project, TestContext context) {
         if (StringUtils.hasText(propertyFilePath)) {
             String propertyFileResource = context.replaceDynamicContentInString(propertyFilePath);
-            logger.info("Reading build property file: " + propertyFileResource);
+            logger.info("Reading build property file: {}", propertyFileResource);
             Properties fileProperties = new Properties();
             try {
                 Resource propertyResource = Resources.fromClasspath(propertyFileResource);
                 fileProperties.load(propertyResource.getInputStream());
 
                 for (Entry<Object, Object> entry : fileProperties.entrySet()) {
                     String propertyValue = entry.getValue() != null ? context.replaceDynamicContentInString(entry.getValue().toString()) : "";
-
-                    if (logger.isDebugEnabled()) {
-                        logger.debug("Set build property from file resource: " + entry.getKey() + "=" + propertyValue);
-                    }
+                    logger.debug("Set build property from file resource: {}={}", entry.getKey(), propertyValue);
                     project.setProperty(entry.getKey().toString(), propertyValue);
                 }
             } catch (IOException e) {

diff --git a/core/citrus-base/src/main/java/org/citrusframework/actions/CreateVariablesAction.java b/core/citrus-base/src/main/java/org/citrusframework/actions/CreateVariablesAction.java
@@ -16,16 +16,16 @@
 
 package org.citrusframework.actions;
 
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
 import org.citrusframework.AbstractTestActionBuilder;
 import org.citrusframework.context.TestContext;
 import org.citrusframework.variable.VariableUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
 /**
  * Action creating new test variables during a test. Existing test variables are overwritten
  * by new values.
@@ -64,7 +64,7 @@ public void doExecute(TestContext context) {
             //check if value is variable or function (and resolve it if yes)
             value = context.replaceDynamicContentInString(value);
 
-            logger.info("Setting variable: " + key + " to value: " + value);
+            logger.info("Setting variable: {} to value: {}", key, value);
 
             context.setVariable(key, value);
         }

diff --git a/core/citrus-base/src/main/java/org/citrusframework/actions/EchoAction.java b/core/citrus-base/src/main/java/org/citrusframework/actions/EchoAction.java
@@ -16,13 +16,13 @@
 
 package org.citrusframework.actions;
 
-import java.util.Date;
-
 import org.citrusframework.AbstractTestActionBuilder;
 import org.citrusframework.context.TestContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.Date;
+
 /**
  * Prints messages to the console/logger during test execution.
  *
@@ -49,7 +49,7 @@ private EchoAction(Builder builder) {
     @Override
     public void doExecute(TestContext context) {
         if (message == null) {
-            logger.info("Citrus test " + new Date(System.currentTimeMillis()));
+            logger.info("Citrus test {}", new Date(System.currentTimeMillis()));
         } else {
             logger.info(context.getLogModifier().mask(context.replaceDynamicContentInString(message)));
         }

diff --git a/core/citrus-base/src/main/java/org/citrusframework/actions/InputAction.java b/core/citrus-base/src/main/java/org/citrusframework/actions/InputAction.java
@@ -16,6 +16,13 @@
 
 package org.citrusframework.actions;
 
+import org.citrusframework.AbstractTestActionBuilder;
+import org.citrusframework.context.TestContext;
+import org.citrusframework.exceptions.CitrusRuntimeException;
+import org.citrusframework.util.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -24,17 +31,10 @@
 import java.util.StringTokenizer;
 import java.util.stream.Stream;
 
-import org.citrusframework.AbstractTestActionBuilder;
-import org.citrusframework.context.TestContext;
-import org.citrusframework.exceptions.CitrusRuntimeException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.citrusframework.util.StringUtils;
-
 /**
  * Test action prompts user data from standard input stream. The input data is then stored as new
  * test variable. Test workflow stops until user input is complete.
- *
+ * <p>
  * Action can declare a set of valid answers, so user will be prompted until a valid
  * answer was returned.
  *
@@ -77,7 +77,7 @@ public void doExecute(TestContext context) {
 
         if (context.getVariables().containsKey(variable)) {
             input = context.getVariable(variable);
-            logger.info("Variable " + variable + " is already set (='" + input + "'). Skip waiting for user input");
+            logger.info("Variable {} is already set (='{}'). Skip waiting for user input", variable, input);
 
             return;
         }
@@ -123,7 +123,7 @@ private boolean checkAnswer(String input) {
             }
         }
 
-        logger.info("User input is not valid - must be one of " + validAnswers);
+        logger.info("User input is not valid - must be one of {}", validAnswers);
 
         return false;
     }

diff --git a/core/citrus-base/src/main/java/org/citrusframework/actions/JavaAction.java b/core/citrus-base/src/main/java/org/citrusframework/actions/JavaAction.java
@@ -16,14 +16,6 @@
 
 package org.citrusframework.actions;
 
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
 import org.citrusframework.AbstractTestActionBuilder;
 import org.citrusframework.context.TestContext;
 import org.citrusframework.exceptions.CitrusRuntimeException;
@@ -32,6 +24,14 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
 /**
  * Action to enable class invocation through java reflection
  *
@@ -125,7 +125,7 @@ private void invokeMethod(Object instance, Class<?>[] methodTypes, Object[] meth
                     Arrays.stream(methodTypes).map(Class::getSimpleName).collect(Collectors.joining(",")) + ")' for class '" + instance.getClass() + "'");
         }
 
-        logger.info("Invoking method '" + methodToRun.toString() + "' on instance '" + instance.getClass() + "'");
+        logger.info("Invoking method '{}' on instance '{}'", methodToRun, instance.getClass());
 
         methodToRun.invoke(instance, methodObjects);
     }
@@ -152,7 +152,7 @@ private Object getObjectInstanceFromClass(TestContext context) throws ClassNotFo
                 "is set for Java reflection call");
         }
 
-        logger.info("Instantiating class for name '" + className + "'");
+        logger.info("Instantiating class for name '{}'", className);
 
         Class<?> classToRun = Class.forName(className);
 

diff --git a/core/citrus-base/src/main/java/org/citrusframework/actions/LoadPropertiesAction.java b/core/citrus-base/src/main/java/org/citrusframework/actions/LoadPropertiesAction.java
@@ -16,11 +16,6 @@
 
 package org.citrusframework.actions;
 
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Properties;
-
 import org.citrusframework.AbstractTestActionBuilder;
 import org.citrusframework.context.TestContext;
 import org.citrusframework.exceptions.CitrusRuntimeException;
@@ -29,6 +24,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Properties;
+
 /**
  * Action reads property files and creates test variables for every property entry. File
  * resource path can define a resource located on classpath or file system.
@@ -55,23 +55,18 @@ public LoadPropertiesAction(Builder builder) {
     public void doExecute(TestContext context) {
         Resource resource = FileUtils.getFileResource(filePath, context);
 
-        if (logger.isDebugEnabled()) {
-            logger.debug("Reading property file " + FileUtils.getFileName(resource.getLocation()));
-        }
+        logger.debug("Reading property file {}", FileUtils.getFileName(resource.getLocation()));
 
         Properties props = FileUtils.loadAsProperties(resource);
 
         Map<String, Object> unresolved = new LinkedHashMap<>();
         for (Entry<Object, Object> entry : props.entrySet()) {
             String key = entry.getKey().toString();
 
-            if (logger.isDebugEnabled()) {
-                logger.debug("Loading property: " + key + "=" + props.getProperty(key) + " into variables");
-            }
+            logger.debug("Loading property: {}={} into variables", key, props.getProperty(key));
 
             if (logger.isDebugEnabled() && context.getVariables().containsKey(key)) {
-                logger.debug("Overwriting property " + key + " old value:" + context.getVariable(key)
-                        + " new value:" + props.getProperty(key));
+                logger.debug("Overwriting property {} old value:{} new value:{}", key, context.getVariable(key), props.getProperty(key));
             }
 
             try {
@@ -83,7 +78,7 @@ public void doExecute(TestContext context) {
 
         context.resolveDynamicValuesInMap(unresolved).forEach(context::setVariable);
 
-        logger.info("Loaded property file " + FileUtils.getFileName(resource.getLocation()));
+        logger.info("Loaded property file {}", FileUtils.getFileName(resource.getLocation()));
     }
 
     /**