sysop/AtreidesAssetsFree
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
AtreidesAssetsFree/tests/price/dienst-spot.test.mjs
T
Atreides Assets e77d8fd373 Versie 0.2.0
2026-10-29 11:57:29 +01:00

374 lines
17 KiB
JavaScript
Raw Permalink Blame History

// Generated, do not edit. sha256:be43673f9f978564f187426b8db28e08c641acba85e6d36a4aabd536adf07ca5
import { describe, it, beforeEach, mock } from 'node:test';
import assert from 'node:assert/strict';
import { createDbHarness } from '../helpers/db-node.mjs';
import { CONFIG } from '../../shared/config.js';
const harness = createDbHarness();
mock.module('../../server/db.js', { namedExports: harness.exports });
for (const mod of ['providers', 'price-source', 'price-history', 'api-metrics', 'preferences', 'assets']) {
mock.module(`../../client/data/${mod}.js`, { namedExports: await import(`../../server/data/${mod}.js`) });
}
let STAND = 'off';
mock.module('../../client/app-settings.js', {
namedExports: { appSetting: (k) => (k === 'market_spot' ? STAND : 1), baseCurrency: () => 'EUR' },
});
let DIENST = null;
let dienstVragen = 0;
let DAGEN = { status: 'notCovered' };
let dagVragen = [];
let DEKKING = { status: 'off' };
mock.module('../../client/data/market.js', {
namedExports: {
serviceSpot: async () => { dienstVragen++; return DIENST; },
intradaySeries: async () => ({ status: 'off' }),
serviceDayHistory: async (assetId, since) => { dagVragen.push({ assetId, since }); return DAGEN; },
serviceCoverage: async () => DEKKING,
},
});
const facade = await import('../../client/price/providers.js');
let bronVragen = 0;
let bronWeg = false;
globalThis.fetch = async () => {
bronVragen++;
if (bronWeg) throw new Error('bron weg');
return { ok: true, status: 200, json: async () => ({ price: 100 }) };
};
const { run, lastId, one } = harness.exports;
let btc;
function systeemProvider(key, name) {
run(`INSERT INTO Provider (key, name, searchName, baseUrl, authenticationKind, authenticationRequired, isActive, isSeed, isSystem, createdAt)
VALUES (?, ?, ?, '', 'none', 0, 1, 1, 1, '2026-10-09')`, [key, name, name.toLowerCase()]);
return lastId();
}
function eigenBron({ key = 'bron', name = 'Eigen bron', rank = 1, status = 'confirmed' } = {}) {
run(`INSERT INTO Provider (key, name, searchName, baseUrl, authenticationKind, authenticationRequired, isActive, isSeed, isSystem, createdAt)
VALUES (?, ?, ?, 'https://voorbeeld.test', 'none', 0, 1, 1, 0, '2026-10-09')`, [key, name, name.toLowerCase()]);
const id = lastId();
run(`INSERT INTO ProviderCoverage (providerId, symbol) VALUES (?, 'BTC')`, [id]);
run(`INSERT INTO ProviderEndpoint (providerId, capability, method, pathTemplate, queryTemplate) VALUES (?, 'spot', 'GET', '/p', NULL)`, [id]);
run(`INSERT INTO PriceSource (assetId, capability, providerId, rank, status) VALUES (?, 'spot', ?, ?, ?)`, [btc, id, rank, status]);
}
const asset = () => one(`SELECT * FROM Asset WHERE id = ?`, [btc]);
const ok = (price, currency = 'EUR') => ({ status: 'ok', instrument: 'crypto:BTC', price, currency, observedAt: 1, source: 'bitvavo', sourceLabel: 'Bitvavo' });
const gecached = () => one(`SELECT fiatPrice FROM PriceHistory JOIN Provider ON Provider.id = PriceHistory.providerId
WHERE Provider.key = 'atreides_services' AND assetId = ?`, [btc]);
beforeEach(() => {
harness.recreate();
facade.clearSpotCache();
STAND = 'off';
DIENST = ok(61000);
dienstVragen = 0;
DAGEN = { status: 'notCovered' };
dagVragen = [];
DEKKING = { status: 'off' };
facade.forgetSeriesFetches();
bronVragen = 0;
bronWeg = false;
systeemProvider('atreides_services', 'Atreides Services');
run(`INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
VALUES ('BTC','Bitcoin','bitcoin','crypto','BTC','sat',8,'unit')`);
btc = lastId();
});
describe('de stand van market_spot', () => {
it('uit: de dienst wordt NIET gevraagd, ook als de eigen keten niets geeft', async () => {
assert.equal(await facade.liveSpotFor(asset()), null);
assert.equal(dienstVragen, 0);
});
it('als terugval: een werkende eigen bron gaat voor en de dienst wordt niet gevraagd', async () => {
STAND = 'fallback';
eigenBron();
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 100 });
assert.equal(dienstVragen, 0);
assert.equal(facade.lastSpotSource(asset()), 'Eigen bron');
});
it('als terugval: zonder eigen bron levert de dienst, en die koers komt in de cache', async () => {
STAND = 'fallback';
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 61000 });
assert.equal(facade.lastSpotSource(asset()), 'Atreides Services (Bitvavo)');
assert.equal(gecached().fiatPrice, 61000);
});
it('eerst: de dienst gaat vóór een bron die de APP zette', async () => {
STAND = 'first';
eigenBron();
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 61000 });
assert.equal(bronVragen, 0, 'de automatische bron wordt dan niet gevraagd');
});
it('eerst: een bron die de GEBRUIKER koos gaat vóór de dienst', async () => {
STAND = 'first';
eigenBron({ status: 'manual' });
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 100 });
assert.equal(dienstVragen, 0);
});
it('eerst: zelf gekozen bron weg, dan de dienst, en pas daarna de bron van de app', async () => {
STAND = 'first';
eigenBron({ key: 'zelf', name: 'Zelf', rank: 1, status: 'manual' });
eigenBron({ key: 'app', name: 'App', rank: 2, status: 'confirmed' });
bronWeg = true;
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 61000 });
assert.equal(bronVragen, 1, 'alleen de zelf gekozen bron is geprobeerd, de bron van de app niet');
});
it('eerst, dienst weg: na de zelf gekozen bron komt de bron van de app aan de beurt', async () => {
STAND = 'first';
eigenBron({ key: 'app', name: 'App', status: 'confirmed' });
DIENST = { status: 'unavailable', retryLater: true, key: 'marketService.unreachable', params: {} };
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 100 });
assert.equal(facade.lastSpotSource(asset()), 'App');
});
});
describe('een dienst die even weg is', () => {
it('eerst, dienst weg: de eigen bron neemt het over', async () => {
STAND = 'first';
eigenBron();
DIENST = { status: 'unavailable', retryLater: true, key: 'marketService.unreachable', params: {} };
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 100 });
});
it('dienst weg en geen eigen bron: de laatst bekende koers uit de cache, en die zegt dat', async () => {
STAND = 'first';
await facade.liveSpotFor(asset());
facade.clearSpotCache();
DIENST = { status: 'unavailable', retryLater: true, key: 'marketService.unreachable', params: {} };
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 61000 });
assert.match(facade.lastSpotSource(asset()), /laatst bekend/);
});
it('een gat (missing) leest niet uit de cache: dan is er echt geen koers', async () => {
STAND = 'first';
await facade.liveSpotFor(asset());
facade.clearSpotCache();
DIENST = { status: 'missing' };
assert.equal(await facade.liveSpotFor(asset()), null);
});
it('eigen bron weg en dienst weg: eerst de eigen bron geprobeerd, dan de cache', async () => {
STAND = 'fallback';
eigenBron();
bronWeg = true;
DIENST = ok(61000);
await facade.liveSpotFor(asset());
facade.clearSpotCache();
DIENST = { status: 'unavailable', retryLater: true, key: 'marketService.unreachable', params: {} };
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 61000 });
assert.ok(bronVragen >= 2, 'de eigen bron kreeg zijn beurt');
});
});
describe('het statuslampje bij de dienst', () => {
const metDocument = async (fn) => {
const events = [];
globalThis.document = { dispatchEvent: e => { events.push(e.detail); return true; } };
try { await fn(); } finally { delete globalThis.document; }
return events.filter(d => d.provider_key === 'atreides_services');
};
it('licht op bij een spot uit de dienst, met het symbool', async () => {
STAND = 'first';
const events = await metDocument(() => facade.liveSpotFor(asset()));
assert.equal(events.length, 1);
assert.deepEqual([events[0].ok, events[0].symbol, events[0].capability], [true, 'BTC', 'spot']);
});
it('kleurt rood als de dienst weg is, en zegt niets in de stand uit', async () => {
STAND = 'first';
DIENST = { status: 'unavailable', retryLater: true };
const weg = await metDocument(() => facade.liveSpotFor(asset()));
assert.equal(weg[0]?.ok, false);
facade.clearSpotCache();
STAND = 'off';
assert.deepEqual(await metDocument(() => facade.liveSpotFor(asset())), []);
});
it('licht ook op bij dagkoersen uit de dienst', async () => {
STAND = 'first';
DAGEN = { status: 'ok', instrument: 'crypto:BTC', currency: 'EUR', source: 'eulerpool', days: [[Date.now() - 2 * 86_400_000, 60000]] };
const events = await metDocument(() => facade.ensurePriceHistoryFor(asset()));
assert.equal(events.some(d => d.capability === 'daily_history' && d.ok), true);
});
});
describe('de munt van de bron', () => {
it('rekent om naar de rekenvaluta met de koers die elke spot krijgt', async () => {
STAND = 'first';
run(`INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
VALUES ('USD','Dollar','dollar','fiat','USD','cent',2,'unit')`);
const usd = lastId();
const vast = systeemProvider('fixed', 'Vaste koers');
const vandaag = new Date().toISOString().slice(0, 10);
run(`INSERT INTO PriceHistory (assetId, providerId, fiatPrice, resolution, observedAt) VALUES (?, ?, 0.8, 'day', ?)`,
[usd, vast, `${vandaag}T00:00:00Z`]);
DIENST = ok(70000, 'USD');
assert.deepEqual(await facade.liveSpotFor(asset()), { price: 56000 });
});
it('zonder wisselkoers geen koers, in plaats van dollars als euro\'s', async () => {
STAND = 'first';
DIENST = ok(70000, 'USD');
assert.equal(await facade.liveSpotFor(asset()), null);
});
});
describe('dagkoersen uit de dienst', () => {
const DAG = 86_400_000;
const vandaag = () => Date.parse(`${new Date().toISOString().slice(0, 10)}T00:00:00Z`);
const dagen = (...prijzen) => ({ status: 'ok', instrument: 'crypto:BTC', currency: 'EUR', source: 'eulerpool',
days: prijzen.map(([terug, p]) => [vandaag() - terug * DAG, p]) });
const opgeslagen = () => harness.exports.all(`SELECT substr(observedAt, 1, 10) AS dag, fiatPrice FROM PriceHistory
JOIN Provider ON Provider.id = PriceHistory.providerId
WHERE Provider.key = 'atreides_services' AND assetId = ? AND resolution = 'day' ORDER BY observedAt`, [btc]);
const dagVan = (terug) => new Date(vandaag() - terug * DAG).toISOString().slice(0, 10);
it('uit: de dienst wordt niet gevraagd', async () => {
DAGEN = dagen([1, 60000]);
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 0);
});
it('eerst: de dagen van de dienst komen in de cache, en één keer per dag', async () => {
STAND = 'first';
DAGEN = dagen([2, 59000], [1, 60000]);
await facade.ensurePriceHistoryFor(asset());
assert.deepEqual(opgeslagen(), [{ dag: dagVan(2), fiatPrice: 59000 }, { dag: dagVan(1), fiatPrice: 60000 }]);
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 1, 'twee keer gevraagd op één dag');
});
it('vraagt vanaf de dag na de nieuwste afgesloten dag, en niets als gisteren er al is', async () => {
STAND = 'first';
const vast = systeemProvider('fixed', 'Vaste koers');
run(`INSERT INTO PriceHistory (assetId, providerId, fiatPrice, resolution, observedAt) VALUES (?, ?, 1, 'day', ?)`,
[btc, vast, `${dagVan(5)}T00:00:00Z`]);
run(`INSERT INTO PriceHistory (assetId, providerId, fiatPrice, resolution, observedAt) VALUES (?, ?, 1, 'day', ?)`,
[btc, vast, `${dagVan(0)}T00:00:00Z`]);
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen[0].since, vandaag() - 4 * DAG);
facade.forgetSeriesFetches();
run(`INSERT INTO PriceHistory (assetId, providerId, fiatPrice, resolution, observedAt) VALUES (?, ?, 1, 'day', ?)`,
[btc, vast, `${dagVan(1)}T00:00:00Z`]);
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 1);
});
it('rekent elke dag om met de koers van DIE dag, en laat een dag zonder koers weg', async () => {
STAND = 'first';
run(`INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
VALUES ('USD','Dollar','dollar','fiat','USD','cent',2,'unit')`);
const usd = lastId();
const vast = systeemProvider('fixed', 'Vaste koers');
run(`INSERT INTO PriceHistory (assetId, providerId, fiatPrice, resolution, observedAt) VALUES (?, ?, 0.9, 'day', ?)`,
[usd, vast, `${dagVan(20)}T00:00:00Z`]);
run(`INSERT INTO PriceHistory (assetId, providerId, fiatPrice, resolution, observedAt) VALUES (?, ?, 0.8, 'day', ?)`,
[usd, vast, `${dagVan(2)}T00:00:00Z`]);
DAGEN = { ...dagen([30, 1000], [12, 1000], [1, 1000]), currency: 'USD' };
await facade.ensurePriceHistoryFor(asset());
assert.deepEqual(opgeslagen(), [{ dag: dagVan(1), fiatPrice: 800 }]);
});
it('eerst: een reeksbron die de gebruiker zelf koos gaat voor, en de dienst wordt niet gevraagd', async () => {
STAND = 'first';
run(`INSERT INTO Provider (key, name, searchName, baseUrl, authenticationKind, authenticationRequired, isActive, isSeed, isSystem, createdAt)
VALUES ('zelf', 'Zelf', 'zelf', 'https://voorbeeld.test', 'none', 0, 1, 1, 0, '2026-10-09')`);
const id = lastId();
run(`INSERT INTO ProviderCoverage (providerId, symbol) VALUES (?, 'BTC')`, [id]);
run(`INSERT INTO ProviderEndpoint (providerId, capability, method, pathTemplate, queryTemplate) VALUES (?, 'daily_history', 'GET', '/d', NULL)`, [id]);
run(`INSERT INTO PriceSource (assetId, capability, providerId, rank, status) VALUES (?, 'history', ?, 1, 'manual')`, [btc, id]);
DAGEN = dagen([1, 60000]);
try { await facade.ensurePriceHistoryFor(asset()); } catch { }
assert.equal(dagVragen.length, 0);
});
it('Gaten opvullen: de dienst vult het gat, alleen binnen het gat, en niets in stand uit', async () => {
DAGEN = dagen([12, 100], [10, 101], [9, 102], [3, 103]);
const uit = await facade.fillClosesFor(asset(), dagVan(11), dagVan(9));
assert.equal(dagVragen.length, 0, 'stand uit vroeg de dienst');
assert.equal(uit.written, 0);
STAND = 'fallback';
const met = await facade.fillClosesFor(asset(), dagVan(11), dagVan(9));
assert.equal(met.written, 2);
assert.deepEqual(opgeslagen(), [{ dag: dagVan(10), fiatPrice: 101 }, { dag: dagVan(9), fiatPrice: 102 }]);
});
it('een weigering wordt onthouden: een tweede omrekening vraagt de dienst niet opnieuw', async () => {
STAND = 'first';
DAGEN = { status: 'unavailable', retryLater: false, key: 'marketService.rejected', params: { status: 404, key: 'api.noSeries' } };
await facade.ensurePriceHistoryFor(asset());
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 1, 'de weigering is opnieuw gevraagd');
facade.forgetSeriesFetches();
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 2);
});
it('later opnieuw: pas na een korte pauze, niet bij elke weergave', async () => {
STAND = 'first';
DAGEN = { status: 'unavailable', retryLater: true, key: 'marketService.unreachable', params: {} };
await facade.ensurePriceHistoryFor(asset());
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 1, 'binnen de pauze opnieuw gevraagd');
const echt = Date.now;
Date.now = () => echt() + CONFIG.MARKET_SERVICE.RETRY_PAUSE_MS + 1;
try { await facade.ensurePriceHistoryFor(asset()); } finally { Date.now = echt; }
assert.equal(dagVragen.length, 2, 'na de pauze niet opnieuw gevraagd');
});
it('als terugval: een werkende eigen bron gaat voor; zonder eigen bron de dienst', async () => {
STAND = 'fallback';
eigenBron();
DAGEN = dagen([1, 60000]);
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 0);
harness.exports.run(`DELETE FROM PriceSource`);
harness.exports.run(`DELETE FROM PriceHistory`);
facade.forgetSeriesFetches();
await facade.ensurePriceHistoryFor(asset());
assert.equal(dagVragen.length, 1);
assert.equal(opgeslagen().length, 1);
});
});
describe('rateSourceFor: de dienst als wisselkoersbron', () => {
const dollar = () => { run(`INSERT INTO Asset (symbol, name, searchName, kind, unit, subunit, decimals, displayUnit)
VALUES ('USD','Dollar','dollar','fiat','USD','cent',2,'unit')`); return lastId(); };
it('telt mee als de stand niet uit staat en de dienst de munt dekt', async () => {
const usd = dollar();
DEKKING = { status: 'ok', assetIds: [usd] };
for (const stand of ['first', 'fallback']) {
STAND = stand;
assert.equal((await facade.rateSourceFor('USD'))?.key, 'atreides_services', stand);
}
});
it('telt niet mee in de stand uit, voor een munt die hij niet dekt, of als hij weg is', async () => {
const usd = dollar();
DEKKING = { status: 'ok', assetIds: [usd] };
assert.equal(await facade.rateSourceFor('USD'), null, 'stand uit');
STAND = 'first';
DEKKING = { status: 'ok', assetIds: [btc] };
assert.equal(await facade.rateSourceFor('USD'), null, 'niet gedekt');
DEKKING = { status: 'unavailable' };
assert.equal(await facade.rateSourceFor('USD'), null, 'onbereikbaar');
});
});
Reference in new issue View Git Blame Copy Permalink