Testando na trilha de YAMLScript

Testar soluções de exercícios do Exercism escritas em YAMLScript é extremamente fácil. Fácil de rodar e fácil de entender.

Basta rodar make test no diretório do exercício.

Na primeira vez que você rodar make test, todos os testes vão falhar, simplesmente porque você ainda não escreveu nenhum código para resolver os testes.

O processo normal de desenvolvimento de um exercício é começar com make test e depois se concentrar em um teste de cada vez, escrevendo código para fazer aquele teste passar. Quando todos os testes passarem, você terminou!

De bônus, rodar make test também garante que a versão correta do intérprete ys do YAMLScript (a exigida pelo exercício atual) esteja instalada no lugar certo (em /path/to/exercism/yamlscript/.local/). Isso significa que você nem precisa instalar o ys antes para começar!

Estrutura de um diretório de exercício

Se você está trabalhando em um exercício chamado the-great-exercise, então exercism download --exercise=the-great-exercise --track=yamlscript vai criar o diretório /path/to/exercism/yamlscript/the-great-exercise.

Dentro desse diretório, o arquivo de teste se chamará the-great-exercise-test.ys e o arquivo do programa de solução se chamará the-great-exercise.ys. Também haverá um arquivo README.md com a descrição do exercício e um arquivo HELP.md com algumas informações úteis caso você fique travado.

Haverá dois arquivos para o make: Makefile e GNUmakefile. Isso serve para garantir, sem trocadilho, que você está usando o GNU make para rodar os testes, e não algum outro comando make que possa estar instalado no seu sistema. O GNUmakefile é o de verdade, e o GNU make sempre vai preferi-lo ao Makefile. Outros comandos make vão usar o Makefile, que deve dar erro com uma mensagem dizendo para você usar o GNU make!

Anatomia de um arquivo de teste

Os testes do YAMLScript são escritos em YAMLScript, é claro! Como YAMLScript é YAML e YAML é dados, os testes são basicamente só dados.

Veja um exemplo de um arquivo de teste simples. Na verdade, são os 3 primeiros testes do exercício acronym. :-)

#!/usr/bin/env ys-0

use ys::taptest: :all
load: 'acronym.ys'

test::
- name: Basic
  code: abbreviate('Portable Network Graphics')
  want: PNG

- name: Lowercase words
  code: abbreviate('Ruby on Rails')
  want: ROR

- name: Punctuation
  code: abbreviate('First In, First Out')
  want: FIFO

done: 3

A primeira linha é uma linha shebang que diz ao comando prove (executado pelo Makefile) para usar o intérprete ys do YAMLScript para rodar os testes, em vez do perl, que é o padrão do prove.

A segunda linha é uma instrução use que carrega a biblioteca de testes ys::taptest TAP do YAMLScript.

Observação: TAP é uma interface simples, baseada em texto, entre scripts de teste e harnesses de teste, e o prove é o harness padrão para rodar testes TAP em Perl. Como Perl está em toda parte, usar TAP e prove acaba sendo uma ótima escolha para suítes de teste em muitas linguagens (incluindo YAMLScript).

A instrução use carrega o programa de solução acronym.ys, para que este arquivo de teste o esteja testando.

Todos os nossos testes ficam em uma sequência YAML sob a chave test.

A última linha, done:, é obrigatória e informa ao harness de teste que todos os testes realmente rodaram. O número (que é opcional) é a quantidade de testes que esperávamos rodar.

Cada teste (sob a chave test) é um mapeamento com estes pares chave/valor:

• name: - O rótulo do teste, que é impresso pelo prove -v.
• code: - O código YAMLScript a rodar. Esse código vai chamar alguma função no programa de solução em que estamos trabalhando.
• what: - Para testes que esperam que ocorra um erro, o valor é error. Em testes normais, o par não está presente.
• want: - O resultado esperado do teste. É um valor YAML e pode ser uma string, um número, um boolean, uma sequência ou um mapa. Se what: for error, então esse valor é a mensagem de erro esperada.
• SKIP: - Defina como true para pular a execução desse teste.
• ONLY: - Defina como true para rodar apenas esse teste. Se você tiver mais de um teste com ONLY:, cada um deles será rodado.

Isso deve ser tudo que você precisa saber para fazer desenvolvimento guiado por testes em YAMLScript nos exercícios do Exercism!

A biblioteca ys::taptest tem outros recursos que você pode usar para escrever testes mais complexos, mas os testes do Exercism já foram escritos para você. Para saber mais sobre a biblioteca ys::taptest, consulte a documentação.