From 610e8eba736a31486bbfbf053481e50fcf6c8331 Mon Sep 17 00:00:00 2001 From: Chris Cranford Date: Thu, 13 Jan 2022 12:26:36 -0500 Subject: [PATCH] DBZ-4548 Fix DatabaseVersionResolver comparison logic --- .../junit/DatabaseVersionResolver.java | 31 +++-- .../junit/DatabaseVersionResolverTest.java | 107 ++++++++++++++++++ 2 files changed, 128 insertions(+), 10 deletions(-) create mode 100644 debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolverTest.java diff --git a/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolver.java b/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolver.java index f9fb2be1d..acfc761a8 100644 --- a/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolver.java +++ b/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolver.java @@ -45,13 +45,13 @@ public boolean isLessThan(int major, int minor, int patch) { return true; } else if (dbVersionMajor == major) { - if (minor == -1 || dbVersionMinor < minor) { + if (minor != -1 && dbVersionMinor < minor) { + // i.e. db 11.2 and annotation is 11.3 return true; } else if (dbVersionMinor == minor) { - if (patch == -1 || dbVersionPatch < patch) { - return true; - } + // i.e. db 11.2.1 and annotation is 11.2.2 + return patch != -1 && dbVersionPatch < patch; } } return false; @@ -81,14 +81,25 @@ public boolean isGreaterThan(int major, int minor, int patch) { return true; } else if (dbVersionMajor == major) { - if (minor == -1 || dbVersionMinor > minor) { - return true; - } - else if (dbVersionMinor == minor) { - if (patch == -1 || dbVersionPatch > patch) { - return true; + if (minor == -1) { + if (dbVersionMinor == 0) { + if (patch == -1) { + if (dbVersionPatch == 0) { + // effectively i.e. 11.0.0 compared to 11, which isn't greater than. + // if this is needed, GreaterThanOrEqualTo should be used. + return false; + } + // i.e. 11.0.1 compared to 11 + return dbVersionPatch > 0; + } + // i.e. 11.0.2 compared to 11.0.1 + return dbVersionPatch > patch; } + // i.e. 11.1 compared to 11 + return dbVersionMinor > 0; } + // i.e. 11.2 compared to 11.1 + return dbVersionMinor > minor; } return false; } diff --git a/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolverTest.java b/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolverTest.java new file mode 100644 index 000000000..c652d0cf9 --- /dev/null +++ b/debezium-core/src/test/java/io/debezium/junit/DatabaseVersionResolverTest.java @@ -0,0 +1,107 @@ +/* + * Copyright Debezium Authors. + * + * Licensed under the Apache Software License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0 + */ +package io.debezium.junit; + +import static org.fest.assertions.Assertions.assertThat; + +import org.junit.Test; + +import io.debezium.junit.DatabaseVersionResolver.DatabaseVersion; + +/** + * Unit test to verify that the functionality of {@link DatabaseVersionResolver} is accurate. + * + * @author Chris Cranford + */ +public class DatabaseVersionResolverTest { + + private DatabaseVersion databaseVersion; + + @Test + public void testAnnotationLessThanGivenMajorVersion() throws Exception { + // Database version is same major but with later minor/patch values + assertThat(checkLessThan(11, 14, 0, 11, -1, -1)).isFalse(); + // Database version is same major but initial minor/patch of 0 + assertThat(checkLessThan(11, 0, 0, 11, -1, -1)).isFalse(); + // Database version is higher major + assertThat(checkLessThan(12, 0, 0, 11, -1, -1)).isFalse(); + // Database version is lower major + assertThat(checkLessThan(10, 0, 0, 11, -1, -1)).isTrue(); + } + + @Test + public void testAnnotationLessThanOrEqualGivenMajorVersion() throws Exception { + // Database version is same major but with later minor/patch values + assertThat(checkLessThanEqualTo(11, 14, 0, 11, -1, -1)).isTrue(); + // Database version is same major but initial minor/patch of 0 + assertThat(checkLessThanEqualTo(11, 0, 0, 11, -1, -1)).isTrue(); + // Database version is higher major + assertThat(checkLessThanEqualTo(12, 0, 0, 11, -1, -1)).isFalse(); + // Database version is lower major + assertThat(checkLessThanEqualTo(10, 0, 0, 11, -1, -1)).isTrue(); + } + + @Test + public void testAnnotationEqualToGivenMajorVersion() throws Exception { + // Database version is same major but with later minor/patch values + assertThat(checkEqualTo(11, 14, 0, 11, -1, -1)).isTrue(); + // Database version is same major but initial minor/patch of 0 + assertThat(checkEqualTo(11, 0, 0, 11, -1, -1)).isTrue(); + // Database version is higher major + assertThat(checkEqualTo(12, 0, 0, 11, -1, -1)).isFalse(); + // Database version is lower major + assertThat(checkEqualTo(10, 0, 0, 11, -1, -1)).isFalse(); + } + + @Test + public void testAnnotationGreaterThanOrEqualToGivenMajorVersion() throws Exception { + // Database version is same major but with later minor/patch values + assertThat(checkGreaterThanOrEqualTo(11, 14, 0, 11, -1, -1)).isTrue(); + // Database version is same major but initial minor/patch of 0 + assertThat(checkGreaterThanOrEqualTo(11, 0, 0, 11, -1, -1)).isTrue(); + // Database version is higher major + assertThat(checkGreaterThanOrEqualTo(12, 0, 0, 11, -1, -1)).isTrue(); + // Database version is lower major + assertThat(checkGreaterThanOrEqualTo(10, 0, 0, 11, -1, -1)).isFalse(); + } + + @Test + public void testAnnotationGreaterThanGivenMajorVersion() throws Exception { + // Database version is same major but with later minor/patch values + assertThat(checkGreaterThan(11, 14, 0, 11, -1, -1)).isTrue(); + // Database version is same major but initial minor/patch of 0 + assertThat(checkGreaterThan(11, 0, 0, 11, -1, -1)).isFalse(); + // Database version is higher major + assertThat(checkGreaterThan(12, 0, 0, 11, -1, -1)).isTrue(); + // Database version is lower major + assertThat(checkGreaterThan(10, 0, 0, 11, -1, -1)).isFalse(); + } + + private boolean checkLessThan(int dbMajor, int dbMinor, int dbPatch, int major, int minor, int patch) { + final DatabaseVersion dbVersion = new DatabaseVersion(dbMajor, dbMinor, dbPatch); + return dbVersion.isLessThan(major, minor, patch); + } + + private boolean checkLessThanEqualTo(int dbMajor, int dbMinor, int dbPatch, int major, int minor, int patch) { + final DatabaseVersion dbVersion = new DatabaseVersion(dbMajor, dbMinor, dbPatch); + return dbVersion.isLessThanEqualTo(major, minor, patch); + } + + private boolean checkEqualTo(int dbMajor, int dbMinor, int dbPatch, int major, int minor, int patch) { + final DatabaseVersion dbVersion = new DatabaseVersion(dbMajor, dbMinor, dbPatch); + return dbVersion.isEqualTo(major, minor, patch); + } + + private boolean checkGreaterThanOrEqualTo(int dbMajor, int dbMinor, int dbPatch, int major, int minor, int patch) { + final DatabaseVersion dbVersion = new DatabaseVersion(dbMajor, dbMinor, dbPatch); + return dbVersion.isGreaterThanEqualTo(major, minor, patch); + } + + private boolean checkGreaterThan(int dbMajor, int dbMinor, int dbPatch, int major, int minor, int patch) { + final DatabaseVersion dbVersion = new DatabaseVersion(dbMajor, dbMinor, dbPatch); + return dbVersion.isGreaterThan(major, minor, patch); + } +}