AtreidesAssetsFree/tests/price/bron-diagnose.test.mjs

// Generated, do not edit. sha256:082ca8023bd277754ba77e02d92a8c8f7a15d0e14efa7674bf7905310f9ce692
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';

import { diagnoseSources } from '../../shared/source-diagnosis.js';

const GOUD = { id: 7, symbol: 'XAU', kind: 'metal' };
let id = 0;
const bron = (key, extra = {}) => ({
  id: ++id, key, name: key.toUpperCase(), isActive: 1, isSystem: 0, fixedRate: null, callsPerMonth: null,
  coverage: ['XAU'], endpoints: [{ capability: 'daily_history' }], ...extra,
});
const perDatum = { endpoints: [{ capability: 'history_point' }] };

describe('diagnoseSources: de keten van voor naar achter', () => {
  it('geen integratie die het symbool dekt', () => {
    const uit = diagnoseSources(GOUD, { providers: [bron('mempool', { coverage: ['BTC'] })] });
    assert.deepEqual(uit, [{ severity: 'problem', code: 'noCoverage' }]);
  });

  it('een systeembron of een vaste koers telt niet als dekking', () => {
    const uit = diagnoseSources(GOUD, { providers: [bron('manual', { isSystem: 1 }), bron('fixed', { fixedRate: { fiatPrice: 1 } })] });
    assert.equal(uit[0].code, 'noCoverage');
  });

  it('een integratie zonder historie-endpoint telt niet als dekking', () => {
    const uit = diagnoseSources(GOUD, { providers: [bron('alleenspot', { endpoints: [{ capability: 'spot' }] })] });
    assert.equal(uit[0].code, 'noCoverage');
  });

  it('dekking die uit staat noemt de namen', () => {
    const uit = diagnoseSources(GOUD, { providers: [bron('goldapi', { isActive: 0, ...perDatum })] });
    assert.deepEqual(uit, [{ severity: 'problem', code: 'allInactive', names: ['GOLDAPI'] }]);
  });

  it('geen bronkeuze geeft een voorstel voor Historie, en een reeks gaat voor een bron per datum', () => {
    const goldapi = bron('goldapi', perDatum);
    const eulerpool = bron('eulerpool');
    const [f] = diagnoseSources(GOUD, { providers: [goldapi, eulerpool], historyChain: [] });
    assert.equal(f.code, 'noChoice');
    assert.equal(f.severity, 'problem');
    assert.deepEqual(f.proposal, { providerKey: 'eulerpool', providerId: eulerpool.id, providerName: 'EULERPOOL', capability: 'history' });
  });

  it('een gekozen bron die uit staat is geen keuze, en het voorstel is de actieve', () => {
    const uit = bron('goldapi', { isActive: 0, ...perDatum });
    const aan = bron('eulerpool');
    const [f] = diagnoseSources(GOUD, { providers: [uit, aan], historyChain: ['goldapi'] });
    assert.equal(f.code, 'choiceUnusable');
    assert.deepEqual(f.names, ['GOLDAPI']);
    assert.equal(f.proposal.providerKey, 'eulerpool');
  });

  it('een gekozen bron die het symbool niet dekt, is ook geen keuze', () => {
    const mempool = bron('mempool', { coverage: ['BTC'] });
    const [f] = diagnoseSources(GOUD, { providers: [mempool, bron('eulerpool')], historyChain: ['mempool'] });
    assert.equal(f.code, 'choiceUnusable');
  });

  it('een gekozen bron zonder historie-endpoint is ook geen keuze', () => {
    const spot = bron('alleenspot', { endpoints: [{ capability: 'spot' }] });
    const [f] = diagnoseSources(GOUD, { providers: [spot, bron('eulerpool')], historyChain: ['alleenspot'] });
    assert.equal(f.code, 'choiceUnusable');
  });

  it('een keten die op orde is geeft niets, met een reeks of met een bron per datum', () => {
    assert.deepEqual(diagnoseSources(GOUD, { providers: [bron('eulerpool')], historyChain: ['eulerpool'] }), []);
    assert.deepEqual(diagnoseSources(GOUD, { providers: [bron('goldapi', perDatum)], historyChain: ['goldapi'] }), []);
  });
});

describe('diagnoseSources: de maandlimiet en een uitgezette keuze', () => {
  it('alle gekozen bronnen op hun limiet is een probleem', () => {
    const g = bron('goldapi', { callsPerMonth: 100, ...perDatum });
    const [f] = diagnoseSources(GOUD, { providers: [g], historyChain: ['goldapi'], usage: { [g.id]: 100 } });
    assert.deepEqual(f, { severity: 'problem', code: 'limitReached', names: ['GOLDAPI'] });
  });

  it('één van twee op de limiet is aandacht, want de keten valt door', () => {
    const g = bron('goldapi', { callsPerMonth: 100, ...perDatum });
    const e = bron('eulerpool');
    const [f] = diagnoseSources(GOUD, { providers: [g, e], historyChain: ['eulerpool', 'goldapi'], usage: { [g.id]: 120 } });
    assert.equal(f.severity, 'attention');
    assert.deepEqual(f.names, ['GOLDAPI']);
  });

  it('onder de limiet is niets, en een bron zonder limiet telt nooit', () => {
    const g = bron('goldapi', { callsPerMonth: 100, ...perDatum });
    const e = bron('eulerpool');
    const uit = diagnoseSources(GOUD, { providers: [g, e], historyChain: ['eulerpool', 'goldapi'], usage: { [g.id]: 99, [e.id]: 5000 } });
    assert.deepEqual(uit, []);
  });

  it('een gekozen bron die uit staat naast een werkende is aandacht', () => {
    const g = bron('goldapi', { isActive: 0, ...perDatum });
    const e = bron('eulerpool');
    const uit = diagnoseSources(GOUD, { providers: [g, e], historyChain: ['eulerpool', 'goldapi'] });
    assert.deepEqual(uit, [{ severity: 'attention', code: 'choiceInactive', names: ['GOLDAPI'] }]);
  });
});

describe('diagnoseSources: de dienst levert de historie', () => {
  const dienst = { serviceCovers: true };

  it('dekking die uit staat, geen dekking of geen keuze is dan geen melding', () => {
    assert.deepEqual(diagnoseSources(GOUD, { providers: [bron('goldapi', { isActive: 0, ...perDatum })], ...dienst }), []);
    assert.deepEqual(diagnoseSources(GOUD, { providers: [bron('mempool', { coverage: ['BTC'] })], ...dienst }), []);
    assert.deepEqual(diagnoseSources(GOUD, { providers: [bron('eulerpool')], historyChain: [], ...dienst }), []);
  });

  it('alle gekozen bronnen op hun limiet is dan aandacht en geen probleem', () => {
    const g = bron('goldapi', { callsPerMonth: 100, ...perDatum });
    const [f] = diagnoseSources(GOUD, { providers: [g], historyChain: ['goldapi'], usage: { [g.id]: 100 }, ...dienst });
    assert.equal(f.severity, 'attention');
  });

  it('zonder de dienst blijft het een probleem', () => {
    const uit = diagnoseSources(GOUD, { providers: [bron('goldapi', { isActive: 0, ...perDatum })], serviceCovers: false });
    assert.equal(uit[0].code, 'allInactive');
  });
});