Chapitre 14 - Ecrire des tests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapitre 13 - Écrire des tests\n",
    "===\n",
    "\n",
    "Si nous avons couvert l'écriture de tests dans d'autres cours et dans quelques discussions, la rédaction de test reste encore quelque peu un mystère. Et pour cause.\n",
    "\n",
    "Les tests cherchent à vérifier un ensemble de fonctionnements :\n",
    "- les blocs programmés, pris séparément, fonctionnent correctement\n",
    "- ces blocs interagissent correctement les uns avec les autres\n",
    "- (pour les applications graphiques) la partie graphique de l'application interagit correctement avec la partie \"cachée\"\n",
    "- les modifications futures - y compris par des tiers - ne provoquent pas d'erreur\n",
    "\n",
    "## Les tests en python \n",
    "\n",
    "### Le choix des armes\n",
    "\n",
    "Nous avons vu pour l'instant une solution très basique pour faire ce genre de travail :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def carre(x):\n",
    "    \"\"\" Calcul un carré\n",
    "    \n",
    "    :param x: Nombre à mettre en puissance\n",
    "    :type x: int\n",
    "    :returns: Carré du nombre\n",
    "    :rtype: int\n",
    "    \"\"\"\n",
    "    return x**2  # On en profite pour découvrir la fonction `**` qui permet de mettre à la puisse qui suit. x**3 = x*x*x\n",
    "\n",
    "assert carre(8) == 64\n",
    "assert carre(3) == 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si tout fonctionne, `assert` ne nous dit rien. Si par hasard nous avons une erreur, la fonction `assert` va simplement créer une erreur et stopper le reste du code. Malheureusement, cela n'est pas très pratique à l'échelle d'une application. Par exemple, si un seul test ne fonctionne pas, `assert` ne nous avertira pas des autres erreurs, ce qui empêchera une vision d'ensemble.\n",
    "\n",
    "Pour python, heureusement, il existe des librairies plus complètes :\n",
    "- `unittest` qui est incluse par défaut dans python\n",
    "- `nosetest` qui est installable via `pypi` et qui est rétrocompatible avec `unittest`\n",
    "- `py.test` qui est moins verbeux que les deux précédents et utilise beaucoup `assert`\n",
    "\n",
    "Dans le cadre de ce cours, nous verrons le premier **unittest**. Sachez cependant que ce choix peut varier suivant :\n",
    "- les préférences locales de votre équipe\n",
    "- le besoin d'options complexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Unittest`\n",
    "\n",
    "Unittest est très facile à utiliser. Nous devons: \n",
    "1. Créer une classe dérivée de `unittest.TestCase`\n",
    "2. Créer des fonctions commençant par `test_`\n",
    "3. Utiliser des termes vérifiant les égalités telles que `assertEqual(x,y, message=None)`, `assertGreaterThan()`, etc.\n",
    "\n",
    "Prenons comme exemple notre fonction précédente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "class TestCarre(unittest.TestCase):\n",
    "    \"\"\" Test l'ensemble des fonctions pour carré \"\"\"\n",
    "    \n",
    "    def test_calcul_correct(self):\n",
    "        self.assertEqual(carre(8), 64)\n",
    "        self.assertEqual(carre(3), 9)\n",
    "        self.assertEqual(carre(-1), 1)\n",
    "        for x in range(9):\n",
    "            self.assertEqual(carre(x), carre(-x))\n",
    "            \n",
    "    def test_erreur_quand_non_numeric(self):\n",
    "        with self.assertRaises(TypeError):\n",
    "            # Ne fonctionnera que si l'erreur TypeError est lancée\n",
    "            carre(\"Ca va pas marcher...\")\n",
    "            \n",
    "    def test_accepte_decimaux(self):\n",
    "        \"\"\"Le carré d'un décimal devrait être bien calculé\"\"\"\n",
    "        self.assertEqual(carre(0.1), 0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut lancer ces tests directement en python (on verra cependant plus tard qu'on ne les lance que rarement comme cela):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unittest.main(argv=['first-arg-is-ignored'], exit=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit ici 3 choses :\n",
    "- une fonction peut contenir une ou plusieurs assertions\n",
    "- certaines assertions comme `assertRaises` s'utilisent surtout avec `with`\n",
    "- quand un test échoue, des détails sont donnés. Ici on se rend compte que les calculs ne sont pas si faciles quand il est question de décimaux...\n",
    "\n",
    "#### Les assertions de `unittest`\n",
    "\n",
    "| Method                    \t| Checks that                                                                  \t|\n",
    "|---------------------------\t|------------------------------------------------------------------------------\t|\n",
    "| assertEqual(a,b)          \t| a == b                                                                       \t|\n",
    "| assertNotEqual(a,b)       \t| a != b                                                                       \t|\n",
    "| assertTrue(x)             \t| bool(x) is True                                                              \t|\n",
    "| assertFalse(x)            \t| bool(x) is False                                                             \t|\n",
    "| assertIs(a,b)             \t| a is b                                                                       \t|\n",
    "| assertIsNot(a,b)          \t| a is not b                                                                   \t|\n",
    "| assertIsNone(x)           \t| x is None                                                                    \t|\n",
    "| assertIsNotNone(x)        \t| x is not None                                                                \t|\n",
    "| assertIn(a,b)             \t| a in b                                                                       \t|\n",
    "| assertNotIn(a,b)          \t| a not in b                                                                   \t|\n",
    "| assertIsInstance(a,b)     \t| isinstance(a, b)                                                             \t|\n",
    "| assertNotIsInstance(a,b)  \t| not isinstance(a, b)                                                         \t|\n",
    "| assertAlmostEqual(a,b)    \t| round(a-b, 7) == 0                                                           \t|\n",
    "| assertNotAlmostEqual(a,b) \t| round(a-b, 7) != 0                                                           \t|\n",
    "| assertGreater(a,b)        \t| a > b                                                                        \t|\n",
    "| assertGreaterEqual(a,b)   \t| a >= b                                                                       \t|\n",
    "| assertLess(a,b)           \t| a < b                                                                        \t|\n",
    "| assertLessEqual(a,b)      \t| a <= b                                                                       \t|\n",
    "| assertRegex(s,r)          \t| r.search(s)                                                                  \t|\n",
    "| assertNotRegex(s,r)       \t| not r.search(s)                                                              \t|\n",
    "| assertCountEqual(a,b)     \t| a et b sont égaux : même nombre d'éléments et mêmes éléments quelque soit leur ordre \t|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mais si on ne les lance pas comme ça...\n",
    "\n",
    "Comment les lance-t-on ? Typiquement, les dossiers de développement ressembleront à ça : \n",
    "\n",
    "- Dossier de travail\n",
    "    - dossier_application (Module principal)\n",
    "    - tests (Module des tests)\n",
    "    - docs (dossier avec la documentation )\n",
    "    - run.py ou app.py ou autre nom qui fait sens (outil pour lancer l'application)\n",
    "    - env (Environnement virtuel qui sera soigneusement ignoré dans un gitignore)\n",
    "    - README.md\n",
    "    - LICENSE.md\n",
    "    - .gitignore ( [Exemple pour python](https://raw.githubusercontent.com/github/gitignore/master/Python.gitignore)\n",
    "\n",
    "Dans ce cadre là, on fera généralement :\n",
    "\n",
    "```shell\n",
    "cd DOSSIER_DE_TRAVAIL\n",
    "source env/bin/activate\n",
    "python -m unittest discover tests # Où `tests` est le module qui contient les tests\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Concepts fondamentaux de la rédaction de test\n",
    "\n",
    "### Tests unitaires, tests d'intégration\n",
    "\n",
    "> Dans le test unitaire, on vérifie le bon fonctionnement d'une partie précise d'un logiciel ou d'une portion d'un programme (appelée « unité » ou « module ») ; dans le test d’intégration, chacun des modules indépendants du logiciel est assemblé et testé \\[comme\\] ensemble.\n",
    "> https://fr.wikipedia.org/wiki/Test_d%27int%C3%A9gration\n",
    "\n",
    "### `setUp` et `tearDown`\n",
    "\n",
    "Les fonctions de mise en place et de destruction sont des fonctions qui seront lancées avant chacun des tests d'une classe. Elles permettent par exemple de générer une application et de tester cette application plusieurs fois. Ou de rentrer des données dans une base de données.\n",
    "\n",
    "Exemple en mi-pseudocode, mi-python  :\n",
    "\n",
    "\n",
    "```python\n",
    "class TestMiseAJourRessources(TestCase):\n",
    "    def setUp(self):\n",
    "        self.application = gazetteer\n",
    "        self.user = gazetteer.User.Johanna\n",
    "        self.application.login(self.user)\n",
    "        \n",
    "    def tearDown(self):\n",
    "        try:\n",
    "            self.application.logout(self.user)\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "    def test_update(self):\n",
    "        self.application.route.update_item(1).nom = \"Rome\"\n",
    "        self.assertEqual(self.application.item(1).nom, \"Rome\")\n",
    "            \n",
    "    def test_erreur_non_loguee(self):\n",
    "        self.application.logout(self.user)\n",
    "        with self.assertRaises(Forbidden):\n",
    "            self.application.route.update_item(1).nom = \"Rome\"\n",
    "        self.assertEqual(self.application.item(1).nom, \"Roma\")\n",
    "```\n",
    "\n",
    "### Les `Fixtures`\n",
    "\n",
    "Les `fixtures` sont des données pour une base de données temporaire qui permettront de vérifier la validité des tests.\n",
    "\n",
    "### Les `Mocks`\n",
    "\n",
    "Un mock est une fonction qui va venir remplacer une autre fonction capable d'échouer. Très souvent, ces `Mocks` viennent aider à tester des services externes tels que des APIs hébergées par d'autres sites qui pourraient ne pas apprécier d'être la source de tests.\n",
    "\n",
    "Nous n'aborderons pas les mocks ici, mais vous pouvez trouver quelques tutoriels en ligne :\n",
    "- http://python-mock-tutorial.readthedocs.io/en/latest/introduction.html\n",
    "- https://realpython.com/blog/python/testing-third-party-apis-with-mocks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tests et Flask\n",
    "\n",
    "### Avant-propos \n",
    "\n",
    "Pour tester une application, et *à priori* une application qui va posséder une base de données, le premier pas va être de générer un ensemble de données qui sera utilisé pour pouvoir testers les différentes pages. Dans cet avant-propos, nous allons voir quelques conseils permettant de bien travailler avec SQLAlchemy et les tests.\n",
    "\n",
    "#### Génération de la base de données\n",
    "\n",
    "SQLAlchemy et Flask-SQLAlchemy sont tellement bien qu'ils permettent aussi de générer des bases de données à partir de l'ensemble des modèles enregistrés. C'est extrêmement pratique et surtout dans le cadre de tests.\n",
    "\n",
    "Pour générer une base de données, nous aurons besoin de faire :\n",
    "\n",
    "```python\n",
    "from app import db  # Cette ligne d'import peut varier\n",
    "db.create_all()\n",
    "```\n",
    "\n",
    "et nous pourrons de la même manière l'effacer :\n",
    "\n",
    "```python\n",
    "from app import db  # Cette ligne d'import peut varier\n",
    "db.drop_all()\n",
    "```\n",
    "\n",
    "##### Scripts de migration\n",
    "\n",
    "Des outils bien plus complets ainsi qu'un tutoriel pour permettre les migrations sont disponibles sur le site  de M. Grinberg ( [SQLAlchemy - Flask Mega Tutorial](https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-iv-database) ).\n",
    "\n",
    "#### Configuration tests et configuration production\n",
    "\n",
    "Le problème des scripts précédents, c'est qu'ils risquent fortement de détruire les données que nous avons déjà rentrées. Ou pire, ils pourraient facilement se retrouver sur le site en production et détruire les données dessus. Comment limiter ce risque ? En multipliant les configurations.\n",
    "\n",
    "Il y a beaucoup de manières de faire cela : variables environnementales (variable spécifique à votre machine), configurations multiples dans un module config, etc. Nous allons voir une méthode qui me semble particulièrement facile d'utilisation.\n",
    "\n",
    "**Attention:** cette méthode est très susceptible à l'ordre de création des autres variables !\n",
    "\n",
    "##### gazetteer/config.py\n",
    "\n",
    "```python\n",
    "# ...\n",
    "class _TEST:\n",
    "    SECRET_KEY = SECRET_KEY\n",
    "    # On configure la base de données\n",
    "    SQLALCHEMY_DATABASE_URI = 'sqlite:///test_db.sqlite'\n",
    "    SQLALCHEMY_TRACK_MODIFICATIONS = False\n",
    "\n",
    "\n",
    "class _PRODUCTION:\n",
    "    SECRET_KEY = SECRET_KEY\n",
    "    # On configure la base de données\n",
    "    SQLALCHEMY_DATABASE_URI = 'mysql://gazetteer_user:password@localhost/gazetteer'\n",
    "    SQLALCHEMY_TRACK_MODIFICATIONS = False\n",
    "\n",
    "CONFIG = {\n",
    "    \"test\": _TEST,\n",
    "    \"production\": _PRODUCTION\n",
    "}\n",
    "```\n",
    "\n",
    "- On crée deux classes qui possèdent des propriétés similaires aux configurations nécessaires de Flask\n",
    "    - Commencer un nom de variable, de classe ou de fonction par un `_` signifie qu'elle ne devrait pas être appelée directement.\n",
    "- On les regroupe dans un dictionnaire\n",
    "\n",
    "##### gazetteer/app.py\n",
    "\n",
    "```python\n",
    "from flask import Flask\n",
    "from flask_sqlalchemy import SQLAlchemy\n",
    "from flask_login import LoginManager\n",
    "import os\n",
    "from .constantes import CONFIG\n",
    "\n",
    "chemin_actuel = os.path.dirname(os.path.abspath(__file__))\n",
    "templates = os.path.join(chemin_actuel, \"templates\")\n",
    "statics = os.path.join(chemin_actuel, \"static\")\n",
    "\n",
    "# On initie l'extension\n",
    "db = SQLAlchemy()\n",
    "# On met en place la gestion d'utilisateur-rice-s\n",
    "login = LoginManager()\n",
    "\n",
    "app = Flask(\n",
    "    __name__,\n",
    "    template_folder=templates,\n",
    "    static_folder=statics\n",
    ")\n",
    "\n",
    "\n",
    "from .routes import generic\n",
    "from .routes import api\n",
    "\n",
    "\n",
    "def config_app(config_name=\"test\"):\n",
    "    \"\"\" Create the application \"\"\"\n",
    "    app.config.from_object(CONFIG[config_name])\n",
    "\n",
    "    # On initie les extensions\n",
    "    db.init_app(app)\n",
    "    login.init_app(app)\n",
    "\n",
    "    return app\n",
    "```\n",
    "\n",
    "- Toute la partie initiation des routines est mise à part dans une fonction `config_app()` qui retourne l'application.\n",
    "- On importera désormais config_app qu'on exécutera afin de lancer l'application (voire le fichier suivant)\n",
    "\n",
    "##### run.py\n",
    "\n",
    "```python\n",
    "from gazetteer.app import config_app\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    app = config_app(\"production\")\n",
    "    app.run(debug=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mise en place des tests\n",
    "\n",
    "Voici un exemple de test avec l'ensemble de ce que l'on vient de voir :\n",
    "\n",
    "```python\n",
    "from gazetteer.app import db, config_app, login\n",
    "from gazetteer.modeles.utilisateurs import User\n",
    "from gazetteer.modeles.donnees import Place, Authorship\n",
    "from unittest import TestCase\n",
    "\n",
    "\n",
    "class TestApi(Base):\n",
    "    places = [\n",
    "        Place(\n",
    "            place_nom='Hippana',\n",
    "            place_description='Ancient settlement in the western part of Sicily, probably founded in the seventh century B.C.',\n",
    "            place_longitude=37.7018481,\n",
    "            place_latitude=13.4357804,\n",
    "            place_type='settlement'\n",
    "        )\n",
    "    ]\n",
    "\n",
    "    def setUp(self):\n",
    "        self.app = config_app(\"test\")\n",
    "        self.db = db\n",
    "        self.client = self.app.test_client()\n",
    "        self.db.create_all(app=self.app)\n",
    "\n",
    "    def tearDown(self):\n",
    "        self.db.drop_all(app=self.app)\n",
    "\n",
    "    def insert_all(self, places=True):\n",
    "        # On donne à notre DB le contexte d'exécution\n",
    "        with self.app.app_context():\n",
    "            if places:\n",
    "                for fixture in self.places:\n",
    "                    self.db.session.add(fixture)\n",
    "            self.db.session.commit()\n",
    "                            \n",
    "    def test_single_place(self):\n",
    "        \"\"\" Vérifie qu'un lieu est bien traité \"\"\"\n",
    "        self.insert_all()\n",
    "        response = self.client.get(\"/api/places/1\")\n",
    "        # Le corps de la réponse est dans .data\n",
    "        # .data est en \"bytes\". Pour convertir des bytes en str, on fait .decode()\n",
    "        content = response.data.decode()\n",
    "        self.assertEqual(\n",
    "            response.headers[\"Content-Type\"], \"application/json\"\n",
    "        )\n",
    "        json_parse = loads(content)\n",
    "        self.assertEqual(json_parse[\"type\"], \"place\")\n",
    "        self.assertEqual(\n",
    "            json_parse[\"attributes\"],\n",
    "            {'name': 'Hippana', 'latitude': 13.4357804, 'longitude': 37.7018481, 'category': 'settlement',\n",
    "             'description': 'Ancient settlement in the western part of Sicily, probably '\n",
    "                            'founded in the seventh century B.C.'}\n",
    "        )\n",
    "        self.assertEqual(json_parse[\"links\"][\"self\"], 'http://localhost/place/1')\n",
    "\n",
    "        # On vérifie que le lien est correct\n",
    "        seconde_requete = self.client.get(json_parse[\"links\"][\"self\"])\n",
    "        self.assertEqual(seconde_requete.status_code, 200)\n",
    "```\n",
    "\n",
    "Remarquez que :\n",
    "1. On génère l'application dans `setUp()`\n",
    "2. On garder la capacité d'insérer ou non des données (préférences personnelles).\n",
    "3. Une fois l'application générée, on génère un client de test qui nous permettra de faire des requêtes (`test_client()`)\n",
    "4. On utilise ce client pour faire des requêtes. Les réponses sont composées de :\n",
    "    - `.headers` qui est un dictionnaire\n",
    "    - `.data` qui est un `bytes`. On le transforme facilement en `str` via `chaine = response.data.decode()`\n",
    "    - `.status_code` qui est le code réponse HTTP\n",
    "    \n",
    "**Question:** Quel type de test avons-nous ici ?\n",
    "\n",
    "### Tests mixtes\n",
    "\n",
    "Des tests ont été écrits dans `cours-flask/exemple18`. Regardez-les. Nous pouvons les exécuter d'ici via la commande qui suit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EE\r\n",
      "======================================================================\r\n",
      "ERROR: tests.test_api (unittest.loader._FailedTest)\r\n",
      "----------------------------------------------------------------------\r\n",
      "ImportError: Failed to import test module: tests.test_api\r\n",
      "Traceback (most recent call last):\r\n",
      "  File \"/usr/lib/python3.6/unittest/loader.py\", line 428, in _find_test_path\r\n",
      "    module = self._get_module_from_name(name)\r\n",
      "  File \"/usr/lib/python3.6/unittest/loader.py\", line 369, in _get_module_from_name\r\n",
      "    __import__(name)\r\n",
      "  File \"/home/thibault/dev/cours-python/cours-flask/exemple18/tests/test_api.py\", line 1, in <module>\r\n",
      "    from .base import Base\r\n",
      "  File \"/home/thibault/dev/cours-python/cours-flask/exemple18/tests/base.py\", line 1, in <module>\r\n",
      "    from gazetteer.app import db, config_app, login\r\n",
      "  File \"/home/thibault/dev/cours-python/cours-flask/exemple18/gazetteer/app.py\", line 3, in <module>\r\n",
      "    from flask_login import LoginManager\r\n",
      "ModuleNotFoundError: No module named 'flask_login'\r\n",
      "\r\n",
      "\r\n",
      "======================================================================\r\n",
      "ERROR: tests.test_user (unittest.loader._FailedTest)\r\n",
      "----------------------------------------------------------------------\r\n",
      "ImportError: Failed to import test module: tests.test_user\r\n",
      "Traceback (most recent call last):\r\n",
      "  File \"/usr/lib/python3.6/unittest/loader.py\", line 428, in _find_test_path\r\n",
      "    module = self._get_module_from_name(name)\r\n",
      "  File \"/usr/lib/python3.6/unittest/loader.py\", line 369, in _get_module_from_name\r\n",
      "    __import__(name)\r\n",
      "  File \"/home/thibault/dev/cours-python/cours-flask/exemple18/tests/test_user.py\", line 1, in <module>\r\n",
      "    from .base import Base\r\n",
      "  File \"/home/thibault/dev/cours-python/cours-flask/exemple18/tests/base.py\", line 1, in <module>\r\n",
      "    from gazetteer.app import db, config_app, login\r\n",
      "  File \"/home/thibault/dev/cours-python/cours-flask/exemple18/gazetteer/app.py\", line 3, in <module>\r\n",
      "    from flask_login import LoginManager\r\n",
      "ModuleNotFoundError: No module named 'flask_login'\r\n",
      "\r\n",
      "\r\n",
      "----------------------------------------------------------------------\r\n",
      "Ran 2 tests in 0.000s\r\n",
      "\r\n",
      "FAILED (errors=2)\r\n"
     ]
    }
   ],
   "source": [
    "!PYTHONPATH=cours-flask/exemple18/ python -m unittest discover tests\n",
    "# PYTHONPATH=cours-flask/exemple18 permet de dire à python que le dossier d'exécution est ce dernier."
   ]
  }
 ],
 "metadata": {
  "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}