Que es el ciclo de vida, es un proceso en el cual se crea una instancia.
En nuestro caso se crea cuenta test, la referencia bueno, se administra de alguna forma y luego se
termina esta instancia finaliza.
Es decir, al final del proceso se destruye.
A diferencia de otra clase de nuestro código.
Por ejemplo, cuando creamos una referencia es con el operador new, pero acá típicamente compró Nitaria
con este framework.
Lo que hacemos es levantar ejecutar nuestra prueba.
Ya sea con click derecho o con los atajos del teclado con control cheff F10.
Entonces ejecutamos y en este proceso.
Bueno, alguien se tiene que encargar de inicializar esta clase test Arien va a realizar la instancia,
por ejemplo el new cuenta test.
Bueno y que se encarga justamente es el motor de juntito.
La plataforma crea la instancia y no solamente la crea, sino también la administra, la maneja por
detrás.
Un ciclo diría que también es manejado por la plataforma PAII UNIT y justamente es lo que vamos a aprender
en esta clase.
Por ejemplo, cuando se crea una referencia, la instancia, cuántas instancias se van a crear?
Kaikki Ejecutamos un test se fijan en diferente punto importante que hay que ir viendo que hay que analizar.
Otro tema interesante bueno del siglo hoy día son los hooks o evento.
Es decir, Yuni nos da la oportunidad de poder ejecutar algún código específico en cierto punto de nuestro
ciclo de vida.
Quizás al comienzo, cuando recién se está creando la instancia, se crea.
Entonces la primera vez podemos implementar un código o al final cuando se hayan ejecutado todos los
métodos de prueba.
Entonces podemos tener uno comienzo, otro final, incluso entre medio, entre cada método, en cada
ejecución de un método test.
También podemos tener un hook, un evento antes o después de cada método, es decir, el proceso completo
desde que se crea esta instancia hasta su terminación y presos.
Vamos a analizar, realizar diferentes anotaciones y también quizás ver alguna diferencia con Yuni 4.
Pero bueno, y 4 también tiene anotaciones, pero más que nada hay un renombre.
Se cambian un poco el nombre, pero en términos de lo que hacen de funcionalidad es prácticamente lo
mismo.
P Pero hablemos un poco sobre la instancia de la clase de prueba independiente independiente de cantidad
mtodo, por ejemplo.
Bueno, nuestra clase acá tiene método 3 nombre, cuenta de salto, cuenta y te referencia, cuenta
y varios puntos.
Se va a tener métodos que se van a ejecutar.
Y también este método es parte del ciclo de vida.
Importante tener en cuenta cuando ejecutamos una clase de test, la referencia, la instancia en cada
método, en cada test va a ser distinta, es decir, por cada método se a crear una nueva instancia
de la clase, el orden en que se van a ejecutar estos métodos.
Da lo mismo la idea que sea completamente independiente y como hemos visto kaikki ejecutamos nuestra
prueba.
No se puede saber, no se puede decir en qué orden se van a ejecutar estos métodos.
Esencialmente aleatorio es un orden que establece designÃ Julieth y no hay garantía de cuál se ejecuta
primero, cuál se va a ejecutar segundo.
En fin, aunque también podríamos cambiar la forma en que trabajo por defecto este ciclo de día.
La instancia que va a crear de cuéntate es, por ejemplo, por defecto.
Bueno, se crea una por método, pero también podríamos crear una sola durante todo el proceso y esa
instancia sería compartida en la ejecución de lo diferente métodos de test.
Y ahí podríamos establecer un orden en que se ejecuta, pero independiente eso podríamos establecer
un orden en el que se ejecutan los métodos o bien de forma alfabética, ya sea el nombre del método
o mediante el texto el contenido que tenga el display name.
Esta anotación en general, como buena práctica, el orden no es tan importante y de hecho ordenar una
clase test podría tener dos sentidos uno, un tema de visualización que podría estar bien.
Es decir, quiero ver momeno en el reporte cierto orden, pero una muy mala práctica que en realidad
ordenar para establecer dependencia entre los métodos text y crear un cierto estado en la clase de nuestra
unitaria de nuestro test sería una muy mala práctica.
Por ejemplo, muchas veces se cae en el juego, por ejemplo, de querer primero ejecutar un método,
después otro y por ejemplo un método va a utilizar un atributo de la clase, alguna referencia o un
atributo lo va a modificar, por ejemplo.
Y otro método, por ejemplo, mediante un if va a realizar un if.
Si el atributo tiene tal valor, entonces hacer algo se fijan.
Entonces hay una dependencia entre un método y otro método, y eso va a cambiar un poco el comportamiento
de nuestro test.
El segundo método, que depende del valor que asigno en este atributo, el primer método va trabaja
distinto, su comportamiento hace diferente.
El test va a ser diferente según lo que haya sucedido en la primera prueba.
Entonces hay una dependencia fuerte y eso es lo que queremos evitar.
No es recomendable dar un estado fuera de los métodos del test.
No es que vaya a limitar o restringir nuestra preguntaria, pero sí va a crear una dependencia fuerte,
que en realidad es lo que más se quiere evitar en prioritaria.
La idea que sean completamente independiente cada método y cada prueba que estamos realizando y teniendo
en cuenta eso, no se debieran de ejecutar en un orden determinado de otra forma.
Después, porque importante también que conozcan estas anotaciones, vamos a ver cómo ordenar estos
métodos, pero más que nada para algo visual, no para implementar o crear un estado y un acoplamiento
entre nuestro método de texto, no solamente para ordenar de forma visual, pero no para crear dependencia.
Eso lo vamos a hacer después con la anotación Order.
En fin, ahora nos vamos a centrar en el ciclo de vida.
Para eso tenemos un par de anotaciones.
Acá tenemos nuestra clase text.
Por ejemplo, cuenta test con varios métodos y vamos a tener diferentes eventos, diferentes hooks.
Como se le llama, que va a implementar cierto código durante el ciclo de vida, desde que comienza
hasta que termina.
Y básicamente son cuatro anotaciones que se implementan en algún método para agregar esta funcionalidad.
El primero es el Before Hold.
Es decir, que se ejecuta antes de todos los métodos.
Por eso Ol se ejecuta una sola vez durante la ejecución de nuestra unitaria.
Luego tenemos el after all.
Al final, cuando finaliza la prueba, se ejecuta una sola vez al final.
Entonces, al final, el for all y el after hold lo que hacen es envolver la ejecución de nuestra unitaria
y eytan toda la ejecución de los métodos.
Luego tenemos otras anotaciones, eventos que se van a ejecutar en la invocación de cada método.
Es decir, cada vez que se ejecuta un método podemos implementar algo justo antes de que se inicializa.
Por eso es before it cada vez que se ejecuta un métodos realizar alguna tarea y lo mismo.
After it después de que se haya ejecutado el método después que haya finalizado.
Pero lo mismo hay que tener presente de que en cada invocación de método se crea por defecto una nueva
instancia de la clase texto.
Por lo tanto, en este método podríamos utilizar alguna variable en limpio.
Es decir, cada ejecución de un método va a tener su evento before it propio en limpio, que no tiene
dependencia con los demás invocaciones del método porque son otras instancias.
Bueno, lo mejor es ver un ejemplo.
Entonces vamos a partir primero con Before It Voy Init Método Test, por poner un ejemplo.
Bien, entonces acá un shout iniciando el método.
Es decir, se ejecuta antes, pero qué podríamos tener acá en común?
Por ejemplo, en cada método que se repite.
Bueno, la instancia cuenta Andrés con el bit decimal está acá mil punto uno tres cuatro cinco.
Lo utilizamos en varios métodos de test.
Rectifican de todas forma es un atributo independiente.
Por lo tanto, no mantiene un estado.
Además que cada vez que se invoca un método test se realiza una prueba.
Se crea una instancia, por lo tanto, parte completamente limpio.
Este método se va a ejecutar cada vez que se crea una instancia y se llama un nuevo método test.
Entonces lo que vamos a hacer es copiar esto.
O más bien lo cortamos, lo cortamos, lo copiamos y acá lo pegamos.
Vamos a copiar esto también.
Y lo dejamos acá como un atributo de la clase, pero no es un atributo de la clase que mantenga conectados,
sino que es independiente para cada método.
Y esto lo quitamos diez punto, cuenta.
Ni lo tenemos, se fijan.
Ahora se está reutilizando.
Acá también esto lo quitamos, lo quitamos.
En este caso no, porque ya tenemos cuenta y cuenta dos y es distinto, incluso acá cuenta.
No podría bajar así.
Es decir, cambiamos la instancia.
Utilizamos esa.
Esta le quitamos porque la misma se fijan.
Entonces la eliminamos.
Acá en la misma le quitamos.
Le quitamos.
Acá cuenta uno contado distinto, así que eso es lo que tal cual.
También bajamos hasta el cual se fijan, pero ya estamos reutilizando.
Queda mucho más elegante.
Queda mucho mejor.
Ahora, qué faltaría para que esto realmente se aplique?
Bueno, sería importante anotar.
Entonces vi for each importante por cada entonces que se ejecute antes de cada método y luego tenemos
el after it yo mismo, un método.
Bueno, incluso voy a quitar esto y lo podríamos hacer con el atajo Alt insert erijan.
Acá podemos tener los métodos dirigÃan before class, after class.
Y acá nos crea el after it bueno, el Before nos lo mostró porque ya lo tenemos creado, pero el after
it lo creamos de forma automática y acá podemos finalizar nuestra prueba con algo.
Suponte Shout finalizando el método
de programa, por poner un ejemplo.
Bien, entonces primero inicializa cuenta que en común, en común, pero no hay dependencia porque es
en limpio.
Es importante que tengan en cuenta en los métodos test.
Ahora ejecutamos control cheff F10.
Bueno, vamos a tener un fallo, creo.
Bueno, está todo bien.
Claro, acá tenemos deshabilita esta prueba, que era la que falla, pero está todo perfecto, se fijan,
sigue funcionando tal cual como estaba antes.
Ahora, si quieren, en el último test, en la última prueba podríamos comentar esto el fail se fija
y el diseño lo prueba, ha comentado y listo.
Ahí tenemos nuestros primeros métodos ciclo de vida.
Por cada método antes y por cada método.
Después nada más.
Continuamos en la siguiente clase, pero con él before, ol y el after.
Es decir, que se invoque una sola vez durante toda la ejecución de nuestra prueba.