Burlando el DS 150 Motonetive

DS 150 MOTONETIVE

Zero está vendiendo sus bicicletas eléctricas ecológicas a través de una lista en constante expansión de distribuidores e incentivos estatales. Aquí en Colorado, el precio después de la deducción de impuestos federales y todos los sobornos llegan a alrededor de $ 4,107.

Una prueba doble, o simulada, es una representación de un objeto que puede usarse para verificar el comportamiento del código. Hay dos tipos de dobles de prueba: trozos y espías.

¿Qué es Mock?

En el burlamiento de las pruebas de software es el uso de objetos simulados para probar las dependencias de una aplicación. Permite al desarrollador centrarse en un alcance más pequeño de la prueba mientras sigue probando un comportamiento real. Al identificar la fuente de falla más fácilmente, la burla también puede ayudar a los desarrolladores a evitar errores comunes, como las pruebas de una dependencia que ya está probada por una prueba en otro alcance.

Se usa simulacro en pruebas de unidad cuando el objeto bajo prueba tiene dependencias en objetos externos (complejos). Para aislar el objeto en prueba, los objetos externos se reemplazan con reemplazos muy controlados: falsificaciones, trozos y simulacros. Los simulacros simulan el comportamiento de las dependencias reales y pueden programarse para responder de manera diferente dependiendo de las entradas que reciben.

Los stubs están diseñados para devolver un valor fijo o responder solo a un conjunto limitado de entradas (programadas por la prueba). Los simulacros son un tipo de trozo más potente y flexible, ya que se pueden programar para proporcionar cualquier resultado basado en las entradas de prueba y también se pueden programar para responder a solicitudes arbitrarias. JustMock proporciona todo este tipo de reemplazos en una sola API, lo que facilita elegir la adecuada para una prueba en particular.

El uso de simulacros en las pruebas unitarias puede aumentar la velocidad de la prueba, lo que permite que la prueba se ejecute más regularmente. Esto puede ser vital para garantizar que los principios básicos de TDD siempre se cumplan y para minimizar la posibilidad de errores que de otro modo se perderían.

Los simulacros también se pueden usar para probar nuevas funciones, por ejemplo, utilizando un simulacro para verificar que un servicio web tenga la funcionalidad necesaria antes de integrarla con el resto del sistema.

El uso de simulacros puede reducir el número de llamadas externas realizadas al sistema bajo prueba, disminuyendo así el costo y el tiempo dedicado a las pruebas de integración. Esta es una consideración importante al diseñar sistemas complejos y de alto rendimiento, ya que puede afectar significativamente el rendimiento general de la aplicación. La burla solo debe usarse para complementar el proceso de prueba de integración, y no como un reemplazo para él.

Objetos de burla

Se burla es una técnica de prueba de software en la que crea objetos simulados que imitan el comportamiento de los objetos reales a los efectos de las pruebas unitarias. Estos objetos simulados se llaman simulacros, trozos, falsificaciones o muñecos y pueden usarse para proporcionar resultados precomputados o asegurarse de que el objeto bajo prueba se invoque como se esperaba. Permiten a los desarrolladores probar partes específicas de una aplicación sin tener que esperar a que los recursos o dependencias externas estén disponibles y son una herramienta útil para crear pruebas unitarias más confiables y enfocadas.

Por ejemplo, si una aplicación usa una base de datos para realizar traducciones complejas y devuelve los resultados a los usuarios, un desarrollador puede usar simulacros de prueba para simular las llamadas a la base de datos en vivo para probar la funcionalidad de la función de traducción dentro de la aplicación sin tener que tener que Espere una respuesta de la base de datos real. Los simulacros de prueba también se pueden usar para probar el código que se basa en integraciones de terceros o conectividad de red externa para funcionar de manera efectiva.

Si bien las definiciones de simulacros varían, Fowler dice que son "objetos preprogramados con expectativas que forman una especificación de las llamadas que se espera que reciban" y Pivotal los describe como trozos de autoverificación. En general, los simulacros se usan para verificar el comportamiento en lugar de probar el código. Se pueden usar para probar casos de borde que de otro modo no serían probados mediante pruebas unitarias regulares.

La principal diferencia entre stubs y simulacros es que los trozos pueden fallar una prueba, mientras que los simulacros están diseñados para pasar todas las pruebas. Esto se debe a que los stubs están destinados a comportarse como la dependencia en la prueba, mientras que los simulacros están destinados a ser más flexibles y le permiten probar tanto el comportamiento de la clase bajo prueba como sus interacciones con otros componentes en el sistema.

Si bien los simulacros son más flexibles, también pueden ser propensos a errores que pueden ser no detectados por otros tipos de pruebas unitarias. Por ejemplo, si olvida que se ha renombrado un método burlado y continúa probando contra él como si no hubiera cambiado, la prueba fallará porque el método simulado se invocará con una firma incorrecta.

Métodos de burla

Cuando usa métodos de burla, esencialmente está simulando llamadas a dependencias externas. Esto es útil para las pruebas unitarias, porque le permite probar el código sin las dependencias. También ahorra tiempo, ya que no está esperando que los servicios externos respondan.

Un ejemplo común de esto es falsificar llamadas a la base de datos. Por ejemplo, si está probando una función que guarda los datos en una base de datos, pero la base de datos aún no existe (ya sea en producción o en forma probable), puede crear una base de datos simulada y eliminar el método que le escribe. Luego puede probar la función sin preocuparse por el estado de la base de datos, y puede ejecutar múltiples pruebas seguidas sin tener que esperar a que el servicio exterior devuelva un resultado.

Hay muchas maneras diferentes de crear simulacros, pero el más común es usar un método de creación de objetos Mockito llamado Togueturn. Esta función toma una llamada de función y devuelve su valor de retorno. Luego puede usar la función Afirmar para verificar que la función se llamó y devolvió el valor correcto.

Otra forma de burlarse de un método es utilizando el método Spy () en Mockito. Este método crea un objeto "espía" que defiende todas las llamadas de método al objeto real. También registra qué método se llamó, y con qué parámetros. Esto es útil para el código heredado que no se puede rediseñar para que se pruebe fácilmente. Sin embargo, puede conducir a un acoplamiento estricto entre el simulacro y el código bajo prueba, lo que puede aumentar el costo de mantenimiento de realizar las pruebas.

También puede agitar un método definiéndolo como una función vacía. Esto generalmente se usa cuando desea probar el manejo de excepciones. Además, puede configurar un trozo para los métodos que lanzarán una excepción llamando a Thenthrow en el objeto simulado.

Los métodos de burla y de renovación son una parte importante del marco de prueba unitaria, y a menudo se usa para probar dependencias externas como bases de datos, API y sistemas de mensajería. Sin embargo, es importante recordar que su burla debe crecer con su código a medida que refactora y cambia su funcionalidad. En otras palabras, si usa muchos datos burlados en sus pruebas, es importante que su burla se actualice cuando el código cambia para que las pruebas sigan funcionando.

Burlarse de los datos

Si bien usar simulacros es una excelente manera de probar su código, tiene sus inconvenientes. Puede conducir a un acoplamiento estricto entre su código y el objeto simulado, lo que puede dificultar sus pruebas de escribir, mantener y ejecutar. Y, si usa simulacros con demasiada frecuencia o demasiado extensamente, puede hacer que su prueba no sea confiable.

Si está probando un método que llama a un servicio externo, puede hacer su prueba más rápido e independiente burlándose del servicio. Esto le permite verificar que el servicio devuelva lo que espera. Por ejemplo, puede burlarse de DateTime para asegurarse de que una función siempre devuelva el mismo valor. Luego, puede probar que la función usa correctamente ese valor de retorno para crear una fecha.

Sin embargo, en algunos casos, la función que está probando tiene demasiada lógica para ser probada por unidad. Cuando esto sucede, es mejor usar una implementación real del servicio, como una prueba de integración en lugar de una versión burlada. Sin embargo, también puede intentar reemplazar la lógica dentro de la función con algo más.

Esto se llama Stubing. Puede agitar un sistema completo, como una base de datos, o puede agitar un solo método dentro del sistema bajo prueba. Los trozos son fáciles de configurar, pero son menos flexibles que los simulacros. Por ejemplo, si agita la base de datos para una función que escribe en la base de datos, no podrá probar ningún otro comportamiento de la prueba, como eliminar archivos.

Un problema con el uso de stubs es que pueden ser difíciles de leer. Idealmente, debe evitarlos y devolver valores predefinidos en sus pruebas. En algunos casos, es necesario eliminar sistemas más complejos, como bases de datos. Para estos, existen algunas herramientas avanzadas como Salty (para Stubing Clean Data) y DBPLYR que proporcionan un enfoque más compatible con las bases de datos. También puede escribir sus propios trozos con herramientas como la burla y la prueba, pero esto puede implicar mucho código duplicado y calderas. También es importante recordar que sus simulacros y trozos deben evolucionar con su código. Si deja sus simulacros en su lugar demasiado tiempo, pueden causar problemas cuando cambia o refactora su código.