girder 5.0.19.dev26__tar.gz → 5.0.19.dev42__tar.gz

{girder-5.0.19.dev26 → girder-5.0.19.dev42}/.pre-commit-config.yaml

@@ -69,8 +69,8 @@ repos:
         args:
           - --py310-plus
           - --keep-percent-format
-  - repo: https://github.com/pre-commit/mirrors-autopep8
-    rev: v2.0.4
+  - repo: https://github.com/hhatto/autopep8
+    rev: v2.3.2
     hooks:
       - id: autopep8
   - repo: https://github.com/PyCQA/flake8

{girder-5.0.19.dev26/girder.egg-info → girder-5.0.19.dev42}/PKG-INFO

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

{girder-5.0.19.dev26 → girder-5.0.19.dev42}/girder/models/__init__.py

@@ -10,15 +10,14 @@ _dbClients = {}
 logger = logging.getLogger(__name__)
 
 
+# pymongo 4 removed ``Cursor.count``.  Girder intentionally keeps a ``count`` method on
+# cursors, because endpoints return cursors and report a total count (for example via the
+# ``Girder-Total-Count`` header) alongside the requested records.  Rather than thread an
+# out-of-band count through every such call site, the shim reimplements the pymongo 3
+# behavior using ``count_documents``, which is the non-deprecated API.  Because this is the
+# sanctioned way to count a cursor here, it must not emit a deprecation warning.
 if not hasattr(pymongo.cursor.Cursor, 'count'):
-    import warnings
-
     def _cursorCount(self, with_limit_and_skip=False):
-        warnings.warn(
-            'count is deprecated. Use Collection.count_documents instead.',
-            DeprecationWarning,
-            stacklevel=2,
-        )
         params = {}
         if with_limit_and_skip and getattr(self, '_limit', getattr(self, '_Cursor__limit', None)):
             params['limit'] = getattr(self, '_limit', getattr(self, '_Cursor__limit', None))

{girder-5.0.19.dev26 → girder-5.0.19.dev42}/girder/notification.py

@@ -81,7 +81,7 @@ class UserNotificationsSocket(WebSocketEndpoint):
             pass
         finally:
             await self.pubsub.unsubscribe()
-            await self.pubsub.close()
+            await self.pubsub.aclose()
 
     async def on_disconnect(self, websocket, close_code):
         if hasattr(self, 'listen_task'):

{girder-5.0.19.dev26 → girder-5.0.19.dev42}/girder/web/playwright.config.ts

@@ -7,6 +7,16 @@ import { defineConfig, devices } from '@playwright/test';
  */
 export default defineConfig({
   testDir: './tests',
+  /* Test (and hook) timeout. This is intentionally larger than the expect
+   * timeout so that a slow assertion failure or a slow server startup under
+   * load does not consume the entire budget. */
+  timeout: 60000,
+  /* Default timeout for expect() assertions and web-first assertions. Tests
+   * should rely on this value rather than passing explicit timeouts, so that
+   * slower machines and CI runners do not cause flaky failures. */
+  expect: {
+    timeout: 20000,
+  },
   /* Run tests in files in parallel */
   fullyParallel: false,
   /* Fail the build on CI if test.only is in the source code. */
@@ -57,11 +67,4 @@ export default defineConfig({
       use: { ...devices['Desktop Firefox'] },
     },
   ],
-  webServer: {
-    command: 'npx vite dev --port 5173',
-    port: 5173,
-    reuseExistingServer: false,
-    // Disable Vite HMR when running tests so it doesn't consume inotify resources
-    env: { PLAYWRIGHT_TESTING: 'true' },
-  },
 });

{girder-5.0.19.dev26 → girder-5.0.19.dev42}/girder/web/tests/server.ts

@@ -1,4 +1,5 @@
 import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
+import { randomBytes } from 'crypto';
 
 import getPort from 'get-port';
 
@@ -9,13 +10,64 @@ import { outputCoverageReport, startCoverage } from './coverage';
 const mongoUri = process.env.GIRDER_CLIENT_TESTING_MONGO_URI ?? 'mongodb://localhost:27017';
 const girderExecutable = process.env.GIRDER_CLIENT_TESTING_GIRDER_EXECUTABLE ?? 'girder';
 
+/**
+ * Build a database name that is unique to this test server instance.
+ *
+ * This deliberately does not derive the database name from the port alone.
+ * Ports are recycled by the OS, so an interrupted prior run could leave a
+ * database behind that a later run would then reuse, leaking state (for
+ * example, a user registered by a previous run would cause "login already
+ * exists" failures). Combining the pid, a timestamp, and random bytes makes
+ * collisions effectively impossible.
+ */
+const createDatabaseName = () =>
+  `girder-${process.pid}-${Date.now()}-${randomBytes(4).toString('hex')}`;
+
+/**
+ * Drop a database, waiting for mongosh to finish. Failures are reported but
+ * never thrown, so that a cleanup problem cannot mask the actual test result.
+ */
+const dropDatabase = async (database: string) => {
+  const mongoshProcess = spawn('mongosh', [`${mongoUri}/${database}`, '--eval', 'db.dropDatabase();']);
 
-const startServer = async (port: number) => {
+  await new Promise<void>((resolve) => {
+    mongoshProcess?.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`mongo database ${database} cleanup failed with code`, code);
+      }
+      resolve();
+    });
+
+    mongoshProcess?.on('error', (err) => {
+      console.error(`mongosh process error -- database ${database} not cleaned up`, err);
+      resolve();
+    });
+  });
+};
+
+/**
+ * Wait for a server process to exit, but do not wait forever if it hangs.
+ */
+const killServer = async (serverProcess?: ChildProcessWithoutNullStreams) => {
+  if (!serverProcess) {
+    return;
+  }
+
+  await new Promise<void>((resolve) => {
+    const timeout = setTimeout(resolve, 5000);
+    serverProcess.once('close', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    serverProcess.kill();
+  });
+};
+
+const startServer = async (port: number, database: string) => {
   const serverLogs: string[] = [];
-  const database = `${mongoUri}/girder-${port}`;
   const serverProcess = spawn(girderExecutable, [
     'serve',
-    '--database', database,
+    '--database', `${mongoUri}/${database}`,
     '--port', `${port}`,
     '--with-temp-assetstore',
   ], {
@@ -45,11 +97,13 @@ const startServer = async (port: number) => {
 
 export const setupServer = () => {
   let serverProcess: ChildProcessWithoutNullStreams;
+  let database: string;
   let port: number;
 
   test.beforeAll(async () => {
     port = await getPort();
-    serverProcess = await startServer(port);
+    database = createDatabaseName();
+    serverProcess = await startServer(port, database);
   });
 
   test.afterAll(async () => {
@@ -57,32 +111,15 @@ export const setupServer = () => {
       if (serverProcess) {
         console.log('WARNING: Girder server is being kept alive after test ends. Use the following to kill it:');
         console.log(`kill ${serverProcess?.pid}`);
+        console.log(`Its database is: ${database}`);
       }
       return;
     }
 
-    serverProcess?.kill();
-
-    const mongoshProcess = spawn('mongosh', [`${mongoUri}/girder-${port}`, '--eval', 'db.dropDatabase();']);
-
-    await new Promise<void>((resolve) => {
-      mongoshProcess?.on('close', (code) => {
-        if (code === 0) {
-          if (serverProcess) {
-            serverProcess.serverLogs.push('mongo database cleaned up');
-          }
-        } else {
-          console.error('mongo database cleanup failed with code', code);
-        }
-
-        resolve();
-      });
-
-      mongoshProcess?.on('error', (err) => {
-        console.error('mongosh process error -- database not cleaned up', err);
-        resolve();
-      });
-    });
+    // Wait for the server to exit before dropping the database, so it cannot
+    // recreate collections after the drop.
+    await killServer(serverProcess);
+    await dropDatabase(database);
   });
 
   test.beforeEach(async ({ page }) => {

{girder-5.0.19.dev26 → girder-5.0.19.dev42}/girder/web/tests/spec/admin.spec.ts

@@ -33,8 +33,8 @@ test.describe('Create an admin and non-admin user', () => {
     await page.getByRole('button', { name: ' Create Group' }).click();
     await waitForDialog(page);
     await page.getByText('Public — Anyone can see this group').click();
-    await page.getByLabel('Name').fill('pubGroup', { timeout: 1000 });
-    await page.getByLabel('Description (optional)').fill('public group', { timeout: 1000 });
+    await page.getByLabel('Name').fill('pubGroup');
+    await page.getByLabel('Description (optional)').fill('public group');
     await page.getByRole('button', { name: ' Create', exact: true }).click();
   });
 });
@@ -62,16 +62,14 @@ test.describe('Test the assetstore page', () => {
     await createUser(page, 'admin', 'admin@girder.test', 'Admin', 'Admin', 'adminpassword!');
     // Navigate to assetstores page via Admin console
     await page.getByRole('link', { name: 'Admin console' }).click();
-    await expect(page.locator('.g-assetstore-config')).toBeVisible({ timeout: 10000 });
+    await expect(page.locator('.g-assetstore-config')).toBeVisible();
     await page.locator('.g-assetstore-config').click();
     // Wait for assetstores to load and render
-    await expect(page.locator('.g-assetstore-container').first()).toBeVisible({ timeout: 10000 });
+    await expect(page.locator('.g-assetstore-container').first()).toBeVisible();
     const testAssetstoreName = 'Test Filesystem Assetstore';
     // Open the filesystem tab and click create
     await page.locator('[data-target="#g-create-fs-tab"]').click();
-    await expect(page.locator('#g-create-fs-tab .g-new-assetstore-submit:visible')).toBeVisible({
-      timeout: 10000
-    });
+    await expect(page.locator('#g-create-fs-tab .g-new-assetstore-submit:visible')).toBeVisible();
     await page.locator('#g-create-fs-tab .g-new-assetstore-submit').click();
     // Wait for validation message to appear (empty required fields)
     const validationResult = page.locator('#g-create-fs-tab .g-validation-failed-message:visible');
@@ -93,7 +91,7 @@ test.describe('Test the assetstore page', () => {
     await waitForIdlePage(page);
     // Navigate away and back to verify assetstore persists
     await page.getByRole('link', { name: 'Admin console' }).click();
-    await expect(page.locator('.g-assetstore-config')).toBeVisible({ timeout: 10000 });
+    await expect(page.locator('.g-assetstore-config')).toBeVisible();
     await page.locator('.g-assetstore-config').click();
     await expect(page.locator('.g-assetstore-container').first()).toBeVisible();
     // Verify the assetstore is still current (should have "is current" label)
@@ -125,10 +123,10 @@ test.describe('Test the settings page', () => {
     await createUser(page, 'admin', 'admin@girder.test', 'Admin', 'Admin', 'adminpassword!');
     // Navigate to settings page via Admin console
     await page.getByRole('link', { name: 'Admin console' }).click();
-    await expect(page.locator('.g-server-config')).toBeVisible({ timeout: 10000 });
+    await expect(page.locator('.g-server-config')).toBeVisible();
     await page.locator('.g-server-config').click();
     // Wait for settings page to load - title section and form should appear
-    await expect(page.getByText('System configuration')).toBeVisible({ timeout: 10000 });
+    await expect(page.getByText('System configuration')).toBeVisible();
     // Verify main sections exist on the settings page (read-only in Girder 5.x)
     await expect(page.getByText('Instance Branding')).toBeVisible();
     await expect(page.getByText('Administrative Policy')).toBeVisible();
@@ -167,7 +165,7 @@ test.describe('Test the plugins page', () => {
     await page.getByRole('link', { name: ' Admin console' }).click();
     await page.getByRole('link', { name: ' Plugins' }).click();
     // Wait for the plugin list to load - at least core plugins should be present
-    await expect(page.locator('.g-plugin-list-container')).toBeVisible({ timeout: 10000 });
+    await expect(page.locator('.g-plugin-list-container')).toBeVisible();
     // Check that there is at least one plugin (core plugins should always be present)
     const pluginCount = await page.locator('.g-plugin-list-item').count();
     expect(pluginCount).toBeGreaterThanOrEqual(1);