// Generated, do not edit. sha256:ea3063d2dd3cc633da7f13f8cbd1705cc2b0b7e8797aeceebc91b788a0760522
import { describe, it, beforeEach, afterEach } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtemp, rm, readFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

import { credentialsStatus, setCredentials, clearCredentials, loadCredentials } from '../../server/auth.mjs';
import { writeActiveName } from '../../server/portfolios.mjs';
import { secretsFile, writeSecretsStore } from '../../server/keys.mjs';

let DIR;
let vorige;
let vorigeUser;
let vorigWachtwoord;

beforeEach(async () => {
  vorige = process.env.ASSETAPP_DATA_DIR;
  vorigeUser = process.env.ASSETAPP_USER;
  vorigWachtwoord = process.env.ASSETAPP_PASSWORD;
  delete process.env.ASSETAPP_USER;
  delete process.env.ASSETAPP_PASSWORD;
  DIR = await mkdtemp(join(tmpdir(), 'assetapp-auth-'));
  process.env.ASSETAPP_DATA_DIR = DIR;
  writeActiveName('Echt');
});

afterEach(async () => {
  if (vorige === undefined) delete process.env.ASSETAPP_DATA_DIR; else process.env.ASSETAPP_DATA_DIR = vorige;
  if (vorigeUser === undefined) delete process.env.ASSETAPP_USER; else process.env.ASSETAPP_USER = vorigeUser;
  if (vorigWachtwoord === undefined) delete process.env.ASSETAPP_PASSWORD;
  else process.env.ASSETAPP_PASSWORD = vorigWachtwoord;
  await rm(DIR, { recursive: true, force: true });
});

const store = async () => JSON.parse(await readFile(secretsFile(), 'utf-8'));

describe('credentialsStatus', () => {
  it('meldt "geen" als er niets staat', async () => {
    assert.deepEqual(await credentialsStatus(), { ingesteld: false, bron: 'geen', wijzigbaar: true });
  });

  it('geeft het wachtwoord NOOIT terug', async () => {
    await setCredentials('geheim');
    const status = await credentialsStatus();

    assert.equal(status.ingesteld, true);
    assert.equal(JSON.stringify(status).includes('geheim'), false, 'het wachtwoord staat in de status');
  });

  it('meldt de omgeving als bron, en dat het dan niet te wijzigen is', async () => {
    process.env.ASSETAPP_PASSWORD = 'ook';

    const status = await credentialsStatus();
    assert.equal(status.bron, 'omgeving');
    assert.equal(status.wijzigbaar, false);
  });

  it('ZET DE TOEGANGSCONTROLE AAN met alleen ASSETAPP_PASSWORD', async () => {
    process.env.ASSETAPP_PASSWORD = 'uit-de-omgeving';

    assert.equal((await credentialsStatus()).ingesteld, true);
    assert.deepEqual(await loadCredentials(), { password: 'uit-de-omgeving' });
  });

  it('negeert ASSETAPP_USER volledig', async () => {
    process.env.ASSETAPP_USER = 'harmen';

    assert.equal((await credentialsStatus()).ingesteld, false);
    assert.equal(await loadCredentials(), null);
  });

  it('telt een leeg wachtwoord in het bestand niet als slot', async () => {
    await writeSecretsStore({ assetapp_auth: { password: '' } });

    assert.equal((await credentialsStatus()).ingesteld, false);
    assert.equal(await loadCredentials(), null);
  });

  it('laat een BESTAANDE rij met een gebruikersnaam gewoon werken', async () => {
    await writeSecretsStore({ assetapp_auth: { user: 'harmen', password: 'van-vroeger' } });

    assert.equal((await credentialsStatus()).ingesteld, true);
    assert.deepEqual(await loadCredentials(), { password: 'van-vroeger' });
  });
});

describe('setCredentials', () => {
  it('zet het, en loadCredentials vindt het terug', async () => {
    const uit = await setCredentials('geheim');

    assert.equal(uit.ingesteld, true);
    assert.equal(uit.naHerstart, true, 'de UI hoort te melden dat het pas na een herstart geldt');
    assert.deepEqual(await loadCredentials(), { password: 'geheim' });
  });

  it('wijzigen is dezelfde handeling als aanmaken', async () => {
    await setCredentials('eerste');
    await setCredentials('tweede');

    assert.deepEqual(await loadCredentials(), { password: 'tweede' });
  });

  it('weigert een leeg wachtwoord in plaats van het te bewaren', async () => {
    await assert.rejects(() => setCredentials(''), (e) => e.key === 'portfolios.passwordRequired');
    await assert.rejects(() => setCredentials(null), (e) => e.key === 'portfolios.passwordRequired');
    await assert.rejects(() => setCredentials(undefined), (e) => e.key === 'portfolios.passwordRequired');

    assert.equal((await credentialsStatus()).ingesteld, false, 'en er is niets bewaard');
  });

  it('stelt GEEN eisen aan wat er wel in staat', async () => {
    for (const w of ['a', ' ', '1234', 'áé€', 'x'.repeat(500)]) {
      await setCredentials(w);
      assert.deepEqual(await loadCredentials(), { password: w });
    }
  });

  it('schrijft de rij ZONDER gebruikersnaam weg, ook als er een in stond', async () => {
    await writeSecretsStore({ assetapp_auth: { user: 'harmen', password: 'van-vroeger' } });

    await setCredentials('nieuw');

    assert.deepEqual((await store()).assetapp_auth, { password: 'nieuw' });
  });

  it('laat de andere sleutels in het geheimenbestand ongemoeid', async () => {
    await writeSecretsStore({ nwc_3: { uri: 'geheim' }, ai_handle_secret: 'a'.repeat(64) });

    await setCredentials('geheim');

    const s = await store();
    assert.equal(s.nwc_3.uri, 'geheim');
    assert.equal(s.ai_handle_secret, 'a'.repeat(64));
  });

  it('schrijft in het bestand van de ACTIEVE portefeuille', async () => {
    await setCredentials('geheim');
    writeActiveName('Demo');

    assert.equal((await credentialsStatus()).ingesteld, false, 'Demo heeft zijn eigen toegangscontrole');
    writeActiveName('Echt');
    assert.equal((await credentialsStatus()).ingesteld, true);
  });
});

describe('clearCredentials: de weg terug naar "alleen deze machine"', () => {
  it('haalt het weg', async () => {
    await setCredentials('geheim');

    const uit = await clearCredentials();

    assert.equal(uit.ingesteld, false);
    assert.equal(uit.naHerstart, true);
    assert.equal(await loadCredentials(), null);
  });

  it('doet niets als er niets stond, en meldt dat ook zo', async () => {
    const uit = await clearCredentials();

    assert.equal(uit.ingesteld, false);
    assert.equal(uit.naHerstart, false, 'er valt niets te herstarten voor een wijziging die er niet was');
  });

  it('laat de andere sleutels staan', async () => {
    await writeSecretsStore({ nwc_3: { uri: 'geheim' }, assetapp_auth: { password: 'w' } });

    await clearCredentials();

    const s = await store();
    assert.deepEqual(Object.keys(s), ['nwc_3']);
  });
});