Estruturas, métodos e interfaces
Suponha que precisamos de algum código de geometria para calcular o perímetro de um retângulo dado uma altura e largura. Podemos escrever uma função
Perimetro(largura float64, altura float64), onde float64 representa números em ponto flutuante como 123.45.O ciclo de TDD deve ser mais familiar para você agora.
func TestPerimetro(t *testing.T) {
resultado := Perimetro(10.0, 10.0)
esperado := 40.0
if resultado != esperado {
t.Errorf("resultado %.2f esperado %.2f", resultado, esperado)
}
}
Viu a nova string de formatação? O
f é para nosso float64 e o .2 significa imprimir duas casas decimais../formas_test.go:6:9: undefined: Perimetroindefinido: Perimetrofunc Perimetro(largura float64, altura float64) float64 {
return 0
}
Resulta em
formas_test.go:10: resultado 0, esperado 40.func Perimetro(largura float64, altura float64) float64 {
return 2 * (largura + altura)
}
Por enquanto, tudo fácil. Agora vamos criar uma função chamada
Area(largura, altura float64) que retorna a área de um retângulo.Tente fazer isso sozinho, segundo o ciclo de TDD.
Você deve terminar com os testes como estes:
func TestPerimetro(t *testing.T) {
resultado := Perimetro(10.0, 10.0)
esperado := 40.0
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
}
func TestArea(t *testing.T) {
resultado := Area(12.0, 6.0)
esperado := 72.0
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
}
E código como este:
func Perimetro(largura float64, altura float64) float64 {
return 2 * (largura + altura)
}
func Area(largura float64, altura float64) float64 {
return largura * altura
}
Nosso código faz o trabalho, mas não contém nada explícito sobre retângulos. Uma pessoa descuidada poderia tentar passar a largura e altura de um triângulo para esta função sem perceber que ela retornará uma resposta errada.
Podemos apenas dar para a função um nome mais específico como
AreaDoRetangulo. Uma solução mais limpa é definir nosso próprio tipo chamado Retangulo que encapsula este conceito para nós.Podemos criar um tipo simples usando uma struct (estrutura). Uma struct é apenas uma coleção nomeada de campos onde você pode armazenar dados.
Declare uma
struct assim:type Retangulo struct {
Largura float64
Altura float64
}
Agora vamos refatorar os testes para usar
Retangulo em vez de um simples float64.func TestPerimetro(t *testing.T) {
retangulo := Retangulo{10.0, 10.0}
resultado := Perimetro(retangulo)
esperado := 40.0
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
}
func TestArea(t *testing.T) {
retangulo := Retangulo{12.0, 6.0}
resultado := Area(retangulo)
esperado := 72.0
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
}
Lembre de rodar seus testes antes de tentar corrigir. Você deve ter erro útil como:
./formas_test.go:7:18: not enough arguments in call to Perimetro
have (Retangulo)
esperado (float64, float64)
Você pode acessar os campos de uma
struct com a sintaxe minhaStruct.campo.Mude as duas funções para corrigir o teste.
func Perimetro(retangulo Retangulo) float64 {
return 2 * (retangulo.Largura + retangulo.Altura)
}
func Area(retangulo Retangulo) float64 {
return retangulo.Largura * retangulo.Altura
}
Espero que você concorde que passar um
Retangulo para a função mostra nossa intenção com mais clareza, mas existem mais benefícios em usar structs que já vamos entender.Nosso próximo requisito é escrever uma função
Area para círculos.func TestArea(t *testing.T) {
t.Run("retângulos", func(t *testing.T) {
retangulo := Retangulo{12.0, 6.0}
resultado := Area(retangulo)
esperado := 72.0
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
})
t.Run("círculos", func(t *testing.T) {
circulo := Circulo{10}
resultado := Area(circulo)
esperado := 314.1592653589793
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
})
}
./formas_test.go:28:13: undefined: CirculoPrecisamos definir nosso tipo
Circulo.type Circulo struct {
Raio float64
}
Agora rode os testes novamente.
./formas_test.go:29:14: cannot use circulo (type Circulo) as type Retangulo in argument to AreaAlgumas linguagens de programação permitem você fazer algo como:
func Area(circulo Circulo) float64 { ... }
func Area(retangulo Retangulo) float64 { ... }
Mas em Go você não pode:
./formas.go:20:32: Area redeclared in this blockTemos duas escolhas:
- Podemos ter funções com o mesmo nome declaradas em pacotes diferentes. Então, poderíamos criar nossa
Area(Circulo)em um novo pacote, só que isso parece um exagero aqui.
Até agora só escrevemos funções, mas temos usado alguns métodos. Quando chamamos
t.Errorf, nós chamamos o método Errorf na instância de nosso t (testing.T).Um método é uma função com um receptor. Uma declaração de método vincula um identificador e o nome do método a um método e associa o método com o tipo base do receptor.
Métodos são muito parecidos com funções, mas são chamados invocando-os em uma instância de um tipo específico.
Enquanto você chama funções onde quiser, como por exemplo em
Area(retangulo), você só pode chamar métodos em "coisas" específicas.Um exemplo ajudará. Então, vamos mudar nossos testes primeiro para chamar métodos em vez de funções, e, em seguida, corrigir o código.
func TestArea(t *testing.T) {
t.Run("retângulos", func(t *testing.T) {
retangulo := Retangulo{12.0, 6.0}
resultado := retangulo.Area()
esperado := 72.0
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
})
t.Run("círculos", func(t *testing.T) {
circulo := Circulo{10}
resultado := circulo.Area()
esperado := 314.1592653589793
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
})
}
Se rodarmos os testes agora, recebemos:
./formas_test.go:19:19: retangulo.Area undefined (type Retangulo has no field or method Area)
./formas_test.go:29:16: circulo.Area undefined (type Circulo has no field or method Area)
type Circulo has no field or method Area
Gostaria de reforçar o quão grandioso o compilador é. É muito importante ter tempo para ler lentamente as mensagens de erro que você recebe, pois isso te ajudará a longo prazo.
Vamos adicionar alguns métodos para nossos tipos:
type Retangulo struct {
Largura float64
Altura float64
}
func (r Retangulo) Area() float64 {
return 0
}
type Circulo struct {
Raio float64
}
func (c Circulo) Area() float64 {
return 0
}
A sintaxe para declaração de métodos é quase a mesma que usamos para funções e isso acontece porque eles são muito parecidos. A única diferença é a sintaxe para o método receptor:
func (nomeDoReceptor TipoDoReceptor) NomeDoMetodo(argumentos).Quando seu método é chamado em uma variável desse tipo, você tem sua referência para o dado através da variável
nomeDoReceptor. Em muitas outras linguagens de programação isto é feito implicitamente e você acessa o receptor através de this.É uma convenção em Go que a variável receptora seja a primeira letra do tipo em minúsculo.
r Retangulo
Se você executar novamente os testes, eles devem compilar e dar alguma saída do teste falhando.
Agora vamos fazer nossos testes de retângulo passarem corrigindo nosso novo método.
func (r Retangulo) Area() float64 {
return r.Largura * r.Altura
}
Se você executar novamente os testes, aqueles de retângulo devem passar, mas os de círculo ainda falham.
Para fazer a função
Area de círculo passar, vamos emprestar a constante Pi do pacote math (lembre-se de importá-lo).func (c Circulo) Area() float64 {
return math.Pi * c.Raio * c.Raio
}
Existe duplicação em nossos testes.
Tudo o que queremos fazer é pegar uma coleção de formas, chamar o método
Area() e então verificar o resultado.Queremos ser capazes de escrever um tipo de função
verificaArea que permita passar tanto Retangulo quanto Circulo, mas falhe ao compilar se tentarmos passar algo que não seja uma forma.Com Go, podemos trabalhar dessa forma com interfaces.
Interfaces são um conceito muito poderoso em linguagens de programação estaticamente tipadas, como Go, porque permitem que você crie funções que podem ser usadas com diferentes tipos e permite a criação de código altamente desacoplado, mantendo ainda a segurança de tipos.
Vamos apresentar isso refatorando nossos testes.
func TestArea(t *testing.T) {
verificaArea := func(t *testing.T, forma Forma, esperado float64) {
t.Helper()
resultado := forma.Area()
if resultado != esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, esperado)
}
}
t.Run("retângulos", func(t *testing.T) {
retangulo := Retangulo{12.0, 6.0}
verificaArea(t, retangulo, 72.0)
})
t.Run("círculos", func(t *testing.T) {
circulo := Circulo{10}
verificaArea(t, circulo, 314.1592653589793)
})
}
Estamos criando uma função auxiliar como fizemos em outros exercícios, mas desta vez estamos pedindo que uma
Forma seja passada. Se tentarmos chamá-la com algo que não seja uma forma, não vai compilar.Como algo se torna uma forma? Precisamos apenas falar para o Go o que é uma
Forma usando uma declaração de interface.type Forma interface {
Area() float64
}
Estamos criando um novo
tipo, assim como fizemos com Retangulo e Circulo, mas desta vez é uma interface em vez de uma struct.Uma vez adicionado isso ao código, os testes passarão.
A interface em Go bem diferente das interfaces na maioria das outras linguagens de programação. Normalmente você tem que escrever um código para dizer que
meu tipo Foo implementa a interface Bar.Só que no nosso caso:
Retangulotem um método chamadoAreaque retorna umfloat64, então satisfaz a interfaceForma.Circulotem um método chamadoAreaque retorna umfloat64, então satisfaz a interfaceForma.stringnão tem esse método, então não satisfaz a interface.- etc.
Em Go a resolução de interface é implícita. Se o tipo que você passar combinar com o que a interface está esperando, o código será compilado.
Veja como nossa função auxiliar não precisa se preocupar se a forma é um
Retangulo ou um Circulo ou um Triangulo. Ao declarar uma interface, a função auxiliar está desacoplada de tipos concretos e tem apenas o método que precisa para fazer o trabalho.Este tipo de abordagem - de usar interfaces para declarar somente o que você precisa - é muito importante no desenvolvimento de software e será coberto mais detalhadamente nas próximas seções.
Agora que você conhece as
structs, podemos apresentar os "table driven tests" (testes orientados por tabela).Table driven tests são úteis quando você quer construir uma lista de casos de testes que podem ser testados da mesma forma.
func TestArea(t *testing.T) {
testesArea := []struct {
forma Forma
esperado float64
}{
{Retangulo{12, 6}, 72.0},
{Circulo{10}, 314.1592653589793},
}
for _, tt := range testesArea {
resultado := tt.forma.Area()
if resultado != tt.esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, tt.esperado)
}
}
}
A única sintaxe nova aqui é a criação de uma "struct anônima",
testesArea. Estamos declarando um slice de structs usando []struct com dois campos, o forma e o esperado. Então preenchemos o slice com os casos.Depois iteramos sobre eles assim como fazemos com qualquer outro slice, usando os campos da struct para executar nossos testes.
Dá para perceber como será muito fácil para uma pessoa inserir uma nova forma, implementar
Area e então adicioná-la nos casos de teste. Além disso, se for encontrada uma falha em Area, é muito fácil adicionar um novo caso de teste para verificar antes de corrigi-la.Testes baseados em tabela podem ser um item valioso em sua caixa de ferramentas, mas tenha certeza de que você precisa da sintaxe extra nos testes. Se você deseja testar várias implementações de uma interface ou se o dado passado para uma função tem muitos requisitos diferentes que precisam de testes, eles podem servir bem.
Vamos demonstrar tudo isso adicionando e testando outra forma; um triângulo.
Adicionar um teste para nossa nova forma é muito fácil. Simplesmente adicione
{Triangulo{12, 6}, 36.0}, à nossa lista.func TestArea(t *testing.T) {
testesArea := []struct {
forma Forma
esperado float64
}{
{Retangulo{12, 6}, 72.0},
{Circulo{10}, 314.1592653589793},
{Triangulo{12, 6}, 36.0},
}
for _, tt := range testesArea {
resultado := tt.forma.Area()
if resultado != tt.esperado {
t.Errorf("resultado %.2f, esperado %.2f", resultado, tt.esperado)
}
}
}
Lembre-se, continue tentando executar o teste e deixe o compilador guiá-lo em direção a solução.
./formas_test.go:25:4: undefined: TrianguloAinda não definimos
Triangulo:type Triangulo struct {
Base float64
Altura float64
}
Tente novamente:
./formas_test.go:25:8: cannot use Triangulo literal (type Triangulo) as type Forma in field value:
Triangulo does not implement Forma (missing Area method)
Triangulo não implementa Forma (método Area faltando)Isso nos diz que não podemos usar um
Triangulo como uma Forma porque ele não tem um método Area(), então adicione uma implementação vazia para fazermos o teste funcionar:func (t Triangulo) Area() float64 {
return 0
}
Finalmente o código compilou e temos o nosso erro:
formas_test.go:31: resultado 0.00, esperado 36.00func (t Triangulo) Area() float64 {
return (t.Base * t.Altura) * 0.5
}
E nossos testes passaram!
Novamente, a implementação está boa, mas nossos testes podem ser melhorados.
Quando você lê isso:
{Retangulo{12, 6}, 72.0},
{Circulo{10}, 314.1592653589793},
{Triangulo{12, 6}, 36.0},
Não está tão claro o que todos os números representam e você deve ter o objetivo de escrever testes que sejam fáceis de entender.
Até agora você viu uma sintaxe para criar instâncias de structs como
MinhaStruct{valor1, valor2}, mas você pode opcionalmente nomear esses campos.Vamos ver como isso funciona:
{forma: Retangulo{largura: 12, altura: 6}, esperado: 72.0},
{forma: Circulo{Raio: 10}, esperado: 314.1592653589793},
{forma: Triangulo{Base: 12, altura: 6}, esperado: 36.0},
O teste é lido de forma mais clara, como se fosse uma afirmação da verdade, não uma sequência de operações
(ênfase minha)
Agora nossos testes (pelo menos a lista de casos) fazem afirmações da verdade sobre formas e suas áreas.
Lembra anteriormente quando implementamos
Triangulo e tivemos um teste falhando? Ele imprimiu formas_test.go:31: resultado 0.00 esperado, 36.00.Nós sabíamos que estava relacionado ao
Triangulo porque estávamos trabalhando nisso, mas e se uma falha escorregasse para o sistema em um dos 20 casos na tabela? Como alguém saberia qual caso falhou? Não parece ser uma boa experiência. Ela teria que olhar caso a caso para encontrar qual deles está falhando de fato.Podemos mudar nossa mensagem de erro para
%#v resultado %.2f, esperado %.2f. A string de formatação %#v irá imprimir nossa struct com os valores em seu campo para que as pessoas possam ver imediatamente as propriedades que estão sendo testadas.Para melhorar a legibilidade de nossos futuros casos de teste, podemos renomear o campo
esperado para algo mais descritivo como temArea.Uma dica final com testes guiados por tabela é usar
t.Run e renomear os casos de teste.Envolvendo cada caso em um
t.Run você terá uma saída de testes mais limpa em caso de falhas, além de imprimir o nome do caso.--- FAIL: TestArea (0.00s)
--- FAIL: TestArea/Retangulo (0.00s)
formas_test.go:33: main.Retangulo{Largura:12, Altura:6} resultado 72.00, esperado 72.10
E você pode rodar testes específicos dentro de sua tabela com
go test -run TestArea/Retangulo.Aqui está o código final do nosso teste que captura isso:
func TestArea(t *testing.T) {
testesArea := []struct {
nome string
forma Forma
temArea float64
}{
{nome: "Retângulo", forma: Retangulo{Largura: 12, Altura: 6}, temArea: 72.0},
{nome: "Círculo", forma: Circulo{Raio: 10}, temArea: 314.1592653589793},
{nome: "Triângulo", forma: Triangulo{Base: 12, Altura: 6}, temArea: 36.0},
}
for _, tt := range testesArea {
t.Run(tt.nome, func(t *testing.T) {
resultado := tt.forma.Area()
if resultado != tt.temArea {
t.Errorf("%#v resultado %.2f, esperado %.2f", tt.forma, resultado, tt.temArea)
}
})
}
}
Esta foi mais uma prática de TDD, iterando em nossas soluções para problemas matemáticos básicos e aprendendo novos recursos da linguagem motivados por nossos testes.
- Declarar structs para criar seus próprios tipos de dados permite agrupar dados relacionados e torna a intenção do seu código mais clara.
- Declarar interfaces permite que você possa definir funções que podem ser usadas por diferentes tipos (polimorfismo paramétrico).
- Adicionar métodos permite que você possa adicionar funcionalidades aos seus tipos de dados e implementar interfaces.
- Testes baseados em tabela permite que você torne suas asserções mais claras e seus testes mais fáceis de estender e manter.
Este foi um capítulo importante porque agora começamos a definir nossos próprios tipos. Em linguagens estaticamente tipadas como Go, conseguir projetar seus próprios tipos é essencial para construir software que seja fácil de entender, compilar e testar.
Interfaces são uma ótima ferramenta para ocultar a complexidade de outras partes do sistema. Em nosso caso, o código de teste auxiliar não precisou conhecer a forma exata que estava afirmando, apenas como "pedir" pela sua área.
Conforme você se familiariza com Go, começa a ver a força real das interfaces e da biblioteca padrão.
Você aprenderá sobre as interfaces definidas na biblioteca padrão que são usadas em todo lugar e, implementando-as em relação aos seus próprios tipos, você pode reutilizar rapidamente muitas das ótimas funcionalidades.