@polderlabs/bizar 4.8.0 → 5.0.0

package/bizar-dash/tests/eval/runner.test.mjs

@@ -0,0 +1,471 @@
+/**
+ * tests/eval/runner.test.mjs
+ *
+ * v5.0.0 — Tests for the eval runner.
+ *
+ * Verifies:
+ *   - runFixture returns correct shape
+ *   - All check types work (contains, notContains, regex, jsonSchema, maxTokens, maxLatencyMs)
+ *   - Latency tracking
+ *   - Timeout enforcement
+ *   - Suite parallelism
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const EVAL = await import('../../src/server/eval.mjs');
+
+// ── Mock LLM call helpers ──────────────────────────────────────────────────────
+
+function mockLlmCall({ content = 'ok', latencyMs = 10, tokens = 100 } = {}) {
+  return async (prompt, opts) => {
+    await new Promise((r) => setTimeout(r, latencyMs));
+    return {
+      content,
+      usage: {
+        inputTokens: tokens,
+        outputTokens: tokens,
+        totalTokens: tokens * 2,
+      },
+    };
+  };
+}
+
+function failingLlmCall() {
+  return async (prompt, opts) => {
+    throw new Error('LLM error');
+  };
+}
+
+// ── Fixtures ───────────────────────────────────────────────────────────────────
+
+describe('eval runner', () => {
+
+  describe('runFixture', () => {
+
+    it('returns correct shape', async () => {
+      const fixture = {
+        id: 'test-fixture',
+        name: 'Test',
+        description: 'Test fixture',
+        agent: 'thor',
+        prompt: 'Say hello',
+        expected: {},
+      };
+
+      const result = await EVAL.runFixture(fixture, {
+        llmCall: mockLlmCall({ content: 'hello world' }),
+      });
+
+      assert.strictEqual(result.fixtureId, 'test-fixture');
+      assert.strictEqual(typeof result.ok, 'boolean');
+      assert.ok(Array.isArray(result.checks));
+      assert.ok(typeof result.latencyMs === 'number');
+      assert.strictEqual(result.content, 'hello world');
+      assert.ok(result.usage);
+      assert.strictEqual(result.usage.totalTokens, 200);
+    });
+
+    describe('contains check', () => {
+      it('passes when content includes expected substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { contains: ['hello', 'world'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const containsCheck = result.checks.find((c) => c.kind === 'contains');
+        assert.ok(containsCheck);
+        assert.strictEqual(containsCheck.ok, true);
+      });
+
+      it('fails when content does not include expected substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { contains: ['goodbye'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const containsCheck = result.checks.find((c) => c.kind === 'contains');
+        assert.ok(containsCheck);
+        assert.strictEqual(containsCheck.ok, false);
+        assert.ok(containsCheck.message.includes('goodbye'));
+      });
+    });
+
+    describe('notContains check', () => {
+      it('passes when content does NOT include forbidden substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { notContains: ['error', 'fail'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const notContainsCheck = result.checks.find((c) => c.kind === 'notContains');
+        assert.ok(notContainsCheck);
+        assert.strictEqual(notContainsCheck.ok, true);
+      });
+
+      it('fails when content includes forbidden substring', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { notContains: ['error'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello error world' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const notContainsCheck = result.checks.find((c) => c.kind === 'notContains');
+        assert.ok(notContainsCheck);
+        assert.strictEqual(notContainsCheck.ok, false);
+      });
+    });
+
+    describe('regex check', () => {
+      it('passes when regex matches', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { regex: ['hello\\s+world'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const regexCheck = result.checks.find((c) => c.kind === 'regex');
+        assert.ok(regexCheck);
+        assert.strictEqual(regexCheck.ok, true);
+      });
+
+      it('fails when regex does not match', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { regex: ['goodbye\\s+world'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello world' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const regexCheck = result.checks.find((c) => c.kind === 'regex');
+        assert.ok(regexCheck);
+        assert.strictEqual(regexCheck.ok, false);
+      });
+
+      it('fails gracefully on invalid regex', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { regex: ['[invalid'] },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'hello' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const regexCheck = result.checks.find((c) => c.kind === 'regex');
+        assert.ok(regexCheck);
+        assert.strictEqual(regexCheck.ok, false);
+        assert.ok(regexCheck.message.includes('invalid regex'));
+      });
+    });
+
+    describe('jsonSchema check', () => {
+      it('passes when response is valid JSON matching schema', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {
+            jsonSchema: {
+              type: 'object',
+              required: ['status'],
+              properties: { status: { type: 'string' } },
+            },
+          },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: '{"status": "ok"}' }),
+        });
+        assert.strictEqual(result.ok, true);
+        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
+        assert.ok(schemaCheck);
+        assert.strictEqual(schemaCheck.ok, true);
+      });
+
+      it('fails when response is not valid JSON', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { jsonSchema: { type: 'object' } },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: 'not json' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
+        assert.ok(schemaCheck);
+        assert.strictEqual(schemaCheck.ok, false);
+      });
+
+      it('fails when required property is missing', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {
+            jsonSchema: {
+              type: 'object',
+              required: ['version'],
+              properties: { version: { type: 'string' } },
+            },
+          },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ content: '{"status": "ok"}' }),
+        });
+        assert.strictEqual(result.ok, false);
+        const schemaCheck = result.checks.find((c) => c.kind === 'jsonSchema');
+        assert.ok(schemaCheck);
+        assert.strictEqual(schemaCheck.ok, false);
+        assert.ok(schemaCheck.message.includes('missing required property'));
+      });
+    });
+
+    describe('maxTokens check', () => {
+      it('passes when token count is under limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxTokens: 1000 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ tokens: 100 }),
+        });
+        assert.strictEqual(result.ok, true);
+        const tokenCheck = result.checks.find((c) => c.kind === 'maxTokens');
+        assert.ok(tokenCheck);
+        assert.strictEqual(tokenCheck.ok, true);
+      });
+
+      it('fails when token count exceeds limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxTokens: 50 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ tokens: 100 }),
+        });
+        assert.strictEqual(result.ok, false);
+        const tokenCheck = result.checks.find((c) => c.kind === 'maxTokens');
+        assert.ok(tokenCheck);
+        assert.strictEqual(tokenCheck.ok, false);
+        assert.ok(tokenCheck.message.includes('exceeds max'));
+      });
+    });
+
+    describe('maxLatencyMs check', () => {
+      it('passes when latency is under limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxLatencyMs: 5000 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ latencyMs: 10 }),
+        });
+        assert.strictEqual(result.ok, true);
+        const latencyCheck = result.checks.find((c) => c.kind === 'maxLatencyMs');
+        assert.ok(latencyCheck);
+        assert.strictEqual(latencyCheck.ok, true);
+      });
+
+      it('fails when latency exceeds limit', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: { maxLatencyMs: 5 },
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: mockLlmCall({ latencyMs: 100 }),
+        });
+        assert.strictEqual(result.ok, false);
+        const latencyCheck = result.checks.find((c) => c.kind === 'maxLatencyMs');
+        assert.ok(latencyCheck);
+        assert.strictEqual(latencyCheck.ok, false);
+        assert.ok(latencyCheck.message.includes('exceeds max'));
+      });
+    });
+
+    describe('timeout enforcement', () => {
+      it('returns timeout check on timeout', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {},
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: async () => {
+            await new Promise((r) => setTimeout(r, 200));
+            return { content: 'ok', usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } };
+          },
+          timeoutMs: 50,
+        });
+        assert.strictEqual(result.ok, false);
+        const timeoutCheck = result.checks.find((c) => c.kind === 'timeout');
+        assert.ok(timeoutCheck);
+        assert.strictEqual(timeoutCheck.ok, false);
+      });
+    });
+
+    describe('error handling', () => {
+      it('returns error check when LLM call throws', async () => {
+        const fixture = {
+          id: 'test',
+          agent: 'thor',
+          prompt: 'test',
+          expected: {},
+        };
+        const result = await EVAL.runFixture(fixture, {
+          llmCall: failingLlmCall(),
+        });
+        assert.strictEqual(result.ok, false);
+        const errorCheck = result.checks.find((c) => c.kind === 'error');
+        assert.ok(errorCheck);
+        assert.strictEqual(errorCheck.ok, false);
+        assert.ok(errorCheck.message.includes('LLM error'));
+      });
+    });
+  });
+
+  describe('runSuite', () => {
+    const suiteDir = join(tmpdir(), `eval-suite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+    beforeEach(() => {
+      mkdirSync(suiteDir, { recursive: true });
+      writeFileSync(join(suiteDir, 'fix1.json'), JSON.stringify({
+        id: 'fix1',
+        name: 'Fix 1',
+        description: 'First fixture',
+        agent: 'thor',
+        prompt: 'Say hello',
+        expected: { contains: ['hello'] },
+      }));
+      writeFileSync(join(suiteDir, 'fix2.json'), JSON.stringify({
+        id: 'fix2',
+        name: 'Fix 2',
+        description: 'Second fixture',
+        agent: 'thor',
+        prompt: 'Say goodbye',
+        expected: { contains: ['goodbye'] },
+      }));
+    });
+
+    afterEach(() => {
+      rmSync(suiteDir, { recursive: true, force: true });
+    });
+
+    it('runs all fixtures in a directory', async () => {
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ content: 'hello and goodbye' }),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 2);
+      assert.strictEqual(result.passed, 2);
+      assert.strictEqual(result.failed, 0);
+      assert.strictEqual(result.results.length, 2);
+    });
+
+    it('reports failures correctly', async () => {
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ content: 'hello only' }),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 2);
+      assert.strictEqual(result.passed, 1);
+      assert.strictEqual(result.failed, 1);
+    });
+
+    it('runs fixtures in parallel batches', async () => {
+      const start = Date.now();
+      // Create 6 fixtures with unique IDs to test batching
+      for (let i = 0; i < 6; i++) {
+        writeFileSync(join(suiteDir, `batch${i}.json`), JSON.stringify({
+          id: `batch${i}`,
+          name: `Batch ${i}`,
+          description: 'Test fixture',
+          agent: 'thor',
+          prompt: 'Say hello',
+          expected: { contains: ['hello'] },
+        }));
+      }
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ latencyMs: 50 }),
+        concurrency: 3,
+      });
+      // 2 original (fix1, fix2) + 6 new (batch0-5) = 8
+      assert.ok(result.total >= 8, `Expected at least 8 fixtures, got ${result.total}`);
+      // Parallel batches should complete faster than sequential
+      const elapsed = Date.now() - start;
+      assert.ok(elapsed < 500, `Should complete quickly, took ${elapsed}ms`);
+    });
+
+    it('handles suite with no fixtures', async () => {
+      const emptyDir = join(tmpdir(), `eval-empty-${Date.now()}`);
+      mkdirSync(emptyDir, { recursive: true });
+      const result = await EVAL.runSuite(emptyDir, {
+        llmCall: mockLlmCall(),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 0);
+      assert.strictEqual(result.passed, 0);
+      assert.strictEqual(result.failed, 0);
+      rmSync(emptyDir, { recursive: true, force: true });
+    });
+
+    it('loads suite JSON with array of fixtures', async () => {
+      const suiteFile = join(suiteDir, 'suite.json');
+      writeFileSync(suiteFile, JSON.stringify({
+        id: 'my-suite',
+        fixtures: [
+          { id: 'f1', name: 'F1', description: 'F1', agent: 'thor', prompt: 'hi', expected: { contains: ['hi'] } },
+          { id: 'f2', name: 'F2', description: 'F2', agent: 'thor', prompt: 'bye', expected: { contains: ['bye'] } },
+        ],
+      }));
+      const result = await EVAL.runSuite(suiteDir, {
+        llmCall: mockLlmCall({ content: 'hi and bye' }),
+        concurrency: 5,
+      });
+      assert.strictEqual(result.total, 4); // 2 individual + 2 in suite
+    });
+  });
+});

package/bizar-dash/tests/lib/search-fuzzy.test.ts

@@ -0,0 +1,149 @@
+/**
+ * tests/lib/search-fuzzy.test.ts
+ *
+ * v4.9 — Unit tests for fuzzy search with typo tolerance.
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  levenshtein,
+  scoreField,
+  fuzzySearch,
+  type SearchableItem,
+} from '../../src/web/lib/search';
+
+/* ─── Levenshtein ─── */
+
+describe('levenshtein', () => {
+  it('returns 0 for identical strings', () => {
+    expect(levenshtein('hello', 'hello')).toBe(0);
+  });
+
+  it('returns length for completely different strings', () => {
+    expect(levenshtein('abc', 'xyz')).toBe(3);
+  });
+
+  it('counts single-character insertion', () => {
+    expect(levenshtein('cat', 'cats')).toBe(1);
+  });
+
+  it('counts single-character deletion', () => {
+    expect(levenshtein('cats', 'cat')).toBe(1);
+  });
+
+  it('counts single-character substitution', () => {
+    expect(levenshtein('cat', 'car')).toBe(1);
+  });
+
+  it('handles empty strings', () => {
+    expect(levenshtein('', 'abc')).toBe(3);
+    expect(levenshtein('abc', '')).toBe(3);
+    expect(levenshtein('', '')).toBe(0);
+  });
+
+  it('handles transposition as two edits', () => {
+    expect(levenshtein('ab', 'ba')).toBe(2);
+  });
+});
+
+/* ─── scoreField ─── */
+
+describe('scoreField', () => {
+  const field = 'accent color';
+
+  it('exact match scores 100', () => {
+    expect(scoreField('accent color', field)).toBe(100);
+  });
+
+  it('prefix match scores 90', () => {
+    expect(scoreField('acc', field)).toBe(90);
+    expect(scoreField('accent', field)).toBe(90); // starts with "accent"
+  });
+
+  it('word boundary match scores 80', () => {
+    // "color" is a separate word in "accent color"
+    expect(scoreField('color', field)).toBe(80);
+    // "colo" starts at "color" word boundary, not field start
+    expect(scoreField('colo', field)).toBe(80);
+  });
+
+  it('typo within 2 chars scores 40', () => {
+    // "accent" vs "axcent" (one char off)
+    expect(scoreField('axcent', 'accent color')).toBe(40);
+    // "accent" vs "accant" (one char off)
+    const score = scoreField('accant', 'accent color');
+    expect(score).toBe(40);
+  });
+
+  it('substring non-prefix, non-word-boundary match scores 30', () => {
+    // "cent" is not at a word boundary in "accent color"
+    expect(scoreField('cent', 'accent color')).toBe(30);
+  });
+
+  it('returns 0 for no match', () => {
+    expect(scoreField('zzzzz', 'accent color')).toBe(0);
+  });
+
+  it('handles case insensitivity via pre-lowered inputs', () => {
+    // Our callers lower case before passing — verify the scoring works
+    // "accent" is a prefix of "accent color" → scores 90
+    expect(scoreField('Accent'.toLowerCase(), 'Accent Color'.toLowerCase())).toBe(90);
+  });
+});
+
+/* ─── fuzzySearch ─── */
+
+describe('fuzzySearch', () => {
+  const items: SearchableItem[] = [
+    { key: 'theme.accent', label: 'Accent color', section: 'theme', value: '#8b5cf6' },
+    { key: 'theme.fontFamily', label: 'Font family', section: 'theme' },
+    { key: 'ui.layout', label: 'UI layout', section: 'layout', value: 'topnav' },
+    { key: 'defaultAgent', label: 'Default agent', section: 'general', value: 'odin' },
+    { key: 'notifications.onAgentComplete', label: 'Notify on agent complete', section: 'notifications', description: 'Show toast when an agent finishes' },
+  ];
+
+  it('returns empty array for empty query', () => {
+    expect(fuzzySearch('', items)).toEqual([]);
+    expect(fuzzySearch('   ', items)).toEqual([]);
+  });
+
+  it('finds exact match by label', () => {
+    const results = fuzzySearch('accent color', items);
+    expect(results.length).toBeGreaterThanOrEqual(1);
+    expect(results[0].key).toBe('theme.accent');
+    expect(results[0].score).toBe(100);
+  });
+
+  it('finds match by value', () => {
+    const results = fuzzySearch('#8b5cf6', items);
+    expect(results.some((r) => r.key === 'theme.accent')).toBe(true);
+  });
+
+  it('finds match by description', () => {
+    const results = fuzzySearch('toast', items);
+    expect(results.some((r) => r.key === 'notifications.onAgentComplete')).toBe(true);
+  });
+
+  it('finds match via typo tolerance', () => {
+    const results = fuzzySearch('axcent', items);
+    expect(results.some((r) => r.key === 'theme.accent')).toBe(true);
+  });
+
+  it('sorts by score descending', () => {
+    const results = fuzzySearch('agent', items);
+    for (let i = 1; i < results.length; i++) {
+      expect(results[i].score).toBeLessThanOrEqual(results[i - 1].score);
+    }
+  });
+
+  it('returns empty when nothing matches', () => {
+    const results = fuzzySearch('zzzznonexistent', items);
+    expect(results).toEqual([]);
+  });
+
+  it('sets matchedField and matchedTerm on results', () => {
+    const results = fuzzySearch('accent', items);
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].matchedField).toBe('label');
+    expect(results[0].matchedTerm).toBe('Accent color');
+  });
+});

package/bizar-dash/tests/memory-graph-view.test.tsx

@@ -0,0 +1,69 @@
+/**
+ * tests/memory-graph-view.test.tsx
+ *
+ * Tests for MemoryGraphView (SVG force-directed graph).
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import React from 'react';
+import { MemoryGraphView, type GraphData } from '../src/web/views/memory/MemoryGraphView';
+
+const EMPTY_GRAPH: GraphData = { nodes: [], edges: [] };
+
+const THREE_NODE_GRAPH: GraphData = {
+  nodes: [
+    { id: 'notes/alpha.md', label: 'Alpha Note', type: 'note', size: 1, group: 'notes' },
+    { id: 'notes/beta.md', label: 'Beta Note', type: 'note', size: 2, group: 'notes' },
+    { id: 'decisions/dec.md', label: 'Decision', type: 'note', size: 1, group: 'decisions' },
+  ],
+  edges: [
+    { source: 'notes/alpha.md', target: 'notes/beta.md', type: 'links_to', weight: 1 },
+    { source: 'notes/beta.md', target: 'decisions/dec.md', type: 'links_to', weight: 1 },
+  ],
+};
+
+describe('MemoryGraphView', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders SVG with empty graph', () => {
+    render(<MemoryGraphView data={EMPTY_GRAPH} />);
+    const svg = document.querySelector('.memory-graph-canvas');
+    expect(svg).toBeInTheDocument();
+  });
+
+  it('renders nodes and edges', () => {
+    render(<MemoryGraphView data={THREE_NODE_GRAPH} />);
+    // SVG should have circles for nodes (one per node).
+    const circles = document.querySelectorAll('.memory-graph-node');
+    expect(circles.length).toBe(3);
+  });
+
+  it('calls onNodeClick when a node is clicked', () => {
+    const onNodeClick = vi.fn();
+    render(<MemoryGraphView data={THREE_NODE_GRAPH} onNodeClick={onNodeClick} />);
+    const circles = document.querySelectorAll('.memory-graph-node');
+    // Click the first node circle group.
+    if (circles.length > 0) {
+      fireEvent.click(circles[0]);
+    }
+    expect(onNodeClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders filtered nodes when filter is applied via data prop', () => {
+    const filteredData = {
+      nodes: THREE_NODE_GRAPH.nodes.filter((n) => n.label.includes('Alpha')),
+      edges: [],
+    };
+    render(<MemoryGraphView data={filteredData} />);
+    const circles = document.querySelectorAll('.memory-graph-node');
+    expect(circles.length).toBe(1);
+  });
+
+  it('node has correct type and group fields', () => {
+    render(<MemoryGraphView data={THREE_NODE_GRAPH} />);
+    const circles = document.querySelectorAll('.memory-graph-node');
+    expect(circles.length).toBeGreaterThan(0);
+  });
+});