Add converter engine tests (32 tests)

Tests cover EuclidianDistanceEngine (initialization, toVector/fromVector
round-trips, cross-method conversion, distance calculations) and
HDSModelConverters integration (convertMethodToEvent, convertEventToMethod,
convertMethodToMethod, loadPack, error handling).

Author: perki

tests/converterEngine.test.js

@@ -0,0 +1,274 @@
+import { assert } from './test-utils/deps-node.js';
+import { EuclidianDistanceEngine, HDSModelConverters } from '../ts/index.ts';
+
+// Load the cervical-fluid pack from data-model-draft dist
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Resolve path to data-model-draft dist (sibling repo in _macro2)
+const macro2Root = path.resolve(__dirname, '../../..');
+const cervicalFluidPack = JSON.parse(
+  fs.readFileSync(path.join(macro2Root, 'data-model-draft/data-model-draft/dist/converters/cervical-fluid/pack-latest.json'), 'utf-8')
+);
+const moodPack = JSON.parse(
+  fs.readFileSync(path.join(macro2Root, 'data-model-draft/data-model-draft/dist/converters/mood/pack-latest.json'), 'utf-8')
+);
+
+describe('[EDEX] EuclidianDistanceEngine', function () {
+  let cfEngine;
+  let moodEngine;
+
+  before(() => {
+    cfEngine = new EuclidianDistanceEngine(cervicalFluidPack);
+    moodEngine = new EuclidianDistanceEngine(moodPack);
+  });
+
+  describe('[EDEI] Engine initialization', () => {
+    it('[EDEI1] cervical-fluid engine loads 11 methods', () => {
+      assert.strictEqual(cfEngine.methodIds.length, 11);
+    });
+
+    it('[EDEI2] mood engine loads 2 methods', () => {
+      assert.strictEqual(moodEngine.methodIds.length, 2);
+    });
+
+    it('[EDEI3] cervical-fluid has 9 dimensions', () => {
+      assert.strictEqual(cfEngine.dimensionNames.length, 9);
+    });
+
+    it('[EDEI4] mood has 5 dimensions', () => {
+      assert.strictEqual(moodEngine.dimensionNames.length, 5);
+    });
+
+    it('[EDEI5] weights sum to 1.0', () => {
+      let cfSum = 0;
+      for (const d of cfEngine.dimensionNames) cfSum += cfEngine.weights[d];
+      assert.ok(Math.abs(cfSum - 1.0) < 0.01);
+
+      let moodSum = 0;
+      for (const d of moodEngine.dimensionNames) moodSum += moodEngine.weights[d];
+      assert.ok(Math.abs(moodSum - 1.0) < 0.01);
+    });
+  });
+
+  describe('[EDEV] toVector / fromVector', () => {
+    it('[EDEV1] appleHealth eggWhite → vector with high values', () => {
+      const vec = cfEngine.toVector('appleHealth', 'eggWhite');
+      assert.strictEqual(vec.threadiness, 1);
+      assert.strictEqual(vec.stretchability, 1);
+      assert.strictEqual(vec.lubricative, 1);
+    });
+
+    it('[EDEV2] appleHealth dry → zero vector', () => {
+      const vec = cfEngine.toVector('appleHealth', 'dry');
+      let sum = 0;
+      for (const d of cfEngine.dimensionNames) sum += vec[d];
+      assert.strictEqual(sum, 0);
+    });
+
+    it('[EDEV3] fromVector round-trips appleHealth observations', () => {
+      for (const obs of ['dry', 'sticky', 'creamy', 'watery', 'eggWhite']) {
+        const vec = cfEngine.toVector('appleHealth', obs);
+        const result = cfEngine.fromVector('appleHealth', vec);
+        assert.strictEqual(result.data, obs, `round-trip failed for ${obs}`);
+        assert.strictEqual(result.matchDistance, 0, `distance should be 0 for exact match: ${obs}`);
+      }
+    });
+
+    it('[EDEV4] mira mood observations round-trip', () => {
+      for (const obs of ['Happy', 'Sad', 'Normal', 'Excited']) {
+        const vec = moodEngine.toVector('mira', obs);
+        const result = moodEngine.fromVector('mira', vec);
+        assert.strictEqual(result.data, obs, `round-trip failed for ${obs}`);
+      }
+    });
+
+    it('[EDEV5] case-insensitive matching for mira cervical-fluid', () => {
+      const vec = cfEngine.toVector('mira', 'raw egg white');
+      assert.strictEqual(vec.threadiness, 1);
+    });
+
+    it('[EDEV6] unknown observation throws', () => {
+      assert.throws(() => cfEngine.toVector('appleHealth', 'unknown'), /Unknown/);
+    });
+
+    it('[EDEV7] unknown method throws', () => {
+      assert.throws(() => cfEngine.toVector('nonexistent', 'dry'), /Unknown method/);
+    });
+  });
+
+  describe('[EDEC] Cross-method conversion', () => {
+    it('[EDEC1] mira Raw Egg White → appleHealth eggWhite', () => {
+      const result = cfEngine.convertMethodToMethod('mira', 'appleHealth', 'Raw Egg White');
+      assert.strictEqual(result.data, 'eggWhite');
+      assert.strictEqual(result.matchDistance, 0);
+    });
+
+    it('[EDEC2] mira Creamy → appleHealth creamy', () => {
+      const result = cfEngine.convertMethodToMethod('mira', 'appleHealth', 'Creamy');
+      assert.strictEqual(result.data, 'creamy');
+    });
+
+    it('[EDEC3] mira Dry → appleHealth dry', () => {
+      const result = cfEngine.convertMethodToMethod('mira', 'appleHealth', 'Dry');
+      assert.strictEqual(result.data, 'dry');
+    });
+
+    it('[EDEC4] creighton 10KL → appleHealth eggWhite', () => {
+      const result = cfEngine.convertMethodToMethod('creighton', 'appleHealth', '10KL');
+      assert.strictEqual(result.data, 'eggWhite');
+    });
+
+    it('[EDEC5] creighton 0 → appleHealth dry', () => {
+      const result = cfEngine.convertMethodToMethod('creighton', 'appleHealth', '0');
+      assert.strictEqual(result.data, 'dry');
+    });
+
+    it('[EDEC6] mira Clumpy white → appleHealth sticky (pathological)', () => {
+      const result = cfEngine.convertMethodToMethod('mira', 'appleHealth', 'Clumpy white');
+      assert.ok(['dry', 'sticky'].includes(result.data), `expected dry or sticky, got ${result.data}`);
+    });
+
+    it('[EDEC7] mood mira Happy → hds produces valid 5D vector', () => {
+      const vec = moodEngine.toVector('mira', 'Happy');
+      assert.strictEqual(vec.valence, 0.80);
+      assert.strictEqual(vec.arousal, 0.60);
+      const result = moodEngine.fromVector('hds', vec);
+      // hds is assembly — result should be an object with 5 fields
+      assert.ok(result.data, 'should have result data');
+    });
+  });
+
+  describe('[EDED] Distance calculations', () => {
+    it('[EDED1] distance between identical vectors is 0', () => {
+      const vec = cfEngine.toVector('appleHealth', 'creamy');
+      assert.strictEqual(cfEngine.distance(vec, vec), 0);
+    });
+
+    it('[EDED2] distance between dry and eggWhite is large', () => {
+      const dry = cfEngine.toVector('appleHealth', 'dry');
+      const egg = cfEngine.toVector('appleHealth', 'eggWhite');
+      const d = cfEngine.distance(dry, egg);
+      assert.ok(d > 0.5, `expected large distance, got ${d}`);
+    });
+
+    it('[EDED3] distance between sticky and creamy is small', () => {
+      const sticky = cfEngine.toVector('appleHealth', 'sticky');
+      const creamy = cfEngine.toVector('appleHealth', 'creamy');
+      const d = cfEngine.distance(sticky, creamy);
+      assert.ok(d < 0.2, `expected small distance, got ${d}`);
+    });
+
+    it('[EDED4] zeroVector has all zeros', () => {
+      const z = cfEngine.zeroVector();
+      for (const dim of cfEngine.dimensionNames) {
+        assert.strictEqual(z[dim], 0);
+      }
+    });
+  });
+});
+
+describe('[MCVX] HDSModelConverters with loadPack', function () {
+  let converters;
+
+  before(() => {
+    // Create a minimal mock model
+    const mockModel = {
+      modelUrl: 'https://model.datasafe.dev/pack.json',
+      modelData: {
+        items: {
+          'body-vulva-mucus-inspect': {
+            key: 'body-vulva-mucus-inspect',
+            streamId: 'body-vulva-mucus-inspect',
+            eventType: 'vulva-mucus-inspect/9d-vector',
+            type: 'convertible',
+            'converter-engine': { key: 'euclidian-distance', version: 'v0', models: 'cervical-fluid' }
+          },
+          'wellbeing-mood': {
+            key: 'wellbeing-mood',
+            streamId: 'wellbeing-mood',
+            eventType: 'mood/5d-vectors',
+            type: 'convertible',
+            'converter-engine': { key: 'euclidian-distance', version: 'v0', models: 'mood' }
+          }
+        },
+        converters: {
+          'cervical-fluid': { latestVersion: 'v0' },
+          mood: { latestVersion: 'v0' }
+        }
+      }
+    };
+
+    converters = new HDSModelConverters(mockModel);
+    converters.loadPack(cervicalFluidPack);
+    converters.loadPack(moodPack);
+  });
+
+  it('[MCVX1] lists loaded item keys', () => {
+    const keys = converters.loadedItemKeys.sort();
+    assert.deepStrictEqual(keys, ['cervical-fluid', 'mood']);
+  });
+
+  it('[MCVX2] getEngine returns loaded engines', () => {
+    assert.ok(converters.getEngine('cervical-fluid'));
+    assert.ok(converters.getEngine('mood'));
+    assert.strictEqual(converters.getEngine('unknown'), undefined);
+  });
+
+  it('[MCVX3] convertMethodToEvent produces valid event structure', async () => {
+    const event = await converters.convertMethodToEvent('cervical-fluid', 'mira', 'Creamy');
+    assert.strictEqual(event.type, 'vulva-mucus-inspect/9d-vector');
+    assert.deepStrictEqual(event.streamIds, ['body-vulva-mucus-inspect']);
+    assert.ok(event.content.data, 'should have data');
+    assert.strictEqual(event.content.data.threadiness, 0.4);
+    assert.ok(event.content.source, 'should have source');
+    assert.strictEqual(event.content.source.key, 'mira');
+    assert.strictEqual(event.content.source.sourceData, 'Creamy');
+    assert.strictEqual(event.content.source.engineVersion, 'v0');
+  });
+
+  it('[MCVX4] convertEventToMethod recovers source observation', async () => {
+    const event = await converters.convertMethodToEvent('cervical-fluid', 'appleHealth', 'eggWhite');
+    const result = await converters.convertEventToMethod(event, 'appleHealth');
+    assert.strictEqual(result.data, 'eggWhite');
+    assert.strictEqual(result.matchDistance, 0);
+  });
+
+  it('[MCVX5] convertEventToMethod cross-method', async () => {
+    const event = await converters.convertMethodToEvent('cervical-fluid', 'mira', 'Raw Egg White');
+    const result = await converters.convertEventToMethod(event, 'appleHealth');
+    assert.strictEqual(result.data, 'eggWhite');
+  });
+
+  it('[MCVX6] convertMethodToMethod works', async () => {
+    const result = await converters.convertMethodToMethod('mood', 'mira', 'hds', 'Happy');
+    assert.ok(result.data, 'should have result');
+    assert.ok(result.matchDistance >= 0, 'should have matchDistance');
+  });
+
+  it('[MCVX7] convertMethodToEvent for mood produces valid event', async () => {
+    const event = await converters.convertMethodToEvent('mood', 'mira', 'Sad');
+    assert.strictEqual(event.type, 'mood/5d-vectors');
+    assert.deepStrictEqual(event.streamIds, ['wellbeing-mood']);
+    assert.strictEqual(event.content.data.valence, 0.15);
+    assert.strictEqual(event.content.source.key, 'mira');
+    assert.strictEqual(event.content.source.sourceData, 'Sad');
+  });
+
+  it('[MCVX8] throws for unknown item key', async () => {
+    try {
+      await converters.convertMethodToEvent('unknown', 'mira', 'test');
+      assert.fail('should have thrown');
+    } catch (e) {
+      assert.ok(e.message.includes('Unknown converter item key'));
+    }
+  });
+
+  it('[MCVX9] loadPack rejects unknown engine', () => {
+    assert.throws(() => {
+      converters.loadPack({ engine: 'neural-network', itemKey: 'test', methods: [] });
+    }, /Unknown converter engine/);
+  });
+});