Se você trabalha ou já trabalhou em um grande projeto com uma alta cobertura de testes, com certeza você já passou raiva na hora de executar os testes da aplicação localmente.

Isso por que, quanto maior o projeto e mais bem coberto por testes, maior o tempo para executar todas as validações.

Pois bem, hoje venho te mostrar duas formas de continuar com uma ótima cobertura de testes, porém economizar um bom tempo na hora de executá-los localmente ou na abertura de PRs.

Filtros

Normalmente quando há alguma mudança no código, para verificar rapidamente que nada quebrou, podemos executar somente os testes que estão diretamente relacionados com aquela função.

func TestFoo(t *testing.T) {
	tcs := []struct{
		Name string
		// outros campos
	}{
		{ Name: "A+B", // outros valores },
		{ Name: "A+C", // outros valores },
		{ Name: "B+B", // outros valores },
		{ Name: "B+C", // outros valores },
	}
	
	for _, tc := range tcs {
		t.Run(tc.Name, func(t *testing.T) {
			// test
		})
	}
	// teardown
}

Para exemplificar, vamos considerar o teste acima. Digamos que uma mudança foi feita na função Foo, e por isso, antes de fazer o commit e abrir um novo pull request, só queremos executar o teste acima.

Para que o go test execute somente essa função, precisamos usar a flag -run. Essa flag serve como um filtro. No caso do teste acima, ficaria go test -run Foo. Dessa forma, somente o TestFoo e variações, por exemplo TestFooBar, seriam executados.

Para executar somente os subtests de TestFoo que começam com “A”, faça go test -run Foo/A. Caso queria um subtest específico, passe o nome exato dele, por exemplo, go test -run Foo/A+B.

Short vs Long

No meio de tantos testes, com certeza alguns demoram muito mais do que outros. Uma ótima dica para acelerar a execução é utilizar a flag -short.

Ao utilizar essa flag você pode fazer skip de testes que demoram para ser executado. Por exemplo:

func TestFooBar(t *testing.T) {
	if testing.Short() {
		t.Skip()
	}
	// seu teste que demora MUUUUITO para ser executado
}

Com uma pequena mudança no primeiro exemplo, também podemos fazer o skip de alguns cases.

func TestFoo(t *testing.T) {
	tcs := []struct{
		Name string
		Short bool
		// outros campos
	}{
		{ Name: "A+B", Short: true, // outros valores },
		{ Name: "A+C", Short: false, // outros valores },
		{ Name: "B+B", Short: true, // outros valores },
		{ Name: "B+C", Short: false, // outros valores },
	}
	
	for _, tc := range tcs {
		t.Run(tc.Name, func(t *testing.T) {
			if testing.Short() && !tc.Short {
				t.Skip()
			}
			// test
		})
	}
	// teardown
}

Essa estratégia é muito boa para validações rápidas, seja localmente, na abertura de um pull request ou para um bug fix muito urgente.

Conclusão

Embora essas dicas não vão acelerar a execução dos testes como um todo, com certeza elas vão te ajudar na hora de fazer validações rápidas.

E não se esqueça! Mesmo que você implemente as dicas acima, em algum momento é necessário executar todos os seus testes.

Espero que as dicas ajudem a acelerar o seu processo de desenvolvimento.

Se tiver mais alguma dica, deixe nos comentários.

Abraço e até a próxima!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.