@dxos/app-graph 0.4.7-main.d28a540 → 0.4.7-main.e015b9e

package/src/graph.test.ts

@@ -2,315 +2,219 @@
 // Copyright 2023 DXOS.org
 //
 
-import { effect } from '@preact/signals-core';
 import { expect } from 'chai';
 
 import { describe, test } from '@dxos/test';
 
-import { Graph } from './graph';
-import { type Node, type NodeFilter } from './node';
+import { GraphBuilder } from './graph-builder';
+import { createTestNodeBuilder } from './testing';
 
-const longestPaths = new Map<string, string[]>();
-
-const filterLongestPath: NodeFilter = (node, connectedNode): node is Node => {
-  const longestPath = longestPaths.get(node.id);
-  if (!longestPath) {
-    return false;
-  }
-
-  if (longestPath[longestPath.length - 2] !== connectedNode.id) {
-    return false;
-  }
-
-  return true;
-};
-
-// TODO(wittjosiah): Add tests for granularity of reactivity.
 describe('Graph', () => {
-  test('add nodes', () => {
-    const graph = new Graph();
+  test('returns root node', () => {
+    const graph = new GraphBuilder().build();
+    expect(graph.root).to.not.be.undefined;
+    expect(graph.root.id).to.equal('root');
+  });
+
+  test('root node unmodified without builders', () => {
+    const graph = new GraphBuilder().build();
+    expect(graph.root.properties).to.be.empty;
+    expect(graph.root.children).to.be.empty;
+    expect(graph.root.actions).to.be.empty;
+  });
 
-    const [root] = graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
+  test('builder can add children to root node', () => {
+    const builder = new GraphBuilder();
+    const testNode = { id: 'test', label: 'Test', data: null };
+    const id = 'test';
+    builder.addNodeBuilder(id, (parent) => {
+      if (parent.id === 'root') {
+        parent.addNode(id, testNode);
+      }
     });
 
-    expect(root.id).to.equal('root');
-    expect(root.nodes()).to.have.length(2);
-    expect(graph.findNode('test1')?.id).to.equal('test1');
-    expect(graph.findNode('test2')?.id).to.equal('test2');
-    expect(graph.findNode('test1')?.nodes()).to.be.empty;
-    expect(graph.findNode('test2')?.nodes()).to.be.empty;
-    expect(graph.findNode('test1')?.nodes({ direction: 'inbound' })).to.have.length(1);
-    expect(graph.findNode('test2')?.nodes({ direction: 'inbound' })).to.have.length(1);
+    const graph = builder.build();
+    expect(graph.root.childrenMap.test.id).to.equal(testNode.id);
+    expect(graph.root.childrenMap.test.parent!.id).to.equal(graph.root.id);
   });
 
-  test('add nodes updates existing nodes', () => {
-    const graph = new Graph();
-
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
+  test('builder can add actions to root node', () => {
+    const builder = new GraphBuilder();
+    const testAction = { id: 'test', label: 'Test', invoke: () => {} };
+    builder.addNodeBuilder('test', (parent) => {
+      if (parent.id === 'root') {
+        parent.addAction(testAction);
+      }
     });
 
-    expect(Object.keys(graph._nodes)).to.have.length(3);
-    expect(Object.keys(graph._edges)).to.have.length(3);
-    expect(graph.root.nodes()).to.have.length(2);
+    const graph = builder.build();
+    expect(graph.root.actionsMap.test.id).to.equal(testAction.id);
   });
 
-  test('remove node', () => {
-    const graph = new Graph();
+  test('multiple builders can add children to root node', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1').nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
-    const [root] = graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
+    const graph = builder.build();
+    expect(Object.keys(graph.root.childrenMap)).to.deep.equal(['root-test1', 'root-test2']);
+    for (const node of graph.root.children) {
+      expect(graph.root.id).to.equal(node.parent!.id);
+    }
+  });
 
-    expect(root.id).to.equal('root');
-    expect(root.nodes()).to.have.length(2);
-    expect(graph.findNode('test1')?.id).to.equal('test1');
-    expect(graph.findNode('test2')?.id).to.equal('test2');
+  test('multiple builders can add actions to root node', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1').nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
-    graph.removeNode('test1');
-    expect(graph.findNode('test1')).to.be.undefined;
-    expect(root.nodes()).to.have.length(1);
+    const graph = builder.build();
+    expect(Object.keys(graph.root.actionsMap)).to.deep.equal(['root-test1', 'root-test2']);
   });
 
-  test('add edge', () => {
-    const graph = new Graph();
+  test('builders can add children to child node', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.addEdge({ source: 'test1', target: 'test2' });
-
-    expect(graph.findNode('test1')?.nodes()).to.have.length(1);
-    expect(graph.findNode('test2')?.nodes({ direction: 'inbound' })).to.have.length(2);
+    const graph = builder.build();
+    expect(Object.keys(graph.root.childrenMap['root-test1'].children)).to.be.empty;
+    expect(Object.keys(graph.root.childrenMap['root-test2'].childrenMap)).to.deep.equal(['root-test2-test1']);
+    for (const node of graph.root.childrenMap['root-test2'].children) {
+      expect(graph.root.childrenMap['root-test2'].id).to.equal(node.parent!.id);
+    }
   });
 
-  test('add edges is idempontent', () => {
-    const graph = new Graph();
+  test('builders can add actions to child node', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
+
+    const graph = builder.build();
+    expect(Object.keys(graph.root.childrenMap['root-test1'].actionsMap)).to.be.empty;
+    expect(Object.keys(graph.root.childrenMap['root-test2'].actionsMap)).to.deep.equal(['root-test2-test1']);
+  });
 
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
+  test('builders can add actions to action sets', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test', (parent) => {
+      const [set] = parent.addAction({ id: 'test-set', label: 'Test Set', invoke: () => {} });
+      set.addAction({ id: 'test-action', label: 'Test', invoke: () => {} });
     });
-    graph.addEdge({ source: 'test1', target: 'test2' });
-    graph.addEdge({ source: 'test1', target: 'test2' });
 
-    expect(graph.findNode('test1')?.nodes()).to.have.length(1);
-    expect(graph.findNode('test2')?.nodes({ direction: 'inbound' })).to.have.length(2);
+    const graph = builder.build();
+    expect(Object.keys(graph.root.actionsMap['test-set'].actionsMap)).to.deep.equal(['test-action']);
   });
 
-  test('sort edges', () => {
-    const graph = new Graph();
+  test('is updated when nodes change', async () => {
+    const builder = new GraphBuilder();
 
-    const [root] = graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test3' }, { id: 'test2' }, { id: 'test4' }],
-    });
-
-    expect(root.nodes().map((node) => node.id)).to.deep.equal(['test1', 'test3', 'test2', 'test4']);
+    // TODO(burdon): Return TestNodeBuilder object.
+    const { nodeBuilder, addNode, removeNode, addAction, removeAction, addProperty, removeProperty } =
+      createTestNodeBuilder('test1', 2);
+    builder.addNodeBuilder('test1', nodeBuilder);
 
-    graph.sortEdges('root', 'outbound', ['test4', 'test3']);
+    const graph = builder.build();
+    expect(graph.root.children).to.have.length(1);
+    addNode('root', { id: 'root-test2', label: 'root-test2' });
+    expect(graph.root.children).to.have.length(2);
+    expect(graph.root.childrenMap['root-test2'].children).to.have.length(0);
 
-    expect(root.nodes().map((node) => node.id)).to.deep.equal(['test4', 'test3', 'test1', 'test2']);
-  });
+    expect(graph.root.childrenMap['root-test1'].children).to.have.length(0);
+    addNode('root-test1', { id: 'root-test1-test2', label: 'root-test1-test2' });
+    expect(graph.root.childrenMap['root-test1'].children).to.have.length(1);
+    expect(graph.root.childrenMap['root-test1'].childrenMap['root-test1-test2'].children).to.have.length(0);
 
-  test('remove edge', () => {
-    const graph = new Graph();
+    expect(graph.root.actions).to.have.length(1);
+    addAction('root', { id: 'root-test2', label: 'root-test2', invoke: () => {} });
+    expect(graph.root.actions).to.have.length(2);
 
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.removeEdge({ source: 'root', target: 'test1' });
+    expect(graph.root.childrenMap['root-test1'].properties).to.not.have.property('test');
+    addProperty('root-test1', 'test', 'test');
+    expect(graph.root.childrenMap['root-test1'].properties.test).to.equal('test');
 
-    expect(graph.root.nodes()).to.have.length(1);
-    expect(graph.findNode('test1')?.nodes({ direction: 'inbound' })).to.be.empty;
-  });
+    expect(graph.root.children).to.have.length(2);
+    removeNode('root', 'root-test2');
+    expect(graph.root.children).to.have.length(1);
 
-  test('toJSON', () => {
-    const graph = new Graph();
+    expect(graph.root.childrenMap['root-test1'].children).to.have.length(1);
+    removeNode('root-test1', 'root-test1-test2');
+    expect(graph.root.childrenMap['root-test1'].children).to.have.length(0);
 
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.addEdge({ source: 'test1', target: 'test2' });
+    expect(graph.root.actions).to.have.length(2);
+    removeAction('root', 'root-test2');
+    expect(graph.root.actions).to.have.length(1);
 
-    const json = graph.toJSON();
-    expect(json).to.deep.equal({
-      id: 'root',
-      nodes: [{ id: 'test1', nodes: [{ id: 'test2' }] }, { id: 'test2' }],
-    });
+    expect(graph.root.childrenMap['root-test1'].properties.test).to.equal('test');
+    removeProperty('root-test1', 'test');
+    expect(graph.root.childrenMap['root-test1'].properties).to.not.have.property('test');
   });
 
-  test('can be traversed', () => {
-    const graph = new Graph();
+  test.skip('node builder unsubscribe is called when builder is re-run', async () => {
+    // TODO(wittjosiah): Implement.
+  });
 
-    const [root] = graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
+  test('can find nodes', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
-    const nodes: string[] = [];
-    graph.traverse({ node: root, visitor: (node) => nodes.push(node.id) });
-    expect(nodes).to.deep.equal(['root', 'test1', 'test2']);
+    const graph = builder.build();
+    expect(graph.findNode('root-test1')?.id).to.equal('root-test1');
+    expect(graph.findNode('root-test2-test1')?.id).to.equal('root-test2-test1');
   });
 
-  test('traversal breaks cycles', () => {
-    const graph = new Graph();
-
-    const [root] = graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.addEdge({ source: 'test1', target: 'root' });
+  test('can be traversed', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
+    const graph = builder.build();
     const nodes: string[] = [];
-    graph.traverse({ node: root, visitor: (node) => nodes.push(node.id) });
-    expect(nodes).to.deep.equal(['root', 'test1', 'test2']);
+    graph.traverse({ visitor: (node) => nodes.push(node.id) });
+    expect(nodes).to.deep.equal(['root', 'root-test1', 'root-test2', 'root-test2-test1']);
   });
 
   test('traversal can be limited by predicate', () => {
-    const graph = new Graph();
-
-    const [root] = graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }, { id: 'test3' }, { id: 'test4' }],
-    });
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
+    const graph = builder.build();
     const nodes: string[] = [];
     graph.traverse({
-      node: root,
+      filter: (node) => node.id.includes('test1'),
       visitor: (node) => nodes.push(node.id),
-      filter: (node) => {
-        try {
-          const id = parseInt(node.id.replace('test', ''), 10);
-          return id % 2 === 0;
-        } catch (e) {
-          return false;
-        }
-      },
     });
-    expect(nodes).to.deep.equal(['test2', 'test4']);
+    expect(nodes).to.deep.equal(['root-test1', 'root-test2-test1']);
   });
 
   test('traversal can be started from any node', () => {
-    const graph = new Graph();
-
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1', nodes: [{ id: 'test2', nodes: [{ id: 'test3' }] }] }],
-    });
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
+    const graph = builder.build();
     const nodes: string[] = [];
     graph.traverse({
-      node: graph.findNode('test2')!,
+      node: graph.root.childrenMap['root-test2'],
       visitor: (node) => nodes.push(node.id),
     });
-    expect(nodes).to.deep.equal(['test2', 'test3']);
+    expect(nodes).to.deep.equal(['root-test2', 'root-test2-test1']);
   });
 
-  test('traversal can follow inbound edges', () => {
-    const graph = new Graph();
-
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1', nodes: [{ id: 'test2', nodes: [{ id: 'test3' }] }] }],
-    });
+  test('can traverse up', () => {
+    const builder = new GraphBuilder();
+    builder.addNodeBuilder('test1', createTestNodeBuilder('test1', 2).nodeBuilder);
+    builder.addNodeBuilder('test2', createTestNodeBuilder('test2').nodeBuilder);
 
+    const graph = builder.build();
     const nodes: string[] = [];
     graph.traverse({
-      node: graph.findNode('test2')!,
-      direction: 'inbound',
+      direction: 'up',
+      node: graph.root.childrenMap['root-test2'].childrenMap['root-test2-test1'],
       visitor: (node) => nodes.push(node.id),
     });
-    expect(nodes).to.deep.equal(['test2', 'test1', 'root']);
-  });
-
-  test('can filter to longest pathes', () => {
-    const graph = new Graph();
-
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.addEdge({ source: 'test1', target: 'test2' });
-
-    graph.traverse({
-      visitor: (node, path) => {
-        if (!longestPaths.has(node.id) || longestPaths.get(node.id)!.length < path.length) {
-          longestPaths.set(node.id, path);
-        }
-      },
-    });
-
-    expect(longestPaths.get('root')).to.deep.equal(['root']);
-    expect(longestPaths.get('test1')).to.deep.equal(['root', 'test1']);
-    expect(longestPaths.get('test2')).to.deep.equal(['root', 'test1', 'test2']);
-    expect(graph.root.nodes({ filter: filterLongestPath })).to.have.length(1);
-    expect(graph.findNode('test1')?.nodes({ filter: filterLongestPath })).to.have.length(1);
-    expect(graph.findNode('test2')?.nodes({ filter: filterLongestPath })).to.be.empty;
-
-    longestPaths.clear();
-  });
-
-  test('traversing the graph subscribes to changes', () => {
-    const graph = new Graph();
-
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-
-    const dispose = effect(() => {
-      graph.traverse({
-        visitor: (node, path) => {
-          if (!longestPaths.has(node.id) || longestPaths.get(node.id)!.length < path.length) {
-            longestPaths.set(node.id, path);
-          }
-        },
-      });
-    });
-
-    expect(longestPaths.get('root')).to.deep.equal(['root']);
-    expect(longestPaths.get('test1')).to.deep.equal(['root', 'test1']);
-    expect(longestPaths.get('test2')).to.deep.equal(['root', 'test2']);
-    expect(graph.root.nodes({ filter: filterLongestPath })).to.have.length(2);
-    expect(graph.findNode('test1')?.nodes({ filter: filterLongestPath })).to.be.empty;
-    expect(graph.findNode('test2')?.nodes({ filter: filterLongestPath })).to.be.empty;
-
-    graph.addEdge({ source: 'test1', target: 'test2' });
-
-    expect(longestPaths.get('root')).to.deep.equal(['root']);
-    expect(longestPaths.get('test1')).to.deep.equal(['root', 'test1']);
-    expect(longestPaths.get('test2')).to.deep.equal(['root', 'test1', 'test2']);
-    expect(graph.root.nodes({ filter: filterLongestPath })).to.have.length(1);
-    expect(graph.findNode('test1')?.nodes({ filter: filterLongestPath })).to.have.length(1);
-    expect(graph.findNode('test2')?.nodes({ filter: filterLongestPath })).to.be.empty;
-
-    dispose();
-    longestPaths.clear();
-  });
-
-  test('get path', () => {
-    const graph = new Graph();
-
-    graph.addNodes({
-      id: 'root',
-      nodes: [{ id: 'test1' }, { id: 'test2' }],
-    });
-    graph.addEdge({ source: 'test1', target: 'test2' });
-
-    expect(graph.getPath({ target: 'test2' })).to.deep.equal(['root', 'test1', 'test2']);
-    expect(graph.getPath({ source: 'test1', target: 'test2' })).to.deep.equal(['test1', 'test2']);
-    expect(graph.getPath({ source: 'test2', target: 'test1' })).to.be.undefined;
+    expect(nodes).to.deep.equal(['root-test2-test1', 'root-test2', 'root']);
   });
 });