¿Qué es el testing unitario? Por qué DEBERÍAS aprenderlo + Ejemplos fáciles de entender

Lazy Loading
18 Nov 202108:09

Summary

TLDREl video ofrece una visión detallada sobre la importancia del testing unitario en el desarrollo de software, un tema que a menudo intimida a los desarrolladores principiantes. Se desmiente la idea de que el testing unitario requiere un conocimiento profundo, y se muestra cómo es una herramienta valiosa para quienes comienzan. Se explica que el testing unitario implica examinar partes pequeñas y comprovables de una aplicación, llamadas unidades, de forma individual para asegurar su correcto funcionamiento. Se utiliza Python como ejemplo debido a su sintaxis clara y seguidilla, aunque el concepto es independiente del lenguaje de programación. Además de corregir errores tempranos y ahorrar costos, el testing unitario ayuda a los desarrolladores a comprender y modificar el código con confianza. Se discuten también los 'test doubles', objetos que reemplazan a otros para mantener la independencia en las pruebas, y se introduce la práctica TDD (Test-Driven Development), que implica escribir los tests antes del código, lo que asegura una cobertura de pruebas y permite un diseño de implementación. Finalmente, se destaca que, aunque puede parecer que el testing unitario retrasa el desarrollo, en realidad se ahorra tiempo en etapas posteriores, y se recomienda su implementación en todos los proyectos.

Takeaways

  • 🧪 El testing unitario es una herramienta valiosa para los desarrolladores principiantes, no solo para los experimentados.
  • 📚 La comprensión de los conceptos básicos, como el de la página text target, ayuda a desmitificar el testing unitario.
  • 🔍 Las unidades más pequeñas de un programa, generalmente funciones o métodos, son examinadas individualmente para verificar su correcto funcionamiento.
  • 🐍 Seleccionar un lenguaje de programación claro y sencillo, como Python, facilita la creación y comprensión de pruebas unitarias.
  • ✅ Las pruebas unitarias son fundamentales para detectar y corregir errores en las etapas tempranas del desarrollo, lo que ahorra costos.
  • 🛠️ Los tests unitarios también ayudan a los desarrolladores a comprender rápidamente el código y a realizar cambios con confianza.
  • 🔄 La reutilización de código es más fácil cuando se tienen pruebas unitarias, lo que es útil para la migración de proyectos.
  • 🤖 Los dobles de prueba (mocks, stubs, fakes, spies, y dummies) son esenciales para probar funciones de manera independiente.
  • 📝 La práctica TDD (Test-Driven Development) implica escribir los tests antes del código, lo que asegura que cada función tenga una prueba asociada y promueve un diseño mejorado.
  • 🚀 A pesar de que escribir pruebas unitarias puede parecer que retrasa el desarrollo, a largo plazo se ahorra tiempo y se mejora la calidad del código.
  • 📚 Es recomendable tener una guía de buenas prácticas y utilizar bibliotecas específicas del lenguaje para realizar pruebas unitarias y TDD.

Q & A

  • ¿Qué es el testing unitario y por qué puede resultar intimidante para los desarrolladores principiantes?

    -El testing unitario es un proceso de prueba de software donde se examinan las partes más pequeñas o unidades de una aplicación de forma individual y independiente para verificar su correcto funcionamiento. Puede intimidar a los desarrolladores principiantes porque creen que requiere un conocimiento profundo para entenderlo, pero en realidad es una herramienta útil para quienes están comenzando.

  • ¿Por qué las pruebas unitarias son especialmente útiles para los desarrolladores que están empezando?

    -Las pruebas unitarias son útiles para los desarrolladores principiantes porque les ayudan a comprender rápidamente cómo funciona el código y a realizar cambios sin miedo a que rompan algo, ya que si ocurre un error, es probable que algún test falle y les notifique el problema.

  • ¿Cómo se ve un test unitario utilizando el lenguaje de programación Python?

    -Un test unitario en Python comienza definiendo una función de prueba, estableciendo una variable con el resultado esperado, invocar la función con los argumentos deseados y finalmente, verificar que el resultado obtenido coincida con el resultado esperado.

  • ¿Cómo pueden las pruebas unitarias ayudar en la fase temprana de desarrollo de software?

    -Las pruebas unitarias ayudan a corregir errores en las etapas tempranas de desarrollo, lo que puede ahorrar costos. Si una función no es testeada correctamente y se encuentra un error en la fase de despliegue, podría requerir actualizar y desplegar nuevamente varias capas de la aplicación, lo que es costoso y tiempo-consuming.

  • ¿Cómo facilitan las pruebas unitarias la reutilización de código?

    -Las pruebas unitarias facilitan la reutilización de código al asegurar que las funcionalidades previamente desarrolladas y probadas funcionen correctamente en un nuevo contexto. Si se migran los tests junto con el proyecto, y estos funcionan bien en el nuevo entorno, se puede estar seguros de que la migración fue exitosa.

  • ¿Qué son los test doubles y cuál es su propósito en el testing unitario?

    -Los test doubles son objetos que reemplazan a otros objetos en pruebas unitarias para mantener la independencia de la prueba. Permiten probar una función sin necesidad de ejecutar las funciones que dependen de ella,模拟不同的行为 y/o mantener un estado para verificar ciertos aspectos de la función que se está probando.

  • ¿Cuáles son los cinco tipos de test doubles mencionados en el script?

    -Los cinco tipos de test doubles son: Stubs (que simulan lo que retorna una función), Mocks (similares a los Stubs pero también comprueban si ciertas funciones fueron llamadas), Dummies (objetos que no hacen nada pero satisfacen las necesidades de una función), Fakes (objetos que simulan diferentes objetos con una implementación distinta) y Spies (Stubs que mantienen información sobre su estado).

  • ¿Qué es TD (Test-Driven Development) y cómo se relaciona con el testing unitario?

    -TD, o Desarrollo Guiado por Tests, es una práctica de programación que implica escribir los tests primero (los tres pasos TDD: Red, Green, Refactor) y luego el código que se está probando. Ayuda a definir claramente los objetivos deseados y asegura que cada función esté acompañada de un test, mejorando la calidad del código y su diseño.

  • ¿Cómo afecta el uso de TD en el proceso de desarrollo de software?

    -El uso de TD puede parecer que retrasa el proceso de desarrollo al requerir escribir tests antes del código. Sin embargo, en realidad se ahorra tiempo en etapas posteriores al detectar errores temprano y permitir un diseño más sólido y previo a la implementación del código.

  • ¿Por qué es recomendable tener un conjunto mínimo de tests para cada cambio realizado en un proyecto?

    -Es recomendable tener un conjunto mínimo de tests para cada cambio porque garantiza que cualquier modificación en el código no introduzca errores y que el código siga funcionando correctamente según lo previsto. Además, facilita la identificación rápida de problemas en caso de que un test falle.

  • ¿Cómo pueden las buenas prácticas y las librerías específicas del lenguaje de programación ayudar en la realización de pruebas unitarias?

    -Las buenas prácticas y las librerías específicas del lenguaje de programación pueden facilitar y estandarizar el proceso de testing unitario. Proporcionan estructuras y utilidades para escribir tests de manera más eficiente, legible y efectiva, adaptadas a las características y particularidades del lenguaje en cuestión.

  • ¿Por qué es importante compartir y discutir los conceptos de testing unitario y TD con otros desarrolladores?

    -Compartir y discutir estos conceptos es importante porque promueve la mejora continua del código y la calidad del software. Ayuda a los desarrolladores a aprender técnicas y prácticas efectivas de testing, a entender los beneficios de estos en el desarrollo de software y a incorporarlos en sus proyectos, lo que lleva a un código más robusto y confiable.

Outlines

00:00

😀 Introducción al testing unitario y su importancia

Este primer párrafo introduce el tema de testing unitario y cómo a menudo puede intimidar a los desarrolladores principiantes. Sin embargo, se aclara que no solo es un mito que requiere un conocimiento profundo, sino que es una herramienta especialmente útil para quienes comienzan. Se menciona el concepto de 'text target' y se describe la definición de un proyecto de desarrollo de software que examina las unidades más pequeñas de una aplicación de forma individual y independiente. Se utiliza Python como ejemplo para demostrar cómo se ve un test unitario, destacando su independencia del lenguaje de programación y su utilidad en la fase de desarrollo para detectar errores temprano y ahorrar costos.

05:01

📚 Pruebas unitarias y su impacto en la reutilización de código y desarrollo

El segundo párrafo profundiza en los beneficios de las pruebas unitarias, destacando cómo pueden ayudar a corregir errores en las etapas tempranas de desarrollo y a ahorrar costos en el largo plazo. Se da un ejemplo hipotético de cómo un error en una biblioteca no testeada podría tener un costo elevado en términos de actualizaciones y despliegues. Además, se discute cómo las pruebas unitarias ayudan a los desarrolladores a comprender el código y a realizar cambios sin miedo a romper cosas, ya que los tests fallarán y alertarán sobre los problemas. También se introduce el concepto de 'dobles' o 'mocks', que son objetos que reemplazan a otros objetos para mantener la independencia de los tests. Se describen los diferentes tipos de dobles y cómo funcionan. Finalmente, se habla sobre TDD (Desarrollo Guiado por Pruebas) como una práctica que implica escribir los tests primero y luego el código, lo que permite un diseño de implementación y asegura que cada cambio venga acompañado de un test.

Mindmap

Keywords

💡Testing unitario

El testing unitario es una práctica en la que se analizan las partes más pequeñas de un programa, llamadas unidades, de forma individual y aislada para comprobar su correcto funcionamiento. En el video, se destaca que este método es especialmente útil para desarrolladores principiantes y permite detectar errores tempranamente en el desarrollo de software.

💡Pruebas inmunizantes

Las pruebas inmunizantes son una técnica de testing que se realiza durante la fase de desarrollo y que, si se implementan correctamente, pueden ayudar a corregir errores en etapas tempranas y, por lo tanto, ahorrar costos. El video menciona que si una biblioteca no es testeada adecuadamente y se encuentra un error en la fase de despliegue, esto podría resultar en un costo significativo para la corrección y actualización de las dependencias.

💡Doble (Mocks, Stubs, Dummies, Fakes, Spies)

Los dobles son objetos que se utilizan en testing unitario para reemplazar a otros objetos y lograr que los tests sean independientes. En el video, se describen cinco tipos de dobles: los Stubs, los Mocks, los Dummies, los Fakes y los Spies, cada uno con una función específica para simular el comportamiento de otros componentes y verificar las interacciones en pruebas de unidad.

💡TDD (Desarrollo orientado a pruebas)

El TDD, o Desarrollo orientado a pruebas, es una práctica de programación que implica escribir primero los tests (los tres primeros pasos: expectativa, comando y verificación) y luego el código que se está probando. En el video se explica que TDD no solo asegura que cada función tenga un test asociado, sino que también ayuda en la definición de objetivos y en un diseño preliminar de la implementación antes de escribir el código.

💡Python

Python es un lenguaje de programación que se destaca por su sintaxis clara y su facilidad de uso, lo que lo hace ideal para los desarrolladores principiantes. En el video, se elige Python como el lenguaje de ejemplo para demostrar cómo se lleva a cabo un testing unitario, mostrando su agnosticismo hacia el lenguaje de programación en el contexto de pruebas unitarias.

💡Funciones

Las funciones son bloques de código reutilizables que realizan una tarea específica y son una de las unidades más pequeñas contra las que se realizan pruebas unitarias. En el video, se utiliza la función 'sumar' como ejemplo para demostrar cómo se estructura un test unitario, definiendo una función de prueba y comparando el resultado esperado con el resultado obtenido.

💡Errores

Los errores son parte inevitable del proceso de desarrollo de software y el testing unitario ayuda a detectarlos en etapas tempranas. Cuando un test unitario falla, como se muestra en el video, indica que la unidad de código no está funcionando como se esperaba, lo que permite corregirlo antes de que el problema afecte a otros componentes del sistema.

💡Reutilización de código

La reutilización de código es un concepto clave en la programación que permite ahorrar tiempo y esfuerzo al no tener que reinventar soluciones existentes. Las pruebas unitarias facilitan la reutilización de código, como se menciona en el video, ya que si se migran los tests junto con el código, se puede verificar la correctitud de la migración sin tener que ejecutar el código en sí.

💡Lenguajes de programación

Los lenguajes de programación son herramientas utilizadas por los desarrolladores para escribir y crear software. Aunque el video utiliza Python como ejemplo, se aclara que el concepto de testing unitario es agnóstico al lenguaje, lo que significa que se puede aplicar a cualquier lenguaje de programación con las bibliotecas y buenas prácticas adecuadas.

💡Buenas prácticas

Las buenas prácticas en programación son técnicas y enfoques recomendados que mejoran la calidad del código y hacen que el proceso de desarrollo sea más eficiente. En el video, se hace referencia a las buenas prácticas relacionadas con el testing unitario y TDD, como la importancia de tener un conjunto de tests para cada cambio en el código y la utilización de bibliotecas específicas para el lenguaje de programación en uso.

Highlights

El video aborda el tema del testing unitario y cómo a menudo intimida a los desarrolladores principiantes.

Se refuta la idea de que se necesita mucho conocimiento para entender el testing unitario, y se lo presenta como una herramienta útil para los recién llegados.

Se define la unidad de prueba en el desarrollo de software como las partes más pequeñas de una aplicación que se examinan individualmente.

Se utiliza Python como el lenguaje de programación para demostrar un test unitario debido a su sintaxis clara y su facilidad de uso.

Se muestra un ejemplo de un test unitario para una función que suma dos números.

Se destaca la importancia de los tests unitarios en la fase de desarrollo para detectar errores tempranos y ahorrar costos.

Se discute cómo la falta de testing unitario puede resultar en un costo elevado en el despliegue y la necesidad de actualizar múltiples bibliotecas y servicios.

Los tests unitarios ayudan a los desarrolladores a entender el código rápidamente y a realizar cambios sin miedo a romper algo, debido a la seguridad que brindan.

Se menciona la ayuda que los tests unitarios proporcionan para la reutilización de código y la migración de proyectos.

Se introduce el concepto de 'dobles' o 'mocks' en pruebas unitarias para simular la ejecución de otras bibliotecas o funciones.

Se describen los cinco tipos de 'mocks' o 'dobles' que se utilizan en pruebas unitarias: stubs, mocks, dummies, fakes y spies.

Se explica la práctica TDD (Test-Driven Development), que consiste en escribir los tests antes del código.

Se ilustra cómo TDD permite definir claramente los objetivos de la función que se está escribiendo y asegurar que cada función tenga un test asociado.

Se proporciona un ejemplo práctico de TDD aplicado a una función de resta en un script.

Se discute cómo TDD puede influir en el diseño de la implementación incluso antes de escribir el código.

Se aboga por la realización de testing en todos los proyectos y se recomienda tener un conjunto mínimo de tests para cada cambio realizado.

Se sugiere que los desarrolladores revisen las buenas prácticas y documentaciones de las herramientas de testing unitario específicas del lenguaje que utilicen.

Se destaca que, aunque puede parecer que escribir tests unitarios retrasa el proceso de desarrollo, a largo plazo se gana tiempo.

Transcripts

play00:00

hola muchachos bienvenidos a un nuevo

play00:01

vídeo para el canal en esta oportunidad

play00:02

vamos a hablar de testing unitario y tv

play00:11

este tema suele darle mucho miedo a los

play00:13

desarrolladores que empiezan porque

play00:15

piensan que hay que saber mucho para

play00:17

entenderlo pero hoy vamos a demostrar

play00:19

que esto no solamente es falso sino que

play00:21

además es una herramienta especialmente

play00:23

útil para la gente que empieza que este

play00:25

es inmunitario vamos a leer el concepto

play00:27

de la página text target que es uno de

play00:29

los conceptos más completos que he leído

play00:31

y uni testing es un proyecto de

play00:33

desarrollo de software en el que las

play00:35

partes comprobables más pequeñas una

play00:37

aplicación llamadas unidades se examinan

play00:40

de forma individual e independiente para

play00:43

comprobar su correcto funcionamiento

play00:44

entonces vamos a probar que unidades

play00:46

pequeñas de nuestro código hagan lo que

play00:48

se supone que tienen que hacer y cómo se

play00:50

ven estas unidades pues normalmente son

play00:52

funciones o métodos de clase vamos a ver

play00:55

cómo se vería un test unitario

play00:56

utilizando el lenguaje de paita porque

play00:58

escogí python porque es uno de los más

play01:00

sencillos con la sintaxis más clara y es

play01:02

el lenguaje con el que trabajo

play01:03

actualmente pero realmente este concepto

play01:05

es agnóstico de los lenguajes de

play01:07

programación bien tenemos una función

play01:09

que se llama at que lo que va a hacer es

play01:10

sumar dos números en este caso a y b y

play01:13

va a retornar en resultados el test

play01:15

unitario de esta función se vería de

play01:17

manera definir una función text

play01:20

definimos una variable con nuestro

play01:22

resultado esperado que en este caso es 3

play01:23

luego ejecutamos o invocamos la función

play01:26

pasándole los argumentos que queremos en

play01:28

este caso 1 y 2 y por último hacemos un

play01:30

hacer de que el resultado que estamos

play01:33

esperando es realmente el resultado que

play01:36

llegó y esto es todo si ejecutamos esta

play01:38

función nos daremos cuenta que el

play01:40

proceso se ejecutó de manera correcta

play01:42

ahora si cambiamos a esta función y le

play01:44

cambiamos el comportamiento y volvemos a

play01:46

ejecutar el test nos daremos cuenta que

play01:48

se va a haber levantado una acción error

play01:51

lo cual quiere decir que en nuestro test

play01:52

ha fallado y así es como se realiza un

play01:54

test unitario el test inmunitario se

play01:56

realiza en la fase de desarrollo y es un

play01:59

paso importante ya que si se implementa

play02:01

de manera correcta puede ayudarnos en

play02:03

los siguientes puntos las pruebas

play02:05

unitarias ayudan a corregir errores en

play02:07

las etapas tempranas de desarrollo y

play02:09

ahorrar costos imaginemos que la función

play02:11

que acabamos de testear llamada app la

play02:13

convertimos en una librería esta

play02:14

librería es utilizada por otra librería

play02:17

llamada mud que realiza multiplicación y

play02:19

a su vez esta librería de multiplicación

play02:21

es utilizada en un micro servicio que

play02:23

ayuda a calcular el carrito de compras y

play02:25

la librería no es testeado correctamente

play02:27

y se encuentra un error por ejemplo en

play02:29

la fase de despliegue esto significaría

play02:31

que la librería that tiene que ser

play02:33

corregida y luego subida una versión lo

play02:35

que significaría que la librería mud

play02:37

tendría que crear una nueva versión

play02:39

apuntando la nueva versión de la

play02:41

librería y a su vez el micro servicio

play02:43

que realiza la comprobación del carrito

play02:45

de compras tendría que subir una versión

play02:47

nueva apuntando a la nueva versión de la

play02:49

librería de moody como ven todo esto es

play02:51

sumamente costoso y esto es un ejemplo

play02:53

muy sencillo pero existen casos

play02:54

realmente complicados además de esto

play02:56

ayuda a los desarrolladores a entender

play02:58

el code veis rápidamente y a realizar

play03:00

cambios nada más como charlé un vistazo

play03:02

a la suite de un proyecto podríamos

play03:05

entender todas las cosas que se realizan

play03:06

en el mismo y además de esto ayuda a los

play03:08

desarrolladores a realizar cambios sin

play03:10

miedos porque saben que si rompen algo

play03:12

probablemente algún test va a fallar y

play03:14

lo va a respaldar además de esto las

play03:16

pruebas unitarias ayudan a la

play03:18

reutilización de código si se migra un

play03:20

proyecto y a su vez emigran los tests

play03:22

que se realizaron para probar este

play03:24

proyecto sólo hace falta asegurarse de

play03:26

que los tests funcionen correctamente

play03:27

para saber que la migración con éxito

play03:30

ahora vamos a ver un concepto muy

play03:32

importante relacionado a las pruebas

play03:33

unitarias llamadas de dobles o dobles de

play03:36

text vamos a volver al caso de la

play03:38

librería mud que utilizaba la librería

play03:40

that para realizar una multiplicación al

play03:42

momento de querer testear esta librería

play03:44

nos damos cuenta que para que funcione

play03:46

en nuestra librería es necesario la

play03:48

correcta ejecución de la librería pero

play03:50

si recordamos el concepto del principio

play03:52

un test unitario debería aprobar esta

play03:54

función de manera individual e

play03:56

independiente por lo tanto queremos que

play03:58

nuestro test pruebe esta función muy sin

play04:00

tener que ejecutar la función a para

play04:02

esto utilizamos los test de bus que no

play04:04

son más que objetos que reemplazan a

play04:06

otros objetos para lograr que nuestro

play04:08

ustedes sean independientes existen

play04:10

cinco tipos de texto bus los stops que

play04:12

son objetos que simulan lo que retorna

play04:15

la función que vas a probar los mods que

play04:17

son similares a los stops pero también

play04:19

puedes comprobar que ciertas funciones

play04:21

fueron llamadas y los dormis que son

play04:23

objetos que realmente no hacen

play04:24

absolutamente nada pero permiten

play04:26

satisfacer las necesidades de una

play04:28

función los fakes que son objetos que

play04:30

simulan diferentes objetos mediante una

play04:32

implementación distinta como por ejemplo

play04:34

un sistema de auténticas y por último

play04:36

los tres países que son stops pero que

play04:38

mantienen información sobre el estado

play04:40

del mismo y por último en este vídeo

play04:42

vamos a hablar sobre ted describe nivel

play04:44

td es una práctica de programación que

play04:47

consiste en escribir los tres primeros y

play04:49

luego escribir el código que se está

play04:50

probando de esta manera puedes definir

play04:53

claramente los objetivos que buscas a

play04:55

realizar el código que estás escribiendo

play04:56

y además de esto te aseguras que no

play04:59

existan ninguna función que no esté

play05:00

debidamente acompañada de un test bien

play05:02

vamos a ver cómo se ve esto de td en la

play05:04

práctica problemas nuestro ejemplo de la

play05:06

función y ahora digamos que queremos que

play05:08

este pequeño script realice más

play05:10

funciones que no sólo sea la suma

play05:11

queremos que por ejemplo también realice

play05:13

resta re nombramos nuestro archivo de

play05:15

atacar y real nombramos también el test

play05:17

antes acá lo que normalmente haríamos

play05:19

definir en este archivo la función

play05:21

sustrato por ejemplo y luego iríamos a

play05:24

los tests y 2 y tendríamos el test que

play05:25

lo prueba con td en lo que tendríamos

play05:27

que hacer es empezar de hecho por el de

play05:29

ficción que son un poquito extraño y

play05:31

confusos y no los trabajaba antes pero

play05:33

veremos que tiene todo el sentido del

play05:34

mundo empezamos definiendo nuestro test

play05:36

en este caso lo vamos allá artes como

play05:39

vibración de subte a veces el copa y lo

play05:41

que están fastidiando en este caso

play05:43

nuestro spector crisol podría ser igual

play05:45

3 en este caso el copiloto nos está

play05:48

completando su y vamos a hacer el mismo

play05:50

caso bueno vamos a decir 5 menos 2 y

play05:53

correctamente y luego de último hacemos

play05:55

un hacer de que actual es igual a

play05:58

spector sol y lo que tendríamos que

play05:59

hacer es llamar a esta función bien si

play06:02

ejecutamos este archivo nos daremos

play06:03

cuenta que hay un atributo error y dice

play06:05

el módulo calc no tienen atributos sub

play06:07

porque porque realmente no lo hemos

play06:09

implementado pero cuando trabajamos con

play06:11

td esto es realmente lo que queremos que

play06:13

nuestro test falle primero porque porque

play06:15

no hemos realizado ningún código que

play06:17

respalde este test después que tenemos

play06:18

nuestros tres fallando ahora sí podemos

play06:20

implementar la función sub que es la que

play06:22

falta nos vamos a nuestro hogar a

play06:24

nuestro módulo ponemos sub de aire igual

play06:26

y dejamos que compay lo complete bien

play06:29

muy bien y ahora si ejecutamos nuestro

play06:31

módulo de nuevo nos daremos cuenta que

play06:32

todo se ejecutó perfectamente y se fijan

play06:34

cuando realizamos el test sin saber o

play06:36

sin tener la función primero de alguna

play06:38

manera realizamos un poquito de diseño

play06:41

sobre cómo iba a ser nuestra

play06:42

implementación pusimos el nombre a la

play06:43

función sub que todaví existía por lo

play06:45

tanto utilizar t no sólo te permite

play06:47

tener siempre un test sino además te

play06:49

permite hacer un poquito de diseño de

play06:51

implementación a nivel de test inclusive

play06:53

antes de escribir ningún tipo de código

play06:55

y ya para finalizar sé que probablemente

play06:56

estás pensando que escribir tests

play06:58

unitarios hace que se retrase el proceso

play07:00

de desarrollo pero en realidad estás

play07:02

ganando tiempo en etapas posteriores por

play07:04

lo tanto es recomendable realizar

play07:05

testing en todos los proyectos que

play07:08

trabajes con respecto a td no es

play07:10

necesariamente estricto que lo

play07:11

implementas en tu tipo de desarrollo no

play07:13

es mandatorio que empieces cada cosa que

play07:15

realices a través de un test a veces

play07:17

esto suele ser realmente complicado pero

play07:19

lo que sí es recomendable es que tengas

play07:21

un main set de que todo cambio que

play07:22

realices debe venir acompañado de un

play07:24

test además de esto dependiendo del

play07:26

lenguaje con el que tú trabajes existen

play07:28

distintas librerías para realizar este

play07:29

tipo de test además existen distintas

play07:31

librerías para implementar los test op

play07:33

adicional a esto cada lenguaje tiene sus

play07:36

buenas prácticas de cómo realizar el

play07:37

test así que te animo a que revisen las

play07:39

documentaciones de estas herramientas

play07:41

esto fue todo por el vídeo de hoy antes

play07:43

de despedirme me gustaría que te

play07:45

suscribas al canal que le des me gusta

play07:47

si disfrutaste estos vídeos y que lo

play07:49

compartas con amigos desarrolladores nos

play07:51

vemos en un próximo vídeo y happy

play07:53

calling

play07:54

[Música]

play07:57

[Aplausos]

play08:01

[Música]

Rate This

5.0 / 5 (0 votes)

Related Tags
Testing UnitarioDesarrollo de SoftwarePythonCódigoErroresReutilizaciónPruebasDoble de PruebasTDDProgramaciónDesarrolladores
Do you need a summary in English?