Issue 51524: Allowlist for acceptable types of file upload - automation test

src/org/labkey/test/TestScrubber.java

@@ -20,6 +20,7 @@
 import org.labkey.remoteapi.Connection;
 import org.labkey.remoteapi.SimplePostCommand;
 import org.labkey.test.components.html.Checkbox;
+import org.labkey.test.pages.core.admin.AllowedFileExtensionAdminPage;
 import org.labkey.test.pages.core.admin.BaseSettingsPage;
 import org.labkey.test.pages.core.admin.ConfigureFileSystemAccessPage;
 import org.labkey.test.pages.core.admin.LimitActiveUserPage;
@@ -132,6 +133,15 @@ public void cleanSiteSettings()
             TestLogger.error("Failed to re-enable file Upload after test", e);
         }
 
+        try
+        {
+            AllowedFileExtensionAdminPage.deleteAllAllowedFileExtension(createDefaultConnection());
+        }
+        catch (Exception e)
+        {
+            TestLogger.error("Failed to remove list of allowed file extensions.", e);
+        }
+
         try
         {
             LimitActiveUserPage.resetUserLimits(connection);
@@ -213,4 +223,5 @@ private void disableFileUploadSetting() throws IOException, CommandException
             }
         }
     }
+
 }

src/org/labkey/test/components/html/FileInput.java

@@ -33,6 +33,11 @@ public void set(File file)
         getWrapper().setFormElement(getComponentElement(), file);
     }
 
+    public void clear()
+    {
+        getComponentElement().clear();
+    }
+
     @Override
     protected void assertElementType(WebElement el)
     {

src/org/labkey/test/pages/announcements/BaseUpdatePage.java

@@ -42,12 +42,22 @@ public PAGE setTitle(String title)
         return getThis();
     }
 
+    public String getTitle()
+    {
+        return elementCache().titleInput.get();
+    }
+
     public PAGE setBody(String body)
     {
         elementCache().bodyInput.set(body);
         return getThis();
     }
 
+    public String getBody()
+    {
+        return elementCache().bodyInput.get();
+    }
+
     public PAGE setRenderAs(WikiRendererType renderAs)
     {
         elementCache().rendererSelect.set(renderAs);

src/org/labkey/test/pages/core/admin/AllowedFileExtensionAdminPage.java

@@ -0,0 +1,219 @@
+package org.labkey.test.pages.core.admin;
+
+import org.labkey.remoteapi.CommandException;
+import org.labkey.remoteapi.Connection;
+import org.labkey.remoteapi.SimplePostCommand;
+import org.labkey.test.BootstrapLocators;
+import org.labkey.test.Locator;
+import org.labkey.test.Locators;
+import org.labkey.test.WebDriverWrapper;
+import org.labkey.test.WebTestHelper;
+import org.labkey.test.components.html.Input;
+import org.labkey.test.pages.LabKeyPage;
+import org.labkey.test.util.PortalHelper;
+import org.openqa.selenium.NoSuchElementException;
+import org.openqa.selenium.StaleElementReferenceException;
+import org.openqa.selenium.TimeoutException;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.support.ui.ExpectedConditions;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class AllowedFileExtensionAdminPage extends LabKeyPage<AllowedFileExtensionAdminPage.ElementCache>
+{
+    public AllowedFileExtensionAdminPage(WebDriver driver)
+    {
+        super(driver);
+    }
+
+    public static AllowedFileExtensionAdminPage beginAt(WebDriverWrapper webDriverWrapper)
+    {
+        webDriverWrapper.beginAt(WebTestHelper.buildURL("admin", "allowList",
+                Map.of("type", "FileExtension")));
+        return new AllowedFileExtensionAdminPage(webDriverWrapper.getDriver());
+    }
+
+    @Override
+    protected void waitForPage()
+    {
+        waitFor(()-> {
+            try
+            {
+                return !BootstrapLocators.loadingSpinner.areAnyVisible(getDriver()) &&
+                        elementCache().extension.getComponentElement().isDisplayed();
+            }
+            catch (NoSuchElementException | StaleElementReferenceException | TimeoutException retry)
+            {
+                return false;
+            }
+        }, "Allowed File Extensions page did not load in time.", 3_000);
+
+    }
+
+    /**
+     * Clears any file extensions that are set as the only allowable names, letting users upload any filename they like.
+     *
+     * @param connection A connection object to use in the command.execute call.
+     */
+    public static void deleteAllAllowedFileExtension(Connection connection) throws IOException, CommandException
+    {
+        SimplePostCommand command = new SimplePostCommand("admin", "deleteAllValues");
+        Map<String, Object> params = new HashMap<>();
+        params.put("type", "FileExtension");
+        command.setParameters(params);
+        command.execute(connection, "/");
+    }
+
+
+    public AllowedFileExtensionAdminPage setExtension(String extension)
+    {
+        elementCache().extension.set(extension);
+        return this;
+    }
+
+    public String clickSaveExpectingError()
+    {
+        return clickButtonExpectingError(elementCache().saveExtension);
+    }
+
+    public AllowedFileExtensionAdminPage clickSaveExtension()
+    {
+        return clickButtonNoError(elementCache().saveExtension);
+    }
+
+    public AllowedFileExtensionAdminPage updateExtension(String oldExtension, String newExtension)
+    {
+        getAllowedExtension(getAllowedExtensionIndex(oldExtension)).set(newExtension);
+        clearCache();
+        return this;
+    }
+
+    public AllowedFileExtensionAdminPage clickSaveUpdateExtension()
+    {
+        return clickButtonNoError(elementCache().saveUpdateExtension);
+    }
+
+    public String clickUpdateExtensionExpectingError()
+    {
+        return clickButtonExpectingError(elementCache().saveUpdateExtension);
+    }
+
+    private AllowedFileExtensionAdminPage clickButtonNoError(WebElement button)
+    {
+        clickAndWait(button);
+        clearCache();
+        assertNoLabKeyErrors();
+        return this;
+    }
+
+    private String clickButtonExpectingError(WebElement button)
+    {
+        clickAndWait(button);
+        clearCache();
+        return waitForElement(Locators.labkeyError).getText();
+    }
+
+    public AllowedFileExtensionAdminPage deleteExtension(int index)
+    {
+        WebElement deleteButton = elementCache().deleteExtensions.get(index);
+        deleteButton.click();
+
+        shortWait().withMessage("Existing extenstion was not deleted.")
+                .until(ExpectedConditions.stalenessOf(deleteButton));
+
+        clearCache();
+        return this;
+    }
+
+    public AllowedFileExtensionAdminPage deleteExtension(String extension)
+    {
+        return deleteExtension(getAllowedExtensionIndex(extension));
+    }
+
+    public AllowedFileExtensionAdminPage deleteAllExtensions(boolean acceptAlert)
+    {
+        if (acceptAlert)
+        {
+            doAndWaitForPageToLoad(() -> {
+                elementCache().deleteAll.click();
+                acceptAlert();
+            });
+            clearCache();
+            assertFalse("Delete All button should not be present after deleting all extensions", elementCache().deleteAll.isDisplayed());
+        }
+        else
+        {
+            elementCache().deleteAll.click();
+            cancelAlert();
+            assertTrue("Delete All button should be present", elementCache().deleteAll.isDisplayed());
+        }
+        return this;
+    }
+
+    public List<Input> getAllowedExtensions()
+    {
+        List<WebElement> collection = Locator.inputByIdContaining("existingValue")
+                .findElements(elementCache().existingPanel);
+
+        return collection.stream().map(el -> new Input(el, getDriver())).collect(Collectors.toList());
+
+    }
+
+    public Input getAllowedExtension(int index)
+    {
+        return getAllowedExtensions().get(index);
+    }
+
+    public Integer getAllowedExtensionIndex(String extension)
+    {
+        int index = 0;
+        List<Input> allowedExtensions = getAllowedExtensions();
+
+        for(Input element : allowedExtensions)
+        {
+            if (element.getValue().equalsIgnoreCase(extension))
+                return index;
+
+            index++;
+        }
+
+        return  -1;
+    }
+
+    @Override
+    protected ElementCache newElementCache()
+    {
+        return new ElementCache();
+    }
+
+    protected class ElementCache extends LabKeyPage<ElementCache>.ElementCache
+    {
+        final WebElement registerNewPanel = PortalHelper.Locators.webPart("Register New Allowed File Extension").findWhenNeeded(this);
+        final WebElement existingPanel = PortalHelper.Locators.webPart("Existing Allowed File Extensions").findWhenNeeded(this);
+
+        final Input extension = new Input(Locator.id("newValueTextField").findWhenNeeded(registerNewPanel), getDriver());
+        final WebElement saveExtension = Locator.lkButton("Save").findWhenNeeded(registerNewPanel);
+
+        final WebElement saveUpdateExtension = Locator.lkButton("Save").findWhenNeeded(existingPanel);
+
+        List<Input> allowedExtensions()
+        {
+            return Locator.inputByIdContaining("existingValue")
+                    .findElements(elementCache().existingPanel)
+                    .stream().map(el -> new Input(el, getDriver())).collect(Collectors.toList());
+        }
+
+        final List<WebElement> deleteExtensions = Locator.linkWithText("Delete").findElements(existingPanel);
+
+        final WebElement deleteAll = Locator.linkWithText("Delete All").findWhenNeeded(existingPanel);
+
+    }
+}

src/org/labkey/test/pages/core/admin/ShowAdminPage.java

@@ -99,6 +99,13 @@ public ShowAuditLogPage clickAuditLog()
         return new ShowAuditLogPage(getDriver());
     }
 
+    public AllowedFileExtensionAdminPage clickAllowedFileExtensions()
+    {
+        goToSettingsSection();
+        clickAndWait(elementCache().allowedFileExtensionLink);
+        return new AllowedFileExtensionAdminPage(getDriver());
+    }
+
     public void clickAuditLogMaintenance()
     {
         goToSettingsSection();
@@ -280,6 +287,7 @@ protected class ElementCache extends LabKeyPage.ElementCache
 
         protected WebElement analyticsSettingsLink = Locator.linkWithText("analytics settings").findWhenNeeded(this);
         protected WebElement externalRedirectHostLink = Locator.linkWithText("allowed external redirect hosts").findElement(this);
+        protected WebElement allowedFileExtensionLink = Locator.linkWithText("allowed file extensions").findElement(this);
         protected WebElement auditLogLink = Locator.linkWithText("audit log").findWhenNeeded(this);
         protected WebElement auditLogMaintenanceLink = Locator.linkWithText("Audit Log Maintenance").findWhenNeeded(this);
         protected WebElement authenticationLink = Locator.linkWithText("authentication").findWhenNeeded(this);

src/org/labkey/test/tests/core/admin/AllowedFileExtensionBaseTest.java

@@ -0,0 +1,66 @@
+package org.labkey.test.tests.core.admin;
+
+import org.labkey.remoteapi.CommandException;
+import org.labkey.test.BaseWebDriverTest;
+import org.labkey.test.TestFileUtils;
+import org.labkey.test.components.html.Input;
+import org.labkey.test.pages.core.admin.AllowedFileExtensionAdminPage;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+public abstract class AllowedFileExtensionBaseTest extends BaseWebDriverTest
+{
+
+    protected final File TAR_FILE = TestFileUtils.getSampleData("fileTypes/targz_sample.tar.gz");
+    protected final File CSV_FILE = TestFileUtils.getSampleData("fileTypes/csv_sample.csv");
+    protected final File TSV_FILE = TestFileUtils.getSampleData("fileTypes/tsv_sample.tsv");
+    protected final File TXT_FILE = TestFileUtils.getSampleData("fileTypes/sample.txt");
+    protected final File XLS_FILE = TestFileUtils.getSampleData("fileTypes/xls_sample.xls");
+    protected final File XLSX_FILE = TestFileUtils.getSampleData("fileTypes/xlsx_sample.xlsx");
+
+    protected final Map<String, File> fileMap = Map.of(
+            ".tar.gz", TAR_FILE,
+            ".xls", XLS_FILE,
+            ".tsv", TSV_FILE,
+            ".csv", CSV_FILE,
+            ".txt", TXT_FILE,
+            ".xlsx", XLSX_FILE
+    );
+
+    @Override
+    protected void doCleanup(boolean afterTest)
+    {
+        _containerHelper.deleteProject(getProjectName(), afterTest);
+        try
+        {
+            AllowedFileExtensionAdminPage.deleteAllAllowedFileExtension(createDefaultConnection());
+        }
+        catch (IOException | CommandException e)
+        {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected AllowedFileExtensionAdminPage setAllowedExtensions(List<String> allowedTypes, List<String> expectedTypes)
+    {
+        AllowedFileExtensionAdminPage allowedFileExtensionAdminPage = goToAdminConsole().clickAllowedFileExtensions();
+
+        for (String extension : allowedTypes)
+        {
+            allowedFileExtensionAdminPage.setExtension(extension);
+            allowedFileExtensionAdminPage.clickSaveExtension();
+        }
+
+        List<Input> extensions = allowedFileExtensionAdminPage.getAllowedExtensions();
+
+        checker().withScreenshot()
+                .verifyEqualsSorted("List of 'Allowed extensions' is not as expected.",
+                        expectedTypes, extensions.stream().map(Input::getValue).toList());
+
+        return allowedFileExtensionAdminPage;
+    }
+
+}