Créer et tester un environnement CI pour plusieurs versions de Python

Je m'appelle @giginet et je suis en charge du 25e jour du calendrier de l'Avent Python. C'est le dernier jour, j'ai donc réussi à l'écrire pour ne pas être en retard.

L'autre jour, j'ai développé un simple plugin pour Django. Ainsi, lorsque j'ai créé un environnement CI pour absorber les différences entre Python 2 et 3 et tester le plug-in implémenté dans plusieurs environnements, il y avait de nombreux points addictifs, je vais donc le résumer à cette occasion.

Dans cet article, je vais vous montrer comment utiliser Travis CI pour exécuter des tests sur plusieurs versions de Python afin de mesurer la couverture.

Mettre en œuvre le module

Tout d'abord, implémentez le module simple que vous souhaitez tester. Cette fois, j'ai mis calculator.py dans le module calculator et implémenté la classe Calculator.

Cette fois, on suppose que tout le code sera implémenté en Python3.

calculator/calculator.py

class Calculator(object):
    @staticmethod
    def power(number):
        return number * number

Mettre en œuvre un cas de test

Ensuite, implémentez le scénario de test. Ici, nous testons simplement si «Calculator # power» fonctionne.

tests/test_calculator.py

from unittest import TestCase
from calculator.calculator import Calculator


class CalculatorTestCase(TestCase):
    def setUp(self):
        self.calculator = Calculator()

    def test_power(self):
        self.assertEqual(self.calculator.power(12), 144)

Mettre en œuvre Test Runner

Recherchez maintenant le scénario de test que vous avez écrit et écrivez un script pour exécuter le test.

Si vous avez Python 2.7 ou supérieur, vous pouvez facilement rechercher des cas de test et exécuter des tests comme suit.

$ python -m unittest discover

Si vous testez également Python 2.6 et les versions antérieures, le module standard ʻunittest n'inclut pas dediscover pour rechercher des cas de test, vous devrez donc installer un package appelé ʻunittest2 à la place.

requirements-test.txt

unittest2

$ pip install -r requirements-test.txt

En utilisant ʻunittest2`, j'ai implémenté un script qui recherche et exécute les cas de test comme suit.

runtest.py

#!/usr/bin/env python

import unittest2 as unittest

if __name__ == "__main__":
    suite = unittest.TestLoader().discover('tests', pattern = "test_*.py")
    unittest.TextTestRunner().run(suite)

Lorsque vous faites cela, le test s'exécute comme indiqué ci-dessous.

$ chmod +x runtest.py
$ ./runtest.py
.
----------------------------------------------------------------------
Ran 1 tests in 0.001s

OK

Tester avec plusieurs versions de Python en utilisant tox

Ensuite, exécutons ce cas de test dans plusieurs environnements.

** tox ** est un moyen simple et bien connu de tester une source avec plusieurs versions de Python ou Django.

Welcome to the tox automation project — tox 2.3.1 documentation

tox est un outil qui vous permet de créer un environnement de test en modifiant diverses conditions et d'exécuter des tests dans plusieurs environnements à la fois.

Vous pouvez créer un environnement de test en définissant un fichier de paramètres appelé tox.ini, donc cette fois nous allons le définir comme suit.

tox.ini

[tox]
skipsdist = True
envlist =
    py26,
    py27,
    py33,
    py34,
    py35

[testenv]
deps=
    -rrequirements-test.txt
commands=
  ./runtest.py

Veuillez consulter la documentation pour plus de détails.

tox configuration specification — tox 2.3.1 documentation

Enfin, exécuter tox vous permet d'exécuter tous les environnements de test en même temps.

Cette fois, je vais exécuter le test uniquement avec Python 3.5 pour vérifier le fonctionnement.

$ tox -r -e 'py35'

Vous avez maintenant créé un environnement de test qui prend en charge plusieurs versions de Python.

Exécutez tox sur Travis CI avec tox-travis

Maintenant, exécutons ceci sur Travis CI.

Cette fois, nous utiliserons un module appelé «tox-travis».

ryanhiebert/tox-travis

Avec cela, vous pouvez omettre les paramètres pour exécuter tox sur Travis CI.

Par exemple, vous pouvez exécuter le test dans plusieurs environnements simplement en préparant .travis.yml comme indiqué ci-dessous.

yaml:.travis.yml

sudo: false
language: python
python:
  - 2.6
  - 2.7
  - 3.3
  - 3.4
  - 3.5

install:
  - pip install tox tox-travis
  - pip install coverage coveralls

script:
  - tox -r

Si vous faites cela sur Travis CI, plusieurs conteneurs seront lancés pour des tests faciles, comme indiqué ci-dessous. C'est pratique.

Gardez Python 2 et 3 compatibles avec le module __future__

Afin d'exécuter le code écrit pour Python3 sur Python2, vous devez utiliser le module __future__ etc. et l'écrire de manière rétrocompatible.

Veuillez consulter la documentation pour plus de détails, car cet article n'entre pas dans les détails.

Easy, clean, reliable Python 2/3 compatibility — Python-Future documentation

Test simulé avec Python2

Si vous souhaitez tester avec une maquette ou un stub, Python 3 inclut un module factice dans la bibliothèque standard.

26.5. unittest.mock — mock object library — Python 3.5.1 documentation

Par contre, mock ne peut pas être utilisé en standard dans l'environnement avant Python2.

Il existe un package qui rétroport le module fictif de Python 3 avant 2, alors introduisons-le.

requirements-test.txt

mock

Essayez d'abord de voir si ʻunittest.mock peut être importé, et s'il n'est pas inclus dans la bibliothèque standard, importez-le depuis la bibliothèque simulée`.

from unittest import TestCase

try:
    from unittest.mock import MagicMock
except ImportError:
    from mock import MagicMock


class CalcTestCase(TestCase):
    def test_mock(self):
        mock_object = MagicMock()
        mock_object.__str__.return_value = 'hello'
        self.assertEqual(str(mock_object), 'hello')

En faisant cela, vous pouvez effectuer des tests simulés sur Python 2 ainsi que 3.

Pour plus de détails sur l'utilisation de la simulation, reportez-vous à ce qui suit.

Python --Mock Mock ~ unittest.mock, mock.mock revisit ~ --Qiita

Mesurer la couverture

Une fois les tests réussis dans tous les environnements, mesurez enfin la couverture et gérez-la avec coverails.

Premièrement, mesurez la couverture en exécutant "couverture" dans "tox.ini" comme suit.

tox.ini

deps=
    -rrequirements-test.txt
    coverage
commands=
  {envbindir}/coverage run --append --source=calculator runtest.py

À ce stade, si vous définissez un fichier appelé «.coveragerc», vous pouvez définir les règles de mesure de la couverture. Ce qui suit définit les fichiers et les lignes pour lesquels la mesure de couverture n'est pas effectuée.

Voir ci-dessous pour plus de détails.

Configuration files — Coverage.py 4.0.3 documentation

.coveragerc

[report]
include =
    calculator/*.py
omit =
    calculator/__init__.py
exclude_lines =
    pragma: no cover
    if __name__ == .__main__.:

Enfin, ajoutez ce qui suit à «.travis.yml» pour que le journal soit envoyé à «combinaisons» une fois le test terminé.

yaml:.travis.yml

install:
  - pip install tox tox-travis
  - pip install coverage coveralls

after_success:
  - coverage report
  - coveralls

Vous pouvez désormais enregistrer la couverture dans Combinaisons.

Résumé

Dans cet article, j'ai brièvement résumé comment tester les bibliothèques Python avec plusieurs versions.

La suite de tests introduite cette fois est brièvement résumée dans le référentiel suivant.

https://github.com/giginet/python-ci-suite

Vous pouvez aussi bien utiliser tox pour tester une bibliothèque en plusieurs versions.

Les plugins Django suivants sont testés avec plusieurs versions de combinaisons Python et Django. Si vous êtes intéressé, veuillez vous y référer.

giginet/django-debug-toolbar-vcs-info