Merge pull request #256 from zonkyio/flyway-9.9-plus

Support Flyway 9.9 - 10.5

Author: tomix26

.github/workflows/test.yml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        java: [8, 11, 15]
+        java: [8, 11, 17]
     steps:
     - name: Checkout project
       uses: actions/checkout@v3

build.gradle

@@ -26,29 +26,30 @@
 
 public class FlywayClassUtils {
 
-    private static final int flywayVersion = loadFlywayVersion();
+    private static final FlywayVersion flywayVersion = loadFlywayVersion();
 
     private FlywayClassUtils() {}
 
-    private static int loadFlywayVersion() {
+    private static FlywayVersion loadFlywayVersion() {
         try {
             ClassPathResource versionResource = new ClassPathResource("org/flywaydb/core/internal/version.txt", FlywayClassUtils.class.getClassLoader());
             if (versionResource.exists()) {
-                return Integer.parseInt(StreamUtils.copyToString(versionResource.getInputStream(), UTF_8).replaceAll("^(\\d+)\\.\\d{2,}", "$1.9").replaceAll("^(\\d+)\\.(\\d).*", "$1$2"));
+                String version = StreamUtils.copyToString(versionResource.getInputStream(), UTF_8);
+                return FlywayVersion.parseVersion(version);
             } else if (ClassUtils.hasMethod(Flyway.class, "isPlaceholderReplacement")) {
-                return 32;
+                return FlywayVersion.parseVersion("3.2");
             } else if (ClassUtils.hasMethod(Flyway.class, "getBaselineVersion")) {
-                return 31;
+                return FlywayVersion.parseVersion("3.1");
             } else {
-                return 30;
+                return FlywayVersion.parseVersion("3.0");
             }
         } catch (Exception e) {
             LoggerFactory.getLogger(FlywayClassUtils.class).error("Unexpected error when resolving flyway version", e);
-            return 0;
+            return FlywayVersion.parseVersion("0");
         }
     }
 
-    public static int getFlywayVersion() {
+    public static FlywayVersion getFlywayVersion() {
         return flywayVersion;
     }
 }

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

@@ -61,7 +61,7 @@
 
 public class FlywayDatabaseExtension implements BeanPostProcessor {
 
-    private static final int flywayVersion = FlywayClassUtils.getFlywayVersion();
+    private static final FlywayVersion flywayVersion = FlywayClassUtils.getFlywayVersion();
 
     private static final ConcurrentMap<FlywayDescriptor, Collection<ResolvedMigration>> resolvedMigrationsCache = new ConcurrentHashMap<>();
 
@@ -196,7 +196,7 @@ protected Object apply(Function<FlywayDescriptor, FlywayDatabasePreparer> creato
             try {
                 return preparer.getResult().get(0, TimeUnit.MILLISECONDS);
             } catch (InterruptedException | ExecutionException | TimeoutException e) {
-                if (preparer instanceof MigrateFlywayDatabasePreparer && flywayVersion < 70) {
+                if (preparer instanceof MigrateFlywayDatabasePreparer && flywayVersion.isLessThan("7")) {
                     return 0;
                 }
             }
@@ -267,7 +267,7 @@ protected void applyTestMigrations(FlywayOperation operation) {
             List<String> defaultLocations = flywayWrapper.getLocations();
             boolean ignoreMissingMigrations = flywayWrapper.isIgnoreMissingMigrations();
             try {
-                if (flywayVersion >= 41) {
+                if (flywayVersion.isGreaterThanOrEqualTo("4.1")) {
                     flywayWrapper.setLocations(testLocations);
                     flywayWrapper.setIgnoreMissingMigrations(true);
 

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

@@ -78,6 +78,7 @@ public class FlywayDescriptor {
     private final boolean ignoreFutureMigrations;
     private final boolean validateOnMigrate;
     private final Map<Field, Object> otherFields;
+    private final Map<Field, Object> envConfFields;
     private final Map<Class<?>, Map<Field, Object>> pluginsFields;
 
     private FlywayDescriptor(FlywayWrapper wrapper) {
@@ -93,6 +94,7 @@ private FlywayDescriptor(FlywayWrapper wrapper) {
         this.validateOnMigrate = wrapper.isValidateOnMigrate();
 
         this.otherFields = getFields(wrapper.getConfig(), OTHER_FIELDS);
+        this.envConfFields = getFields(wrapper.getEnvConfig(), PLUGIN_FIELDS);
 
         Map<Class<?>, Map<Field, Object>> pluginsFields = new HashMap<>();
         List<Object> plugins = wrapper.getConfigurationExtensions();
@@ -108,8 +110,6 @@ public static FlywayDescriptor from(FlywayWrapper wrapper) {
     }
 
     public void applyTo(FlywayWrapper wrapper) {
-        Object config = wrapper.getConfig();
-
         wrapper.setLocations(locations);
         wrapper.setSchemas(schemas);
         wrapper.setTable(table);
@@ -121,7 +121,8 @@ public void applyTo(FlywayWrapper wrapper) {
         wrapper.setIgnoreFutureMigrations(ignoreFutureMigrations);
         wrapper.setValidateOnMigrate(validateOnMigrate);
 
-        setFields(config, otherFields);
+        setFields(wrapper.getConfig(), otherFields);
+        setFields(wrapper.getEnvConfig(), envConfFields);
 
         List<Object> plugins = wrapper.getConfigurationExtensions();
         for (Object plugin : plugins) {
@@ -186,6 +187,7 @@ public boolean equals(Object o) {
                 && Objects.equals(sqlMigrationSeparator, that.sqlMigrationSeparator)
                 && Objects.equals(sqlMigrationSuffixes, that.sqlMigrationSuffixes)
                 && Objects.equals(otherFields, that.otherFields)
+                && Objects.equals(envConfFields, that.envConfFields)
                 && Objects.equals(pluginsFields, that.pluginsFields);
     }
 
@@ -195,27 +197,31 @@ public int hashCode() {
                 sqlMigrationPrefix, repeatableSqlMigrationPrefix,
                 sqlMigrationSeparator, sqlMigrationSuffixes,
                 ignoreMissingMigrations, ignoreFutureMigrations,
-                validateOnMigrate, otherFields, pluginsFields);
+                validateOnMigrate, otherFields, envConfFields, pluginsFields);
     }
 
     private static void setCollection(Field field, Object target, Collection<?> value) {
         Collection collection = (Collection) getField(field, target);
         if (collection != null) {
-            collection.clear();
-            collection.addAll(value);
-        } else {
-            setField(field, target, value);
+            try {
+                collection.clear();
+                collection.addAll(value);
+                return;
+            } catch (UnsupportedOperationException e) {}
         }
+        setField(field, target, Lists.newArrayList(value));
     }
 
     private static void setMap(Field field, Object target, Map<?, ?> value) {
         Map map = (Map) getField(field, target);
         if (map != null) {
-            map.clear();
-            map.putAll(value);
-        } else {
-            setField(field, target, value);
+            try {
+                map.clear();
+                map.putAll(value);
+                return;
+            } catch (UnsupportedOperationException e) {}
         }
+        setField(field, target, Maps.newHashMap(value));
     }
 
     private static void setArray(Field field, Object config, List<?> value) {
@@ -227,28 +233,34 @@ private static void setArray(Field field, Object config, List<?> value) {
     private static Map<Field, Object> getFields(Object targetObject, FieldFilter fieldFilter) {
         Map<Field, Object> fieldValues = new HashMap<>();
 
-        Class<?> objectClass = targetObject.getClass();
-        doWithFields(objectClass, field -> {
-            makeAccessible(field);
-            Object value = getField(field, targetObject);
-
-            if (value != null) {
-                if (Collection.class.isAssignableFrom(field.getType())) {
-                    value = Lists.newArrayList((Collection<?>) value);
-                } else if (Map.class.isAssignableFrom(field.getType())) {
-                    value = Maps.newHashMap((Map<?, ?>) value);
-                } else if (field.getType().isArray()) {
-                    value = Lists.newArrayList((Object[]) value);
+        if (targetObject != null) {
+            Class<?> objectClass = targetObject.getClass();
+            doWithFields(objectClass, field -> {
+                makeAccessible(field);
+                Object value = getField(field, targetObject);
+
+                if (value != null) {
+                    if (Collection.class.isAssignableFrom(field.getType())) {
+                        value = Lists.newArrayList((Collection<?>) value);
+                    } else if (Map.class.isAssignableFrom(field.getType())) {
+                        value = Maps.newHashMap((Map<?, ?>) value);
+                    } else if (field.getType().isArray()) {
+                        value = Lists.newArrayList((Object[]) value);
+                    }
                 }
-            }
 
-            fieldValues.put(field, value);
-        }, fieldFilter);
+                fieldValues.put(field, value);
+            }, fieldFilter);
+        }
 
         return fieldValues;
     }
 
     private static void setFields(Object targetObject, Map<Field, Object> fieldValues) {
+        if (targetObject == null) {
+            return;
+        }
+
         fieldValues.forEach((field, value) -> {
             makeAccessible(field);
 

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

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2023 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.zonky.test.db.flyway;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class FlywayVersion implements Comparable<FlywayVersion> {
+
+    private final int[] parts;
+
+    public static FlywayVersion parseVersion(String version) {
+        String[] split = version.split("\\.");
+        int[] parts = Arrays.stream(split).mapToInt(Integer::parseInt).toArray();
+        return new FlywayVersion(parts);
+    }
+
+    private FlywayVersion(int[] parts) {
+        this.parts = parts;
+    }
+
+    public boolean isGreaterThan(String version) {
+        return compareTo(parseVersion(version)) > 0;
+    }
+
+    public boolean isGreaterThanOrEqualTo(String version) {
+        return compareTo(parseVersion(version)) >= 0;
+    }
+
+    public boolean isLessThan(String version) {
+        return compareTo(parseVersion(version)) < 0;
+    }
+
+    public boolean isLessThanOrEqualTo(String version) {
+        return compareTo(parseVersion(version)) <= 0;
+    }
+
+    @Override
+    public int compareTo(FlywayVersion other) {
+        for (int i = 0; i < this.parts.length || i < other.parts.length; i++) {
+            int thisPart = i < this.parts.length ? this.parts[i] : 0;
+            int otherPart = i < other.parts.length ? other.parts[i] : 0;
+
+            if (thisPart > otherPart) {
+                return 1;
+            } else if (thisPart < otherPart) {
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        FlywayVersion that = (FlywayVersion) o;
+        return Arrays.equals(parts, that.parts);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(parts);
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.stream(parts)
+                .mapToObj(String::valueOf)
+                .collect(Collectors.joining("."));
+    }
+}