Fluxo de trabalho de teste de Haskell

Acabei de começar um novo projeto Haskell e queria configurar um bom fluxo de trabalho de teste desde o início. Parece que Haskell tem muitas ferramentas de teste excelentes e exclusivas e muitas maneiras diferentes de integrá-las.

Eu pesquisei:

• HUnit
• Checagem rápida
• supino
• HPC
• complexidade

Todos parecem funcionar muito bem em seus domínios, mas estou procurando uma abordagem abrangente para testes e gostaria de saber o que funcionou bem para outras pessoas.

Obter testes de unidade, cobertura de código e benchmarks corretos é principalmente sobre escolher as ferramentas certas.

• test-framework fornece um balcão único para executar todos os seus casos de teste HUnit e propriedades QuickCheck de um único chicote.
• A cobertura do código é integrada ao GHC na forma da ferramenta HPC .
• A Criterion fornece algumas ótimas máquinas de benchmarking

Usarei como exemplo de execução um pacote que acabei de ativar com testes de unidade, cobertura de código e benchmarks:

http://github.com/ekmett/speculation

Você pode integrar seus testes e benchmarks diretamente em seu arquivo de cabal, adicionando seções para eles, e mascarando-os atrás de sinalizadores para que eles não façam isso de forma que todos os usuários de sua biblioteca tenham acesso (e queiram usar para si próprios ) a versão exata das ferramentas de teste que você escolheu.

http://github.com/ekmett/speculation/blob/master/speculation.cabal

Então, você pode contar à cabal como executar seu conjunto de testes. Como o teste de cabala ainda não existe - temos um aluno trabalhando nisso para o verão de código deste ano! - o melhor mecanismo que temos é aqui como usar o mecanismo de gancho do usuário da cabal. Isso significa mudar para uma construção 'Custom' com cabal e configurar um testHook. Um exemplo de testHook que executa um programa de teste escrito com test-framework e, em seguida, aplica hpc ao perfil dele pode ser encontrado aqui:

http://github.com/ekmett/speculation/blob/master/Setup.lhs

E então você pode usar o test-framework para agrupar os testes QuickCheck e HUnit em um programa:

http://github.com/ekmett/speculation/blob/master/Test.hs

O arquivo cabal tem o cuidado de ativar -fhpc para habilitar o teste de cobertura de código e, em seguida, o testHook em Setup.lhs executa manualmente o hpc e grava sua saída em seu diretório dist.

Para benchmarking, a história é um pouco mais manual, não há opção de 'benchmark cabal'. Você poderia conectar seus benchmarks em seu gancho de teste, mas eu gosto de executá-los manualmente, uma vez que o Criterion tem muitas opções de relatórios gráficos. Você pode adicionar seus benchmarks ao arquivo de cabala conforme mostrado acima, dar-lhes sinalizadores de compilação separados, ocultá-los atrás de um sinalizador de cabala e, em seguida, usar o critério para fazer todo o trabalho pesado:

http://github.com/ekmett/speculation/blob/master/Benchmark.hs

Você pode então executar seus benchmarks a partir da linha de comando e obter janelas pop-up do KDE com resultados de benchmarks, etc.

Já que, na prática, você está vivendo em cabala enquanto desenvolve o código Haskell, faz muito sentido integrar seu conjunto de ferramentas a ele.

Edit : O suporte ao teste Cabal agora existe. Consulte http://www.haskell.org/cabal/release/cabal-latest/doc/users-guide/developing-packages.html#test-suites

A abordagem é defendida em RWH ch 11 e em XMonad é aproximadamente:

• Indique todas as propriedades do sistema no QuickCheck
• Mostre a cobertura do teste com HPC.
• Confirme o comportamento do espaço com o perfil de heap .
• Confirme o comportamento de thread / paralelo com ThreadScope .
• Confirme o comportamento do microbenchmark com o Critério .

Depois que suas invariantes principais forem estabelecidas por meio do QuickCheck, você pode começar a refatorar, movendo esses testes para invariantes de tipo.

Práticas para apoiar seus esforços:

• Execute uma regressão QuickCheck simplificada em cada confirmação.
• Publique detalhes de cobertura de HPC.

O pacote test-framework é realmente incrível. Você pode integrar facilmente os testes HUnit e QuickCheck e obter executáveis ​​que executam apenas suítes especificadas, com base em sinalizadores de linha de comando, com vários destinos de saída.

Testar e criar perfis são feras diferentes. Para a criação de perfil, eu configuraria um executável separado que enfatiza apenas a seção que você deseja criar o perfil, e apenas observando cuidadosamente os resultados das compilações e execuções de criação de perfil (com -prof-auto-all para compilação e + RTS -p para um tempo de execução bandeira).

Para testes, confio nas propriedades HUnit e QuickCheck e uso o Haskell Test Framework para coletar todos os testes de unidade e todas as propriedades QuickCheck automaticamente.

Aviso: Sou o principal desenvolvedor do Haskell Test Framework.