girder 5.0.19.dev20__tar.gz → 5.0.19.dev22__tar.gz

{girder-5.0.19.dev20/girder.egg-info → girder-5.0.19.dev22}/PKG-INFO

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

girder-5.0.19.dev22/girder/web/tests/spec/plugin_slicer_cli_web_config_view.spec.ts

@@ -0,0 +1,57 @@
+import { expect, Page, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, waitForIdlePage } from '../util';
+
+async function asyncRestRequest(page: Page, opts: any) {
+    return await page.evaluate((opts) => {
+        return new Promise((resolve, reject) => {
+            window.girder.rest.restRequest(opts).done((resp: any) => {
+                resolve(resp);
+            }).fail((resp: any) => {
+                reject(resp);
+            });
+        });
+    }, opts);
+}
+
+test.describe('Slicer CLI web config view', () => {
+    setupServer();
+
+    test('change the slicer_cli_web task folder setting', async ({ page }) => {
+        await createUser(page, 'admin');
+        await waitForIdlePage(page);
+
+        const me = await asyncRestRequest(page, { url: '/user/me' }) as any;
+        const folder = await asyncRestRequest(page, {
+            url: '/folder',
+            method: 'POST',
+            data: { name: 'Task Folder', parentType: 'user', parentId: me._id },
+        }) as any;
+        await waitForIdlePage(page);
+
+        // Navigate to the plugin's admin settings page.
+        await page.getByRole('link', { name: ' Admin console' }).click();
+        await page.getByRole('link', { name: ' Plugins' }).click();
+        const configLink = page.locator('.g-plugin-config-link[g-route="plugins/slicer_cli_web/config"]');
+        await expect(configLink).toBeVisible();
+        await configLink.click();
+
+        await expect(page.locator('#g-slicer-cli-web-form input#g-slicer-cli-web-upload-folder')).toBeVisible();
+
+        // Fill in the created folder and save.
+        await page.locator('#g-slicer-cli-web-upload-folder').fill(folder._id);
+        await expect(page.locator('#g-slicer-cli-web-upload-folder')).toHaveValue(folder._id);
+
+        // Save the settings.
+        await page.locator('#g-slicer-cli-web-form input.btn-primary').click();
+        await waitForIdlePage(page);
+
+        const settings = await asyncRestRequest(page, {
+            url: '/system/setting',
+            method: 'GET',
+            data: { list: JSON.stringify(['slicer_cli_web.task_folder']) },
+        }) as any;
+        expect(settings['slicer_cli_web.task_folder']).toBe(folder._id);
+    });
+});

girder-5.0.19.dev22/girder/web/tests/spec/plugin_slicer_cli_web_container_view.spec.ts

@@ -0,0 +1,79 @@
+import { expect, Page, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, logout, waitForIdlePage } from '../util';
+
+async function asyncRestRequest(page: Page, opts: any) {
+    return await page.evaluate((opts) => {
+        return new Promise((resolve, reject) => {
+            window.girder.rest.restRequest(opts).done((resp: any) => {
+                resolve(resp);
+            }).fail((resp: any) => {
+                reject(resp);
+            });
+        });
+    }, opts);
+}
+
+async function createDefaultTaskFolder(page: Page) {
+    const collection = await asyncRestRequest(page, {
+        url: '/collection',
+        method: 'POST',
+        data: { name: 'Tasks', description: 'Default Tasks', public: true },
+    }) as any;
+    const folder = await asyncRestRequest(page, {
+        url: '/folder',
+        method: 'POST',
+        data: {
+            name: 'Slicer CLI Web Tasks',
+            parentType: 'collection',
+            parentId: collection._id,
+            public: true,
+        },
+    }) as any;
+    await asyncRestRequest(page, {
+        url: '/system/setting',
+        method: 'PUT',
+        data: { key: 'slicer_cli_web.task_folder', value: folder._id },
+    });
+}
+
+async function navigateToCollectionsFolder(page: Page, collectionName: string, folderName: string) {
+    await page.locator('a.g-nav-link[g-target="collections"]').click();
+    await expect(page.locator('.g-collection-list-entry').first()).toBeVisible({ timeout: 10000 });
+    await page.locator('.g-collection-link', { hasText: collectionName }).first().click();
+    await expect(page.locator('.g-folder-list-link').first()).toBeVisible({ timeout: 10000 });
+    await page.locator('.g-folder-list-link', { hasText: folderName }).first().click();
+    await expect(page.locator('.g-hierarchy-widget').first()).toBeVisible({ timeout: 10000 });
+}
+
+test.describe('Slicer CLI web upload docker images button', () => {
+    setupServer();
+
+    test('the upload CLI task button is visible only for the admin-configured task folder', async ({ page }) => {
+        await createUser(page, 'admin');
+        await waitForIdlePage(page);
+        await createDefaultTaskFolder(page);
+        await waitForIdlePage(page);
+
+        await navigateToCollectionsFolder(page, 'Tasks', 'Slicer CLI Web Tasks');
+
+        // The button is visible for an admin in the configured task folder.
+        const uploadButton = page.locator('.g-upload-slicer-cli-task-button');
+        await expect(uploadButton).toBeVisible();
+
+        // Clicking it opens the upload image dialog.
+        await uploadButton.click();
+        await expect(page.locator('#g-slicer-cli-web-image')).toBeVisible();
+        await page.locator('#g-slicer-cli-web-upload-form button.close').click();
+        await expect(page.locator('#g-slicer-cli-web-image')).toBeHidden();
+
+        // A normal user never sees the button.
+        await logout(page);
+        await createUser(page, 'johndoe', 'john.doe@girder.test', 'John', 'Doe', 'password!');
+        await waitForIdlePage(page);
+
+        await navigateToCollectionsFolder(page, 'Tasks', 'Slicer CLI Web Tasks');
+        await expect(page.locator('.g-upload-slicer-cli-task-button')).toHaveCount(0);
+    });
+});

girder-5.0.19.dev22/girder/web/tests/spec/plugin_slicer_cli_web_item_selector.spec.ts

@@ -0,0 +1,159 @@
+import { expect, Page, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+import { createUser, waitForIdlePage } from '../util';
+
+async function asyncRestRequest(page: Page, opts: any) {
+    return await page.evaluate((opts) => {
+        return new Promise((resolve, reject) => {
+            window.girder.rest.restRequest(opts).done((resp: any) => {
+                resolve(resp);
+            }).fail((resp: any) => {
+                reject(resp);
+            });
+        });
+    }, opts);
+}
+
+async function selectedNames(page: Page) {
+    return page.evaluate(() => {
+        const girder = (window as any).girder;
+        const $ = girder.$;
+        const names: string[] = [];
+        $('.g-selected .g-item-list-link').each((index: number, el: any) => {
+            names.push($(el).clone().children().remove().end().text());
+        });
+        return names;
+    });
+}
+
+test.describe('Slicer CLI web item selector regex selection', () => {
+    setupServer();
+
+    test('browser hierarchy paginated selection', async ({ page }) => {
+        await createUser(page, 'admin');
+        await waitForIdlePage(page);
+
+        // Seed a folder hierarchy with many items through REST.
+        const me = await asyncRestRequest(page, { url: '/user/me' }) as any;
+        const folder = await asyncRestRequest(page, {
+            url: '/folder',
+            method: 'POST',
+            data: { name: 'top level folder', parentType: 'user', parentId: me._id },
+        }) as any;
+        await asyncRestRequest(page, {
+            url: '/folder',
+            method: 'POST',
+            data: { name: 'subfolder', parentType: 'folder', parentId: folder._id },
+        });
+        const item = await asyncRestRequest(page, {
+            url: '/item',
+            method: 'POST',
+            data: { name: 'an item', folderId: folder._id },
+        }) as any;
+        for (let i = 0; i < 20; i += 1) {
+            await asyncRestRequest(page, {
+                url: '/item',
+                method: 'POST',
+                data: { name: `item#: ${i}`, folderId: folder._id },
+            });
+        }
+        await waitForIdlePage(page);
+
+        // Instantiate the multi-file selector directly against the seeded folder.
+        await page.evaluate(async ({ folderId, itemId }) => {
+            const girder = (window as any).girder;
+            const slicer = girder.plugins.slicer_cli_web;
+            const folderModel = new girder.models.FolderModel({ _id: folderId });
+            await new Promise((resolve, reject) => {
+                folderModel.once('g:fetched', resolve).once('g:error', reject).fetch();
+            });
+            const itemModel = new girder.models.ItemModel({ _id: itemId });
+            const dialogEl = girder.$('<div/>').appendTo('body');
+            const selector = new slicer.views.ItemSelectorWidget({
+                parentView: { registerChildView: () => undefined },
+                el: dialogEl.get(0),
+                rootPath: folderModel,
+                root: folderModel,
+                defaultSelectedResource: itemModel,
+                selectItem: true,
+                showItems: true,
+                model: new slicer.models.WidgetModel({
+                    type: 'multi',
+                    title: 'Title',
+                    id: 'item-widget',
+                }),
+            });
+            selector.once('g:saved', () => {
+                selector.$el.modal('hide');
+            });
+            (window as any).__itemSelector = selector;
+            selector.render();
+        }, { folderId: folder._id, itemId: item._id });
+
+        await expect(page.locator('.g-item-list-entry')).toHaveCount(21);
+
+        const input = page.locator('#g-input-element');
+
+        await input.fill('[0-9][1-3]');
+        await expect(page.locator('.g-selected .g-item-list-link')).not.toHaveCount(0);
+        let names = await selectedNames(page);
+        expect(names).not.toContain('item#: 10');
+        expect(names).toContain('item#: 11');
+        expect(names).toContain('item#: 12');
+        expect(names).toContain('item#: 13');
+        expect(names).not.toContain('item#: 14');
+
+        await input.fill(' [4-7]$');
+        await expect(page.locator('.g-selected .g-item-list-link')).not.toHaveCount(0);
+        names = await selectedNames(page);
+        expect(names).toContain('item#: 4');
+        expect(names).toContain('item#: 5');
+        expect(names).toContain('item#: 6');
+        expect(names).toContain('item#: 7');
+        expect(names).not.toContain('item#: 14');
+        expect(names).not.toContain('item#: 17');
+
+        await input.fill('');
+        await expect(page.locator('.g-selected .g-item-list-link')).toHaveCount(21);
+
+        await input.fill('\\');
+        await expect(page.locator('.g-selected .g-item-list-link')).toHaveCount(0);
+        await expect(page.locator('.g-validation-failed-message:visible')).toHaveCount(1);
+
+        await page.evaluate(() => (window as any).__itemSelector.$('.g-submit-button').click());
+        await expect(page.locator('.g-validation-failed-message:visible')).toHaveCount(1);
+
+        // Resetting the selector re-highlights every item.
+        await page.evaluate(() => {
+            const selector = (window as any).__itemSelector;
+            selector.$('#g-input-element').val('');
+            selector._selectModel();
+            selector._hierarchyView.itemListView.trigger('g:changed');
+        });
+        await expect(page.locator('.g-selected .g-item-list-link')).toHaveCount(21);
+
+        await input.fill('[5]$');
+        await expect(page.locator('.g-selected .g-item-list-link')).not.toHaveCount(0);
+        names = await selectedNames(page);
+        expect(names).toContain('item#: 5');
+        expect(names).toContain('item#: 15');
+
+        await page.evaluate(() => (window as any).__itemSelector.$('.g-submit-button').click());
+        await expect.poll(() => page.evaluate(() => {
+            const model = (window as any).__itemSelector.model;
+            const value = model.get('value');
+            return value ? value.get('name') : null;
+        }), { timeout: 8000 }).toBe('[5]$');
+
+        const state = await page.evaluate(() => {
+            const model = (window as any).__itemSelector.model;
+            return {
+                path: model.get('path'),
+                folderName: model.get('folderName'),
+            };
+        });
+        expect(state.path.filter(Boolean)).toEqual(['top level folder']);
+        expect(state.folderName).toBe('top level folder');
+    });
+});

girder-5.0.19.dev22/girder/web/tests/spec/plugin_slicer_cli_web_panel_group.spec.ts

@@ -0,0 +1,89 @@
+import { expect, test } from '@playwright/test';
+
+import { setupServer } from '../server';
+
+const SPEC_XML = '' +
+    '<?xml version="1.0" encoding="UTF-8" ?>' +
+    '<executable>' +
+    '  <category>Example</category>' +
+    '  <title>Simple Example</title>' +
+    '  <description>Report on a few input parameters.</description>' +
+    '  <version>0.1.0</version>' +
+    '  <license>Apache 2.0</license>' +
+    '  <contributor>David Manthey (Kitware)</contributor>' +
+    '  <parameters>' +
+    '    <label>IO</label>' +
+    '    <description>Input/output parameters.</description>' +
+    '    <image>' +
+    '      <name>ImageFile</name>' +
+    '      <label>Input Image</label>' +
+    '      <channel>input</channel>' +
+    '      <description>Input image</description>' +
+    '      <index>0</index>' +
+    '    </image>' +
+    '    <double-vector>' +
+    '      <name>Color1</name>' +
+    '      <label>RGB Color</label>' +
+    '      <description>An RGB Color Vector</description>' +
+    '      <channel>input</channel>' +
+    '      <index>1</index>' +
+    '    </double-vector>' +
+    '    <double-vector>' +
+    '      <name>Color2</name>' +
+    '      <label>YCbCr Color</label>' +
+    '      <description>A YCBCr Color Vector</description>' +
+    '      <channel>input</channel>' +
+    '      <index>2</index>' +
+    '    </double-vector>' +
+    '  </parameters>' +
+    '</executable>';
+
+test.describe('Slicer CLI web panel group', () => {
+    setupServer();
+
+    test('panel group', async ({ page }) => {
+        const fails = await page.evaluate(async (xml) => {
+            const w = window as any;
+            const girder = w.girder;
+            const slicer = girder.plugins.slicer_cli_web;
+            const parentView = { registerChildView: () => undefined };
+            const el = girder.$('<div/>').appendTo('body');
+
+            const failures: string[] = [];
+            const is = (actual: any, expected: any, msg: string) => {
+                if (actual !== expected) {
+                    failures.push(`${msg}: expected ${JSON.stringify(expected)} got ${JSON.stringify(actual)}`);
+                }
+            };
+            const waitFor = (cond: () => boolean, timeout = 5000) => new Promise<void>((resolve, reject) => {
+                const start = Date.now();
+                const tick = () => {
+                    if (cond()) {
+                        resolve();
+                        return;
+                    }
+                    if (Date.now() - start > timeout) {
+                        reject(new Error('waitFor timeout'));
+                        return;
+                    }
+                    setTimeout(tick, 20);
+                };
+                tick();
+            });
+
+            const view = new slicer.views.PanelGroup({
+                closeButton: true,
+                parentView,
+                el: el.get(0),
+            });
+            view.render();
+            is(view.$el.hasClass('hidden'), true, 'hidden initially');
+
+            view.setAnalysis('/test', xml);
+            await waitFor(() => view.panels.length > 0);
+            is(view.panels.length, 1, 'panel count');
+            return failures;
+        }, SPEC_XML);
+        expect(fails).toEqual([]);
+    });
+});