@oceanum/oceanumlab 4.7.0 → 4.7.2

package/src/__tests__/StoredNotebooks.spec.tsx

@@ -0,0 +1,157 @@
+import { ReactWidget } from '@jupyterlab/ui-components';
+import { Signal } from '@lumino/signaling';
+import { Widget } from '@lumino/widgets';
+import React from 'react';
+
+import { IOceanumAuth, IOceanumUser } from '../auth/tokens';
+import { notebooksChanged } from '../share/events';
+import { StoredNotebooks } from '../StoredNotebooks';
+
+/** A signed-out auth that records whether sign-in was asked for. */
+function signedOut(): IOceanumAuth & { signIns: number } {
+  const auth = {
+    signIns: 0,
+    environment: null as IOceanumAuth['environment'],
+    urls: { specs: 'https://specs.example.com' },
+    ready: Promise.resolve(),
+    user: null as IOceanumUser | null,
+    userChanged: new Signal<IOceanumAuth, IOceanumUser | null>(
+      {} as IOceanumAuth
+    ),
+    tokenChanged: new Signal<IOceanumAuth, string | null>({} as IOceanumAuth),
+    signIn: async (): Promise<void> => {
+      auth.signIns += 1;
+    },
+    signOut: async (): Promise<void> => undefined,
+    getAccessToken: async (): Promise<string | null> => null
+  };
+  return auth as unknown as IOceanumAuth & { signIns: number };
+}
+
+class Harness extends ReactWidget {
+  constructor(
+    private readonly _auth: IOceanumAuth,
+    private readonly _onSignIn?: () => void
+  ) {
+    super();
+  }
+
+  render(): React.ReactElement {
+    return <StoredNotebooks auth={this._auth} onSignIn={this._onSignIn} />;
+  }
+}
+
+async function mount(
+  auth: IOceanumAuth,
+  onSignIn?: () => void
+): Promise<Harness> {
+  const widget = new Harness(auth, onSignIn);
+  Widget.attach(widget, document.body);
+  const deadline = Date.now() + 4000;
+  for (;;) {
+    if (widget.node.querySelector('.oceanum-text-empty')) {
+      return widget;
+    }
+    if (Date.now() > deadline) {
+      throw new Error('StoredNotebooks rendered nothing within 4s');
+    }
+    await new Promise(resolve => setTimeout(resolve, 25));
+  }
+}
+
+describe('the Notebooks tab while signed in', () => {
+  const ID = '6f1c1a52-4b8e-4c0f-9a57-1d2e3f4a5b6c';
+
+  it('lists again when a record is created, renamed or deleted', async () => {
+    const auth = signedOut();
+    (auth as { user: IOceanumUser | null }).user = {
+      sub: 'auth0|1',
+      email: 'me@example.com',
+      name: null,
+      activeOrg: null,
+      colorScheme: null
+    };
+    auth.getAccessToken = async () => 'tok';
+    const fetches: string[] = [];
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async (input: RequestInfo | URL) => {
+      fetches.push(String(input));
+      return {
+        ok: true,
+        status: 200,
+        json: async () => [
+          {
+            id: ID,
+            name: 'Waves',
+            description: null as string | null,
+            modified: '2026-09-12T10:00:00',
+            creator: 'me@example.com'
+          }
+        ]
+      } as unknown as Response;
+    }) as typeof fetch;
+    try {
+      const widget = new Harness(auth);
+      Widget.attach(widget, document.body);
+      const until = async (test: () => boolean): Promise<void> => {
+        const deadline = Date.now() + 4000;
+        while (!test()) {
+          if (Date.now() > deadline) {
+            throw new Error('timed out');
+          }
+          await new Promise(resolve => setTimeout(resolve, 25));
+        }
+      };
+      await until(() => !!widget.node.querySelector('.oceanum-notebooks-item'));
+      expect(fetches).toHaveLength(1);
+      const row = widget.node.querySelector('.oceanum-notebooks-item')!;
+      expect(row.getAttribute('data-spec-id')).toBe(ID);
+
+      notebooksChanged.emit();
+
+      await until(() => fetches.length === 2);
+      widget.dispose();
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});
+
+describe('the Notebooks tab while signed out', () => {
+  it('links "Sign in" to starting a sign-in', async () => {
+    const auth = signedOut();
+    const widget = await mount(auth);
+
+    expect(widget.node.textContent).toContain(
+      'Sign in to Oceanum.io to see your notebooks.'
+    );
+    const link = widget.node.querySelector<HTMLAnchorElement>(
+      '.oceanum-text-empty a'
+    );
+    expect(link?.textContent).toBe('Sign in');
+
+    link!.click();
+    expect(auth.signIns).toBe(1);
+
+    widget.dispose();
+  });
+
+  it("prefers the host's own way of signing in when given one", async () => {
+    // On a JupyterLab server that is the device sign-in command, which shows the
+    // code; the auth's signIn() alone would start the flow with nothing to look at.
+    const auth = signedOut();
+    let hostSignIns = 0;
+    const widget = await mount(auth, () => {
+      hostSignIns += 1;
+    });
+
+    widget.node
+      .querySelector<HTMLAnchorElement>('.oceanum-text-empty a')!
+      .click();
+
+    expect(hostSignIns).toBe(1);
+    expect(auth.signIns).toBe(0);
+
+    widget.dispose();
+  });
+});

package/src/__tests__/Tabs.spec.tsx

@@ -0,0 +1,168 @@
+import { ReactWidget } from '@jupyterlab/ui-components';
+import { Widget } from '@lumino/widgets';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import React from 'react';
+
+import { ITab, Tabs } from '../Tabs';
+
+/** A widget whose sole job is to render the tab strip so the DOM can be inspected. */
+class Harness extends ReactWidget {
+  selected = 'one';
+  readonly selections: string[] = [];
+
+  constructor(private readonly _tabs: ITab[]) {
+    super();
+  }
+
+  render(): React.ReactElement {
+    return (
+      <Tabs
+        tabs={this._tabs}
+        selected={this.selected}
+        onSelect={id => {
+          this.selections.push(id);
+          this.selected = id;
+          this.update();
+        }}
+      />
+    );
+  }
+}
+
+const TABS: ITab[] = [
+  { id: 'one', label: 'One', render: () => <p>first pane</p> },
+  { id: 'two', label: 'Two', render: () => <p>second pane</p> },
+  { id: 'three', label: 'Three', render: () => <p>third pane</p> }
+];
+
+async function mount(): Promise<Harness> {
+  const widget = new Harness(TABS);
+  Widget.attach(widget, document.body);
+  // ReactWidget renders on an animation frame, so wait for the first pane rather than
+  // sleeping a fixed 50ms and hoping. That wait was enough on a warm run and not on a cold
+  // one: the first run after a fresh install, with an empty ts-jest cache, rendered nothing
+  // in time and every test here failed at once with zero panes -- which reads like a broken
+  // component rather than a slow one.
+  const deadline = Date.now() + 4000;
+  for (;;) {
+    if (widget.node.querySelector('[role="tabpanel"]')) {
+      return widget;
+    }
+    if (Date.now() > deadline) {
+      throw new Error('Tabs rendered no panes within 4s');
+    }
+    await new Promise(resolve => setTimeout(resolve, 25));
+  }
+}
+
+function strip(widget: Harness): HTMLElement[] {
+  return Array.from(widget.node.querySelectorAll<HTMLElement>('[role="tab"]'));
+}
+
+function panels(widget: Harness): HTMLElement[] {
+  return Array.from(
+    widget.node.querySelectorAll<HTMLElement>('[role="tabpanel"]')
+  );
+}
+
+describe('Tabs', () => {
+  it('marks only the selected tab, and puts only it in the tab order', async () => {
+    const widget = await mount();
+    const tabs = strip(widget);
+
+    expect(tabs.map(t => t.textContent)).toEqual(['One', 'Two', 'Three']);
+    expect(tabs.map(t => t.getAttribute('aria-selected'))).toEqual([
+      'true',
+      'false',
+      'false'
+    ]);
+    // A single tab stop for the strip: Tab moves past it, arrows move within it.
+    expect(tabs.map(t => t.tabIndex)).toEqual([0, -1, -1]);
+
+    widget.dispose();
+  });
+
+  it('keeps every pane mounted and hides the inactive ones', async () => {
+    // Unmounting would discard the AI conversation whenever the user switches away.
+    const widget = await mount();
+    const rendered = panels(widget);
+
+    expect(rendered).toHaveLength(3);
+    expect(rendered.map(p => p.hidden)).toEqual([false, true, true]);
+    expect(widget.node.textContent).toContain('second pane');
+
+    widget.dispose();
+  });
+
+  it('the stylesheet actually hides them', async () => {
+    // `hidden` is only a hint: an author `display` on .oceanum-tabpanel overrides the
+    // user agent's `[hidden] { display: none }`, and asserting the IDL property above
+    // cannot see that. This renders the real stylesheet and asks for the computed value.
+    const css = readFileSync(
+      join(__dirname, '..', '..', 'style', 'index.css'),
+      'utf8'
+    );
+    const style = document.createElement('style');
+    style.textContent = css;
+    document.head.appendChild(style);
+
+    const widget = await mount();
+    const [active, inactive] = panels(widget);
+    expect(getComputedStyle(active).display).not.toBe('none');
+    expect(getComputedStyle(inactive).display).toBe('none');
+
+    widget.dispose();
+    style.remove();
+  });
+
+  it('moves with the arrow keys, wrapping at both ends', async () => {
+    const widget = await mount();
+    // ReactWidget re-renders on an animation frame, so each key has to land on the
+    // render that the previous one produced.
+    const settle = (): Promise<void> =>
+      new Promise(resolve => setTimeout(resolve, 50));
+
+    strip(widget)[0].dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true })
+    );
+    expect(widget.selections.pop()).toBe('two');
+    await settle();
+
+    strip(widget)[1].dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'ArrowLeft', bubbles: true })
+    );
+    expect(widget.selections.pop()).toBe('one');
+    await settle();
+
+    // Wrapping: left from the first tab reaches the last.
+    strip(widget)[0].dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'ArrowLeft', bubbles: true })
+    );
+    expect(widget.selections.pop()).toBe('three');
+
+    widget.dispose();
+  });
+
+  it('jumps to the ends with Home and End', async () => {
+    const widget = await mount();
+
+    strip(widget)[0].dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'End', bubbles: true })
+    );
+    expect(widget.selections.pop()).toBe('three');
+
+    widget.dispose();
+  });
+
+  it('falls back to the first tab when the selection names no tab', async () => {
+    const widget = new Harness(TABS);
+    widget.selected = 'gone';
+    Widget.attach(widget, document.body);
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    expect(strip(widget)[0].getAttribute('aria-selected')).toBe('true');
+
+    widget.dispose();
+  });
+});

package/src/__tests__/aiBackend.spec.ts

@@ -1,4 +1,3 @@
-import schema from '../../schema/datamesh-connect.json';
 import {
   ACCESS_TOKEN_COMMAND,
   SIGN_IN_COMMAND,
@@ -15,11 +14,11 @@ import { OCEANUM_AI_BACKEND_URL } from '../constants';
 import { validHttpUrl } from '../httpUrl';
 
 describe('aiBackendUrl', () => {
-  it('is the default the settings schema offers', () => {
-    expect(schema.properties.aiBackendUrl.default).toBe(OCEANUM_AI_BACKEND_URL);
-    expect(aiBackendUrl(schema.properties.aiBackendUrl.default)).toBe(
-      'https://ai.oceanum.io'
-    );
+  it('is production when the deployment names no address', () => {
+    // What index.ts passes when the sign-in environment has no `ai` URL, or there is no
+    // sign-in at all.
+    expect(aiBackendUrl('')).toBe(OCEANUM_AI_BACKEND_URL);
+    expect(aiBackendUrl(undefined)).toBe('https://ai.oceanum.io');
   });
 
   it.each([

package/src/__tests__/chatRouter.spec.ts

@@ -417,12 +417,10 @@ describe('ChatRouter: where a request goes, and what it is signed with', () => {
 
   it('sends to the configured address, without a double slash', async () => {
     const router = new ChatRouter(
-      settingsWith({
-        datameshToken: 'a-token',
-        aiBackendUrl: ' https://ai.oceanum.tech/ '
-      }),
+      settings,
       noSignIn,
-      noNotebook
+      noNotebook,
+      () => ' https://ai.oceanum.tech/ '
     );
 
     await router.route('hello');
@@ -434,12 +432,10 @@ describe('ChatRouter: where a request goes, and what it is signed with', () => {
 
   it('sends to the default for an invalid address', async () => {
     const router = new ChatRouter(
-      settingsWith({
-        datameshToken: 'a-token',
-        aiBackendUrl: 'javascript:alert(1)'
-      }),
+      settings,
       noSignIn,
-      noNotebook
+      noNotebook,
+      () => 'javascript:alert(1)'
     );
 
     await router.route('hello');
@@ -542,12 +538,10 @@ describe('ChatRouter: where a request goes, and what it is signed with', () => {
       throw new TypeError('Failed to fetch');
     });
     const router = new ChatRouter(
-      settingsWith({
-        datameshToken: 'a-token',
-        aiBackendUrl: 'http://localhost:8000/'
-      }),
+      settings,
       noSignIn,
-      noNotebook
+      noNotebook,
+      () => 'http://localhost:8000/'
     );
 
     await expect(router.route('hello')).rejects.toThrow(

package/src/__tests__/datameshUiUrl.spec.ts

@@ -1,4 +1,3 @@
-import schema from '../../schema/datamesh-connect.json';
 import { DATAMESH_UI_SERVICE } from '../constants';
 import {
   datameshUiSrc,
@@ -7,8 +6,10 @@ import {
 } from '../datameshUiUrl';
 
 describe('validDatameshUiUrl', () => {
-  it('is the default the settings schema offers', () => {
-    expect(schema.properties.datameshUiUrl.default).toBe(DATAMESH_UI_SERVICE);
+  it('is production when the deployment names no address', () => {
+    expect(validDatameshUiUrl(undefined).href).toBe(
+      new URL(DATAMESH_UI_SERVICE).href
+    );
   });
 
   it('takes an http(s) address as it is', () => {

package/src/__tests__/oceanumOnly.spec.ts

@@ -0,0 +1,193 @@
+import type { INotebookTracker, NotebookPanel } from '@jupyterlab/notebook';
+import { CommandRegistry } from '@lumino/commands';
+import { Signal } from '@lumino/signaling';
+import { Menu, Panel, Widget } from '@lumino/widgets';
+
+import {
+  FILE_BROWSER_ID,
+  hideFileBrowser,
+  LOCAL_FILE_COMMANDS,
+  pruneBeforeEachOpen,
+  pruneFileMenu,
+  routeSaves
+} from '../share/oceanumOnly';
+
+describe('hideFileBrowser', () => {
+  it('closes the file browser without disposing it, and leaves the rest', () => {
+    const left = new Panel();
+    const browser = new Widget();
+    browser.id = FILE_BROWSER_ID;
+    const running = new Widget();
+    running.id = 'jp-running-sessions';
+    left.addWidget(browser);
+    left.addWidget(running);
+
+    expect(hideFileBrowser({ widgets: () => left.widgets })).toBe(true);
+
+    expect(left.widgets).toEqual([running]);
+    // Other extensions still hold it through IDefaultFileBrowser.
+    expect(browser.isDisposed).toBe(false);
+  });
+
+  it('reports when there is none to hide', () => {
+    const left = new Panel();
+    expect(hideFileBrowser({ widgets: () => left.widgets })).toBe(false);
+  });
+});
+
+function fileMenu(commands: string[]): {
+  menu: Menu;
+  registry: CommandRegistry;
+} {
+  const registry = new CommandRegistry();
+  const menu = new Menu({ commands: registry });
+  for (const command of commands) {
+    if (command === '-') {
+      menu.addItem({ type: 'separator' });
+      continue;
+    }
+    registry.addCommand(command, { execute: () => undefined, label: command });
+    menu.addItem({ command });
+  }
+  return { menu, registry };
+}
+
+const menuCommands = (menu: Menu): string[] =>
+  menu.items.map(item => (item.type === 'separator' ? '-' : item.command));
+
+describe('pruneFileMenu', () => {
+  it('drops the local-file entries and keeps Save, Rename and everything else', () => {
+    const { menu } = fileMenu([
+      'filebrowser:open-path',
+      'filebrowser:open-url',
+      '-',
+      'docmanager:save',
+      'docmanager:save-as',
+      'docmanager:save-all',
+      '-',
+      'docmanager:reload',
+      'docmanager:restore-checkpoint',
+      'docmanager:rename',
+      'docmanager:duplicate',
+      '-',
+      'docmanager:download',
+      'oceanum-share:save'
+    ]);
+
+    expect(pruneFileMenu(menu)).toBe(7);
+
+    expect(menuCommands(menu)).toEqual([
+      '-',
+      'docmanager:save',
+      'docmanager:save-all',
+      '-',
+      'docmanager:rename',
+      '-',
+      'oceanum-share:save'
+    ]);
+    // Idempotent: nothing left to remove.
+    expect(pruneFileMenu(menu)).toBe(0);
+  });
+
+  it('drops the Open Recent submenu, which the document manager builds by hand', () => {
+    const { menu, registry } = fileMenu(['docmanager:save']);
+    registry.addCommand('docmanager:clear-recents', {
+      execute: () => undefined,
+      label: 'Clear Recent'
+    });
+    const recents = new Menu({ commands: registry });
+    recents.title.label = 'Open Recent';
+    recents.addItem({ command: 'docmanager:clear-recents' });
+    menu.addItem({ type: 'submenu', submenu: recents });
+    const other = new Menu({ commands: registry });
+    other.title.label = 'New';
+    menu.addItem({ type: 'submenu', submenu: other });
+
+    expect(pruneFileMenu(menu)).toBe(1);
+
+    expect(menu.items.map(item => item.type)).toEqual(['command', 'submenu']);
+    expect(menu.items[1].submenu?.title.label).toBe('New');
+  });
+
+  it('names every entry it prunes, so the list is reviewable', () => {
+    expect(LOCAL_FILE_COMMANDS).toEqual([
+      'filebrowser:open-path',
+      'filebrowser:open-url',
+      'docmanager:save-as',
+      'docmanager:reload',
+      'docmanager:restore-checkpoint',
+      'docmanager:duplicate',
+      'docmanager:download'
+    ]);
+  });
+});
+
+describe('pruneBeforeEachOpen', () => {
+  it('prunes entries that arrive after the first pass, each time the menu opens', () => {
+    const { menu, registry } = fileMenu(['docmanager:save']);
+    pruneBeforeEachOpen(menu);
+    // A plugin's settings schema loads late and adds its entry.
+    registry.addCommand('docmanager:save-as', {
+      execute: () => undefined,
+      label: 'Save As'
+    });
+    menu.addItem({ command: 'docmanager:save-as' });
+    expect(menuCommands(menu)).toEqual([
+      'docmanager:save',
+      'docmanager:save-as'
+    ]);
+
+    menu.open(0, 0);
+    try {
+      expect(menuCommands(menu)).toEqual(['docmanager:save']);
+    } finally {
+      menu.close();
+      menu.dispose();
+    }
+  });
+});
+
+/** Just enough of a notebook tracker and its panels to route saves. */
+function fakeTracker(): {
+  tracker: INotebookTracker;
+  add: () => { panel: NotebookPanel; saveState: Signal<unknown, string> };
+} {
+  const panels: NotebookPanel[] = [];
+  const widgetAdded = new Signal<INotebookTracker, NotebookPanel>(
+    {} as INotebookTracker
+  );
+  const tracker = {
+    forEach: (fn: (panel: NotebookPanel) => void) => panels.forEach(fn),
+    widgetAdded
+  } as unknown as INotebookTracker;
+  const add = () => {
+    const saveState = new Signal<unknown, string>({});
+    const panel = { context: { saveState } } as unknown as NotebookPanel;
+    panels.push(panel);
+    widgetAdded.emit(panel);
+    return { panel, saveState };
+  };
+  return { tracker, add };
+}
+
+describe('routeSaves', () => {
+  it('pushes after every completed save, of notebooks open now and later', () => {
+    const { tracker, add } = fakeTracker();
+    const first = add();
+    const pushed: NotebookPanel[] = [];
+    routeSaves(tracker, async panel => {
+      pushed.push(panel);
+    });
+
+    first.saveState.emit('started');
+    expect(pushed).toEqual([]);
+    first.saveState.emit('completed');
+    expect(pushed).toEqual([first.panel]);
+
+    const second = add();
+    second.saveState.emit('completed');
+    second.saveState.emit('failed');
+    first.saveState.emit('completed');
+    expect(pushed).toEqual([first.panel, second.panel, first.panel]);
+  });
+});

package/src/__tests__/pluginArity.spec.ts

@@ -0,0 +1,24 @@
+import plugins from '../index';
+
+/**
+ * JupyterLab passes `requires` then `optional` to `activate`, positionally, after the
+ * application. Omitting a parameter for a dependency you do not use does not skip it —
+ * it shifts every later argument along by one, silently handing the wrong object to the
+ * wrong parameter. TypeScript cannot see this: `activate` is typed loosely enough that
+ * the mismatch compiles, and unit tests that never activate the plugin never notice.
+ *
+ * This bit exactly once: adding an optional IOceanumAuth to a plugin whose signature
+ * had quietly omitted its IStateDB meant `auth` received the state database, and the
+ * panel crashed on `auth.userChanged.connect` at application start.
+ */
+describe('plugin activate signatures', () => {
+  it.each(plugins.map(plugin => [plugin.id, plugin] as const))(
+    '%s takes one parameter per declared dependency',
+    (_id, plugin) => {
+      const declared =
+        (plugin.requires?.length ?? 0) + (plugin.optional?.length ?? 0);
+      // +1 for the JupyterFrontEnd itself.
+      expect(plugin.activate.length).toBe(declared + 1);
+    }
+  );
+});