test: cover graph3d_transform.linkKey + app.formatQn (node tests)

Author: smochan

tests/test_app_format.js

@@ -0,0 +1,73 @@
+/* Tests for formatQn() in codegraph/web/static/app.js
+ *
+ * app.js is a classic browser script. Extract the `formatQn` function source
+ * (along with its `esc` dependency) and evaluate them in a Node vm sandbox.
+ *
+ * Run with:  node --test tests/test_app_format.js
+ */
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+const APP_JS = path.join(
+  __dirname, '..', 'codegraph', 'web', 'static', 'app.js'
+);
+
+function loadFormatQn() {
+  const source = fs.readFileSync(APP_JS, 'utf-8');
+  const escMatch = source.match(/function esc\(s\)\s*\{[\s\S]*?\n\}/);
+  if (!escMatch) throw new Error('esc() not found in app.js');
+  const fmtMatch = source.match(/function formatQn\(qn,\s*opts\)\s*\{[\s\S]*?\n\}/);
+  if (!fmtMatch) throw new Error('formatQn() not found in app.js');
+  const sandbox = {};
+  vm.createContext(sandbox);
+  vm.runInContext(
+    `${escMatch[0]}\n${fmtMatch[0]}\nthis.formatQn = formatQn;`,
+    sandbox,
+  );
+  return sandbox.formatQn;
+}
+
+const formatQn = loadFormatQn();
+
+test('formatQn renders single-segment as leaf', () => {
+  const out = formatQn('foo', { maxParts: 3 });
+  assert.match(out, /qn-key/);
+  assert.match(out, />foo</);
+});
+
+test('formatQn dims parent path', () => {
+  const out = formatQn('a.b.c', { maxParts: 3 });
+  assert.match(out, /qn-dim/);
+  assert.match(out, /a\.b\./);
+  assert.match(out, />c</);
+});
+
+test('formatQn truncates long paths with ellipsis', () => {
+  const out = formatQn('a.b.c.d.e', { maxParts: 2 });
+  assert.match(out, /…/);
+  assert.match(out, />e</);
+});
+
+test('formatQn escapes HTML in qn segments', () => {
+  const out = formatQn('a.<b>', { maxParts: 3 });
+  assert.match(out, /&lt;b&gt;/);
+  assert.doesNotMatch(out, /<b>/);
+});
+
+test('formatQn handles null gracefully', () => {
+  const out = formatQn(null, { maxParts: 3 });
+  // null is coalesced to '' before splitting; one empty leaf, no head.
+  assert.match(out, /qn-key/);
+  assert.doesNotMatch(out, /null/);
+});
+
+test('formatQn defaults maxParts when opts omitted', () => {
+  const out = formatQn('a.b.c.d.e');
+  // default maxParts = 3 -> visible head = last 2 segments
+  assert.match(out, /…/);
+});

tests/test_graph3d_transform.js

@@ -175,3 +175,53 @@ test('edgeColor varies by edge kind', () => {
   assert.notEqual(a, b);
   assert.notEqual(b, c);
 });
+
+// ---------------------------------------------------------------------------
+// linkKey() — pure helper used for dedup. Not exported; load via vm.
+// ---------------------------------------------------------------------------
+
+const fs = require('node:fs');
+const vm = require('node:vm');
+
+function loadLinkKey() {
+  const file = path.join(
+    __dirname, '..', 'codegraph', 'web', 'static', 'views', 'graph3d_transform.js'
+  );
+  const source = fs.readFileSync(file, 'utf-8');
+  const match = source.match(/function linkKey\(source,\s*target\)\s*\{[\s\S]*?\n\}/);
+  if (!match) throw new Error('linkKey() not found in graph3d_transform.js');
+  const sandbox = {};
+  vm.createContext(sandbox);
+  vm.runInContext(`${match[0]}\nthis.linkKey = linkKey;`, sandbox);
+  return sandbox.linkKey;
+}
+
+const linkKey = loadLinkKey();
+
+test('linkKey accepts plain string ids', () => {
+  assert.equal(linkKey('a', 'b'), 'a->b');
+});
+
+test('linkKey extracts .id from object source', () => {
+  assert.equal(linkKey({ id: 'x' }, 'y'), 'x->y');
+});
+
+test('linkKey extracts .id from object target', () => {
+  assert.equal(linkKey('a', { id: 'b' }), 'a->b');
+});
+
+test('linkKey works for both objects', () => {
+  assert.equal(linkKey({ id: 'foo' }, { id: 'bar' }), 'foo->bar');
+});
+
+test('linkKey stringifies non-string ids', () => {
+  assert.equal(linkKey(1, 2), '1->2');
+});
+
+test('linkKey is deterministic — same inputs same output', () => {
+  assert.equal(linkKey('a', 'b'), linkKey('a', 'b'));
+});
+
+test('linkKey distinguishes direction', () => {
+  assert.notEqual(linkKey('a', 'b'), linkKey('b', 'a'));
+});