Unit tests voor Apps Script schrijven

Teststrategieen voor Apps Script

Apps Script heeft geen ingebouwd testframework zoals Jest of PHPUnit. Je hebt grofweg drie opties:

1. Zelf schrijven: eenvoudige assert-functies in Apps Script.
2. Lichtgewicht library: een testframework dat speciaal voor Apps Script is gemaakt, zoals GasT, GASUnit of UnitTestingApp.
3. Jest via clasp: schrijf tests in TypeScript of JavaScript die lokaal op je eigen machine draaien.

Voor de meeste projecten zijn optie 1 of 2 het meest pragmatisch. Optie 3 loont zodra je veel pure businesslogica hebt die je los van de Google-services wilt testen.

Eigen testhelpers schrijven

Een handvol assert-functies is genoeg om serieus te kunnen testen. Plak deze in een apart bestand, bijvoorbeeld Test.gs.

function assert(conditie, bericht) {
  if (!conditie) {
    throw new Error(`TEST MISLUKT: ${bericht}`);
  }
}

function assertEqual(werkelijk, verwacht, bericht = '') {
  if (werkelijk !== verwacht) {
    throw new Error(`TEST MISLUKT ${bericht}: verwacht "${verwacht}", kreeg "${werkelijk}"`);
  }
}

function assertBevatSleutel(obj, sleutel, bericht = '') {
  if (!(sleutel in obj)) {
    throw new Error(`TEST MISLUKT ${bericht}: sleutel "${sleutel}" ontbreekt`);
  }
}

function assertGooit(fn, bericht = '') {
  try {
    fn();
    throw new Error(`TEST MISLUKT ${bericht}: verwachtte een fout, maar geen fout gegooid`);
  } catch (e) {
    if (e.message.startsWith('TEST MISLUKT')) throw e;
  }
}

Tests schrijven voor bedrijfslogica

De grootste winst zit in het testen van pure functies: berekeningen, validaties en transformaties zonder service-aanroepen.

function berekenKorting(bedrag, klantType) {
  if (bedrag <= 0) throw new Error('Bedrag moet positief zijn');
  switch (klantType) {
    case 'PREMIUM': return bedrag * 0.15;
    case 'STANDAARD': return bedrag * 0.05;
    case 'NIEUW': return 0;
    default: throw new Error(`Onbekend klanttype: ${klantType}`);
  }
}

function runBerekenKortingTests() {
  assertEqual(berekenKorting(100, 'PREMIUM'), 15, 'Premium 15%');
  assertEqual(berekenKorting(200, 'STANDAARD'), 10, 'Standaard 5%');
  assertEqual(berekenKorting(50, 'NIEUW'), 0, 'Nieuw geen korting');
  assertGooit(() => berekenKorting(-10, 'PREMIUM'), 'Negatief bedrag');
  assertGooit(() => berekenKorting(100, 'ONBEKEND'), 'Onbekend type');
  Logger.log('berekenKorting: alle tests geslaagd');
}

Testrunner met rapportage

Met een eenvoudige runner draai je alle suites in een keer en krijg je een overzichtelijk resultaat in het logboek.

function runAllTests() {
  const suites = [
    {naam: 'berekenKorting', fn: runBerekenKortingTests},
    {naam: 'formateerDatum', fn: runFormateerDatumTests},
    {naam: 'valideerEmail', fn: runValideerEmailTests},
  ];

  let geslaagd = 0;
  let mislukt = 0;
  const rapport = [];

  suites.forEach(suite => {
    try {
      suite.fn();
      geslaagd++;
      rapport.push(`GESLAAGD: ${suite.naam}`);
    } catch (e) {
      mislukt++;
      rapport.push(`MISLUKT: ${suite.naam} - ${e.message}`);
    }
  });

  rapport.forEach(r => Logger.log(r));
  Logger.log(`Resultaat: ${geslaagd}/${geslaagd + mislukt} geslaagd`);

  if (mislukt > 0) {
    throw new Error(`${mislukt} testsuites mislukt`);
  }
}

Mocking van services

Voor functies die GmailApp, SpreadsheetApp of een andere service aanroepen, geef je een nep-versie (mock) mee in plaats van de echte service. Zo test je het gedrag zonder echt e-mails te versturen.

let mockEmailVerzonden = false;
let mockEmailData = null;

const MockGmailApp = {
  sendEmail: (naar, onderwerp, body) => {
    mockEmailVerzonden = true;
    mockEmailData = {naar, onderwerp, body};
  },
};

function notificatieService(emailService, ontvanger, bericht) {
  if (!ontvanger || !bericht) {
    throw new Error('Ontvanger en bericht zijn verplicht');
  }
  emailService.sendEmail(ontvanger, 'Notificatie', bericht);
}

function runNotificatieTests() {
  mockEmailVerzonden = false;
  notificatieService(MockGmailApp, 'test@voorbeeld.nl', 'Test bericht');
  assert(mockEmailVerzonden, 'E-mail zou verstuurd moeten zijn');
  assertEqual(mockEmailData.naar, 'test@voorbeeld.nl', 'Ontvanger');

  assertGooit(
    () => notificatieService(MockGmailApp, '', 'bericht'),
    'Lege ontvanger'
  );

  Logger.log('notificatieService: alle tests geslaagd');
}

De truc is dat notificatieService de service als parameter ontvangt in plaats van GmailApp rechtstreeks aan te roepen. Die zogenoemde dependency injection maakt je code testbaar.

Integratietests voor Sheets

Soms wil je toch tegen de echte service testen, bijvoorbeeld om te controleren of data correct wordt weggeschreven. Ruim na afloop altijd op met een try/finally-blok.

function runSheetIntegratieTest() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  let testBlad = ss.getSheetByName('__TEST__');

  if (testBlad) ss.deleteSheet(testBlad);
  testBlad = ss.insertSheet('__TEST__');

  try {
    testBlad.getRange('A1:C3').setValues([
      ['Naam', 'Score', 'Actief'],
      ['Anna', 95, true],
      ['Bob', 72, false],
    ]);

    const data = testBlad.getDataRange().getValues();
    assertEqual(data.length, 3, 'Aantal rijen');
    assertEqual(data[1][0], 'Anna', 'Eerste naam');
    assertEqual(data[1][1], 95, 'Anna score');

    Logger.log('Sheet integratie: geslaagd');
  } finally {
    ss.deleteSheet(testBlad);
  }
}

Lokaal testen met clasp en Jest

Wil je pure logica buiten de editor testen, dan haal je je code met clasp naar je eigen machine. Clasp is de officiele command-line tool van Google en vereist Node.js v20 of nieuwer (stand juni 2026).

Voor service-interacties (SpreadsheetApp, GmailApp) blijft mocking of een integratietest in de editor nodig, omdat die services lokaal niet bestaan.

Test-driven development in de praktijk

Tests zijn de vangrail bij het wijzigen van Apps Script code. Zelfs eenvoudige assert-functies voorkomen regressies en geven vertrouwen wanneer je productiescripts aanpast.