Base classes for upgrade pipeline

src/org/labkey/test/BaseWebDriverTest.java

@@ -1333,11 +1333,16 @@ private int getPendingRequestCount(Connection connection)
         }
     }
 
+    protected boolean skipCleanup(boolean afterTest)
+    {
+        return false;
+    }
+
     private void cleanup(boolean afterTest)
     {
         ensureSignedInAsPrimaryTestUser();
 
-        if (!ClassUtils.getAllInterfaces(getClass()).contains(ReadOnlyTest.class) || ((ReadOnlyTest) this).needsSetup())
+        if (!skipCleanup(afterTest) && (!(this instanceof ReadOnlyTest readOnlyTest) || readOnlyTest.needsSetup()))
         {
             if (afterTest)
                 waitForPendingRequests(WAIT_FOR_PAGE);

src/org/labkey/test/TestProperties.java

@@ -373,7 +373,7 @@ public static File getDumpDir()
      * @param def Default value
      * @return value of the specified property
      */
-    private static boolean getBooleanProperty(String key, boolean def)
+    public static boolean getBooleanProperty(String key, boolean def)
     {
         String prop = System.getProperty(key);
         if (!StringUtils.isBlank(prop))
@@ -393,7 +393,7 @@ private static boolean getBooleanProperty(String key, boolean def)
      * @param def Default value
      * @return value of the specified property
      */
-    private static int getIntegerProperty(String key, int def)
+    public static int getIntegerProperty(String key, int def)
     {
         String prop = System.getProperty(key);
         if (!StringUtils.isBlank(prop))
@@ -417,7 +417,7 @@ private static int getIntegerProperty(String key, int def)
      * @param def Default value
      * @return value of the specified property
      */
-    private static double getDoubleProperty(String key, double def)
+    public static double getDoubleProperty(String key, double def)
     {
         String prop = System.getProperty(key);
         if (!StringUtils.isBlank(prop))

src/org/labkey/test/tests/upgrade/BaseUpgradeTest.java

@@ -0,0 +1,125 @@
+package org.labkey.test.tests.upgrade;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Assume;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.labkey.test.BaseWebDriverTest;
+import org.labkey.test.TestProperties;
+import org.labkey.test.util.TestLogger;
+import org.labkey.test.util.Version;
+import org.labkey.test.util.VersionRange;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static org.apache.commons.lang3.StringUtils.trimToNull;
+
+/**
+ * Base test class for tests that setup data and configure a server then verify the persistence or modification of those
+ * data and configurations after upgrading to a newer version of LabKey.<br>
+ * The {@code EariestVersion} and {@code LatestVersion} annotations can be used to skip particular tests when they are
+ * not relevant to the version of LabKey being upgraded from (specified in the {@code webtest.upgradePreviousVersion}
+ * system property).<br>
+ * The setup steps will be skipped if the {@code webtest.upgradeSetup} system property is set to {@code false}.
+ */
+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);
+
+    @Override
+    protected boolean skipCleanup(boolean afterTest)
+    {
+        return afterTest || !isUpgradeSetupPhase;
+    }
+
+    @BeforeClass
+    public static void setupProject() throws Exception
+    {
+        BaseUpgradeTest currentTest = BaseWebDriverTest.getCurrentTest();
+
+        if (isUpgradeSetupPhase)
+        {
+            currentTest.doSetup();
+        }
+        else
+        {
+            TestLogger.info("Skipping setup for %s. Verifying upgrade.". formatted(currentTest.getClass().getSimpleName()));
+        }
+    }
+
+    protected abstract void doSetup() throws Exception;
+
+    @Rule
+    public final TestRule upgradeVersionCheck = new UpgradeVersionCheck();
+
+    @Override
+    public List<String> getAssociatedModules()
+    {
+        return Arrays.asList();
+    }
+
+    /**
+     * Annotates test methods that should only run when upgrading from particular LabKey versions, as specified in
+     * {@code webtest.upgradePreviousVersion}.<br>
+     * Specifies the earliest version of the test class that performed the required setup for the annotated method.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.METHOD})
+    protected @interface EariestVersion {
+        String value();
+    }
+
+    /**
+     * Annotates test methods that should only run when upgrading from particular LabKey versions, as specified in
+     * {@code webtest.upgradePreviousVersion}.<br>
+     * Specifies the latest version of the test class that performed the required setup for the annotated method.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.METHOD})
+    protected @interface LatestVersion {
+        String value();
+    }
+
+    private static class UpgradeVersionCheck implements TestRule
+    {
+
+        @Override
+        public @NotNull Statement apply(Statement base, Description description)
+        {
+            String eariestVersion = Optional.ofNullable(description.getAnnotation(EariestVersion.class))
+                .map(EariestVersion::value).orElse(null);
+            String latestVersion = Optional.ofNullable(description.getAnnotation(LatestVersion.class))
+                .map(LatestVersion::value).orElse(null);
+
+            if (isUpgradeSetupPhase || previousVersion == null || (eariestVersion == null && latestVersion == null))
+            {
+                return base; // Run the test normally
+            }
+
+            return new Statement()
+            {
+                @Override
+                public void evaluate() throws Throwable
+                {
+                    Assume.assumeTrue("Test doesn't support upgrading from version: " + previousVersion,
+                        VersionRange.versionRange(eariestVersion, latestVersion).contains(previousVersion)
+                    );
+                    base.evaluate();
+                }
+            };
+        }
+    }
+
+}

src/org/labkey/test/tests/upgrade/BasicUpgradeTest.java

@@ -0,0 +1,92 @@
+package org.labkey.test.tests.upgrade;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.labkey.remoteapi.CommandException;
+import org.labkey.remoteapi.Connection;
+import org.labkey.remoteapi.query.SelectRowsCommand;
+import org.labkey.test.params.FieldInfo;
+import org.labkey.test.params.experiment.SampleTypeDefinition;
+import org.labkey.test.util.TestUser;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertFalse;
+import static org.labkey.test.util.PermissionsHelper.READER_ROLE;
+
+@Category({})
+public class BasicUpgradeTest extends BaseUpgradeTest
+{
+    private static final TestUser USER = new TestUser("basic_upgrade_reader@basicupgradetest.test");
+    private static final String SAMPLE_TYPE = "UpgradeTestSamples";
+
+    private static final FieldInfo STR_COL = new FieldInfo("String Col1");
+
+    @Override
+    protected void doCleanup(boolean afterTest)
+    {
+        _containerHelper.deleteProject(getProjectName(), afterTest);
+        _userHelper.deleteUsers(afterTest, USER);
+    }
+
+    @Override
+    protected void doSetup() throws Exception
+    {
+        _containerHelper.createProject(getProjectName(), null);
+        USER.create(this);
+        USER.setInitialPassword();
+        USER.addPermission(READER_ROLE, getProjectName());
+
+        new SampleTypeDefinition(SAMPLE_TYPE)
+            .setFields(List.of(STR_COL.getFieldDefinition()))
+            .create(createDefaultConnection(), getProjectName())
+            .insertRows(createDefaultConnection(), List.of(Map.of(
+                "Name", "S-1",
+                STR_COL.getName(), "Test String Value"
+            )) );
+    }
+
+    @Before
+    public void preTest()
+    {
+        USER.load(this);
+    }
+
+    @Test
+    public void testSampleRowsExist() throws Exception
+    {
+        // Use primary user to verify data
+        queryData(createDefaultConnection());
+    }
+
+    @Test
+    public void testUserPassword() throws Exception
+    {
+        // Use password authentication for USER
+        queryData(USER.getUserConnection());
+    }
+
+    @Test
+    public void testUserPermissions() throws Exception
+    {
+        // Impersonate to test USER's permission level
+        queryData(createDefaultConnection().impersonate(USER.getEmail()));
+    }
+
+    private void queryData(Connection connection) throws IOException, CommandException
+    {
+        List<Map<String, Object>> rows = new SelectRowsCommand("samples", SAMPLE_TYPE)
+            .execute(connection, getProjectName())
+            .getRows();
+        assertFalse("Expected at least one row", rows.isEmpty());
+    }
+
+    @Override
+    protected String getProjectName()
+    {
+        return getClass().getSimpleName() + " Project";
+    }
+}

src/org/labkey/test/util/APIUserHelper.java

@@ -217,6 +217,14 @@ public Integer getUserId(String userEmail)
         return getUserIds(Arrays.asList(userEmail)).get(userEmail);
     }
 
+    public int getUserIdStrict(String userEmail)
+    {
+        Integer userId = getUserId(userEmail);
+        if (userId == null)
+            throw new IllegalStateException("No user with email " + userEmail + " found.");
+        return userId;
+    }
+
     @Override
     protected void _deleteUser(String userEmail)
     {
@@ -255,6 +263,11 @@ protected void _deleteUsers(boolean failIfNotFound, String... userEmails)
 
     private static final Pattern regEmailVerification = Pattern.compile("verification=([A-Za-z0-9]+)");
 
+    public String setInitialPassword(String email)
+    {
+        return setInitialPassword(getUserIdStrict(email));
+    }
+
     @Override
     public String setInitialPassword(int userId)
     {

src/org/labkey/test/util/PermissionsHelper.java

@@ -38,6 +38,12 @@ public abstract class PermissionsHelper
     public static final String APP_ADMIN_ROLE = "Application Admin";
     public static final String DEVELOPER_ROLE = "Platform Developer";
     public static final String IMP_TROUBLESHOOTER_ROLE = "Impersonating Troubleshooter";
+    public static final String PROJECT_ADMIN_ROLE = "Project Administrator";
+    public static final String FOLDER_ADMIN_ROLE = "Folder Administrator";
+    public static final String READER_ROLE = "Reader";
+    public static final String EDITOR_ROLE = "Editor";
+    public static final String AUTHOR_ROLE = "Author";
+    public static final String SUBMITTER_ROLE = "Submitter";
 
     public static String toRole(final String name)
     {