@finos/legend-cube-builder 0.0.4 → 0.0.6

package/src/__lib__/LegendCubeTesting.ts

@@ -15,6 +15,7 @@
  */
 
 export enum LEGEND_CUBE_TEST_ID {
+  RUNNING_NODE_BADGE = 'legend-cube__running-node-badge',
   EDITOR = 'legend-cube__editor',
   GRAPH_REGION = 'legend-cube__graph-region',
   GRID_REGION = 'legend-cube__grid-region',
@@ -26,9 +27,17 @@ export enum LEGEND_CUBE_TEST_ID {
   NODE_EDITOR = 'legend-cube__node-editor',
   EDITOR_NOTICE = 'legend-cube__editor-notice',
   ENTRY_SOURCE_ERROR = 'legend-cube__entry-source-error',
+  LAMBDA_IMPORT = 'legend-cube__lambda-import',
+  IMPORT_PURE = 'legend-cube__import-pure',
   FILTER_CONDITION = 'legend-cube__filter-condition',
   RESULT_GRID = 'legend-cube__result-grid',
+  DRILLDOWN_BAR = 'legend-cube__drilldown-bar',
+  RUN_STATS = 'legend-cube__run-stats',
+  COLUMN_FORMAT = 'legend-cube__column-format',
+  DRILLDOWN_SETTINGS = 'legend-cube__drilldown-settings',
   GRID_TOOLBAR = 'legend-cube__grid-toolbar',
   EXECUTION_ERROR = 'legend-cube__execution-error',
   SQL_PANEL = 'legend-cube__sql-panel',
+  JSON_VIEWER = 'legend-cube__json-viewer',
+  JSON_EXPLORER = 'legend-cube__json-explorer',
 }

package/src/__lib__/LegendCubeTour.ts

@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  EXECUTE_SHORTCUT_LABEL,
+  REDO_SHORTCUT_LABEL,
+  UNDO_SHORTCUT_LABEL,
+} from './LegendCubeCommand.js';
+
+// The editor's guided tour (PLAN §11.21): its steps, in order, each pointing
+// at the controls marked with its anchor. A control joins a step by carrying
+// `cubeTourAnchor(...)`; a step whose controls aren't on the page (the graph
+// hidden, no run yet, a host without examples) is skipped. A new step adds
+// its anchor here, its text below, and the anchor on its controls.
+
+/** The attribute that marks a control as a tour step's */
+export const CUBE_TOUR_ANCHOR_ATTRIBUTE = 'data-cube-tour';
+
+export enum CUBE_TOUR_ANCHOR {
+  SOURCES = 'sources',
+  STEPS = 'steps',
+  CANVAS = 'canvas',
+  RUNNING_STEP = 'running-step',
+  EXECUTE = 'execute',
+  GRID_MODE = 'grid-mode',
+  RESULTS = 'results',
+  SHOW_SQL = 'show-sql',
+  RUNS = 'runs',
+  CUBE_MENU = 'cube-menu',
+  ADD_ITEMS = 'add-items',
+  EXAMPLES = 'examples',
+  VIEW = 'view',
+  PAGE_MENU = 'page-menu',
+}
+
+/** The props that mark a control as a tour step's */
+export const cubeTourAnchor = (
+  anchor: CUBE_TOUR_ANCHOR,
+): { [CUBE_TOUR_ANCHOR_ATTRIBUTE]: string } => ({
+  [CUBE_TOUR_ANCHOR_ATTRIBUTE]: anchor,
+});
+
+/** Where a step's card sits beside its controls */
+export type CubeTourPlacement = 'top' | 'bottom' | 'left' | 'right';
+
+export interface CubeTourStep {
+  readonly title: string;
+  readonly text: string;
+  /** The controls it points at; none for a card in the middle of the page */
+  readonly anchor?: CUBE_TOUR_ANCHOR | undefined;
+  readonly placement?: CubeTourPlacement | undefined;
+}
+
+/** The example the tour opens on an empty cube, where examples are offered */
+export const CUBE_TOUR_EXAMPLE_ID = 'northwind-top-customers';
+
+export const CUBE_EDITOR_TOUR: readonly CubeTourStep[] = Object.freeze([
+  {
+    title: 'Welcome to Legend Cube',
+    text: 'A cube is a query built as a chain of steps: a source of rows, then steps that sort, group, filter or join them. This tour shows where everything is: Next (or the → key) moves on, and Esc ends it.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.SOURCES,
+    placement: 'right',
+    title: 'Sources',
+    text: 'Where the rows come from: a database table, a function, a data product or a service. Click one, or drop it on the canvas.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.STEPS,
+    placement: 'right',
+    title: 'Steps',
+    text: 'Each step works on the rows of the step before it. Click one to add it after the selected step, or drop it on the canvas. A greyed-out step says why when you hover over it.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.CANVAS,
+    placement: 'bottom',
+    title: 'The graph',
+    text: 'Your query, from left to right. Click a step to edit it: its editor opens beside it, with a ? that says what the step does.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.RUNNING_STEP,
+    placement: 'bottom',
+    title: 'The step that runs',
+    text: 'Execute runs the query up to the step marked Runs. To run up to another step, open its editor and click Run this step.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.EXECUTE,
+    placement: 'top',
+    title: 'Execute',
+    text: `Runs the query and shows its rows below (${EXECUTE_SHORTCUT_LABEL}). Rows caps how many rows come back.`,
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.GRID_MODE,
+    placement: 'top',
+    title: 'Server-side or Local',
+    text: 'Server-side: each sort and drill-down in the grid runs on the engine, over every row of the query. Local: the grid groups, pivots and filters the rows already fetched, in your browser.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.RESULTS,
+    placement: 'top',
+    title: 'The results',
+    text: 'The rows of the last run. Right-click a cell to sort, group or filter by its column as a new step, drill down, format a number column, or export the rows.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.SHOW_SQL,
+    placement: 'top',
+    title: 'Show SQL',
+    text: 'The SQL the last run sent to the database.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.RUNS,
+    placement: 'top',
+    title: 'Runs',
+    text: 'The latest runs, fetches and exports, each with its SQL and how long it took.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.CUBE_MENU,
+    placement: 'bottom',
+    title: 'The Cube menu',
+    text: 'Start a new cube, import or export one, or read a Pure query in as steps with Import Pure.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.ADD_ITEMS,
+    placement: 'bottom',
+    title: 'Add Items',
+    text: "The palette's sources and steps, as a menu.",
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.EXAMPLES,
+    placement: 'bottom',
+    title: 'Examples',
+    text: 'Ready-made cubes on sample data, to try things out.',
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.VIEW,
+    placement: 'bottom',
+    title: 'Undo, Show Pure, Hide graph',
+    text: `Undo (${UNDO_SHORTCUT_LABEL}) and Redo (${REDO_SHORTCUT_LABEL}) every change. Show Pure shows the Pure query Execute runs. Hide graph leaves more room for the results.`,
+  },
+  {
+    anchor: CUBE_TOUR_ANCHOR.PAGE_MENU,
+    placement: 'right',
+    title: "That's the tour",
+    text: 'Take it again from this menu whenever you like.',
+  },
+]);
+
+export const CUBE_TOUR_LABEL = {
+  START: 'Take the tour',
+  /** The empty canvas's offer */
+  OFFER: 'New to Legend Cube?',
+  NEXT: 'Next',
+  BACK: 'Back',
+  DONE: 'Done',
+  END: 'End the tour',
+  progress: (step: number, steps: number): string => `${step} of ${steps}`,
+  /** Added to the first step when the tour opened its example */
+  EXAMPLE_OPENED:
+    'The tour opened the example "Top customers by orders" to show you around; Undo puts the empty cube back.',
+};

package/src/__test-utils__/CubeEngineTestSupport.ts

@@ -117,13 +117,14 @@ export const CUBE_ENGINE_TEST__jsonToGrammar_lambda = async (
  */
 export const CUBE_ENGINE_TEST__execute = async (
   input: object | string,
+  serializationFormat = 'DEFAULT',
 ): Promise<{ ok: boolean; status: number; text: () => Promise<string> }> => {
   const response = await axios.post<unknown, AxiosResponse<string>>(
     `${PURE_API}/execution/execute`,
     input,
     {
       headers: JSON_HEADERS,
-      params: { serializationFormat: 'DEFAULT' },
+      params: { serializationFormat },
       responseType: 'text',
       transformResponse: (data: string) => data,
       validateStatus: () => true,

package/src/__test-utils__/CubeExampleTestUtils.ts

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  buildSchemasAndValidity,
+  createNodeRegistry,
+  Extend,
+  type ModelContext,
+  Query,
+  RelationalTableSource,
+  Schema,
+} from '@finos/legend-cube';
+import type { CubeEngine } from '../graph-manager/CubeEngine.js';
+import {
+  buildCubeExtendTypingLambdas,
+  readCubeExtendTyping,
+} from '../stores/CubeExtendTyping.js';
+import type { CubeExample } from '../stores/CubeExamples.js';
+
+/**
+ * The query with each Extend typed by the engine, in node order, as the
+ * editor types them in the background
+ */
+export const TEST__typeExtendsOnEngine = async (
+  engine: CubeEngine,
+  model: ModelContext,
+  input: Query,
+): Promise<Query> => {
+  const registry = createNodeRegistry();
+  let query = input;
+  for (const node of query.nodes) {
+    if (node instanceof Extend) {
+      const columns = node.columns.map(({ name, lambda }) => ({
+        name,
+        lambda: lambda as NonNullable<typeof lambda>,
+      }));
+      const [inputId] = query.getInputIds(node.id);
+      const answers = await engine.typeLambdas(
+        model,
+        buildCubeExtendTypingLambdas(query, node, columns, registry, false),
+      );
+      const { typing } = readCubeExtendTyping(
+        answers,
+        node,
+        buildSchemasAndValidity(query, registry.queryRules).schemas.get(
+          inputId ?? '',
+        ) as Schema,
+        columns,
+        undefined,
+      );
+      query = query.replace(
+        new Extend(node.id, node.columns, typing, node.rest),
+      );
+    }
+  }
+  return query;
+};
+
+/**
+ * An example's cube as opening it types it, on the engine: its tables, then
+ * each Extend, in node order, as the editor types it in the background (an
+ * Extend parsing JSON, PLAN §11.20)
+ */
+export const TEST__openExampleOnEngine = async (
+  engine: CubeEngine,
+  example: CubeExample,
+): Promise<{ model: ModelContext; runtime: string; query: Query }> => {
+  const document = example.createDocument();
+  const model = document.context?.model;
+  const runtime = document.context?.runtime;
+  if (!model || !runtime) {
+    throw new Error(`Example ${example.id} has no model or runtime`);
+  }
+  const sources = document.query.nodes.filter(
+    (node): node is RelationalTableSource =>
+      node instanceof RelationalTableSource,
+  );
+  const typed = await engine.resolveSchemas(
+    model,
+    new Map(
+      sources.map((source) => [
+        source.id,
+        [source.database, source.schema, source.table] as const,
+      ]),
+    ),
+  );
+  const query = new Query(
+    document.query.nodes.map((node) => {
+      if (!(node instanceof RelationalTableSource)) {
+        return node;
+      }
+      const schema = typed.get(node.id);
+      if (!(schema instanceof Schema)) {
+        throw schema ?? new Error(`No schema for ${node.id}`);
+      }
+      return node.withResolution({ kind: 'resolved', schema });
+    }),
+    document.query.connections,
+    document.query.selected,
+  );
+  return {
+    model,
+    runtime,
+    query: await TEST__typeExtendsOnEngine(engine, model, query),
+  };
+};

package/src/__test-utils__/CubeExpressionTestUtils.ts

@@ -16,15 +16,18 @@
 
 import {
   buildSchemasAndValidity,
+  ExpressionFilter,
   Extend,
+  getExpressionFilterSignature,
   getExtendSignature,
   type JsonObject,
   PrimitiveType,
   type Query,
 } from '@finos/legend-cube';
 
-// Extend columns for tests (PLAN §11.7), written as the engine's JSON, as a
-// column stores it: number literals as their digits
+// Extend columns and filter conditions for tests (PLAN §11.7, §11.11),
+// written as the engine's JSON, as a node stores it: number literals as their
+// digits
 
 /** `x | <body>` and the pieces of a body */
 export const TEST__expression = {
@@ -54,6 +57,7 @@ export const TEST__expression = {
     _type: 'integer',
     value: String(value),
   }),
+  string: (value: string): JsonObject => ({ _type: 'string', value }),
 };
 
 /** A new column: its name, its lambda, and the type the engine gives it */
@@ -88,6 +92,29 @@ export const TEST__typedExtend = (
   });
 };
 
+/**
+ * A Filter by Expression of this condition, checked for the input Cube infers
+ * for `input`'s selected node, so it is valid without the engine; the engine
+ * tests check the engine takes it. With an invalid input, not checked.
+ */
+export const TEST__checkedExpressionFilter = (
+  id: string,
+  input: Query,
+  code: string,
+  lambda: JsonObject,
+): ExpressionFilter => {
+  const filter = new ExpressionFilter(id, code, lambda);
+  const schema = buildSchemasAndValidity(input).schemas.get(
+    input.selected ?? '',
+  );
+  return schema
+    ? filter.withCheck({
+        kind: 'checked',
+        signature: getExpressionFilterSignature(schema, lambda),
+      })
+    : filter;
+};
+
 /** `a: x | $x.ORDER_ID + 1` and `b: x | $x.a * 2`, the second using the first, both Integer */
 export const TEST__ORDER_ID_EXTEND_COLUMNS: readonly TEST__ExtendColumn[] = [
   [

package/src/__test-utils__/CubeFunctionTestOutline.ts

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { resolveCubeType, Schema, SchemaColumn } from '@finos/legend-cube';
+import type {
+  CubeModelOutline,
+  CubeOutlineFunction,
+} from '../graph-manager/CubeEngine.js';
+import {
+  NORTHWIND_DATABASE,
+  NORTHWIND_RUNTIME,
+} from './CubeNorthwindTestQueries.js';
+import { FAKE_NORTHWIND_OUTLINE } from './FakeCubeEngine.js';
+
+// The fake Northwind outline with functions that return a relation (PLAN
+// §6.5), and a second runtime: one function of each kind
+
+export const ARCHIVE_RUNTIME = 'northwind::ArchiveRuntime';
+
+const fn = (
+  name: string,
+  parameters: CubeOutlineFunction['parameters'] = [],
+  extra: Partial<CubeOutlineFunction> = {},
+): CubeOutlineFunction => ({
+  path: `northwind::${name}`,
+  signature: `northwind::${name}__Relation_1_`,
+  parameters,
+  columns: [{ name: 'ORDER_ID', type: 'Integer' }],
+  ...extra,
+});
+
+export const ALL_ORDERS = fn('allOrders');
+export const ORDERS_ABOVE = fn('ordersAbove', [
+  { name: 'min', type: 'Float', multiplicity: '[1]' },
+  { name: 'status', type: 'String', multiplicity: '[0..1]' },
+]);
+export const SHIPPED = fn('shipped', [], { runtime: NORTHWIND_RUNTIME });
+export const ARCHIVED = fn('archived', [], { runtime: ARCHIVE_RUNTIME });
+export const ORDERS_OF = fn(
+  'ordersOf',
+  [{ name: 'ids', type: 'Integer', multiplicity: '[*]' }],
+  {
+    problem:
+      'Its parameter "ids" takes [*] values; Cube takes one value, or none',
+  },
+);
+
+export const FUNCTIONS_OUTLINE: CubeModelOutline = {
+  ...FAKE_NORTHWIND_OUTLINE,
+  runtimes: [
+    ...FAKE_NORTHWIND_OUTLINE.runtimes,
+    {
+      path: ARCHIVE_RUNTIME,
+      storePaths: [NORTHWIND_DATABASE],
+      connections: [
+        { storePath: NORTHWIND_DATABASE, databaseType: 'Postgres' },
+      ],
+    },
+  ],
+  functions: [ALL_ORDERS, ORDERS_ABOVE, SHIPPED, ARCHIVED, ORDERS_OF],
+};
+
+export const FUNCTION_SCHEMA = new Schema([
+  new SchemaColumn('ORDER_ID', resolveCubeType('Integer'), true),
+]);

package/src/__test-utils__/CubeLambdaCorpus.ts

@@ -0,0 +1,137 @@
+/**
+ * Copyright (c) 2026-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  buildSchemasAndValidity,
+  CubeLambdaReadError,
+  decodeCubeSpec,
+  ExpressionFilter,
+  getExpressionFilterSignature,
+  lambda,
+  QueryEmitter,
+  RelationalTableSource,
+  type CubeDocument,
+  type CubeSourceStep,
+  type IR,
+  type Query,
+} from '@finos/legend-cube';
+import { readdirSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+// The lambdas Cube writes for the core's saved spec samples (PLAN §10.3),
+// for Import Pure's round trips (PLAN §11.18): for each node that can be
+// written, as a matview saves it and as Show Pure shows a run of it
+
+const FIXTURES = resolve(
+  __dirname,
+  '../../../legend-cube/src/spec/__tests__/fixtures',
+);
+
+export interface TEST__CubeLambdaSample {
+  /** `<file>/<node id>` */
+  readonly key: string;
+  readonly document: CubeDocument;
+  readonly nodeId: string;
+  /** The node's relation, as a matview saves it: `{| <relation>}`, written with its rows' order */
+  readonly relation: IR;
+  /** A run of the node with no row limit, as Show Pure shows it: lets, the capture's sort, `from()` */
+  readonly run: IR;
+}
+
+/** Every node of every sample that can be written, by key */
+export const TEST__cubeLambdaSamples = (): TEST__CubeLambdaSample[] =>
+  readdirSync(FIXTURES)
+    .filter((file) => file.endsWith('.cube.json'))
+    .sort()
+    .flatMap((file) => {
+      const { document } = decodeCubeSpec(
+        JSON.parse(readFileSync(join(FIXTURES, file), 'utf-8')),
+      );
+      const runtime = document.context?.runtime;
+      if (runtime === undefined) {
+        return [];
+      }
+      const emitter = new QueryEmitter(document.query);
+      return document.query.nodes
+        .filter((node) => emitter.canEmit(node.id))
+        .map((node) => ({
+          key: `${file}/${node.id}`,
+          document,
+          nodeId: node.id,
+          relation: lambda(
+            [],
+            [emitter.emitRelation(node.id, { withRowOrder: true })],
+          ),
+          run: new QueryEmitter(
+            document.query.selected === node.id
+              ? document.query
+              : document.query.select(node.id),
+          ).emitExecutionLambda({ runtime }),
+        }));
+    });
+
+/** Each table of the lambda bound to the sample's own source of it, with its saved columns */
+export const TEST__bindSampleSources =
+  (document: CubeDocument) =>
+  (source: IR): CubeSourceStep => {
+    const table = document.query.nodes.find(
+      (node): node is RelationalTableSource =>
+        node instanceof RelationalTableSource &&
+        source.k === 'storeAccessor' &&
+        source.path.join('.') ===
+          [node.database, node.schema, node.table].join('.'),
+    );
+    if (!table) {
+      throw new CubeLambdaReadError(`No table for ${JSON.stringify(source)}`);
+    }
+    return {
+      type: RelationalTableSource.TYPE,
+      create: (id) =>
+        new RelationalTableSource(
+          id,
+          {
+            database: table.database,
+            schema: table.schema,
+            table: table.table,
+          },
+          table.resolution,
+        ),
+    };
+  };
+
+/**
+ * The query with each Filter by Expression checked, as the editor has the
+ * engine check them on import: the samples' conditions are all Booleans
+ */
+export const TEST__checkedAsTheEngineWould = (query: Query): Query =>
+  query.nodes.reduce((checked, node) => {
+    if (!(node instanceof ExpressionFilter) || !node.lambda) {
+      return checked;
+    }
+    const [inputId] = checked.getInputIds(node.id);
+    const input =
+      inputId === undefined
+        ? undefined
+        : buildSchemasAndValidity(checked).schemas.get(inputId);
+    return input
+      ? checked.replace(
+          node.withCheck({
+            kind: 'checked',
+            signature: getExpressionFilterSignature(input, node.lambda),
+          }),
+        )
+      : checked;
+  }, query);

package/src/__test-utils__/CubePageTestUtils.tsx

@@ -129,3 +129,37 @@ export const TEST__closeAddItems = async (): Promise<void> => {
   fireEvent.keyDown(screen.getByRole('menu'), { key: 'Escape' });
   await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
 };
+
+/** Opens 'Cube' (New, Import, Export) in the graph's header and returns its menu */
+export const TEST__openCubeMenu = async (): Promise<HTMLElement> => {
+  fireEvent.click(
+    within(screen.getByTestId(LEGEND_CUBE_TEST_ID.GRAPH_REGION)).getByRole(
+      'button',
+      { name: 'Cube' },
+    ),
+  );
+  return screen.findByRole('menu');
+};
+
+/** Chooses an item of the 'Cube' menu (New, Import or Export), and waits for the menu to close */
+export const TEST__chooseCubeMenuItem = async (
+  label: string,
+): Promise<void> => {
+  const menu = await TEST__openCubeMenu();
+  fireEvent.click(within(menu).getByRole('menuitem', { name: label }));
+  await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
+};
+
+/** Whether an item of the 'Cube' menu is disabled; the menu is closed again */
+export const TEST__isCubeMenuItemDisabled = async (
+  label: string,
+): Promise<boolean> => {
+  const menu = await TEST__openCubeMenu();
+  const disabled =
+    within(menu)
+      .getByRole('menuitem', { name: label })
+      .getAttribute('aria-disabled') === 'true';
+  fireEvent.keyDown(menu, { key: 'Escape' });
+  await waitFor(() => expect(screen.queryByRole('menu')).toBeNull());
+  return disabled;
+};