@assistkick/create 1.0.0

package/templates/product-system/tests/hide_defined_filter.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tests for Hide Defined Nodes Filter (feat_018).
+ * Uses node:test built-in runner.
+ * Tests the filtering logic that hides fully defined (status=defined, completeness=1)
+ * nodes and their connected edges from the graph.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// Minimal renderer mock that replicates the buildNodes and buildLinks logic
+const createRenderer = (hideDefinedActive = false) => {
+  const renderer = {
+    hideDefinedActive,
+
+    buildNodes: function (graphData) {
+      const edgeCounts = new Map();
+      graphData.edges.forEach(e => {
+        edgeCounts.set(e.from, (edgeCounts.get(e.from) || 0) + 1);
+        edgeCounts.set(e.to, (edgeCounts.get(e.to) || 0) + 1);
+      });
+
+      let nodes = graphData.nodes.map(n => ({
+        ...n,
+        edgeCount: edgeCounts.get(n.id) || 0,
+      }));
+
+      if (this.hideDefinedActive) {
+        nodes = nodes.filter(n => !(n.status === 'defined' && n.completeness === 1));
+      }
+
+      return nodes;
+    },
+
+    buildLinks: function (graphData, nodes) {
+      const nodeIds = new Set(nodes.map(n => n.id));
+      return graphData.edges
+        .filter(e => nodeIds.has(e.from) && nodeIds.has(e.to))
+        .map(e => ({
+          source: e.from,
+          target: e.to,
+          relation: e.relation,
+        }));
+    },
+  };
+  return renderer;
+};
+
+// Test fixtures
+const makeGraphData = () => ({
+  nodes: [
+    { id: 'feat_001', type: 'feature', name: 'Defined Feature', status: 'defined', completeness: 1, open_questions_count: 0 },
+    { id: 'feat_002', type: 'feature', name: 'Draft Feature', status: 'draft', completeness: 0.3, open_questions_count: 1 },
+    { id: 'comp_001', type: 'component', name: 'Defined Component', status: 'defined', completeness: 1, open_questions_count: 0 },
+    { id: 'dec_001', type: 'decision', name: 'Partial Decision', status: 'partially_defined', completeness: 0.5, open_questions_count: 0 },
+    { id: 'feat_003', type: 'feature', name: 'Almost Done', status: 'defined', completeness: 0.9, open_questions_count: 0 },
+  ],
+  edges: [
+    { from: 'feat_001', to: 'comp_001', relation: 'contains' },
+    { from: 'feat_002', to: 'dec_001', relation: 'depends_on' },
+    { from: 'feat_001', to: 'dec_001', relation: 'governed_by' },
+    { from: 'feat_003', to: 'comp_001', relation: 'contains' },
+  ],
+});
+
+describe('Hide Defined Nodes Filter', () => {
+
+  describe('buildNodes filtering', () => {
+    it('returns all nodes when filter is inactive', () => {
+      const renderer = createRenderer(false);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      assert.equal(nodes.length, 5);
+    });
+
+    it('removes nodes with status=defined and completeness=1 when filter is active', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      assert.equal(nodes.length, 3);
+      const ids = nodes.map(n => n.id).sort();
+      assert.deepEqual(ids, ['dec_001', 'feat_002', 'feat_003']);
+    });
+
+    it('keeps nodes with status=defined but completeness < 1', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      const feat003 = nodes.find(n => n.id === 'feat_003');
+      assert.ok(feat003, 'feat_003 should be kept (completeness 0.9)');
+    });
+
+    it('keeps draft and partially_defined nodes regardless of completeness', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      const feat002 = nodes.find(n => n.id === 'feat_002');
+      const dec001 = nodes.find(n => n.id === 'dec_001');
+      assert.ok(feat002, 'feat_002 (draft) should be kept');
+      assert.ok(dec001, 'dec_001 (partially_defined) should be kept');
+    });
+
+    it('returns empty array when all nodes are fully defined', () => {
+      const renderer = createRenderer(true);
+      const graphData = {
+        nodes: [
+          { id: 'a', type: 'feature', name: 'A', status: 'defined', completeness: 1, open_questions_count: 0 },
+          { id: 'b', type: 'feature', name: 'B', status: 'defined', completeness: 1, open_questions_count: 0 },
+        ],
+        edges: [],
+      };
+      const nodes = renderer.buildNodes(graphData);
+      assert.equal(nodes.length, 0);
+    });
+  });
+
+  describe('edge filtering with hidden nodes', () => {
+    it('removes edges connected to hidden nodes', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      // feat_001 and comp_001 are hidden (both defined, completeness=1)
+      // Only edge feat_002 -> dec_001 should remain
+      assert.equal(links.length, 1);
+      assert.equal(links[0].source, 'feat_002');
+      assert.equal(links[0].target, 'dec_001');
+    });
+
+    it('keeps all edges when filter is inactive', () => {
+      const renderer = createRenderer(false);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      assert.equal(links.length, 4);
+    });
+
+    it('removes edges where source is hidden', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      // feat_001 -> dec_001 edge should be gone (feat_001 is hidden)
+      const hasEdgeFromFeat001 = links.some(l => l.source === 'feat_001');
+      assert.equal(hasEdgeFromFeat001, false);
+    });
+
+    it('removes edges where target is hidden', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+      const links = renderer.buildLinks(graphData, nodes);
+
+      // feat_003 -> comp_001 edge should be gone (comp_001 is hidden)
+      const hasEdgeToComp001 = links.some(l => l.target === 'comp_001');
+      assert.equal(hasEdgeToComp001, false);
+    });
+  });
+
+  describe('toggle state', () => {
+    it('starts with filter inactive', () => {
+      const renderer = createRenderer();
+      assert.equal(renderer.hideDefinedActive, false);
+    });
+
+    it('can be toggled on', () => {
+      const renderer = createRenderer(false);
+      renderer.hideDefinedActive = true;
+      assert.equal(renderer.hideDefinedActive, true);
+    });
+
+    it('toggling changes buildNodes output', () => {
+      const renderer = createRenderer(false);
+      const graphData = makeGraphData();
+
+      const nodesBefore = renderer.buildNodes(graphData);
+      assert.equal(nodesBefore.length, 5);
+
+      renderer.hideDefinedActive = true;
+      const nodesAfter = renderer.buildNodes(graphData);
+      assert.equal(nodesAfter.length, 3);
+    });
+  });
+
+  describe('edge count calculation', () => {
+    it('calculates edge counts before filtering', () => {
+      const renderer = createRenderer(true);
+      const graphData = makeGraphData();
+      const nodes = renderer.buildNodes(graphData);
+
+      // feat_002 has 1 edge (feat_002 -> dec_001)
+      const feat002 = nodes.find(n => n.id === 'feat_002');
+      assert.equal(feat002.edgeCount, 1);
+
+      // dec_001 has 2 edges (feat_002 -> dec_001, feat_001 -> dec_001)
+      const dec001 = nodes.find(n => n.id === 'dec_001');
+      assert.equal(dec001.edgeCount, 2);
+    });
+  });
+});