Refactoring and changing DatabaseNotCompatibleException

pesse · Samuel Nitsche · commit ec81b5bb5514 · 2017-11-10T09:00:54.000+01:00
- TestRunnerStatement-Implementations are now hidden from public
- DatabaseNotCompatibleException now uses Version-objects instead of strings
- Version now contains a getNormalizedVersion()-method and it's
toString()-method returns the original version string
diff --git a/src/main/java/org/utplsql/api/DBHelper.java b/src/main/java/org/utplsql/api/DBHelper.java
@@ -108,12 +108,12 @@ public static void failOnVersionCompatibilityCheckFailed( Connection conn ) thro
                 // Try to find out Framework Version
                 Version v = DBHelper.getDatabaseFrameworkVersion(conn);
 
-                throw new DatabaseNotCompatibleException( v.getVersionString() );
+                throw new DatabaseNotCompatibleException( v );
             }
         }
         catch ( SQLException e )
         {
-            throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting. Reason: " + e.getMessage(), UTPLSQL_COMPATIBILITY_VERSION, "Unknown", e);
+            throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting. Reason: " + e.getMessage(), new Version(UTPLSQL_COMPATIBILITY_VERSION), new Version("Unknown"), e);
         }
     }
 
diff --git a/src/main/java/org/utplsql/api/TestRunner.java b/src/main/java/org/utplsql/api/TestRunner.java
@@ -6,7 +6,6 @@
 import org.utplsql.api.exception.SomeTestsFailedException;
 import org.utplsql.api.reporter.DocumentationReporter;
 import org.utplsql.api.reporter.Reporter;
-import org.utplsql.api.testRunner.AbstractTestRunnerStatement;
 import org.utplsql.api.testRunner.TestRunnerStatement;
 
 import java.sql.CallableStatement;
diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java
@@ -48,7 +48,8 @@ private void parseVersionString()
         }
     }
 
-    public String getOrigString() {
+    @Override
+    public String toString() {
         return origString;
     }
 
@@ -76,7 +77,7 @@ public boolean isValid() {
      *
      * @return
      */
-    public String getVersionString()
+    public String getNormalizedString()
     {
         if ( isValid() ) {
             StringBuilder sb = new StringBuilder();
diff --git a/src/main/java/org/utplsql/api/compatibility/CompatibilityProvider.java b/src/main/java/org/utplsql/api/compatibility/CompatibilityProvider.java
@@ -2,11 +2,7 @@
 
 import org.utplsql.api.DBHelper;
 import org.utplsql.api.TestRunnerOptions;
-import org.utplsql.api.Version;
-import org.utplsql.api.testRunner.AbstractTestRunnerStatement;
-import org.utplsql.api.testRunner.Pre303TestRunnerStatement;
-import org.utplsql.api.testRunner.ActualTestRunnerStatement;
-import org.utplsql.api.testRunner.TestRunnerStatement;
+import org.utplsql.api.testRunner.*;
 
 import java.sql.Connection;
 import java.sql.SQLException;
@@ -22,15 +18,6 @@ public class CompatibilityProvider {
 
     public static TestRunnerStatement getTestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException
     {
-        Version version = DBHelper.getDatabaseFrameworkVersion(conn);
-
-        AbstractTestRunnerStatement stmt = null;
-
-        if ( version.getMajor() == 3 && version.getMinor() == 0 && version.getBugfix() <= 2 )
-            stmt = new Pre303TestRunnerStatement(options, conn);
-        else
-            stmt = new ActualTestRunnerStatement(options, conn);
-
-        return stmt;
+        return TestRunnerStatementProvider.getCompatibleTestRunnerStatement(DBHelper.getDatabaseFrameworkVersion(conn), options, conn);
     }
 }
diff --git a/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java b/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java
@@ -1,6 +1,7 @@
 package org.utplsql.api.exception;
 
 import org.utplsql.api.DBHelper;
+import org.utplsql.api.Version;
 
 import java.sql.SQLException;
 
@@ -11,42 +12,42 @@
  */
 public class DatabaseNotCompatibleException extends SQLException {
 
-    private String clientVersion;
-    private String databaseVersion;
+    private Version clientVersion;
+    private Version databaseVersion;
 
-    public DatabaseNotCompatibleException( String message, String clientVersion, String databaseVersion, Throwable cause )
+    public DatabaseNotCompatibleException( String message, Version clientVersion, Version databaseVersion, Throwable cause )
     {
         super(message, cause);
 
         this.clientVersion = clientVersion;
         this.databaseVersion = databaseVersion;
     }
 
-    public DatabaseNotCompatibleException( String clientVersion, String databaseVersion, Throwable cause )
+    public DatabaseNotCompatibleException( Version clientVersion, Version databaseVersion, Throwable cause )
     {
         this("utPLSQL API (" + String.valueOf(clientVersion) + ") not compatible with database (" + String.valueOf(databaseVersion) + ")", clientVersion, databaseVersion, cause);
     }
 
-    public DatabaseNotCompatibleException( String clientVersion, String databaseVersion )
+    public DatabaseNotCompatibleException( Version clientVersion, Version databaseVersion )
     {
         this(clientVersion, databaseVersion, null);
     }
 
-    public DatabaseNotCompatibleException( String databaseVersion, Throwable cause )
+    public DatabaseNotCompatibleException( Version databaseVersion, Throwable cause )
     {
-        this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, cause );
+        this(new Version(DBHelper.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, cause );
     }
 
-    public DatabaseNotCompatibleException( String databaseVersion )
+    public DatabaseNotCompatibleException( Version databaseVersion )
     {
-        this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, null );
+        this(new Version(DBHelper.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, null );
     }
 
-    public String getClientVersion() {
+    public Version getClientVersion() {
         return clientVersion;
     }
 
-    public String getDatabaseVersion()
+    public Version getDatabaseVersion()
     {
         return databaseVersion;
     }
diff --git a/src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java b/src/main/java/org/utplsql/api/testRunner/AbstractTestRunnerStatement.java
@@ -15,7 +15,7 @@
  *
  * @author pesse
  */
-public abstract class AbstractTestRunnerStatement implements TestRunnerStatement {
+abstract class AbstractTestRunnerStatement implements TestRunnerStatement {
 
     protected TestRunnerOptions options;
     protected Connection conn;
diff --git a/src/main/java/org/utplsql/api/testRunner/ActualTestRunnerStatement.java b/src/main/java/org/utplsql/api/testRunner/ActualTestRunnerStatement.java
@@ -10,7 +10,7 @@
  *
  * @author  pesse
  */
-public class ActualTestRunnerStatement extends AbstractTestRunnerStatement {
+class ActualTestRunnerStatement extends AbstractTestRunnerStatement {
 
     public ActualTestRunnerStatement(TestRunnerOptions options, Connection connection ) throws SQLException {
         super( options, connection);
diff --git a/src/main/java/org/utplsql/api/testRunner/Pre303TestRunnerStatement.java b/src/main/java/org/utplsql/api/testRunner/Pre303TestRunnerStatement.java
@@ -10,7 +10,7 @@
  *
  * @author pesse
  */
-public class Pre303TestRunnerStatement extends AbstractTestRunnerStatement {
+class Pre303TestRunnerStatement extends AbstractTestRunnerStatement {
 
     public Pre303TestRunnerStatement(TestRunnerOptions options, Connection conn) throws SQLException {
         super(options, conn);
diff --git a/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java b/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java
@@ -0,0 +1,35 @@
+package org.utplsql.api.testRunner;
+
+import org.utplsql.api.DBHelper;
+import org.utplsql.api.TestRunnerOptions;
+import org.utplsql.api.Version;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+/** Provides different implementations of TestRunnerStatement based on the version of the database framework
+ *
+ * @author pesse
+ */
+public class TestRunnerStatementProvider {
+
+    /** Returns the TestRunnerStatement-implementation compatible with the given databaseVersion.
+     *
+     * @param databaseVersion Version of the database framework
+     * @param options TestRunnerOptions to be used
+     * @param conn Active Connection
+     * @return TestRunnerStatment compatible with the database framework
+     * @throws SQLException
+     */
+    public static TestRunnerStatement getCompatibleTestRunnerStatement(Version databaseVersion, TestRunnerOptions options, Connection conn ) throws SQLException
+    {
+        AbstractTestRunnerStatement stmt = null;
+
+        if ( databaseVersion.getMajor() == 3 && databaseVersion.getMinor() == 0 && databaseVersion.getBugfix() <= 2 )
+            stmt = new Pre303TestRunnerStatement(options, conn);
+        else
+            stmt = new ActualTestRunnerStatement(options, conn);
+
+        return stmt;
+    }
+}
diff --git a/src/test/java/org/utplsql/api/VersionObjectTest.java b/src/test/java/org/utplsql/api/VersionObjectTest.java
@@ -14,7 +14,7 @@ public void versionPatternRecognitionFull() {
         Assert.assertEquals(3, (long)v.getBugfix());
         Assert.assertEquals(1234, (long)v.getBuild());
         Assert.assertEquals(true, v.isValid());
-        Assert.assertEquals("3.1.3.1234", v.getVersionString());
+        Assert.assertEquals("3.1.3.1234", v.getNormalizedString());
     }
 
     @Test
@@ -26,7 +26,7 @@ public void versionPatternRecognitionPartial() {
         Assert.assertNull(v.getBugfix());
         Assert.assertNull(v.getBuild());
         Assert.assertEquals(true, v.isValid());
-        Assert.assertEquals("3.1", v.getVersionString());
+        Assert.assertEquals("3.1", v.getNormalizedString());
     }
 
     @Test
@@ -38,6 +38,6 @@ public void versionPatternRecognitionInvalid() {
         Assert.assertNull(v.getBugfix());
         Assert.assertNull(v.getBuild());
         Assert.assertEquals(false, v.isValid());
-        Assert.assertEquals("invalid", v.getVersionString());
+        Assert.assertEquals("invalid", v.getNormalizedString());
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -108,12 +108,12 @@ public static void failOnVersionCompatibilityCheckFailed( Connection conn ) thro`
`108`	`108`	`// Try to find out Framework Version`
`109`	`109`	`Version v = DBHelper.getDatabaseFrameworkVersion(conn);`
`110`	`110`
`111`		`- throw new DatabaseNotCompatibleException( v.getVersionString() );`
	`111`	`+ throw new DatabaseNotCompatibleException( v );`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`	`catch ( SQLException e )`
`115`	`115`	`{`
`116`		`- throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting. Reason: " + e.getMessage(), UTPLSQL_COMPATIBILITY_VERSION, "Unknown", e);`
	`116`	`+ throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting. Reason: " + e.getMessage(), new Version(UTPLSQL_COMPATIBILITY_VERSION), new Version("Unknown"), e);`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,8 @@ private void parseVersionString()`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`- public String getOrigString() {`
	`51`	`+ @Override`
	`52`	`+ public String toString() {`
`52`	`53`	`return origString;`
`53`	`54`	`}`
`54`	`55`
`@@ -76,7 +77,7 @@ public boolean isValid() {`
`76`	`77`	`*`
`77`	`78`	`* @return`
`78`	`79`	`*/`
`79`		`- public String getVersionString()`
	`80`	`+ public String getNormalizedString()`
`80`	`81`	`{`
`81`	`82`	`if ( isValid() ) {`
`82`	`83`	`StringBuilder sb = new StringBuilder();`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`package org.utplsql.api.exception;`
`2`	`2`
`3`	`3`	`import org.utplsql.api.DBHelper;`
	`4`	`+import org.utplsql.api.Version;`
`4`	`5`
`5`	`6`	`import java.sql.SQLException;`
`6`	`7`
`@@ -11,42 +12,42 @@`
`11`	`12`	`*/`
`12`	`13`	`public class DatabaseNotCompatibleException extends SQLException {`
`13`	`14`
`14`		`- private String clientVersion;`
`15`		`- private String databaseVersion;`
	`15`	`+ private Version clientVersion;`
	`16`	`+ private Version databaseVersion;`
`16`	`17`
`17`		`- public DatabaseNotCompatibleException( String message, String clientVersion, String databaseVersion, Throwable cause )`
	`18`	`+ public DatabaseNotCompatibleException( String message, Version clientVersion, Version databaseVersion, Throwable cause )`
`18`	`19`	`{`
`19`	`20`	`super(message, cause);`
`20`	`21`
`21`	`22`	`this.clientVersion = clientVersion;`
`22`	`23`	`this.databaseVersion = databaseVersion;`
`23`	`24`	`}`
`24`	`25`
`25`		`- public DatabaseNotCompatibleException( String clientVersion, String databaseVersion, Throwable cause )`
	`26`	`+ public DatabaseNotCompatibleException( Version clientVersion, Version databaseVersion, Throwable cause )`
`26`	`27`	`{`
`27`	`28`	`this("utPLSQL API (" + String.valueOf(clientVersion) + ") not compatible with database (" + String.valueOf(databaseVersion) + ")", clientVersion, databaseVersion, cause);`
`28`	`29`	`}`
`29`	`30`
`30`		`- public DatabaseNotCompatibleException( String clientVersion, String databaseVersion )`
	`31`	`+ public DatabaseNotCompatibleException( Version clientVersion, Version databaseVersion )`
`31`	`32`	`{`
`32`	`33`	`this(clientVersion, databaseVersion, null);`
`33`	`34`	`}`
`34`	`35`
`35`		`- public DatabaseNotCompatibleException( String databaseVersion, Throwable cause )`
	`36`	`+ public DatabaseNotCompatibleException( Version databaseVersion, Throwable cause )`
`36`	`37`	`{`
`37`		`- this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, cause );`
	`38`	`+ this(new Version(DBHelper.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, cause );`
`38`	`39`	`}`
`39`	`40`
`40`		`- public DatabaseNotCompatibleException( String databaseVersion )`
	`41`	`+ public DatabaseNotCompatibleException( Version databaseVersion )`
`41`	`42`	`{`
`42`		`- this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, null );`
	`43`	`+ this(new Version(DBHelper.UTPLSQL_COMPATIBILITY_VERSION), databaseVersion, null );`
`43`	`44`	`}`
`44`	`45`
`45`		`- public String getClientVersion() {`
	`46`	`+ public Version getClientVersion() {`
`46`	`47`	`return clientVersion;`
`47`	`48`	`}`
`48`	`49`
`49`		`- public String getDatabaseVersion()`
	`50`	`+ public Version getDatabaseVersion()`
`50`	`51`	`{`
`51`	`52`	`return databaseVersion;`
`52`	`53`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`	`*`
`16`	`16`	`* @author pesse`
`17`	`17`	`*/`
`18`		`-public abstract class AbstractTestRunnerStatement implements TestRunnerStatement {`
	`18`	`+abstract class AbstractTestRunnerStatement implements TestRunnerStatement {`
`19`	`19`
`20`	`20`	`protected TestRunnerOptions options;`
`21`	`21`	`protected Connection conn;`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`*`
`11`	`11`	`* @author pesse`
`12`	`12`	`*/`
`13`		`-public class ActualTestRunnerStatement extends AbstractTestRunnerStatement {`
	`13`	`+class ActualTestRunnerStatement extends AbstractTestRunnerStatement {`
`14`	`14`
`15`	`15`	`public ActualTestRunnerStatement(TestRunnerOptions options, Connection connection ) throws SQLException {`
`16`	`16`	`super( options, connection);`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public void versionPatternRecognitionFull() {`
`14`	`14`	`Assert.assertEquals(3, (long)v.getBugfix());`
`15`	`15`	`Assert.assertEquals(1234, (long)v.getBuild());`
`16`	`16`	`Assert.assertEquals(true, v.isValid());`
`17`		`- Assert.assertEquals("3.1.3.1234", v.getVersionString());`
	`17`	`+ Assert.assertEquals("3.1.3.1234", v.getNormalizedString());`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`@Test`
`@@ -26,7 +26,7 @@ public void versionPatternRecognitionPartial() {`
`26`	`26`	`Assert.assertNull(v.getBugfix());`
`27`	`27`	`Assert.assertNull(v.getBuild());`
`28`	`28`	`Assert.assertEquals(true, v.isValid());`
`29`		`- Assert.assertEquals("3.1", v.getVersionString());`
	`29`	`+ Assert.assertEquals("3.1", v.getNormalizedString());`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`@Test`
`@@ -38,6 +38,6 @@ public void versionPatternRecognitionInvalid() {`
`38`	`38`	`Assert.assertNull(v.getBugfix());`
`39`	`39`	`Assert.assertNull(v.getBuild());`
`40`	`40`	`Assert.assertEquals(false, v.isValid());`
`41`		`- Assert.assertEquals("invalid", v.getVersionString());`
	`41`	`+ Assert.assertEquals("invalid", v.getNormalizedString());`
`42`	`42`	`}`
`43`	`43`	`}`