Calidad_unittesting_and_tdd.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.7"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#TDD"
      ],
      "metadata": {
        "id": "8TMTGC9wTFE3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## El Desarrollo Dirigido por Pruebas (TDD)\n",
        "\n",
        "El **Desarrollo Dirigido por Pruebas (TDD)**, por sus siglas en inglés, es una metodología de desarrollo de software que se enfoca en escribir pruebas automatizadas antes de escribir el código de producción. Este enfoque promueve la iteración, la claridad en el diseño y la calidad del código. El proceso de TDD generalmente sigue los siguientes pasos:\n",
        "\n",
        "1. **Escribir una prueba (Test First):** Comienza escribiendo una prueba automatizada que describa una funcionalidad específica que deseas implementar. La prueba debe ser lo suficientemente pequeña y específica para que falle inicialmente.\n",
        "\n",
        "2. **Ejecutar la prueba y fallar (Red):** Ejecuta la prueba recién escrita. Espera que falle, ya que aún no has implementado la funcionalidad que estás probando. Si la prueba no falla, verifica que esté correctamente escrita y que refleje el comportamiento deseado.\n",
        "\n",
        "3. **Escribir el código mínimo para que la prueba pase (Green):** Escribe la cantidad mínima de código necesario para que la prueba pase. El objetivo es que la prueba pase de manera exitosa, sin preocuparte por escribir código perfecto o optimizado en este momento.\n",
        "\n",
        "4. **Refactorizar (Refactor):** Una vez que la prueba ha pasado, puedes mejorar y refactorizar el código para que sea más legible, eficiente y mantenible. Asegúrate de que las pruebas sigan pasando después del refactorizado.\n",
        "\n",
        "5. **Repetir (Cycle):** Repite los pasos anteriores para agregar más funcionalidades. Escribe una nueva prueba, asegúrate de que falle, implementa el código mínimo para hacerla pasar y luego refactoriza.\n",
        "\n",
        "TDD promueve varios beneficios:\n",
        "\n",
        "- **Mayor calidad del código:** Al escribir pruebas antes de implementar el código, te aseguras de que la funcionalidad sea correcta y libre de errores.\n",
        "\n",
        "- **Diseño claro y modular:** TDD fomenta la creación de interfaces bien definidas y módulos independientes, lo que conduce a un diseño de software más limpio.\n",
        "\n",
        "- **Retroalimentación inmediata:** Las pruebas te proporcionan una retroalimentación rápida sobre el estado de tu código, lo que te permite detectar problemas temprano y abordarlos antes de que se acumulen.\n",
        "\n",
        "- **Documentación viva:** Las pruebas actúan como documentación viva del comportamiento esperado de tu código.\n",
        "\n",
        "- **Mayor confianza en el código:** Tener pruebas sólidas te brinda confianza para realizar cambios y mejoras en el código sin temor a introducir errores inadvertidamente.\n",
        "\n",
        "TDD es una práctica poderosa para el desarrollo de software, pero requiere un enfoque disciplinado y un cambio de mentalidad. Al seguir este enfoque, puedes desarrollar software más robusto y de mayor calidad.\n"
      ],
      "metadata": {
        "id": "JudnYfaPVWWf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install nose2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aiKuDw_cUMXT",
        "outputId": "e811fe14-018c-4ccf-bf4e-46f60feeb95d"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting nose2\n",
            "  Downloading nose2-0.13.0-py3-none-any.whl (205 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/205.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[91m━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m112.6/205.6 kB\u001b[0m \u001b[31m3.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m205.6/205.6 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: nose2\n",
            "Successfully installed nose2-0.13.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nose2 -v"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iDgYChQQUV2J",
        "outputId": "20d3eed4-1954-4428-c1e9-8f8257247f33"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 0 tests in 0.000s\n",
            "\n",
            "OK\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Calculator:\n",
        "    def add(self, a, b):\n",
        "        return a + b\n",
        "\n",
        "    def sub(self, a, b):\n",
        "        return a - b\n",
        "\n",
        "    def mul(self, a, b):\n",
        "        return a * b\n",
        "\n",
        "    def div(self, a, b):\n",
        "\n",
        "\n",
        "# Creamos una instancia de la calculadora\n",
        "calc = Calculator()\n",
        "\n",
        "# Pruebas\n",
        "assert calc.add(2, 3) == 5\n",
        "assert calc.sub(5, 2) == 3\n",
        "assert calc.mul(4, 3) == 12\n",
        "assert calc.div(10, 2) == 5\n",
        "\n",
        "print(\"Todas las pruebas han pasado.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 140
        },
        "id": "VxmrkVoCT8Bb",
        "outputId": "e5b1c6ba-0634-40d0-e992-b5bc2391a86d"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-27-ba256a4e1759>\"\u001b[0;36m, line \u001b[0;32m15\u001b[0m\n\u001b[0;31m    calc = Calculator()\u001b[0m\n\u001b[0m                       ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after function definition on line 11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Pruebas que fallan"
      ],
      "metadata": {
        "id": "xXI0xIGwVf_b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Calculator:\n",
        "    def add(self, a, b):\n",
        "        return a + b\n",
        "\n",
        "    def sub(self, a, b):\n",
        "        return a - b\n",
        "\n",
        "    def mul(self, a, b):\n",
        "        return a * b\n",
        "\n",
        "    def div(self, a, b):\n",
        "        if b != 0:\n",
        "            return a / b\n",
        "\n",
        "# Creamos una instancia de la calculadora\n",
        "calc = Calculator()\n",
        "\n",
        "# Pruebas que fallan\n",
        "assert calc.add(2, 3) == 6   # Debería ser 5\n",
        "assert calc.sub(5, 2) == 2   # Debería ser 3\n",
        "assert calc.mul(4, 3) == 10  # Debería ser 12\n",
        "assert calc.div(10, 2) == 4  # Debería ser 5\n",
        "\n",
        "print(\"Todas las pruebas han sido ejecutadas.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 245
        },
        "id": "Q8WQCTrpU1Qg",
        "outputId": "01a473c9-f481-41d3-a077-9635f84b07b4"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AssertionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-25-f2763854c5f4>\u001b[0m in \u001b[0;36m<cell line: 19>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;31m# Pruebas que fallan\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m6\u001b[0m   \u001b[0;31m# Debería ser 5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msub\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m2\u001b[0m   \u001b[0;31m# Debería ser 3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mcalc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmul\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m10\u001b[0m  \u001b[0;31m# Debería ser 12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAssertionError\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3M1vUNoetsJ"
      },
      "source": [
        "# Pruebas unitarias\n",
        "La prueba unitaria es donde cada unidad del sistema se prueba individualmente. El propósito es aislar cada parte del sistema para verificar que funcionan según lo especificado. El uso de este tipo de prueba a lo largo de la implementación es posible para reducir la cantidad de errores en la aplicación. Funciona comparando la salida de una función a probar con los valores esperados.\n",
        "\n",
        "Mire el siguiente video de 2 minutos para una comprensión más clara sobre las pruebas unitarias."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FqPzHkOg2gJO",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 322
        },
        "outputId": "1b8741db-e6c2-4649-e94e-564d901e525b"
      },
      "source": [
        "from IPython.display import YouTubeVideo\n",
        "YouTubeVideo('upzTwaVNZzs')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<IPython.lib.display.YouTubeVideo at 0x79509a5d5300>"
            ],
            "text/html": [
              "\n",
              "        <iframe\n",
              "            width=\"400\"\n",
              "            height=\"300\"\n",
              "            src=\"https://www.youtube.com/embed/upzTwaVNZzs\"\n",
              "            frameborder=\"0\"\n",
              "            allowfullscreen\n",
              "            \n",
              "        ></iframe>\n",
              "        "
            ],
            "image/jpeg": "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\n"
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P1eC38LM0OUr"
      },
      "source": [
        "## Práctica\n",
        "\n",
        "<un\n",
        "href=\"https://colab.research.google.com/github/damorimRG/practical_testing_book/blob/master/testgranularity/unittesting.ipynb\" target=\"_blank\">\n",
        "<img alt=\"Abrir en Colab\" src=\"https://colab.research.google.com/assets/colab-badge.svg\"></a>\n",
        "\n",
        "A continuación tenemos una clase de calculadora básica que usaremos en este tutorial. Tiene la opción de abrirlo en Google Colab haciendo clic en el botón de arriba `Abrir en Colab` donde puede ejecutar y modificar el código.\n",
        "\n",
        "El marco de prueba de unidades de Python que usaremos se llama `unittest`, uno de los marcos más conocidos para probar el código de Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bc83M4RyeDyq"
      },
      "source": [
        "import unittest"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NlSOSDXT8TM5"
      },
      "source": [
        "Nuestra calculadora básica tiene solo cuatro operaciones básicas: suma, resta, multiplicación y división."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wM6zJL3X8IDy"
      },
      "source": [
        "class Calculator:\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def add(self, a, b):\n",
        "        return a + b\n",
        "\n",
        "    def sub(self, a, b):\n",
        "        return a - b\n",
        "\n",
        "    def mul(self, a, b):\n",
        "        return a * b\n",
        "\n",
        "    def div(self, a, b):\n",
        "        if b != 0:\n",
        "            return a / b"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fLu5dxMlKTC1"
      },
      "source": [
        "El objetivo es garantizar que cada método funcione correctamente y proporcione el resultado correcto al recibir dos entradas cualesquiera.\n",
        "\n",
        "Un caso de prueba se crea subclasificando `unittest.TestCase`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m_9AnKez-E-h"
      },
      "source": [
        "class TestCalculator(unittest.TestCase):\n",
        "\n",
        "    def test_add(self):\n",
        "        '''Test case function for addition'''\n",
        "        self.calc = Calculator()\n",
        "        result = self.calc.add(4, 7)\n",
        "        expected = 11\n",
        "        self.assertEqual(result, expected)\n",
        "\n",
        "    def test_sub(self):\n",
        "        '''Test case function for subtraction'''\n",
        "        self.calc = Calculator()\n",
        "        result = self.calc.sub(10, 5)\n",
        "        expected = 5\n",
        "        self.assertEqual(result, expected)\n",
        "\n",
        "    @unittest.skip('Some reason')\n",
        "    def test_mul(self):\n",
        "        '''Test case function for multiplication'''\n",
        "        self.calc = Calculator()\n",
        "        result = self.calc.mul(3, 7)\n",
        "        expected = 21\n",
        "        self.assertEqual(result, expected)\n",
        "\n",
        "    def test_div(self):\n",
        "        '''Test case function for division'''\n",
        "        self.calc = Calculator()\n",
        "        result = self.calc.div(10, 2)\n",
        "        expected = 4\n",
        "        self.assertEqual(result, expected)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w5YMvPwo-mqb"
      },
      "source": [
        "Creamos 4 pruebas unitarias, cada una de ellas verifica un método de la clase calculadora. Estas comprobaciones se realizan mediante llamadas a `Assertions`, en este caso la función `assertEqual`. Tenga en cuenta que marcar el método `test_mul` con `@unittest.skip('your_reason')` omitirá la prueba para ese método.\n",
        "\n",
        "Para simplemente ejecutar las pruebas, use:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G0wAtv8a-4bM",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8dfd7b22-cd80-4f3d-c096-b97034da7f34"
      },
      "source": [
        "unittest.main(argv=[''], verbosity=2, exit=False)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "test_div (__main__.TestCalcDiv)\n",
            "Test case function for division ... ok\n",
            "test_div_error (__main__.TestCalcDiv)\n",
            "Make sure ZeroDivisionError is raised when necessary ... FAIL\n",
            "test_div (__main__.TestCalculator)\n",
            "Make sure ZeroDivisionError is raised when necessary ... FAIL\n",
            "\n",
            "======================================================================\n",
            "FAIL: test_div_error (__main__.TestCalcDiv)\n",
            "Make sure ZeroDivisionError is raised when necessary\n",
            "----------------------------------------------------------------------\n",
            "Traceback (most recent call last):\n",
            "  File \"<ipython-input-9-4d1412c0fd4d>\", line 14, in test_div_error\n",
            "    self.assertRaises(ZeroDivisionError, self.calc.div, 10, 0)\n",
            "AssertionError: ZeroDivisionError not raised by div\n",
            "\n",
            "======================================================================\n",
            "FAIL: test_div (__main__.TestCalculator)\n",
            "Make sure ZeroDivisionError is raised when necessary\n",
            "----------------------------------------------------------------------\n",
            "Traceback (most recent call last):\n",
            "  File \"<ipython-input-7-3eaf8b53df88>\", line 6, in test_div\n",
            "    self.assertRaises(ZeroDivisionError, self.calc.div, 10, 0)\n",
            "AssertionError: ZeroDivisionError not raised by div\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 3 tests in 0.024s\n",
            "\n",
            "FAILED (failures=2)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<unittest.main.TestProgram at 0x79509a66db40>"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ViO48KML_qJL"
      },
      "source": [
        "\n",
        "Después de ejecutar verás algo como:\n",
        "\n",
        "```\n",
        "test_add (__main__.TestCalculator)\n",
        "Test case function for addition ... ok\n",
        "test_div (__main__.TestCalculator)\n",
        "Test case function for division ... FAIL\n",
        "test_mul (__main__.TestCalculator)\n",
        "Test case function for multiplication ... skipped 'Some reason'\n",
        "test_sub (__main__.TestCalculator)\n",
        "Test case function for subtraction ... ok\n",
        "```\n",
        "\n",
        "\n",
        "Donde la suma y la resta pasaron, la multiplicación se omitió intencionalmente y la división falló.\n",
        "\n",
        "Unittest tiene varias funciones, conocidas como `Assertions`, útiles para el desarrollo de pruebas unitarias. Algunos son: `assertNotEqual(a, b)`, `assertTrue(x)`, `assertFalse(x)`, `assertIs(a, b)`, `assertIsNot(a, b)`, `assertIsNone(x)` , y mucho más."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oSNV-9X2K9FS"
      },
      "source": [
        "\n",
        "## Pruebas de excepción\n",
        "\n",
        "Del mismo modo, las funciones `assert*` enumeradas anteriormente también tienen la función `assertRaises` para probar una excepción.\n",
        "\n",
        "Utilice: `assertRaises(excepción, invocable, *args, **kwds)`\n",
        "\n",
        "Donde `exception` es el tipo de excepción, `callable` es el método a probar y `args` son parámetros opcionales pasados ​​al método `callable`.\n",
        "\n",
        "Cambiemos la operación de división de la calculadora por un uso práctico de `assertRaises`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "apjyti3t7w4g"
      },
      "source": [
        "class Calculator:\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def add(self, a, b):\n",
        "        return a + b\n",
        "\n",
        "    def sub(self, a, b):\n",
        "        return a - b\n",
        "\n",
        "    def mul(self, a, b):\n",
        "        return a * b\n",
        "\n",
        "    def div(self, a, b):\n",
        "        if b == 0:\n",
        "            raise ZeroDivisionError(\"The divisor must not be zero\")\n",
        "        return a / b"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtKXCsfDId5E"
      },
      "source": [
        "Cada vez que se llama a `div` con el divisor igual a 0, aparece un error. Compruébelo ejecutando el siguiente caso de prueba:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8wBtAY0II8bG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "176869ca-bce3-4d26-b1b7-9cb8e4d3eff4"
      },
      "source": [
        "class TestCalculator(unittest.TestCase):\n",
        "\n",
        "    def test_div(self):\n",
        "        '''Make sure ZeroDivisionError is raised when necessary'''\n",
        "        self.calc = Calculator()\n",
        "        self.assertRaises(ZeroDivisionError, self.calc.div, 10, 0)\n",
        "\n",
        "unittest.main(argv=[''], verbosity=2, exit=False)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "test_div (__main__.TestCalculator)\n",
            "Make sure ZeroDivisionError is raised when necessary ... ok\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 1 test in 0.011s\n",
            "\n",
            "OK\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<unittest.main.TestProgram at 0x79509a6267a0>"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YWCrD0yyJHXa"
      },
      "source": [
        "\n",
        "La prueba pasa porque 10 sobre 0 genera una excepción `ZeroDivisionError`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wUBMH5EmxRTf"
      },
      "source": [
        "## Organización de casos de prueba\n",
        "\n",
        "La organización de los casos de prueba es fundamental para hacerlos mejores, más independientes y ayudar a su mantenimiento. Para eso, existen varios estándares relacionados con las pruebas automatizadas que se pueden utilizar en las pruebas unitarias. Algunos de ellos son:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SrsCjvFtKMse"
      },
      "source": [
        "### Organización por instancias\n",
        "\n",
        "Como se vio anteriormente, los casos de prueba de unidad están representados por instancias `unittest.TestCase`. En otras palabras, creamos solo una clase de prueba que contiene todas las pruebas de sus métodos. Para una buena organización del código de prueba, es posible crear diferentes instancias, lo que significa que cada una puede contener un montón de pruebas específicas para un solo método.\n",
        "\n",
        "Vamos a crear otro caso de prueba solo para división."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BcyiMC0BKTM5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a2e004fd-51ba-46c5-b107-dcdde81d33a9"
      },
      "source": [
        "class TestCalcDiv(unittest.TestCase):\n",
        "\n",
        "    def test_div(self):\n",
        "        '''Test case function for division'''\n",
        "        self.calc = Calculator()\n",
        "        self.assertEqual(self.calc.div(10, 5), 2)\n",
        "        self.assertEqual(self.calc.div(12, 2), 6)\n",
        "\n",
        "    def test_div_error(self):\n",
        "        '''Make sure ZeroDivisionError is raised when necessary'''\n",
        "        self.calc = Calculator()\n",
        "        self.assertRaises(ZeroDivisionError, self.calc.div, 10, 0)\n",
        "\n",
        "unittest.main(argv=[''], defaultTest='TestCalcDiv', verbosity=2, exit=False)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "test_div (__main__.TestCalcDiv)\n",
            "Test case function for division ... ok\n",
            "test_div_error (__main__.TestCalcDiv)\n",
            "Make sure ZeroDivisionError is raised when necessary ... ok\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 2 tests in 0.013s\n",
            "\n",
            "OK\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<unittest.main.TestProgram at 0x79509a6276d0>"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C2OjssRIPiDS"
      },
      "source": [
        "\n",
        "El caso de prueba anterior pasará."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vkVGBtwwxXac"
      },
      "source": [
        "### Configurar() y Desmontar()\n",
        "\n",
        "Los métodos setUp y tearDown también son útiles para organizar casos de prueba. Cuando se define una `configuración`, el corredor de la prueba ejecutará ese método **antes** de cada prueba. Del mismo modo, si se define un `tearDown`, el corredor de pruebas invocará ese método **después** de cada prueba.\n",
        "\n",
        "Como puede notar, estamos creando una instancia de Calculator `self.calc = Calculator()` en cada método que se probará. Para evitar repetir el código, simplemente podemos usar la función `setUp` disponible."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FHbBFvQWOS0N",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ca7d2a45-5196-42ac-c772-b21ac96df158"
      },
      "source": [
        "class TestCalcDiv(unittest.TestCase):\n",
        "\n",
        "    def setUp(self):\n",
        "        '''Set up an instance of Calculator pior to every test execution'''\n",
        "        self.calc = Calculator()\n",
        "\n",
        "    def test_div(self):\n",
        "        '''Test case function for division'''\n",
        "        self.assertEqual(self.calc.div(10, 5), 2)\n",
        "        self.assertEqual(self.calc.div(12, 2), 6)\n",
        "\n",
        "    def test_div_error(self):\n",
        "        '''Make sure ZeroDivisionError is raised when necessary'''\n",
        "        self.assertRaises(ZeroDivisionError, self.calc.div, 10, 0)\n",
        "\n",
        "unittest.main(argv=[''], defaultTest='TestCalcDiv', verbosity=2, exit=False)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "test_div (__main__.TestCalcDiv)\n",
            "Test case function for division ... ok\n",
            "test_div_error (__main__.TestCalcDiv)\n",
            "Make sure ZeroDivisionError is raised when necessary ... ok\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 2 tests in 0.014s\n",
            "\n",
            "OK\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<unittest.main.TestProgram at 0x79509a66fe50>"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jgrLmXwoZV0a"
      },
      "source": [
        "\n",
        "El caso de prueba debería pasar sin problemas. Puede intentar crear su propia función `tearDown` en Colab."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "opuRF9GQVo2I"
      },
      "source": [
        "\n",
        "## Consideración final\n",
        "\n",
        "La prueba no detectará todos los errores en el programa, porque no puede evaluar todas las rutas de ejecución en ninguno de los programas, excepto en los más triviales. No puede probar la corrección. Este problema es un superconjunto del problema de detención, que es indecidible."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xHl-Kc6L1U-F"
      },
      "source": [
        "## References\n",
        "\n",
        "1. [Unit testing framework](https://docs.python.org/3/library/unittest.html)"
      ]
    }
  ]
}