girder 5.0.19.dev60__tar.gz → 5.0.19.dev74__tar.gz

{girder-5.0.19.dev60 → girder-5.0.19.dev74}/.circleci/config.yml

@@ -175,6 +175,11 @@ jobs:
   web-test:
     executor: py3-mongo
     resource_class: large
+    parameters:
+      browser:
+        description: "Playwright project / browser to run the web tests against"
+        type: enum
+        enum: [chromium, firefox]
     steps:
       - checkout:
           path: girder
@@ -188,20 +193,26 @@ jobs:
       - build-plugins
       - run:
           name: Install playwright browser dependencies
-          command: npm run install-browsers
+          command: npx playwright install --with-deps << parameters.browser >>
           working_directory: girder/girder/web
       - run:
-          name: Test @girder/core
-          command: npm run test
+          name: Test @girder/core (<< parameters.browser >>)
+          command: npm run test -- --project=<< parameters.browser >>
           working_directory: girder/girder/web
           environment:
             PLAYWRIGHT_WORKERS: 4
+            GIRDER_TEST_COVERAGE_DIR: ../../build/test/coverage/<< parameters.browser >>
+            GIRDER_TEST_COVERAGE_FILE: cobertura-coverage.xml
       - store_artifacts:
           path: girder/girder/web/coverage/report
-          destination: coverage
+          destination: coverage-<< parameters.browser >>
       - store_artifacts:
           path: girder/girder/web/test-results
-          destination: test-results
+          destination: test-results-<< parameters.browser >>
+      - persist_to_workspace:
+          root: /home/circleci/project
+          paths:
+            - girder/build/test/coverage/<< parameters.browser >>
 
   integration-test:
     executor: machine
@@ -316,7 +327,7 @@ jobs:
           working_directory: girder
       - run:
           name: Upload coverage
-          command: ./codecov --disable search pycov gcov --root girder --required --file build/test/coverage/py_coverage.xml build/test/coverage/cobertura-coverage.xml
+          command: ./codecov --disable search pycov gcov --root girder --required --file build/test/coverage/py_coverage.xml build/test/coverage/chromium/cobertura-coverage.xml build/test/coverage/firefox/cobertura-coverage.xml
           working_directory: girder
 
   dockers:
@@ -424,6 +435,14 @@ workflows:
             tags:
               only: /^v[0-9]+.*/
       - web-test:
+          name: web-test-chromium
+          browser: chromium
+          filters:
+            tags:
+              only: /^v[0-9]+.*/
+      - web-test:
+          name: web-test-firefox
+          browser: firefox
           filters:
             tags:
               only: /^v[0-9]+.*/
@@ -435,7 +454,8 @@ workflows:
           requires:
             - server-pytest-test
             - server-legacy-test
-            - web-test
+            - web-test-chromium
+            - web-test-firefox
             - integration-test
           filters:
             tags:

{girder-5.0.19.dev60 → girder-5.0.19.dev74}/.pre-commit-config.yaml

@@ -62,6 +62,7 @@ repos:
     rev: v0.0.18
     hooks:
       - id: circleci-config-validate
+        files: ^\.circleci/.*\.yml$
   - repo: https://github.com/asottile/pyupgrade
     rev: v3.21.2
     hooks:

{girder-5.0.19.dev60/girder.egg-info → girder-5.0.19.dev74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: girder
-Version: 5.0.19.dev60
+Version: 5.0.19.dev74
 Summary: Web-based data management platform
 Home-page: https://girder.readthedocs.org
 Author: Kitware, Inc.

{girder-5.0.19.dev60 → girder-5.0.19.dev74}/girder/web/tests/playwright-teardown.ts

@@ -33,7 +33,7 @@ export default async (_config: PlaywrightTestConfig) => {
 
   report.execute(context);
 
-  const outputDir = '../../build/test/coverage';
+  const outputDir = process.env.GIRDER_TEST_COVERAGE_DIR || '../../build/test/coverage';
   await fs.mkdir(outputDir, { recursive: true });
   const contextXml = libReport.createContext({
     dir: outputDir,
@@ -41,7 +41,7 @@ export default async (_config: PlaywrightTestConfig) => {
     coverageMap,
   });
   const xmlReport = reports.create('cobertura', {
-    file: 'cobertura-coverage.xml',
+    file: process.env.GIRDER_TEST_COVERAGE_FILE || 'cobertura-coverage.xml',
     skipEmpty: false,
   });
   xmlReport.execute(contextXml);

girder-5.0.19.dev74/girder/web/tests/spec/plugin_autojoin.spec.ts

@@ -0,0 +1,100 @@
+import { expect, Page, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, waitForIdlePage } from '../util';
+
+/**
+ * Ported from 3.x-maintenance: plugins/autojoin/plugin_tests/autojoinSpec.js
+ * Tests for the Auto Join plugin's configuration page and its effect on new
+ * users.
+ */
+
+/**
+ * Navigate to the groups list page.
+ */
+async function gotoGroupsPage(page: Page) {
+    await page.locator('a.g-nav-link[g-target="groups"]').click();
+    await expect(page.locator('.g-group-search-form .g-search-field')).toBeVisible();
+}
+
+/**
+ * Create a private group and wait for its page to load. Assumes the user is
+ * logged in.
+ */
+async function createGroup(page: Page, name: string) {
+    await gotoGroupsPage(page);
+    await expect(page.locator('.g-group-create-button')).toBeVisible();
+    await page.locator('.g-group-create-button').click();
+    await expect(page.locator('#g-name')).toBeVisible();
+    await page.locator('#g-name').fill(name);
+    await page.locator('.g-save-group').click();
+    await waitForIdlePage(page);
+    await expect(page.locator('.g-group-name')).toHaveText(name);
+}
+
+/**
+ * Navigate to the Auto Join plugin configuration page.
+ */
+async function gotoAutojoinConfig(page: Page) {
+    await page.locator('a.g-nav-link[g-target="admin"]').click();
+    await page.locator('.g-plugins-config').click();
+    const configLink = page.locator('.g-plugin-list-item[data-name="autojoin"] a.g-plugin-config-link');
+    await expect(configLink).toBeVisible();
+    await configLink.click();
+    // Wait for the group collection to populate the group select.
+    await expect(page.locator('#g-autojoin-group > option')).toHaveCount(4);
+}
+
+/**
+ * Fill out and submit the "add rule" row of the Auto Join configuration page.
+ */
+async function addRule(page: Page, pattern: string, groupName: string, level: string) {
+    await page.locator('#g-autojoin-pattern').fill(pattern);
+    await page.locator('#g-autojoin-group').selectOption({ label: groupName });
+    await page.locator('#g-autojoin-level').selectOption(level);
+    await page.locator('#g-autojoin-add').click();
+}
+
+test.describe('Test the auto join plugin', () => {
+    setupServer();
+
+    test('configure auto join rules', async ({ page }) => {
+        await createUser(page, 'admin', 'admin@girder.test', 'Joe', 'Admin', 'password');
+
+        await createGroup(page, 'group1');
+        await createGroup(page, 'group2');
+        await createGroup(page, 'group3');
+
+        await gotoAutojoinConfig(page);
+
+        await addRule(page, '@girder1.test', 'group1', '2');
+        await addRule(page, '@girder2.test', 'group2', '1');
+        await addRule(page, '@girder2.test', 'group3', '0');
+
+        await expect(page.locator('.g-autojoin-container tbody tr')).toHaveCount(3);
+        await expect(page.locator('.g-autojoin-container')).toContainText('@girder1.test');
+        await expect(page.locator('.g-autojoin-container')).toContainText('@girder2.test');
+
+        await page.locator('#g-autojoin-save').click();
+        await expect(page.locator('#g-alerts-container')).toContainText('Settings saved');
+        await waitForIdlePage(page);
+    });
+
+    test('auto join a user whose email matches the girder2 rule', async ({ page }) => {
+        await createUser(page, 'user1', 'user1@girder2.test', 'Joe', 'User', 'password');
+
+        await gotoGroupsPage(page);
+        await expect(page.locator('.g-group-title', { hasText: 'group1' })).toHaveCount(0);
+        await expect(page.locator('.g-group-title', { hasText: 'group2' })).toHaveCount(1);
+        await expect(page.locator('.g-group-title', { hasText: 'group3' })).toHaveCount(1);
+    });
+
+    test('auto join a user whose email matches the girder1 rule', async ({ page }) => {
+        await createUser(page, 'user2', 'user2@girder1.test', 'Joe', 'User', 'password');
+
+        await gotoGroupsPage(page);
+        await expect(page.locator('.g-group-title', { hasText: 'group1' })).toHaveCount(1);
+        await expect(page.locator('.g-group-title', { hasText: 'group2' })).toHaveCount(0);
+        await expect(page.locator('.g-group-title', { hasText: 'group3' })).toHaveCount(0);
+    });
+});

girder-5.0.19.dev74/girder/web/tests/spec/plugin_hashsum_download.spec.ts

@@ -0,0 +1,74 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Page, expect, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, upload, waitForIdlePage } from '../util';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Make a REST request from within the page context and await its result.
+ */
+async function asyncRestRequest(page: Page, opts: Record<string, unknown>) {
+    return await page.evaluate((requestOpts) => {
+        return new Promise((resolve, reject) => {
+            // @ts-ignore - window.girder is available at runtime
+            window.girder.rest.restRequest(requestOpts).done((resp: unknown) => {
+                resolve(resp);
+            }).fail((resp: unknown) => {
+                reject(resp);
+            });
+        });
+    }, opts);
+}
+
+test.describe('Test the hashsum download front-end', () => {
+    setupServer();
+
+    test('verify presence of key file', async ({ page }) => {
+        await createUser(page, 'admin');
+        await page.locator('#g-app-header-container').getByText('admin').click();
+        await page.locator('a.g-my-folders').click();
+        await page.getByRole('link', { name: ' Private ' }).click();
+        await upload(page, path.join(__dirname, 'data', 'ten_byte_file.txt'));
+
+        await page.getByRole('link', { name: ' ten_byte_file.txt' }).click();
+        await page.getByTitle('Show info').click();
+        await expect(page.locator('input.g-hash-textbox').first()).toHaveValue('ff3245abe317049ed1b8aa7aa2f4c4dcb8bf86f083ed67eb26b43e2fbe3ba8fdf759f9e2f46fcf2a06c2dfeddf0cedcd41a68034cd618b880785b34f759d1a69')
+    });
+});
+
+test.describe('Test the hashsum download configuration page', () => {
+    setupServer();
+
+    test('enable automatic checksum computation', async ({ page }) => {
+        await createUser(page, 'admin');
+
+        // Navigate to the plugin's admin settings page.
+        await page.locator('a.g-nav-link[g-target="admin"]').click();
+        await page.locator('.g-plugins-config').click();
+        const configLink = page.locator('.g-plugin-list-item[data-name="hashsum_download"] a.g-plugin-config-link');
+        await expect(configLink).toBeVisible();
+        await configLink.click();
+
+        const autoCompute = page.locator('#g-hashsum-download-auto-compute');
+        await expect(autoCompute).toBeVisible();
+        await expect(autoCompute).not.toBeChecked();
+        await autoCompute.check();
+
+        await page.locator('#g-hashsum-download-config-form input[type="submit"]').click();
+        await expect(page.locator('#g-alerts-container')).toContainText('Settings saved');
+        await waitForIdlePage(page);
+
+        // Verify that the setting was persisted on the server.
+        const settings = await asyncRestRequest(page, {
+            url: '/system/setting',
+            method: 'GET',
+            data: { list: JSON.stringify(['hashsum_download.auto_compute']) },
+        }) as Record<string, unknown>;
+        expect(settings['hashsum_download.auto_compute']).toBe(true);
+    });
+});

girder-5.0.19.dev74/girder/web/tests/spec/plugin_homepage.spec.ts

@@ -0,0 +1,118 @@
+import { Locator, Page, expect, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, login, logout } from '../util';
+
+/**
+ * Ported from 3.x-maintenance: plugins/homepage/plugin_tests/homepageSpec.js
+ * Tests for the Homepage plugin's configuration page and its effect on the
+ * front page.
+ */
+
+const markdown =
+    'It\'s very easy to make some words **bold** and other words *italic* with ' +
+    'Markdown. You can even [link to Girder!](https://girder.readthedocs.io/)';
+
+/**
+ * Assert that the given container renders the expected markdown content.
+ */
+async function expectMarkdown(container: Locator) {
+    await expect(container.locator('p')).toContainText("It's very easy");
+    await expect(container.locator('strong')).toContainText('bold');
+    await expect(container.locator('em')).toContainText('italic');
+    await expect(container.locator('a[href="https://girder.readthedocs.io/"]')).toContainText('link to Girder!');
+}
+
+/**
+ * Navigate to the Homepage plugin configuration page.
+ */
+async function gotoHomepageConfig(page: Page) {
+    await page.locator('a.g-nav-link[g-target="admin"]').click();
+    await page.locator('.g-plugins-config').click();
+    const configLink = page.locator('.g-plugin-list-item[data-name="homepage"] a.g-plugin-config-link');
+    await expect(configLink).toBeVisible();
+    await configLink.click();
+    await expect(page.locator('.g-homepage-container')).toBeVisible();
+}
+
+/**
+ * Navigate back to the front page via the app title.
+ */
+async function gotoFrontPage(page: Page) {
+    await page.locator('.g-app-title').click();
+}
+
+/**
+ * Save the homepage configuration form and wait for the success alert.
+ */
+async function saveHomepageConfig(page: Page) {
+    await page.locator('#g-homepage-form input[type="submit"]').click();
+    await expect(page.locator('#g-alerts-container')).toContainText('Settings saved');
+}
+
+test.describe('Test the homepage front-end', () => {
+    setupServer();
+
+    test('exercise homepage markdown customization', async ({ page }) => {
+        await createUser(page, 'admin', 'admin@girder.test', 'Mark', 'Down', 'password');
+
+        await gotoHomepageConfig(page);
+
+        // Write markdown and verify the preview renders it.
+        await page.locator('.g-homepage-container textarea.g-markdown-text').fill(markdown);
+        await page.locator('.g-homepage-container a.g-preview-link').click();
+        await expectMarkdown(page.locator('.g-homepage-container .g-markdown-preview'));
+
+        await saveHomepageConfig(page);
+
+        // The front page body is completely replaced by the rendered markdown.
+        await gotoFrontPage(page);
+        await expectMarkdown(page.locator('#g-app-body-container'));
+    });
+
+    test('set, preview, and save welcome text and branding', async ({ page }) => {
+        await login(page, 'admin', 'password');
+
+        await gotoHomepageConfig(page);
+
+        // Clear the full-page markdown so the branding settings are used.
+        await page.locator('.g-homepage-container textarea.g-markdown-text').fill('');
+        await page.locator('.g-homepage-container a.g-preview-link').click();
+        await expect(page.locator('.g-homepage-container .g-markdown-preview')).toHaveText('Nothing to show');
+
+        // Set header, subheader, and welcome text.
+        await page.locator('#g-homepage-header').fill('Header');
+        await page.locator('#g-homepage-subheader').fill('Subheader');
+        const welcomeText = page.locator('.g-homepage-welcome-text-container textarea.g-markdown-text');
+        await welcomeText.fill(markdown);
+        await page.locator('.g-homepage-welcome-text-container a.g-preview-link').click();
+        await expectMarkdown(page.locator('.g-homepage-welcome-text-container .g-markdown-preview'));
+
+        await saveHomepageConfig(page);
+
+        // The branded front page shows the configured header/subheader and the
+        // welcome text rendered as markdown.
+        await gotoFrontPage(page);
+        await expect(page.locator('.g-frontpage-title')).toHaveText('Header');
+        await expect(page.locator('.g-frontpage-subtitle')).toHaveText('Subheader');
+        await expectMarkdown(page.locator('.g-frontpage-welcome-text-content'));
+    });
+
+    test('settings persist after reload and are visible anonymously', async ({ page }) => {
+        await login(page, 'admin', 'password');
+
+        // Configure the full-page markdown replacement.
+        await gotoHomepageConfig(page);
+        await page.locator('.g-homepage-container textarea.g-markdown-text').fill(markdown);
+        await saveHomepageConfig(page);
+
+        // Re-open the config page and verify the markdown was persisted.
+        await gotoHomepageConfig(page);
+        await expect(page.locator('.g-homepage-container textarea.g-markdown-text')).toHaveValue(markdown);
+
+        // Log out and verify the markdown still renders to anonymous users.
+        await logout(page);
+        await gotoFrontPage(page);
+        await expectMarkdown(page.locator('#g-app-body-container'));
+    });
+});

girder-5.0.19.dev74/girder/web/tests/spec/plugin_item_licenses.spec.ts

@@ -0,0 +1,257 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Locator, Page, expect, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, login, waitForDialog, waitForIdlePage } from '../util';
+
+/**
+ * Ported from 3.x-maintenance:
+ * plugins/item_licenses/plugin_tests/itemLicensesSpec.js
+ *
+ * Tests the item_licenses plugin: selecting a license when creating/editing an
+ * item or uploading a file, viewing the license on the item page, and the
+ * behavior of the "Unspecified" license.
+ *
+ * The original spec was a single sequential Jasmine describe. This port keeps
+ * the same sequence in a serial Playwright describe: the server and database
+ * are shared across the whole describe, admin is registered in the first test,
+ * and later tests log back in as needed.
+ */
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const ADMIN = {
+    login: 'admin',
+    email: 'admin@girder.test',
+    firstName: 'Admin',
+    lastName: 'User',
+    password: 'password!',
+};
+
+const MIT_LICENSE = 'The MIT License (MIT)';
+const APACHE_LICENSE = 'Apache License 2';
+
+/** The number of license options: 12 code + 9 content, plus "Unspecified". */
+const NUM_LICENSES = 22;
+
+/**
+ * Navigate to the admin's folder list.
+ */
+async function gotoMyFolders(page: Page) {
+    await expect(page.locator('.g-user-dropdown-link')).toBeVisible();
+    await page.locator('.g-user-dropdown-link').click();
+    await page.locator('a.g-my-folders').click();
+    await expect(page.locator('a.g-folder-list-link', { hasText: 'Public' })).toBeVisible();
+}
+
+/**
+ * Open a folder of the current user's page by name.
+ */
+async function openFolder(page: Page, name: string) {
+    await expect(page.locator('a.g-folder-list-link', { hasText: name })).toBeVisible();
+    await page.locator('a.g-folder-list-link', { hasText: name }).click();
+    await expect(page.locator('.g-folder-actions-button:visible')).toHaveCount(1);
+    await waitForIdlePage(page);
+}
+
+/**
+ * Assert that the license select in the currently open dialog has the expected
+ * options and selected value.
+ */
+async function expectLicenseSelect(select: Locator, currentLicense: string) {
+    await expect(select).toBeVisible();
+    await expect(select.locator('optgroup')).toHaveCount(2);
+    await expect(select.locator('option')).toHaveCount(NUM_LICENSES);
+    await expect(select).toHaveValue(currentLicense);
+}
+
+/**
+ * Open the "Create item here" dialog from the folder actions menu.
+ */
+async function openCreateItemDialog(page: Page) {
+    await page.locator('.g-folder-actions-button:visible').click();
+    await expect(page.locator('a.g-create-item:visible')).toHaveCount(1);
+    await page.locator('a.g-create-item:visible').click();
+    await expect.poll(() => page.evaluate(() => window.location.hash)).toContain('dialog=itemcreate');
+    await waitForDialog(page);
+    await expect(page.locator('.g-save-item:visible')).toHaveText('Create');
+}
+
+/**
+ * Open the item edit dialog from the item actions menu.
+ */
+async function openEditItemDialog(page: Page) {
+    await expect(page.locator('.g-item-actions-button:visible')).toHaveCount(1);
+    await page.locator('.g-item-actions-button:visible').click();
+    await expect(page.locator('.g-edit-item:visible')).toHaveCount(1);
+    await page.locator('.g-edit-item:visible').click();
+    await expect.poll(() => page.evaluate(() => window.location.hash)).toContain('dialog=itemedit');
+    await waitForDialog(page);
+    await expect(page.locator('#g-name')).not.toHaveValue('');
+    await expect(page.locator('.g-save-item:visible')).toHaveText('Save');
+}
+
+/**
+ * Open an item from the current folder listing and return once the item page's
+ * license field has loaded.
+ */
+async function openItem(page: Page, name: string) {
+    await expect(page.locator('a.g-item-list-link', { hasText: name })).toHaveCount(1);
+    await page.locator('a.g-item-list-link', { hasText: name }).click();
+    await expect(page.locator('.g-item-name')).toHaveText(name);
+    await expect(page.locator('.g-item-license')).toHaveCount(1);
+    await waitForIdlePage(page);
+}
+
+/**
+ * Navigate back to the Public folder listing via the breadcrumb.
+ */
+async function backToPublicFolder(page: Page) {
+    await expect(page.locator('a.g-item-breadcrumb-link', { hasText: 'Public' })).toBeVisible();
+    await page.locator('a.g-item-breadcrumb-link', { hasText: 'Public' }).click();
+    await expect(page.locator('.g-folder-actions-button:visible')).toHaveCount(1);
+    await waitForIdlePage(page);
+}
+
+test.describe('Test the item licenses front-end', () => {
+    setupServer();
+
+    test('register the admin user', async ({ page }) => {
+        await createUser(page, ADMIN.login, ADMIN.email, ADMIN.firstName, ADMIN.lastName, ADMIN.password);
+    });
+
+    test('create an item with a license', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+        await openCreateItemDialog(page);
+
+        // "Unspecified" is selected by default.
+        await expectLicenseSelect(page.locator('#g-license'), '');
+
+        await page.locator('input#g-name').fill('Test Item');
+        await page.locator('#g-license').selectOption(MIT_LICENSE);
+        await page.locator('.g-save-item').click();
+        await waitForIdlePage(page);
+
+        await openItem(page, 'Test Item');
+        await expect(page.locator('.g-item-license')).toContainText(MIT_LICENSE);
+    });
+
+    test('edit an item license', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+        await openItem(page, 'Test Item');
+
+        await openEditItemDialog(page);
+        // The item's current license is selected by default.
+        await expectLicenseSelect(page.locator('#g-license'), MIT_LICENSE);
+
+        await page.locator('#g-license').selectOption(APACHE_LICENSE);
+        await page.locator('.g-save-item').click();
+        await waitForIdlePage(page);
+
+        await expect(page.locator('.g-item-license')).toContainText(APACHE_LICENSE);
+    });
+
+    test('upload into an item does not show the license widget', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+        await openItem(page, 'Test Item');
+
+        await expect(page.locator('.g-upload-into-item:visible')).toHaveCount(1);
+        await page.locator('.g-upload-into-item:visible').click();
+        await expect.poll(() => page.evaluate(() => window.location.hash)).toContain('dialog=upload');
+        await waitForDialog(page);
+        await expect(page.locator('.g-start-upload:visible')).toContainText('Start Upload');
+
+        // Uploading into a specific item must not offer a license selection.
+        await expect(page.locator('#g-license')).toHaveCount(0);
+
+        // Close the dialog and return to the folder listing.
+        await page.locator('#g-dialog-container .modal-header .close').click();
+        await expect(page.locator('#g-dialog-container')).toBeHidden();
+        await backToPublicFolder(page);
+    });
+
+    test('upload a file into a folder, specifying a license', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+
+        await page.locator('.g-upload-here-button:visible').click();
+        await expect.poll(() => page.evaluate(() => window.location.hash)).toContain('dialog=upload');
+        await waitForDialog(page);
+        await expect(page.locator('.g-start-upload:visible')).toContainText('Start Upload');
+
+        // Uploading into a folder offers the license selection widget.
+        await expectLicenseSelect(page.locator('#g-license'), '');
+        await page.locator('#g-license').selectOption(APACHE_LICENSE);
+
+        await page.locator('#g-files').setInputFiles(path.join(__dirname, 'data', 'testFile.txt'));
+        await expect(page.locator('.g-start-upload')).toBeEnabled();
+        await page.locator('.g-start-upload').click();
+        await waitForIdlePage(page);
+        await expect(page.locator('#g-dialog-container')).toBeHidden();
+
+        await openItem(page, 'testFile.txt');
+        await expect(page.locator('.g-item-license')).toContainText(APACHE_LICENSE);
+
+        await backToPublicFolder(page);
+    });
+
+    test('create an item with an unspecified license', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+        await openCreateItemDialog(page);
+
+        await expectLicenseSelect(page.locator('#g-license'), '');
+
+        await page.locator('input#g-name').fill('Test Item 2');
+        await page.locator('#g-license').selectOption('');
+        await page.locator('.g-save-item').click();
+        await waitForIdlePage(page);
+
+        await openItem(page, 'Test Item 2');
+        await expect(page.locator('.g-item-license')).toContainText('Unspecified');
+    });
+
+    test('edit an item that has an unspecified license', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+        await openItem(page, 'Test Item 2');
+
+        await openEditItemDialog(page);
+        // The unspecified license is selected by default.
+        await expectLicenseSelect(page.locator('#g-license'), '');
+
+        await page.locator('#g-license').selectOption(MIT_LICENSE);
+        await page.locator('.g-save-item').click();
+        await waitForIdlePage(page);
+
+        await expect(page.locator('.g-item-license')).toContainText(MIT_LICENSE);
+    });
+
+    test('edit an item to have an unspecified license', async ({ page }) => {
+        await login(page, ADMIN.login, ADMIN.password);
+        await gotoMyFolders(page);
+        await openFolder(page, 'Public');
+        await openItem(page, 'Test Item 2');
+
+        await openEditItemDialog(page);
+        await expectLicenseSelect(page.locator('#g-license'), MIT_LICENSE);
+
+        await page.locator('#g-license').selectOption('');
+        await page.locator('.g-save-item').click();
+        await waitForIdlePage(page);
+
+        await expect(page.locator('.g-item-license')).toContainText('Unspecified');
+    });
+});