Versie 0.2.0

2026-10-29 11:57:29 +01:00
commit e77d8fd373
@@ -0,0 +1,162 @@
+// Generated, do not edit. sha256:f1d5e464bcd04ed7f483f797346cfeb34bcf1b0c9306b56821baa618e0b3ee5f
+import { describe, it, before, mock } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createDbHarness } from '../helpers/db-node.mjs';
+
+const harness = createDbHarness({ seedPreferences: true });
+mock.module('../../server/db.js', { namedExports: harness.exports });
+
+const { precisionSettings, precisionKey, shareDisclosure } = await import('../../server/ai/precision.js');
+const { createTranslator } = await import('../../server/ai/translate.js');
+const { setPref } = await import('../../server/data/preferences.js');
+
+const TEST_GEHEIM = 'geheim-voor-de-precisietest-0123456789ab';
+
+before(() => { harness.recreate(); });
+
+describe('precisionSettings: de stand van dit moment', () => {
+  it('volgt de voorkeur, en leest hem per aanroep', async () => {
+    await setPref('ai', 'allow_raw', 0);
+    assert.equal(precisionSettings().rawValues, false);
+
+    await setPref('ai', 'allow_raw', 1);
+    assert.equal(precisionSettings().rawValues, true,
+      'zonder herlezen doet de schuif pas iets bij een nieuwe verbinding');
+
+    await setPref('ai', 'allow_raw', 0);
+  });
+
+  it('is bevroren, zodat een tool zijn eigen antwoord niet kan verbreden', () => {
+    const stand = precisionSettings();
+    assert.throws(() => { stand.rawValues = true; }, TypeError);
+    assert.equal(stand.rawValues, false);
+  });
+});
+
+describe('precisionKey: de stand als geheel in de sleutel', () => {
+  it('hangt niet aan de volgorde van de velden', () => {
+    assert.equal(precisionKey({ rawValues: false, totals: true }), precisionKey({ totals: true, rawValues: false }));
+  });
+
+  it('geeft twee verschillende standen twee verschillende sleutels', () => {
+    const a = precisionKey({ rawValues: false, totals: true });
+    const b = precisionKey({ rawValues: false, totals: false });
+    assert.notEqual(a, b, 'een verschil in welk veld dan ook hoort een andere sleutel op te leveren');
+  });
+
+  it('heeft een eigen vorm voor de lege stand, en verwart die niet met een ontbrekende', () => {
+    assert.equal(precisionKey({}), 'leeg');
+    assert.equal(precisionKey(undefined), 'leeg');
+    assert.equal(precisionKey(null), 'leeg');
+  });
+});
+
+describe('createTranslator: de stand komt binnen als geheel', () => {
+  it('valt zonder stand terug op VERTAALD en niet op onbewerkt', () => {
+    const t = createTranslator({ secret: TEST_GEHEIM });
+    assert.equal(t.precision.rawValues, false);
+    const uit = t.toAi({ id: 1, amount: 12345.678 }, { entity: 'account' });
+    assert.equal(typeof uit.amount, 'string');
+  });
+
+  it('draagt de stand die hij kreeg, en die is van buitenaf niet te verzetten', () => {
+    const t = createTranslator({ secret: TEST_GEHEIM, precision: { rawValues: true } });
+    assert.equal(t.precision.rawValues, true);
+    assert.throws(() => { t.precision.rawValues = false; }, TypeError);
+  });
+
+  it('laat een onbekend veld in de stand niet als raw gelden', () => {
+    const t = createTranslator({ secret: TEST_GEHEIM, precision: { rawWaarden: true } });
+    assert.equal(t.precision.rawValues, false);
+    const uit = t.toAi({ id: 1, amount: 12345.678 }, { entity: 'account' });
+    assert.equal(typeof uit.amount, 'string');
+  });
+});
+
+describe('de vier precisie-schuiven', () => {
+  const zet = async (sleutels) => {
+    for (const [k, v] of Object.entries(sleutels)) await setPref('ai', k, v ? 1 : 0);
+  };
+
+  it('zet de vier op false zodra onbewerkt delen aan staat, want dan valt er niets te emmeren', async () => {
+    await zet({ bucket_shares: 1, bucket_totals: 1, bucket_amounts: 1, bucket_quantities: 1 });
+    await setPref('ai', 'allow_raw', 1);
+    try {
+      const p = precisionSettings();
+      assert.equal(p.rawValues, true);
+      assert.deepEqual(
+        [p.bucketShares, p.bucketTotals, p.bucketAmounts, p.bucketQuantities],
+        [false, false, false, false],
+        'laag 3 hoort laag 1 te overrulen in de LAAG, niet bij elke aanroeper opnieuw');
+    } finally {
+      await setPref('ai', 'allow_raw', 0);
+    }
+  });
+
+  it('leest elke schuif apart, zodat er geen twee aan elkaar vastzitten', async () => {
+    await zet({ bucket_shares: 0, bucket_totals: 1, bucket_amounts: 0, bucket_quantities: 1 });
+    const p = precisionSettings();
+    assert.deepEqual(
+      [p.bucketShares, p.bucketTotals, p.bucketAmounts, p.bucketQuantities],
+      [false, true, false, true]);
+    await zet({ bucket_shares: 1, bucket_totals: 1, bucket_amounts: 1, bucket_quantities: 1 });
+  });
+
+  it('emmert een hoeveelheid alleen zolang ZIJN schuif aan staat', () => {
+    const aan = createTranslator({ secret: TEST_GEHEIM, precision: { bucketQuantities: true } });
+    const uit = createTranslator({ secret: TEST_GEHEIM, precision: { bucketQuantities: false } });
+    assert.equal(typeof aan.toAi({ amount: 12345.678 }, { entity: 'account' }).amount, 'string');
+    assert.equal(uit.toAi({ amount: 12345.678 }, { entity: 'account' }).amount, 12345.678);
+  });
+
+  it('KRUISPROEF: dezelfde klasse gaat anders naar buiten als TOTAAL dan als REGEL', () => {
+    const t = createTranslator({
+      secret: TEST_GEHEIM,
+      precision: { bucketTotals: false, bucketAmounts: true },
+    });
+    const alsTotaal = t.toAi({ fiatValue: 98765 }, { entity: 'wealth', role: 'total' }).fiatValue;
+    const alsRegel = t.toAi({ fiatValue: 98765 }, { entity: 'wealth' }).fiatValue;
+    assert.equal(alsTotaal, 98765, 'het totaal hoort exact te zijn: die schuif staat uit');
+    assert.equal(typeof alsRegel, 'string', 'het regelbedrag hoort een emmer te zijn: die staat aan');
+  });
+
+  it('leest een ontbrekende rol als REGEL, en dat is de striktste van de twee', () => {
+    const t = createTranslator({
+      secret: TEST_GEHEIM,
+      precision: { bucketTotals: false, bucketAmounts: true },
+    });
+    assert.equal(typeof t.toAi({ fiatValue: 98765 }, { entity: 'wealth' }).fiatValue, 'string');
+  });
+});
+
+describe('shareDisclosure: de invariant van §10c in de laag', () => {
+  const stand = (o) => ({ rawValues: false, bucketShares: true, bucketTotals: true,
+    bucketAmounts: true, bucketQuantities: true, ...o });
+
+  it('laat een geëmmerd aandeel naast een geëmmerd totaal toe: de gemeten uitzondering', () => {
+    assert.equal(shareDisclosure(stand({})), 'bucketed');
+  });
+
+  it('laat een exact aandeel toe zolang het TOTAAL geëmmerd is, want dat is één beeld', () => {
+    assert.equal(shareDisclosure(stand({ bucketShares: false })), 'exact');
+  });
+
+  it('LAAT DE VERDELING WEG als het totaal én het aandeel exact zijn', () => {
+    assert.equal(shareDisclosure(stand({ bucketShares: false, bucketTotals: false })), 'omit');
+  });
+
+  it('houdt de verdeling wél als de regelbedragen tóch al exact zijn', () => {
+    assert.equal(
+      shareDisclosure(stand({ bucketShares: false, bucketTotals: false, bucketAmounts: false })),
+      'exact');
+  });
+
+  it('geeft in de onbewerkte stand alles exact', () => {
+    assert.equal(shareDisclosure({ rawValues: true }), 'exact');
+  });
+
+  it('valt op een lege stand niet om', () => {
+    assert.equal(shareDisclosure(undefined), 'exact');
+  });
+});