Introduced DatabaseNotComptabileException

Samuel Nitsche · Samuel Nitsche · commit 4fbda90b8b28 · 2017-11-05T14:58:21.000+01:00
Also added some tests for getting Framework version and fixed error in getting it
diff --git a/src/main/java/org/utplsql/api/DBHelper.java b/src/main/java/org/utplsql/api/DBHelper.java
@@ -1,6 +1,7 @@
 package org.utplsql.api;
 
 import oracle.jdbc.OracleTypes;
+import org.utplsql.api.exception.DatabaseNotCompatibleException;
 
 import java.sql.*;
 
@@ -94,20 +95,25 @@ public static boolean versionCompatibilityCheck(Connection conn)
     }
 
 
-    /** Checks if actual API-version is compatible with utPLSQL database version and throws a RuntimeException if not
-     * Throws a RuntimeException if version compatibility can not be checked.
+    /** Checks if actual API-version is compatible with utPLSQL database version and throws a DatabaseNotCompatibleException if not
+     * Throws a DatabaseNotCompatibleException if version compatibility can not be checked.
      *
      * @param conn Active db connection
      */
-    public static void failOnVersionCompatibilityCheckFailed( Connection conn )
+    public static void failOnVersionCompatibilityCheckFailed( Connection conn ) throws DatabaseNotCompatibleException
     {
         try {
             if (!versionCompatibilityCheck(conn))
-                throw new RuntimeException("API-Version " + UTPLSQL_COMPATIBILITY_VERSION + " not compatible with database. Aborting.");
+            {
+                // Try to find out Framework Version
+                Version v = DBHelper.getDatabaseFrameworkVersion(conn);
+
+                throw new DatabaseNotCompatibleException( v.getVersionString() );
+            }
         }
         catch ( SQLException e )
         {
-            throw new RuntimeException("Compatibility-check failed with error. Aborting.", e);
+            throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting.", UTPLSQL_COMPATIBILITY_VERSION, "Unknown", e);
         }
     }
 
@@ -120,9 +126,9 @@ public static void failOnVersionCompatibilityCheckFailed( Connection conn )
     public static Version getDatabaseFrameworkVersion( Connection conn )
             throws SQLException {
         Version result = new Version("");
-        try (Statement stmt = conn.prepareStatement("select ut_runner.version() from dual"))
+        try (PreparedStatement stmt = conn.prepareStatement("select ut_runner.version() from dual"))
         {
-            ResultSet rs = stmt.getResultSet();
+            ResultSet rs = stmt.executeQuery();
 
             if ( rs.next() )
                 result = new Version(rs.getString(1));
diff --git a/src/main/java/org/utplsql/api/TestRunner.java b/src/main/java/org/utplsql/api/TestRunner.java
@@ -1,5 +1,6 @@
 package org.utplsql.api;
 
+import org.utplsql.api.exception.DatabaseNotCompatibleException;
 import org.utplsql.api.exception.SomeTestsFailedException;
 import org.utplsql.api.reporter.DocumentationReporter;
 import org.utplsql.api.reporter.Reporter;
@@ -84,7 +85,7 @@ public TestRunner failOnErrors(boolean failOnErrors) {
         return this;
     }
 
-    public void run(Connection conn) throws SomeTestsFailedException, SQLException {
+    public void run(Connection conn) throws SomeTestsFailedException, SQLException, DatabaseNotCompatibleException {
 
         // First of all check version compatibility
         DBHelper.failOnVersionCompatibilityCheckFailed(conn);
diff --git a/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java b/src/main/java/org/utplsql/api/exception/DatabaseNotCompatibleException.java
@@ -2,12 +2,14 @@
 
 import org.utplsql.api.DBHelper;
 
+import java.sql.SQLException;
+
 /** Custom exception to indicate API is not compatible with database framework
  *
  * @author pesse
  *
  */
-public class DatabaseNotCompatibleException extends Exception {
+public class DatabaseNotCompatibleException extends SQLException {
 
     private String clientVersion;
     private String databaseVersion;
@@ -35,6 +37,11 @@ public DatabaseNotCompatibleException( String databaseVersion, Throwable cause )
         this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, cause );
     }
 
+    public DatabaseNotCompatibleException( String databaseVersion )
+    {
+        this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, null );
+    }
+
     public String getClientVersion() {
         return clientVersion;
     }
diff --git a/src/test/java/org/utplsql/api/DBHelperTest.java b/src/test/java/org/utplsql/api/DBHelperTest.java
@@ -34,4 +34,17 @@ public void incompatibleVersion() {
         }
     }
 
+    @Test
+    public void getFrameworkVersion()
+    {
+        try {
+            Version v = DBHelper.getDatabaseFrameworkVersion(db.newConnection());
+            Assert.assertEquals(true, v.isValid());
+        } catch (SQLException e)
+        {
+            e.printStackTrace();
+            Assert.fail();
+        }
+    }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`package org.utplsql.api;`
`2`	`2`
`3`	`3`	`import oracle.jdbc.OracleTypes;`
	`4`	`+import org.utplsql.api.exception.DatabaseNotCompatibleException;`
`4`	`5`
`5`	`6`	`import java.sql.*;`
`6`	`7`
`@@ -94,20 +95,25 @@ public static boolean versionCompatibilityCheck(Connection conn)`
`94`	`95`	`}`
`95`	`96`
`96`	`97`
`97`		`- /** Checks if actual API-version is compatible with utPLSQL database version and throws a RuntimeException if not`
`98`		`- * Throws a RuntimeException if version compatibility can not be checked.`
	`98`	`+ /** Checks if actual API-version is compatible with utPLSQL database version and throws a DatabaseNotCompatibleException if not`
	`99`	`+ * Throws a DatabaseNotCompatibleException if version compatibility can not be checked.`
`99`	`100`	`*`
`100`	`101`	`* @param conn Active db connection`
`101`	`102`	`*/`
`102`		`- public static void failOnVersionCompatibilityCheckFailed( Connection conn )`
	`103`	`+ public static void failOnVersionCompatibilityCheckFailed( Connection conn ) throws DatabaseNotCompatibleException`
`103`	`104`	`{`
`104`	`105`	`try {`
`105`	`106`	`if (!versionCompatibilityCheck(conn))`
`106`		`- throw new RuntimeException("API-Version " + UTPLSQL_COMPATIBILITY_VERSION + " not compatible with database. Aborting.");`
	`107`	`+ {`
	`108`	`+ // Try to find out Framework Version`
	`109`	`+ Version v = DBHelper.getDatabaseFrameworkVersion(conn);`
	`110`	`+`
	`111`	`+ throw new DatabaseNotCompatibleException( v.getVersionString() );`
	`112`	`+ }`
`107`	`113`	`}`
`108`	`114`	`catch ( SQLException e )`
`109`	`115`	`{`
`110`		`- throw new RuntimeException("Compatibility-check failed with error. Aborting.", e);`
	`116`	`+ throw new DatabaseNotCompatibleException("Compatibility-check failed with error. Aborting.", UTPLSQL_COMPATIBILITY_VERSION, "Unknown", e);`
`111`	`117`	`}`
`112`	`118`	`}`
`113`	`119`
`@@ -120,9 +126,9 @@ public static void failOnVersionCompatibilityCheckFailed( Connection conn )`
`120`	`126`	`public static Version getDatabaseFrameworkVersion( Connection conn )`
`121`	`127`	`throws SQLException {`
`122`	`128`	`Version result = new Version("");`
`123`		`- try (Statement stmt = conn.prepareStatement("select ut_runner.version() from dual"))`
	`129`	`+ try (PreparedStatement stmt = conn.prepareStatement("select ut_runner.version() from dual"))`
`124`	`130`	`{`
`125`		`- ResultSet rs = stmt.getResultSet();`
	`131`	`+ ResultSet rs = stmt.executeQuery();`
`126`	`132`
`127`	`133`	`if ( rs.next() )`
`128`	`134`	`result = new Version(rs.getString(1));`
Original file line number	Diff line number	Diff line change
`@@ -2,12 +2,14 @@`
`2`	`2`
`3`	`3`	`import org.utplsql.api.DBHelper;`
`4`	`4`
	`5`	`+import java.sql.SQLException;`
	`6`	`+`
`5`	`7`	`/** Custom exception to indicate API is not compatible with database framework`
`6`	`8`	`*`
`7`	`9`	`* @author pesse`
`8`	`10`	`*`
`9`	`11`	`*/`
`10`		`-public class DatabaseNotCompatibleException extends Exception {`
	`12`	`+public class DatabaseNotCompatibleException extends SQLException {`
`11`	`13`
`12`	`14`	`private String clientVersion;`
`13`	`15`	`private String databaseVersion;`
`@@ -35,6 +37,11 @@ public DatabaseNotCompatibleException( String databaseVersion, Throwable cause )`
`35`	`37`	`this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, cause );`
`36`	`38`	`}`
`37`	`39`
	`40`	`+ public DatabaseNotCompatibleException( String databaseVersion )`
	`41`	`+ {`
	`42`	`+ this(DBHelper.UTPLSQL_COMPATIBILITY_VERSION, databaseVersion, null );`
	`43`	`+ }`
	`44`	`+`
`38`	`45`	`public String getClientVersion() {`
`39`	`46`	`return clientVersion;`
`40`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,4 +34,17 @@ public void incompatibleVersion() {`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ @Test`
	`38`	`+ public void getFrameworkVersion()`
	`39`	`+ {`
	`40`	`+ try {`
	`41`	`+ Version v = DBHelper.getDatabaseFrameworkVersion(db.newConnection());`
	`42`	`+ Assert.assertEquals(true, v.isValid());`
	`43`	`+ } catch (SQLException e)`
	`44`	`+ {`
	`45`	`+ e.printStackTrace();`
	`46`	`+ Assert.fail();`
	`47`	`+ }`
	`48`	`+ }`
	`49`	`+`
`37`	`50`	`}`