Started with compatibility support

had to restructure current code a bit to support different implementations of TestRunner calls

Author: Samuel Nitsche

src/main/java/org/utplsql/api/TestRunner.java

@@ -5,6 +5,8 @@
 import org.utplsql.api.reporter.DocumentationReporter;
 import org.utplsql.api.reporter.Reporter;
 import oracle.jdbc.OracleConnection;
+import org.utplsql.api.testRunner.AbstractTestRunnerStatement;
+import org.utplsql.api.testRunner.TestRunnerStatement;
 
 import java.sql.CallableStatement;
 import java.sql.Connection;
@@ -18,70 +20,60 @@
  */
 public class TestRunner {
 
-    private List<String> pathList = new ArrayList<>();
-    private List<Reporter> reporterList = new ArrayList<>();
-    private boolean colorConsole = false;
-    private List<String> coverageSchemes = new ArrayList<>();
-    private List<String> sourceFiles = new ArrayList<>();
-    private List<String> testFiles = new ArrayList<>();
-    private List<String> includeObjects = new ArrayList<>();
-    private List<String> excludeObjects = new ArrayList<>();
-    private FileMapperOptions sourceMappingOptions;
-    private FileMapperOptions testMappingOptions;
-    private boolean failOnErrors = false;
+    private TestRunnerOptions options = new TestRunnerOptions();
 
     public TestRunner addPath(String path) {
-        this.pathList.add(path);
+        options.pathList.add(path);
         return this;
     }
 
     public TestRunner addPathList(List<String> paths) {
-        if (pathList != null) this.pathList.addAll(paths);
+        if (options.pathList != null) options.pathList.addAll(paths);
         return this;
     }
 
     public TestRunner addReporter(Reporter reporter) {
-        this.reporterList.add(reporter);
+        options.reporterList.add(reporter);
         return this;
     }
 
     public TestRunner colorConsole(boolean colorConsole) {
-        this.colorConsole = colorConsole;
+        options.colorConsole = colorConsole;
         return this;
     }
 
     public TestRunner addReporterList(List<Reporter> reporterList) {
-        if (reporterList != null) this.reporterList.addAll(reporterList);
+        if (options.reporterList != null) options.reporterList.addAll(reporterList);
         return this;
     }
 
     public TestRunner addCoverageScheme(String coverageScheme) {
-        this.coverageSchemes.add(coverageScheme);
+        options.coverageSchemes.add(coverageScheme);
         return this;
     }
 
     public TestRunner includeObject(String obj) {
-        this.includeObjects.add(obj);
+        options.includeObjects.add(obj);
         return this;
     }
 
     public TestRunner excludeObject(String obj) {
-        this.excludeObjects.add(obj);
+        options.excludeObjects.add(obj);
         return this;
     }
 
     public TestRunner sourceMappingOptions(FileMapperOptions mapperOptions) {
-        this.sourceMappingOptions = mapperOptions;
+        options.sourceMappingOptions = mapperOptions;
         return this;
     }
 
     public TestRunner testMappingOptions(FileMapperOptions mapperOptions) {
-        this.testMappingOptions = mapperOptions;
+        options.testMappingOptions = mapperOptions;
         return this;
     }
 
     public TestRunner failOnErrors(boolean failOnErrors) {
-        this.failOnErrors = failOnErrors;
+        options.failOnErrors = failOnErrors;
         return this;
     }
 
@@ -90,97 +82,34 @@ public void run(Connection conn) throws SomeTestsFailedException, SQLException,
         // First of all check version compatibility
         DBHelper.failOnVersionCompatibilityCheckFailed(conn);
 
-        for (Reporter r : this.reporterList)
+        for (Reporter r : options.reporterList)
             validateReporter(conn, r);
 
-        if (this.pathList.isEmpty()) {
-            this.pathList.add(DBHelper.getCurrentSchema(conn));
+        if (options.pathList.isEmpty()) {
+            options.pathList.add(DBHelper.getCurrentSchema(conn));
         }
 
-        if (this.reporterList.isEmpty()) {
-            this.reporterList.add(new DocumentationReporter().init(conn));
+        if (options.reporterList.isEmpty()) {
+            options.reporterList.add(new DocumentationReporter().init(conn));
         }
 
-        // Workaround because Oracle JDBC doesn't support passing boolean to stored procedures.
-        String colorConsoleStr = Boolean.toString(this.colorConsole);
-        String failOnErrors = Boolean.toString(this.failOnErrors);
+        AbstractTestRunnerStatement testRunnerStatement = null;
 
-        OracleConnection oraConn = conn.unwrap(OracleConnection.class);
-        CallableStatement callableStatement = null;
         try {
             DBHelper.enableDBMSOutput(conn);
 
-            callableStatement = conn.prepareCall(
-                    "BEGIN " +
-                        "ut_runner.run(" +
-                            "a_paths                => ?, " +
-                            "a_reporters            => ?, " +
-                            "a_color_console        => " + colorConsoleStr + ", " +
-                            "a_coverage_schemes     => ?, " +
-                            "a_source_file_mappings => ?, " +
-                            "a_test_file_mappings   => ?, " +
-                            "a_include_objects      => ?, " +
-                            "a_exclude_objects      => ?, " +
-                            "a_fail_on_errors       => " + failOnErrors + "); " +
-                    "END;");
-
-            int paramIdx = 0;
-
-            callableStatement.setArray(
-                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, this.pathList.toArray()));
-
-            callableStatement.setArray(
-                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_REPORTERS, this.reporterList.toArray()));
-
-            if (this.coverageSchemes.isEmpty()) {
-                callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_VARCHAR2_LIST);
-            } else {
-                callableStatement.setArray(
-                        ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, this.coverageSchemes.toArray()));
-            }
-
-            if (this.sourceMappingOptions == null) {
-                callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_FILE_MAPPINGS);
-            } else {
-                List<FileMapping> sourceMappings = FileMapper.buildFileMappingList(conn, this.sourceMappingOptions);
-
-                callableStatement.setArray(
-                        ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_FILE_MAPPINGS, sourceMappings.toArray()));
-            }
-
-            if (this.testMappingOptions == null) {
-                callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_FILE_MAPPINGS);
-            } else {
-                List<FileMapping> sourceMappings = FileMapper.buildFileMappingList(conn, this.testMappingOptions);
-
-                callableStatement.setArray(
-                        ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_FILE_MAPPINGS, sourceMappings.toArray()));
-            }
-
-            if (this.includeObjects.isEmpty()) {
-                callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_VARCHAR2_LIST);
-            } else {
-                callableStatement.setArray(
-                        ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, this.includeObjects.toArray()));
-            }
-
-            if (this.excludeObjects.isEmpty()) {
-                callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_VARCHAR2_LIST);
-            } else {
-                callableStatement.setArray(
-                        ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, this.excludeObjects.toArray()));
-            }
+            testRunnerStatement = new TestRunnerStatement(options, conn);
 
-            callableStatement.execute();
+            testRunnerStatement.execute();
         } catch (SQLException e) {
             if (e.getErrorCode() == SomeTestsFailedException.ERROR_CODE) {
                 throw new SomeTestsFailedException(e.getMessage(), e);
             } else {
                 throw e;
             }
         } finally {
-            if (callableStatement != null) {
-                callableStatement.close();
+            if (testRunnerStatement != null) {
+                testRunnerStatement.close();
             }
 
             DBHelper.disableDBMSOutput(conn);

src/main/java/org/utplsql/api/TestRunnerOptions.java

@@ -0,0 +1,20 @@
+package org.utplsql.api;
+
+import org.utplsql.api.reporter.Reporter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestRunnerOptions {
+    public List<String> pathList = new ArrayList<>();
+    public List<Reporter> reporterList = new ArrayList<>();
+    public boolean colorConsole = false;
+    public List<String> coverageSchemes = new ArrayList<>();
+    public List<String> sourceFiles = new ArrayList<>();
+    public List<String> testFiles = new ArrayList<>();
+    public List<String> includeObjects = new ArrayList<>();
+    public List<String> excludeObjects = new ArrayList<>();
+    public FileMapperOptions sourceMappingOptions;
+    public FileMapperOptions testMappingOptions;
+    public boolean failOnErrors = false;
+}

src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java

@@ -0,0 +1,90 @@
+package org.utplsql.api.testRunner;
+
+import oracle.jdbc.OracleConnection;
+import org.utplsql.api.*;
+import org.utplsql.api.exception.SomeTestsFailedException;
+
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.List;
+
+public abstract class AbstractTestRunnerStatement {
+
+    protected TestRunnerOptions options;
+    protected Connection conn;
+    protected CallableStatement callableStatement;
+
+    public AbstractTestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException {
+        this.options = options;
+        this.conn = conn;
+
+        createStatement();
+    }
+
+    protected abstract String getSql();
+
+    protected void createStatement() throws SQLException {
+
+        OracleConnection oraConn = conn.unwrap(OracleConnection.class);
+
+        callableStatement = conn.prepareCall(getSql());
+
+        int paramIdx = 0;
+
+        callableStatement.setArray(
+                ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, options.pathList.toArray()));
+
+        callableStatement.setArray(
+                ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_REPORTERS, options.reporterList.toArray()));
+
+        if (options.coverageSchemes.isEmpty()) {
+            callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_VARCHAR2_LIST);
+        } else {
+            callableStatement.setArray(
+                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, options.coverageSchemes.toArray()));
+        }
+
+        if (options.sourceMappingOptions == null) {
+            callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_FILE_MAPPINGS);
+        } else {
+            List<FileMapping> sourceMappings = FileMapper.buildFileMappingList(conn, options.sourceMappingOptions);
+
+            callableStatement.setArray(
+                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_FILE_MAPPINGS, sourceMappings.toArray()));
+        }
+
+        if (options.testMappingOptions == null) {
+            callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_FILE_MAPPINGS);
+        } else {
+            List<FileMapping> sourceMappings = FileMapper.buildFileMappingList(conn, options.testMappingOptions);
+
+            callableStatement.setArray(
+                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_FILE_MAPPINGS, sourceMappings.toArray()));
+        }
+
+        if (options.includeObjects.isEmpty()) {
+            callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_VARCHAR2_LIST);
+        } else {
+            callableStatement.setArray(
+                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, options.includeObjects.toArray()));
+        }
+
+        if (options.excludeObjects.isEmpty()) {
+            callableStatement.setNull(++paramIdx, Types.ARRAY, CustomTypes.UT_VARCHAR2_LIST);
+        } else {
+            callableStatement.setArray(
+                    ++paramIdx, oraConn.createOracleArray(CustomTypes.UT_VARCHAR2_LIST, options.excludeObjects.toArray()));
+        }
+    }
+
+    public void execute() throws SQLException {
+        callableStatement.execute();
+    }
+
+    public void close() throws SQLException {
+        if (callableStatement != null)
+            callableStatement.close();
+    }
+}

src/main/java/org/utplsql/api/testRunner/Pre303TestRunnerStatement.java

@@ -0,0 +1,31 @@
+package org.utplsql.api.testRunner;
+
+import org.utplsql.api.TestRunnerOptions;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class Pre303TestRunnerStatement extends AbstractTestRunnerStatement {
+
+    public Pre303TestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException {
+        super(options, conn);
+    }
+
+    @Override
+    protected String getSql() {
+        // Workaround because Oracle JDBC doesn't support passing boolean to stored procedures.
+        String colorConsoleStr = Boolean.toString(options.colorConsole);
+
+        return "BEGIN " +
+                "ut_runner.run(" +
+                "a_paths            => ?, " +
+                "a_reporters        => ?, " +
+                "a_color_console    => " + colorConsoleStr + ", " +
+                "a_coverage_schemes => ?, " +
+                "a_source_files     => ?, " +
+                "a_test_files       => ?, " +
+                "a_include_objects  => ?, " +
+                "a_exclude_objects  => ?); " +
+                "END;";
+    }
+}

src/main/java/org/utplsql/api/testRunner/TestRunnerStatement.java

@@ -0,0 +1,34 @@
+package org.utplsql.api.testRunner;
+
+import org.utplsql.api.TestRunnerOptions;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+public class TestRunnerStatement extends AbstractTestRunnerStatement {
+
+    public TestRunnerStatement(TestRunnerOptions options, Connection connection ) throws SQLException {
+        super( options, connection);
+    }
+
+    @Override
+    protected String getSql() {
+        // Workaround because Oracle JDBC doesn't support passing boolean to stored procedures.
+        String colorConsoleStr = Boolean.toString(options.colorConsole);
+        String failOnErrors = Boolean.toString(options.failOnErrors);
+
+        return
+                "BEGIN " +
+                        "ut_runner.run(" +
+                        "a_paths                => ?, " +
+                        "a_reporters            => ?, " +
+                        "a_color_console        => " + colorConsoleStr + ", " +
+                        "a_coverage_schemes     => ?, " +
+                        "a_source_file_mappings => ?, " +
+                        "a_test_file_mappings   => ?, " +
+                        "a_include_objects      => ?, " +
+                        "a_exclude_objects      => ?, " +
+                        "a_fail_on_errors       => " + failOnErrors + "); " +
+                        "END;";
+    }
+}