El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Proves Unitàries amb NUnit

Següent ►
►

Les proves unitàries són una part essencial del desenvolupament de programari, ja que permeten verificar que les unitats individuals de codi funcionin correctament. En aquest tema, aprendrem a utilitzar NUnit, un marc de proves popular per a .NET, per escriure i executar proves unitàries en F#.

Continguts

  1. Introducció a NUnit
  2. Configuració de l'Entorn
  3. Estructura d'una Prova Unitària
  4. Escriure Proves Unitàries en F#
  5. Executar Proves Unitàries
  6. Exercicis Pràctics

  1. Introducció a NUnit

NUnit és un marc de proves unitàries per a .NET que permet als desenvolupadors escriure proves per verificar el comportament del seu codi. NUnit proporciona una API rica per definir i executar proves, així com per verificar els resultats esperats.

Característiques Clau de NUnit

  • Atributs de Prova: Permeten marcar mètodes com a proves.
  • Assert: Proporciona mètodes per verificar condicions.
  • Categories de Prova: Permeten agrupar proves per facilitar-ne l'execució.
  • Configuració i Desconfiguració: Permeten inicialitzar i netejar recursos abans i després de les proves.

  1. Configuració de l'Entorn

Abans de començar a escriure proves unitàries, necessitem configurar el nostre entorn de desenvolupament.

Passos per Configurar l'Entorn

  1. Instal·lar NUnit: Afegiu NUnit al vostre projecte F# utilitzant NuGet.

    dotnet add package NUnit
dotnet add package NUnit3TestAdapter
dotnet add package Microsoft.NET.Test.Sdk

  2. Crear un Projecte de Proves: Creeu un projecte de proves separat si encara no en teniu un.

    dotnet new nunit -n MyFSharpTests
cd MyFSharpTests

  3. Afegir Referència al Projecte Principal: Assegureu-vos que el projecte de proves tingui una referència al projecte principal.

    dotnet add reference ../MyFSharpProject/MyFSharpProject.fsproj

  1. Estructura d'una Prova Unitària

Una prova unitària en NUnit es defineix com un mètode marcat amb l'atribut [<Test>]. Aquí teniu un exemple bàsic:

open NUnit.Framework

[<TestFixture>]
type MyTests() =

    [<Test>]
    member this.``Test Example``() =
        Assert.AreEqual(4, 2 + 2)

Explicació del Codi

  • [<TestFixture>]: Marca una classe que conté proves.
  • [<Test>]: Marca un mètode com a prova.
  • Assert.AreEqual(expected, actual): Verifica que el valor actual sigui igual al valor esperat.

  1. Escriure Proves Unitàries en F#

Ara que tenim la configuració bàsica, escrivim algunes proves unitàries per a una funció simple.

Exemple de Funció a Provar

module MyMath =
    let add x y = x + y

Proves Unitàries per a la Funció add

open NUnit.Framework
open MyMath

[<TestFixture>]
type MyMathTests() =

    [<Test>]
    member this.``Add 2 and 3 should equal 5``() =
        let result = add 2 3
        Assert.AreEqual(5, result)

    [<Test>]
    member this.``Add -1 and 1 should equal 0``() =
        let result = add -1 1
        Assert.AreEqual(0, result)

Explicació del Codi

  • let result = add 2 3: Crida la funció add amb els arguments 2 i 3.
  • Assert.AreEqual(5, result): Verifica que el resultat sigui 5.

  1. Executar Proves Unitàries

Per executar les proves unitàries, utilitzeu la següent comanda:

dotnet test

Aquesta comanda compilarà el projecte de proves i executarà totes les proves definides.

  1. Exercicis Pràctics

Exercici 1: Escriure Proves per a una Funció de Multiplicació

  1. Creeu una funció multiply que multipliqui dos nombres.
  2. Escriu proves unitàries per verificar el comportament de la funció multiply.

Solució

module MyMath =
    let multiply x y = x * y

open NUnit.Framework
open MyMath

[<TestFixture>]
type MyMathTests() =

    [<Test>]
    member this.``Multiply 2 and 3 should equal 6``() =
        let result = multiply 2 3
        Assert.AreEqual(6, result)

    [<Test>]
    member this.``Multiply -1 and 1 should equal -1``() =
        let result = multiply -1 1
        Assert.AreEqual(-1, result)

Exercici 2: Escriure Proves per a una Funció de Divisió

  1. Creeu una funció divide que divideixi dos nombres.
  2. Escriu proves unitàries per verificar el comportament de la funció divide, incloent-hi la divisió per zero.

Solució

module MyMath =
    let divide x y =
        if y = 0 then failwith "Cannot divide by zero"
        else x / y

open NUnit.Framework
open MyMath

[<TestFixture>]
type MyMathTests() =

    [<Test>]
    member this.``Divide 6 by 3 should equal 2``() =
        let result = divide 6 3
        Assert.AreEqual(2, result)

    [<Test>]
    member this.``Divide by zero should throw exception``() =
        Assert.Throws<System.Exception>(fun () -> divide 6 0 |> ignore)

Conclusió

En aquesta secció, hem après a configurar l'entorn per a proves unitàries amb NUnit, a escriure i executar proves unitàries en F#, i hem practicat amb alguns exercicis. Les proves unitàries són una eina poderosa per assegurar la qualitat del codi i detectar errors de manera primerenca en el procés de desenvolupament.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats