Tests unitaires mock_kesako_20130516

16 mai 13
Test unitaire ?
Mock ? TDD ?
Kezako ?
1

réseaux sociaux
Prochaines conférences : http://soat.fr
twitter : @soatgroup / @soatexpertsjava
slideshares : http://fr.slideshare.net/soatexpert
Aller plus loin : http://blog.soat.fr

Test unitaire ? Mock ? TDD ? Kezako ?
en ﬁnir avec les régressions par David Wursteisen
16 MAI 2013

HTTP://UPLOAD.WIKIMEDIA.ORG/WIKIPEDIA/COMMONS/THUMB/6/69/HUMAN_EVOLUTION.SVG/1000PX-HUMAN_EVOLUTION.SVG.PNG
LEGACY CODE

La documentation explique le code
/**
*
* @param xml : document xml représentant le swap
* @return objet Swap
*/
public Swap parse(String xml) {
Swap swap = new Swap();
String currency = getNodeValue("/swap/currency", xml);
swap.setCurrency(currency);
/* beaucoup de code... */
Date d = new Date();
if(test == 1) {
if(d.after(spotDate)) {
swap.setType("IRS");
} else {
swap.setType("CURVE");
}
} else if (test == 2) {
if(d.after(spotDate)) {
swap.setType("IRS");
} else {
swap.setType("CURVE");
}
}
/* encore beaucoup de code... */
return swap;
}

La documentation explique le code
1 /**
2 *
3 * @param xml : document xml représentant le swap
4 * @return objet Swap
5 */
6 public Swap parse(String xml) {
7 Swap swap = new Swap();
8 String currency = getNodeValue("/swap/currency", xml);
9 swap.setCurrency(currency);
[...] /* beaucoup de code... */
530 Date d = new Date();
531 if(test == 1) {
532 if(d.after(spotDate)) {
533 swap.setType("IRS");
534 } else {
535 swap.setType("CURVE");
536 }
537 } else if (test == 2) {
540 } else {
542 }
543 }
[...] /* encore beaucoup de code... */
1135 return swap;
1136 }
1000
LIGNES !

La documentation a raison
1 /**
2 * Always returns true.
3 */
4 public boolean isAvailable() {
5 return false;
6 }

La documentation a raison
1 /**
2 * Always returns true.
3 */
4 public boolean isAvailable() {
5 return false;
6 }
WTF ?!?

La documentation n’est plus
ﬁable
une aide
utile

4 obj = networkService.getObject("product", id);
1 public Object getProduct(String id) {
2 Object obj = null;
3 try {
5 } catch (IOException e) {
6 System.err.println("Error with obj : " + obj.toString());
7 }
8 return obj;
9 }
Faire du code qui marche

3 try {
7 }
8 return obj;
9 }
7 }
Faire du code qui marche
NullPointerException !

4 account = (BankAccount) service.getProduct(this.name);
5 account.deposit();
1 public void affiche(BankAccount account, ProductService service) {
2 System.out.println("Bank Account : "+this.name);
3 System.out.println("Autres informations : ");
4 account = (BankAccount) service.getProduct(this.name);
5 account.deposit();
6 System.out.println(account);
7 System.out.println("=== FIN ===");
8
9 }
Code simple
HTTP://EN.WIKIPEDIA.ORG/WIKI/FILE:JEU_DE_MIKADO.JPG

C’est compliqué de faire
simple
un test
une évolution

Je vous prend dans mon équipe !

HTTP://WWW.SXC.HU/PROFILE/HOTBLACK
COMMENT VA
T’ON POUVOIR
S’EN SORTIR ?

TEST DRIVEN DEVELOPMENT

Lancement
du test
Ecriture
du test

Lancement
du test
Correction de
l’implémentation
Ecriture
du test
KO

Lancement
du test
Correction de
l’implémentation
Ecriture
du test
Fin
KO
OK

Lancement
du test
Correction de
l’implémentation
Ecriture
du test
Fin
KO
OK
REFACTOR

Toujours faire le test cassant avant
le test passant
(pour tester le test)

TEST UNITAIRE
tester la plus petite unité de code possible

TEST UNITAIRE
SIMPLE

TEST UNITAIRE
SIMPLEFEEDBACK

TEST UNITAIRE
SIMPLEFEEDBACKCOÛT

1 @Test
2 public void can_deposit() {
3 bankAccount.setBalance(50);
4
5 boolean result = bankAccount.deposit(1000);
6
7 assertTrue(result);
8 assertEquals(1050, bankAccount.getBalance());
9 }
Test d’abord !

1 @Test
4
6
9 }
Test d’abord !

Test d’abord !
1 boolean deposit(int amount) {
2 return false;
3 }

Test d’abord !
2 bal = bal + amount;
3 return true;
4 }

Test d’abord !
1 @Test
2 public void cant_deposit_with_negative_amount() {
4
5 boolean result = bankAccount.deposit(-20);
6
7 assertFalse(result);
9 }

Test d’abord !
1 @Test
4
6
9 }

Test d’abord !
2 if(amount < 0) {
3 return false;
4 }
5 bal = bal + amount;
6 return true;
7 }

les «3 A» : Acteur/Action/Assertion
1 @Test
4
6
9 }

1 @Test
4
6
9 }
Acteur

1 @Test
4
6
9 }
Action

1 @Test
4
6
9 }
Assertions

KISSKEEP IT SIMPLE (AND STUPID)

7 CustomerDTO targetDTO = this.serviceImpl.getCustomer("ABC99");
8
9 // VÃ©rifier.
10 Assert.assertNotNull("Extra non trouvÃ©.", targetDTO);
11 Assert.assertEquals("Les accountId doivent Ãªtre identiques.",
12 "ABC99", targetDTO.getAccountId());
1 @Test
2 public void testGetCustomerOK() {
3
4 LOGGER.info("======= testGetCustomerOK starting...");
5
6 try {
8
9 // VÃ©rifier.
13
14 } catch (CustomerBusinessException exception) {
15 LOGGER.error("CustomerBusinessException : {}",
16 exception.getCause());
17 Assert.fail(exception.getMessage());
18 } catch (UnavailableResourceException exception) {
19 LOGGER.error("UnavailableResourceException : {}",
20 exception.getMessage());
22 } catch (UnexpectedException exception) {
23 LOGGER.error("UnexpectedException : {}" +
26 } catch (Exception exception) {
27 LOGGER.error("CRASH : " + exception.getMessage());
29 }
30
31 LOGGER.info("======= testGetCustomerOK done.");
32 }

1 @Test
2 public void testGetCustomerOK() {
3
4 LOGGER.info("======= testGetCustomerOK starting...");
5
6 try {
8
9 // VÃ©rifier.
13
29 }
30
32 }
29 }
30
BRUIT

KISS !
1 @Test
2 public void can_get_customer() throws Exception {
4 Assert.assertEquals("Les accountId doivent être identiques.",
6 }

EN PRATIQUE

Mock ?
simulacre
se fait passer pour ce qu’il
n’est pas
comportement
paramétrable

doReturn(new BankAccount()).when(daoService).getObject("product", "id");

doReturn(new BankAccount()).when(daoService).getObject("product", "id");doReturn(new BankAccount())

doReturn(new BankAccount()).when(daoService).getObject("product", "id");when(daoService)

doReturn(new BankAccount()).when(daoService).getObject("product", "id");getObject("product", "id");

doThrow(IOException.class).when(daoService).getObject("product", "id");

doThrow(IOException.class).when(daoService).getObject("product", "id");doThrow(IOException.class)

doThrow(IOException.class).when(daoService).getObject("product", "id");when(daoService)

doThrow(IOException.class).when(daoService).getObject("product", "id");getObject("product", "id");

assertThat(age).isGreaterThan(5);

assertThat(myList).containsExactly("MONAD42", "META18")

assertThat(negotation).isBooked();

nouveau bug = nouveau test
3 try {
7 }
8 return obj;
9 }

3 try {
7 }
8 return obj;
9 }
LE BUG EST ICI !

1 @Test
2 public void can_return_null_when_ioexception() throws IOException {
3 Mockito.doThrow(IOException.class)
4 .when(networkService).getObject("product", "azerty");
5
6 Object product = service.getProduct("azerty");
7
8 assertThat(product).isNull();
9 }

1 @Test
5
7
9 }

3 try {
7 }
8 return obj;
9 }
LE BUG EST TOUJOURS ICI !

3 try {
6 System.err.println("Error with obj with id: " + id);
7 }
8 return obj;
9 }

3 try {
7 }
8 return obj;
9 }

Laissez votre câble tranquille

code complexe
1 /**
2 *
5 */
531 if(test == 1) {
534 } else {
536 }
537 } else if (test == 2) {
540 } else {
542 }
543 }
1135 return swap;
1136 }

1 @Test
2 public void can_parse_xml() throws Exception {
3 String xml = "<?xml version="1.0" encoding="UTF-8"?>n" +
4 "n" +
9 "<FpML version="4-2" xmlns="http://www.fpml.org/2005/FpML-4-2" xmlns:xsi="http://www.w3.org/2001/
XMLSchema-instance" xsi:schemaLocation="http://www.fpml.org/2005/FpML-4-2 fpml-main-4-2.xsd" xsi:type=
"TradeCashflowsAsserted">n" +
10 "t<header>n" +
11 "tt<messageId messageIdScheme="http://www.example.com/messageId">CEN/2004/01/05/15-38</messageId>n"
+
12 "tt<sentBy>ABC</sentBy>n" +
13 "tt<sendTo>DEF</sendTo>n" +
14 "tt<creationTimestamp>2005-01-05T15:38:00-00:00</creationTimestamp>n" +
15 "t</header>n" +
16 "t<asOfDate>2005-01-05T15:00:00-00:00</asOfDate>n" +
17 "t<tradeIdentifyingItems>n" +
18 "tt<partyTradeIdentifier>n" +
19 "ttt<partyReference href="abc"/>n" +
20 "ttt<tradeId tradeIdScheme="http://www.abc.com/tradeId/">trade1abcxxx</tradeId>n" +
21 "tt</partyTradeIdentifier>n" +
22 "tt<partyTradeIdentifier>n" +
23 "ttt<partyReference href="def"/>n" +
24 "ttt<tradeId tradeIdScheme="http://www.def.com/tradeId/">123cds</tradeId>n" +
25 "tt</partyTradeIdentifier>n" +
26 "t</tradeIdentifyingItems>n" +
27 "t<adjustedPaymentDate>2005-01-31</adjustedPaymentDate>n" +
28 "t<netPayment>n" +
29 "tt<identifier netPaymentIdScheme="http://www.centralservice.com/netPaymentId">netPaymentABCDEF001</
identifier>n" +
30 "tt<payerPartyReference href="abc"/>n" +
31 "tt<receiverPartyReference href="def"/>n" +
32 "tt<paymentAmount>n" +

1 /**
2 *
5 */
531 if(test == 1) {
534 } else {
536 }
537 } else if (test == 2) {
540 } else {
542 }
543 }
1135 return swap;
1136 }
code complexe
531 if(test == 1) {
534 } else {
536 }
537 } else if (test == 2) {
540 } else {
542 }
543 }
EXTRACT METHOD !

code complexe
1 public void updateSwapType(Swap swapToUpdate, Date now, Date spotDate, int test) {
2 if(test == 1) {
3 if(now.after(spotDate)) {
4 swapToUpdate.setType("IRS");
5 } else {
6 swapToUpdate.setType("CURVE");
7 }
8 } else if (test == 2) {
9 if(now.after(spotDate)) {
10 swapToUpdate.setType("IRS");
11 } else {
12 swapToUpdate.setType("CURVE");
13 }
14 }
15 }

code complexe
1 @Test
2 public void can_update_swap_type() throws Exception {
4 Date now = simpleDateFormat.parse("2012-06-15");
5 Date before = simpleDateFormat.parse("2012-05-05");
6 service.updateSwapType(swap, now, before, 1);
7 assertEquals("IRS", swap.getType());
8 }

Singleton
1 public class ProductService {
2
3 private static ProductService instance = new ProductService();
4
5 private DAOService daoService;
6
7 private ProductService() {
8 System.out.println("ProductService constructor");
9 daoService = DAOService.getInstance();
10 }
11
12 public static ProductService getInstance() {
13 return instance;
14 }
15
16
17
19 return daoService.getObject("product", id);
20 }
21 }

2
4
6
10 }
11
13 return instance;
14 }
15
16
17
20 }
21 }
Singleton

2
4
6
10 }
11
13 return instance;
14 }
15
16
17
20 }
21 }
Singleton
10 }

Singleton
Code ProductService DAOService

Singleton
Code ProductService DAOService
Mock
ProductService

Singleton
1 public void validateSwap(String id) {
2 Swap swap = (Swap) ProductService.getInstance().getProduct(id);
3 swap.updateState("VALIDATE");
4 ProductService.getInstance().save(swap);
5 }

5 }
Singleton
ProductService.getInstance()
4 ProductService.getInstance()
COUPLAGE FORT

Injection
1 private ProductService productService;
2
3 public void setProductService(ProductService injectedService) {
4 this.productService = injectedService;
5 }
6
8 Swap swap = (Swap) productService.getProduct(id);
10 productService.save(swap);
11 }

2
5 }
6
11 }
Injection
5 }
INJECTION

2
5 }
6
11 }
Injection
UTILISATION

Injection
1 @InjectMocks
2 private BankAccount bankAccount;
3
4 @Mock
6
7 @Test
8 public void can_validate_swap() {
10
11 Mockito.doReturn(swap).when(productService).getProduct("fakeId");
12 Mockito.doNothing().when(productService).save(swap);
13
14 bankAccount.validateSwap("fakeId");
15
16 assertEquals("VALIDATE", swap.getState());
17 }

1 @InjectMocks
3
4 @Mock
6
7 @Test
10
13
15
17 }
Injection
4 @Mock
MOCK

1 @InjectMocks
3
4 @Mock
6
7 @Test
10
13
15
17 }
Injection
1 @InjectMocks
INJECTION AUTOMATIQUE
DES MOCKS

1 @InjectMocks
3
4 @Mock
6
7 @Test
10
13
15
17 }
Injection

Injection
1 @InjectMocks
3
4 @Mock
6
7 @Test
10
13
15
17 }

UTILISE L’INJECTION,
LUKE
YODA (C) DISNEY

Sans injecteur ?
5 }

5 }
Sans injecteur ?
ProductService.getInstance()
4 ProductService.getInstance()
EXTRACT METHOD !

1 public ProductService getProductService() {
2 return ProductService.getInstance();
3 }
4
6 Swap swap = (Swap) getProductService().getProduct(id);
8 getProductService().save(swap);
9 }
Sans injecteur ?
1 public ProductService getProductService() {
2 return ProductService.getInstance();
3 }
getProductService()
8 getProductService()

Sans injecteur ?
1 @Spy
2 private BankAccount bankAccount = new BankAccount("", 23, "", 3);
3
4 @Mock
6
7 @Test
10
11 Mockito.doReturn(productService).when(bankAccount).getProductService();
12
15
17
19 }

1 @Spy
3
4 @Mock
6
7 @Test
10
12
15
17
19 }
Sans injecteur ?
1 @Spy
REDÉFINITION DES MÉTHODES
POSSIBLE

1 @Spy
3
4 @Mock
6
7 @Test
10
12
15
17
19 }
Sans injecteur ?

Sans injecteur ?
1 @Spy
3
4 @Mock
6
7 @Test
10
12
15
17
19 }

LANCER UN TEST DOIT ÊTRE FACILE

Tests dans son IDE
ECLIPSE
NETBEANS
INTELLIJ

LE CODE DOIT TOUJOURS
ÊTRE DÉPLOYABLE

Intégration continue
mvn install

[INFO] ---------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ---------------------------------------------

[INFO] ---------------------------------------------
[INFO] BUILD FAILURE
[INFO] ---------------------------------------------

[INFO] ---------------------------------------------
[INFO] BUILD FAILURE
[INFO] ---------------------------------------------
WORKS ON
MY
MACHINE

Déclenchement
d’un build

Déclenchement
d’un build
Compilation

Déclenchement
d’un build
Compilation Test

Déclenchement
d’un build
Compilation Test
Déploiement
Analyse de code

80%DE COUVERTURE DE GETTER/SETTER

binomage (pair hero)
philosophie diﬀérente pour code identique
HTTP://WWW.SXC.HU/PHOTO/959091

philosophie diﬀérente pour code identiqueLES COMMANDES

philosophie diﬀérente pour code identique
LE PLAN DE VOL

Bugs
0
22,5
45
67,5
90
Janvier Février Mars Avril Mai Juin
Bugs Satisfaction

BRAVO À NOTRE ÉQUIPE DE CHOC !

(même si il est «trop» simple)

IL FAUT APPRENDRE
À NAGER...

...AVANT DE GAGNER
DES COMPÉTITIONS

QUESTIONS ?

référence
jenkins : http://jenkins-ci.org/
assertj : https://github.com/joel-costigliola/assertj
mockito : https://code.google.com/p/mockito/
démo : http://parleys.com/play/5148922a0364bc17fc56c85a/about

Tests unitaires mock_kesako_20130516

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (8)

Similaire à Tests unitaires mock_kesako_20130516

Similaire à Tests unitaires mock_kesako_20130516 (20)

Plus de SOAT

Plus de SOAT (20)

Dernier

Dernier (20)

Tests unitaires mock_kesako_20130516