AtreidesAssetsFree/tests/server/license.test.mjs

// Generated, do not edit. sha256:750cbb904d1f7cfd54fdb78681dde6a5150641198d16274559a18e9e1a72c8e2
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { createHash } from 'node:crypto';
import { schnorr } from '@noble/curves/secp256k1.js';
import { CONFIG } from '../../shared/config.js';
import {
  parseLicense, verifySignature, coversVersion, licenseMessage, readLicense,
} from '../../server/license.mjs';

const SELLER_PRIV = Buffer.from('1'.repeat(64), 'hex');
const SELLER_PUB = Buffer.from(schnorr.getPublicKey(SELLER_PRIV)).toString('hex');
const KOPER = 'a'.repeat(64);

const GELDIG = { buyer: KOPER, level: 'full', issued: '2026-09-19', majorFrom: 1, majorTo: 1 };

function onderteken(body, priv = SELLER_PRIV) {
  const hash = createHash('sha256').update(licenseMessage(body), 'utf-8').digest();
  return Buffer.from(schnorr.sign(hash, priv)).toString('hex');
}

function bestand(body, extra = {}) {
  return JSON.stringify({ format: CONFIG.LICENSE.FORMAT, license: body, signature: onderteken(body), ...extra });
}

describe('de vorm van het bestand', () => {
  it('leest een geldige licentie', () => {
    const p = parseLicense(bestand(GELDIG));
    assert.deepEqual(p.license, GELDIG);
  });

  it('weigert een ONTBREKEND veld in plaats van er een standaard voor te nemen', () => {
    for (const veld of ['buyer', 'level', 'issued', 'majorFrom', 'majorTo']) {
      const body = { ...GELDIG };
      delete body[veld];
      assert.throws(() => parseLicense(bestand(body)), new RegExp(veld), `${veld} mag niet weggelaten kunnen worden`);
    }
  });

  it('weigert een ONBEKEND veld, want dat kan een beperking zijn die deze versie nog niet kent', () => {
    assert.throws(() => parseLicense(bestand({ ...GELDIG, seats: 99 })), /unknown fields: seats/);
  });

  it('weigert een ander formaatnummer, en zegt welke het las', () => {
    assert.throws(() => parseLicense(JSON.stringify({ format: 3, license: GELDIG, signature: onderteken(GELDIG) })), /format 3/);
  });

  it('weigert rommel: geen JSON, geen object, geen handtekening van de juiste lengte', () => {
    assert.throws(() => parseLicense('geen json'), /not valid JSON/);
    assert.throws(() => parseLicense('[]'), /not an object/);
    assert.throws(() => parseLicense(JSON.stringify({ format: 1, license: GELDIG, signature: 'kort' })), /128 hex/);
  });

  it('weigert een koper-sleutel die geen 64 hex is, en een niveau buiten de lijst', () => {
    assert.throws(() => parseLicense(bestand({ ...GELDIG, buyer: 'npub1abc' })), /64 hex/);
    assert.throws(() => parseLicense(bestand({ ...GELDIG, level: 'super' })), /Unknown level/);
  });

  it('weigert een bereik dat achterstevoren staat of op 0 begint', () => {
    assert.throws(() => parseLicense(bestand({ ...GELDIG, majorFrom: 2, majorTo: 1 })), /majorTo/);
    assert.throws(() => parseLicense(bestand({ ...GELDIG, majorFrom: 0 })), /majorFrom/);
  });

  it('accepteert ONBEPERKT als expliciete waarde', () => {
    const eeuwig = { ...GELDIG, majorTo: CONFIG.LICENSE.UNLIMITED };
    assert.equal(parseLicense(bestand(eeuwig)).license.majorTo, 'unlimited');
  });
});

describe('de handtekening', () => {
  it('klopt bij de sleutel van de verkoper', () => {
    assert.equal(verifySignature(parseLicense(bestand(GELDIG)), SELLER_PUB), true);
  });

  it('valt om zodra er ÉÉN veld gewijzigd is, ook als dat veld er geldig uitziet', () => {
    const parsed = parseLicense(bestand(GELDIG));
    parsed.license.majorTo = CONFIG.LICENSE.UNLIMITED;
    assert.equal(verifySignature(parsed, SELLER_PUB), false);
  });

  it('valt om bij een handtekening van een ANDERE sleutel', () => {
    const vreemd = Buffer.from('2'.repeat(64), 'hex');
    const ruw = JSON.stringify({ format: 1, license: GELDIG, signature: onderteken(GELDIG, vreemd) });
    assert.equal(verifySignature(parseLicense(ruw), SELLER_PUB), false);
  });

  it('is ONGELDIG zonder verkopersleutel, en met een sleutel die geen sleutel is', () => {
    for (const sleutel of ['', 'geen sleutel', 'a'.repeat(63)]) {
      assert.equal(verifySignature(parseLicense(bestand(GELDIG)), sleutel), false, `sleutel ${JSON.stringify(sleutel)}`);
    }
  });

  it('geeft NEE en geen uitzondering bij een handtekening die geen punt op de curve is', () => {
    const ruw = JSON.stringify({ format: 1, license: GELDIG, signature: 'f'.repeat(128) });
    assert.equal(verifySignature(parseLicense(ruw), SELLER_PUB), false);
  });

  it('ondertekent niet over de kale waarden: het voorvoegsel zit in het bericht', () => {
    assert.ok(licenseMessage(GELDIG).startsWith(`${CONFIG.LICENSE.MESSAGE_PREFIX}\n`));
  });
});

describe('het versiebereik', () => {
  it('dekt de hoofdversie in het bereik en niets erbuiten', () => {
    assert.equal(coversVersion({ majorFrom: 1, majorTo: 1 }, '1.4.2'), true);
    assert.equal(coversVersion({ majorFrom: 1, majorTo: 1 }, '2.0.0'), false);
    assert.equal(coversVersion({ majorFrom: 2, majorTo: 3 }, '1.9.9'), false);
    assert.equal(coversVersion({ majorFrom: 2, majorTo: 3 }, '3.0.1'), true);
  });

  it('dekt ALLES vanaf de ondergrens bij een onbeperkt bereik', () => {
    const eeuwig = { majorFrom: 1, majorTo: CONFIG.LICENSE.UNLIMITED };
    assert.equal(coversVersion(eeuwig, '1.0.0'), true);
    assert.equal(coversVersion(eeuwig, '9.3.1'), true);
  });

  it('dekt NOOIT een 0.x-versie, want dat is develop', () => {
    assert.equal(coversVersion({ majorFrom: 1, majorTo: 1 }, '0.1.3'), false);
    assert.equal(coversVersion({ majorFrom: 1, majorTo: CONFIG.LICENSE.UNLIMITED }, '0.9.9'), false);
    assert.equal(coversVersion({ majorFrom: 0, majorTo: CONFIG.LICENSE.UNLIMITED }, '0.5.0'), false);
  });

  it('dekt niets bij een versie die niet de vorm x.y.z heeft', () => {
    assert.equal(coversVersion({ majorFrom: 1, majorTo: 1 }, 'v1.0.0'), false);
    assert.equal(coversVersion({ majorFrom: 1, majorTo: 1 }, undefined), false);
  });

  it('EEN ONTBREKENDE BOVENGRENS IS NIET EEUWIG', () => {
    assert.equal(coversVersion({ majorFrom: 1 }, '1.0.0'), false);
    const body = { ...GELDIG };
    delete body.majorTo;
    assert.throws(() => parseLicense(bestand(body)), /majorTo/);
  });
});

describe('het bestand op schijf', () => {
  it('meldt GEEN licentie als er geen bestand is, en dat is geen fout', () => {
    const map = mkdtempSync(join(tmpdir(), 'lic-'));
    try {
      assert.deepEqual(readLicense(map), { state: 'none' });
    } finally {
      rmSync(map, { recursive: true, force: true });
    }
  });

  it('meldt ONGELDIG met een reden bij een kapot bestand, en crasht niet', () => {
    const map = mkdtempSync(join(tmpdir(), 'lic-'));
    try {
      writeFileSync(join(map, CONFIG.LICENSE.FILE_NAME), '{ half');
      const uitkomst = readLicense(map);
      assert.equal(uitkomst.state, 'invalid');
      assert.match(uitkomst.reason, /JSON/);
    } finally {
      rmSync(map, { recursive: true, force: true });
    }
  });

  it('meldt ONGELDIG bij een nette licentie zolang er geen verkopersleutel is', () => {
    const map = mkdtempSync(join(tmpdir(), 'lic-'));
    try {
      writeFileSync(join(map, CONFIG.LICENSE.FILE_NAME), bestand(GELDIG));
      assert.equal(readLicense(map).state, 'invalid');
    } finally {
      rmSync(map, { recursive: true, force: true });
    }
  });
});