Natuurlijk! Hier is een overzicht van de verschillende test doubles en hoe je ze kunt toepassen in jouw scenario met de functie `sendEmail(recipient)`. 1. Dummy **Wanneer gebruiken:** Wanneer je een parameter of afhankelijkheid nodig hebt om de test uit te voeren, maar deze niet daadwerkelijk gebruikt wordt in de test. **Waarom:** Om te voldoen aan de vereiste parameters zonder dat ze relevant zijn voor de test. **Voorbeeld:** ```javascript const dummyRecipient = null; // of een lege string sendEmail(dummyRecipient); ``` 2. Stub **Wanneer gebruiken:** Wanneer je de afhankelijkheid (bijvoorbeeld een e-mailservice) wilt simuleren met vaste data, zodat je de functionaliteit kunt testen zonder echte acties uit te voeren. **Waarom:** Om gecontroleerde, voorspelbare resultaten te krijgen zonder afhankelijk te zijn van externe systemen. **Voorbeeld:** Je hebt misschien een `EmailService` die je wilt simuleren: ```javascript const emailServiceStub = { send: (recipient) => { // Simuleer succesvolle verzending return true; } }; function sendEmail(recipient) { emailServiceStub.send(recipient); } sendEmail('test@example.com'); ``` 3. Fake **Wanneer gebruiken:** Wanneer je een eenvoudige, werkende implementatie hebt die de echte functionaliteit nabootst, bijvoorbeeld een in-memory database of een mock e-mailsysteem. **Waarom:** Voor integratietests waarbij je een meer realistische omgeving wilt simuleren zonder de volledige externe systemen te gebruiken. **Voorbeeld:** ```javascript const fakeEmailService = { sentEmails: [], send: function(recipient) { this.sentEmails.push(recipient); return true; } }; sendEmail('test@voorbeeld.com'); // Controleer of het emailadres is toegevoegd aan fakeEmailService.sentEmails ``` 4. Spy **Wanneer gebruiken:** Om te controleren of een functie werd aangeroepen, met welke parameters, en hoe vaak. **Waarom:** Om te verifiëren dat je code de juiste acties onderneemt, bijvoorbeeld dat `sendEmail` daadwerkelijk de verzendfunctie aanroept met de juiste gegevens. **Voorbeeld:** ```javascript const emailServiceSpy = { called: false, calledWith: null, send: function(recipient) { this.called = true; this.calledWith = recipient; } }; function sendEmail(recipient) { emailServiceSpy.send(recipient); } // Test sendEmail('test@voorbeeld.com'); console.log(emailServiceSpy.called); // true console.log(emailServiceSpy.calledWith); // 'test@voorbeeld.com' ``` **Samenvatting voor jouw scenario:** - Gebruik een **dummy** als je een parameter moet doorgeven, maar deze niet gebruikt wordt. - Gebruik een **stub** om de e-mailservice te simuleren met voorspelbare resultaten. - Gebruik een **fake** als je een eenvoudige, in-memory of mock implementatie wilt die meer gedrag vertoont. - Gebruik een **spy** om te controleren of `sendEmail` de juiste acties onderneemt, zoals het aanroepen van de verzendfunctie met het juiste e-mailadres. Wil je dat ik een compleet voorbeeld voor jouw `sendEmail` functie uitwerk met een specifiek test double?

Zeker, ik help je graag bij het kiezen en toepassen van de juiste test doubles. Laten we dit stap voor stap doen voor jouw `sendEmail` functie. ### Overzicht van Test Doubles: 1. **Dummy** - Gebruikt wanneer een parameter vereist is maar niet daadwerkelijk gebruikt wordt 2. **Stub** - Levert voorgeprogrammeerde antwoorden naar de onder test zijnde code 3. **Spy** - Registreert informatie over hoe deze werd aangeroepen 4. **Fake** - Werkt functioneel maar met vereenvoudigde implementatie 5. **Mock** - Verifieert interacties (vaak als framework geïmplementeerd) ### Praktische toepassing voor `sendEmail`: ```javascript // Originele functie (vereenvoudigd) function sendEmail(recipient, emailService) { if (!recipient || !recipient.email) { throw new Error('Ongeldige ontvanger'); } const result = emailService.send(recipient.email, 'Onderwerp', 'Body'); return result.success; } ``` #### 1. **DUMMY** - Wanneer parameters vereist zijn maar niet gebruikt ```javascript // Test geval: valideren van ontvanger zonder e-mailservice te gebruiken test('should throw error for invalid recipient', () => { const dummyService = {}; // Leeg object, wordt niet gebruikt expect(() => sendEmail(null, dummyService)).toThrow('Ongeldige ontvanger'); }); ``` #### 2. **STUB** - Om specifieke returnwaarden te forceren ```javascript // Test geval: controleren of e-mail succesvol wordt verzonden test('should return true on successful send', () => { const stubService = { send: () => ({ success: true }) // Forceren van succes }; const result = sendEmail({ email: 'test@example.com' }, stubService); expect(result).toBe(true); }); ``` #### 3. **SPY** - Om te controleren of functies correct worden aangeroepen ```javascript // Test geval: verifiëren dat send wordt aangeroepen met juiste parameters test('should call email service with correct parameters', () => { const spyService = { send: jest.fn(() => ({ success: true })) }; sendEmail({ email: 'test@example.com' }, spyService); expect(spyService.send).toHaveBeenCalledWith( 'test@example.com', 'Onderwerp', 'Body' ); }); ``` #### 4. **FAKE** - Lichtgewicht implementatie voor integratietesten ```javascript // Test geval: simuleren van e-mailservice gedrag zonder externe afhankelijkheid class FakeEmailService { constructor() { this.sentEmails = []; } send(to, subject, body) { this.sentEmails.push({ to, subject, body }); return { success: true, messageId: Date.now() }; } getSentEmails() { return this.sentEmails; } } test('should track sent emails in fake service', () => { const fakeService = new FakeEmailService(); sendEmail({ email: 'test@example.com' }, fakeService); expect(fakeService.getSentEmails()).toHaveLength(1); expect(fakeService.getSentEmails()[0].to).toBe('test@example.com'); }); ``` ### Waarom elk type gebruiken: - **Dummy**: Voor parameterverplichtingen wanneer de functionaliteit niet relevant is - **Stub**: Om specifieke scenario's te testen (succes/fout cases) - **Spy**: Voor interactie-verificatie zonder gedrag te veranderen - **Fake**: Voor complexere integratietesten zonder externe dependencies - **Mock**: (Niet getoond) Voor uitgebreide verwachtingsverificatie met frameworks ### Best practices voor jouw context: 1. Gebruik **stubs** voor het testen van bedrijfslogica 2. Gebruik **spies** om te verifiëren of e-mails correct worden aangeroepen 3. Gebruik **fakes** voor end-to-end testscenario's 4. Vermijd echte e-mailverzending tijdens unit tests Zo houd je je tests snel, betrouwbaar en vrij van externe afhankelijkheden!