Introducción a la prueba unitaria

Una prueba unitaria es una técnica de pruebas de software para verificar la funcionalidad de componentes o unidades de un programa de manera aislada del resto de la aplicación.

Por lo general, una “unidad” es la parte más pequeña que se puede probar de un programa, como una función, método, clase o script. Dividir scripts o algoritmos complejos en estas unidades más pequeñas permite desarrollar pruebas precisas y específicas para validar la funcionalidad de cada componente.

Relevancia de la prueba unitaria

Realizar pruebas unitarias de unidades individuales en etapas iniciales permite detectar y corregir errores, lo que se traduce en un código más fiable, además de proyectos de depuración menos complicados y lentos. También permite desarrollar software modular y mantenible, lo que, a su vez, mejora la calidad del código.

Beneficios y desafíos de la prueba unitaria

Una prueba unitaria ofrece varias ventajas:

• Las pruebas unitarias suelen ser más fáciles de desarrollar y más rápidas de ejecutar que pruebas más completas o de todo un sistema.
• Es probable que resulte más sencillo identificar y aislar bugs en una etapa temprana.
• Puede ayudar a identificar problemas en otras partes del software, y reducir al mínimo el número de interacciones con subsistemas.
• Puede comenzar a realizar pruebas en etapas de desarrollo iniciales, sin necesidad de esperar a que se complete toda la aplicación.

No obstante, un desafío es que probar unidades por separado no siempre detecta todos los problemas.

Cuándo realizar una prueba unitaria

Para garantizar la calidad del código y detectar como repercuten los cambios de codificación, se deben realizar pruebas unitarias a lo largo del proceso de desarrollo:

• Durante el desarrollo: Desarrolle pruebas unitarias a medida que crea nuevas funcionalidades. Este enfoque garantiza que todos los componentes funcionen según lo previsto desde el principio.
• Durante la refactorización: Utilice pruebas unitarias para asegurarse de que la refactorización no altera el comportamiento esperado del código.
• Después de correcciones de fallos: Implemente pruebas unitarias para bugs que se han resuelto, para evitar que se repitan y garantizar que las correcciones no afectan negativamente a otras funcionalidades del software.
• Antes y durante la integración: Realice pruebas unitarias antes de fusionar cambios en el código principal e incorporarlos en un flujo de integración continua (CI). Esto evita que el nuevo código genere errores y ayuda a mantener una base de código estable.

La pirámide de pruebas de software

Realizar una prueba unitaria en etapas iniciales y durante todo el proceso de desarrollo de software permite obtener código de mejor calidad. No obstante, la prueba unitaria es solo una parte de una estrategia integral. La pirámide de pruebas de software ilustra los distintos niveles de pruebas (prueba unitaria, pruebas de integración y pruebas del sistemas) y muestra su granularidad y frecuencia. Esta pirámide ofrece un enfoque estructurado para gestionar y priorizar los esfuerzos de pruebas, y resalta el equilibrio necesario para lograr una calidad del software óptima.

Las características de estos tipos de pruebas son:

• Prueba unitaria: en la base de la pirámide, es la más granular y se ejecuta con frecuencia. Las pruebas unitarias suelen ser pequeñas; por tanto, su desarrollo y ejecución es más rápido y rentable. Se pueden implementar en etapas iniciales del proceso de desarrollo, y ofrecen información inmediata sobre la funcionalidad de componentes individuales.
• Pruebas de integración: situadas en el centro de la pirámide, se centran en verificar las interacciones entre diferentes componentes o sistemas. Las pruebas de integración son un poco más complejas y lentas que las pruebas unitarias, pero son cruciales para garantizar que los componentes integrados funcionan juntos según lo esperado.
• Pruebas del sistema: en la cima de la pirámide, evalúan toda la aplicación. Las pruebas del sistema son más completas y requieren más recursos. Por lo general, se realizan en las etapas finales del ciclo de desarrollo para validar que todo el sistema cumple con los requisitos especificados.

La pirámide destaca la importancia de realizar más pruebas de bajo nivel, como pruebas unitarias, y menos pruebas de alto nivel. Un enfoque equilibrado persigue aproximadamente un 70% de pruebas unitarias, un 20% de pruebas de integración y un 10% de pruebas del sistema al final del proyecto. Esta estrategia garantiza una base sólida de código fiable, y reduce la probabilidad de problemas en etapas de pruebas de nivel superior.

Otros tipos de pruebas de software

Además de la granularidad y frecuencia de las pruebas representadas por la pirámide de pruebas de software, existen varios tipos de métodos de pruebas, cada uno con objetivos específicos en función de los resultados previstos. Una distinción clave es entre pruebas funcionales y no funcionales:

• Pruebas funcionales: se centran en verificar que la funcionalidad y comportamiento del software sean correctos. Algunos ejemplos incluyen las pruebas de humo, que comprueban funcionalidad básica, y las pruebas de regresión, que garantizan que los cambios de código nuevos no afectan negativamente a funcionalidades existentes.
• Pruebas no funcionales: evalúan otros aspectos críticos del software, como usabilidad, seguridad y estabilidad. Las pruebas de rendimiento son el tipo más común de pruebas no funcionales, y evalúan cuán bien funciona el software en condiciones específicas de carga y estrés.

Utilizar pruebas funcionales y no funcionales garantiza que el software funciona correctamente y cumple con los estándares de calidad.

Prueba unitaria con MATLAB

Probar el código es una parte fundamental del desarrollo de software de calidad. MATLAB^® ofrece un marco de pruebas unitarias sólido e integrado que permite desarrollar pruebas unitarias y monitorizar regresiones de funcionalidad del código. Con este marco se pueden desarrollar pruebas empleando clases, lo que permite estructurar las pruebas de manera lógica. Además, puede ejecutar y analizar resultados de pruebas.

Pruebas unitarias basadas en clases

Con este enfoque, las pruebas se definen como métodos de una clase. MATLAB puede generar una plantilla genérica, mientras que MATLAB Test™ puede generar una prueba específica para el código. Este enfoque permite probar scripts y funciones conforme a sus métodos de pruebas, así como combinar programación orientada a objetos con la flexibilidad para probar diversos tipos de código. Este ejemplo ilustra el desarrollo de pruebas unitarias basadas en clases.

Ejecución de pruebas

Una vez guardado el archivo de prueba, puede ejecutar la prueba desde la barra de herramientas de MATLAB. También puede servirse de la función runtests o la app MATLAB Test Browser para ejecutar pruebas, ver resultados y depurar fallos de manera interactiva.

Análisis de resultados de pruebas

MATLAB ofrece resúmenes, informes detallados y cobertura de código para analizar código fuente.

Las prestaciones más avanzadas de MATLAB Test incluyen funcionalidades adicionales que mejoran el proceso de pruebas, como generación automática de pruebas, gestión mejorada de pruebas, integración con sistemas de CI/CD, cobertura de código avanzada y un panel de calidad. Obtenga más información sobre análisis de resultados de pruebas.

Ejemplo de prueba unitaria en MATLAB

Este ejemplo muestra cómo realizar una prueba unitaria de una función fibonacci sencilla. Esta función calcula la secuencia de Fibonacci hasta un número especificado (n). Para validar su exactitud, proporcionamos entradas de ejemplo, y la prueba unitaria comprueba si la salida calculada coincide con la salida esperada para la entrada suministrada. Si las salidas coinciden, la prueba es correcta; en caso contrario, es incorrecta.

function x = fibonacci (n) 
% Generate the first n Fibonacci numbers
n=6;
x = ones (1,n);
for ii = 3:n;
      x(ii) = x(ii - 1) + x(ii - 2);
end

end

% This is an autogenerated sample test for file fibonacci.m
classdef test fibonacci < matlab.unittest.TestCase

    methods (Test)

        function test_fibonacci (testCase)
            % Specify the input (s) of
            % fibonacci
            n = 6;

            % Specify the expected output(s) of
            % fibonacci
            expected_x = [1, 1, 2, 3, 5, 8];

            % Exercise the function fibonacci
            actual_x = fibonacci(n);

            testCase.verifyEqual(actual_x,expected_x);

        end
    end
end