Initial implementation of Picocli usage

Introduced new Config-Objects to abstract away cli-arguments to config transformation. Will also be needed for YAML/JSON configuration in the future
utPLSQL · pesse · Jun 26, 2019 · Jun 4, 2019 · Jun 7, 2019 · Jun 7, 2019
commit ce849fcabf34dd39bd47fdca0691ec724335a200
diff --git a/pom.xml b/pom.xml
@@ -61,6 +61,11 @@
           <artifactId>logback-classic</artifactId>
           <version>1.2.3</version>
       </dependency>
+      <dependency>
+          <groupId>info.picocli</groupId>
+          <artifactId>picocli</artifactId>
+          <version>4.0.0-beta-1b</version>
+      </dependency>
       <dependency>
           <groupId>com.oracle.jdbc</groupId>
           <artifactId>ojdbc8</artifactId>

diff --git a/src/main/java/org/utplsql/cli/LoggerConfiguration.java b/src/main/java/org/utplsql/cli/LoggerConfiguration.java
@@ -9,7 +9,7 @@
 import com.zaxxer.hikari.HikariDataSource;
 import org.slf4j.LoggerFactory;
 
-class LoggerConfiguration {
+public class LoggerConfiguration {
 
     public enum ConfigLevel {
         BASIC, NONE, DEBUG

diff --git a/src/main/java/org/utplsql/cli/RunPicocliCommand.java b/src/main/java/org/utplsql/cli/RunPicocliCommand.java
@@ -0,0 +1,230 @@
+package org.utplsql.cli;
+
+import org.utplsql.cli.config.FileMapperConfig;
+import org.utplsql.cli.config.ReporterConfig;
+import org.utplsql.cli.config.RunCommandConfig;
+import picocli.CommandLine.*;
+
+import java.util.*;
+import java.util.concurrent.Callable;
+
+@Command( name = "run", description = "run tests")
+public class RunPicocliCommand implements Callable<RunCommandConfig> {
+
+    @Parameters(description = ConnectionInfo.COMMANDLINE_PARAM_DESCRIPTION)
+    private String connectionString;
+
+    @Option(names = {"-p", "--path"},
+            description = "run suites/tests by path, format: " +
+                    "-p=[schema|schema:[suite ...][.test]|schema[.suite ...][.test]")
+    private List<String> paths = new ArrayList<>();
+
+
+    @Option(
+            names = {"-c", "--color"},
+            description = "enables printing of test results in colors as defined by ANSICONSOLE standards")
+    private boolean colorConsole = false;
+
+    @Option(
+            names = {"-d", "--debug"},
+            description = "Outputs a load of debug information to console")
+    private boolean logDebug = false;
+
+    @Option(
+            names = {"-q", "--quiet"},
+            description = "Does not output the informational messages normally printed to console")
+    private boolean logSilent = false;
+
+    @Option(
+            names = {"--failure-exit-code"},
+            description = "override the exit code on failure, default = 1")
+    private int failureExitCode = 1;
+
+
+    @Option(
+            names = {"-scc", "--skip-compatibility-check"},
+            description = "Skips the check for compatibility with database framework. CLI expects the framework to be " +
+                    "most actual. Use this if you use CLI with a development version of utPLSQL-framework")
+    private boolean skipCompatibilityCheck = false;
+
+    @Option(
+            names = {"-t", "--timeout"},
+            description = "Sets the timeout in minutes after which the cli will abort. Default 60")
+    private int timeoutInMinutes = 60;
+
+    @Option(
+            names = {"-include"},
+            description = "Comma-separated object list to include in the coverage report. " +
+                    "Format: [schema.]package[,[schema.]package ...]. See coverage reporting options in framework documentation"
+    )
+    private String includeObjects = null;
+
+    @Option(
+            names = {"-exclude"},
+            description = "Comma-separated object list to exclude from the coverage report. " +
+                    "Format: [schema.]package[,[schema.]package ...]. See coverage reporting options in framework documentation"
+    )
+    private String excludeObjects = null;
+
+
+    @Option(
+            names = {"-D", "--dbms_output"},
+            description = "Enables DBMS_OUTPUT for the TestRunner (default: DISABLED)"
+    )
+    private boolean enableDbmsOutput = false;
+
+    // RandomTestOrder
+    @Option(
+            names = {"-r", "--random-test-order"},
+            description = "Enables random order of test executions (default: DISABLED)"
+    )
+    private boolean randomTestOrder = false;
+
+    @Option(
+            names = {"-seed", "--random-test-order-seed"},
+            description = "Sets the seed to use for random test execution order. If set, it sets --random-test-order to true"
+    )
+    private Integer randomTestOrderSeed;
+
+    @ArgGroup(exclusive = false, multiplicity = "0..*")
+    private List<Format> reporters = new ArrayList<>();
+
+    static class Format {
+        @Option(names={"-f", "--format"}, required = true, description = "Enables specified format reporting")
+        String format;
+        @Option(names={"-o"}, description = "Outputs format to file")
+        String outputFile;
+        @Option(names={"-s"}, description = "Outputs to screen even when an output file is specified")
+        boolean outputToScreen = false;
+    }
+
+    // FileMappings
+    @ArgGroup(exclusive = false, multiplicity = "0..2")
+    private List<FileMappingComposite> fileMappings;
+
+    static class FileMappingComposite {
+
+        static class TestOrSourcePath {
+            @Option(names="-source_path", required = true)
+            String sourcePath;
+            @Option(names="-test_path", required = true)
+            String testPath;
+
+            String getPath() {
+                return ( isSourcePath() ) ? sourcePath : testPath;
+            }
+
+            boolean isSourcePath() {
+                return sourcePath != null;
+            }
+        }
+
+        static class FileMapping {
+            @Option(names="-owner")
+            String owner;
+            @Option(names="-regex_expression")
+            String regexExpression;
+            @Option(names="-type_mapping")
+            String typeMapping;
+            @Option(names="-owner_subexpression")
+            Integer ownerSubExpression;
+            @Option(names="-type_subexpression")
+            Integer typeSubExpression;
+            @Option(names="-name_subexpression")
+            Integer nameSubExpression;
+        }
+
+        @ArgGroup(exclusive = true, multiplicity = "1")
+        TestOrSourcePath testOrSourcePath;
+
+        @ArgGroup(exclusive = false, multiplicity = "1")
+        FileMapping mapping;
+
+
+        FileMapperConfig toFileMapperConfig() {
+            Map<String, String> typeMap = new HashMap<>();
+
+            if ( mapping.typeMapping != null && !mapping.typeMapping.isEmpty()) {
+                for ( String keyVal : mapping.typeMapping.split("/")) {
+                    String[] values = keyVal.split("=");
+                    typeMap.put(values[0], values[1]);
+                }
+            }
+
+            return new FileMapperConfig(
+                    testOrSourcePath.getPath(),
+                    mapping.owner,
+                    mapping.regexExpression,
+                    typeMap,
+                    mapping.ownerSubExpression,
+                    mapping.typeSubExpression,
+                    mapping.nameSubExpression
+            );
+        }
+    }
+
+    private String[] splitOrEmpty(String value) {
+        if ( value == null || value.isEmpty() ) {
+            return new String[0];
+        }
+        else {
+            return value.split(",");
+        }
+    }
+
+    @Override
+    public RunCommandConfig call() throws Exception {
+
+        // Prepare path elements
+        ArrayList<String> suitePaths = new ArrayList<>();
+        for ( String pathElem : paths ) {
+            suitePaths.addAll(Arrays.asList(pathElem.split(",")));
+        }
+
+        // Prepare LogLevelConfig
+        LoggerConfiguration.ConfigLevel loggerConfigLevel = LoggerConfiguration.ConfigLevel.BASIC;
+        if ( logSilent ) {
+            loggerConfigLevel = LoggerConfiguration.ConfigLevel.NONE;
+        }
+        else if ( logDebug ) {
+            loggerConfigLevel = LoggerConfiguration.ConfigLevel.DEBUG;
+        }
+
+        // Prepare Reporter configs
+        List<ReporterConfig> reporterConfigs = new ArrayList<>();
+        for ( Format format : reporters ) {
+            reporterConfigs.add(new ReporterConfig(format.format, format.outputFile, format.outputToScreen));
+        }
+
+        // Prepare TypeMappings
+        FileMapperConfig sourceFileMapping = null;
+        FileMapperConfig testFileMapping = null;
+        if ( fileMappings != null ) {
+            for ( FileMappingComposite fmc : fileMappings ) {
+                if ( fmc.testOrSourcePath.isSourcePath() ) {
+                    sourceFileMapping = fmc.toFileMapperConfig();
+                }
+                else {
+                    testFileMapping = fmc.toFileMapperConfig();
+                }
+            }
+        }
+
+        return new RunCommandConfig(
+                connectionString,
+                suitePaths.toArray(new String[0]),
+                reporterConfigs.toArray(new ReporterConfig[0]),
+                colorConsole,
+                failureExitCode,
+                skipCompatibilityCheck,
+                splitOrEmpty(includeObjects),
+                splitOrEmpty(excludeObjects),
+                sourceFileMapping,
+                testFileMapping,
+                loggerConfigLevel,
+                timeoutInMinutes,
+                enableDbmsOutput,
+                randomTestOrder,
+                randomTestOrderSeed);
+    }
+}
diff --git a/src/main/java/org/utplsql/cli/UtplsqlPicocliCommand.java b/src/main/java/org/utplsql/cli/UtplsqlPicocliCommand.java
@@ -0,0 +1,11 @@
+package org.utplsql.cli;
+
+import picocli.CommandLine;
+
+@CommandLine.Command(
+        name = "utplsql",
+        description = "utPLSQL cli",
+        subcommands = { RunPicocliCommand.class })
+public class UtplsqlPicocliCommand {
+
+}
diff --git a/src/main/java/org/utplsql/cli/config/ConnectionConfig.java b/src/main/java/org/utplsql/cli/config/ConnectionConfig.java
@@ -0,0 +1,18 @@
+package org.utplsql.cli.config;
+
+import java.beans.ConstructorProperties;
+
+public class ConnectionConfig {
+
+    private final String connectString;
+
+    @ConstructorProperties({"connectString"})
+    public ConnectionConfig(String connectString) {
+        this.connectString = connectString;
+    }
+
+    public String getConnectString() {
+        return connectString;
+    }
+
+}
diff --git a/src/main/java/org/utplsql/cli/config/FileMapperConfig.java b/src/main/java/org/utplsql/cli/config/FileMapperConfig.java
@@ -0,0 +1,54 @@
+package org.utplsql.cli.config;
+
+import java.beans.ConstructorProperties;
+import java.util.Map;
+
+public class FileMapperConfig {
+
+    private final String path;
+    private final String owner;
+    private final String regexExpression;
+    private final Map<String, String> typeMapping;
+    private final Integer ownerSubexpression;
+    private final Integer nameSubexpression;
+    private final Integer typeSubexpression;
+
+    @ConstructorProperties({"path", "owner", "regexExpression", "typeMapping", "ownerSubexpression", "nameSubexpression", "typeSubexpression"})
+    public FileMapperConfig(String path, String owner, String regexExpression, Map<String, String> typeMapping, Integer ownerSubexpression, Integer nameSubexpression, Integer typeSubexpression) {
+        this.path = path;
+        this.owner = owner;
+        this.regexExpression = regexExpression;
+        this.typeMapping = typeMapping;
+        this.ownerSubexpression = ownerSubexpression;
+        this.nameSubexpression = nameSubexpression;
+        this.typeSubexpression = typeSubexpression;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public String getOwner() {
+        return owner;
+    }
+
+    public String getRegexExpression() {
+        return regexExpression;
+    }
+
+    public Map<String, String> getTypeMapping() {
+        return typeMapping;
+    }
+
+    public Integer getOwnerSubexpression() {
+        return ownerSubexpression;
+    }
+
+    public Integer getNameSubexpression() {
+        return nameSubexpression;
+    }
+
+    public Integer getTypeSubexpression() {
+        return typeSubexpression;
+    }
+}
diff --git a/src/main/java/org/utplsql/cli/config/ReporterConfig.java b/src/main/java/org/utplsql/cli/config/ReporterConfig.java
@@ -0,0 +1,29 @@
+package org.utplsql.cli.config;
+
+import java.beans.ConstructorProperties;
+
+public class ReporterConfig {
+
+    private final String name;
+    private final String output;
+    private boolean screen = false;
+
+    @ConstructorProperties({"name", "output", "screen"})
+    public ReporterConfig( String name, String output, Boolean screen ) {
+        this.name = name;
+        this.output = output;
+        if ( screen != null ) this.screen = screen;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getOutput() {
+        return output;
+    }
+
+    public boolean isScreen() {
+        return screen;
+    }
+}