@oceanum/oceanumlab 4.8.0 → 4.10.0

package/src/__tests__/StoredNotebooks.spec.tsx

@@ -86,7 +86,10 @@ describe('the Notebooks tab while signed in', () => {
     const fetches: string[] = [];
     const originalFetch = globalThis.fetch;
     globalThis.fetch = (async (input: RequestInfo | URL) => {
-      fetches.push(String(input));
+      // Counts the notebook listing only; each load also lists the demos.
+      if (String(input).endsWith('/specs/notebook')) {
+        fetches.push(String(input));
+      }
       return {
         ok: true,
         status: 200,
@@ -130,53 +133,41 @@ describe('the Notebooks tab while signed in', () => {
 
 describe('the Examples in the Notebooks tab', () => {
   const MINE = '6f1c1a52-4b8e-4c0f-9a57-1d2e3f4a5b6c';
-  const PUBLIC_EXAMPLE = '0b7d9f2e-1111-4a2b-8c3d-9e8f7a6b5c4d';
-  const OTHER_EXAMPLE = '1c2d3e4f-2222-4a2b-8c3d-9e8f7a6b5c4d';
+  const QUERY = '0b7d9f2e-1111-4a2b-8c3d-9e8f7a6b5c4d';
+  const PLOT = '1c2d3e4f-2222-4a2b-8c3d-9e8f7a6b5c4d';
   const SHARED = '2d3e4f5a-3333-4a2b-8c3d-9e8f7a6b5c4d';
-  const DEMO_ID = '3e4f5a6b-4444-4a2b-8c3d-9e8f7a6b5c4d';
-
-  const summary = (id: string, name: string, creator: string | null) => ({
+  const SPECTRA = '3e4f5a6b-4444-4a2b-8c3d-9e8f7a6b5c4d';
+
+  const summary = (
+    id: string,
+    name: string,
+    creator: string | null,
+    description: string | null = null
+  ) => ({
     id,
     name,
-    description: null as string | null,
+    description,
     modified: '2026-09-12T10:00:00',
     creator
   });
 
-  // The listing returns a public example as shared with every signed-in user.
+  // The user's notebooks.
   const LISTING = [
     summary(MINE, 'Mine', 'me@example.com'),
-    summary(PUBLIC_EXAMPLE, 'Query (example)', null),
     summary(SHARED, 'Shared', null)
   ];
 
-  const DEMO = {
-    ...summary(DEMO_ID, 'Notebook Demo', null),
-    spec: {
-      kind: 'notebook-demo',
-      version: 1,
-      sections: [
-        {
-          title: 'Getting started',
-          items: [
-            {
-              id: PUBLIC_EXAMPLE,
-              title: 'Query a datasource',
-              summary: 'One line'
-            },
-            { id: OTHER_EXAMPLE, title: 'Plot waves' }
-          ]
-        },
-        // A curator's own example is also theirs: it stays in My notebooks.
-        { title: 'Advanced', items: [{ id: MINE, title: 'Spectra' }] }
-      ]
-    }
-  };
+  // The Notebook Demo specs, each one an example notebook, in no particular order.
+  const DEMOS = [
+    summary(PLOT, '10 Plot waves', null),
+    summary(SPECTRA, 'Spectra', null),
+    summary(QUERY, '2 Query a datasource', null, 'One line')
+  ];
 
   const ok = (data: unknown): Response =>
     ({ ok: true, status: 200, json: async () => data }) as unknown as Response;
 
-  function signedIn(notebookDemo?: string): IOceanumAuth {
+  function signedIn(): IOceanumAuth {
     const auth = signedOut();
     (auth as { user: IOceanumUser | null }).user = {
       sub: 'auth0|1',
@@ -186,20 +177,19 @@ describe('the Examples in the Notebooks tab', () => {
       colorScheme: null
     };
     auth.getAccessToken = async () => 'tok';
-    (auth as { environment: unknown }).environment = notebookDemo
-      ? { notebookDemo }
-      : {};
+    (auth as { environment: unknown }).environment = {};
     return auth;
   }
 
   const originalFetch = globalThis.fetch;
   let fetches: string[];
-  function stubFetch(demo: () => Response = () => ok(DEMO)): void {
+  const DEMO_LISTING = 'https://specs.example.com/specs/notebook-demo';
+  function stubFetch(demos: () => Response = () => ok(DEMOS)): void {
     fetches = [];
     globalThis.fetch = (async (input: RequestInfo | URL) => {
       const url = String(input);
       fetches.push(url);
-      return url.includes('/specs/notebook-demo/') ? demo() : ok(LISTING);
+      return url === DEMO_LISTING ? demos() : ok(LISTING);
     }) as typeof fetch;
   }
   afterEach(() => {
@@ -268,73 +258,83 @@ describe('the Examples in the Notebooks tab', () => {
     Widget.detach(widget);
   });
 
-  it('lists the record’s examples in order, under their section titles', async () => {
+  it('lists every Notebook Demo spec as an example, ordered by name', async () => {
     stubFetch();
-    const widget = await render(signedIn(DEMO_ID));
+    const widget = await render(signedIn());
 
     const examples = section(widget, 'Examples')!;
     expect(examples).not.toBeNull();
-    expect(
-      Array.from(
-        examples.querySelectorAll('.oceanum-notebooks-subheading'),
-        node => node.textContent
-      )
-    ).toEqual(['Getting started', 'Advanced']);
     const rows = Array.from(
       examples.querySelectorAll<HTMLElement>('[data-example-id]')
     );
+    // Numbered as people number them: 2 before 10.
     expect(rows.map(row => row.textContent)).toEqual([
-      'Query a datasource',
-      'Plot waves',
+      '2 Query a datasource',
+      '10 Plot waves',
       'Spectra'
     ]);
     expect(rows.map(row => row.getAttribute('data-example-id'))).toEqual([
-      PUBLIC_EXAMPLE,
-      OTHER_EXAMPLE,
-      MINE
+      QUERY,
+      PLOT,
+      SPECTRA
     ]);
     expect(rows[0].getAttribute('title')).toBe('One line');
     expect(
       examples.querySelector('.oceanum-notebooks-count')?.textContent
     ).toBe('3');
-    expect(fetches).toContain(
-      `https://specs.example.com/specs/notebook-demo/${DEMO_ID}`
-    );
+    expect(fetches).toContain(DEMO_LISTING);
     widget.dispose();
   });
 
-  it('moves examples out of Shared with me, but leaves My notebooks alone', async () => {
+  it('leaves My notebooks and Shared with me as listed', async () => {
     stubFetch();
-    const widget = await render(signedIn(DEMO_ID));
+    const widget = await render(signedIn());
 
+    expect(idsIn(section(widget, 'My notebooks'), 'data-spec-id')).toEqual([
+      MINE
+    ]);
     expect(idsIn(section(widget, 'Shared with me'), 'data-spec-id')).toEqual([
       SHARED
     ]);
+    widget.dispose();
+  });
+
+  it('shows no Examples section when there are no demos', async () => {
+    stubFetch(() => ok([]));
+    const widget = await render(signedIn());
+
+    expect(section(widget, 'Examples')).toBeNull();
+    widget.dispose();
+  });
+
+  it('shows no Examples, and no error, where the store has no Notebook Demo type', async () => {
+    stubFetch(
+      () => ({ ok: false, status: 404, json: async () => ({}) }) as Response
+    );
+    const widget = await render(signedIn());
+
+    expect(section(widget, 'Examples')).toBeNull();
     expect(idsIn(section(widget, 'My notebooks'), 'data-spec-id')).toEqual([
       MINE
     ]);
     widget.dispose();
   });
 
-  it('asks for nothing more and shows no Examples where none is configured', async () => {
+  it('asks for no demos while signed out', async () => {
     stubFetch();
-    const widget = await render(signedIn());
+    const widget = new Harness(signedOut());
+    Widget.attach(widget, document.body);
+    await new Promise(resolve => setTimeout(resolve, 100));
 
-    expect(section(widget, 'Examples')).toBeNull();
-    expect(fetches).toEqual(['https://specs.example.com/specs/notebook']);
-    // Without a record, a public example is just another shared notebook.
-    expect(idsIn(section(widget, 'Shared with me'), 'data-spec-id')).toEqual([
-      PUBLIC_EXAMPLE,
-      SHARED
-    ]);
+    expect(fetches).toEqual([]);
     widget.dispose();
   });
 
-  it('says so when the record cannot be read, and still lists the rest', async () => {
+  it('says so when the demos cannot be listed, and still lists the rest', async () => {
     stubFetch(
-      () => ({ ok: false, status: 404, json: async () => ({}) }) as Response
+      () => ({ ok: false, status: 500, json: async () => ({}) }) as Response
     );
-    const widget = await render(signedIn(DEMO_ID));
+    const widget = await render(signedIn());
 
     const examples = section(widget, 'Examples')!;
     expect(
@@ -345,7 +345,6 @@ describe('the Examples in the Notebooks tab', () => {
       MINE
     ]);
     expect(idsIn(section(widget, 'Shared with me'), 'data-spec-id')).toEqual([
-      PUBLIC_EXAMPLE,
       SHARED
     ]);
     widget.dispose();
@@ -354,7 +353,7 @@ describe('the Examples in the Notebooks tab', () => {
   it('keeps example rows out of the stored-notebook row menu', async () => {
     // Its Rename and Delete would act on Oceanum's own example records.
     stubFetch();
-    const widget = await render(signedIn(DEMO_ID), () => undefined);
+    const widget = await render(signedIn(), () => undefined);
 
     const rows = section(widget, 'Examples')!.querySelectorAll('button');
     expect(rows).toHaveLength(3);
@@ -367,13 +366,13 @@ describe('the Examples in the Notebooks tab', () => {
   it('opens an example through onOpenExample, with its title', async () => {
     stubFetch();
     const opened: INotebookDemoItem[] = [];
-    const widget = await render(signedIn(DEMO_ID), item => opened.push(item));
+    const widget = await render(signedIn(), item => opened.push(item));
 
     section(widget, 'Examples')!
-      .querySelector<HTMLButtonElement>(`[data-example-id="${OTHER_EXAMPLE}"]`)!
+      .querySelector<HTMLButtonElement>(`[data-example-id="${PLOT}"]`)!
       .click();
 
-    expect(opened).toEqual([{ id: OTHER_EXAMPLE, title: 'Plot waves' }]);
+    expect(opened).toEqual([{ id: PLOT, title: '10 Plot waves' }]);
     widget.dispose();
   });
 
@@ -385,7 +384,7 @@ describe('the Examples in the Notebooks tab', () => {
   it('puts a switch on the Examples heading that asks to hide them', async () => {
     stubFetch();
     const changes: boolean[] = [];
-    const widget = await render(signedIn(DEMO_ID), undefined, {
+    const widget = await render(signedIn(), undefined, {
       showExamples: true,
       onShowExamplesChange: show => changes.push(show)
     });
@@ -408,7 +407,7 @@ describe('the Examples in the Notebooks tab', () => {
   it('keeps hidden examples folded under their heading, with the switch to bring them back', async () => {
     stubFetch();
     const changes: boolean[] = [];
-    const widget = await render(signedIn(DEMO_ID), undefined, {
+    const widget = await render(signedIn(), undefined, {
       showExamples: false,
       onShowExamplesChange: show => changes.push(show)
     });
@@ -418,14 +417,8 @@ describe('the Examples in the Notebooks tab', () => {
     expect(
       examples.querySelector('.oceanum-notebooks-count')?.textContent
     ).toBe('3');
-    // Hidden, not forgotten: the record is still read, and its examples stay out of
-    // Shared with me.
-    expect(fetches).toContain(
-      `https://specs.example.com/specs/notebook-demo/${DEMO_ID}`
-    );
-    expect(idsIn(section(widget, 'Shared with me'), 'data-spec-id')).toEqual([
-      SHARED
-    ]);
+    // Hidden, not forgotten: the demos are still listed, for the count.
+    expect(fetches).toContain(DEMO_LISTING);
 
     const toggle = switchIn(widget)!;
     expect(toggle.getAttribute('aria-checked')).toBe('false');
@@ -437,9 +430,9 @@ describe('the Examples in the Notebooks tab', () => {
 
   it('shows no error for examples the user has hidden', async () => {
     stubFetch(
-      () => ({ ok: false, status: 404, json: async () => ({}) }) as Response
+      () => ({ ok: false, status: 500, json: async () => ({}) }) as Response
     );
-    const widget = await render(signedIn(DEMO_ID), undefined, {
+    const widget = await render(signedIn(), undefined, {
       showExamples: false,
       onShowExamplesChange: () => undefined
     });
@@ -452,7 +445,7 @@ describe('the Examples in the Notebooks tab', () => {
 
   it('offers no switch where the choice could not be kept', async () => {
     stubFetch();
-    const widget = await render(signedIn(DEMO_ID));
+    const widget = await render(signedIn());
 
     expect(switchIn(widget)).toBeNull();
     expect(
@@ -464,7 +457,7 @@ describe('the Examples in the Notebooks tab', () => {
   it('shows no examples while the setting is still loading', async () => {
     // Otherwise examples a user has hidden would show for a moment on every reload.
     stubFetch();
-    const widget = await render(signedIn(DEMO_ID), undefined, {
+    const widget = await render(signedIn(), undefined, {
       showExamples: null,
       onShowExamplesChange: () => undefined
     });
@@ -479,7 +472,7 @@ describe('the Examples in the Notebooks tab', () => {
 
   it('shows nothing for hidden examples that no switch could bring back', async () => {
     stubFetch();
-    const widget = await render(signedIn(DEMO_ID), undefined, {
+    const widget = await render(signedIn(), undefined, {
       showExamples: false
     });
 

package/src/__tests__/fromDatamesh.spec.ts

@@ -0,0 +1,301 @@
+import {
+  decodePayload,
+  encodePayload,
+  FRAGMENT_KEY,
+  hashWithoutPayload,
+  IDatameshNotebookRequest,
+  MAX_DEPTH,
+  MAX_ITEMS,
+  notebookFromDatamesh,
+  notebookName,
+  payloadFromHash,
+  pyIdentifier,
+  pyLiteral,
+  pyString,
+  queryCellSource,
+  queryFields
+} from '../share/fromDatamesh';
+import { removeMath, replaceMath } from '@jupyterlab/rendermime/lib/latex';
+import { marked } from 'marked';
+
+const QUERY = {
+  id: 'abc123',
+  label: 'era5_wind10m_abc123',
+  datasource: 'era5_wind10m',
+  description: 'ERA5 10m wind',
+  variables: ['u10', 'v10'],
+  timefilter: { times: ['2024-01-01T00:00:00Z', null] },
+  geofilter: { type: 'bbox', geom: [170, -45, 175, -40] }
+};
+
+function request(items: unknown[], name?: string): IDatameshNotebookRequest {
+  return { v: 1, name, items } as IDatameshNotebookRequest;
+}
+
+describe('payload encoding', () => {
+  it('round-trips through base64url, including non-ASCII text', () => {
+    const req = request(
+      [{ ...QUERY, description: 'Vent à 10 m — 風' }],
+      'Ōtaki'
+    );
+    const encoded = encodePayload(req);
+    expect(encoded).toMatch(/^[A-Za-z0-9_-]+$/);
+    expect(decodePayload(encoded)).toEqual(req);
+  });
+
+  it('rejects text that is not a payload', () => {
+    expect(() => decodePayload('!!!')).toThrow('not valid');
+    expect(() => decodePayload(btoa('not json'))).toThrow('not valid');
+  });
+
+  it('rejects other versions, empty and oversized workspaces, and bad items', () => {
+    const enc = (v: unknown) =>
+      encodePayload(v as unknown as IDatameshNotebookRequest);
+    expect(() => decodePayload(enc({ v: 2, items: [QUERY] }))).toThrow(
+      'newer Datamesh UI'
+    );
+    expect(() => decodePayload(enc({ v: 1, items: [] }))).toThrow('no queries');
+    expect(() =>
+      decodePayload(enc({ v: 1, items: Array(MAX_ITEMS + 1).fill(QUERY) }))
+    ).toThrow('too many');
+    expect(() =>
+      decodePayload(enc({ v: 1, items: [{ datasource: 3 }] }))
+    ).toThrow('not valid');
+    expect(() =>
+      decodePayload(enc({ v: 1, items: [{ datasource: ' ' }] }))
+    ).toThrow('not valid');
+    expect(() => decodePayload(enc({ v: 1, name: 5, items: [QUERY] }))).toThrow(
+      'not valid'
+    );
+  });
+});
+
+describe('fragment handling', () => {
+  it('finds the payload among other hash keys and removes only it', () => {
+    const hash = `#foo=1&${FRAGMENT_KEY}=abc_-`;
+    expect(payloadFromHash(hash)).toBe('abc_-');
+    expect(hashWithoutPayload(hash)).toBe('#foo=1');
+    expect(hashWithoutPayload(`#${FRAGMENT_KEY}=x`)).toBe('');
+    expect(payloadFromHash('')).toBeNull();
+  });
+
+  it('keeps every other part of the hash exactly as it was', () => {
+    expect(hashWithoutPayload(`#my-heading&${FRAGMENT_KEY}=x`)).toBe(
+      '#my-heading'
+    );
+    expect(hashWithoutPayload(`#a=b%20c&${FRAGMENT_KEY}=x&d`)).toBe(
+      '#a=b%20c&d'
+    );
+  });
+});
+
+describe('payload limits', () => {
+  const nested = (depth: number): unknown => {
+    let v: unknown = 'x'.repeat(80);
+    for (let i = 0; i < depth; i++) {
+      v = [v];
+    }
+    return v;
+  };
+
+  it('rejects nesting deeper than real queries use', () => {
+    const enc = (depth: number) =>
+      encodePayload({
+        v: 1,
+        items: [{ datasource: 'abc', variables: nested(depth) }]
+      } as unknown as IDatameshNotebookRequest);
+    expect(() => decodePayload(enc(20))).not.toThrow();
+    expect(() => decodePayload(enc(MAX_DEPTH))).toThrow('not valid');
+  });
+
+  it('renders deep values in linear time (was 2^depth)', () => {
+    const started = Date.now();
+    pyLiteral(nested(MAX_DEPTH));
+    expect(Date.now() - started).toBeLessThan(1000);
+  });
+});
+
+describe('pyLiteral', () => {
+  it('writes Python, not JSON, constants', () => {
+    expect(pyLiteral({ a: null, b: true, c: false, d: 1.5 })).toBe(
+      '{"a": None, "b": True, "c": False, "d": 1.5}'
+    );
+  });
+
+  it('keeps "null" and "true" inside strings as text', () => {
+    expect(pyLiteral(['null', 'true'])).toBe('["null", "true"]');
+  });
+
+  it('escapes strings so they cannot end the literal', () => {
+    const nasty = '"); import os; os.system("x") #\n\'\'\'\\';
+    const lit = pyLiteral(nasty);
+    expect(lit).toBe(JSON.stringify(nasty));
+    expect(lit).not.toContain('\n');
+  });
+
+  it('wraps long values over several indented lines', () => {
+    const lit = pyLiteral({
+      geofilter: { type: 'feature', geom: { coordinates: Array(30).fill(1) } }
+    });
+    expect(lit.split('\n').length).toBeGreaterThan(3);
+    expect(lit).toContain('\n    "geofilter": {');
+  });
+});
+
+describe('pyIdentifier', () => {
+  it('makes valid, unique names', () => {
+    const taken = new Set<string>();
+    expect(pyIdentifier('ERA5 wind-10m.v2', taken)).toBe('era5_wind_10m_v2');
+    expect(pyIdentifier('ERA5 wind-10m.v2', taken)).toBe('era5_wind_10m_v2_2');
+    expect(pyIdentifier('2024 swell', taken)).toBe('ds_2024_swell');
+    expect(pyIdentifier('import', taken)).toBe('import_');
+    expect(pyIdentifier('datamesh', taken)).toBe('datamesh_');
+    expect(pyIdentifier('—', taken)).toBe('data');
+  });
+});
+
+describe('query cells', () => {
+  it('passes only fields oceanum-python Query accepts', () => {
+    expect(Object.keys(queryFields(QUERY)).sort()).toEqual(
+      [
+        'datasource',
+        'description',
+        'geofilter',
+        'timefilter',
+        'variables'
+      ].sort()
+    );
+  });
+
+  it('queries a filtered selection', () => {
+    const src = queryCellSource(QUERY, 'wind');
+    expect(src).toContain('# ERA5 10m wind');
+    expect(src).toContain('wind = datamesh.query({');
+    expect(src).toContain('"times": ["2024-01-01T00:00:00Z", None]');
+    expect(src).not.toContain('"label"');
+    expect(src.endsWith('\nwind')).toBe(true);
+  });
+
+  it('opens an unfiltered datasource lazily', () => {
+    const src = queryCellSource(
+      { datasource: 'era5_wind10m', variables: [], functions: [] },
+      'wind'
+    );
+    expect(src).toBe('wind = datamesh.load_datasource("era5_wind10m")\nwind');
+  });
+
+  it('keeps a multi-line description on one comment line', () => {
+    const src = queryCellSource(
+      { ...QUERY, description: 'a\nprint("pwned")' },
+      'x'
+    );
+    expect(src.split('\n')[0]).toBe('# a print("pwned")');
+  });
+});
+
+// Every character Python's str.splitlines() breaks on, which IPython uses to split
+// a cell into lines (reviewer-found injection through the comment line).
+const SPLITLINES = [
+  0x0a, 0x0b, 0x0c, 0x0d, 0x1c, 0x1d, 0x1e, 0x85, 0x2028, 0x2029
+].map(c => String.fromCharCode(c));
+
+describe('line breaks cannot escape a comment or a string', () => {
+  it.each(SPLITLINES.map(c => [c.charCodeAt(0).toString(16), c]))(
+    'U+%s in a description or label stays inside the comment',
+    (_hex, sep) => {
+      for (const item of [
+        { ...QUERY, description: `wind${sep}import os` },
+        { ...QUERY, description: undefined, label: `wind${sep}import os` }
+      ]) {
+        const src = queryCellSource(item, 'x');
+        const comment = src.split('\n')[0];
+        expect(comment).toBe('# wind import os');
+        for (const c of SPLITLINES.filter(s => s !== '\n')) {
+          expect(src).not.toContain(c);
+        }
+      }
+    }
+  );
+
+  it('escapes C1 controls and U+2028/9 inside string literals and keys', () => {
+    const text = SPLITLINES.join('') + String.fromCharCode(0, 0x7f, 0x9f);
+    const lit = pyLiteral({ [text]: text });
+    // Only printable ASCII is left: every control and separator is a \u escape.
+    expect(pyString(text)).toMatch(/^[\x20-\x7e]*$/);
+    // pyLiteral's own wrapping adds plain newlines, and nothing else.
+    expect(lit).toMatch(/^[\x20-\x7e\n]*$/);
+    expect(lit).toContain('\\u0085');
+    expect(lit).toContain('\\u2028');
+    // Still the same value once parsed (JSON reads \u escapes as Python does).
+    expect(JSON.parse(pyString(text))).toBe(text);
+  });
+
+  it('strips them from the Markdown heading too', () => {
+    const nb = notebookFromDatamesh(
+      request([QUERY], `a${SPLITLINES.join('')}b`)
+    );
+    expect(String(nb.cells[0].source).split('\n')[0]).toBe('# a b');
+  });
+});
+
+describe('the Markdown heading, rendered as JupyterLab renders it', () => {
+  it.each([
+    '[x](https://e.example) ![y](https://e.example/p.png)',
+    'https://2130706433/login',
+    'www.evil.example',
+    'me@evil.example',
+    '<img src=x onerror=alert(1)>',
+    '[x](javascript:alert(1))',
+    '`code` **bold** _em_ ~~s~~',
+    '@@0@@',
+    'run @@12@@ of 20',
+    'Cost $5 and $6'
+  ])('%s renders as plain text', async name => {
+    const nb = notebookFromDatamesh(request([QUERY], name));
+    // JupyterLab's own Markdown path: math placeholders, marked, math restored.
+    const { text, math } = removeMath(String(nb.cells[0].source));
+    const html = replaceMath(await marked.parse(text, { gfm: true }), math);
+    const heading = html.split('\n')[0];
+    expect(heading).toMatch(/^<h1>[^<]*<\/h1>$/);
+  });
+});
+
+describe('optional text fields', () => {
+  it('accepts null name, label and description', () => {
+    const enc = encodePayload({
+      v: 1,
+      name: null,
+      items: [{ ...QUERY, label: null, description: null }]
+    } as unknown as IDatameshNotebookRequest);
+    const req = decodePayload(enc);
+    expect(req.name).toBeUndefined();
+    const nb = notebookFromDatamesh(req);
+    expect(nb.cells[2].source).toContain('era5_wind10m = datamesh.query(');
+  });
+});
+
+describe('notebookFromDatamesh', () => {
+  it('builds an untrusted, unlinked notebook with one cell per query', () => {
+    const nb = notebookFromDatamesh(
+      request([QUERY, { ...QUERY, label: undefined }], 'My <b>work</b>space')
+    );
+    expect(nb.nbformat).toBe(4);
+    expect(nb.metadata).toEqual({ language_info: { name: 'python' } });
+    expect(nb.cells).toHaveLength(4);
+    expect(nb.cells[0].source).toContain('# My &lt;b&gt;work&lt;\\/b&gt;space');
+    expect(nb.cells[1].source).toContain('datamesh = Connector()');
+    expect(nb.cells[2].source).toContain(
+      'era5_wind10m_abc123 = datamesh.query'
+    );
+    expect(nb.cells[3].source).toContain('era5_wind10m = datamesh.query');
+    for (const cell of nb.cells) {
+      expect(cell.metadata).toEqual({});
+    }
+  });
+
+  it('names the notebook after the workspace, else the single query', () => {
+    expect(notebookName(request([QUERY], ' Coast '))).toBe('Coast');
+    expect(notebookName(request([QUERY]))).toBe('era5_wind10m_abc123');
+    expect(notebookName(request([QUERY, QUERY]))).toBe('Datamesh workspace');
+  });
+});