Bienvenido de nuevo.
Escribamos nuestra primera prueba ahora, vamos a tener una función simple que ejecutamos y este programa creará en
nuestro archivo DCPI principal, digamos, hagamos esto un poco más grande.
Diremos que tenemos una función llamada hacer cosas.
Sí, función muy descriptiva.
Ahora, aquí, solo diremos que aceptamos un número.
Y simplemente devolveremos NUM más cinco, una función muy, muy simple.
Entonces, digamos que este fue nuestro código que compila nuestra aplicación, por lo que esta es solo una función,
pero hipotéticamente, tenemos muchas funciones que queremos probar porque estas son acciones que vamos a realizar en nuestro
código.
Entonces, la forma en que funciona la prueba unitaria.
Es así.
Tenemos nuestro archivo de prueba, y después de importar nuestras pruebas unitarias, queremos importar mientras que el archivo que
queremos probar en nuestro caso es el DCPI principal, así que simplemente importemos main.
Que está justo aquí.
O también podemos importar la función si queremos.
Pero en nuestro caso, hipotéticamente, tenemos muchas funciones aquí, por lo que podemos simplemente importar, significar y usar
todas las funciones disponibles allí.
Ahora, la forma en que funciona la prueba unitaria es que creamos una clase y luego la nombramos como quieras aquí, tendrá todas
nuestras pruebas.
Así que llamémoslo prueba principal.
Y heredamos dentro de esta clase lo que nos da la prueba unitaria, que es una prueba.
Entonces, esta es solo una forma estándar de trabajar con la prueba unitaria, por lo que heredaremos los
casos de prueba unitarios y ahora tenemos esa funcionalidad disponible en nuestra clase principal de prueba.
Ahora, aquí, podemos comenzar a probar y escribir código para probar.
Entonces, ¿cómo podemos probar main?
Hacer la función de cosas.
Bueno, simplemente decimos, oye, escribamos una función aquí o un método, porque esto es parte
de una clase y decimos, oye, quiero probar cosas.
Y aquí se recibirá a sí mismo.
Ahora, aquí, puedo probar mi abrigo para poder decir si no aquí es igual a 10, solo le estoy dando un número
aleatorio, entonces voy a decir que el resultado será igual al punto principal para hacer las cosas.
Así que recuerde, hacer cosas viene de Maine, que es la función que queremos probar,
así que quiero ejecutar la función hacer cosas y aquí dar el número de parámetro, que acabo de dar aquí, o simplemente
llamemos a esta prueba deberes.
Entonces, en este programa de prueba, ejecutaremos el código y obtendremos un resultado.
Y esta última línea es la parte clave de la prueba unitaria, la prueba unitaria nos permite decir self punt, afirmar igual y afirmar
igual es algo que obtenemos cuando heredamos de la prueba unitaria y afirmar igual dice, oye,
afirmar.
O asegúrese de que estos dos parámetros sean iguales en nuestro caso, quiero probar que el resultado es igual
a, bueno, en nuestro caso, 10.
Más cinco deberían ser 15.
Muy bien, ahora, finalmente aquí, solo ejecutamos la prueba unitaria.
Y la forma en que ejecutamos la unidad, debido a que esta es solo una prueba que hice, podría haber hecho varias
pruebas.
Todo lo que necesitamos decir es prueba unitaria, punto principal.
Que ejecutará todo el archivo de prueba dentro de la prueba realizada.
Ahora, si ejecuto esto ahora, todo lo que tengo que hacer es decir Python tres, mi línea de comando y decir punto de prueba.
Y me puse bien, hice una prueba súper rápido en cero segundos, eso fue agradable y rápido.
Ahora, digamos que hago otra cosa en la que afirmo igual que esto es igual a 10 si ejecuto esto.
Me sale un fallo, ¿qué falló?
Bueno, la prueba para hacer la función falló.
En la línea ocho.
Así que aquí tenemos una afirmación: obtuvimos 15, pero esperábamos 10.
¿Cuan genial es eso?
Así que ahora tengo una falla, así que necesito arreglar mi código.
Entonces algo no está bien aquí.
Ahora bien, en mi caso, esto se debe a que lo he afirmado.
La respuesta es 15, pero ¿y si creamos otra prueba aquí?
Y verifique, oye, qué pasa si también tenemos cosas de prueba, y esta vez el programa de prueba en realidad va a ser un
trozo de cuerda.
Entonces, ¿qué queremos que haga la función?
Bueno, en nuestro caso, tal vez nos dé después, tal vez un valor, así que solo diré valor.
Debido a que esto no debería funcionar si ejecuto esto ahora, aclaremos esto, si ejecuto esto ahora.
Está bien, tengo que probar.
Pero tengo una oreja y veo aquí que me está escuchando una oreja que dice que, oye,
una taip solo puede concatenar cuerdas, no ocho.
Ahora bien, en este caso, ¿qué falla realmente?
Es el archivo de prueba, porque lo que acabamos de hacer en realidad falla en nuestra función.
Pero de inmediato, veo que está bien, bueno, esto es algo que tenemos que arreglar
para poder volver a Maine y decir, oye, quiero asegurarme de detectar cualquier error.
Como las peras tailandesas o los tasadores de valores, lo primero que puedo hacer es decir y.
No.
Y si digo eso para asegurarnos de que convertimos algo en un número entero y ejecuto esto.
En este momento, obtengo un aire de valor y un litoral de valor para que pueda ejecutarse en este trozo de cuerda.
Bien, otra cosa que podemos hacer para mejorar nuestro código es envolverlo en un bloque tri except.
Derecha.
Y luego podemos atrapar.
Así que digamos excepto.
Y aquí, aceptamos un error de valor y digamos como aire y aquí podemos hacer lo que queramos.
Entonces podemos regresar si queremos el aire o incluso podemos levantar el aire en nuestro caso, solo devolvamos el aire.
Y te mostraré por qué en un segundo.
Ahora, si ejecuto esto.
Verá que mi prueba falla, pero ahora es en realidad una aserción, er la aserción er proviene
de nuestro archivo de prueba aquí y estoy afirmando que quiero asegurarme de que el resultado y el valor er
sean iguales.
Ahora, ve aquí que hay un poco de discrepancia, tenemos un error de valor aquí que no es igual al error
de valor de clase.
Ahora, esto es un truco porque estamos devolviendo un aire.
En realidad, es una instancia de la clase value er.
Entonces tenemos que hacer algo como esto, tenemos que decir, oye, es una instancia.
Y digamos, qué es, una instancia de guerra es un resultado, una instancia de valor como esta, pero el problema
aquí.
Es que hagamos esto un poco más grande, el problema aquí es que aseverar igual va a esperar
dos parámetros, dos cosas que deben ser iguales.
Pero aquí solo quiero asegurarme de que esto devuelva verdadero, que el resultado sea una instancia de error de valor.
Entonces, ¿cómo puedo hacer eso?
Bueno, además de afirmar igual, tenemos algunos otros métodos que nos brinda la prueba unitaria.
Si voy a la documentación de la prueba unitaria aquí en la primera línea, dice la lista de métodos de búsqueda.
Entonces, aquí veo que estos son todos los métodos para afirmar y probar nuestro código.
El que probablemente queremos es este Asatru.
Para comprobar si algo es cierto.
Así que si afirmo.
Que esto es cierto.
Y ejecuté mi prueba, aclaremos esto y ejecute mi prueba nuevamente.
Ahí lo tienes, hice dos pruebas y todo parece estar bien, y nuevamente, para repasar esto, ¿por qué es esto?
Bueno, estoy haciendo mi prueba mientras.
Y luego voy a ejecutar la prueba, hacer cosas que van a estar bien, luego hago la segunda parte donde el parámetro de prueba es
algo que realmente no queremos, que es solo un trozo de cuerda.
El resultado nos dará un error de valor porque hemos detectado este error y ahora lo devolvemos.
Y luego, finalmente, ejecutamos este fragmento de código, oye, ¿es cierto, el resultado va a ser un error de
valor?
Entonces, verá lo que estamos haciendo aquí, lo que estamos tratando de hacer con nuestras pruebas es mejorar nuestra
función simplemente tratando de romperla.
Entonces queremos romper nuestra función y decir, oye, ¿puedo engañar a esta función para que me dé un heredero?
Y luego, una vez que haces eso y falla una prueba, vuelves a una función y tratas de arreglarla, algo así como
lo hicimos aquí, lo cual es realmente genial.
Esta es una práctica común con las pruebas en la que intentas romper cosas hasta que, bueno, la función se vuelve
perfecta.
Ahora, quiero que se tomen su tiempo aquí y vean si podemos romper esta función y tal vez agregar un par
de pruebas más en el siguiente video. Voy a agregar algunas más para hacer esta función aún mejor.
Te veo en el proximo.