fsharp-testing

Padrões de Teste em F#

Padrões abrangentes de teste para aplicações F# usando xUnit, FsUnit, Unquote, FsCheck e práticas modernas de teste .NET.

Quando Ativar

• Escrevendo novos testes para código F#
• Revisando qualidade e cobertura de testes
• Configurando infraestrutura de teste para projetos F#
• Depurando testes lentos ou instáveis

Stack de Frameworks de Teste

Ferramenta	Propósito
xUnit	Framework de teste (escolha padrão do ecossistema .NET)
FsUnit.xUnit	Sintaxe de asserção amigável para F# com xUnit
Unquote	Biblioteca de asserção usando citações F# para mensagens de falha claras
FsCheck.xUnit	Testes baseados em propriedades integrados com xUnit
NSubstitute	Mock de dependências .NET
Testcontainers	Infraestrutura real em testes de integração
WebApplicationFactory	Testes de integração ASP.NET Core

Testes Unitários com xUnit + FsUnit

Estrutura Básica de Teste

module OrderServiceTests

open Xunit
open FsUnit.Xunit

[<Fact>]
let ``create define status como Pendente`` () =
    let order = Order.create "cust-1" [ validItem ]
    order.Status |> should equal Pending

[<Fact>]
let ``confirm altera status para Confirmado`` () =
    let order = Order.create "cust-1" [ validItem ]
    let confirmed = Order.confirm order
    confirmed.Status |> should be (ofCase <@ Confirmed @>)

Asserções com Unquote

Unquote usa citações F# para que as mensagens de falha mostrem a expressão completa que falhou, não apenas "esperava X, obteve Y".

module OrderValidationTests

open Xunit
open Swensen.Unquote

[<Fact>]
let ``PlaceOrder retorna sucesso quando a requisição é válida`` () =
    let request = { CustomerId = "cust-123"; Items = [ validItem ] }
    let result = OrderService.placeOrder request
    test <@ Result.isOk result @>

[<Fact>]
let ``total do pedido soma preços dos itens`` () =
    let items = [ { Sku = "A"; Quantity = 2; Price = 10m }
                  { Sku = "B"; Quantity = 1; Price = 5m } ]
    let total = Order.calculateTotal items
    test <@ total = 25m @>

[<Fact>]
let ``email validado rejeita entrada vazia`` () =
    let result = ValidatedEmail.create ""
    test <@ Result.isError result @>

Testes Assíncronos

[<Fact>]
let ``PlaceOrder retorna sucesso quando a requisição é válida`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "cust-123"; Items = [ validItem ] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isOk result @>
}

[<Fact>]
let ``PlaceOrder retorna erro quando os itens estão vazios`` () = task {
    let deps = createTestDeps ()
    let request = { CustomerId = "cust-123"; Items = [] }

    let! result = OrderService.placeOrder deps request

    test <@ Result.isError result @>
}

Testes Parametrizados com Theory

[<Theory>]
[<InlineData("")>]
[<InlineData("   ")>]
let ``PlaceOrder rejeita ID de cliente vazio`` (customerId: string) =
    let request = { CustomerId = customerId; Items = [ validItem ] }
    let result = OrderService.placeOrder request
    result |> should be (ofCase <@ Error @>)

[<Theory>]
[<InlineData("", false)>]
[<InlineData("a", false)>]
[<InlineData("[email protected]", true)>]
[<InlineData("[email protected]", true)>]
let ``IsValidEmail retorna resultado esperado`` (email: string, expected: bool) =
    test <@ EmailValidator.isValid email = expected @>

Testes Baseados em Propriedades com FsCheck

Usando FsCheck.xUnit

open FsCheck
open FsCheck.Xunit

[<Property>]
let ``total do pedido é sempre não negativo`` (items: NonEmptyList<PositiveInt * decimal>) =
    let orderItems =
        items.Get
        |> List.map (fun (qty, price) ->
            { Sku = "SKU"; Quantity = qty.Get; Price = abs price })
    let total = Order.calculateTotal orderItems
    total >= 0m

[<Property>]
let ``serialização ida e volta`` (order: Order) =
    let json = JsonSerializer.Serialize order
    let deserialized = JsonSerializer.Deserialize<Order> json
    deserialized = order

Geradores Personalizados

type OrderGenerators =
    static member ValidEmail () =
        gen {
            let! user = Gen.elements [ "alice"; "bob"; "carol" ]
            let! domain = Gen.elements [ "example.com"; "test.org" ]
            return $"{user}@{domain}"
        }
        |> Arb.fromGen

[<Property(Arbitrary = [| typeof<OrderGenerators> |])>]
let ``emails válidos passam na validação`` (email: string) =
    EmailValidator.isValid email

Mock de Dependências

Stubs de Função (Preferido)

let createTestDeps () =
    let mutable savedOrders = []
    { FindOrder = fun id -> task { return Map.tryFind id testData }
      SaveOrder = fun order -> task { savedOrders <- order :: savedOrders }
      SendNotification = fun _ -> Task.CompletedTask }

[<Fact>]
let ``PlaceOrder salva o pedido confirmado`` () = task {
    let mutable saved = []
    let deps =
        { createTestDeps () with
            SaveOrder = fun order -> task { saved <- order :: saved } }

    let! _ = OrderService.placeOrder deps validRequest

    test <@ saved.Length = 1 @>
}

NSubstitute para Interfaces .NET

open NSubstitute

[<Fact>]
let ``chama repositório com o ID correto`` () = task {
    let repo = Substitute.For<IOrderRepository>()
    repo.FindByIdAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
        .Returns(Task.FromResult(Some testOrder))

    let service = OrderService(repo)
    let! _ = service.GetOrder(testOrder.Id, CancellationToken.None)

    do! repo.Received(1).FindByIdAsync(testOrder.Id, Arg.Any<CancellationToken>())
}

Testes de Integração ASP.NET Core

type OrderApiTests (factory: WebApplicationFactory<Program>) =
    interface IClassFixture<WebApplicationFactory<Program>>

    let client =
        factory.WithWebHostBuilder(fun builder ->
            builder.ConfigureServices(fun services ->
                services.RemoveAll<DbContextOptions<AppDbContext>>() |> ignore
                services.AddDbContext<AppDbContext>(fun options ->
                    options.UseInMemoryDatabase("TestDb") |> ignore) |> ignore))
            .CreateClient()

    [<Fact>]
    member _.``GET order retorna 404 quando não encontrada`` () = task {
        let! response = client.GetAsync($"/api/orders/{Guid.NewGuid()}")
        test <@ response.StatusCode = HttpStatusCode.NotFound @>
    }

Organização de Testes

tests/
  MyApp.Tests/
    Unit/
      OrderServiceTests.fs
      PaymentServiceTests.fs
    Integration/
      OrderApiTests.fs
      OrderRepositoryTests.fs
    Properties/
      OrderPropertyTests.fs
    Helpers/
      TestData.fs
      TestDeps.fs

Anti-Padrões Comuns

Anti-Padrão	Correção
Testar detalhes de implementação	Testar comportamento e resultados
Estado compartilhado mutável entre testes	Estado novo por teste
Thread.Sleep em testes assíncronos	Usar Task.Delay com timeout ou helpers de polling
Asserção em saída de sprintf	Asserção em valores tipados e pattern matches
Ignorar CancellationToken	Sempre passar e verificar cancelamento
Pular testes baseados em propriedades	Usar FsCheck para qualquer função com invariantes claros

Skills Relacionados

• dotnet-patterns - Padrões idiomáticos .NET, injeção de dependência e arquitetura
• csharp-testing - Padrões de teste em C# (infraestrutura compartilhada como WebApplicationFactory e Testcontainers também se aplica a F#)

Executando Testes

# Executar todos os testes
dotnet test

# Executar com cobertura
dotnet test --collect:"XPlat Code Coverage"

# Executar projeto específico
dotnet test tests/MyApp.Tests/

# Filtrar por nome de teste
dotnet test --filter "FullyQualifiedName~OrderService"

# Modo watch durante desenvolvimento
dotnet watch test --project tests/MyApp.Tests/