Legibilidade em testes: do caos à clareza

Transcript

1. Legibilidade em testes: do caos à clareza
2. •Estudante de CC na UFCG •Desenvolvedor na Alura Quem sou eu
3. • Como escrever testes legíveis Sobre a apresentação
4. • 😬 Como escrever testes legíveis Sobre a apresentação
5. • 😬 Como escrever testes legíveis • ✅ Como escrever testes manuteníveis Sobre a apresentação
6. • 😬 Como escrever testes legíveis • ✅ Como escrever testes manuteníveis • ❌ Como usar ferramentas de testes Sobre a apresentação
7. • 😬 Como escrever testes legíveis • ✅ Como escrever testes manuteníveis • ❌ Como usar ferramentas de testes • ❌ Quais testes criar para meu código Sobre a apresentação
8. • Con fi ança no código Por que criar testes automatizados?
9. • Con fi ança no código • Regressão Por que criar testes automatizados?
10. • Con fi ança no código • Regressão • Prática de mercado Por que criar testes automatizados?
11. Preocupações no momento da escrita do teste
12. • Meu teste aumenta a chance que um bug seja exposto em meu sistema? Preocupações no momento da escrita do teste
13. • Meu teste aumenta a chance que um bug seja exposto em meu sistema? • O meu teste vai me ajudar a manter o sistema? Preocupações no momento da escrita do teste
14. Maurício Aniche "As with production code, we must put extra effort into writing high-quality test code bases so they can be maintained and developed sustainably.”
15. Maurício Aniche "As with production code, we must put extra effort into writing high-quality test code bases so they can be maintained and developed sustainably.”
17. Maurício Aniche "As with production code, we must put extra effort into writing high-quality test code bases so they can be maintained and developed sustainably.”
18. Princípios de um bom teste
19. 1. Testes devem ser rápidos
20. Feedback Loop
22. Estratégias para tornar meu teste mais rápido •Criar suíte de testes diferentes
23. Estratégias para tornar meu teste mais rápido •Criar suíte de testes diferentes •Testes rápidos •Testes lentos
24. Estratégias para tornar meu teste mais rápido •Criar suíte de testes diferentes •Testes unitários •Testes de integração
25. Estratégias para tornar meu teste mais rápido •Substituir dependências pesadas em certos tipos de testes.
26. class MeuTesteDemorado { // 11s private DependenciaPesada dependenciaPesada; // test1 // test2 // test3 //...
27. @TestInstance(TestInstance.Lifecycle.PER_CLASS) class MeuTesteDemorado { // 11s private DependenciaPesada dependenciaPesada; // test1 // test2 // test3 //...
28. 2. Testes devem ser legíveis (Readable)
29. Testes devem ser legíveis •Arrange, Act, Assert
30. @Test void purchaseSucceedsWhenEnoughInventory() { Product paperclip = new Product(1L, "Paperclip"); Store store = new Store(); store.addInventory(paperclip, 100); Customer customer = new Customer(); assertTrue(customer.purchase(store, paperclip, 10)); assertEquals(90, store.getInventory(paperclip)); } ❌
31. @Test void purchaseSucceedsWhenEnoughInventory() { //Arrange Product paperclip = new Product(1L, "Paperclip"); Store store = new Store(); store.addInventory(paperclip, 100); Customer customer = new Customer(); //Act boolean purchaseSucceeded = customer.purchase(store, paperclip,10); //Assert assertTrue(purchaseSucceeded); assertEquals(90, store.getInventory(paperclip)); } ✅
32. Testes devem ser legíveis •Arrange, Act, Assert •Nomes descritivos
33. @Test void testDeposit() { BankAccount account = new BankAccount(100); account.deposit(100); assertEquals(200, account.getBalance()); } ❌
34. @Test @DisplayName("increases balance when a deposit is made") void increaseBalanceWhenDepositIsMade() { BankAccount account = new BankAccount(100); account.deposit(100); assertEquals(200, account.getBalance()); } ✅
35. Testes devem ser legíveis •Arrange, Act, Assert •Nomes descritivos •Funções auxiliares
36. @Test void categoryQueryParameter() throws Exception { List<ProductEntity> products = List.of( new ProductEntity().setId("1").setName("Envelope").setCategory("Office").setDescription("An Envelope").setStockAmount(1), //Mais objetos de produtos sendo criados ); for (ProductEntity product : products) { template.execute(createSqlInsertStatement(product)); } String responseJson = client.perform(get("/products?category=Office")) .andExpect(status().is(200)) .andReturn().getResponse().getContentAsString(); assertThat(toDTOs(responseJson)) .extracting(ProductDTO::getId) .containsOnly("1", "2"); } ❌
37. @Test public void categoryQueryParameter() throws Exception { insertIntoDatabase( createProductWithCategory("1", "Office"), createProductWithCategory("2", "Office"), createProductWithCategory("3", "Hardware") ); String responseJson = requestProductsByCategory("Office"); assertThat(toDTOs(responseJson)) .extracting(ProductDTO::getId) .containsOnly("1", "2"); } ✅
38. Testes devem ser legíveis •Arrange, Act, Assert •Nomes descritivos •Funções auxiliares •Esconda informações desnecessárias
39. @Test @DisplayName("should return username derived from full name") void shouldReturnUsernameDerivedFromFullname() { var user = new User("Henrique", "Lopes Nóbrega", "henrique.nobrega@ccc.ufcg.edu.br", LocalDate.parse("2000-09-12"), "+5584.....", "Rua Pipipi Popopo", "12345678910"); var username = user.getUsername(); assertThat(username).isEqualTo("henrique.nobrega"); } ❌
40. @Test @DisplayName("should return username derived from full name") void shouldReturnUsernameDerivedFromFullname() { var user = anUser("Henrique", "Lopes Nóbrega"); var username = user.getUsername(); assertThat(username).isEqualTo("henrique.nobrega"); } ✅
41. @Test @DisplayName("should return username derived from full name") void shouldReturnUsernameDerivedFromFullname() { var user = anUser(); //?? var username = user.getUsername(); assertThat(username).isEqualTo("henrique.nobrega"); } Mas cuidado para não esconder demais 😅
42. 3. Testes devem ser sensíveis
43. Testes devem ser sensíveis •Sensíveis ao comportamento
44. Se seu comportamento muda, seu teste DEVE QUEBRAR
46. SEMPRE faça seu teste quebrar
47. Testes devem ser sensíveis •Sensíveis ao comportamento •Insensíveis à estrutura
48. Testes devem ser sensíveis •Sensíveis ao comportamento •Insensíveis à estrutura •Use boas asserções
49. Testes devem ser sensíveis •Sensíveis ao comportamento •Insensíveis à estrutura •Use boas asserções •AssertJ
50. assertTrue(actualProductList.contains(expectedProduct)); assertTrue(actualProductList.size() == 5); assertTrue(actualProduct instanceof Product); //expected: <true> but was: <false> ❌
51. assertThat(actualProductList).contains(expectedProduct); assertThat(actualProductList).hasSize(5); assertThat(actualProduct).isInstanceOf(Product.class); //Expecting: // <[Product[id=1, name='Samsung Galaxy']]> //to contain: // <[Product[id=2, name='iPhone']]> //but could not find: // <[Product[id=2, name='iPhone']]> ✅
52. 4. Testes devem ser específicos
53. Testes devem ser específicos •Devem ter um motivo claro para existir
54. Testes devem ser específicos •Devem ter um motivo claro para existir •Devem ter uma única e clara razão para falhar
55. @Test @DisplayName("return false when token is invalid") void returnFalseWhenTokenIsInvalid() { // Para o token ser válido: // tamanho >= 10 // não pode ter número // precisa ter sido emitido nas últimas 48h // testa tamanho < 10 // testa se tem numero // testa se é mais antigo que 48h } ❌
56. @Test @DisplayName("return false when token has not necessary length") void returnFalseWhenTokenHasNotNecessaryLength() { /*...*/ } @Test @DisplayName("return false if token has number") void returnFalseIfTokenHasNumber() { /*…*/ } @Test @DisplayName("return false if token has expired") void returnFalseIfTokenHasExpired() { /*...*/ } ✅
57. 5. Testes devem ser isolados
58. Testes devem ser isolados •Cada teste prepara o que precisa
59. Testes devem ser isolados •Cada teste prepara o que precisa •Cada teste limpa o que usa
60. Testes devem ser isolados •Cada teste prepara o que precisa •Cada teste limpa o que usa •Pode ser executado independente ou em conjunto
61. 6. Testes devem ser determinísticos
62. Testes devem ser determinísticos •Con fi ança na suíte de testes
63. Testes devem ser determinísticos •Con fi ança na suíte de testes •Causas principais para não determinismo •Concorrência
64. Testes devem ser determinísticos •Con fi ança na suíte de testes •Causas principais para não determinismo •Concorrência •Async wait
65. Testes devem ser determinísticos •Con fi ança na suíte de testes •Causas principais para não determinismo •Concorrência •Async wait •Dependência da execução de testes
66. 7. Testes devem ser fáceis de escrever
67. Testes devem ser fáceis de escrever •Escreva a infraestrutura necessária
68. Testes devem ser fáceis de escrever •Escreva a infraestrutura necessária •Test Data Builders
69. public class OrderBuilder { private Long orderId = 1L; private Customer customer = new Customer(...); /** … */ public OrderBuilder withId(Long orderId) { this.orderId = orderId; return this; } /** ... */ public Order build() { Order order = new Order(orderId, customer, discountRate, couponCode); orderItems.forEach(order::addOrderItem); return order; } }
70. Testes devem ser fáceis de escrever •Escreva a infraestrutura necessária •Test Data Builders •Object Mother
71. public class Orders { public static Order createOrderWithCustomer(Customer customer) { return new Order(1L, customer, 0.0, null); } }
72. Testes devem ser fáceis de escrever •Escreva a infraestrutura necessária •Test Data Builders •Object Mother •Page Object
73. public class LoginPage { private WebDriver driver; private By username = By.id("username"); private By password = By.id("password"); private By loginBtn = By.id("login"); public LoginPage(WebDriver driver) { this.driver = driver; } public HomePage login(String user, String pass) { driver.findElement(username).sendKeys(user); driver.findElement(password).sendKeys(pass); driver.findElement(loginBtn).click(); return new HomePage(driver); } }
74. Recapitulando…
75. 1. Rápidos
76. 1. Rápidos 2. Legíveis
77. 1. Rápidos 2. Legíveis 3. Sensíveis ao comportamento
78. 1. Rápidos 2. Legíveis 3. Sensíveis ao comportamento 4. Especí fi cos
79. 1. Rápidos 2. Legíveis 3. Sensíveis ao comportamento 4. Especí fi cos 5. Isolados
80. 1. Rápidos 2. Legíveis 3. Sensíveis ao comportamento 4. Especí fi cos 5. Isolados 6. Determinísticos
81. 1. Rápidos 2. Legíveis 3. Sensíveis ao comportamento 4. Especí fi cos 5. Isolados 6. Determinísticos 7. Fáceis de escrever
82. Para saber mais Veri fi cação e Validação de Software
83. Para saber mais Effective software testing, by Maurício Aniche
84. Para saber mais Outros materiais (gist) https://bit.ly/talk-testes-hacktoberfest-ccc
85. Dúvidas, comentários?
86. •Github •Linkedin •henriqueln7 em praticamente qualquer local :p Contato
87. Obrigado pela presença ❤ e cuidado com a sexta-feira 13 👻