utPLSQL · pesse · Apr 4, 2019 · Apr 3, 2019 · Apr 3, 2019 · Apr 3, 2019
diff --git a/RELEASE-CHECKLIST.md b/RELEASE-CHECKLIST.md
@@ -0,0 +1,5 @@
+# TODO's before releasing a new java-api version
+
+- Update `CoreReporters`
+- Update `Version`: knownVersions, LATEST
+- Update `build.gradle.kts`: baseVersion
diff --git a/src/main/java/org/utplsql/api/TestRunner.java b/src/main/java/org/utplsql/api/TestRunner.java
@@ -152,8 +152,12 @@ public void run(Connection conn) throws SQLException {
 
         DatabaseInformation databaseInformation = new DefaultDatabaseInformation();
 
-        compatibilityProxy = new CompatibilityProxy(conn, options.skipCompatibilityCheck, databaseInformation);
-        logger.info("Running on utPLSQL {}", compatibilityProxy.getDatabaseVersion());
+        if ( options.skipCompatibilityCheck ) {
+            compatibilityProxy = new CompatibilityProxy(conn, Version.LATEST, databaseInformation);
+        } else {
+            compatibilityProxy = new CompatibilityProxy(conn, databaseInformation);
+        }
+        logger.info("Running on utPLSQL {}", compatibilityProxy.getVersionDescription());
 
         if (reporterFactory == null) {
             reporterFactory = ReporterFactory.createDefault(compatibilityProxy);
@@ -236,7 +240,7 @@ private void validateReporter(Connection conn, Reporter reporter) throws SQLExce
      */
     public Version getUsedDatabaseVersion() {
         if (compatibilityProxy != null) {
-            return compatibilityProxy.getDatabaseVersion();
+            return compatibilityProxy.getUtPlsqlVersion();
         } else {
             return null;
         }

diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java
@@ -27,9 +27,14 @@ public class Version implements Comparable<Version> {
     public final static Version V3_1_0 = new Version("3.1.0", 3, 1, 0, null, true);
     public final static Version V3_1_1 = new Version("3.1.1", 3, 1, 1, null, true);
     public final static Version V3_1_2 = new Version("3.1.2", 3, 1, 2, null, true);
+    public final static Version V3_1_3 = new Version("3.1.3", 3, 1, 3, null, true);
+    public final static Version V3_1_4 = new Version("3.1.4", 3, 1, 4, null, true);
+    public final static Version V3_1_5 = new Version("3.1.5", 3, 1, 5, null, true);
+    public final static Version V3_1_6 = new Version("3.1.6", 3, 1, 6, null, true);
     private final static Map<String, Version> knownVersions =
-            Stream.of(V3_0_0, V3_0_1, V3_0_2, V3_0_3, V3_0_4, V3_1_0, V3_1_1, V3_1_2)
+            Stream.of(V3_0_0, V3_0_1, V3_0_2, V3_0_3, V3_0_4, V3_1_0, V3_1_1, V3_1_2, V3_1_3, V3_1_4, V3_1_5, V3_1_6)
                     .collect(toMap(Version::toString, Function.identity()));
+    public final static Version LATEST = V3_1_6;
 
     private final String origString;
     private final Integer major;

diff --git a/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java b/src/main/java/org/utplsql/api/compatibility/CompatibilityProxy.java
@@ -11,6 +11,7 @@
 import org.utplsql.api.testRunner.TestRunnerStatement;
 import org.utplsql.api.testRunner.TestRunnerStatementProvider;
 
+import javax.annotation.Nullable;
 import java.sql.Connection;
 import java.sql.SQLException;
 import java.util.Objects;
@@ -25,30 +26,42 @@
 public class CompatibilityProxy {
 
     public static final String UTPLSQL_COMPATIBILITY_VERSION = "3";
-    private static final String UTPLSQL_API_VERSION = "3.1.1";
     private final DatabaseInformation databaseInformation;
-    private Version databaseVersion;
+    private Version utPlsqlVersion;
+    private Version realDbPlsqlVersion;
     private boolean compatible = false;
 
     public CompatibilityProxy(Connection conn) throws SQLException {
-        this(conn, false, null);
+        this(conn, null, null);
     }
 
-    public CompatibilityProxy(Connection conn, DatabaseInformation databaseInformation) throws SQLException {
-        this(conn, false, databaseInformation);
+    @Deprecated
+    public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck ) throws SQLException {
+        this(conn, skipCompatibilityCheck, null);
     }
 
-    public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck) throws SQLException {
-        this(conn, skipCompatibilityCheck, null);
+    @Deprecated
+    public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck, @Nullable  DatabaseInformation databaseInformation ) throws SQLException {
+        this(conn, skipCompatibilityCheck ? Version.LATEST : null, databaseInformation);
+    }
+
+    public CompatibilityProxy(Connection conn, @Nullable DatabaseInformation databaseInformation) throws SQLException {
+        this(conn, null, databaseInformation);
     }
 
-    public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck, DatabaseInformation databaseInformation) throws SQLException {
+    public CompatibilityProxy(Connection conn, @Nullable Version assumedUtPlsVersion) throws SQLException {
+        this(conn, assumedUtPlsVersion, null);
+    }
+
+    public CompatibilityProxy(Connection conn, @Nullable Version assumedUtPlsqlVersion, @Nullable DatabaseInformation databaseInformation) throws SQLException {
         this.databaseInformation = (databaseInformation != null)
                 ? databaseInformation
                 : new DefaultDatabaseInformation();
 
-        if (skipCompatibilityCheck) {
-            doExpectCompatibility();
+        realDbPlsqlVersion = this.databaseInformation.getUtPlsqlFrameworkVersion(conn);
+        if ( assumedUtPlsqlVersion != null ) {
+            utPlsqlVersion = assumedUtPlsqlVersion;
+            compatible = utPlsqlVersion.getNormalizedString().startsWith(UTPLSQL_COMPATIBILITY_VERSION);
         } else {
             doCompatibilityCheckWithDatabase(conn);
         }
@@ -62,18 +75,18 @@ public CompatibilityProxy(Connection conn, boolean skipCompatibilityCheck, Datab
      * @throws SQLException
      */
     private void doCompatibilityCheckWithDatabase(Connection conn) throws SQLException {
-        databaseVersion = databaseInformation.getUtPlsqlFrameworkVersion(conn);
+        utPlsqlVersion = realDbPlsqlVersion;
         Version clientVersion = Version.create(UTPLSQL_COMPATIBILITY_VERSION);
 
-        if (databaseVersion == null) {
+        if (utPlsqlVersion == null) {
             throw new DatabaseNotCompatibleException("Could not get database version", clientVersion, null, null);
         }
 
-        if (databaseVersion.getMajor() == null) {
-            throw new DatabaseNotCompatibleException("Illegal database version: " + databaseVersion.toString(), clientVersion, databaseVersion, null);
+        if (utPlsqlVersion.getMajor() == null) {
+            throw new DatabaseNotCompatibleException("Illegal database version: " + utPlsqlVersion.toString(), clientVersion, utPlsqlVersion, null);
         }
 
-        if (OptionalFeatures.FRAMEWORK_COMPATIBILITY_CHECK.isAvailableFor(databaseVersion)) {
+        if (OptionalFeatures.FRAMEWORK_COMPATIBILITY_CHECK.isAvailableFor(utPlsqlVersion)) {
             try {
                 compatible = versionCompatibilityCheck(conn, UTPLSQL_COMPATIBILITY_VERSION, null);
             } catch (SQLException e) {
@@ -84,14 +97,6 @@ private void doCompatibilityCheckWithDatabase(Connection conn) throws SQLExcepti
         }
     }
 
-    /**
-     * Just prepare the proxy to expect compatibility, expecting the database framework to be the same version as the API
-     */
-    private void doExpectCompatibility() {
-        databaseVersion = Version.create(UTPLSQL_API_VERSION);
-        compatible = true;
-    }
-
     /**
      * Check the utPLSQL version compatibility.
      *
@@ -121,10 +126,10 @@ private boolean versionCompatibilityCheck(Connection conn, String requested, Str
     private boolean versionCompatibilityCheckPre303(String requested) {
         Version requestedVersion = Version.create(requested);
 
-        Objects.requireNonNull(databaseVersion.getMajor(), "Illegal database Version: " + databaseVersion.toString());
-        return databaseVersion.getMajor().equals(requestedVersion.getMajor())
+        Objects.requireNonNull(utPlsqlVersion.getMajor(), "Illegal database Version: " + utPlsqlVersion.toString());
+        return utPlsqlVersion.getMajor().equals(requestedVersion.getMajor())
                 && (requestedVersion.getMinor() == null
-                || requestedVersion.getMinor().equals(databaseVersion.getMinor()));
+                || requestedVersion.getMinor().equals(utPlsqlVersion.getMinor()));
     }
 
     /**
@@ -133,16 +138,29 @@ private boolean versionCompatibilityCheckPre303(String requested) {
      */
     public void failOnNotCompatible() throws DatabaseNotCompatibleException {
         if (!isCompatible()) {
-            throw new DatabaseNotCompatibleException(databaseVersion);
+            throw new DatabaseNotCompatibleException(utPlsqlVersion);
         }
     }
 
     public boolean isCompatible() {
         return compatible;
     }
 
-    public Version getDatabaseVersion() {
-        return databaseVersion;
+    @Deprecated
+    public Version getDatabaseVersion() { return utPlsqlVersion; }
+
+    public Version getUtPlsqlVersion() {
+        return utPlsqlVersion;
+    }
+
+    public Version getRealDbPlsqlVersion() { return realDbPlsqlVersion; }
+
+    public String getVersionDescription() {
+        if ( utPlsqlVersion != realDbPlsqlVersion ) {
+            return realDbPlsqlVersion.toString() + " (Assumed: " + utPlsqlVersion.toString() + ")";
+        } else {
+            return utPlsqlVersion.toString();
+        }
     }
 
     /**
@@ -154,7 +172,7 @@ public Version getDatabaseVersion() {
      * @throws SQLException
      */
     public TestRunnerStatement getTestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException {
-        return TestRunnerStatementProvider.getCompatibleTestRunnerStatement(databaseVersion, options, conn);
+        return TestRunnerStatementProvider.getCompatibleTestRunnerStatement(utPlsqlVersion, options, conn);
     }
 
     /**
@@ -166,6 +184,6 @@ public TestRunnerStatement getTestRunnerStatement(TestRunnerOptions options, Con
      * @throws SQLException
      */
     public OutputBuffer getOutputBuffer(Reporter reporter, Connection conn) throws SQLException {
-        return OutputBufferProvider.getCompatibleOutputBuffer(databaseVersion, reporter, conn);
+        return OutputBufferProvider.getCompatibleOutputBuffer(utPlsqlVersion, reporter, conn);
     }
 }
diff --git a/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java b/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java
@@ -10,7 +10,8 @@ public enum OptionalFeatures {
 
     FAIL_ON_ERROR("3.0.3.1266", null),
     FRAMEWORK_COMPATIBILITY_CHECK("3.0.3.1266", null),
-    CUSTOM_REPORTERS("3.1.0.1849", null);
+    CUSTOM_REPORTERS("3.1.0.1849", null),
+    CLIENT_CHARACTER_SET("3.1.2.2130", null);
 
     private final Version minVersion;
     private final Version maxVersion;
@@ -32,6 +33,10 @@ public boolean isAvailableFor(Version version) {
 
     public boolean isAvailableFor(Connection conn) throws SQLException {
         CompatibilityProxy proxy = new CompatibilityProxy(conn);
-        return isAvailableFor(proxy.getDatabaseVersion());
+        return isAvailableFor(proxy.getUtPlsqlVersion());
     }
+
+    public Version getMinVersion() { return minVersion; }
+
+    public Version getMaxVersion() { return maxVersion; }
 }
diff --git a/src/main/java/org/utplsql/api/reporter/CoreReporters.java b/src/main/java/org/utplsql/api/reporter/CoreReporters.java
@@ -11,14 +11,18 @@
  */
 public enum CoreReporters {
 
+    UT_COVERAGE_COBERTURA_REPORTER(Version.V3_1_0, null),
     UT_COVERAGE_HTML_REPORTER(Version.V3_0_0, null),
-    UT_DOCUMENTATION_REPORTER(Version.V3_0_0, null),
-    UT_TEAMCITY_REPORTER(Version.V3_0_0, null),
-    UT_XUNIT_REPORTER(Version.V3_0_0, null),
-    UT_COVERALLS_REPORTER(Version.V3_0_0, null),
     UT_COVERAGE_SONAR_REPORTER(Version.V3_0_0, null),
+    UT_COVERALLS_REPORTER(Version.V3_0_0, null),
+    UT_DEBUG_REPORTER(Version.V3_1_4, null),
+    UT_DOCUMENTATION_REPORTER(Version.V3_0_0, null),
+    UT_JUNIT_REPORTER(Version.V3_1_0, null),
+    UT_REALTIME_REPORTER(Version.V3_1_4, null),
     UT_SONAR_TEST_REPORTER(Version.V3_0_0, null),
-    UT_COVERAGE_COBERTURA_REPORTER(Version.V3_1_0, null);
+    UT_TEAMCITY_REPORTER(Version.V3_0_0, null),
+    UT_TFS_JUNIT_REPORTER(Version.V3_1_0, null),
+    UT_XUNIT_REPORTER(Version.V3_0_0, null);
 
     private final Version since;
     private final Version until;

diff --git a/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspector.java
@@ -31,7 +31,7 @@ static ReporterInspector create(ReporterFactory reporterFactory, Connection conn
 
         CompatibilityProxy proxy = new CompatibilityProxy(conn);
 
-        if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_0)) {
+        if (proxy.getUtPlsqlVersion().isGreaterOrEqualThan(Version.V3_1_0)) {
             return new ReporterInspector310(reporterFactory, conn);
         } else {
             return new ReporterInspectorPre310(reporterFactory, conn);

diff --git a/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspectorPre310.java b/src/main/java/org/utplsql/api/reporter/inspect/ReporterInspectorPre310.java
@@ -21,7 +21,7 @@ class ReporterInspectorPre310 extends AbstractReporterInspector {
         registeredReporterFactoryMethods = reporterFactory.getRegisteredReporterInfo();
         initDefaultDescriptions();
 
-        Version databaseVersion = new CompatibilityProxy(connection).getDatabaseVersion();
+        Version databaseVersion = new CompatibilityProxy(connection).getUtPlsqlVersion();
         this.infos = Arrays.stream(CoreReporters.values())
                 .filter(r -> r.isAvailableFor(databaseVersion))
                 .map(this::getReporterInfo)

diff --git a/src/test/java/org/utplsql/api/CompatibilityIT.java b/src/test/java/org/utplsql/api/CompatibilityIT.java
@@ -19,9 +19,8 @@ void compatibleVersion() throws SQLException {
 
     @Test
     void skipCompatibilityCheck() throws SQLException {
-        CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), true);
+        CompatibilityProxy proxy = new CompatibilityProxy(getConnection(), Version.LATEST);
         proxy.failOnNotCompatible();
         assertTrue(proxy.isCompatible());
-
     }
 }
diff --git a/src/test/java/org/utplsql/api/OptionalFeaturesIT.java b/src/test/java/org/utplsql/api/OptionalFeaturesIT.java
@@ -1,6 +1,7 @@
 package org.utplsql.api;
 
 import org.junit.jupiter.api.Test;
+import org.omg.CORBA.DynAnyPackage.Invalid;
 import org.utplsql.api.compatibility.CompatibilityProxy;
 import org.utplsql.api.compatibility.OptionalFeatures;
 import org.utplsql.api.exception.InvalidVersionException;
@@ -14,7 +15,7 @@ class OptionalFeaturesIT extends AbstractDatabaseTest {
 
 
     private Version getDatabaseVersion() throws SQLException {
-        return new CompatibilityProxy(getConnection()).getDatabaseVersion();
+        return new CompatibilityProxy(getConnection()).getUtPlsqlVersion();
     }
 
     @Test
@@ -52,4 +53,15 @@ void customReporters() throws SQLException, InvalidVersionException {
             assertFalse(available);
         }
     }
+
+    @Test
+    void clientCharset() throws SQLException, InvalidVersionException {
+        boolean available = OptionalFeatures.CLIENT_CHARACTER_SET.isAvailableFor(getConnection());
+
+        if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_2)) {
+            assertTrue(available);
+        } else {
+            assertFalse(available);
+        }
+    }
 }
diff --git a/src/test/java/org/utplsql/api/OutputBufferIT.java b/src/test/java/org/utplsql/api/OutputBufferIT.java
@@ -131,7 +131,7 @@ void getOutputFromSonarReporter() throws SQLException {
     void sonarReporterHasEncodingSet() throws SQLException, InvalidVersionException {
         CompatibilityProxy proxy = new CompatibilityProxy(newConnection());
 
-        if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_2)) {
+        if (proxy.getUtPlsqlVersion().isGreaterOrEqualThan(Version.V3_1_2)) {
             Reporter reporter = new DefaultReporter(CoreReporters.UT_SONAR_TEST_REPORTER.name(), null).init(getConnection());
 
             TestRunner tr = new TestRunner()

diff --git a/src/test/java/org/utplsql/api/ReporterInspectorIT.java b/src/test/java/org/utplsql/api/ReporterInspectorIT.java
@@ -39,7 +39,7 @@ void testGetReporterInfo() throws SQLException, InvalidVersionException {
         assertEquals(infos.get(CoreReporters.UT_TEAMCITY_REPORTER.name()).getType(), ReporterInfo.Type.SQL);
         assertEquals(infos.get(CoreReporters.UT_XUNIT_REPORTER.name()).getType(), ReporterInfo.Type.SQL);
 
-        if (CoreReporters.UT_COVERAGE_COBERTURA_REPORTER.isAvailableFor(proxy.getDatabaseVersion())) {
+        if (CoreReporters.UT_COVERAGE_COBERTURA_REPORTER.isAvailableFor(proxy.getUtPlsqlVersion())) {
             assertEquals(infos.get(CoreReporters.UT_COVERAGE_COBERTURA_REPORTER.name()).getType(), ReporterInfo.Type.SQL);
         }
     }

diff --git a/src/test/java/org/utplsql/api/TestRunnerIT.java b/src/test/java/org/utplsql/api/TestRunnerIT.java
@@ -3,6 +3,9 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.function.Executable;
 import org.utplsql.api.compatibility.CompatibilityProxy;
+import org.utplsql.api.compatibility.OptionalFeatures;
+import org.utplsql.api.db.DatabaseInformation;
+import org.utplsql.api.db.DefaultDatabaseInformation;
 import org.utplsql.api.exception.InvalidVersionException;
 import org.utplsql.api.exception.SomeTestsFailedException;
 import org.utplsql.api.reporter.CoreReporters;
@@ -31,9 +34,11 @@ void runWithDefaultParameters() throws SQLException {
      */
     @Test
     void runWithoutCompatibilityCheck() throws SQLException, InvalidVersionException {
-        CompatibilityProxy proxy = new CompatibilityProxy(getConnection());
 
-        if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) {
+        DatabaseInformation databaseInformation = new DefaultDatabaseInformation();
+
+        // We can only test this for the versions of the latest TestRunnerStatement-Change
+        if ( OptionalFeatures.CLIENT_CHARACTER_SET.isAvailableFor(databaseInformation.getUtPlsqlFrameworkVersion(getConnection())) ) {
             new TestRunner()
                     .skipCompatibilityCheck(true)
                     .run(getConnection());
@@ -65,7 +70,7 @@ void failOnErrors() throws SQLException, InvalidVersionException {
 
         CompatibilityProxy proxy = new CompatibilityProxy(conn);
 
-        if (proxy.getDatabaseVersion().isGreaterOrEqualThan(Version.V3_0_3)) {
+        if (proxy.getUtPlsqlVersion().isGreaterOrEqualThan(Version.V3_0_3)) {
             Executable throwingTestRunner = () -> new TestRunner()
                     .failOnErrors(true)
                     .run(conn);