Desenvolvimento F # e teste de unidade?

Acabei de começar com F #, que é minha primeira linguagem funcional. Tenho trabalhado quase exclusivamente com C # e gosto muito de como o F # me leva a repensar como escrevo código. Um aspecto que considero um pouco desorientador é a mudança no processo de escrever código. Tenho usado o TDD há anos em C # e realmente aprecio ter testes de unidade para saber onde estou.

Até agora, meu processo com o F # tem sido escrever algumas funções, brincar com elas com o console interativo até estar "razoavelmente" certo de que funcionam e ajustar e combinar. Isso funciona bem em problemas de pequena escala como o Projeto Euler, mas não consigo imaginar construir algo grande dessa forma.

Como as pessoas abordam o teste de unidade e a construção de um conjunto de testes para um programa F #? Existe um equivalente ao TDD? Quaisquer sugestões ou pensamentos são apreciados.

Os desenvolvedores orientados a testes devem se sentir em casa em linguagens funcionais como F #: pequenas funções que fornecem resultados deterministicamente repetíveis se prestam perfeitamente a testes de unidade. Também existem recursos na linguagem F # que facilitam a escrita de testes. Considere, por exemplo, Expressões de Objeto . Você pode facilmente escrever falsificações para funções que tomam como entrada um tipo de interface.

De qualquer forma, F # é uma linguagem orientada a objetos de primeira classe e você pode usar as mesmas ferramentas e truques que usa ao fazer TDD em C #. Existem também algumas ferramentas de teste escritas em ou especificamente para F #:

• NaturalSpec
• FsCheck
• FsTest
• FsUnit

Matthew Podwysocki escreveu uma ótima série sobre testes de unidade em linguagens funcionais. Tio Bob também escreveu um artigo instigante aqui .

Eu uso o NUnit e não me parece tão difícil de ler ou oneroso de escrever:

open NUnit.Framework

[<TestFixture>]
type myFixture() = class

    [<Test>]
    member self.myTest() =
       //test code

end

Como meu código é uma mistura de F # e outras linguagens .Net, gosto do fato de escrever os testes de unidade basicamente da mesma maneira e com sintaxe semelhante em F # e C #.

Dê uma olhada no FsCheck , uma ferramenta de teste automática para F #, é basicamente uma versão do QuickCheck de Haskell. Ele permite que você forneça uma especificação do programa, na forma de propriedades que as funções ou métodos devem satisfazer, e o FsCheck testa que as propriedades mantêm em um grande número de casos gerados aleatoriamente.

Página FsCheck CodePlex

Página do autor FsCheck

Como o dglaubman sugere, você pode usar o NUnit. xUnit.net também fornece suporte para isso e funciona bem com TestDriven.net . O código é semelhante aos testes NUnit, mas sem a necessidade de envolver o teste em um tipo de contenção.

#light

// Supply a module name here not a combination of module and namespace, otherwise
// F# cannot resolve individual tests nfrom the UI.
module NBody.DomainModel.FSharp.Tests

open System
open Xunit

open Internal

[<Fact>]
let CreateOctantBoundaryReordersMinMax() =
    let Max = VectorFloat(1.0, 1.0, 1.0)
    let Min = VectorFloat(-1.0, -1.0, -1.0)

    let result = OctantBoundary.create Min Max

    Assert.Equal(Min, result.Min)     
    Assert.Equal(Max, result.Max) 

Acho que esta é uma questão muito interessante, sobre a qual eu mesmo me questiono muito. Meus pensamentos até agora são apenas pensamentos, então aceite-os como são.

Acho que a rede de segurança de um conjunto de testes automatizados é um ativo valioso demais para ser deixado de lado, por mais atraente que o console interativo possa ser, então pretendo continuar escrevendo testes de unidade como sempre fiz.

Um dos principais pontos fortes do .NET são os recursos de várias linguagens. Eu sei que estarei escrevendo código de produção em F # em breve, mas meu plano é escrever testes de unidade em C # para facilitar meu caminho para o que para mim é uma nova linguagem. Dessa forma, também posso testar se o que escrevo em F # será compatível com C # (e outras linguagens .NET).

Com essa abordagem, entendo que existem certos recursos do F # que só posso usar internamente em meu código F #, mas não expor como parte da minha API pública, mas vou aceitar isso, assim como aceito hoje que há certas coisas C # me permite expressar (como uint) que não são compatíveis com CLS e, portanto, evito usá-los.

Você poderia dar uma olhada no FSUnit - embora eu não o tenha usado ainda, vale a pena tentar. Certamente melhor do que usar, por exemplo, NUnit (nativo) em F #.

Apesar de estar um pouco atrasado para a festa, gostaria de dar as boas-vindas a Mathias em F # (antes tarde do que nunca;)) e avisar que você pode gostar de Expecto

Expecto tem alguns recursos de que você pode gostar:

• Sintaxe de F # em toda, testes como valores; escreva F # simples para gerar testes
• Use o módulo Expect integrado ou uma biblioteca externa como Unquote para asserções
• Testes paralelos por padrão
• Teste seu código Hopac ou código Async; Expecto é totalmente assíncrono
• Registro e métricas plugáveis ​​via Logary Facade; escrever facilmente adaptadores para sistemas de construção ou usar o mecanismo de tempo para construir um painel InfluxDB + Grafana dos tempos de execução de seus testes
• Suporte integrado para BenchmarkDotNet
• Construir em suporte para FsCheck; torna mais fácil construir testes com dados gerados / aleatórios ou construir modelos invariantes do espaço de estado do seu objeto / ator

-

open Expecto

let tests =
  test "A simple test" {
    let subject = "Hello World"
    Expect.equal subject "Hello World" "The strings should equal"
  }

[<EntryPoint>]
let main args =
  runTestsWithArgs defaultConfig args tests

https://github.com/haf/expecto/