1
00:00:00,180 --> 00:00:04,290
Que es el ciclo de vida, es un proceso en el cual se crea una instancia.

2
00:00:04,500 --> 00:00:10,860
En nuestro caso se crea cuenta test, la referencia bueno, se administra de alguna forma y luego se

3
00:00:10,860 --> 00:00:12,570
termina esta instancia finaliza.

4
00:00:12,690 --> 00:00:14,580
Es decir, al final del proceso se destruye.

5
00:00:14,730 --> 00:00:16,770
A diferencia de otra clase de nuestro código.

6
00:00:16,830 --> 00:00:22,620
Por ejemplo, cuando creamos una referencia es con el operador new, pero acá típicamente compró Nitaria

7
00:00:22,710 --> 00:00:23,520
con este framework.

8
00:00:23,580 --> 00:00:26,310
Lo que hacemos es levantar ejecutar nuestra prueba.

9
00:00:26,430 --> 00:00:30,960
Ya sea con click derecho o con los atajos del teclado con control cheff F10.

10
00:00:31,140 --> 00:00:32,910
Entonces ejecutamos y en este proceso.

11
00:00:32,960 --> 00:00:38,360
Bueno, alguien se tiene que encargar de inicializar esta clase test Arien va a realizar la instancia,

12
00:00:38,370 --> 00:00:40,200
por ejemplo el new cuenta test.

13
00:00:40,380 --> 00:00:44,150
Bueno y que se encarga justamente es el motor de juntito.

14
00:00:44,370 --> 00:00:49,890
La plataforma crea la instancia y no solamente la crea, sino también la administra, la maneja por

15
00:00:49,890 --> 00:00:50,190
detrás.

16
00:00:50,250 --> 00:00:56,640
Un ciclo diría que también es manejado por la plataforma PAII UNIT y justamente es lo que vamos a aprender

17
00:00:56,700 --> 00:00:57,480
en esta clase.

18
00:00:57,690 --> 00:01:03,030
Por ejemplo, cuando se crea una referencia, la instancia, cuántas instancias se van a crear?

19
00:01:03,150 --> 00:01:09,330
Kaikki Ejecutamos un test se fijan en diferente punto importante que hay que ir viendo que hay que analizar.

20
00:01:09,660 --> 00:01:13,890
Otro tema interesante bueno del siglo hoy día son los hooks o evento.

21
00:01:14,220 --> 00:01:21,810
Es decir, Yuni nos da la oportunidad de poder ejecutar algún código específico en cierto punto de nuestro

22
00:01:21,810 --> 00:01:22,440
ciclo de vida.

23
00:01:22,530 --> 00:01:27,210
Quizás al comienzo, cuando recién se está creando la instancia, se crea.

24
00:01:27,420 --> 00:01:32,460
Entonces la primera vez podemos implementar un código o al final cuando se hayan ejecutado todos los

25
00:01:32,460 --> 00:01:33,300
métodos de prueba.

26
00:01:33,450 --> 00:01:39,180
Entonces podemos tener uno comienzo, otro final, incluso entre medio, entre cada método, en cada

27
00:01:39,270 --> 00:01:40,980
ejecución de un método test.

28
00:01:41,070 --> 00:01:46,590
También podemos tener un hook, un evento antes o después de cada método, es decir, el proceso completo

29
00:01:46,770 --> 00:01:50,370
desde que se crea esta instancia hasta su terminación y presos.

30
00:01:50,370 --> 00:01:57,150
Vamos a analizar, realizar diferentes anotaciones y también quizás ver alguna diferencia con Yuni 4.

31
00:01:57,300 --> 00:02:01,980
Pero bueno, y 4 también tiene anotaciones, pero más que nada hay un renombre.

32
00:02:02,100 --> 00:02:07,470
Se cambian un poco el nombre, pero en términos de lo que hacen de funcionalidad es prácticamente lo

33
00:02:07,470 --> 00:02:07,800
mismo.

34
00:02:08,050 --> 00:02:14,160
P Pero hablemos un poco sobre la instancia de la clase de prueba independiente independiente de cantidad

35
00:02:14,160 --> 00:02:15,150
mtodo, por ejemplo.

36
00:02:15,200 --> 00:02:20,640
Bueno, nuestra clase acá tiene método 3 nombre, cuenta de salto, cuenta y te referencia, cuenta

37
00:02:20,730 --> 00:02:21,830
y varios puntos.

38
00:02:21,870 --> 00:02:25,110
Se va a tener métodos que se van a ejecutar.

39
00:02:25,290 --> 00:02:28,170
Y también este método es parte del ciclo de vida.

40
00:02:28,390 --> 00:02:35,190
Importante tener en cuenta cuando ejecutamos una clase de test, la referencia, la instancia en cada

41
00:02:35,250 --> 00:02:41,550
método, en cada test va a ser distinta, es decir, por cada método se a crear una nueva instancia

42
00:02:41,640 --> 00:02:44,760
de la clase, el orden en que se van a ejecutar estos métodos.

43
00:02:44,970 --> 00:02:50,520
Da lo mismo la idea que sea completamente independiente y como hemos visto kaikki ejecutamos nuestra

44
00:02:50,520 --> 00:02:50,940
prueba.

45
00:02:51,150 --> 00:02:56,370
No se puede saber, no se puede decir en qué orden se van a ejecutar estos métodos.

46
00:02:56,730 --> 00:03:03,690
Esencialmente aleatorio es un orden que establece designà Julieth y no hay garantía de cuál se ejecuta

47
00:03:03,690 --> 00:03:05,880
primero, cuál se va a ejecutar segundo.

48
00:03:05,940 --> 00:03:11,460
En fin, aunque también podríamos cambiar la forma en que trabajo por defecto este ciclo de día.

49
00:03:11,610 --> 00:03:15,120
La instancia que va a crear de cuéntate es, por ejemplo, por defecto.

50
00:03:15,180 --> 00:03:20,310
Bueno, se crea una por método, pero también podríamos crear una sola durante todo el proceso y esa

51
00:03:20,310 --> 00:03:24,030
instancia sería compartida en la ejecución de lo diferente métodos de test.

52
00:03:24,270 --> 00:03:30,030
Y ahí podríamos establecer un orden en que se ejecuta, pero independiente eso podríamos establecer

53
00:03:30,090 --> 00:03:36,150
un orden en el que se ejecutan los métodos o bien de forma alfabética, ya sea el nombre del método

54
00:03:36,270 --> 00:03:40,530
o mediante el texto el contenido que tenga el display name.

55
00:03:40,800 --> 00:03:47,280
Esta anotación en general, como buena práctica, el orden no es tan importante y de hecho ordenar una

56
00:03:47,280 --> 00:03:52,410
clase test podría tener dos sentidos uno, un tema de visualización que podría estar bien.

57
00:03:52,470 --> 00:03:57,930
Es decir, quiero ver momeno en el reporte cierto orden, pero una muy mala práctica que en realidad

58
00:03:58,050 --> 00:04:06,150
ordenar para establecer dependencia entre los métodos text y crear un cierto estado en la clase de nuestra

59
00:04:06,280 --> 00:04:09,450
unitaria de nuestro test sería una muy mala práctica.

60
00:04:09,600 --> 00:04:16,080
Por ejemplo, muchas veces se cae en el juego, por ejemplo, de querer primero ejecutar un método,

61
00:04:16,140 --> 00:04:21,870
después otro y por ejemplo un método va a utilizar un atributo de la clase, alguna referencia o un

62
00:04:21,870 --> 00:04:25,170
atributo lo va a modificar, por ejemplo.

63
00:04:25,260 --> 00:04:28,800
Y otro método, por ejemplo, mediante un if va a realizar un if.

64
00:04:28,920 --> 00:04:32,220
Si el atributo tiene tal valor, entonces hacer algo se fijan.

65
00:04:32,250 --> 00:04:37,740
Entonces hay una dependencia entre un método y otro método, y eso va a cambiar un poco el comportamiento

66
00:04:37,740 --> 00:04:38,340
de nuestro test.

67
00:04:38,460 --> 00:04:44,820
El segundo método, que depende del valor que asigno en este atributo, el primer método va trabaja

68
00:04:44,820 --> 00:04:47,340
distinto, su comportamiento hace diferente.

69
00:04:47,430 --> 00:04:51,930
El test va a ser diferente según lo que haya sucedido en la primera prueba.

70
00:04:52,210 --> 00:04:55,350
Entonces hay una dependencia fuerte y eso es lo que queremos evitar.

71
00:04:55,560 --> 00:04:59,880
No es recomendable dar un estado fuera de los métodos del test.

72
00:05:00,370 --> 00:05:06,460
No es que vaya a limitar o restringir nuestra preguntaria, pero sí va a crear una dependencia fuerte,

73
00:05:06,610 --> 00:05:09,820
que en realidad es lo que más se quiere evitar en prioritaria.

74
00:05:10,210 --> 00:05:15,710
La idea que sean completamente independiente cada método y cada prueba que estamos realizando y teniendo

75
00:05:15,710 --> 00:05:20,650
en cuenta eso, no se debieran de ejecutar en un orden determinado de otra forma.

76
00:05:20,880 --> 00:05:26,320
Después, porque importante también que conozcan estas anotaciones, vamos a ver cómo ordenar estos

77
00:05:26,320 --> 00:05:32,920
métodos, pero más que nada para algo visual, no para implementar o crear un estado y un acoplamiento

78
00:05:33,130 --> 00:05:38,380
entre nuestro método de texto, no solamente para ordenar de forma visual, pero no para crear dependencia.

79
00:05:38,590 --> 00:05:41,230
Eso lo vamos a hacer después con la anotación Order.

80
00:05:41,290 --> 00:05:44,770
En fin, ahora nos vamos a centrar en el ciclo de vida.

81
00:05:44,890 --> 00:05:47,020
Para eso tenemos un par de anotaciones.

82
00:05:47,410 --> 00:05:48,580
Acá tenemos nuestra clase text.

83
00:05:48,640 --> 00:05:53,920
Por ejemplo, cuenta test con varios métodos y vamos a tener diferentes eventos, diferentes hooks.

84
00:05:54,010 --> 00:05:59,680
Como se le llama, que va a implementar cierto código durante el ciclo de vida, desde que comienza

85
00:05:59,770 --> 00:06:00,490
hasta que termina.

86
00:06:00,680 --> 00:06:07,150
Y básicamente son cuatro anotaciones que se implementan en algún método para agregar esta funcionalidad.

87
00:06:07,390 --> 00:06:09,610
El primero es el Before Hold.

88
00:06:09,850 --> 00:06:12,730
Es decir, que se ejecuta antes de todos los métodos.

89
00:06:12,850 --> 00:06:17,320
Por eso Ol se ejecuta una sola vez durante la ejecución de nuestra unitaria.

90
00:06:17,440 --> 00:06:19,810
Luego tenemos el after all.

91
00:06:19,900 --> 00:06:23,650
Al final, cuando finaliza la prueba, se ejecuta una sola vez al final.

92
00:06:23,920 --> 00:06:30,340
Entonces, al final, el for all y el after hold lo que hacen es envolver la ejecución de nuestra unitaria

93
00:06:30,580 --> 00:06:32,020
y eytan toda la ejecución de los métodos.

94
00:06:32,140 --> 00:06:38,950
Luego tenemos otras anotaciones, eventos que se van a ejecutar en la invocación de cada método.

95
00:06:39,040 --> 00:06:43,900
Es decir, cada vez que se ejecuta un método podemos implementar algo justo antes de que se inicializa.

96
00:06:43,960 --> 00:06:50,350
Por eso es before it cada vez que se ejecuta un métodos realizar alguna tarea y lo mismo.

97
00:06:50,440 --> 00:06:54,840
After it después de que se haya ejecutado el método después que haya finalizado.

98
00:06:55,000 --> 00:07:01,540
Pero lo mismo hay que tener presente de que en cada invocación de método se crea por defecto una nueva

99
00:07:01,540 --> 00:07:02,890
instancia de la clase texto.

100
00:07:03,160 --> 00:07:07,650
Por lo tanto, en este método podríamos utilizar alguna variable en limpio.

101
00:07:07,840 --> 00:07:14,560
Es decir, cada ejecución de un método va a tener su evento before it propio en limpio, que no tiene

102
00:07:14,560 --> 00:07:18,700
dependencia con los demás invocaciones del método porque son otras instancias.

103
00:07:18,850 --> 00:07:20,550
Bueno, lo mejor es ver un ejemplo.

104
00:07:20,740 --> 00:07:31,030
Entonces vamos a partir primero con Before It Voy Init Método Test, por poner un ejemplo.

105
00:07:31,680 --> 00:07:34,900
Bien, entonces acá un shout iniciando el método.

106
00:07:36,670 --> 00:07:40,480
Es decir, se ejecuta antes, pero qué podríamos tener acá en común?

107
00:07:40,510 --> 00:07:43,810
Por ejemplo, en cada método que se repite.

108
00:07:44,080 --> 00:07:50,100
Bueno, la instancia cuenta Andrés con el bit decimal está acá mil punto uno tres cuatro cinco.

109
00:07:50,230 --> 00:07:52,510
Lo utilizamos en varios métodos de test.

110
00:07:52,960 --> 00:07:56,020
Rectifican de todas forma es un atributo independiente.

111
00:07:56,140 --> 00:07:58,390
Por lo tanto, no mantiene un estado.

112
00:07:58,480 --> 00:08:01,810
Además que cada vez que se invoca un método test se realiza una prueba.

113
00:08:01,900 --> 00:08:05,470
Se crea una instancia, por lo tanto, parte completamente limpio.

114
00:08:05,560 --> 00:08:12,970
Este método se va a ejecutar cada vez que se crea una instancia y se llama un nuevo método test.

115
00:08:13,330 --> 00:08:15,130
Entonces lo que vamos a hacer es copiar esto.

116
00:08:16,440 --> 00:08:21,990
O más bien lo cortamos, lo cortamos, lo copiamos y acá lo pegamos.

117
00:08:22,260 --> 00:08:23,580
Vamos a copiar esto también.

118
00:08:25,330 --> 00:08:30,910
Y lo dejamos acá como un atributo de la clase, pero no es un atributo de la clase que mantenga conectados,

119
00:08:30,910 --> 00:08:33,790
sino que es independiente para cada método.

120
00:08:34,720 --> 00:08:39,880
Y esto lo quitamos diez punto, cuenta.

121
00:08:41,450 --> 00:08:42,500
Ni lo tenemos, se fijan.

122
00:08:43,000 --> 00:08:44,450
Ahora se está reutilizando.

123
00:08:46,310 --> 00:08:50,060
Acá también esto lo quitamos, lo quitamos.

124
00:08:51,200 --> 00:08:56,930
En este caso no, porque ya tenemos cuenta y cuenta dos y es distinto, incluso acá cuenta.

125
00:08:58,050 --> 00:08:58,890
No podría bajar así.

126
00:08:59,160 --> 00:09:00,780
Es decir, cambiamos la instancia.

127
00:09:00,860 --> 00:09:01,800
Utilizamos esa.

128
00:09:05,950 --> 00:09:07,780
Esta le quitamos porque la misma se fijan.

129
00:09:07,870 --> 00:09:09,670
Entonces la eliminamos.

130
00:09:10,780 --> 00:09:13,150
Acá en la misma le quitamos.

131
00:09:14,240 --> 00:09:15,110
Le quitamos.

132
00:09:16,330 --> 00:09:19,270
Acá cuenta uno contado distinto, así que eso es lo que tal cual.

133
00:09:20,320 --> 00:09:23,640
También bajamos hasta el cual se fijan, pero ya estamos reutilizando.

134
00:09:23,650 --> 00:09:25,660
Queda mucho más elegante.

135
00:09:25,750 --> 00:09:26,480
Queda mucho mejor.

136
00:09:27,160 --> 00:09:29,500
Ahora, qué faltaría para que esto realmente se aplique?

137
00:09:29,800 --> 00:09:31,600
Bueno, sería importante anotar.

138
00:09:32,290 --> 00:09:41,320
Entonces vi for each importante por cada entonces que se ejecute antes de cada método y luego tenemos

139
00:09:41,380 --> 00:09:46,270
el after it yo mismo, un método.

140
00:09:46,390 --> 00:09:52,750
Bueno, incluso voy a quitar esto y lo podríamos hacer con el atajo Alt insert erijan.

141
00:09:52,840 --> 00:09:57,040
Acá podemos tener los métodos dirigÃan before class, after class.

142
00:10:00,100 --> 00:10:06,820
Y acá nos crea el after it bueno, el Before nos lo mostró porque ya lo tenemos creado, pero el after

143
00:10:06,910 --> 00:10:11,320
it lo creamos de forma automática y acá podemos finalizar nuestra prueba con algo.

144
00:10:11,330 --> 00:10:14,170
Suponte Shout finalizando el método

145
00:10:17,530 --> 00:10:18,880
de programa, por poner un ejemplo.

146
00:10:19,040 --> 00:10:24,400
Bien, entonces primero inicializa cuenta que en común, en común, pero no hay dependencia porque es

147
00:10:24,490 --> 00:10:25,090
en limpio.

148
00:10:25,210 --> 00:10:28,490
Es importante que tengan en cuenta en los métodos test.

149
00:10:28,690 --> 00:10:31,210
Ahora ejecutamos control cheff F10.

150
00:10:33,010 --> 00:10:35,290
Bueno, vamos a tener un fallo, creo.

151
00:10:35,420 --> 00:10:36,120
Bueno, está todo bien.

152
00:10:37,240 --> 00:10:41,560
Claro, acá tenemos deshabilita esta prueba, que era la que falla, pero está todo perfecto, se fijan,

153
00:10:41,560 --> 00:10:43,360
sigue funcionando tal cual como estaba antes.

154
00:10:44,900 --> 00:10:51,890
Ahora, si quieren, en el último test, en la última prueba podríamos comentar esto el fail se fija

155
00:10:51,980 --> 00:10:55,880
y el diseño lo prueba, ha comentado y listo.

156
00:10:55,970 --> 00:10:58,550
Ahí tenemos nuestros primeros métodos ciclo de vida.

157
00:10:58,730 --> 00:11:01,390
Por cada método antes y por cada método.

158
00:11:01,670 --> 00:11:03,050
Después nada más.

159
00:11:03,080 --> 00:11:07,650
Continuamos en la siguiente clase, pero con él before, ol y el after.

160
00:11:07,880 --> 00:11:11,950
Es decir, que se invoque una sola vez durante toda la ejecución de nuestra prueba.