Inleiding tot testen op basis van onroerend goed met behulp van een voorbeeld van geldoverdracht 🏦💰

Heb je je ooit afgevraagd hoe banken ervoor zorgen dat wanneer je geld overmaakt, het juiste bedrag altijd op de juiste rekening terechtkomt? Een van de manieren waarop ze dit doen, is door gebruik te maken van iets dat „Property-Based Testing” wordt genoemd.

Stel je in dit scenario twee banken voor, Bank A en Bank B. We testen een systeem waarbij mensen geld kunnen overboeken van bank A naar bank B, en we willen ervoor zorgen dat het totale geldbedrag in beide banken hetzelfde blijft, zelfs als er iets misgaat tijdens de overboeking!

Zo werkt Property-Based Testing in dit voorbeeld:

Eigenschappen definiëren: We beginnen met het definiëren van enkele regels (eigenschappen) die altijd waar moeten zijn. Voor onze banken zijn de eigendommen:
Consistentie: de totale hoeveelheid geld in beide banken moet gelijk blijven.
Geen geldverlies: het geld moet in bank A blijven of worden overgemaakt naar bank B.
Testcases genereren: In plaats van specifieke scenario’s te schrijven, laten we de computer willekeurige testcases voor ons genereren. In ons voorbeeld bepaalt het willekeurig hoeveel geld moet worden overgemaakt.
Eigenschappen controleren: Voor elke testcase controleren we of onze eigenschappen kloppen. In ons voorbeeld simuleren we het overboeken van geld en controleren we of het totaalbedrag consistent blijft en er geen geld verloren gaat.
Fouten melden: Als we een scenario vinden waarin de eigenschappen niet kloppen, mislukt de test en weten we dat er een probleem is in ons systeem!

Door deze methode te gebruiken, kunnen we ons geldoverdrachtsysteem testen met een breed scala aan scenario’s, zodat we er zeker van zijn dat het correct werkt, zelfs als dingen niet volgens plan verlopen!

Een geldoverdrachtsysteem testen 🏦💰

Stel je voor dat je twee banken hebt, Bank A en Bank B. Je test een systeem waarbij mensen geld kunnen overboeken van bank A naar bank B.

De code 🧑‍💻

const fc = require('fast-check');

const initialAmountA = 1000;
const initialAmountB = 1000;

fc.assert(
 fc.property(fc.integer(1, 1000), async (transactionAmount) => {
   let amountA = initialAmountA;
   let amountB = initialAmountB;

   amountA -= transactionAmount;
   if (Math.random() < 0.9) {
     amountB += transactionAmount;
   }

   const totalAmount = amountA + amountB;
   const initialTotalAmount = initialAmountA + initialAmountB;
   if (totalAmount !== initialTotalAmount) {
     throw new Error('Consistency property violated');
   }

   if (amountB === initialAmountB && amountA !== initialAmountA - transactionAmount) {
     throw new Error('No Money Loss property violated');
   }
 })
);

Het opsplitsen 🧐

Wat zijn we aan het doen?

We testen of het geldoverdrachtsysteem correct werkt, zelfs als sommige transacties mislukken.

Hoe werkt de code?

Instellen:

InitialAmounta en InitialAmountB: Dit zijn de startbedragen in beide banken.

Testen:

fc.assert: Deze functie controleert of onze test (de dingen waarvan we zeker willen zijn dat ze correct werken) slaagt of mislukt.
fc.property: Dit is onze test! Het wordt meerdere keren uitgevoerd met verschillende transactiebedragen.

Transacties simuleren:

AmountA -= TransactieBedrag: We nemen het overboekingsbedrag van Bank A af.
if (Math.random () < 0.9): We draaien een virtuele munt om om te beslissen of Bank B het geld krijgt (90% kans dat dit het geval is).

De regels controleren (eigenschappen):

Consistentie: we controleren of het totale bedrag nog steeds hetzelfde is.
Geen geldverlies: we controleren of het geld nog in bank A staat of bank B heeft bereikt.