AtreidesAssetsFree/tests/wealth/account-cards.test.mjs

// Generated, do not edit. sha256:0f6993661d02e71fdfac02fe8654043545e492226f4b4b24bcf5f37c477e0be0
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { accountCards } from '../../client/wealth/account-cards.js';

const BTC = { id: 1, symbol: 'BTC', name: 'Bitcoin', kind: 'crypto', decimals: 8 };
const EUR = { id: 2, symbol: 'EUR', name: 'Euro', kind: 'fiat', decimals: 2 };
const kaart = (asset, net, fiatPrice, unrealized = null) => ({ asset, p: { id: asset.id, net }, m: { fiatPrice, unrealized, origin: null } });
const accounts = [
  { id: 10, name: 'Koude wallet', kind: 'wallet' },
  { id: 11, name: 'Beurs', kind: 'exchange' },
  { id: 12, name: 'Bank', kind: 'bank' },
];
const rond = v => Math.round(v * 1e6) / 1e6;

describe('accountCards', () => {
  it('telt per account op tot de assetkaarten, ongerealiseerd naar rato van de eenheden', () => {
    const cards = accountCards({
      kaarten: [kaart(BTC, 3e8, 100, 60), kaart(EUR, 50000, 1)],
      holdings: [
        { accountId: 10, assetId: BTC.id, saldo: 2e8 },
        { accountId: 11, assetId: BTC.id, saldo: 1e8 },
        { accountId: 11, assetId: EUR.id, saldo: 50000 },
      ],
      accounts,
    });
    assert.deepEqual(cards.map(c => c.accountId), [11, 10], 'beurs vóór wallet: de volgorde van de soorten');
    const [beurs, wallet] = cards;
    assert.equal(rond(wallet.value), 200);
    assert.equal(rond(wallet.unrealized), 40);
    assert.equal(rond(beurs.value), 600);
    assert.equal(rond(beurs.unrealized), 20, 'de euro heeft geen kostprijs en telt niet mee');
    assert.deepEqual(beurs.kinds.sort(), ['crypto', 'fiat']);
  });

  it('geeft wat op geen account staat een eigen kaart, achteraan', () => {
    const cards = accountCards({
      kaarten: [kaart(BTC, 3e8, 100)],
      holdings: [{ accountId: 10, assetId: BTC.id, saldo: 2e8 }],
      accounts,
    });
    assert.deepEqual(cards.map(c => c.accountId), [10, null]);
    assert.equal(rond(cards[1].value), 100);
    assert.equal(cards[1].account, null);
  });

  it('laat waarde en ongerealiseerd leeg zonder koers, en niet nul', () => {
    const [c] = accountCards({
      kaarten: [kaart(BTC, 1e8, null, null)],
      holdings: [{ accountId: 10, assetId: BTC.id, saldo: 1e8 }],
      accounts,
    });
    assert.equal(c.value, null);
    assert.equal(c.unrealized, null);
    assert.equal(c.lines.length, 1);
  });

  it('toont een account dat in de periode bewoog ook zonder saldo, en een onbekend id zonder saldo niet', () => {
    const cards = accountCards({
      kaarten: [kaart(BTC, 1e8, 100)],
      holdings: [{ accountId: 10, assetId: BTC.id, saldo: 1e8 }],
      accounts,
      toon: new Set([12, 99]),
    });
    assert.deepEqual(cards.map(c => c.accountId), [10, 12]);
    assert.equal(cards[1].value, null);
  });

  it('geeft een beheerd account zijn eigen deel, en de eigen accounts het eigen deel naar rato', () => {
    const k = kaart(BTC, 3e8, 100, 30);
    k.m.eigen = { net: 2e8, unrealized: 40 };
    k.m.beheerd = [{ accountId: 10, saldo: 1e8, unrealized: -10 }];
    const cards = accountCards({
      kaarten: [k],
      holdings: [{ accountId: 10, assetId: BTC.id, saldo: 1e8 }, { accountId: 11, assetId: BTC.id, saldo: 1.5e8 }],
      accounts,
    });
    const per = new Map(cards.map(c => [c.accountId, c]));
    assert.equal(rond(per.get(10).unrealized), -10, 'het beheerde account tegen zijn eigen kostprijs');
    assert.equal(rond(per.get(11).unrealized), 30, 'driekwart van het eigen deel van 40');
    assert.equal(rond(per.get(null).unrealized), 10, 'de rest zonder account: een kwart van het eigen deel');
    assert.equal(rond(cards.reduce((s, c) => s + c.unrealized, 0)), 30, 'samen weer de assetkaart');
  });

  it('negeert een saldo van een asset zonder kaart, zodat de som de pagina volgt', () => {
    const cards = accountCards({
      kaarten: [kaart(BTC, 1e8, 100)],
      holdings: [{ accountId: 10, assetId: BTC.id, saldo: 1e8 }, { accountId: 10, assetId: 77, saldo: 5 }],
      accounts,
    });
    assert.equal(cards.length, 1);
    assert.deepEqual(cards[0].assetIds, [BTC.id]);
  });
});