Merge pull request #82 from utPLSQL/feature/add_support_for_random_order_of_execution

pesse · web-flow · commit 7f22e43168cc · 2019-04-05T07:48:24.000+02:00
Feature/add support for random order of execution
diff --git a/.travis.yml b/.travis.yml
@@ -28,6 +28,7 @@ env:
     - UTPLSQL_VERSION="v3.1.1"
     - UTPLSQL_VERSION="v3.1.2"
     - UTPLSQL_VERSION="v3.1.3"
+    - UTPLSQL_VERSION="v3.1.6"
     - UTPLSQL_VERSION="develop"
       UTPLSQL_FILE="utPLSQL"
 
diff --git a/src/main/java/org/utplsql/api/TestRunner.java b/src/main/java/org/utplsql/api/TestRunner.java
@@ -118,6 +118,19 @@ public TestRunner setReporterFactory(ReporterFactory reporterFactory) {
         return this;
     }
 
+    public TestRunner randomTestOrder(boolean randomTestOrder ) {
+        this.options.randomTestOrder = randomTestOrder;
+        return this;
+    }
+
+    public TestRunner randomTestOrderSeed( Integer seed ) {
+        this.options.randomTestOrderSeed = seed;
+        if ( seed != null ) this.options.randomTestOrder = true;
+        return this;
+    }
+
+    public TestRunnerOptions getOptions() { return options; }
+
     private void delayedAddReporters() {
         if (reporterFactory != null) {
             reporterNames.forEach(this::addReporter);
diff --git a/src/main/java/org/utplsql/api/TestRunnerOptions.java b/src/main/java/org/utplsql/api/TestRunnerOptions.java
@@ -25,4 +25,6 @@ public class TestRunnerOptions {
     public boolean failOnErrors = false;
     public boolean skipCompatibilityCheck = false;
     public String clientCharacterSet = Charset.defaultCharset().toString();
+    public boolean randomTestOrder = false;
+    public Integer randomTestOrderSeed;
 }
diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java
@@ -31,10 +31,11 @@ public class Version implements Comparable<Version> {
     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);
+    public final static Version V3_1_7 = new Version("3.1.7", 3, 1, 7, 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, V3_1_3, V3_1_4, V3_1_5, V3_1_6)
+            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, V3_1_7)
                     .collect(toMap(Version::toString, Function.identity()));
-    public final static Version LATEST = V3_1_6;
+    public final static Version LATEST = V3_1_7;
 
     private final String origString;
     private final Integer major;
diff --git a/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java b/src/main/java/org/utplsql/api/compatibility/OptionalFeatures.java
@@ -11,7 +11,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),
-    CLIENT_CHARACTER_SET("3.1.2.2130", null);
+    CLIENT_CHARACTER_SET("3.1.2.2130", null),
+    RANDOM_EXECUTION_ORDER("3.1.7.2795", null);
 
     private final Version minVersion;
     private final Version maxVersion;
diff --git a/src/main/java/org/utplsql/api/testRunner/ActualTestRunnerStatement.java b/src/main/java/org/utplsql/api/testRunner/ActualTestRunnerStatement.java
@@ -4,6 +4,7 @@
 
 import java.sql.Connection;
 import java.sql.SQLException;
+import java.sql.Types;
 
 /**
  * Provides the call to run tests for the most actual Framework version.
@@ -22,20 +23,24 @@ 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);
+        String randomExecutionOrder = Boolean.toString(options.randomTestOrder);
 
         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 + ", " +
-                        "a_client_character_set => ?); " +
+                        "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 + ", " +
+                        "a_client_character_set   => ?, " +
+                        "a_random_test_order      => " + randomExecutionOrder + ", " +
+                        "a_random_test_order_seed => ?"+
+                        "); " +
                         "END;";
     }
 
@@ -44,6 +49,11 @@ protected int createStatement() throws SQLException {
         int curParamIdx = super.createStatement();
 
         callableStatement.setString(++curParamIdx, options.clientCharacterSet);
+        if ( options.randomTestOrderSeed == null ) {
+            callableStatement.setNull(++curParamIdx, Types.INTEGER);
+        } else {
+            callableStatement.setInt(++curParamIdx, options.randomTestOrderSeed);
+        }
 
         return curParamIdx;
     }
diff --git a/src/main/java/org/utplsql/api/testRunner/Pre317TestRunnerStatement.java b/src/main/java/org/utplsql/api/testRunner/Pre317TestRunnerStatement.java
@@ -0,0 +1,50 @@
+package org.utplsql.api.testRunner;
+
+import org.utplsql.api.TestRunnerOptions;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+/**
+ * Provides the call to run tests for the most actual Framework version.
+ * Includes fail on error
+ *
+ * @author pesse
+ */
+class Pre317TestRunnerStatement extends AbstractTestRunnerStatement {
+
+    public Pre317TestRunnerStatement(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 + ", " +
+                        "a_client_character_set => ?); " +
+                        "END;";
+    }
+
+    @Override
+    protected int createStatement() throws SQLException {
+        int curParamIdx = super.createStatement();
+
+        callableStatement.setString(++curParamIdx, options.clientCharacterSet);
+
+        return curParamIdx;
+    }
+}
diff --git a/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java b/src/main/java/org/utplsql/api/testRunner/TestRunnerStatementProvider.java
@@ -35,6 +35,8 @@ public static TestRunnerStatement getCompatibleTestRunnerStatement(Version datab
                 stmt = new Pre303TestRunnerStatement(options, conn);
             } else if (databaseVersion.isLessThan(Version.V3_1_2)) {
                 stmt = new Pre312TestRunnerStatement(options, conn);
+            } else if (databaseVersion.isLessThan(Version.V3_1_7)) {
+                stmt = new Pre317TestRunnerStatement(options, conn);
             }
 
         } catch (InvalidVersionException ignored) {
diff --git a/src/test/java/org/utplsql/api/OptionalFeaturesIT.java b/src/test/java/org/utplsql/api/OptionalFeaturesIT.java
@@ -64,4 +64,15 @@ void clientCharset() throws SQLException, InvalidVersionException {
             assertFalse(available);
         }
     }
+
+    @Test
+    void randomExecutionOrder() throws SQLException, InvalidVersionException {
+        boolean available = OptionalFeatures.RANDOM_EXECUTION_ORDER.isAvailableFor(getConnection());
+
+        if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_7)) {
+            assertTrue(available);
+        } else {
+            assertFalse(available);
+        }
+    }
 }
diff --git a/src/test/java/org/utplsql/api/TestRunnerIT.java b/src/test/java/org/utplsql/api/TestRunnerIT.java
@@ -38,7 +38,7 @@ void runWithoutCompatibilityCheck() throws SQLException, InvalidVersionException
         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())) ) {
+        if ( OptionalFeatures.RANDOM_EXECUTION_ORDER.isAvailableFor(databaseInformation.getUtPlsqlFrameworkVersion(getConnection())) ) {
             new TestRunner()
                     .skipCompatibilityCheck(true)
                     .run(getConnection());
@@ -78,4 +78,14 @@ void failOnErrors() throws SQLException, InvalidVersionException {
         }
     }
 
+    @Test
+    void runWithRandomExecutionOrder() throws SQLException {
+        CompatibilityProxy proxy = new CompatibilityProxy(getConnection());
+
+        new TestRunner()
+                .randomTestOrder(true)
+                .randomTestOrderSeed(123)
+                .run(getConnection());
+    }
+
 }
diff --git a/src/test/java/org/utplsql/api/testRunner/TestRunnerStatementProviderIT.java b/src/test/java/org/utplsql/api/testRunner/TestRunnerStatementProviderIT.java
@@ -7,32 +7,76 @@
 
 import java.sql.SQLException;
 
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 class TestRunnerStatementProviderIT extends AbstractDatabaseTest {
 
+    AbstractTestRunnerStatement getTestRunnerStatementForVersion( Version version ) throws SQLException {
+        return (AbstractTestRunnerStatement)TestRunnerStatementProvider.getCompatibleTestRunnerStatement(version, new TestRunnerOptions(), getConnection());
+    }
+
     @Test
     void testGettingPre303Version() throws SQLException {
-        TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_0_2, new TestRunnerOptions(), getConnection());
+        AbstractTestRunnerStatement stmt = getTestRunnerStatementForVersion(Version.V3_0_2);
         assertEquals(Pre303TestRunnerStatement.class, stmt.getClass());
+        assertThat(stmt.getSql(), not(containsString("a_fail_on_errors")));
+        assertThat(stmt.getSql(), not(containsString("a_client_character_set")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order_seed")));
     }
 
 
     @Test
     void testGettingPre312Version_from_303() throws SQLException {
-        TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_0_3, new TestRunnerOptions(), getConnection());
+        AbstractTestRunnerStatement stmt = getTestRunnerStatementForVersion(Version.V3_0_3);
         assertEquals(Pre312TestRunnerStatement.class, stmt.getClass());
+        assertThat(stmt.getSql(), containsString("a_fail_on_errors"));
+        assertThat(stmt.getSql(), not(containsString("a_client_character_set")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order_seed")));
     }
 
     @Test
     void testGettingPre312Version_from_311() throws SQLException {
-        TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_1_1, new TestRunnerOptions(), getConnection());
-        assertEquals(Pre312TestRunnerStatement.class, stmt.getClass());
+        AbstractTestRunnerStatement stmt = getTestRunnerStatementForVersion(Version.V3_1_1);
+        assertThat(stmt, instanceOf(Pre312TestRunnerStatement.class));
+        assertThat(stmt.getSql(), containsString("a_fail_on_errors"));
+        assertThat(stmt.getSql(), not(containsString("a_client_character_set")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order_seed")));
+    }
+
+    @Test
+    void testGettingPre317Version_from_312() throws SQLException {
+        AbstractTestRunnerStatement stmt = getTestRunnerStatementForVersion(Version.V3_1_2);
+        assertThat(stmt, instanceOf(Pre317TestRunnerStatement.class));
+        assertThat(stmt.getSql(), containsString("a_fail_on_errors"));
+        assertThat(stmt.getSql(), containsString("a_client_character_set"));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order_seed")));
+    }
+
+    @Test
+    void testGettingPre317Version_from_316() throws SQLException {
+        AbstractTestRunnerStatement stmt = getTestRunnerStatementForVersion(Version.V3_1_6);
+        assertThat(stmt, instanceOf(Pre317TestRunnerStatement.class));
+        assertThat(stmt.getSql(), containsString("a_fail_on_errors"));
+        assertThat(stmt.getSql(), containsString("a_client_character_set"));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order")));
+        assertThat(stmt.getSql(), not(containsString("a_random_test_order_seed")));
     }
 
     @Test
-    void testGettingActualVersion() throws SQLException {
-        TestRunnerStatement stmt = TestRunnerStatementProvider.getCompatibleTestRunnerStatement(Version.V3_1_2, new TestRunnerOptions(), getConnection());
-        assertEquals(ActualTestRunnerStatement.class, stmt.getClass());
+    void testGettingActualVersion_from_latest() throws SQLException {
+        AbstractTestRunnerStatement stmt = getTestRunnerStatementForVersion(Version.LATEST);
+        assertThat(stmt, instanceOf(ActualTestRunnerStatement.class));
+        assertThat(stmt.getSql(), containsString("a_fail_on_errors"));
+        assertThat(stmt.getSql(), containsString("a_client_character_set"));
+        assertThat(stmt.getSql(), containsString("a_random_test_order"));
+        assertThat(stmt.getSql(), containsString("a_random_test_order_seed"));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -25,4 +25,6 @@ public class TestRunnerOptions {`
`25`	`25`	`public boolean failOnErrors = false;`
`26`	`26`	`public boolean skipCompatibilityCheck = false;`
`27`	`27`	`public String clientCharacterSet = Charset.defaultCharset().toString();`
	`28`	`+ public boolean randomTestOrder = false;`
	`29`	`+ public Integer randomTestOrderSeed;`
`28`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,8 @@ public static TestRunnerStatement getCompatibleTestRunnerStatement(Version datab`
`35`	`35`	`stmt = new Pre303TestRunnerStatement(options, conn);`
`36`	`36`	`} else if (databaseVersion.isLessThan(Version.V3_1_2)) {`
`37`	`37`	`stmt = new Pre312TestRunnerStatement(options, conn);`
	`38`	`+ } else if (databaseVersion.isLessThan(Version.V3_1_7)) {`
	`39`	`+ stmt = new Pre317TestRunnerStatement(options, conn);`
`38`	`40`	`}`
`39`	`41`
`40`	`42`	`} catch (InvalidVersionException ignored) {`
Original file line number	Diff line number	Diff line change
`@@ -64,4 +64,15 @@ void clientCharset() throws SQLException, InvalidVersionException {`
`64`	`64`	`assertFalse(available);`
`65`	`65`	`}`
`66`	`66`	`}`
	`67`	`+`
	`68`	`+ @Test`
	`69`	`+ void randomExecutionOrder() throws SQLException, InvalidVersionException {`
	`70`	`+ boolean available = OptionalFeatures.RANDOM_EXECUTION_ORDER.isAvailableFor(getConnection());`
	`71`	`+`
	`72`	`+ if (getDatabaseVersion().isGreaterOrEqualThan(Version.V3_1_7)) {`
	`73`	`+ assertTrue(available);`
	`74`	`+ } else {`
	`75`	`+ assertFalse(available);`
	`76`	`+ }`
	`77`	`+ }`
`67`	`78`	`}`