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 no .NET.

Quando Ativar

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

Pilha 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 ao F# para xUnit
Unquote	Biblioteca de asserção que usa 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 muda 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 "esperado X, recebido Y".

module OrderValidationTests

open Xunit
open Swensen.Unquote

[<Fact>]
let ``PlaceOrder retorna sucesso quando 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 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 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 mantém identidade`` (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ções (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 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 encontrado`` () = 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

Antipadrões Comuns

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

Skills Relacionadas

• 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 ao 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 do teste
dotnet test --filter "FullyQualifiedName~OrderService"

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