Condividi tramite

Testare unità delle librerie F# in .NET Core utilizzando dotnet test e MSTest

Questa esercitazione illustra un'esperienza interattiva che crea una soluzione di esempio dettagliata per apprendere i concetti di unit test. Se preferisci seguire il tutorial usando una soluzione predefinita, visualizza o scarica il codice di esempio prima di iniziare. Per istruzioni sul download, vedere esempi ed esercitazioni .

Questo articolo descrive il test di un progetto .NET Core. Se si sta testando un progetto ASP.NET Core, vedere test di integrazione in ASP.NET Core.

Creazione del progetto di origine

Aprire una finestra della shell. Creare una directory denominata unit-testing-with-fsharp per contenere la soluzione. All'interno di questa nuova directory eseguire dotnet new sln per creare una nuova soluzione. In questo modo è più semplice gestire sia la libreria di classi che il progetto di unit test. All'interno della directory della soluzione creare una directory MathService . La struttura di directory e file finora è illustrata di seguito:

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

Impostare MathService sulla directory corrente ed eseguire dotnet new classlib -lang "F#" per creare il progetto di origine. Si creerà un'implementazione non riuscita del servizio matematico:

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

Cambia la directory tornando alla directory unit-testing-with-fsharp. Eseguire dotnet sln add .\MathService\MathService.fsproj per aggiungere il progetto di libreria di classi alla soluzione.

Creazione del progetto di test

Creare quindi la directory MathService.Tests . La seguente illustrazione mostra la struttura della directory:

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

Impostare la directory MathService.Tests nella directory corrente e creare un nuovo progetto usando dotnet new mstest -lang "F#". Verrà creato un progetto di test che usa MSTest come framework di test. Il modello generato configura il test runner in MathServiceTests.fsproj:

<ItemGroup>
  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0-preview-20170628-02" />
  <PackageReference Include="MSTest.TestAdapter" Version="1.1.18" />
  <PackageReference Include="MSTest.TestFramework" Version="1.1.18" />
</ItemGroup>

Il progetto di test richiede altri pacchetti per creare ed eseguire unit test. dotnet new ha aggiunto MSTest nel passaggio precedente. Aggiungere ora la libreria di classi MathService come altra dipendenza al progetto. Usare il comando dotnet reference add:

dotnet reference add ../MathService/MathService.fsproj

È possibile visualizzare l'intero file nel repository degli esempi su GitHub.

Il layout finale della soluzione è il seguente:

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

Esegui dotnet sln add .\MathService.Tests\MathService.Tests.fsproj nella directory unit-testing-with-fsharp.

Creazione del primo test

Si scrive un test con esito negativo, si passa, quindi si ripete il processo. Aprire Tests.fs e aggiungere il codice seguente:

namespace MathService.Tests

open System
open Microsoft.VisualStudio.TestTools.UnitTesting
open MathService

[<TestClass>]
type TestClass () =

    [<TestMethod>]
    member this.TestMethodPassing() =
        Assert.IsTrue(true)

    [<TestMethod>]
     member this.FailEveryTime() = Assert.IsTrue(false)

L'attributo [<TestClass>] indica una classe che contiene test. L'attributo [<TestMethod>] indica un metodo di test eseguito dal test runner. Dalla directory unit-testing-with-fsharp eseguire dotnet test per compilare i test e la libreria di classi e quindi eseguire i test. Lo strumento esecutore di test MSTest contiene il punto di ingresso del programma per eseguire i test. dotnet test avvia lo strumento di esecuzione dei test usando il progetto di test unitario che hai creato.

Questi due test mostrano i test più basilari che vengono superati e quelli che non vengono superati. My test passa e Fail every time fallisce. Creare ora un test per il squaresOfOdds metodo . Il squaresOfOdds metodo restituisce un elenco dei quadrati di tutti i valori interi dispari che fanno parte della sequenza di input. Invece di provare a scrivere tutte queste funzioni contemporaneamente, è possibile creare in modo iterativo test che convalidano la funzionalità. L'esecuzione di ogni passaggio di test implica la creazione della funzionalità necessaria per il metodo .

Il test più semplice che possiamo scrivere consiste nel chiamare squaresOfOdds con tutti i numeri pari, dove il risultato deve essere una sequenza vuota di numeri interi. Ecco questo test:

[<TestMethod>]
member this.TestEvenSequence() =
    let expected = Seq.empty<int> |> Seq.toList
    let actual = MyMath.squaresOfOdds [2; 4; 6; 8; 10]
    Assert.AreEqual(expected, actual)

Si noti che la expected sequenza è stata convertita in un elenco. La libreria MSTest si basa su molti tipi .NET standard. Questa dipendenza significa che l'interfaccia pubblica e i risultati previsti supportano ICollection anziché IEnumerable.

Quando esegui il test, vedrai che il tuo test fallisce. L'implementazione non è ancora stata creata. Eseguire questo test scrivendo il codice più semplice nella classe Mathservice che funziona:

let squaresOfOdds xs =
    Seq.empty<int> |> Seq.toList

Nella directory unit-testing-with-fsharp eseguire dotnet test di nuovo. Il comando dotnet test esegue una compilazione per il progetto MathService e quindi per il progetto MathService.Tests. Dopo la compilazione di entrambi i progetti, viene eseguito questo singolo test. Passa.

Completamento dei requisiti

Ora che hai superato un test, è il momento di scrivere altri test. Il caso semplice successivo funziona con una sequenza il cui solo numero dispari è 1. Il numero 1 è più facile perché il quadrato di 1 è 1. Ecco il test successivo:

[<TestMethod>]
member public this.TestOnesAndEvens() =
    let expected = [1; 1; 1; 1]
    let actual = MyMath.squaresOfOdds [2; 1; 4; 1; 6; 1; 8; 1; 10]
    Assert.AreEqual(expected, actual)

L'esecuzione di dotnet test fallisce il nuovo test. È necessario aggiornare il squaresOfOdds metodo per gestire questo nuovo test. È necessario filtrare tutti i numeri pari fuori dalla sequenza per passare questo test. A tale scopo, scrivere una piccola funzione di filtro e usare Seq.filter:

let private isOdd x = x % 2 <> 0

let squaresOfOdds xs =
    xs
    |> Seq.filter isOdd |> Seq.toList

Si noti la chiamata a Seq.toList. In questo modo viene creato un elenco, che implementa l'interfaccia ICollection .

C'è un altro passo da fare: quadrare ciascuno dei numeri dispari. Iniziare scrivendo un nuovo test:

[<TestMethod>]
member public this.TestSquaresOfOdds() =
    let expected = [1; 9; 25; 49; 81]
    let actual = MyMath.squaresOfOdds [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
    Assert.AreEqual(expected, actual)

È possibile correggere il test trasmettendo la sequenza filtrata attraverso un'operazione di mappatura per calcolare il quadrato di ogni numero dispari.

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

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

Hai creato una piccola libreria e un set di test unitari per tale libreria. La soluzione è stata strutturata in modo che l'aggiunta di nuovi pacchetti e test faccia parte del normale flusso di lavoro. La maggior parte del tempo e dello sforzo è stata concentrata sulla risoluzione degli obiettivi dell'applicazione.

Vedere anche

  • Last updated on