// Generated, do not edit. sha256:343dcdbc15ae356dbb8783f015151f9b7adeb88cf1b2d498ee256dd978f6bd8e
import { describe, it, beforeEach, mock } from 'node:test';
import assert from 'node:assert/strict';

const opslag = new Map();
const sleutel = (scope, key) => `${scope}::${key}`;
mock.module('../../client/data/_rpc.js', {
  namedExports: {
    async rpc(module, functie, ...args) {
      if (module !== 'preferences') throw new Error(`onverwachte module in deze test: ${module}`);
      if (functie === 'getPref') {
        const [scope, key, fallback] = args;
        return opslag.has(sleutel(scope, key)) ? opslag.get(sleutel(scope, key)) : fallback;
      }
      if (functie === 'setPref') {
        const [scope, key, waarde] = args;
        opslag.set(sleutel(scope, key), waarde);
        return null;
      }
      throw new Error(`onverwachte functie in deze test: ${functie}`);
    },
    decodeer: v => v,
    setRowGuard() {},
    rowGuardAan: () => false,
  },
});

const { tableViewCfg } = await import('../../client/data/preferences.js');

beforeEach(() => opslag.clear());

describe('tableViewCfg', () => {
  it('geeft de meegegeven standaardsortering als er nog niets bewaard is', async () => {
    const cfg = await tableViewCfg('trades', { key: 'occurredAt', dir: 'desc' });
    assert.deepEqual(cfg.sort, { key: 'occurredAt', dir: 'desc' });
    assert.equal(cfg.group, null);
    assert.deepEqual(cfg.groupFilter, {});
    assert.deepEqual(cfg.groupCollapsed, {});
  });

  it('vult de nieuwere sleutels aan die een oudere bewaarde stand nog niet had', async () => {
    opslag.set(sleutel('table.trades', 'view'),
      { sort: { key: 'amount', dir: 'asc' }, group: 'kind', groupFilter: { kind: ['buy'] } });

    const cfg = await tableViewCfg('trades', { key: 'occurredAt', dir: 'desc' });
    assert.deepEqual(cfg.sort, { key: 'amount', dir: 'asc' }, 'de bewaarde sortering wint');
    assert.equal(cfg.group, 'kind');
    assert.deepEqual(cfg.groupFilter, { kind: ['buy'] });
    assert.deepEqual(cfg.groupCollapsed, {}, 'de ontbrekende sleutel wordt aangevuld');
    assert.equal(cfg.group2, null);
    assert.equal(cfg.group3, null);
  });

  it('geeft de standaardsortering MEE, ook als er een bewaarde stand is', async () => {
    opslag.set(sleutel('table.trades', 'view'), { sort: { key: 'weg', dir: 'asc' }, group: null });
    const cfg = await tableViewCfg('trades', { key: 'occurredAt', dir: 'desc' });
    assert.deepEqual(cfg.defaultSort, { key: 'occurredAt', dir: 'desc' });
  });

  it('schrijft een wijziging terug via onStateChange', async () => {
    const cfg = await tableViewCfg('trades', null);
    await cfg.onStateChange({ sort: null, group: 'kind', group2: null, group3: null, groupFilter: {}, groupCollapsed: { kind: ['buy'] } });
    assert.deepEqual(opslag.get(sleutel('table.trades', 'view')).groupCollapsed, { kind: ['buy'] });
  });

  it('negeert met een vaste groepering de bewaarde stand en schrijft niets terug', async () => {
    opslag.set(sleutel('table.trades', 'view'),
      { sort: { key: 'amount', dir: 'asc' }, group: 'kind', groupFilter: { kind: ['buy'] } });
    opslag.set(sleutel('table.trades', 'sticky'), { loc: 3 });
    const cfg = await tableViewCfg('trades', { key: 'occurredAt', dir: 'desc' }, 'assetId');
    assert.deepEqual(cfg.sort, { key: 'occurredAt', dir: 'desc' }, 'de standaard, niet de bewaarde');
    assert.equal(cfg.group, 'assetId');
    assert.equal(cfg.groupChoice, false);
    assert.equal(cfg.groupFilter, undefined, 'geen bewaard filter');
    assert.equal(cfg.onStateChange, undefined, 'er wordt niets teruggeschreven');
    assert.deepEqual(cfg.sticky, { loc: 3 }, 'de laatst gebruikte waarden van een nieuwe regel blijven');
  });

  it('laat een mislukte schrijfactie de tabel niet breken', async () => {
    const cfg = await tableViewCfg('trades', null);
    const stuk = { get sort() { throw new Error('kapot'); } };
    await assert.doesNotReject(() => Promise.resolve(cfg.onStateChange(stuk)));
  });
});