Bienvenido de nuevo.
Hagamos un pequeño ejercicio divertido revisando un fragmento de código que hemos escrito antes, recuerde
el juego aleatorio sin adivinanzas en el que teníamos que adivinar un número entre uno y diez si ejecutaba este archivo, ¿lo ve?
Me pidió que adivinara.
Digamos que uno, dos, tres, cuatro, cinco, seis, siete, ocho, nueve.
Y finalmente consigo el número.
Eres un genio.
El número era nueve.
Entonces, ¿cómo podemos probar este código ahora?
Una cosa que notará aquí es que realmente no tenemos una función.
Recuerdo cuando les hablé sobre la programación funcional y lo bueno que es dividir nuestro
código en pequeños fragmentos de funciones que hacen una cosa y una cosa realmente bien, especialmente las funciones puras.
Bueno, uno de los grandes beneficios de esa mentalidad es que creas un código que es muy, muy fácil de
probar.
En lugar de tener una lógica realmente complicada en nuestras pruebas, simplemente podemos dar a nuestras funciones una
entrada y esperar una salida y es por eso que tenemos una prueba unitaria.
Y la idea de una prueba unitaria es que estamos probando cada pieza de unidad.
Estas pruebas unitarias son pequeñas piezas que prueban estas funciones simples.
Entonces, mi desafío para ti es usar este código e intentar dividirlo en funciones simples.
Ahora.
En nuestro caso, quiero que probemos esta parte del código, que es la parte de adivinanzas donde recibimos una
entrada.
Cuál será la suposición y luego la probará con alguna respuesta aleatoria que tengamos y deberíamos esperar algún tipo
de resultado.
Entonces, o ingresamos un No.
Tiene que ser de uno a 10, y si lo hacemos bien, tenemos que conseguir la cadena.
Pero la clave aquí es que probablemente queremos mover esto a una función que podamos probar, podemos ignorar
el mundo exterior.
Y divida esto en su propia pequeña función.
Así que pausa el video aquí.
Darle una oportunidad.
Tendrá que superar algunos obstáculos, pero realmente pondrá a prueba su comprensión de las
pruebas.
Ja ja.
Gracioso, eso fue todo.
Así que pasa el video, pruébalo, de lo contrario, me pondré en marcha con la respuesta.
Lo primero que quiero hacer es configurar mi prueba nuevamente, voy a importar la prueba unitaria y voy a crear
la prueba principal de la clase.
O llamemos a un guión de prueba esta vez o un juego de prueba.
Voy a decir caso de prueba de punto de prueba unitaria.
Este será nuestro caso de prueba y luego aquí crearé, digamos, una simple prueba, digamos.
¿Juego o entrada de prueba?
Recibe el yo.
Y por ahora, voy a aprobar esto porque realmente no estamos haciendo nada.
Finalmente, diré si.
Nombre, porque para mí luego ejecutar la prueba unitaria.
Punto principal.
Así que esta es solo nuestra configuración simple.
Entonces, si ejecutamos esto ahora, digamos Python tres.
Prueba por.
Verá que hicimos una prueba.
Muy bien, esta es nuestra configuración a continuación, lo que quiero hacer es eliminar esto para poder usarlo
en mi archivo de prueba extrayéndolo en una función.
Así que solo voy a decir en la parte superior de aquí.
Voy a definir nuestra suposición.
Gain o llamémoslo Ron.
Suponer.
Eso va a recibir una entrada.
O digamos una suposición, y luego ejecutará este código, así que hagámoslo.
Voy a tomar.
Este fragmento de código.
Como esto.
Y simplemente pégalo aquí.
Ahora, la suposición incorrecta también necesitará la variable de respuesta, así que le daré una segunda respuesta de
parámetro.
Así, para que ahora pueda simplemente estar dentro de aquí.
Ejecute esta función con los invitados y responda.
Así.
Así que guardémoslo aquí y ejecutemos esta prueba o simplemente ejecutemos el archivo real para asegurarnos de que sigue funcionando.
Y tenemos un poco de sangría allí, así que tenemos que asegurarnos de que nuestra sangría sea correcta porque
recuerde en Python, eso significa algo.
Muy bien, ahora tenemos un problema, tenemos una pausa fuera del ciclo porque mientras estamos usando la pausa,
la palabra clave y mientras estamos fuera de un ciclo en este momento.
Entonces, una cosa que podemos hacer es decir que regrese aquí.
Así que ejecutemos eso de nuevo.
Y sigue adivinando un nombre.
O un número, y ahí lo tienes.
Esto todavía funciona, puedo usar return aquí porque este pozo se ejecutará y regresará, pero ahora todavía estamos
dentro del juego.
Así que quizás podamos regresar.
Verdadero.
Y di, si.
Corre adivina.
Es cierto, vamos a salir de esto.
Nuevamente, comencemos nuestro juego.
Voy a aclarar esto y ejecutar el juego nuevamente.
Uno dos tres CUATRO.
Y ahí lo tienes.
He introducido un no, soy un genio, acabamos de terminar el juego.
Hagamos esto un poco más pequeño, solo para que pueda ver.
Así que tenemos nuestra ejecución supongo que modifiqué un poco el código.
Pero la clave es que extraje una unidad de funcionalidad para poder probar algo como ejecutar
adivinar.
Parece que modifiqué nuestro código, pero el código sigue funcionando.
Así que ahora comencemos a probar nuestra función más incorrecta.
Vayamos aquí.
Y empieza a importar nuestro script.
Y aquí, haga algunas cosas primero, quiero que la respuesta, digamos, sea igual a cinco.
Y la suposición será igual a cinco, por lo que queremos asegurarnos de que si los invitados
y la respuesta coinciden, bueno, los invitados equivocados revisan la declaración if y la imprimen, usted es un genio o, en nuestro
caso, devuelve verdadero. .
Así que digamos afirmar autodidacta.
Igual.
Ese script o, en realidad, la primera vez, ejecutémoslo, así que tengamos un resultado igual al
script DOT.
¿Qué fue, Rodríguez?
Corre a adivinar y dale la respuesta y adivina.
Y esperamos que el resultado.
Devuelve verdadero, por lo que solo podemos decir afirmar que es cierto.
El resultado es cierto si ahora ejecuto esto.
Oh, en realidad iniciamos el juego, entonces, ¿cómo podemos solucionar esto?
Bueno, podemos cerrar esto y agregar el nombre if main.
Aquí adentro.
Así que aquí abajo.
Diremos, oye, solo ejecuta esto si este es el archivo principal que se está ejecutando así.
Si vuelvo a probar aquí y ejecuto esto nuevamente.
Muy bien, ahora está funcionando, pero obtengo una afirmación de que el objeto del juego de prueba aérea no tiene ningún atributo afirmar verdadero
porque, bueno, yo.
Deletrea mal eso.
Intentémoslo de nuevo.
Muy bien, parece que se ejecutó una prueba y todo está bien.
También vemos que imprimió que eres un genio, muy, muy simpático.
Por cierto, les muestro esta forma de prueba porque así es como se ve un escenario de la vida real.
Sigues rompiendo cosas, sigues cometiendo errores y luego intentas arreglarlos y corregir tu código.
Y puede ver que nuestro código ya se ve cada vez mejor con solo ejecutar estas pruebas.
OK, ¿qué más podemos hacer, digamos, aquí?
Que vamos a copiar esto y para que las cosas sean más breves, solo voy a ingresar directamente los
parámetros aquí.
Así.
Digamos entrada de sabor, digamos incorrecto.
O.
Suposición equivocada.
Digamos que la respuesta es cinco y supongo que cero.
Así que queremos afirmar que esto va a ser igual a falso.
Entonces, si ejecuto esto, pasan dos pruebas, eso es increíble.
¿Qué más podemos probar aquí?
Está bien, bueno, queremos probar que si la suposición no está entre cero y 10 o entre uno y 10, en ese caso,
queremos tener una impresión de, oye, bozo, dije de uno a diez.
Entonces, una vez más, puedo probar.
Eso si mi conjetura es incorrecta.
No.
Digamos que la respuesta es cinco, pero yo doy 11.
Queremos afirmar.
Bueno, ahora mismo estamos imprimiendo y no estamos haciendo nada, así que quizás deberíamos devolver falso solo para tener algo de
coherencia aquí.
De nuevo, si hago eso y corro.
Ahí tienes.
Están pasando tres pruebas, eso es genial, y hay muchas, muchas más pruebas que podemos escribir.
Quizás hagamos una prueba más, que es probar.
¿Qué pasa si la entrada es una cadena?
Si ejecuto esto.
Y asegúrese de que esté mal.
Escriba aquí, asegúrese de que los nombres sean diferentes.
Y tengo cuatro pruebas en ejecución.
Porque esto no va a pasar y volverá falso.
Ahora, hay muchas más cosas que podemos hacer aquí, pero puedes ver el poder de la prueba ahora mismo si tienes una
prueba diferente a la mía.
Eso está bien, todos.
Los casos de prueba son diferentes.
El objetivo de las pruebas es simplemente.
Mire nuestro código y vea cómo podemos mejorarlo, cómo podemos romper nuestro código, cómo podemos simplificar nuestro
código dividiéndolo en unidades más pequeñas, unidades más pequeñas que se pueden probar y corregir algunos errores que quizás
no hubiéramos pensado sobre.
Ahora, hay muchas más cosas que podemos hacer.
Pero aquí se nota cómo la idea era trabajar en pieza pequeña a la vez probada.
Y luego, tal vez más adelante, podamos ver esta parte del código o tal vez probar y aceptar parte del
código.
Y esta es la cuestión, cuando trabajas para una empresa, yo sostengo que hay una cantidad infinita de pruebas que
puedes hacer.
Puede tener cientos de líneas aquí para probar su código en bits.
Pero el hecho de que esté probando tantas veces como sea posible no hace que sus pruebas sean buenas.
Como dije, hay un número infinito de pruebas que puedes escribir.
La idea es escribir pruebas de buena calidad que cubran la mayoría de sus casos, pero eventualmente tendrá
rendimientos decrecientes donde debe tener un equilibrio entre escribir código y escribir pruebas.
Y a veces, dependiendo de lo que requiera el trabajo, es posible que deba concentrarse más en las pruebas y menos
en el código.
O, a veces, tal vez necesite moverse rápido y no tenga tiempo para escribir pruebas.
Y nuevamente, dependiendo de las necesidades comerciales, ese también podría ser el caso.
Pero con esta sección, espero que comprenda algunos de los principios que siguen a las pruebas en el desarrollo de software.
Es decir, siempre van a surgir errores en nuestro código.
Y podemos usar Lintang para ayudarnos con esto, pero una de las mejores formas de asegurarnos de que nuestro
código funcione correctamente es probarlo.
Y cuantas más pruebas tengamos normalmente, más estable será nuestro código.
Lo veré en el próximo, adiós.