Merge pull request #115 from zonkyio/flyway-6.1.0-plus

#114 Implement support for Flyway 6.1.0 and above

Author: tomix26

build.gradle

@@ -27,8 +27,14 @@ ext {
             [core: '5.1.4', test: '5.1.0'],
             [core: '5.2.4', test: '5.2.4'],
             [core: '6.0.2', test: '6.0.0'],
-            [core: '6.0.7', test: '6.0.0'],
-            
+            [core: '6.0.8', test: '6.0.0'],
+            [core: '6.1.4', test: '6.1.0'],
+            [core: '6.2.4', test: '6.1.0'],
+            [core: '6.3.2', test: '6.1.0'],
+            [core: '6.3.3', test: '6.3.3'],
+            [core: '6.4.4', test: '6.4.0'],
+            [core: '6.5.3', test: '6.4.0'],
+
             [core: '5.0.7', test: '5.0.0'] // default version
     ]
     embeddedPostgresVersions = ['9.4.25', '9.5.20', '9.6.16', '10.11.0', '11.6.0', '12.1.0']

embedded-database-spring-test/src/main/java/io/zonky/test/db/flyway/FlywayConfigSnapshot.java

@@ -31,11 +31,13 @@ public class FlywayConfigSnapshot {
     private final Object[] callbacks; // the callbacks are modified during the migration
 
     // included in equals and hashCode methods
-    // but it will work only for empty arrays (that is common use-case)
+    // but it will work only for empty arrays or null values (that is common use-case)
     // because of missing equals and hashCode methods
     // on classes implementing these interfaces
     private final List<MigrationResolver> resolvers;
     private final List<Object> errorHandlers;
+    private final Object resourceProvider;
+    private final Object javaMigrationClassProvider;
 
     // included in equals and hashCode methods
     private final MigrationVersion baselineVersion;
@@ -48,6 +50,7 @@ public class FlywayConfigSnapshot {
     private final Map<String, String> placeholders;
     private final String table;
     private final String tablespace;
+    private final String defaultSchemaName;
     private final String baselineDescription;
     private final String undoSqlMigrationPrefix;
     private final String repeatableSqlMigrationPrefix;
@@ -67,10 +70,12 @@ public class FlywayConfigSnapshot {
     private final boolean ignoreIgnoredMigrations;
     private final boolean ignorePendingMigrations;
     private final boolean ignoreFutureMigrations;
+    private final boolean validateMigrationNaming;
     private final boolean validateOnMigrate;
     private final boolean cleanOnValidationError;
     private final boolean cleanDisabled;
     private final boolean allowMixedMigrations;
+    private final boolean createSchemas;
     private final boolean mixed;
     private final boolean group;
     private final String installedBy;
@@ -79,6 +84,7 @@ public class FlywayConfigSnapshot {
     private final boolean batch;
     private final boolean oracleSqlPlus;
     private final boolean oracleSqlplusWarn;
+    private final boolean outputQueryResults;
     private final int connectRetries;
 
     public FlywayConfigSnapshot(Flyway flyway) {
@@ -226,8 +232,32 @@ public FlywayConfigSnapshot(Flyway flyway) {
 
         if (flywayVersion >= 60 && isFlywayPro) {
             this.oracleSqlplusWarn = getValue(config, "isOracleSqlplusWarn");
+            this.outputQueryResults = getValue(config, "outputQueryResults");
         } else {
             this.oracleSqlplusWarn = false;
+            this.outputQueryResults = true;
+        }
+
+        if (flywayVersion >= 61) {
+            this.defaultSchemaName = getValue(config, "getDefaultSchema");
+        } else {
+            this.defaultSchemaName = null;
+        }
+
+        if (flywayVersion >= 62) {
+            this.validateMigrationNaming = getValue(config, "isValidateMigrationNaming");
+        } else {
+            this.validateMigrationNaming = false;
+        }
+
+        if (flywayVersion >= 65) {
+            this.resourceProvider = getValue(config, "getResourceProvider");
+            this.javaMigrationClassProvider = getValue(config, "getJavaMigrationClassProvider");
+            this.createSchemas = getValue(config, "getCreateSchemas");
+        } else {
+            this.resourceProvider = null;
+            this.javaMigrationClassProvider = null;
+            this.createSchemas = true;
         }
     }
 
@@ -263,6 +293,14 @@ public List<MigrationResolver> getResolvers() {
         return resolvers;
     }
 
+    public Object getResourceProvider() {
+        return resourceProvider;
+    }
+
+    public Object getJavaMigrationClassProvider() {
+        return javaMigrationClassProvider;
+    }
+
     public boolean isSkipDefaultResolvers() {
         return skipDefaultResolvers;
     }
@@ -327,6 +365,10 @@ public String getTablespace() {
         return tablespace;
     }
 
+    public String getDefaultSchemaName() {
+        return defaultSchemaName;
+    }
+
     public List<String> getSchemas() {
         return schemas;
     }
@@ -371,6 +413,10 @@ public boolean isIgnoreFutureMigrations() {
         return ignoreFutureMigrations;
     }
 
+    public boolean isValidateMigrationNaming() {
+        return validateMigrationNaming;
+    }
+
     public boolean isValidateOnMigrate() {
         return validateOnMigrate;
     }
@@ -387,6 +433,10 @@ public boolean isAllowMixedMigrations() {
         return allowMixedMigrations;
     }
 
+    public boolean isCreateSchemas() {
+        return createSchemas;
+    }
+
     public boolean isMixed() {
         return mixed;
     }
@@ -427,6 +477,10 @@ public boolean isOracleSqlplusWarn() {
         return oracleSqlplusWarn;
     }
 
+    public boolean isOutputQueryResults() {
+        return outputQueryResults;
+    }
+
     public int getConnectRetries() {
         return connectRetries;
     }
@@ -445,20 +499,25 @@ public boolean equals(Object o) {
                 ignoreIgnoredMigrations == that.ignoreIgnoredMigrations &&
                 ignorePendingMigrations == that.ignorePendingMigrations &&
                 ignoreFutureMigrations == that.ignoreFutureMigrations &&
+                validateMigrationNaming == that.validateMigrationNaming &&
                 validateOnMigrate == that.validateOnMigrate &&
                 cleanOnValidationError == that.cleanOnValidationError &&
                 cleanDisabled == that.cleanDisabled &&
                 allowMixedMigrations == that.allowMixedMigrations &&
+                createSchemas == that.createSchemas &&
                 mixed == that.mixed &&
                 group == that.group &&
                 dryRun == that.dryRun &&
                 stream == that.stream &&
                 batch == that.batch &&
                 oracleSqlPlus == that.oracleSqlPlus &&
                 oracleSqlplusWarn == that.oracleSqlplusWarn &&
+                outputQueryResults == that.outputQueryResults &&
                 connectRetries == that.connectRetries &&
                 Objects.equals(resolvers, that.resolvers) &&
                 Objects.equals(errorHandlers, that.errorHandlers) &&
+                Objects.equals(resourceProvider, that.resourceProvider) &&
+                Objects.equals(javaMigrationClassProvider, that.javaMigrationClassProvider) &&
                 Objects.equals(baselineVersion, that.baselineVersion) &&
                 Objects.equals(target, that.target) &&
                 Objects.equals(locations, that.locations) &&
@@ -469,6 +528,7 @@ public boolean equals(Object o) {
                 Objects.equals(placeholders, that.placeholders) &&
                 Objects.equals(table, that.table) &&
                 Objects.equals(tablespace, that.tablespace) &&
+                Objects.equals(defaultSchemaName, that.defaultSchemaName) &&
                 Objects.equals(baselineDescription, that.baselineDescription) &&
                 Objects.equals(undoSqlMigrationPrefix, that.undoSqlMigrationPrefix) &&
                 Objects.equals(repeatableSqlMigrationPrefix, that.repeatableSqlMigrationPrefix) &&
@@ -485,16 +545,17 @@ public boolean equals(Object o) {
     @Override
     public int hashCode() {
         return Objects.hash(
-                resolvers, errorHandlers,
+                resolvers, errorHandlers, resourceProvider, javaMigrationClassProvider,
                 baselineVersion, target, locations, schemas, sqlMigrationSuffixes,
-                javaMigrations, errorOverrides, placeholders, table, tablespace,
+                javaMigrations, errorOverrides, placeholders, table, tablespace, defaultSchemaName,
                 baselineDescription, undoSqlMigrationPrefix, repeatableSqlMigrationPrefix,
                 sqlMigrationSeparator, sqlMigrationPrefix, placeholderPrefix,
                 placeholderSuffix, encoding, initSql, licenseKey,
                 skipDefaultResolvers, skipDefaultCallbacks, placeholderReplacement, baselineOnMigrate,
                 outOfOrder, ignoreMissingMigrations, ignoreIgnoredMigrations, ignorePendingMigrations,
-                ignoreFutureMigrations, validateOnMigrate, cleanOnValidationError, cleanDisabled,
-                allowMixedMigrations, mixed, group, installedBy, dryRun, stream, batch,
-                oracleSqlPlus, oracleSqlplusWarn, connectRetries);
+                ignoreFutureMigrations, validateMigrationNaming, validateOnMigrate,
+                cleanOnValidationError, cleanDisabled, allowMixedMigrations, createSchemas,
+                mixed, group, installedBy, dryRun, stream, batch,
+                oracleSqlPlus, oracleSqlplusWarn, outputQueryResults, connectRetries);
     }
 }

embedded-database-spring-test/src/main/java/io/zonky/test/db/flyway/OptimizedFlywayTestExecutionListener.java

@@ -25,7 +25,6 @@
 import org.flywaydb.core.api.MigrationVersion;
 import org.flywaydb.core.api.resolver.MigrationResolver;
 import org.flywaydb.core.api.resolver.ResolvedMigration;
-import org.flywaydb.core.internal.database.DatabaseFactory;
 import org.flywaydb.core.internal.util.scanner.Scanner;
 import org.flywaydb.test.annotation.FlywayTest;
 import org.flywaydb.test.junit.FlywayTestExecutionListener;
@@ -51,7 +50,6 @@
 import static io.zonky.test.db.util.ReflectionUtils.getField;
 import static io.zonky.test.db.util.ReflectionUtils.invokeConstructor;
 import static io.zonky.test.db.util.ReflectionUtils.invokeMethod;
-import static io.zonky.test.db.util.ReflectionUtils.invokeStaticMethod;
 
 /**
  * Optimized implementation of the {@link org.flywaydb.test.junit.FlywayTestExecutionListener}
@@ -254,41 +252,24 @@ protected static MigrationResolver createMigrationResolver(Flyway flyway, String
         try {
             setFlywayLocations(flyway, locations);
 
-            if (flywayVersion >= 60) {
-                Object configuration = getField(flyway, "configuration");
-                Object jdbcConnectionFactory = invokeConstructor("org.flywaydb.core.internal.jdbc.JdbcConnectionFactory", invokeMethod(configuration, "getDataSource"), 0);
-                closeConnection(invokeMethod(jdbcConnectionFactory, "openConnection")); // closes an internal unused connection
-                Object sqlScriptFactory = invokeStaticMethod(DatabaseFactory.class, "createSqlScriptFactory", jdbcConnectionFactory, configuration);
-                Object sqlScriptExecutorFactory = invokeStaticMethod(DatabaseFactory.class, "createSqlScriptExecutorFactory", jdbcConnectionFactory);
-                Object scanner;
-
-                try {
-                    scanner = invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
-                            ClassUtils.forName("org.flywaydb.core.api.migration.JavaMigration", classLoader),
-                            Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
-                            invokeMethod(configuration, "getClassLoader"),
-                            invokeMethod(configuration, "getEncoding"));
-                } catch (RuntimeException ex) {
-                    scanner = invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
-                            Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
-                            invokeMethod(configuration, "getClassLoader"),
-                            invokeMethod(configuration, "getEncoding"));
-                }
-
+            if (flywayVersion >= 63) {
+                Object scanner = createScanner(flyway);
+                Object sqlScriptFactory = createMock("org.flywaydb.core.internal.sqlscript.SqlScriptFactory");
+                Object sqlScriptExecutorFactory = createMock("org.flywaydb.core.internal.sqlscript.SqlScriptExecutorFactory");
+                Object parsingContext = invokeConstructor("org.flywaydb.core.internal.parser.ParsingContext");
+                return invokeMethod(flyway, "createMigrationResolver", scanner, scanner, sqlScriptExecutorFactory, sqlScriptFactory, parsingContext);
+            } else if (flywayVersion >= 60) {
+                Object scanner = createScanner(flyway);
+                Object sqlScriptFactory = createMock("org.flywaydb.core.internal.sqlscript.SqlScriptFactory");
+                Object sqlScriptExecutorFactory = createMock("org.flywaydb.core.internal.sqlscript.SqlScriptExecutorFactory");
                 return invokeMethod(flyway, "createMigrationResolver", scanner, scanner, sqlScriptExecutorFactory, sqlScriptFactory);
             } else if (flywayVersion >= 52) {
-                Object configuration = getField(flyway, "configuration");
-                Object database = invokeStaticMethod(DatabaseFactory.class, "createDatabase", flyway, false);
-                closeConnection(invokeMethod(database, "getMainConnection")); // closes an internal unused connection
-                Object factory = invokeMethod(database, "createSqlStatementBuilderFactory");
-                Object scanner = invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
-                        Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
-                        invokeMethod(configuration, "getClassLoader"),
-                        invokeMethod(configuration, "getEncoding"));
-                return invokeMethod(flyway, "createMigrationResolver", database, scanner, scanner, factory);
+                Object scanner = createScanner(flyway);
+                Object placeholderReplacer = createMock("org.flywaydb.core.internal.placeholder.PlaceholderReplacer");
+                Object factory = invokeConstructor("org.flywaydb.core.internal.database.postgresql.PostgreSQLSqlStatementBuilderFactory", placeholderReplacer);
+                return invokeMethod(flyway, "createMigrationResolver", null, scanner, scanner, factory);
             } else if (flywayVersion >= 51) {
-                Object configuration = getField(flyway, "configuration");
-                Object scanner = invokeConstructor(Scanner.class, configuration);
+                Object scanner = createScanner(flyway);
                 Object placeholderReplacer = invokeMethod(flyway, "createPlaceholderReplacer");
                 return invokeMethod(flyway, "createMigrationResolver", null, scanner, placeholderReplacer);
             } else if (flywayVersion >= 40) {
@@ -302,6 +283,64 @@ protected static MigrationResolver createMigrationResolver(Flyway flyway, String
         }
     }
 
+    protected static Object createScanner(Flyway flyway) throws ClassNotFoundException {
+        Object configuration = getField(flyway, "configuration");
+
+        if (flywayVersion >= 63) {
+            try {
+                // this code is only for version 6.3.3 and above
+                return invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
+                        ClassUtils.forName("org.flywaydb.core.api.migration.JavaMigration", classLoader),
+                        Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
+                        invokeMethod(configuration, "getClassLoader"),
+                        invokeMethod(configuration, "getEncoding"),
+                        getField(flyway, "resourceNameCache"),
+                        getField(flyway, "locationScannerCache"));
+            } catch (RuntimeException ex) {
+                if (flywayVersion > 63) {
+                    throw ex;
+                }
+                // try next branch
+            }
+        }
+        if (flywayVersion >= 61) {
+            return invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
+                    ClassUtils.forName("org.flywaydb.core.api.migration.JavaMigration", classLoader),
+                    Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
+                    invokeMethod(configuration, "getClassLoader"),
+                    invokeMethod(configuration, "getEncoding"),
+                    getField(flyway, "resourceNameCache"));
+        }
+        if (flywayVersion >= 60) {
+            try {
+                // this code is only for version 6.0.7 and above
+                return invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
+                        ClassUtils.forName("org.flywaydb.core.api.migration.JavaMigration", classLoader),
+                        Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
+                        invokeMethod(configuration, "getClassLoader"),
+                        invokeMethod(configuration, "getEncoding"));
+            } catch (RuntimeException ex) {
+                // try next branch
+            }
+        }
+        if (flywayVersion >= 52) {
+            return invokeConstructor("org.flywaydb.core.internal.scanner.Scanner",
+                    Arrays.asList((Object[]) invokeMethod(configuration, "getLocations")),
+                    invokeMethod(configuration, "getClassLoader"),
+                    invokeMethod(configuration, "getEncoding"));
+        }
+        if (flywayVersion >= 51) {
+            return invokeConstructor(Scanner.class, configuration);
+        }
+
+        throw new IllegalStateException("Unsupported flyway version: " + flywayVersion);
+    }
+
+    protected static Object createMock(String className) throws ClassNotFoundException {
+        Class<?> proxyInterface = ClassUtils.forName(className, classLoader);
+        return ProxyFactory.getProxy(proxyInterface, (MethodInterceptor) invocation -> null);
+    }
+
     protected Flyway getFlywayBean(ApplicationContext applicationContext, FlywayTest annotation) {
         if (flywayNameAttributePresent) {
             return invokeMethod(this, "getBean", applicationContext, Flyway.class, annotation.flywayName());
@@ -348,16 +387,6 @@ protected static FlywayDataSourceContext getDataSourceContext(ApplicationContext
         return null;
     }
 
-    protected static void closeConnection(AutoCloseable connection) {
-        if (connection != null) {
-            try {
-                connection.close();
-            } catch (Exception e) {
-                // ignored
-            }
-        }
-    }
-
     /**
      * Customized implementation because {@link AnnotationUtils#findAnnotation(AnnotatedElement, Class)} method
      * operates generically on annotated elements and not execute specialized search algorithms for classes and methods.