Delen via

F#-bibliotheken in .NET Core testen met behulp van dotnet-test en xUnit

In deze tutorial wordt u stapsgewijs begeleid bij het bouwen van een voorbeeldoplossing om concepten van unit testing te leren. Als u de zelfstudie liever volgt met behulp van een vooraf gebouwde oplossing, de voorbeeldcode bekijken of downloaden voordat u begint. Zie voorbeelden en zelfstudiesvoor downloadinstructies.

Dit artikel gaat over het testen van een .NET Core-project. Als u een ASP.NET Core-project aan het testen bent, zie Integratietests in ASP.NET Core.

Het bronproject maken

Open een shellvenster. Maak een map met de naam unit-testing-with-fsharp om de oplossing te bewaren. Voer in deze nieuwe map dotnet new sln uit om een nieuwe oplossing te maken. Hierdoor is het eenvoudiger om zowel de klassebibliotheek als het eenheidstestproject te beheren. Maak in de oplossingsmap een MathService directory. De map en bestandsstructuur tot nu toe worden hieronder weergegeven:

/unit-testing-with-fsharp
    unit-testing-with-fsharp.sln
    /MathService

Maak MathService de huidige map en voer deze uit dotnet new classlib -lang "F#" om het bronproject te maken. U maakt een mislukte implementatie van de wiskundige service:

module MyMath =
    let squaresOfOdds xs = raise (System.NotImplementedException("You haven't written a test yet!"))

Verander de directory terug naar de eenheidstest-met-fsharp directory. Voer dotnet sln add .\MathService\MathService.fsproj uit om het klassebibliotheekproject toe te voegen aan de oplossing.

Het testproject maken

Maak vervolgens de map MathService.Tests. Het volgende schema toont de directorystructuur:

/unit-testing-with-fsharp
    unit-testing-with-fsharp.sln
    /MathService
        Source Files
        MathService.fsproj
    /MathService.Tests

Maak de MathService.Tests map de huidige map en maak een nieuw project met behulp van dotnet new xunit -lang "F#". Hiermee maakt u een testproject dat xUnit als testbibliotheek gebruikt. De gegenereerde sjabloon configureert de testrunner in de MathServiceTests.fsproj:

<ItemGroup>
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170628-02" />
  <PackageReference Include="xunit" Version="2.2.0" />
  <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
</ItemGroup>

Voor het testproject zijn andere pakketten vereist om eenheidstests te maken en uit te voeren. dotnet new in de vorige stap zijn xUnit en de xUnit runner toegevoegd. Voeg nu de MathService klassebibliotheek toe als een andere afhankelijkheid van het project. Gebruik de opdracht dotnet reference add:

dotnet reference add ../MathService/MathService.fsproj

U kunt het hele bestand zien in de opslagplaats met voorbeelden op GitHub.

U hebt de volgende indeling voor de uiteindelijke oplossing:

/unit-testing-with-fsharp
    unit-testing-with-fsharp.sln
    /MathService
        Source Files
        MathService.fsproj
    /MathService.Tests
        Test Source Files
        MathServiceTests.fsproj

Voer dotnet sln add .\MathService.Tests\MathService.Tests.fsproj uit in de directory unit-testing-with-fsharp.

De eerste test maken

U schrijft één mislukte test, laat deze slagen en herhaal het proces. Open Tests.fs en voeg de volgende code toe:

[<Fact>]
let ``My test`` () =
    Assert.True(true)

[<Fact>]
let ``Fail every time`` () = Assert.True(false)

Het kenmerk [<Fact>] geeft een testmethode aan die wordt uitgevoerd door de testloper. Vanuit de unit-tests-met-fsharp voer dotnet test uit om de tests en de klassebibliotheek te bouwen en daarna de tests uit te voeren. De xUnit-testloper bevat het ingangspunt van het programma om uw tests uit te voeren. dotnet test start de test runner met het unittestproject dat u hebt gemaakt.

Deze twee tests tonen de meest eenvoudige geslaagde en mislukte tests. My test slaagt en Fail every time mislukt. Maak nu een test voor de methode squaresOfOdds. De squaresOfOdds methode retourneert een reeks van de kwadraten van alle oneven gehele getallen die deel uitmaken van de invoerreeks. In plaats van al deze functies tegelijk te schrijven, kunt u iteratief tests maken waarmee de functionaliteit wordt gevalideerd. Het maken van elke testpas betekent het maken van de benodigde functionaliteit voor de methode.

De eenvoudigste test die we kunnen schrijven, is het aanroepen van squaresOfOdds met alle even getallen, waarbij het resultaat een lege reeks gehele getallen moet zijn. Dit is de test:

[<Fact>]
let ``Sequence of Evens returns empty collection`` () =
    let expected = Seq.empty<int>
    let actual = MyMath.squaresOfOdds [2; 4; 6; 8; 10]
    Assert.Equal<Collections.Generic.IEnumerable<int>>(expected, actual)

Uw test mislukt. U hebt de implementatie nog niet gemaakt. Zorg ervoor dat deze test slaagt door de simpelste code in de MathService-klasse te schrijven die werkt.

let squaresOfOdds xs =
    Seq.empty<int>

Voer opnieuw uit in de map dotnet test. Met de opdracht dotnet test wordt een build uitgevoerd voor het MathService project en vervolgens voor het MathService.Tests project. Nadat beide projecten zijn gebouwd, wordt deze enkele test uitgevoerd. Het gaat voorbij.

De vereisten voltooien

Nu je één testronde hebt voltooid, is het tijd om er meer te schrijven. De volgende eenvoudige case werkt met een reeks waarvan alleen oneven getal is 1. Het getal 1 is gemakkelijker omdat het vierkant van 1 1 is. Dit is de volgende test:

[<Fact>]
let ``Sequences of Ones and Evens returns Ones`` () =
    let expected = [1; 1; 1; 1]
    let actual = MyMath.squaresOfOdds [2; 1; 4; 1; 6; 1; 8; 1; 10]
    Assert.Equal<Collections.Generic.IEnumerable<int>>(expected, actual)

Door dotnet test uit te voeren, worden uw tests uitgevoerd en ziet u dat de nieuwe test mislukt. Werk nu de squaresOfOdds methode bij om deze nieuwe test af te handelen. U filtert alle even getallen uit de reeks om deze test te laten slagen. U kunt dit doen door een kleine filterfunctie te schrijven en Seq.filterte gebruiken:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd

Er is nog een stap: elk van de oneven getallen kwadrateren. Begin met het schrijven van een nieuwe test:

[<Fact>]
let ``SquaresOfOdds works`` () =
    let expected = [1; 9; 25; 49; 81]
    let actual = MyMath.squaresOfOdds [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
    Assert.Equal(expected, actual)

U kunt de test oplossen door de gefilterde reeks door te spitsen via een kaartbewerking om het kwadraat van elk oneven getal te berekenen:

let private square x = x * x
let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd
    |> Seq.map square

U hebt een kleine bibliotheek en een set eenheidstests voor die bibliotheek gemaakt. U hebt de oplossing gestructureerd zodat het toevoegen van nieuwe pakketten en tests deel uitmaakt van de normale werkstroom. U hebt zich het grootste deel van uw tijd en moeite geconcentreerd op het oplossen van de doelstellingen van de toepassing.

Zie ook