AtreidesAssetsFree/tests/server/db-fresh.test.mjs

// Generated, do not edit. sha256:819333deae77dc120b2355f624bcd66c41435cf53288c76e8c74c98bc181e6bc
import { describe, it, before, after, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import { DatabaseSync } from 'node:sqlite';
import { mkdtemp, rm, access } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

const DIR = await mkdtemp(join(tmpdir(), 'assetapp-fresh-test-'));
process.env.ASSETAPP_DATA_DIR = DIR;
process.env.ASSETAPP_DB_FILE = join(DIR, 'db.sqlite');

const { initDatabase, dbFile } = await import('../../server/db.js');
const DB_FILE = dbFile();
const { closeDatabase, run, one } = await import('../../server/db/conn.mjs');
const { startFreshDatabase, chooseSetupCurrency } = await import('../../server/db-fresh.mjs');
const { CONFIG } = await import('../../shared/config.js');

const bestaat = async p => { try { await access(p); return true; } catch { return false; } };
const aantal = tabel => one(`SELECT COUNT(*) AS n FROM ${tabel}`).n;

before(() => initDatabase());
after(async () => { closeDatabase(); await rm(DIR, { recursive: true, force: true }); });

beforeEach(async () => {
  closeDatabase();
  for (const b of ['', '-wal', '-shm', '.previous', '.previous-wal', '.previous-shm']) {
    await rm(DB_FILE + b, { force: true });
  }
  initDatabase();
  run(`INSERT INTO Account (name, searchName, kind, isOwnCustody, scanEnabled, isActive, closedAt)
       VALUES ('Kluis','kluis','vault',1,0,1,NULL)`);
  run(`INSERT INTO Label (name, searchName) VALUES ('merkteken','merkteken')`);
});

describe('startFreshDatabase', () => {
  it('laat een administratie achter zonder eigen gegevens', async () => {
    const r = await startFreshDatabase();
    assert.equal(r.versie, CONFIG.SCHEMA_VERSION);
    for (const tabel of ['Account', 'Event', 'Valuation', 'Label']) {
      assert.equal(aantal(tabel), 0, `${tabel} hoort leeg te zijn`);
    }
  });

  it('levert een VERSE en geen LEGE database: de seeds staan erin', async () => {
    await startFreshDatabase();
    assert.ok(aantal('Asset') > 0, 'assets');
    assert.ok(aantal('Provider') > 0, 'providers');
    assert.ok(aantal('DashboardProfile') > 0, 'dashboardprofiel');
    assert.equal(one(`SELECT version FROM Schema`).version, CONFIG.SCHEMA_VERSION);
    assert.equal(one(`SELECT baseCurrency FROM Portfolio`).baseCurrency, CONFIG.PORTFOLIO.DEFAULT_BASE_CURRENCY);
  });

  it('zet alleen fiat neer, geen crypto, geen metaal en geen metaalproducten', async () => {
    await startFreshDatabase();
    assert.equal(aantal('Asset'), one(`SELECT COUNT(*) AS n FROM Asset WHERE kind = 'fiat'`).n, 'alleen fiat');
    assert.equal(aantal('MetalProduct'), 0, 'geen metaalproducten');
  });

  it('houdt de rekenvaluta van de portefeuille, en valt niet terug op de standaard', async () => {
    closeDatabase();
    for (const b of ['', '-wal', '-shm']) await rm(DB_FILE + b, { force: true });
    initDatabase(DB_FILE, { baseCurrency: 'USD' });
    await startFreshDatabase();
    assert.equal(one(`SELECT baseCurrency FROM Portfolio`).baseCurrency, 'USD');
  });

  it('bewaart de oude administratie als .previous', async () => {
    const r = await startFreshDatabase();
    assert.ok(await bestaat(r.previous));
    const oud = new DatabaseSync(r.previous, { readOnly: true });
    assert.equal(oud.prepare(`SELECT name FROM Label LIMIT 1`).get().name, 'merkteken');
    assert.equal(oud.prepare(`SELECT COUNT(*) AS n FROM Account`).get().n, 1);
    oud.close();
  });

  it('laat een werkende verbinding achter', async () => {
    await startFreshDatabase();
    run(`INSERT INTO Label (name, searchName) VALUES ('erna','erna')`);
    assert.equal(aantal('Label'), 1, 'er is te schrijven én te lezen na de wissel');
  });

  it('zegt dat de geheimen NIET zijn weggegooid', async () => {
    const r = await startFreshDatabase();
    assert.match(r.geheimenWaarschuwing, /secrets\.json/);
    assert.match(r.geheimenWaarschuwing, /NIET weggegooid/);
  });
});

describe('chooseSetupCurrency', () => {
  const maagdelijk = async () => {
    closeDatabase();
    for (const b of ['', '-wal', '-shm', '.previous', '.previous-wal', '.previous-shm']) await rm(DB_FILE + b, { force: true });
    initDatabase();
  };
  const munt = () => one(`SELECT baseCurrency FROM Portfolio`).baseCurrency;

  it('zet een maagdelijke portefeuille in de gekozen munt', async () => {
    await maagdelijk();
    assert.deepEqual(await chooseSetupCurrency('USD'), { changed: true });
    assert.equal(munt(), 'USD');
  });

  it('weigert zodra er een account staat, en laat de administratie staan', async () => {
    await assert.rejects(() => chooseSetupCurrency('USD'), /holds nothing yet/);
    assert.equal(munt(), CONFIG.PORTFOLIO.DEFAULT_BASE_CURRENCY);
    assert.equal(aantal('Account'), 1);
    assert.equal(await bestaat(`${DB_FILE}.previous`), false, 'er is niets gewisseld');
  });

  it('weigert na afronden van het venster, ook op een lege portefeuille', async () => {
    await maagdelijk();
    run(`INSERT INTO Preference (scope, key, value) VALUES ('app','setup_done','1')
         ON CONFLICT (scope, key) DO UPDATE SET value = excluded.value`);
    await assert.rejects(() => chooseSetupCurrency('USD'), /holds nothing yet/);
    assert.equal(munt(), CONFIG.PORTFOLIO.DEFAULT_BASE_CURRENCY);
  });

  it('dezelfde munt wisselt niets, ook niet op een gevulde portefeuille', async () => {
    assert.deepEqual(await chooseSetupCurrency(CONFIG.PORTFOLIO.DEFAULT_BASE_CURRENCY), { changed: false });
    assert.equal(aantal('Account'), 1);
  });

  it('weigert een munt buiten de lijst', async () => {
    await maagdelijk();
    await assert.rejects(() => chooseSetupCurrency('XYZ'), /Unknown unit of account/);
    assert.equal(munt(), CONFIG.PORTFOLIO.DEFAULT_BASE_CURRENCY);
  });
});