unit-testing
Test dubbel

Opmerkingen

Een stub gebruiken om standaardantwoorden te leveren

Een stub is een lichtgewicht testdubbel die ingeblikte reacties biedt wanneer methoden worden aangeroepen. Wanneer een te testen klasse afhankelijk is van een interface of basisklasse, kan een alternatieve 'stub'-klasse worden geïmplementeerd voor testen die overeenkomen met de interface.

Dus uitgaande van de volgende interface,

public interface IRecordProvider {
    IEnumerable<Record> GetRecords();
}

Als de volgende methode moest worden getest

public bool ProcessRecord(IRecordProvider provider)

Een stubklasse die de interface implementeert, kan worden geschreven om bekende gegevens terug te sturen naar de te testen methode.

public class RecordProviderStub : IRecordProvider
{
    public IEnumerable<Record> GetRecords()
    {
        return new List<Record> {
            new Record { Id = 1, Flag=false, Value="First" },
            new Record { Id = 2, Flag=true, Value="Second" },
            new Record { Id = 3, Flag=false, Value="Third" }
        };
    }
}

Deze stub-implementatie kan vervolgens aan het systeem worden getest om het gedrag te beïnvloeden.

var stub = new RecordProviderStub();
var processed = sut.ProcessRecord(stub);

Een bespottingsraamwerk gebruiken als een stub

De termen Mock en Stub kunnen vaak in de war raken. Een deel van de reden hiervoor is dat veel mocking-frameworks ook ondersteuning bieden voor het maken van Stubs zonder de verificatiestap die aan Mocking is gekoppeld.

In plaats van een nieuwe klasse te schrijven om een stub te implementeren zoals in het voorbeeld "Een stub gebruiken om standaardantwoorden te leveren", kunnen in plaats daarvan spotmodellen worden gebruikt.

Moq gebruiken:

var stub = new Mock<IRecordProvider>();
stub.Setup(provider => provider.GetRecords()).Returns(new List<Record> {
    new Record { Id = 1, Flag=false, Value="First" },
    new Record { Id = 2, Flag=true, Value="Second" },
    new Record { Id = 3, Flag=false, Value="Third" }
});

Dit bereikt hetzelfde gedrag als de handgecodeerde stub en kan op dezelfde manier aan het te testen systeem worden geleverd:

var processed = sut.ProcessRecord(stub.Object);

Een spotmodel gebruiken om gedrag te valideren

Mocks worden gebruikt wanneer het nodig is om de interacties tussen het geteste systeem en testdubbels te verifiëren. Er moet voor worden gezorgd dat er geen al te broze tests worden gemaakt, maar bespotten kan met name handig zijn wanneer de testmethode eenvoudigweg andere oproepen orkestreert.

Deze test controleert dat wanneer de methode te testen (heet ProcessRecord ), dat de dienst methode ( UseValue ) wordt opgeroepen voor de Record waar de Flag==true . Hiertoe wordt een stub met ingeblikte gegevens ingesteld:

var stub = new Mock<IRecordProvider>();
stub.Setup(provider => provider.GetRecords()).Returns(new List<Record> {
    new Record { Id = 1, Flag=false, Value="First" },
    new Record { Id = 2, Flag=true, Value="Second" },
    new Record { Id = 3, Flag=false, Value="Third" }
});

Vervolgens wordt een mock opgezet die de IService interface implementeert:

var mockService = new Mock<IService>();
mockService.Setup(service => service.UseValue(It.IsAny<string>())).Returns(true);

Deze worden vervolgens aan het te testen systeem toegevoerd en de te testen methode wordt genoemd.

var sut = new SystemUnderTest(mockService.Object);

var processed = sut.ProcessRecord(stub.Object);

De mock kan vervolgens worden ondervraagd om te verifiëren dat de verwachte oproep is gedaan. In dit geval een aanroep naar UseValue , met één parameter "Second", wat de waarde is van het record waarbij Flag==true .

mockService.Verify(service => service.UseValue("Second"));