Wat is het verschil tussen een mock & amp; Stub?

Ik heb verschillende artikelen gelezen over spottende vs struiken in testen, inclusief Martin Fowler’s mocks zijn niet stubs , maar begrijp het verschil nog steeds niet.

Antwoord 1, Autoriteit 100%

stub

Ik geloof dat het grootste onderscheid is dat een stub die je al hebt geschreven met vooraf bepaald gedrag. Dus je zou een klasse hebben die de afhankelijkheid (abstracte klasse of interface waarschijnlijk) implementeert, je fokken voor testdoeleinden en de methoden zouden gewoon worden gesprongen met set reacties. Ze zouden niets bijzonders doen en je zou de gesproeide code voor het buiten je test hebben geschreven.

mock

Een spot is iets dat als onderdeel van uw test u moet instellen met uw verwachtingen. Een spot is niet op een vooraf bepaalde manier ingesteld, zodat je code hebt die het in je test doet. Mocks op een manier worden bepaald bij runtime sinds de code die de verwachtingen instelt, moet worden uitgevoerd voordat ze iets doen.

verschil tussen spot en stubs

Tests geschreven met spot volgen meestal een initialize -> set expectations -> exercise -> verifypatroon om te testen. Terwijl de vooraf geschreven stomp een initialize -> exercise -> verify.

gelijkenis tussen spot en stubs

Het doel van beide is om het testen van alle afhankelijkheden van een klasse of functie te exemineren, zodat uw tests meer gericht en eenvoudiger zijn in wat ze proberen te bewijzen.

Antwoord 2, Autoriteit 116%

Voorwoord

Er zijn verschillende definities van objecten, die niet echt zijn. De algemene term is test dubbel . Deze term omvat: dummy , nep , stub , mock .

Referentie

Volgens Martin Fowler’s artikel :

• Dummy Objecten worden doorgegeven, maar nooit daadwerkelijk gebruikt. Meestal worden ze gewoon gebruikt om parameterlijsten te vullen.
• Fake Objecten hebben daadwerkelijk werkende implementaties, maar maken meestal een snelkoppeling, waardoor ze niet geschikt zijn voor productie (een in de geheugendatabase is een goed voorbeeld).
• Stubs Geef ingeblikte antwoorden op oproepen die tijdens de test zijn gemaakt, meestal niet reageren op alles buiten wat is geprogrammeerd voor de test. Stubs kunnen ook informatie opnemen over oproepen, zoals een e-mailgateway-stub die zich herinnert aan de berichten die het ‘heeft verzonden’, of misschien alleen hoeveel berichten het ‘verzonden’.
• Mocks zijn waar we het over hebben: Objecten pre-geprogrammeerd met verwachtingen die een specificatie van de gesprekken vormen waarvan wordt verwacht dat ze worden verwacht.

Stijl

Mocks vs stubs = Gedragstest vs State Testing

Principle

Volgens het principe van Test slechts één ding per test , er kunnen verschillende stubs in één test zijn, maar over het algemeen is er maar één spot.

Lifecycle

Test levenscyclus met stubs:

1. SETUP – Bereid object dat wordt getest en zijn stubs-medewerkers.
2. Oefening – Test de functionaliteit.
3. Controleer de status – gebruik ASSERTS om de toestand van het object te controleren.
4. Teardown – Reinigingsmiddelen.

Test levenscyclus met spot:

1. Instelgegevens – Bereid het object voor dat wordt getest.
2. Verwachtingen instellen– Bereid verwachtingen voor in een mock die wordt gebruikt door het primaire object.
3. Oefening – Test de functionaliteit.
4. Verifieer verwachtingen– Controleer of de juiste methoden zijn aangeroepen in de vorm van een mock.
5. Status verifiëren – Gebruik beweringen om de staat van het object te controleren.
6. Teardown – Ruim bronnen op.

Samenvatting

Zowel mocks als stubs testen geven een antwoord op de vraag: Wat is het resultaat?

Testen met mocks zijn ook geïnteresseerd in: Hoe het resultaat is bereikt?

Antwoord 3, autoriteit 51%

Een stub is een eenvoudig nep-object. Het zorgt er alleen maar voor dat de test soepel verloopt.
Een mock is een slimmere stomp. U verifieert of uw test erdoor komt.

Antwoord 4, autoriteit 32%

Hier is een beschrijving van elk, gevolgd door een voorbeeld uit de echte wereld.

• Dummy– alleen valse waarden om te voldoen aan de API.

  Voorbeeld: als u een methode van een klasse test die veel verplichte parameters in een constructor vereist die geen effectop uw test hebben, dan kunt u een dummy maken objecten voor het maken van nieuwe instanties van een klasse.

• Nep– maak een testimplementatie van een klasse die mogelijk afhankelijk is van een externe infrastructuur. (Het is een goede gewoonte dat uw eenheidstest NIETdaadwerkelijk interageert met externe infrastructuur.)

  Voorbeeld: maak een nep-implementatie voor toegang tot een database, vervang deze door een in-memory-verzameling.

• Stub – Override-methoden om hardgecodeerde waarden te retourneren, ook bedoeld als state-based.

  Voorbeeld : uw testklasse is afhankelijk van een methode Calculate()het nemen van 5 minuten om te voltooien. In plaats van 5 minuten te wachten, kun je zijn echte implementatie vervangen door Stub die hard-gecodeerde waarden retourneert; slechts een kleine fractie van de tijd nemen.

• Mock – Zeer vergelijkbaar met StubMaar interaction-basedin plaats van op de staat gebaseerd. Dit betekent dat u niet verwacht van Mockom een ​​waarde terug te geven, maar om aan te nemen dat specifieke volgorde van methode-oproepen worden gemaakt.

  Voorbeeld: u test een gebruikersregistratie-klasse. Na het oproepen van Save, zou het moeten bellen SendConfirmationEmail.

Stubsen Mockszijn eigenlijk subtypen Mock, beide swappen echte implementatie met testimplementatie, maar voor verschillende, specifieke redenen.

Antwoord 5, Autoriteit 22%

In de Codeschool.com cursus, Rails testen voor zombies , ze geven deze definitie van de voorwaarden:

Stub

Voor het vervangen van een methode met code die een gespecificeerd resultaat retourneert.

Mock

een stomp met een bewering die de methode wordt genoemd.

Zoals Sean Copenhaver beschreef in zijn antwoord, is het verschil dat spot de verwachtingen instellen (d.w.z. maakte beweringen, over de vraag of ze worden genoemd).

Antwoord 6, Autoriteit 19%

Stubs falen uw tests niet, bespotten kan.

Antwoord 7, Autoriteit 7%

Let me om alle uitleg te lezen, laat me proberen te condenseren:

• Stub: een dummy stukje code waarmee de test kan worden uitgevoerd, maar het maakt je niet uit wat ermee gebeurt.
• Mock: een dummy stukje code, dat u CONTROLEERT, wordt correct aangeroepen als onderdeel van de test.
• Spy: een dummy stukje code, dat sommige oproepen naar een echt stuk code onderschept, zodat u oproepen kunt verifiëren zonder het volledige originele object te vervangen.

Antwoord 8, autoriteit 6%

Ik denk dat het eenvoudigste en duidelijkere antwoord op deze vraag wordt gegeven door Roy Osherovein zijn boek The art of Unit Testing(pagina 85)

De gemakkelijkste manier om te zien of we met een stub te maken hebben, is door op te merken dat de stub de test nooit kan doorstaan. De beweringen dat de testgebruiken altijd tegen zijn
de klas die wordt getest.

Aan de andere kant gebruikt de test een nepobject om te verifiëren of de
test mislukt of niet. […]

Nogmaals, het nepobject is het object dat we gebruiken om te zien of de test is mislukt of niet.

Stub en mock zijn beide nep.

Als je beweringen doet tegen de nep, betekent dit dat je de nep gebruikt als een schijnvertoning, als je de nep alleen gebruikt om de test uit te voeren zonder er iets over te beweren, gebruik je de nep als een steekje.

Antwoord 9, autoriteit 4%

Een Mock is gewoon het testen van gedrag en ervoor zorgen dat bepaalde methoden worden aangeroepen.
Een Stub is een testbare versie (per se) van een bepaald object.

Wat bedoel je op Apple-manier?

Antwoord 10, autoriteit 3%

Als je het vergelijkt met foutopsporing:

Stubis zoiets als ervoor zorgen dat een methode de juiste waarde retourneert

Spottenis alsof je daadwerkelijk in de methode stapten ervoor zorgt dat alles erin klopt voordat je de juiste waarde retourneert.

Antwoord 11, autoriteit 3%

Om heel duidelijk en praktisch te zijn:

Stub: een klasse of object dat de methoden van de te vervalsen klasse/het object implementeert en altijd teruggeeft wat je wilt.

Voorbeeld in JavaScript:

var Stub = {
   method_a: function(param_a, param_b){
      return 'This is an static result';
   }
}

Mock: hetzelfde als stub, maar het voegt wat logica toe die “verifieert” wanneer een methode wordt aangeroepen, zodat je er zeker van kunt zijn dat een implementatie die methode aanroept.

Zoals @mLevan zegt, stel je als voorbeeld voor dat je een gebruikersregistratieklasse test. Na het aanroepen van Save, zou het SendConfirmationEmail moeten aanroepen.

Een erg domme code Voorbeeld:

var Mock = {
   calls: {
      method_a: 0
   }
   method_a: function(param_a, param_b){
     this.method_a++; 
     console.log('Mock.method_a its been called!');
   }
}

Antwoord 12, autoriteit 3%

Het gebruik van een mentaal modelheeft me echt geholpen dit te begrijpen, in plaats van alle uitleg en artikelen die niet helemaal “doordrongen”.

Stel je voor dat je kind een glasplaat op tafel heeft en ermee begint te spelen. Nu ben je bang dat het zal breken. Dus geef je hem in plaats daarvan een plastic bord. Dat zou een Mockzijn (zelfde gedrag, zelfde interface, “zachtere” implementatie).

Stel nu dat je de plastic vervanging niet hebt, dus je legt uit: “Als je ermee blijft spelen, zal het breken!”. Dat is een Stub, je hebt vooraf een vooraf gedefinieerde status opgegeven.

Een Dummyzou de fork zijn die hij niet eens gebruikte… en een Spionzou zoiets kunnen zijn als het geven van dezelfde uitleg die je al gebruikte die werkte.

Antwoord 13, autoriteit 3%

Deze dia legt de belangrijkste verschillen goed uit.

*Uit CSE 403 Lecture 16, University of Washington (dia gemaakt door “Marty Stepp”)

Antwoord 14, autoriteit 2%

laat eens zien Test Doubles:

• Nep: Fakes zijn objecten met werkende implementaties, maar niet hetzelfde als productie-implementaties. Zoals: in-memory implementatie van Data Access Object of Repository.

• Stub: Stub is een object dat vooraf gedefinieerde gegevens bevat en deze gebruikt om oproepen te beantwoorden tijdens tests. Zoals: een object dat gegevens uit de database moet halen om te reageren op een methodeaanroep.

• Mocks: Mocks zijn objecten die oproepen registreren die ze ontvangen.
  In testbevestiging kunnen we op Mocks verifiëren dat alle verwachte acties zijn uitgevoerd. Zoals: een functionaliteit die de e-mailverzendservice aanroept.
  check ditvoor meer informatie.

Antwoord 15, autoriteit 2%

Ik denk dat het belangrijkste verschil tussen hen hun bedoelingen zijn.

Laat me proberen het uit te leggen in WAAROM stubversus WAAROM schijn

Stel dat ik testcode schrijf voor de openbare tijdlijncontroller van mijn mac twitter-client

Hier is testvoorbeeldcode

twitter_api.stub(:public_timeline).and_return(public_timeline_array)
client_ui.should_receive(:insert_timeline_above).with(public_timeline_array)
controller.refresh_public_timeline

• STOMP: De netwerkverbinding op Twitter API is erg traag, die mijn test traag. Ik weet dat het zal tijdlijnen terugkeren, dus maakte ik een stomp simuleren HTTP twitter API, zodat mijn test het heel snel zal lopen, en ik kan het uitvoeren van de test zelfs ik ben niet beschikbaar.
• ONECHTE: Ik heb nog niet geschreven een van mijn UI methoden, en ik ben niet zeker welke methoden ik nodig heb om te schrijven voor mijn ui object. Ik hoop om te weten hoe mijn controller zal samenwerken met mijn ui object door het schrijven van de test code.

Door het schrijven van mock, ontdek je de voorwerpen samenwerkingsrelatie door te controleren of de verwachting is voldaan, terwijl de stomp alleen simuleren gedrag van het object.

Ik stel voor om dit artikel als je probeert om meer over mocks weten te lezen: http://jmock.org/oopsla2004.pdf

Antwoord 16, Autoriteit 2%

Ik hou van de explanantion gezet door Roy Osherove .

Elke klasse of object gemaakt is een Fake. Het is een Mock als je verifiëren
roept tegen. Anders is het een stomp.

Antwoord 17, Autoriteit 2%

• Stubs vs. Mocks
  • Stubs
    1. bieden concrete antwoorden op methoden oproepen
       • ex: myStubbedService.getValues ​​() gewoon terug een string die nodig zijn door de code te testen
    2. gebruiken code testen te isoleren
    3. kan geen test mislukken
       • ex: myStubbedService.getValues ​​() alleen de gerooide waarde terugkeert
    4. vaak implementeren abstract methoden
  • Mocks
    1. “superset” van stubs; kan beweren dat bepaalde methoden worden genoemd
       • ex: controleer of myMockedService.getValues ​​() wordt slechts eenmaal genoemd
    2. gebruikt om te testen het gedrag van de code te testen
    3. kan test niet halen
       • ex: verifieer dat MyMockedService.GetValues ​​() eenmaal werd genoemd; Verificatie mislukt, omdat MyMockedService.getValues ​​() niet is opgeroepen door mijn geteste code
    4. bespotten vaak interfaces

Antwoord 18

Ik lees de kunst van het testen en struikelde op de volgende definitie:

A Fake is een generieke term die kan worden gebruikt om een ​​stomp of een schijnobject (handgeschreven of anderszins) te beschrijven, omdat ze allebei op het echte object lijken . Of een nep een stub is of een schijn is afhankelijk van hoe het wordt gebruikt in de huidige test. Als het wordt gebruikt om een ​​interactie (beweerd tegen) te controleren, is het een Mock-object . Anders is het een stomp .

Antwoord 19

A nep is een generieke term die kan worden gebruikt om een ​​stub te beschrijven
of een schijnobject (met de hand geschreven of anderszins), omdat ze allebei eruit zien als de
Echt object.

Of een nep een stub is of een schijn is afhankelijk van hoe het wordt gebruikt
de huidige test. Als het wordt gebruikt om een ​​interactie (beweerd tegen) te controleren, is het een
Mock-object. Anders is het een stomp.

Fakes zorgt ervoor dat de test soepel loopt. Het betekent dat de lezer van uw toekomstige test zal begrijpen wat het gedrag van het nep-object zal zijn, zonder de broncode te hoeven lezen (zonder dat u afhankelijk is van externe resource).

Wat betekent de test soepel gemiddelde?
Voorvoorbeeld in onderstaande code:

public void Analyze(string filename)
        {
            if(filename.Length<8)
            {
                try
                {
                    errorService.LogError("long file entered named:" + filename);
                }
                catch (Exception e)
                {
                    mailService.SendEMail("[email protected]", "ErrorOnWebService", "someerror");
                }
            }
        }

U wilt de methode mailService.SendEMail()testen, om dat te doen, moet u een uitzondering in uw testmethode simuleren, dus u hoeft alleen maar een Fake Stub errorService-klasse te maken om dat resultaat te simuleren , dan kan uw testcode de methode mailService.SendEMail() testen. Zoals u ziet, moet u een resultaat simuleren dat afkomstig is van een andere External Dependency ErrorService-klasse.

Antwoord 20

Rechtstreeks uit de krant Mock Roles, not Objects, door de ontwikkelaars van jMock:

Stubs zijn dummy-implementaties van productiecode die ingeblikt worden geretourneerd
resultaten. Mock Objects fungeren als stubs, maar bevatten ook beweringen om
instrumenteer de interacties van het doelobject met zijn buren.

Dus de belangrijkste verschillen zijn:

• verwachtingen voor stubs zijn meestal generiek, terwijl verwachtingen voor mocks “slimmer” kunnen zijn (bijvoorbeeld dit teruggeven bij het eerste gesprek, dit bij het tweede enz.).
• stubsworden voornamelijk gebruikt om indirecte ingangen van de SUT in te stellen, terwijl mockskunnen worden gebruikt om zowel indirecte ingangen als indirecteuitgangen van de SUT.

Samenvattend, terwijl we ook proberen de verwarring uit de Fowler’s artikeltitel te verspreiden: spots zijn stubs, maar het zijn niet alleen stubs.

Antwoord 21

Ik kwam dit interessante artikel door Unclebob The Little Mocker . Het verklaart alle terminologie op een zeer gemakkelijk te begrijpen manier, dus het is handig voor beginners. Martin Fowlers Artikel is een harde lezing speciaal voor beginners zoals ik.

Antwoord 22

Veel geldige antwoorden daarboven, maar ik denk dat de moeite waard is om dit te vermelden, zich oom Bob:
https://8thlight.com/blog/Uncle-bob/2014 /05/14/thelittlemocker.html

De beste uitleg ooit met voorbeelden!

Antwoord 23

Stub

A Stub is een object dat wordt gebruikt om een ​​methode te vervalsen die voorgeprogrammeerd gedrag heeft. Misschien wilt u dit gebruiken in plaats van een bestaande methode om ongewenste bijwerkingen (bijvoorbeeld een stomp te voorkomen, kan een nep-oproep maken die een voorgeprogrammeerde respons retourneert zonder daadwerkelijk een verzoek aan een server te doen).

Mock

A Mock is een object dat wordt gebruikt om een ​​methode te vervalsen die voorgeprogrammeerd gedrag heeft, evenals voorgeprogrammeerde verwachtingen . Als niet aan deze verwachtingen worden voldaan, zal de spot veroorzaken dat de test faalt (bijvoorbeeld een mock kan een nep-haaloproep maken die een voorgeprogrammeerde respons retourneert zonder daadwerkelijk een verzoek aan een server te doen die zou verwachten bijvoorbeeld het eerste argument om http://localhost:3008/anders zou de test mislukken.)

verschil

In tegenstelling tot mals, hebben stubs geen voorgeprogrammeerde verwachtingen die uw test kunnen mislukken.

Antwoord 24

Een spot is zowel een technisch als een functioneel -object.

De mock is technisch. Het is inderdaad gemaakt door een mocking-bibliotheek (EasyMock, JMockit en meer recentelijk staan Mockito hier bekend om) dankzij byte-codegeneratie.
De schijnimplementatie is gegenereerdop een manier waarop we deze kunnen instrumenterenom een specifieke waarde te retourneren wanneer een methode wordt aangeroepen, maar ook een aantal andere dingen, zoals het verifiëren dat een schijnmethode is aangeroepen met een aantal specifieke parameters (strikte controle) of wat dan ook de parameters (geen strikte controle).

Een mock maken:

@Mock Foo fooMock

Een gedrag registreren:

when(fooMock.hello()).thenReturn("hello you!");

Een aanroep verifiëren:

verify(fooMock).hello()

Dit is duidelijk niet de natuurlijke manier om de Foo-klasse/het gedrag te instantiëren/overschrijven. Daarom verwijs ik naar een technisch aspect.

Maar de mock is ook functioneelomdat het een instantie is van de klasse die we moeten isoleren van de SUT. En met geregistreerd gedrag erop, zouden we het in de SUT op dezelfde manier kunnen gebruiken als met een stub.

De stub is slechts een functioneelobject : dat is een instantie van de klasse die we moeten isoleren van de SUT en dat is alles.
Dat betekent dat zowel de stub-klasse als alle gedragingen die nodig zijn tijdens onze unit-tests expliciet moeten worden gedefinieerd.
Als u bijvoorbeeld hello()wilt stuben, moet u de klasse Foosubklassen (of de interface implementeren die deze heeft) en hello()negeren :

public class HelloStub extends Hello{    
  public String hello { 
      return "hello you!"; 
  }
}

Als een ander testscenario een ander waarderendement vereist, moeten we waarschijnlijk een generieke manier definiëren om het rendement in te stellen:

public class HelloStub extends Hello{    
  public HelloStub(String helloReturn){
       this.helloReturn = helloReturn;
  }
  public String hello { 
      return helloReturn; 
  }
}

Ander scenario: als ik een bijwerkingsmethode had (geen terugkeer) en ik zou controleren of die methode werd aangeroepen, had ik waarschijnlijk een boolean of een teller in de stub-klasse moeten toevoegen om te tellen hoe vaak de methode werd aangeroepen .

Conclusie

De stub vereist vaak veel overhead/code om te schrijven voor je unit-test. Wat mock voorkomt dankzij het leveren van opname-/verificatiefuncties uit de doos.
Dat is de reden waarom tegenwoordig de stub-benadering in de praktijk zelden wordt gebruikt met de komst van uitstekende nepbibliotheken.

Over het Martin Fowler-artikel: ik denk niet dat ik een “spotter”-programmeur ben terwijl ik mocks gebruik en ik vermijd stubs.
Maar ik gebruik mock wanneer het echt nodig is (vervelende afhankelijkheden) en ik geef de voorkeur aan test slicing en mini-integratietests wanneer ik een klasse test met afhankelijkheden die spotten een overhead zou zijn.

Antwoord 25

Plus nuttige antwoorden, Een van de krachtigste punten van het gebruik van Mocks dan Subs

Als de bijdrager [waarvan de hoofdcode ervan afhangt] niet onder onze controle staat(bijvoorbeeld uit een bibliotheek van derden),
In dit geval is stub moeilijker te schrijven dan te spotten.

Antwoord 26

Stubhelpt ons bij het uitvoeren van tests. Hoe? Het geeft waarden die helpen bij het uitvoeren van de test. Deze waarden zijn zelf niet echt en we hebben deze waarden gemaakt om de test uit te voeren. We maken bijvoorbeeld een HashMap om ons waarden te geven die vergelijkbaar zijn met waarden in de databasetabel. Dus in plaats van directe interactie met de database, hebben we interactie met Hashmap.

Mockis een nep-object dat de test uitvoert. waar we assert zetten.

Antwoord 27

Zie onderstaand voorbeeld van mocks vs stubs met behulp van C# en Moq-framework. Moq heeft geen speciaal trefwoord voor Stub, maar je kunt Mock-object ook gebruiken om stubs te maken.

namespace UnitTestProject2
{
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using Moq;
    [TestClass]
    public class UnitTest1
    {
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method calls Repository GetName method "once" when Id is greater than Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_GetNameCalledOnce()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));
            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Once);
        }
        /// <summary>
        /// Test using Mock to Verify that GetNameWithPrefix method doesn't call Repository GetName method when Id is Zero
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsZero_GetNameNeverCalled()
        {
            // Arrange 
            var mockEntityRepository = new Mock<IEntityRepository>();
            mockEntityRepository.Setup(m => m.GetName(It.IsAny<int>()));
            var entity = new EntityClass(mockEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(0);
            // Assert
            mockEntityRepository.Verify(m => m.GetName(It.IsAny<int>()), Times.Never);
        }
        /// <summary>
        /// Test using Stub to Verify that GetNameWithPrefix method returns Name with a Prefix
        /// </summary>
        [TestMethod]
        public void GetNameWithPrefix_IdIsTwelve_ReturnsNameWithPrefix()
        {
            // Arrange 
            var stubEntityRepository = new Mock<IEntityRepository>();
            stubEntityRepository.Setup(m => m.GetName(It.IsAny<int>()))
                .Returns("Stub");
            const string EXPECTED_NAME_WITH_PREFIX = "Mr. Stub";
            var entity = new EntityClass(stubEntityRepository.Object);
            // Act 
            var name = entity.GetNameWithPrefix(12);
            // Assert
            Assert.AreEqual(EXPECTED_NAME_WITH_PREFIX, name);
        }
    }
    public class EntityClass
    {
        private IEntityRepository _entityRepository;
        public EntityClass(IEntityRepository entityRepository)
        {
            this._entityRepository = entityRepository;
        }
        public string Name { get; set; }
        public string GetNameWithPrefix(int id)
        {
            string name = string.Empty;
            if (id > 0)
            {
                name = this._entityRepository.GetName(id);
            }
            return "Mr. " + name;
        }
    }
    public interface IEntityRepository
    {
        string GetName(int id);
    }
    public class EntityRepository:IEntityRepository
    {
        public string GetName(int id)
        {
            // Code to connect to DB and get name based on Id
            return "NameFromDb";
        }
    }
}

Antwoord 28

De algemene term die hij gebruikt is een Test Double(denk aan stuntdubbel). Test Double is een verzamelnaam voor elk geval waarin u een productieobject vervangt voor testdoeleinden. Er zijn verschillende soorten dubbel die Gerard opsomt:

• Dummy-objecten worden doorgegeven maar nooit daadwerkelijk gebruikt. Meestal worden ze alleen gebruikt om parameterlijsten te vullen.
• Nep-objecten hebben eigenlijk werkende implementaties, maar nemen meestal een kortere weg waardoor ze niet geschikt zijn voor productie (een InMemoryTestDatabase is een goed voorbeeld).
• Stubsbieden standaardantwoorden op oproepen die tijdens de test worden gedaan, en reageren meestal helemaal niet op iets anders dan wat voor de test is geprogrammeerd.
• Spionnenzijn stompjes die ook wat informatie vastleggen op basis van hoe ze werden genoemd. Een vorm hiervan kan een e-mailservice zijn die bijhoudt hoeveel berichten er zijn verzonden (ook wel Gedeeltelijke Mockgenoemd).
• Mockszijn voorgeprogrammeerd met verwachtingen die een specificatie vormen van de oproepen die ze naar verwachting zullen ontvangen. Ze kunnen een uitzondering maken als ze een oproep ontvangen die ze niet verwachten en worden tijdens de verificatie gecontroleerd om er zeker van te zijn dat ze alle oproepen hebben gekregen die ze verwachtten.

Bron

Antwoord 29

Ik heb in mijn antwoord pythonvoorbeelden gebruikt om de verschillen te illustreren.

Stub– Stubbing is een softwareontwikkelingstechniek die wordt gebruikt om methoden van klassen vroeg in de ontwikkelingscyclus te implementeren. Ze worden vaak gebruikt als tijdelijke aanduidingen voor de implementatie van een bekende interface, waarbij de interface is voltooid of bekend, maar de implementatie nog niet bekend of afgerond is. Je begint met stubs, wat simpelweg betekent dat je alleen de definitie van een functie opschrijft en de eigenlijke code voor later laat. Het voordeel is dat je methoden niet vergeet en dat je kunt blijven nadenken over je ontwerp terwijl je het in code ziet. U kunt uw stub ook een statisch antwoord laten retourneren, zodat het antwoord onmiddellijk door andere delen van uw code kan worden gebruikt. Stub-objecten geven een geldig antwoord, maar het is statisch, welke invoer u ook doorgeeft, u krijgt altijd hetzelfde antwoord:

class Foo(object):
    def bar1(self):
        pass
    def bar2(self):
        #or ...
        raise NotImplementedError
    def bar3(self):
        #or return dummy data
        return "Dummy Data"

Nep-objecten worden gebruikt in nep-testcases, ze valideren dat bepaalde methoden op die objecten worden aangeroepen. Mock-objecten zijn gesimuleerde objecten die het gedrag van echte objecten op gecontroleerde manieren nabootsen. Meestal maakt u een nepobject om het gedrag van een ander object te testen. Met mocks kunnen we bronnen simuleren die niet beschikbaar zijn of te onpraktisch zijn voor het testen van eenheden.

mijnmodule.py:

import os
import os.path
def rm(filename):
    if os.path.isfile(filename):
        os.remove(filename)

test.py:

from mymodule import rm
import mock
import unittest
class RmTestCase(unittest.TestCase):
    @mock.patch('mymodule.os')
    def test_rm(self, mock_os):
        rm("any path")
        # test that rm called os.remove with the right parameters
        mock_os.remove.assert_called_with("any path")
if __name__ == '__main__':
    unittest.main()

Dit is een zeer basisch voorbeeld dat gewoon RM runt en beweert de parameter die het is aangeroepen. Je kunt spot gebruiken met objecten die niet alleen functioneren zoals hier wordt weergegeven, en je kunt ook een waarde retourneren, zodat een schijnobject kan worden gebruikt om een stub te vervangen voor testen.

Meer op unittest.mock , opmerking in Python 2.x Mock is niet inbegrepen in Unittest, maar is een downloadbare module die via PIP kan worden gedownload (PIP Install Mock).

Ik heb ook “The Art of Unit Testing” gelezen door Roy Olderove en ik denk dat het geweldig zou zijn als een soortgelijk boek is geschreven met behulp van Python- en Python-voorbeelden. Als iemand van zo’n boek weet, deel dan dan. Proost 🙂

ANTWOORD 30

Een stub is een nep-object gebouwd voor testdoeleinden. Een spot is een stub die registreert of er effectief verwachte oproepen plaatsvonden.