From 508fa0ca22f7195482df3352e50ed9cb7a2fc22a Mon Sep 17 00:00:00 2001 From: labkey-tchad Date: Mon, 1 Dec 2025 13:17:29 -0800 Subject: [PATCH] Update BaseUpgradeTest to use local enlistment version --- src/org/labkey/test/TestProperties.java | 39 +++++++++++++++++++ .../test/tests/upgrade/BaseUpgradeTest.java | 4 +- src/org/labkey/test/util/Version.java | 29 ++++++++++++-- src/org/labkey/test/util/VersionRange.java | 4 +- 4 files changed, 69 insertions(+), 7 deletions(-) diff --git a/src/org/labkey/test/TestProperties.java b/src/org/labkey/test/TestProperties.java index 651e6d14b1..007619f3d7 100644 --- a/src/org/labkey/test/TestProperties.java +++ b/src/org/labkey/test/TestProperties.java @@ -20,6 +20,7 @@ import org.labkey.serverapi.reader.Readers; import org.labkey.test.util.CspLogUtil; import org.labkey.test.util.TestLogger; +import org.labkey.test.util.Version; import org.openqa.selenium.Dimension; import java.io.File; @@ -73,6 +74,31 @@ public abstract class TestProperties TestLogger.error("Failed to load " + propFile.getName() + " file. Running with hard-coded defaults"); ioe.printStackTrace(System.err); } + + final List gradleProperties = List.of("labkeyVersion"); + final File serverPropFile = new File(TestFileUtils.getLabKeyRoot(), "gradle.properties"); + if (serverPropFile.exists()) + { + try (Reader propReader = Readers.getReader(serverPropFile)) + { + TestLogger.log("Loading properties from " + serverPropFile.getName()); + Properties properties = new Properties(); + properties.load(propReader); + for (String key : gradleProperties) + { + if (properties.containsKey(key)) + { + System.setProperty(key, properties.getProperty(key)); + } + } + } + catch (IOException ioe) + { + TestLogger.error("Failed to load " + serverPropFile.getName() + " file."); + ioe.printStackTrace(System.err); + } + } + } private static ZoneId browserZoneId = null; @@ -83,6 +109,19 @@ public static void load() CspLogUtil.init(); } + /// Get the local enlistment version, stripping everything past the minor version. + /// - `"25.11.0"` -> `"25.11"` + /// - `"25.11-SNAPSHOT"` -> `"25.11"` + /// @return Enlistment Version or `null` if unable to determine + public static Version getProductVersion() + { + Version version = new Version(System.getProperty("labkeyVersion", "1")); + if (version.size() >= 2) + return version.trim(2); + else + return null; + } + public static boolean isTestCleanupSkipped() { return !getBooleanProperty("clean", false); diff --git a/src/org/labkey/test/tests/upgrade/BaseUpgradeTest.java b/src/org/labkey/test/tests/upgrade/BaseUpgradeTest.java index 3daaec5540..33fe474029 100644 --- a/src/org/labkey/test/tests/upgrade/BaseUpgradeTest.java +++ b/src/org/labkey/test/tests/upgrade/BaseUpgradeTest.java @@ -36,7 +36,7 @@ public abstract class BaseUpgradeTest extends BaseWebDriverTest protected static final boolean isUpgradeSetupPhase = TestProperties.getBooleanProperty("webtest.upgradeSetup", true); protected static final Version previousVersion = Optional.ofNullable(trimToNull(System.getProperty("webtest.upgradePreviousVersion"))) - .map(Version::new).orElse(null); + .map(Version::new).orElse(TestProperties.getProductVersion()); @Override protected boolean skipCleanup(boolean afterTest) @@ -114,7 +114,7 @@ private static class UpgradeVersionCheck implements TestRule @Override public void evaluate() throws Throwable { - Assume.assumeTrue("Test doesn't support upgrading from version: " + previousVersion, + Assume.assumeTrue("Test not valid when upgrading from version: " + previousVersion, VersionRange.versionRange(earliestVersion, latestVersion).contains(previousVersion) ); base.evaluate(); diff --git a/src/org/labkey/test/util/Version.java b/src/org/labkey/test/util/Version.java index cef81cd705..d67bc37eba 100644 --- a/src/org/labkey/test/util/Version.java +++ b/src/org/labkey/test/util/Version.java @@ -15,14 +15,22 @@ public class Version implements Comparable { private final List _version; - public Version(Integer... version) + private Version(List version) { _version = validate(version); } + public Version(Integer... version) + { + this(List.of(version)); + } + public Version(String version) { - this(Arrays.stream(version.split("\\.")).map(Integer::parseInt).toArray(Integer[]::new)); + this(Arrays.stream(version + .split("-", 2)[0] // Remove snapshot suffix + .split("\\.")) // Split the version into major, minor, patch, etc. parts + .map(Integer::parseInt).toList()); } public Version(Double version) @@ -30,9 +38,9 @@ public Version(Double version) this(version.toString()); } - private static List validate(Integer... versionParts) + private static List validate(List versionParts) { - List partList = List.of(versionParts); + List partList = List.copyOf(versionParts); if (partList.isEmpty()) { throw new IllegalArgumentException("Version must have at least one part"); @@ -47,6 +55,19 @@ private static List validate(Integer... versionParts) return partList; } + public Version trim(int maxParts) + { + if (maxParts == _version.size()) + return this; + else + return new Version(_version.subList(0, maxParts)); + } + + public int size() + { + return _version.size(); + } + @Override public int compareTo(@NotNull Version o) { diff --git a/src/org/labkey/test/util/VersionRange.java b/src/org/labkey/test/util/VersionRange.java index 123b9a987d..0fe8220e5a 100644 --- a/src/org/labkey/test/util/VersionRange.java +++ b/src/org/labkey/test/util/VersionRange.java @@ -23,7 +23,9 @@ public static VersionRange until(String version) public static VersionRange versionRange(String earliestVersion, String latestVersion) { - return new VersionRange(new Version(earliestVersion), new Version(latestVersion)); + Version earliest = earliestVersion == null ? null : new Version(earliestVersion); + Version latest = latestVersion == null ? null : new Version(latestVersion); + return new VersionRange(earliest, latest); } public boolean contains(Version version)