Adicionar um teste

Agora que você deixou seu código em um estado estável (bom trabalho, aliás), adicione um teste. Testar seu código durante o desenvolvimento pode expor bugs que se infiltram à medida que você faz mudanças. Neste tópico, você adiciona um teste para a função Hello.

O suporte nativo do Go a testes unitários facilita testar enquanto você programa. Especificamente, usando convenções de nomes, o pacote testing do Go e o comando go test, você pode escrever e executar testes rapidamente.

  1. No diretório greetings, crie um arquivo chamado greetings_test.go.

    Terminar o nome de um arquivo com _test.go informa ao comando go test que esse arquivo contém funções de teste.

  2. Em greetings_test.go, cole o código a seguir e salve o arquivo.
    package greetings
    
    import (
        "testing"
        "regexp"
    )
    
    // TestHelloName calls greetings.Hello with a name, checking
    // for a valid return value.
    func TestHelloName(t *testing.T) {
        name := "Gladys"
        want := regexp.MustCompile(`\b`+name+`\b`)
        msg, err := Hello("Gladys")
        if !want.MatchString(msg) || err != nil {
            t.Errorf(`Hello("Gladys") = %q, %v, want match for %#q, nil`, msg, err, want)
        }
    }
    
    // TestHelloEmpty calls greetings.Hello with an empty string,
    // checking for an error.
    func TestHelloEmpty(t *testing.T) {
        msg, err := Hello("")
        if msg != "" || err == nil {
            t.Errorf(`Hello("") = %q, %v, want "", error`, msg, err)
        }
    }
    

    Neste código, você:

    • Implementa as funções de teste no mesmo pacote do código que está testando.
    • Cria duas funções de teste para testar a função greetings.Hello. Os nomes das funções de teste têm a forma TestNome, em que Nome diz algo sobre o teste específico. Além disso, as funções de teste recebem como parâmetro um ponteiro para o tipo testing.T do pacote testing. Você usa os métodos desse parâmetro para reportar e registrar logs a partir do seu teste.
    • Implementa dois testes:
      • TestHelloName chama a função Hello, passando um valor name com o qual a função deve conseguir retornar uma mensagem de resposta válida. Se a chamada retornar um erro ou uma mensagem de resposta inesperada (uma que não inclua o nome que você passou), você usa o método Errorf do parâmetro t para imprimir uma mensagem no console.
      • TestHelloEmpty chama a função Hello com uma string vazia. Este teste foi feito para confirmar que o seu tratamento de erros funciona. Se a chamada retornar uma string não vazia ou nenhum erro, você usa o método Errorf do parâmetro t para imprimir uma mensagem no console.
  3. Na linha de comando, no diretório greetings, execute o comando go test para executar o teste.

    O comando go test executa as funções de teste (cujos nomes começam com Test) nos arquivos de teste (cujos nomes terminam com _test.go). Você pode adicionar a flag -v para obter uma saída detalhada que lista todos os testes e seus resultados.

    Os testes devem passar.

    $ go test
    PASS
    ok      example.com/greetings   0.364s
    
    $ go test -v
    === RUN   TestHelloName
    --- PASS: TestHelloName (0.00s)
    === RUN   TestHelloEmpty
    --- PASS: TestHelloEmpty (0.00s)
    PASS
    ok      example.com/greetings   0.372s
    
  4. Quebre a função greetings.Hello para ver um teste falhando.

    A função de teste TestHelloName verifica o valor de retorno para o nome que você especificou como parâmetro da função Hello. Para ver o resultado de um teste falhando, altere a função greetings.Hello para que ela não inclua mais o nome.

    Em greetings/greetings.go, cole o código a seguir no lugar da função Hello. Observe que as linhas destacadas mudam o valor que a função retorna, como se o argumento name tivesse sido removido por engano.

    // Hello returns a greeting for the named person.
    func Hello(name string) (string, error) {
        // If no name was given, return an error with a message.
        if name == "" {
            return name, errors.New("empty name")
        }
        // Create a message using a random format.
        // message := fmt.Sprintf(randomFormat(), name)
        message := fmt.Sprint(randomFormat())
        return message, nil
    }
    
  5. Na linha de comando, no diretório greetings, execute go test para executar o teste.

    Desta vez, execute go test sem a flag -v. A saída vai incluir resultados apenas dos testes que falharam, o que pode ser útil quando você tem muitos testes. O teste TestHelloName deve falhar -- TestHelloEmpty continua passando.

    $ go test
    --- FAIL: TestHelloName (0.00s)
        greetings_test.go:15: Hello("Gladys") = "Hail, %v! Well met!", <nil>, want match for `\bGladys\b`, nil
    FAIL
    exit status 1
    FAIL    example.com/greetings   0.182s
    

No próximo (e último) tópico, você verá como compilar e instalar seu código para executá-lo localmente.