[Trem on Rails] Como não odiar seus testes

Sabemos que escrever testes automatizados é extremamente importante, pois, entre outras coisas, eles garantem a qualidade do nosso código e o funcionamento da nossa aplicação. Apesar disso, muitas vezes acabamos com uma suíte de testes que, além de ser difícil de entender e manter, não é confiável. Nessa talk, vamos ver como reconhecer e evitar alguns dos problemas mais comuns que nos fazem odiar nossos testes, além de dar algumas dicas de como melhorar nossos testes.

Links legais:
Talk: Como não odiar seus testes (v1): https://www.youtube.com/watch?v=Dkqbck_DMoE&ab_channel=AtlasTechnologies
Livro: X-Unit Patterns: http://xunitpatterns.com/
Catálogo de test smells: https://test-smell-catalog.readthedocs.io/
Talk do Joe Yoder: Architecting Agility: https://www.youtube.com/live/0bGVSQw1948?si=7Hn3F9KDa_vhpxJs&t=2634

1. @camposmilaa Como não odiar seus testes @camposmilaa
2. @camposmilaa Camila Campos Meu propósito de vida é promover diversidade e inclusão através da educação @camposmilaa Software Engineer @ Coinbase
3. @camposmilaa @railsgirls.sp
4. @camposmilaa Como não odiar seus testes @camposmilaa
5. @camposmilaa test('should setup middleware', async () => { const nuxt = createNuxt() const server = new Server(nuxt) server.useMiddleware = jest.fn() server.serverContext = { id: 'test-server-context' } await server.setupMiddleware() expect(server.nuxt.callHook).toBeCalledTimes(2) expect(server.nuxt.callHook).nthCalledWith(1, 'render:setupMiddleware', server.app) expect(server.nuxt.callHook).nthCalledWith(2, 'render:errorMiddleware', server.app) expect(server.useMiddleware).toBeCalledTimes(4) expect(serveStatic).toBeCalledTimes(2) expect(serveStatic).nthCalledWith(1, 'resolve(/var/nuxt/src, var/nuxt/static)', server.options.render.static) expect(server.useMiddleware).nthCalledWith(1, { dir: 'resolve(/var/nuxt/src, var/nuxt/static)', id: 'test-serve-static', prefix: 'test-render-static-prefix' }) expect(serveStatic).nthCalledWith(2, 'resolve(/var/nuxt/build, dist, client)', server.options.render.dist) expect(server.useMiddleware).nthCalledWith(2, { handler: { dir: 'resolve(/var/nuxt/build, dist, client)', id: 'test-serve-static' }, path: '__nuxt_test' }) const nuxtMiddlewareOpts = { options: server.options, nuxt: server.nuxt, renderRoute: expect.any(Function), resources: server.resources } expect(nuxtMiddleware).toBeCalledTimes(1) expect(nuxtMiddleware).toBeCalledWith(nuxtMiddlewareOpts)
6. @camposmilaa Nós odiamos nossos testes?
7. @camposmilaa Por que nós odiamos nossos testes?
8. @camposmilaa @camposmilaa Tempo Sentido
9. @camposmilaa @camposmilaa Tempo Sentido Demora muito pra rodar Gasta tempo para fazer Não dá pra entender Não testa nada Falha aleatoriamente É redundante
10. @camposmilaa Por que nós escrevemos testes?
11. @camposmilaa Anos 90/2000
12. @camposmilaa Todo código é testado. Se não for por você, será por quem o utiliza.
13. @camposmilaa Meados de 2015
14. @camposmilaa Atualmente…
15. @camposmilaa Big ball of mud
16. @camposmilaa print de um slide do @metayoda
17. @camposmilaa print de um slide do @metayoda
18. @camposmilaa Não existe uma boa arquitetura sem testes!
19. @camposmilaa Code without tests is bad code. It doesn’t matter how well written it is; it doesn’t matter how pretty or object-oriented or well-encapsulated it is. (...) Michael Feathers
20. @camposmilaa Código sem testes é código ruim. Não importa o quão bem escrito está; não importa quão bonito ou orientado a objetos ou bem encapsulado ele está. (...) Michael Feathers
21. @camposmilaa @camposmilaa Testes não são só sobre achar bugs na aplicação!
22. @camposmilaa @camposmilaa Testes não são só sobre achar bugs na aplicação! Achar bugs Poder mudar comportamento Evitar bugs Ter qualidade de código Poder refatorar Ter uma boa arquitetura Garantir funcionamento Mover com agilidade
23. @camposmilaa Legal, teste é top! Mas ainda temos os problemas de: Tempo Sentido
24. @camposmilaa "Escrever testes gasta um tempo precioso do time de desenvolvimento, que poderia estar sendo usado para fazer funcionalidades!"
25. @camposmilaa @camposmilaa if you think good architecture is expensive, try bad architecture. Joe Yoder
26. @camposmilaa @camposmilaa se você acha que uma boa arquitetura custa caro, tenta ter uma arquitetura ruim. Joe Yoder
27. @camposmilaa Sem testes = Código ruim
28. @camposmilaa @camposmilaa O teste é o primeiro usuário do código!
29. @camposmilaa Tá difícil de escrever? Seu código real precisa ser refatorado!
30. @camposmilaa Hora de refatorar!
31. @camposmilaa Hora de refatorar! Setup complexo ou grande
32. @camposmilaa Hora de refatorar! Setup complexo ou grande Muitas dependências
33. @camposmilaa Hora de refatorar! Setup complexo ou grande Múltiplas verificações Muitas dependências
34. @camposmilaa Hora de refatorar! Setup complexo ou grande Múltiplas verificações Muitas dependências Muitas responsabilidades
35. @camposmilaa Hora de refatorar! Setup complexo ou grande Múltiplas verificações Fluxo de teste muito longo Muitas dependências Muitas responsabilidades
36. @camposmilaa Hora de refatorar! Setup complexo ou grande Múltiplas verificações Fluxo de teste muito longo Muitas dependências Muitas responsabilidades API complexa
37. @camposmilaa Hora de refatorar! Setup complexo ou grande Múltiplas verificações Código complexo no teste Fluxo de teste muito longo Muitas dependências Muitas responsabilidades API complexa
38. @camposmilaa Hora de refatorar! Muitos passos de "exercise" Setup complexo ou grande Múltiplas verificações Código complexo no teste Fluxo de teste muito longo Muitas dependências Muitas responsabilidades Código complexo API complexa
39. @camposmilaa Se fazer teste não vale a pena, escrever código bom também não!
40. @camposmilaa @camposmilaa "Tem um tanto de testes na minha aplicação, mas eles demoram horas para rodar. Haja paciencia! ):"
41. @camposmilaa e2e integração unidade Pirâmide de testes
42. @camposmilaa @camposmilaa testes de unidade Não é teste de unidade se: 1. Não é rápido 2. Fala com o banco de dados 3. Faz chamadas externas 4. Escreve/Lê algum arquivo 5. Precisa de configurações especiais de ambiente
43. @camposmilaa @camposmilaa testes de unidade
44. @camposmilaa e2e integração unidade Pirâmide de testes
45. @camposmilaa e2e integração unidade Pirâmide de testes
46. @camposmilaa e2e integração unidade Pirâmide de testes
47. @camposmilaa "Que que tá rolando nesse teste?" "Essa desgrama não tá testando é nada!" "Roda de novo que vai…"
48. @camposmilaa Sem testes = Código ruim
49. @camposmilaa = Sem testes = Código ruim Com testes Código bom
50. @camposmilaa @camposmilaa Precisamos escrever testes bons Simples Pequenos Objetivos Fáceis de ler
51. @camposmilaa DRY Alguns padrões de código não se aplicam aos testes Don’t Repeat Yourself
52. @camposmilaa "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system" Andy Hunt e Dave Thomas - The Pragmatic Programmer
53. @camposmilaa "Cada pedaço de conhecimento deve ter uma representação única, clara e confiável dentro do sistema." Andy Hunt e Dave Thomas - The Pragmatic Programmer
54. @camposmilaa it 'greets a person' do # ... end it 'gracefully greets a person' do # ... end
55. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
56. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
57. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
58. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
59. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
60. @camposmilaa let(:person) { Person.new(name: 'any-name') } it 'greets a person' do response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
61. @camposmilaa let(:person) { Person.new(name: 'any-name') } it 'greets a person' do response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
62. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'greets a person' do expect(messenger.greet).to eq 'Hello, any-name' end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am any-name!" end
63. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'greets a person' do expect(messenger.greet).to eq 'Hello, any-name' end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am any-name!" end
64. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'greets a person' do expect(messenger.greet).to eq 'Hello, any-name' end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am any-name!" end
65. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
66. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'does an entirely different thing' do # .... end it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
67. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'does nothing sometimes' do # .... end it 'does an entirely different thing' do # .... end it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
68. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'does any other thing' do # .... end it 'does nothing sometimes' do # .... end it 'does an entirely different thing' do # .... end it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
69. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'does something else' do # .... end it 'does any other thing' do # .... end it 'does nothing sometimes' do # .... end it 'does an entirely different thing' do # .... end it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
70. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'does something' do # .... end it 'does something else' do # .... end it 'does any other thing' do # .... end it 'does nothing sometimes' do # .... end it 'does an entirely different thing' do # .... end it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
71. @camposmilaa let(:person) { Person.new(name: 'any-name') } let(:messenger) { Messenger.new(person) } it 'does something' do # .... end it 'does something else' do # .... end it 'does any other thing' do # .... end it 'does nothing sometimes' do # .... end it 'does an entirely different thing' do # .... end it 'greets a person' do expect(messenger.greet).to eq "Hello, #{person.name}" end it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
72. @camposmilaa it 'gracefully greets a person' do expect(messenger.fancy_greet).to eq "Good afternoon, ma'am #{person.name}!" end
73. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).greet expect(response).to eq 'Hello, any-name' end it 'gracefully greets a person' do person = Person.new(name: 'any-name') response = Messenger.new(person).fancy_greet expect(response).to eq "Good afternoon, ma'am any-name!" end
74. @camposmilaa @camposmilaa Precisamos escrever testes com padrões Arrange Act Assert Setup Exercise Verify Teardown
75. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') # Setup response = Messenger.new(person).greet # Exercise expect(response).to eq 'Hello, any-name' # Verify end
76. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') # Setup response = Messenger.new(person).greet # Exercise expect(response).to eq 'Hello, any-name' # Verify end
77. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') # Setup response = Messenger.new(person).greet # Exercise expect(response).to eq 'Hello, any-name' # Verify end
78. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') # Setup response = Messenger.new(person).greet # Exercise expect(response).to eq 'Hello, any-name' # Verify end
79. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') # Setup response = Messenger.new(person).greet # Exercise expect(response).to eq 'Hello, any-name' # Verify end
80. @camposmilaa it 'greets a person' do person = Person.new(name: 'any-name') # Setup response = Messenger.new(person).greet # Exercise expect(response).to eq 'Hello, any-name' # Verify end
81. @camposmilaa it 'sends email to person' do mailer = double('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup expect(mailer).to receive(:notify).with(person.email) # Verify Messenger.new(person, mailer: mailer).send_email # Exercise end
82. @camposmilaa it 'sends email to person' do mailer = double('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup expect(mailer).to receive(:notify).with(person.email) # Verify Messenger.new(person, mailer: mailer).send_email # Exercise end
83. @camposmilaa it 'sends email to person' do mailer = double('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup expect(mailer).to receive(:notify).with(person.email) # Verify Messenger.new(person, mailer: mailer).send_email # Exercise end
84. @camposmilaa it 'sends email to person' do mailer = double('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup expect(mailer).to receive(:notify).with(person.email) # Verify Messenger.new(person, mailer: mailer).send_email # Exercise end
85. @camposmilaa it 'sends email to person' do mailer = double('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup expect(mailer).to receive(:notify).with(person.email) # Verify Messenger.new(person, mailer: mailer).send_email # Exercise end
86. @camposmilaa it 'sends email to person' do mailer = double('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup expect(mailer).to receive(:notify).with(person.email) # Verify Messenger.new(person, mailer: mailer).send_email # Exercise end
87. @camposmilaa it 'sends email to person' do mailer = spy('my mailer') # Setup person = Person.new(name: 'any-name', email: 'e@mail.com') # Setup Messenger.new(person, mailer: mailer).send_email # Exercise expect(mailer).to have_received(:notify).with(person.email) # Verify end
88. @camposmilaa Diminua testes redundantes controller service model repository A B A B A B classe 1 classe 2 classe 4 classe 3 A B A B
89. @camposmilaa Diminua testes redundantes controller service model repository A B A B A B classe 1 classe 2 classe 4 classe 3 A B A B O teste é de unidade mesmo? Que tal remover alguns desses testes?
90. @camposmilaa @camposmilaa Testes intermitentes: arrume agora ou delete! Dependentes de ordem Precisam de configurações externas Quebram em determinados horários Funcionam em só um tipo de máquina
91. @camposmilaa Com isso, passamos por todos os pontos
92. @camposmilaa @camposmilaa como não odiar seus testes 1. Ter bons testes é ter qualidade de código 2. Testes difíceis indicam código ruim 3. Um teste bom é simples e fácil de entender
93. @camposmilaa para mais detalhes sobre test smells 1. Talk: Como não odiar seus testes (v1) 2. Livro: X-Unit Patterns 3. Catálogo de test smells 4. Talk do Joe Yoder: Architecting Agility
94. @camposmilaa @camposmilaa (...) undesigned applications carry the seeds of their own destruction; they are easy to write but gradually become impossible to change. Sandi Metz
95. @camposmilaa @camposmilaa (...) aplicações sem design carregam os frutos da sua própria destruição; elas são fáceis de escrever mas gradualmente se tornam impossíveis de mudar. Sandi Metz
96. @camposmilaa Testes ruins são melhor que nada
97. @camposmilaa Testes ruins são melhor que nada Não ter testes é melhor do que ter testes ruins
98. @camposmilaa @camposmilaa Camila Campos Software Engineer @ Coinbase @camposmilaa bit.ly/camila-tremonrails
99. @camposmilaa Camila Campos bit.ly/camila-codecon25 @camposmilaa Valeuzão!