boc/aamos-ledger/tests/validation.test.mjs

/**
 * ═══════════════════════════════════════════════════════════════════════════
 * AAMOS Ledger — Input Validation Tester
 * ═══════════════════════════════════════════════════════════════════════════
 */

import { describe, it } from 'node:test';
import assert from 'node:assert';
import { schemas, validate, sanitizeString, sanitizeMetadata } from '../validation.mjs';

describe('Account validation', () => {
  it('ska acceptera giltigt konto', () => {
    const result = schemas.createAccount.validate({
      account_number: '1910',
      name: 'Kassa',
      account_type: 'asset',
      normal_balance: 'debit',
    });
    assert.strictEqual(result.error, undefined);
  });

  it('ska neka ogiltigt account_type', () => {
    const result = schemas.createAccount.validate({
      account_number: '1910',
      name: 'Kassa',
      account_type: 'invalid',
      normal_balance: 'debit',
    });
    assert.ok(result.error);
  });

  it('ska neka numeriskt account_number', () => {
    const result = schemas.createAccount.validate({
      account_number: '19AB',
      name: 'Kassa',
      account_type: 'asset',
      normal_balance: 'debit',
    });
    assert.ok(result.error);
    assert.ok(result.error.details[0].message.includes('numeriskt'));
  });
});

describe('Journal entry validation', () => {
  it('ska acceptera giltig journalpost', () => {
    const result = schemas.createJournalEntry.validate({
      entry_date: '2026-06-25',
      description: 'Testverifikation',
      lines: [
        { account_number: '1910', debit: 1000 },
        { account_number: '3000', credit: 1000 },
      ],
    });
    assert.strictEqual(result.error, undefined);
  });

  it('ska neka obalanserad journalpost', () => {
    const result = schemas.createJournalEntry.validate({
      entry_date: '2026-06-25',
      description: 'Testverifikation',
      lines: [
        { account_number: '1910', debit: 1000 },
        { account_number: '3000', credit: 500 },
      ],
    });
    assert.ok(result.error);
    assert.ok(result.error.message.includes('Dubbelbokföring'));
  });

  it('ska neka rad med både debit och credit', () => {
    const result = schemas.createJournalEntry.validate({
      entry_date: '2026-06-25',
      description: 'Testverifikation',
      lines: [
        { account_number: '1910', debit: 1000, credit: 1000 },
        { account_number: '3000', credit: 1000 },
      ],
    });
    assert.ok(result.error);
  });

  it('ska neka rad utan debit eller credit', () => {
    const result = schemas.createJournalEntry.validate({
      entry_date: '2026-06-25',
      description: 'Testverifikation',
      lines: [
        { account_number: '1910' },
        { account_number: '3000', credit: 1000 },
      ],
    });
    assert.ok(result.error);
  });

  it('ska neka för få rader', () => {
    const result = schemas.createJournalEntry.validate({
      entry_date: '2026-06-25',
      description: 'Testverifikation',
      lines: [
        { account_number: '1910', debit: 1000 },
      ],
    });
    assert.ok(result.error);
    assert.ok(result.error.message.includes('Minst 2'));
  });

  it('ska nega ogiltigt datumformat', () => {
    const result = schemas.createJournalEntry.validate({
      entry_date: '25-06-2026',
      description: 'Testverifikation',
      lines: [
        { account_number: '1910', debit: 1000 },
        { account_number: '3000', credit: 1000 },
      ],
    });
    assert.ok(result.error);
  });
});

describe('Trial balance validation', () => {
  it('ska kräva fiscal_year', () => {
    const result = schemas.trialBalance.validate({});
    assert.ok(result.error);
    assert.ok(result.error.details[0].path.includes('fiscal_year'));
  });

  it('ska acceptera giltig query', () => {
    const result = schemas.trialBalance.validate({ fiscal_year: 2026, period: '2026-06' });
    assert.strictEqual(result.error, undefined);
  });
});

describe('Sanitizer', () => {
  it('ska rensa HTML-taggar', () => {
    const result = sanitizeString('<script>alert(1)</script>');
    assert.strictEqual(result, 'scriptalert(1)/script');
  });

  it('ska trunkera för långa strängar', () => {
    const long = 'a'.repeat(2000);
    const result = sanitizeString(long, 1000);
    assert.strictEqual(result.length, 1000);
  });

  it('ska rensa farliga nycklar i metadata', () => {
    const result = sanitizeMetadata({ normal: 'ok', __proto__: 'bad', constructor: 'bad' });
    assert.strictEqual(result.normal, 'ok');
    assert.strictEqual(Object.prototype.hasOwnProperty.call(result, '__proto__'), false);
    assert.strictEqual(Object.prototype.hasOwnProperty.call(result, 'constructor'), false);
  });
});

console.log('✅ Validation-tester klara');