# Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. # msgid "" msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-04-14 13:19+0200\n" "PO-Revision-Date: 2019-04-22 12:07+0200\n" "Last-Translator: Bousquié Pierre \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 2.2.1\n" #: library/unittest.mock.rst:3 msgid ":mod:`unittest.mock` --- mock object library" msgstr ":mod:`unittest.mock` — Bibliothèque d'objets simulacres" #: library/unittest.mock.rst:13 msgid "**Source code:** :source:`Lib/unittest/mock.py`" msgstr "**Code source :** :source:`Lib/unittest/mock.py`" #: library/unittest.mock.rst:17 msgid "" ":mod:`unittest.mock` is a library for testing in Python. It allows you to " "replace parts of your system under test with mock objects and make " "assertions about how they have been used." msgstr "" ":mod:`unittest.mock` est une bibliothèque pour tester en Python. Elle permet " "de remplacer des parties du système sous tests par des objets simulacres et " "faire des assertions sur la façon dont ces objets ont été utilisés." #: library/unittest.mock.rst:21 msgid "" ":mod:`unittest.mock` provides a core :class:`Mock` class removing the need " "to create a host of stubs throughout your test suite. After performing an " "action, you can make assertions about which methods / attributes were used " "and arguments they were called with. You can also specify return values and " "set needed attributes in the normal way." msgstr "" ":mod:`unittest.mock` fournit une classe :class:`Mock` pour ne pas avoir " "besoin de créer manuellement des objets factices dans la suite de tests. " "Après avoir effectué une action, on peut faire des assertions sur les " "méthodes / attributs utilisés et les arguments avec lesquels ils ont été " "appelés. On peut également spécifier des valeurs renvoyées et définir les " "attributs nécessaires aux tests." #: library/unittest.mock.rst:27 msgid "" "Additionally, mock provides a :func:`patch` decorator that handles patching " "module and class level attributes within the scope of a test, along with :" "const:`sentinel` for creating unique objects. See the `quick guide`_ for " "some examples of how to use :class:`Mock`, :class:`MagicMock` and :func:" "`patch`." msgstr "" "De plus, *mock* fournit un décorateur :func:`patch` qui est capable de " "*patcher* les modules et les classes dans la portée d'un test, ainsi que :" "const:`sentinel` pour créer des objets uniques. Voir le guide rapide `quick " "guide`_ pour quelques exemples d'utilisation de :class:`Mock`, :class:" "`MagicMock` et :func:`patch`." #: library/unittest.mock.rst:33 #, fuzzy msgid "" "Mock is designed for use with :mod:`unittest` and is based on the 'action -> " "assertion' pattern instead of 'record -> replay' used by many mocking " "frameworks." msgstr "" "*Mock* est très facile à utiliser et est conçu pour être utilisé avec :mod:" "`unittest`. *Mock* est basé sur le modèle *action -> assertion* au lieu de " "*enregistrement -> rejouer* utilisé par de nombreux cadriciels d'objets " "simulacres." #: library/unittest.mock.rst:37 msgid "" "There is a backport of :mod:`unittest.mock` for earlier versions of Python, " "available as `mock on PyPI `_." msgstr "" "Il y a un portage de :mod:`unittest.mock` pour les versions antérieures de " "Python, disponible `sur PyPI `_." #: library/unittest.mock.rst:42 msgid "Quick Guide" msgstr "Guide rapide" #: library/unittest.mock.rst:60 msgid "" ":class:`Mock` and :class:`MagicMock` objects create all attributes and " "methods as you access them and store details of how they have been used. You " "can configure them, to specify return values or limit what attributes are " "available, and then make assertions about how they have been used:" msgstr "" "Les classes :class:`Mock` et :class:`MagicMock` créent tous les attributs et " "méthodes au fur et à mesure des accès et stockent les détails de la façon " "dont ils ont été utilisés. On peut les configurer, pour spécifier des " "valeurs de renvoi ou limiter les attributs utilisables, puis faire des " "assertions sur la façon dont ils ont été utilisés :" #: library/unittest.mock.rst:72 msgid "" ":attr:`side_effect` allows you to perform side effects, including raising an " "exception when a mock is called:" msgstr "" "L'attribut :attr:`side_effect` permet de spécifier des effets de bords, y " "compris la levée d'une exception lorsqu'un objet simulacre est appelé :" #: library/unittest.mock.rst:92 msgid "" "Mock has many other ways you can configure it and control its behaviour. For " "example the *spec* argument configures the mock to take its specification " "from another object. Attempting to access attributes or methods on the mock " "that don't exist on the spec will fail with an :exc:`AttributeError`." msgstr "" "Il existe beaucoup d'autres façons de configurer et de contrôler le " "comportement de *Mock*. Par exemple, l'argument *spec* configure le *mock* " "pour qu'il utilise les spécifications d'un autre objet. Tenter d'accéder à " "des attributs ou méthodes sur le *mock* qui n'existent pas sur l'objet " "*spec* lève une :exc:`AttributeError`." #: library/unittest.mock.rst:97 #, fuzzy msgid "" "The :func:`patch` decorator / context manager makes it easy to mock classes " "or objects in a module under test. The object you specify will be replaced " "with a mock (or other object) during the test and restored when the test " "ends::" msgstr "" "Le décorateur / gestionnaire de contexte :func:`patch` permet de simuler " "facilement des classes ou des objets dans un module sous tests. L'objet " "spécifié est remplacé par un objet simulacre (ou autre) pendant le test et " "est restauré à la fin du test ::" #: library/unittest.mock.rst:116 msgid "" "When you nest patch decorators the mocks are passed in to the decorated " "function in the same order they applied (the normal *Python* order that " "decorators are applied). This means from the bottom up, so in the example " "above the mock for ``module.ClassName1`` is passed in first." msgstr "" "Lorsque l'on imbrique des décorateurs de patchs, les *mocks* sont transmis à " "la fonction décorée dans le même ordre qu'ils ont été déclarés (l'ordre " "normal *Python* des décorateurs est appliqué). Cela signifie du bas vers le " "haut, donc dans l'exemple ci-dessus, l'objet simulacre pour ``module." "ClassName1`` est passé en premier." #: library/unittest.mock.rst:121 msgid "" "With :func:`patch` it matters that you patch objects in the namespace where " "they are looked up. This is normally straightforward, but for a quick guide " "read :ref:`where to patch `." msgstr "" "Avec :func:`patch`, il est important de *patcher* les objets dans l'espace " "de nommage où ils sont recherchés. C'est ce qui se fait normalement, mais " "pour un guide rapide, lisez :ref:`où patcher `." #: library/unittest.mock.rst:125 msgid "" "As well as a decorator :func:`patch` can be used as a context manager in a " "with statement:" msgstr "" "Comme tout décorateur, :func:`patch` peut être utilisé comme gestionnaire de " "contexte avec une instruction *with* :" #: library/unittest.mock.rst:135 msgid "" "There is also :func:`patch.dict` for setting values in a dictionary just " "during a scope and restoring the dictionary to its original state when the " "test ends:" msgstr "" "Il existe également :func:`patch.dict` pour définir des valeurs d'un " "dictionnaire au sein d'une portée et restaurer ce dictionnaire à son état " "d'origine lorsque le test se termine :" #: library/unittest.mock.rst:146 msgid "" "Mock supports the mocking of Python :ref:`magic methods `. " "The easiest way of using magic methods is with the :class:`MagicMock` class. " "It allows you to do things like:" msgstr "" "*Mock* gère le remplacement des :ref:`méthodes magiques ` de " "Python. La façon la plus simple d'utiliser les méthodes magiques est la " "classe :class:`MagicMock`. Elle permet de faire des choses comme :" #: library/unittest.mock.rst:156 msgid "" "Mock allows you to assign functions (or other Mock instances) to magic " "methods and they will be called appropriately. The :class:`MagicMock` class " "is just a Mock variant that has all of the magic methods pre-created for you " "(well, all the useful ones anyway)." msgstr "" "*Mock* permet d'assigner des fonctions (ou d'autres instances *Mock*) à des " "méthodes magiques et elles seront appelées correctement. La classe :class:" "`MagicMock` est juste une variante de *Mock* qui a toutes les méthodes " "magiques pré-créées (enfin, toutes les méthodes utiles)." #: library/unittest.mock.rst:161 msgid "" "The following is an example of using magic methods with the ordinary Mock " "class:" msgstr "" "L'exemple suivant est un exemple de création de méthodes magiques avec la " "classe *Mock* ordinaire :" #: library/unittest.mock.rst:169 msgid "" "For ensuring that the mock objects in your tests have the same api as the " "objects they are replacing, you can use :ref:`auto-speccing `. Auto-speccing can be done through the *autospec* argument to " "patch, or the :func:`create_autospec` function. Auto-speccing creates mock " "objects that have the same attributes and methods as the objects they are " "replacing, and any functions and methods (including constructors) have the " "same call signature as the real object." msgstr "" "Pour être sûr que les objets simulacres dans vos tests ont la même API que " "les objets qu'ils remplacent, utilisez :ref:`l'auto-spécification `. L'auto-spécification peut se faire via l'argument *autospec* de " "patch ou par la fonction :func:`create_autospec`. L'auto-spécification crée " "des objets simulacres qui ont les mêmes attributs et méthodes que les objets " "qu'ils remplacent, et toutes les fonctions et méthodes (y compris les " "constructeurs) ont les mêmes signatures d'appel que l'objet réel." #: library/unittest.mock.rst:177 msgid "" "This ensures that your mocks will fail in the same way as your production " "code if they are used incorrectly:" msgstr "" "Ceci garantit que vos objets simulacres échouent de la même manière que " "votre code de production s'ils ne sont pas utilisés correctement :" #: library/unittest.mock.rst:193 msgid "" ":func:`create_autospec` can also be used on classes, where it copies the " "signature of the ``__init__`` method, and on callable objects where it " "copies the signature of the ``__call__`` method." msgstr "" "La fonction :func:`create_autospec` peut aussi être utilisée sur les " "classes, où elle copie la signature de la méthode ``__init__``, et sur les " "objets appelables où elle copie la signature de la méthode ``__call__``." #: library/unittest.mock.rst:200 msgid "The Mock Class" msgstr "La classe *Mock*" #: library/unittest.mock.rst:211 msgid "" ":class:`Mock` is a flexible mock object intended to replace the use of stubs " "and test doubles throughout your code. Mocks are callable and create " "attributes as new mocks when you access them [#]_. Accessing the same " "attribute will always return the same mock. Mocks record how you use them, " "allowing you to make assertions about what your code has done to them." msgstr "" "La classe :class:`Mock` est un objet simulacre flexible destiné à remplacer " "l'utilisation d'objets bouchons et factices dans votre code. Les Mocks sont " "appelables et créent des attributs comme de nouveaux *Mocks* lorsque l'on y " "accède [#]_. L'accès au même attribut renvoie toujours le même *mock*. Les " "simulacres enregistrent la façon dont ils sont utilisés, ce qui permet de " "faire des assertions sur ce que le code leur a fait." #: library/unittest.mock.rst:217 msgid "" ":class:`MagicMock` is a subclass of :class:`Mock` with all the magic methods " "pre-created and ready to use. There are also non-callable variants, useful " "when you are mocking out objects that aren't callable: :class:" "`NonCallableMock` and :class:`NonCallableMagicMock`" msgstr "" "La classe :class:`MagicMock` est une sous-classe de :class:`Mock` avec " "toutes les méthodes magiques pré-créées et prête à l'emploi. Il existe " "également des variantes non appelables, utiles lorsque l'on simule des " "objets qui ne sont pas appelables : :class:`NonCallableMock` et :class:" "`NonCallableMagicMock`" #: library/unittest.mock.rst:222 msgid "" "The :func:`patch` decorators makes it easy to temporarily replace classes in " "a particular module with a :class:`Mock` object. By default :func:`patch` " "will create a :class:`MagicMock` for you. You can specify an alternative " "class of :class:`Mock` using the *new_callable* argument to :func:`patch`." msgstr "" "Le décorateur :func:`patch` facilite le remplacement temporaire de classes " "d'un module avec un objet :class:`Mock`. Par défaut :func:`patch` crée un :" "class:`MagicMock`. On peut spécifier une classe alternative de :class:`Mock` " "en utilisant le paramètre *new_callable* de :func:`patch`." #: library/unittest.mock.rst:230 msgid "" "Create a new :class:`Mock` object. :class:`Mock` takes several optional " "arguments that specify the behaviour of the Mock object:" msgstr "" "Crée un nouvel objet :class:`Mock`. :class:`Mock` prend plusieurs arguments " "optionnels qui spécifient le comportement de l'objet *Mock* :" #: library/unittest.mock.rst:233 msgid "" "*spec*: This can be either a list of strings or an existing object (a class " "or instance) that acts as the specification for the mock object. If you pass " "in an object then a list of strings is formed by calling dir on the object " "(excluding unsupported magic attributes and methods). Accessing any " "attribute not in this list will raise an :exc:`AttributeError`." msgstr "" "*spec* : une liste de chaînes de caractères ou un objet existant (une classe " "ou une instance) qui sert de spécification pour l'objet simulacre. Si on " "passe un objet, alors une liste de chaînes de caractères est formée en " "appelant la fonction *dir* sur l'objet (à l'exclusion des attributs et " "méthodes magiques non pris en charge). L'accès à un attribut qui n'est pas " "dans cette liste entraîne la levée d'une exception :exc:`AttributeError`." #: library/unittest.mock.rst:239 msgid "" "If *spec* is an object (rather than a list of strings) then :attr:`~instance." "__class__` returns the class of the spec object. This allows mocks to pass :" "func:`isinstance` tests." msgstr "" "Si *spec* est un objet (plutôt qu'une liste de chaînes de caractères) alors :" "attr:`~instance.__class__` renvoie la classe de l'objet spécifié. Ceci " "permet aux *mocks* de passer les tests :func:`isinstance`." #: library/unittest.mock.rst:243 msgid "" "*spec_set*: A stricter variant of *spec*. If used, attempting to *set* or " "get an attribute on the mock that isn't on the object passed as *spec_set* " "will raise an :exc:`AttributeError`." msgstr "" "*spec_set* : variante plus stricte de *spec*. S'il est utilisé, essayer " "d'utiliser la fonction *set* ou tenter d’accéder à un attribut sur le *mock* " "qui n'est pas sur l'objet passé comme *spec_set* lève une exception :exc:" "`AttributeError`." #: library/unittest.mock.rst:247 msgid "" "*side_effect*: A function to be called whenever the Mock is called. See the :" "attr:`~Mock.side_effect` attribute. Useful for raising exceptions or " "dynamically changing return values. The function is called with the same " "arguments as the mock, and unless it returns :data:`DEFAULT`, the return " "value of this function is used as the return value." msgstr "" "*side_effect* : fonction à appeler à chaque fois que le *Mock* est appelé. " "Voir l'attribut :attr:`~Mock.side_effect`. Utile pour lever des exceptions " "ou modifier dynamiquement les valeurs de retour. La fonction est appelée " "avec les mêmes arguments que la fonction simulée et, à moins qu'elle ne " "renvoie :data:`DEFAULT`, la valeur de retour de cette fonction devient la " "valeur de retour de la fonction simulée." #: library/unittest.mock.rst:253 msgid "" "Alternatively *side_effect* can be an exception class or instance. In this " "case the exception will be raised when the mock is called." msgstr "" "*side_effect* peut être soit une classe, soit une instance d'exception. Dans " "ce cas, l'exception est levée lors de l'appel de l'objet simulacre." #: library/unittest.mock.rst:256 msgid "" "If *side_effect* is an iterable then each call to the mock will return the " "next value from the iterable." msgstr "" "Si *side_effect* est un itérable alors chaque appel au *mock* renvoie la " "valeur suivante de l’itérable." #: library/unittest.mock.rst:259 msgid "A *side_effect* can be cleared by setting it to ``None``." msgstr "Utilisez ``None`` pour remettre à zéro un *side_effect*." #: library/unittest.mock.rst:261 msgid "" "*return_value*: The value returned when the mock is called. By default this " "is a new Mock (created on first access). See the :attr:`return_value` " "attribute." msgstr "" "*return_value* : valeur renvoyée lors de l'appel de l'objet simulacre. Par " "défaut, il s'agit d'un nouveau *Mock* (créé lors du premier accès). Voir " "l'attribut :attr:`return_value`." #: library/unittest.mock.rst:265 #, fuzzy msgid "" "*unsafe*: By default, accessing any attribute whose name starts with " "*assert*, *assret*, *asert*, *aseert* or *assrt* will raise an :exc:" "`AttributeError`. Passing ``unsafe=True`` will allow access to these " "attributes." msgstr "" "*unsafe* : par défaut, si un attribut commence par *assert* ou *assret*, une " "exception :exc:`AttributeError` est levée. Le fait de passer ``unsafe=True`` " "permet d'accéder à ces attributs." #: library/unittest.mock.rst:272 msgid "" "*wraps*: Item for the mock object to wrap. If *wraps* is not ``None`` then " "calling the Mock will pass the call through to the wrapped object (returning " "the real result). Attribute access on the mock will return a Mock object " "that wraps the corresponding attribute of the wrapped object (so attempting " "to access an attribute that doesn't exist will raise an :exc:" "`AttributeError`)." msgstr "" "*wraps* : élément que le simulacre doit simuler. Si *wraps* n'est pas " "``None`` alors appeler *Mock* passe l'appel à l'objet simulé (renvoyant le " "résultat réel). L'accès à un attribut sur le *mock* renvoie un objet *Mock* " "qui simule l'attribut correspondant de l'objet simulé (donc essayer " "d'accéder à un attribut qui n'existe pas lève une exception :exc:" "`AttributeError`)." #: library/unittest.mock.rst:279 msgid "" "If the mock has an explicit *return_value* set then calls are not passed to " "the wrapped object and the *return_value* is returned instead." msgstr "" "Si l'objet simulacre a un ensemble explicite de *return_value* alors les " "appels ne sont pas passés à l'objet simulé et c'est *return_value* qui est " "renvoyée à la place." #: library/unittest.mock.rst:282 msgid "" "*name*: If the mock has a name then it will be used in the repr of the mock. " "This can be useful for debugging. The name is propagated to child mocks." msgstr "" "*name* : Si le *mock* a un nom, il est alors utilisé par la fonction *repr* " "du *mock*. C'est utile pour le débogage. Le nom est propagé aux enfants de " "l'objet *mock*." #: library/unittest.mock.rst:286 msgid "" "Mocks can also be called with arbitrary keyword arguments. These will be " "used to set attributes on the mock after it is created. See the :meth:" "`configure_mock` method for details." msgstr "" "Les *mocks* peuvent aussi être appelés avec des arguments par mots-clés " "arbitraires. Ceux-ci sont utilisés pour définir les attributs sur le *mock* " "après sa création. Voir la méthode :meth:`configure_mock` pour plus de " "détails." #: library/unittest.mock.rst:292 msgid "Assert that the mock was called at least once." msgstr "Asserter que le *mock* a été appelé au moins une fois." #: library/unittest.mock.rst:303 msgid "Assert that the mock was called exactly once." msgstr "Asserter que le *mock* a été appelé exactement une fois." #: library/unittest.mock.rst:321 #, fuzzy msgid "" "This method is a convenient way of asserting that the last call has been " "made in a particular way:" msgstr "" "Cette méthode est un moyen pratique d'asserter que les appels sont effectués " "d'une manière particulière :" #: library/unittest.mock.rst:331 #, fuzzy msgid "" "Assert that the mock was called exactly once and that call was with the " "specified arguments." msgstr "" "Asserter que le simulacre a été appelé exactement une fois et que cet appel " "était avec les arguments spécifiés." #: library/unittest.mock.rst:346 msgid "assert the mock has been called with the specified arguments." msgstr "Asserter que le simulacre a été appelé avec les arguments spécifiés." #: library/unittest.mock.rst:348 msgid "" "The assert passes if the mock has *ever* been called, unlike :meth:" "`assert_called_with` and :meth:`assert_called_once_with` that only pass if " "the call is the most recent one, and in the case of :meth:" "`assert_called_once_with` it must also be the only call." msgstr "" "Asserter que le simulacre a *bien* été appelé avec les arguments au cours de " "la vie du simulacre. Contrairement à :meth:`assert_called_with` et :meth:" "`assert_called_once_with` qui passent seulement si l'appel demandé " "correspond bien au dernier appel, et dans le cas de :meth:" "`assert_called_once_with` l'appel au simulacre doit être unique." #: library/unittest.mock.rst:361 msgid "" "assert the mock has been called with the specified calls. The :attr:" "`mock_calls` list is checked for the calls." msgstr "" "Asserter que le simulacre a été appelé avec les appels spécifiés. " "L'attribut :attr:`mock_calls` est comparé à la liste des appels." #: library/unittest.mock.rst:364 #, fuzzy msgid "" "If *any_order* is false then the calls must be sequential. There can be " "extra calls before or after the specified calls." msgstr "" "Si *any_order* est faux (la valeur par défaut) alors les appels doivent être " "séquentiels. Il peut y avoir des appels supplémentaires avant ou après les " "appels spécifiés." #: library/unittest.mock.rst:368 msgid "" "If *any_order* is true then the calls can be in any order, but they must all " "appear in :attr:`mock_calls`." msgstr "" "Si *any_order* est vrai alors les appels peuvent être dans n'importe quel " "ordre, mais ils doivent tous apparaître dans :attr:`mock_calls`." #: library/unittest.mock.rst:383 msgid "Assert the mock was never called." msgstr "Asserter que le simulacre n'a jamais été appelé." #: library/unittest.mock.rst:398 msgid "The reset_mock method resets all the call attributes on a mock object:" msgstr "" "La méthode *reset_mock* réinitialise tous les attributs d'appel sur un " "simulacre :" #: library/unittest.mock.rst:408 #, fuzzy msgid "Added two keyword-only arguments to the reset_mock function." msgstr "Ajout de deux arguments nommés à la fonction *reset_mock*." #: library/unittest.mock.rst:411 msgid "" "This can be useful where you want to make a series of assertions that reuse " "the same object. Note that :meth:`reset_mock` *doesn't* clear the return " "value, :attr:`side_effect` or any child attributes you have set using normal " "assignment by default. In case you want to reset *return_value* or :attr:" "`side_effect`, then pass the corresponding parameter as ``True``. Child " "mocks and the return value mock (if any) are reset as well." msgstr "" "Utile pour faire une série d'assertions qui réutilisent le même objet. " "Attention :meth:`reset_mock` *ne réinitialise pas* la valeur de retour, les :" "attr:`side_effect` ou tout attribut enfant que vous avez défini en utilisant " "l'affectation normale par défaut. Pour réinitialiser *return_value* ou :attr:" "`side_effect`, utiliser les paramètres correspondants avec la valeur " "``True``. Les simulacres enfants et le simulacre de valeur de retour (le cas " "échéant) seront également réinitialisés." #: library/unittest.mock.rst:419 #, fuzzy msgid "*return_value*, and :attr:`side_effect` are keyword-only arguments." msgstr "" "*return_value*, et :attr:`side_effect` sont utilisable uniquement par " "arguments nommés." #: library/unittest.mock.rst:425 msgid "" "Add a spec to a mock. *spec* can either be an object or a list of strings. " "Only attributes on the *spec* can be fetched as attributes from the mock." msgstr "" "Ajoute une spécification à un simulacre. *spec* peut être un objet ou une " "liste de chaînes de caractères. Seuls les attributs de la spécification " "*spec* peuvent être récupérés en tant qu'attributs du simulacre." #: library/unittest.mock.rst:429 msgid "If *spec_set* is true then only attributes on the spec can be set." msgstr "" "Si *spec_set* est vrai, seuls les attributs de la spécification peuvent être " "définis." #: library/unittest.mock.rst:434 msgid "" "Attach a mock as an attribute of this one, replacing its name and parent. " "Calls to the attached mock will be recorded in the :attr:`method_calls` and :" "attr:`mock_calls` attributes of this one." msgstr "" "Attache un simulacre comme attribut de l'instance courante, en remplaçant " "son nom et son parent. Les appels au simulacre attaché sont enregistrés dans " "les attributs :attr:`method_calls` et :attr:`mock_calls` de l'instance " "courante." #: library/unittest.mock.rst:441 msgid "Set attributes on the mock through keyword arguments." msgstr "Définir les attributs sur le simulacre à l'aide d'arguments nommés." #: library/unittest.mock.rst:443 msgid "" "Attributes plus return values and side effects can be set on child mocks " "using standard dot notation and unpacking a dictionary in the method call:" msgstr "" "Les attributs, les valeurs de retour et les effets de bords peuvent être " "définis sur des simulacres enfants en utilisant la notation par points " "standard et en dépaquetant un dictionnaire dans l'appel de méthode :" #: library/unittest.mock.rst:457 msgid "The same thing can be achieved in the constructor call to mocks:" msgstr "" "La même chose peut être réalisée en utilisant le constructeur des " "simulacres :" #: library/unittest.mock.rst:470 msgid "" ":meth:`configure_mock` exists to make it easier to do configuration after " "the mock has been created." msgstr "" ":meth:`configure_mock` existe pour faciliter la configuration après la " "création du simulacre." #: library/unittest.mock.rst:476 msgid "" ":class:`Mock` objects limit the results of ``dir(some_mock)`` to useful " "results. For mocks with a *spec* this includes all the permitted attributes " "for the mock." msgstr "" "Les objets :class:`Mock` limitent les résultats de ``dir(un_mock)`` à des " "résultats utiles. Pour les simulacres avec une spécification *spec*, cela " "inclut tous les attributs autorisés du simulacre." #: library/unittest.mock.rst:480 msgid "" "See :data:`FILTER_DIR` for what this filtering does, and how to switch it " "off." msgstr "" "Voir :data:`FILTER_DIR` pour savoir ce que fait ce filtrage, et comment le " "désactiver." #: library/unittest.mock.rst:486 msgid "" "Create the child mocks for attributes and return value. By default child " "mocks will be the same type as the parent. Subclasses of Mock may want to " "override this to customize the way child mocks are made." msgstr "" "Crée les simulacres enfants pour les attributs et la valeur de retour. Par " "défaut, les objets simulacre enfants sont du même type que le parent. Les " "sous-classes de *Mock* peuvent surcharger cette méthode pour personnaliser " "la façon dont les simulacres enfants sont créés." #: library/unittest.mock.rst:491 msgid "" "For non-callable mocks the callable variant will be used (rather than any " "custom subclass)." msgstr "" "Pour les simulacres non appelables, la variante appelable est utilisée " "(plutôt qu'une sous-classe personnalisée)." #: library/unittest.mock.rst:497 msgid "A boolean representing whether or not the mock object has been called:" msgstr "Un booléen représentant si le simulacre a bien été appelé ou non :" #: library/unittest.mock.rst:508 msgid "An integer telling you how many times the mock object has been called:" msgstr "Un entier indiquant combien de fois le simulacre a été appelé :" #: library/unittest.mock.rst:520 msgid "Set this to configure the value returned by calling the mock:" msgstr "" "Définir cette option pour configurer la valeur renvoyé par appel du " "simulacre :" #: library/unittest.mock.rst:527 msgid "" "The default return value is a mock object and you can configure it in the " "normal way:" msgstr "" "La valeur de revoie par défaut est un simulacre configurable normalement :" #: library/unittest.mock.rst:536 msgid ":attr:`return_value` can also be set in the constructor:" msgstr "" "L'attribut :attr:`return_value` peut également être défini dans le " "constructeur :" #: library/unittest.mock.rst:547 msgid "" "This can either be a function to be called when the mock is called, an " "iterable or an exception (class or instance) to be raised." msgstr "" "C'est soit une fonction à appeler lors de l'appel du simulacre, soit une " "exception (classe ou instance) à lever." #: library/unittest.mock.rst:550 msgid "" "If you pass in a function it will be called with same arguments as the mock " "and unless the function returns the :data:`DEFAULT` singleton the call to " "the mock will then return whatever the function returns. If the function " "returns :data:`DEFAULT` then the mock will return its normal value (from " "the :attr:`return_value`)." msgstr "" "Si vous passez une fonction, elle est appelée avec les mêmes arguments que " "la fonction simulée et à moins que la fonction ne renvoie le singleton :data:" "`DEFAULT` l'appel le la fonction simulée renvoie ce que la fonction renvoie. " "Si la fonction renvoie :data:`DEFAULT` alors le simulacre renvoie sa valeur " "normale (celle de :attr:`return_value`)." #: library/unittest.mock.rst:556 msgid "" "If you pass in an iterable, it is used to retrieve an iterator which must " "yield a value on every call. This value can either be an exception instance " "to be raised, or a value to be returned from the call to the mock (:data:" "`DEFAULT` handling is identical to the function case)." msgstr "" "Si vous passez un itérable, il est utilisé pour récupérer un itérateur qui " "doit renvoyer une valeur à chaque appel. Cette valeur peut être soit une " "instance d'exception à lever, soit une valeur à renvoyer à l'appel au " "simulacre (le traitement :data:`DEFAULT` est identique au renvoie de la " "fonction simulée)." #: library/unittest.mock.rst:561 msgid "" "An example of a mock that raises an exception (to test exception handling of " "an API):" msgstr "" "Un exemple d'un simulacre qui lève une exception (pour tester la gestion des " "exceptions d'une API) :" #: library/unittest.mock.rst:571 msgid "Using :attr:`side_effect` to return a sequence of values:" msgstr "Utiliser :attr:`side_effect` pour renvoyer une séquence de valeurs :" #: library/unittest.mock.rst:578 msgid "Using a callable:" msgstr "Utilisation d'un objet appelable :" #: library/unittest.mock.rst:588 msgid "" ":attr:`side_effect` can be set in the constructor. Here's an example that " "adds one to the value the mock is called with and returns it:" msgstr "" "Un attribut :attr:`side_effect` peut être défini dans le constructeur. Voici " "un exemple qui ajoute un à la valeur du simulacre appelé et qui le renvoie :" #: library/unittest.mock.rst:598 msgid "Setting :attr:`side_effect` to ``None`` clears it:" msgstr "Positionner :attr:`side_effect` sur ``None`` l'efface :" #: library/unittest.mock.rst:612 #, fuzzy msgid "" "This is either ``None`` (if the mock hasn't been called), or the arguments " "that the mock was last called with. This will be in the form of a tuple: the " "first member, which can also be accessed through the ``args`` property, is " "any ordered arguments the mock was called with (or an empty tuple) and the " "second member, which can also be accessed through the ``kwargs`` property, " "is any keyword arguments (or an empty dictionary)." msgstr "" "C'est soit ``None`` (si le simulacre n'a pas été appelé), soit les arguments " "avec lesquels le simulacre a été appelé en dernier. Le retour est sous la " "forme d'un *n*-uplet : le premier élément est l'ensemble des arguments " "ordonnés avec lequel le simulacre a été appelé (ou un *n*-uplet vide) et le " "second élément est l'ensemble des arguments nommés (ou un dictionnaire vide)." #: library/unittest.mock.rst:645 msgid "" ":attr:`call_args`, along with members of the lists :attr:`call_args_list`, :" "attr:`method_calls` and :attr:`mock_calls` are :data:`call` objects. These " "are tuples, so they can be unpacked to get at the individual arguments and " "make more complex assertions. See :ref:`calls as tuples `." msgstr "" "L'attribut :attr:`call_args`, ainsi que les éléments des listes :attr:" "`call_args_list`, :attr:`method_calls` et :attr:`mock_calls` sont des " "objets :data:`call`. Ce sont des *n*-uplets, que l'on peut dépaqueter afin " "de faire des affirmations plus complexes sur chacun des arguments. Voir :ref:" "`appels comme *n*-uplets `." #: library/unittest.mock.rst:651 msgid "Added ``args`` and ``kwargs`` properties." msgstr "" #: library/unittest.mock.rst:657 msgid "" "This is a list of all the calls made to the mock object in sequence (so the " "length of the list is the number of times it has been called). Before any " "calls have been made it is an empty list. The :data:`call` object can be " "used for conveniently constructing lists of calls to compare with :attr:" "`call_args_list`." msgstr "" #: library/unittest.mock.rst:673 msgid "" "Members of :attr:`call_args_list` are :data:`call` objects. These can be " "unpacked as tuples to get at the individual arguments. See :ref:`calls as " "tuples `." msgstr "" #: library/unittest.mock.rst:680 msgid "" "As well as tracking calls to themselves, mocks also track calls to methods " "and attributes, and *their* methods and attributes:" msgstr "" #: library/unittest.mock.rst:691 msgid "" "Members of :attr:`method_calls` are :data:`call` objects. These can be " "unpacked as tuples to get at the individual arguments. See :ref:`calls as " "tuples `." msgstr "" #: library/unittest.mock.rst:698 msgid "" ":attr:`mock_calls` records *all* calls to the mock object, its methods, " "magic methods *and* return value mocks." msgstr "" #: library/unittest.mock.rst:716 msgid "" "Members of :attr:`mock_calls` are :data:`call` objects. These can be " "unpacked as tuples to get at the individual arguments. See :ref:`calls as " "tuples `." msgstr "" #: library/unittest.mock.rst:722 msgid "" "The way :attr:`mock_calls` are recorded means that where nested calls are " "made, the parameters of ancestor calls are not recorded and so will always " "compare equal:" msgstr "" #: library/unittest.mock.rst:736 msgid "" "Normally the :attr:`__class__` attribute of an object will return its type. " "For a mock object with a :attr:`spec`, ``__class__`` returns the spec class " "instead. This allows mock objects to pass :func:`isinstance` tests for the " "object they are replacing / masquerading as:" msgstr "" #: library/unittest.mock.rst:745 msgid "" ":attr:`__class__` is assignable to, this allows a mock to pass an :func:" "`isinstance` check without forcing you to use a spec:" msgstr "" #: library/unittest.mock.rst:755 msgid "" "A non-callable version of :class:`Mock`. The constructor parameters have the " "same meaning of :class:`Mock`, with the exception of *return_value* and " "*side_effect* which have no meaning on a non-callable mock." msgstr "" #: library/unittest.mock.rst:759 msgid "" "Mock objects that use a class or an instance as a :attr:`spec` or :attr:" "`spec_set` are able to pass :func:`isinstance` tests:" msgstr "" #: library/unittest.mock.rst:769 msgid "" "The :class:`Mock` classes have support for mocking magic methods. See :ref:" "`magic methods ` for the full details." msgstr "" #: library/unittest.mock.rst:772 msgid "" "The mock classes and the :func:`patch` decorators all take arbitrary keyword " "arguments for configuration. For the :func:`patch` decorators the keywords " "are passed to the constructor of the mock being created. The keyword " "arguments are for configuring attributes of the mock:" msgstr "" #: library/unittest.mock.rst:783 msgid "" "The return value and side effect of child mocks can be set in the same way, " "using dotted notation. As you can't use dotted names directly in a call you " "have to create a dictionary and unpack it using ``**``:" msgstr "" #: library/unittest.mock.rst:798 msgid "" "A callable mock which was created with a *spec* (or a *spec_set*) will " "introspect the specification object's signature when matching calls to the " "mock. Therefore, it can match the actual call's arguments regardless of " "whether they were passed positionally or by name::" msgstr "" #: library/unittest.mock.rst:811 msgid "" "This applies to :meth:`~Mock.assert_called_with`, :meth:`~Mock." "assert_called_once_with`, :meth:`~Mock.assert_has_calls` and :meth:`~Mock." "assert_any_call`. When :ref:`auto-speccing`, it will also apply to method " "calls on the mock object." msgstr "" #: library/unittest.mock.rst:816 msgid "Added signature introspection on specced and autospecced mock objects." msgstr "" #: library/unittest.mock.rst:822 msgid "" "A mock intended to be used as a property, or other descriptor, on a class. :" "class:`PropertyMock` provides :meth:`__get__` and :meth:`__set__` methods so " "you can specify a return value when it is fetched." msgstr "" #: library/unittest.mock.rst:826 msgid "" "Fetching a :class:`PropertyMock` instance from an object calls the mock, " "with no args. Setting it calls the mock with the value being set. ::" msgstr "" #: library/unittest.mock.rst:847 msgid "" "Because of the way mock attributes are stored you can't directly attach a :" "class:`PropertyMock` to a mock object. Instead you can attach it to the mock " "type object::" msgstr "" #: library/unittest.mock.rst:861 msgid "" "An asynchronous version of :class:`MagicMock`. The :class:`AsyncMock` object " "will behave so the object is recognized as an async function, and the result " "of a call is an awaitable." msgstr "" #: library/unittest.mock.rst:871 msgid "" "The result of ``mock()`` is an async function which will have the outcome of " "``side_effect`` or ``return_value`` after it has been awaited:" msgstr "" #: library/unittest.mock.rst:874 msgid "" "if ``side_effect`` is a function, the async function will return the result " "of that function," msgstr "" #: library/unittest.mock.rst:876 msgid "" "if ``side_effect`` is an exception, the async function will raise the " "exception," msgstr "" #: library/unittest.mock.rst:878 msgid "" "if ``side_effect`` is an iterable, the async function will return the next " "value of the iterable, however, if the sequence of result is exhausted, " "``StopAsyncIteration`` is raised immediately," msgstr "" #: library/unittest.mock.rst:881 msgid "" "if ``side_effect`` is not defined, the async function will return the value " "defined by ``return_value``, hence, by default, the async function returns a " "new :class:`AsyncMock` object." msgstr "" #: library/unittest.mock.rst:886 msgid "" "Setting the *spec* of a :class:`Mock` or :class:`MagicMock` to an async " "function will result in a coroutine object being returned after calling." msgstr "" #: library/unittest.mock.rst:898 msgid "" "Setting the *spec* of a :class:`Mock`, :class:`MagicMock`, or :class:" "`AsyncMock` to a class with asynchronous and synchronous functions will " "automatically detect the synchronous functions and set them as :class:" "`MagicMock` (if the parent mock is :class:`AsyncMock` or :class:`MagicMock`) " "or :class:`Mock` (if the parent mock is :class:`Mock`). All asynchronous " "functions will be :class:`AsyncMock`." msgstr "" #: library/unittest.mock.rst:926 msgid "" "Assert that the mock was awaited at least once. Note that this is separate " "from the object having been called, the ``await`` keyword must be used:" msgstr "" #: library/unittest.mock.rst:945 #, fuzzy msgid "Assert that the mock was awaited exactly once." msgstr "Asserter que le *mock* a été appelé exactement une fois." #: library/unittest.mock.rst:961 #, fuzzy msgid "Assert that the last await was with the specified arguments." msgstr "Asserter que le simulacre a été appelé avec les arguments spécifiés." #: library/unittest.mock.rst:978 #, fuzzy msgid "" "Assert that the mock was awaited exactly once and with the specified " "arguments." msgstr "" "Asserter que le simulacre a été appelé exactement une fois et que cet appel " "était avec les arguments spécifiés." #: library/unittest.mock.rst:995 #, fuzzy msgid "Assert the mock has ever been awaited with the specified arguments." msgstr "Asserter que le simulacre a été appelé avec les arguments spécifiés." #: library/unittest.mock.rst:1011 #, fuzzy msgid "" "Assert the mock has been awaited with the specified calls. The :attr:" "`await_args_list` list is checked for the awaits." msgstr "" "Asserter que le simulacre a été appelé avec les appels spécifiés. " "L'attribut :attr:`mock_calls` est comparé à la liste des appels." #: library/unittest.mock.rst:1014 #, fuzzy msgid "" "If *any_order* is false then the awaits must be sequential. There can be " "extra calls before or after the specified awaits." msgstr "" "Si *any_order* est faux (la valeur par défaut) alors les appels doivent être " "séquentiels. Il peut y avoir des appels supplémentaires avant ou après les " "appels spécifiés." #: library/unittest.mock.rst:1018 #, fuzzy msgid "" "If *any_order* is true then the awaits can be in any order, but they must " "all appear in :attr:`await_args_list`." msgstr "" "Si *any_order* est vrai alors les appels peuvent être dans n'importe quel " "ordre, mais ils doivent tous apparaître dans :attr:`mock_calls`." #: library/unittest.mock.rst:1038 #, fuzzy msgid "Assert that the mock was never awaited." msgstr "Asserter que le simulacre n'a jamais été appelé." #: library/unittest.mock.rst:1045 msgid "" "See :func:`Mock.reset_mock`. Also sets :attr:`await_count` to 0, :attr:" "`await_args` to None, and clears the :attr:`await_args_list`." msgstr "" #: library/unittest.mock.rst:1050 #, fuzzy msgid "" "An integer keeping track of how many times the mock object has been awaited." msgstr "Un entier indiquant combien de fois le simulacre a été appelé :" #: library/unittest.mock.rst:1065 msgid "" "This is either ``None`` (if the mock hasn’t been awaited), or the arguments " "that the mock was last awaited with. Functions the same as :attr:`Mock." "call_args`." msgstr "" #: library/unittest.mock.rst:1083 msgid "" "This is a list of all the awaits made to the mock object in sequence (so the " "length of the list is the number of times it has been awaited). Before any " "awaits have been made it is an empty list." msgstr "" #: library/unittest.mock.rst:1102 msgid "Calling" msgstr "" #: library/unittest.mock.rst:1104 msgid "" "Mock objects are callable. The call will return the value set as the :attr:" "`~Mock.return_value` attribute. The default return value is a new Mock " "object; it is created the first time the return value is accessed (either " "explicitly or by calling the Mock) - but it is stored and the same one " "returned each time." msgstr "" #: library/unittest.mock.rst:1110 msgid "" "Calls made to the object will be recorded in the attributes like :attr:" "`~Mock.call_args` and :attr:`~Mock.call_args_list`." msgstr "" #: library/unittest.mock.rst:1113 msgid "" "If :attr:`~Mock.side_effect` is set then it will be called after the call " "has been recorded, so if :attr:`side_effect` raises an exception the call is " "still recorded." msgstr "" #: library/unittest.mock.rst:1117 msgid "" "The simplest way to make a mock raise an exception when called is to make :" "attr:`~Mock.side_effect` an exception class or instance:" msgstr "" #: library/unittest.mock.rst:1135 msgid "" "If :attr:`side_effect` is a function then whatever that function returns is " "what calls to the mock return. The :attr:`side_effect` function is called " "with the same arguments as the mock. This allows you to vary the return " "value of the call dynamically, based on the input:" msgstr "" #: library/unittest.mock.rst:1151 msgid "" "If you want the mock to still return the default return value (a new mock), " "or any set return value, then there are two ways of doing this. Either " "return :attr:`mock.return_value` from inside :attr:`side_effect`, or return :" "data:`DEFAULT`:" msgstr "" #: library/unittest.mock.rst:1170 msgid "" "To remove a :attr:`side_effect`, and return to the default behaviour, set " "the :attr:`side_effect` to ``None``:" msgstr "" #: library/unittest.mock.rst:1184 msgid "" "The :attr:`side_effect` can also be any iterable object. Repeated calls to " "the mock will return values from the iterable (until the iterable is " "exhausted and a :exc:`StopIteration` is raised):" msgstr "" #: library/unittest.mock.rst:1200 msgid "" "If any members of the iterable are exceptions they will be raised instead of " "returned::" msgstr "" #: library/unittest.mock.rst:1218 msgid "Deleting Attributes" msgstr "" #: library/unittest.mock.rst:1220 msgid "" "Mock objects create attributes on demand. This allows them to pretend to be " "objects of any type." msgstr "" #: library/unittest.mock.rst:1223 msgid "" "You may want a mock object to return ``False`` to a :func:`hasattr` call, or " "raise an :exc:`AttributeError` when an attribute is fetched. You can do this " "by providing an object as a :attr:`spec` for a mock, but that isn't always " "convenient." msgstr "" #: library/unittest.mock.rst:1227 msgid "" "You \"block\" attributes by deleting them. Once deleted, accessing an " "attribute will raise an :exc:`AttributeError`." msgstr "" #: library/unittest.mock.rst:1244 msgid "Mock names and the name attribute" msgstr "" #: library/unittest.mock.rst:1246 msgid "" "Since \"name\" is an argument to the :class:`Mock` constructor, if you want " "your mock object to have a \"name\" attribute you can't just pass it in at " "creation time. There are two alternatives. One option is to use :meth:`~Mock." "configure_mock`::" msgstr "" #: library/unittest.mock.rst:1256 msgid "" "A simpler option is to simply set the \"name\" attribute after mock " "creation::" msgstr "" #: library/unittest.mock.rst:1263 msgid "Attaching Mocks as Attributes" msgstr "" #: library/unittest.mock.rst:1265 msgid "" "When you attach a mock as an attribute of another mock (or as the return " "value) it becomes a \"child\" of that mock. Calls to the child are recorded " "in the :attr:`~Mock.method_calls` and :attr:`~Mock.mock_calls` attributes of " "the parent. This is useful for configuring child mocks and then attaching " "them to the parent, or for attaching mocks to a parent that records all " "calls to the children and allows you to make assertions about the order of " "calls between mocks:" msgstr "" #: library/unittest.mock.rst:1283 msgid "" "The exception to this is if the mock has a name. This allows you to prevent " "the \"parenting\" if for some reason you don't want it to happen." msgstr "" #: library/unittest.mock.rst:1294 msgid "" "Mocks created for you by :func:`patch` are automatically given names. To " "attach mocks that have names to a parent you use the :meth:`~Mock." "attach_mock` method::" msgstr "" #: library/unittest.mock.rst:1312 msgid "" "The only exceptions are magic methods and attributes (those that have " "leading and trailing double underscores). Mock doesn't create these but " "instead raises an :exc:`AttributeError`. This is because the interpreter " "will often implicitly request these methods, and gets *very* confused to get " "a new Mock object when it expects a magic method. If you need magic method " "support see :ref:`magic methods `." msgstr "" #: library/unittest.mock.rst:1321 msgid "The patchers" msgstr "" #: library/unittest.mock.rst:1323 msgid "" "The patch decorators are used for patching objects only within the scope of " "the function they decorate. They automatically handle the unpatching for " "you, even if exceptions are raised. All of these functions can also be used " "in with statements or as class decorators." msgstr "" #: library/unittest.mock.rst:1330 msgid "patch" msgstr "" #: library/unittest.mock.rst:1334 msgid "" "The key is to do the patching in the right namespace. See the section `where " "to patch`_." msgstr "" #: library/unittest.mock.rst:1338 msgid "" ":func:`patch` acts as a function decorator, class decorator or a context " "manager. Inside the body of the function or with statement, the *target* is " "patched with a *new* object. When the function/with statement exits the " "patch is undone." msgstr "" #: library/unittest.mock.rst:1343 msgid "" "If *new* is omitted, then the target is replaced with an :class:`AsyncMock` " "if the patched object is an async function or a :class:`MagicMock` " "otherwise. If :func:`patch` is used as a decorator and *new* is omitted, the " "created mock is passed in as an extra argument to the decorated function. " "If :func:`patch` is used as a context manager the created mock is returned " "by the context manager." msgstr "" #: library/unittest.mock.rst:1351 msgid "" "*target* should be a string in the form ``'package.module.ClassName'``. The " "*target* is imported and the specified object replaced with the *new* " "object, so the *target* must be importable from the environment you are " "calling :func:`patch` from. The target is imported when the decorated " "function is executed, not at decoration time." msgstr "" #: library/unittest.mock.rst:1357 msgid "" "The *spec* and *spec_set* keyword arguments are passed to the :class:" "`MagicMock` if patch is creating one for you." msgstr "" #: library/unittest.mock.rst:1360 msgid "" "In addition you can pass ``spec=True`` or ``spec_set=True``, which causes " "patch to pass in the object being mocked as the spec/spec_set object." msgstr "" #: library/unittest.mock.rst:1363 msgid "" "*new_callable* allows you to specify a different class, or callable object, " "that will be called to create the *new* object. By default :class:" "`AsyncMock` is used for async functions and :class:`MagicMock` for the rest." msgstr "" #: library/unittest.mock.rst:1367 msgid "" "A more powerful form of *spec* is *autospec*. If you set ``autospec=True`` " "then the mock will be created with a spec from the object being replaced. " "All attributes of the mock will also have the spec of the corresponding " "attribute of the object being replaced. Methods and functions being mocked " "will have their arguments checked and will raise a :exc:`TypeError` if they " "are called with the wrong signature. For mocks replacing a class, their " "return value (the 'instance') will have the same spec as the class. See the :" "func:`create_autospec` function and :ref:`auto-speccing`." msgstr "" #: library/unittest.mock.rst:1377 msgid "" "Instead of ``autospec=True`` you can pass ``autospec=some_object`` to use an " "arbitrary object as the spec instead of the one being replaced." msgstr "" #: library/unittest.mock.rst:1380 msgid "" "By default :func:`patch` will fail to replace attributes that don't exist. " "If you pass in ``create=True``, and the attribute doesn't exist, patch will " "create the attribute for you when the patched function is called, and delete " "it again after the patched function has exited. This is useful for writing " "tests against attributes that your production code creates at runtime. It is " "off by default because it can be dangerous. With it switched on you can " "write passing tests against APIs that don't actually exist!" msgstr "" #: library/unittest.mock.rst:1390 msgid "" "If you are patching builtins in a module then you don't need to pass " "``create=True``, it will be added by default." msgstr "" #: library/unittest.mock.rst:1394 msgid "" "Patch can be used as a :class:`TestCase` class decorator. It works by " "decorating each test method in the class. This reduces the boilerplate code " "when your test methods share a common patchings set. :func:`patch` finds " "tests by looking for method names that start with ``patch.TEST_PREFIX``. By " "default this is ``'test'``, which matches the way :mod:`unittest` finds " "tests. You can specify an alternative prefix by setting ``patch." "TEST_PREFIX``." msgstr "" #: library/unittest.mock.rst:1401 msgid "" "Patch can be used as a context manager, with the with statement. Here the " "patching applies to the indented block after the with statement. If you use " "\"as\" then the patched object will be bound to the name after the \"as\"; " "very useful if :func:`patch` is creating a mock object for you." msgstr "" #: library/unittest.mock.rst:1406 msgid "" ":func:`patch` takes arbitrary keyword arguments. These will be passed to :" "class:`AsyncMock` if the patched object is asynchronous, to :class:" "`MagicMock` otherwise or to *new_callable* if specified." msgstr "" #: library/unittest.mock.rst:1410 msgid "" "``patch.dict(...)``, ``patch.multiple(...)`` and ``patch.object(...)`` are " "available for alternate use-cases." msgstr "" #: library/unittest.mock.rst:1413 msgid "" ":func:`patch` as function decorator, creating the mock for you and passing " "it into the decorated function::" msgstr "" #: library/unittest.mock.rst:1423 msgid "" "Patching a class replaces the class with a :class:`MagicMock` *instance*. If " "the class is instantiated in the code under test then it will be the :attr:" "`~Mock.return_value` of the mock that will be used." msgstr "" #: library/unittest.mock.rst:1427 msgid "" "If the class is instantiated multiple times you could use :attr:`~Mock." "side_effect` to return a new mock each time. Alternatively you can set the " "*return_value* to be anything you want." msgstr "" #: library/unittest.mock.rst:1431 msgid "" "To configure return values on methods of *instances* on the patched class " "you must do this on the :attr:`return_value`. For example::" msgstr "" #: library/unittest.mock.rst:1445 msgid "" "If you use *spec* or *spec_set* and :func:`patch` is replacing a *class*, " "then the return value of the created mock will have the same spec. ::" msgstr "" #: library/unittest.mock.rst:1455 msgid "" "The *new_callable* argument is useful where you want to use an alternative " "class to the default :class:`MagicMock` for the created mock. For example, " "if you wanted a :class:`NonCallableMock` to be used::" msgstr "" #: library/unittest.mock.rst:1468 msgid "" "Another use case might be to replace an object with an :class:`io.StringIO` " "instance::" msgstr "" #: library/unittest.mock.rst:1481 msgid "" "When :func:`patch` is creating a mock for you, it is common that the first " "thing you need to do is to configure the mock. Some of that configuration " "can be done in the call to patch. Any arbitrary keywords you pass into the " "call will be used to set attributes on the created mock::" msgstr "" #: library/unittest.mock.rst:1493 msgid "" "As well as attributes on the created mock attributes, like the :attr:`~Mock." "return_value` and :attr:`~Mock.side_effect`, of child mocks can also be " "configured. These aren't syntactically valid to pass in directly as keyword " "arguments, but a dictionary with these as keys can still be expanded into a :" "func:`patch` call using ``**``::" msgstr "" #: library/unittest.mock.rst:1509 msgid "" "By default, attempting to patch a function in a module (or a method or an " "attribute in a class) that does not exist will fail with :exc:" "`AttributeError`::" msgstr "" #: library/unittest.mock.rst:1521 msgid "" "but adding ``create=True`` in the call to :func:`patch` will make the " "previous example work as expected::" msgstr "" #: library/unittest.mock.rst:1532 msgid "" ":func:`patch` now returns an :class:`AsyncMock` if the target is an async " "function." msgstr "" #: library/unittest.mock.rst:1536 msgid "patch.object" msgstr "" #: library/unittest.mock.rst:1540 msgid "" "patch the named member (*attribute*) on an object (*target*) with a mock " "object." msgstr "" #: library/unittest.mock.rst:1543 msgid "" ":func:`patch.object` can be used as a decorator, class decorator or a " "context manager. Arguments *new*, *spec*, *create*, *spec_set*, *autospec* " "and *new_callable* have the same meaning as for :func:`patch`. Like :func:" "`patch`, :func:`patch.object` takes arbitrary keyword arguments for " "configuring the mock object it creates." msgstr "" #: library/unittest.mock.rst:1549 msgid "" "When used as a class decorator :func:`patch.object` honours ``patch." "TEST_PREFIX`` for choosing which methods to wrap." msgstr "" #: library/unittest.mock.rst:1552 msgid "" "You can either call :func:`patch.object` with three arguments or two " "arguments. The three argument form takes the object to be patched, the " "attribute name and the object to replace the attribute with." msgstr "" #: library/unittest.mock.rst:1556 msgid "" "When calling with the two argument form you omit the replacement object, and " "a mock is created for you and passed in as an extra argument to the " "decorated function:" msgstr "" #: library/unittest.mock.rst:1567 msgid "" "*spec*, *create* and the other arguments to :func:`patch.object` have the " "same meaning as they do for :func:`patch`." msgstr "" #: library/unittest.mock.rst:1572 msgid "patch.dict" msgstr "" #: library/unittest.mock.rst:1576 msgid "" "Patch a dictionary, or dictionary like object, and restore the dictionary to " "its original state after the test." msgstr "" #: library/unittest.mock.rst:1579 msgid "" "*in_dict* can be a dictionary or a mapping like container. If it is a " "mapping then it must at least support getting, setting and deleting items " "plus iterating over keys." msgstr "" #: library/unittest.mock.rst:1583 msgid "" "*in_dict* can also be a string specifying the name of the dictionary, which " "will then be fetched by importing it." msgstr "" #: library/unittest.mock.rst:1586 msgid "" "*values* can be a dictionary of values to set in the dictionary. *values* " "can also be an iterable of ``(key, value)`` pairs." msgstr "" #: library/unittest.mock.rst:1589 msgid "" "If *clear* is true then the dictionary will be cleared before the new values " "are set." msgstr "" #: library/unittest.mock.rst:1592 msgid "" ":func:`patch.dict` can also be called with arbitrary keyword arguments to " "set values in the dictionary." msgstr "" #: library/unittest.mock.rst:1597 msgid "" ":func:`patch.dict` now returns the patched dictionary when used as a context " "manager." msgstr "" #: library/unittest.mock.rst:1600 #, fuzzy msgid "" ":func:`patch.dict` can be used as a context manager, decorator or class " "decorator:" msgstr "" "Comme tout décorateur, :func:`patch` peut être utilisé comme gestionnaire de " "contexte avec une instruction *with* :" #: library/unittest.mock.rst:1610 msgid "" "When used as a class decorator :func:`patch.dict` honours ``patch." "TEST_PREFIX`` (default to ``'test'``) for choosing which methods to wrap:" msgstr "" #: library/unittest.mock.rst:1621 msgid "" "If you want to use a different prefix for your test, you can inform the " "patchers of the different prefix by setting ``patch.TEST_PREFIX``. For more " "details about how to change the value of see :ref:`test-prefix`." msgstr "" #: library/unittest.mock.rst:1625 msgid "" ":func:`patch.dict` can be used to add members to a dictionary, or simply let " "a test change a dictionary, and ensure the dictionary is restored when the " "test ends." msgstr "" #: library/unittest.mock.rst:1646 msgid "" "Keywords can be used in the :func:`patch.dict` call to set values in the " "dictionary:" msgstr "" #: library/unittest.mock.rst:1656 msgid "" ":func:`patch.dict` can be used with dictionary like objects that aren't " "actually dictionaries. At the very minimum they must support item getting, " "setting, deleting and either iteration or membership test. This corresponds " "to the magic methods :meth:`__getitem__`, :meth:`__setitem__`, :meth:" "`__delitem__` and either :meth:`__iter__` or :meth:`__contains__`." msgstr "" #: library/unittest.mock.rst:1685 msgid "patch.multiple" msgstr "" #: library/unittest.mock.rst:1689 msgid "" "Perform multiple patches in a single call. It takes the object to be patched " "(either as an object or a string to fetch the object by importing) and " "keyword arguments for the patches::" msgstr "" #: library/unittest.mock.rst:1696 msgid "" "Use :data:`DEFAULT` as the value if you want :func:`patch.multiple` to " "create mocks for you. In this case the created mocks are passed into a " "decorated function by keyword, and a dictionary is returned when :func:" "`patch.multiple` is used as a context manager." msgstr "" #: library/unittest.mock.rst:1701 msgid "" ":func:`patch.multiple` can be used as a decorator, class decorator or a " "context manager. The arguments *spec*, *spec_set*, *create*, *autospec* and " "*new_callable* have the same meaning as for :func:`patch`. These arguments " "will be applied to *all* patches done by :func:`patch.multiple`." msgstr "" #: library/unittest.mock.rst:1706 msgid "" "When used as a class decorator :func:`patch.multiple` honours ``patch." "TEST_PREFIX`` for choosing which methods to wrap." msgstr "" #: library/unittest.mock.rst:1709 msgid "" "If you want :func:`patch.multiple` to create mocks for you, then you can " "use :data:`DEFAULT` as the value. If you use :func:`patch.multiple` as a " "decorator then the created mocks are passed into the decorated function by " "keyword. ::" msgstr "" #: library/unittest.mock.rst:1723 msgid "" ":func:`patch.multiple` can be nested with other ``patch`` decorators, but " "put arguments passed by keyword *after* any of the standard arguments " "created by :func:`patch`::" msgstr "" #: library/unittest.mock.rst:1735 msgid "" "If :func:`patch.multiple` is used as a context manager, the value returned " "by the context manager is a dictionary where created mocks are keyed by " "name::" msgstr "" #: library/unittest.mock.rst:1749 msgid "patch methods: start and stop" msgstr "" #: library/unittest.mock.rst:1751 msgid "" "All the patchers have :meth:`start` and :meth:`stop` methods. These make it " "simpler to do patching in ``setUp`` methods or where you want to do multiple " "patches without nesting decorators or with statements." msgstr "" #: library/unittest.mock.rst:1755 msgid "" "To use them call :func:`patch`, :func:`patch.object` or :func:`patch.dict` " "as normal and keep a reference to the returned ``patcher`` object. You can " "then call :meth:`start` to put the patch in place and :meth:`stop` to undo " "it." msgstr "" #: library/unittest.mock.rst:1759 msgid "" "If you are using :func:`patch` to create a mock for you then it will be " "returned by the call to ``patcher.start``. ::" msgstr "" #: library/unittest.mock.rst:1773 msgid "" "A typical use case for this might be for doing multiple patches in the " "``setUp`` method of a :class:`TestCase`::" msgstr "" #: library/unittest.mock.rst:1795 msgid "" "If you use this technique you must ensure that the patching is \"undone\" by " "calling ``stop``. This can be fiddlier than you might think, because if an " "exception is raised in the ``setUp`` then ``tearDown`` is not called. :meth:" "`unittest.TestCase.addCleanup` makes this easier::" msgstr "" #: library/unittest.mock.rst:1810 msgid "" "As an added bonus you no longer need to keep a reference to the ``patcher`` " "object." msgstr "" #: library/unittest.mock.rst:1813 msgid "" "It is also possible to stop all patches which have been started by using :" "func:`patch.stopall`." msgstr "" #: library/unittest.mock.rst:1818 msgid "Stop all active patches. Only stops patches started with ``start``." msgstr "" #: library/unittest.mock.rst:1824 msgid "patch builtins" msgstr "" #: library/unittest.mock.rst:1825 msgid "" "You can patch any builtins within a module. The following example patches " "builtin :func:`ord`::" msgstr "" #: library/unittest.mock.rst:1840 msgid "TEST_PREFIX" msgstr "" #: library/unittest.mock.rst:1842 msgid "" "All of the patchers can be used as class decorators. When used in this way " "they wrap every test method on the class. The patchers recognise methods " "that start with ``'test'`` as being test methods. This is the same way that " "the :class:`unittest.TestLoader` finds test methods by default." msgstr "" #: library/unittest.mock.rst:1847 msgid "" "It is possible that you want to use a different prefix for your tests. You " "can inform the patchers of the different prefix by setting ``patch." "TEST_PREFIX``::" msgstr "" #: library/unittest.mock.rst:1870 msgid "Nesting Patch Decorators" msgstr "" #: library/unittest.mock.rst:1872 msgid "" "If you want to perform multiple patches then you can simply stack up the " "decorators." msgstr "" #: library/unittest.mock.rst:1875 msgid "You can stack up multiple patch decorators using this pattern:" msgstr "" #: library/unittest.mock.rst:1891 msgid "" "Note that the decorators are applied from the bottom upwards. This is the " "standard way that Python applies decorators. The order of the created mocks " "passed into your test function matches this order." msgstr "" #: library/unittest.mock.rst:1899 msgid "Where to patch" msgstr "" #: library/unittest.mock.rst:1901 msgid "" ":func:`patch` works by (temporarily) changing the object that a *name* " "points to with another one. There can be many names pointing to any " "individual object, so for patching to work you must ensure that you patch " "the name used by the system under test." msgstr "" #: library/unittest.mock.rst:1906 msgid "" "The basic principle is that you patch where an object is *looked up*, which " "is not necessarily the same place as where it is defined. A couple of " "examples will help to clarify this." msgstr "" #: library/unittest.mock.rst:1910 msgid "" "Imagine we have a project that we want to test with the following structure::" msgstr "" #: library/unittest.mock.rst:1919 msgid "" "Now we want to test ``some_function`` but we want to mock out ``SomeClass`` " "using :func:`patch`. The problem is that when we import module b, which we " "will have to do then it imports ``SomeClass`` from module a. If we use :func:" "`patch` to mock out ``a.SomeClass`` then it will have no effect on our test; " "module b already has a reference to the *real* ``SomeClass`` and it looks " "like our patching had no effect." msgstr "" #: library/unittest.mock.rst:1926 msgid "" "The key is to patch out ``SomeClass`` where it is used (or where it is " "looked up). In this case ``some_function`` will actually look up " "``SomeClass`` in module b, where we have imported it. The patching should " "look like::" msgstr "" #: library/unittest.mock.rst:1932 msgid "" "However, consider the alternative scenario where instead of ``from a import " "SomeClass`` module b does ``import a`` and ``some_function`` uses ``a." "SomeClass``. Both of these import forms are common. In this case the class " "we want to patch is being looked up in the module and so we have to patch " "``a.SomeClass`` instead::" msgstr "" #: library/unittest.mock.rst:1941 msgid "Patching Descriptors and Proxy Objects" msgstr "" #: library/unittest.mock.rst:1943 msgid "" "Both patch_ and patch.object_ correctly patch and restore descriptors: class " "methods, static methods and properties. You should patch these on the " "*class* rather than an instance. They also work with *some* objects that " "proxy attribute access, like the `django settings object `_." msgstr "" #: library/unittest.mock.rst:1951 msgid "MagicMock and magic method support" msgstr "" #: library/unittest.mock.rst:1956 msgid "Mocking Magic Methods" msgstr "" #: library/unittest.mock.rst:1958 msgid "" ":class:`Mock` supports mocking the Python protocol methods, also known as " "\"magic methods\". This allows mock objects to replace containers or other " "objects that implement Python protocols." msgstr "" #: library/unittest.mock.rst:1962 msgid "" "Because magic methods are looked up differently from normal methods [#]_, " "this support has been specially implemented. This means that only specific " "magic methods are supported. The supported list includes *almost* all of " "them. If there are any missing that you need please let us know." msgstr "" #: library/unittest.mock.rst:1967 msgid "" "You mock magic methods by setting the method you are interested in to a " "function or a mock instance. If you are using a function then it *must* take " "``self`` as the first argument [#]_." msgstr "" #: library/unittest.mock.rst:1990 msgid "" "One use case for this is for mocking objects used as context managers in a :" "keyword:`with` statement:" msgstr "" #: library/unittest.mock.rst:2002 msgid "" "Calls to magic methods do not appear in :attr:`~Mock.method_calls`, but they " "are recorded in :attr:`~Mock.mock_calls`." msgstr "" #: library/unittest.mock.rst:2007 msgid "" "If you use the *spec* keyword argument to create a mock then attempting to " "set a magic method that isn't in the spec will raise an :exc:" "`AttributeError`." msgstr "" #: library/unittest.mock.rst:2010 msgid "The full list of supported magic methods is:" msgstr "" #: library/unittest.mock.rst:2012 msgid "``__hash__``, ``__sizeof__``, ``__repr__`` and ``__str__``" msgstr "" #: library/unittest.mock.rst:2013 msgid "``__dir__``, ``__format__`` and ``__subclasses__``" msgstr "``__dir__``, ``__format__`` et ``__subclasses__``" #: library/unittest.mock.rst:2014 #, fuzzy msgid "``__round__``, ``__floor__``, ``__trunc__`` and ``__ceil__``" msgstr "``__floor__``, ``__trunc__`` et ``__ceil__``" #: library/unittest.mock.rst:2015 msgid "" "Comparisons: ``__lt__``, ``__gt__``, ``__le__``, ``__ge__``, ``__eq__`` and " "``__ne__``" msgstr "" #: library/unittest.mock.rst:2017 msgid "" "Container methods: ``__getitem__``, ``__setitem__``, ``__delitem__``, " "``__contains__``, ``__len__``, ``__iter__``, ``__reversed__`` and " "``__missing__``" msgstr "" #: library/unittest.mock.rst:2020 #, fuzzy msgid "" "Context manager: ``__enter__``, ``__exit__``, ``__aenter__`` and " "``__aexit__``" msgstr "``__get__``, ``__set__`` et ``__delete__``" #: library/unittest.mock.rst:2021 msgid "Unary numeric methods: ``__neg__``, ``__pos__`` and ``__invert__``" msgstr "" #: library/unittest.mock.rst:2022 msgid "" "The numeric methods (including right hand and in-place variants): " "``__add__``, ``__sub__``, ``__mul__``, ``__matmul__``, ``__truediv__``, " "``__floordiv__``, ``__mod__``, ``__divmod__``, ``__lshift__``, " "``__rshift__``, ``__and__``, ``__xor__``, ``__or__``, and ``__pow__``" msgstr "" #: library/unittest.mock.rst:2026 msgid "" "Numeric conversion methods: ``__complex__``, ``__int__``, ``__float__`` and " "``__index__``" msgstr "" #: library/unittest.mock.rst:2028 msgid "Descriptor methods: ``__get__``, ``__set__`` and ``__delete__``" msgstr "" #: library/unittest.mock.rst:2029 msgid "" "Pickling: ``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, " "``__getnewargs__``, ``__getstate__`` and ``__setstate__``" msgstr "" #: library/unittest.mock.rst:2031 msgid "File system path representation: ``__fspath__``" msgstr "" #: library/unittest.mock.rst:2032 msgid "Asynchronous iteration methods: ``__aiter__`` and ``__anext__``" msgstr "" #: library/unittest.mock.rst:2034 msgid "Added support for :func:`os.PathLike.__fspath__`." msgstr "" #: library/unittest.mock.rst:2037 msgid "" "Added support for ``__aenter__``, ``__aexit__``, ``__aiter__`` and " "``__anext__``." msgstr "" #: library/unittest.mock.rst:2041 msgid "" "The following methods exist but are *not* supported as they are either in " "use by mock, can't be set dynamically, or can cause problems:" msgstr "" #: library/unittest.mock.rst:2044 msgid "``__getattr__``, ``__setattr__``, ``__init__`` and ``__new__``" msgstr "" #: library/unittest.mock.rst:2045 msgid "" "``__prepare__``, ``__instancecheck__``, ``__subclasscheck__``, ``__del__``" msgstr "" #: library/unittest.mock.rst:2050 msgid "Magic Mock" msgstr "" #: library/unittest.mock.rst:2052 msgid "" "There are two ``MagicMock`` variants: :class:`MagicMock` and :class:" "`NonCallableMagicMock`." msgstr "" #: library/unittest.mock.rst:2057 msgid "" "``MagicMock`` is a subclass of :class:`Mock` with default implementations of " "most of the magic methods. You can use ``MagicMock`` without having to " "configure the magic methods yourself." msgstr "" #: library/unittest.mock.rst:2061 msgid "The constructor parameters have the same meaning as for :class:`Mock`." msgstr "" #: library/unittest.mock.rst:2063 msgid "" "If you use the *spec* or *spec_set* arguments then *only* magic methods that " "exist in the spec will be created." msgstr "" #: library/unittest.mock.rst:2069 msgid "A non-callable version of :class:`MagicMock`." msgstr "" #: library/unittest.mock.rst:2071 msgid "" "The constructor parameters have the same meaning as for :class:`MagicMock`, " "with the exception of *return_value* and *side_effect* which have no meaning " "on a non-callable mock." msgstr "" #: library/unittest.mock.rst:2075 msgid "" "The magic methods are setup with :class:`MagicMock` objects, so you can " "configure them and use them in the usual way:" msgstr "" #: library/unittest.mock.rst:2085 msgid "" "By default many of the protocol methods are required to return objects of a " "specific type. These methods are preconfigured with a default return value, " "so that they can be used without you having to do anything if you aren't " "interested in the return value. You can still *set* the return value " "manually if you want to change the default." msgstr "" #: library/unittest.mock.rst:2091 msgid "Methods and their defaults:" msgstr "" #: library/unittest.mock.rst:2093 msgid "``__lt__``: ``NotImplemented``" msgstr "``__lt__``: ``NotImplemented``" #: library/unittest.mock.rst:2094 msgid "``__gt__``: ``NotImplemented``" msgstr "``__gt__``: ``NotImplemented``" #: library/unittest.mock.rst:2095 msgid "``__le__``: ``NotImplemented``" msgstr "``__le__``: ``NotImplemented``" #: library/unittest.mock.rst:2096 msgid "``__ge__``: ``NotImplemented``" msgstr "``__ge__``: ``NotImplemented``" #: library/unittest.mock.rst:2097 msgid "``__int__``: ``1``" msgstr "``__int__``: ``1``" #: library/unittest.mock.rst:2098 msgid "``__contains__``: ``False``" msgstr "``__contains__``: ``False``" #: library/unittest.mock.rst:2099 msgid "``__len__``: ``0``" msgstr "``__int__``: ``0``" #: library/unittest.mock.rst:2100 msgid "``__iter__``: ``iter([])``" msgstr "``__iter__``: ``iter([])``" #: library/unittest.mock.rst:2101 msgid "``__exit__``: ``False``" msgstr "``__exit__``: ``False``" #: library/unittest.mock.rst:2102 msgid "``__aexit__``: ``False``" msgstr "``__exit__``: ``False``" #: library/unittest.mock.rst:2103 msgid "``__complex__``: ``1j``" msgstr "``__complex__``: ``1j``" #: library/unittest.mock.rst:2104 msgid "``__float__``: ``1.0``" msgstr "``__float__``: ``1.0``" #: library/unittest.mock.rst:2105 msgid "``__bool__``: ``True``" msgstr "``__bool__``: ``True``" #: library/unittest.mock.rst:2106 msgid "``__index__``: ``1``" msgstr "``__index__``: ``1``" #: library/unittest.mock.rst:2107 msgid "``__hash__``: default hash for the mock" msgstr "" #: library/unittest.mock.rst:2108 msgid "``__str__``: default str for the mock" msgstr "" #: library/unittest.mock.rst:2109 msgid "``__sizeof__``: default sizeof for the mock" msgstr "" #: library/unittest.mock.rst:2111 msgid "For example:" msgstr "Par exemple :" #: library/unittest.mock.rst:2123 msgid "" "The two equality methods, :meth:`__eq__` and :meth:`__ne__`, are special. " "They do the default equality comparison on identity, using the :attr:`~Mock." "side_effect` attribute, unless you change their return value to return " "something else::" msgstr "" #: library/unittest.mock.rst:2137 msgid "" "The return value of :meth:`MagicMock.__iter__` can be any iterable object " "and isn't required to be an iterator:" msgstr "" #: library/unittest.mock.rst:2147 msgid "" "If the return value *is* an iterator, then iterating over it once will " "consume it and subsequent iterations will result in an empty list:" msgstr "" #: library/unittest.mock.rst:2156 msgid "" "``MagicMock`` has all of the supported magic methods configured except for " "some of the obscure and obsolete ones. You can still set these up if you " "want." msgstr "" #: library/unittest.mock.rst:2159 msgid "" "Magic methods that are supported but not setup by default in ``MagicMock`` " "are:" msgstr "" #: library/unittest.mock.rst:2161 msgid "``__subclasses__``" msgstr "``__subclasses__``" #: library/unittest.mock.rst:2162 msgid "``__dir__``" msgstr "``__dir__``" #: library/unittest.mock.rst:2163 msgid "``__format__``" msgstr "``__format__``" #: library/unittest.mock.rst:2164 msgid "``__get__``, ``__set__`` and ``__delete__``" msgstr "``__get__``, ``__set__`` et ``__delete__``" #: library/unittest.mock.rst:2165 msgid "``__reversed__`` and ``__missing__``" msgstr "``__reversed__`` et ``__missing__``" #: library/unittest.mock.rst:2166 msgid "" "``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, ``__getnewargs__``, " "``__getstate__`` and ``__setstate__``" msgstr "" #: library/unittest.mock.rst:2168 #, fuzzy msgid "``__getformat__``" msgstr "``__format__``" #: library/unittest.mock.rst:2172 msgid "" "Magic methods *should* be looked up on the class rather than the instance. " "Different versions of Python are inconsistent about applying this rule. The " "supported protocol methods should work with all supported versions of Python." msgstr "" #: library/unittest.mock.rst:2176 msgid "" "The function is basically hooked up to the class, but each ``Mock`` instance " "is kept isolated from the others." msgstr "" #: library/unittest.mock.rst:2181 msgid "Helpers" msgstr "" #: library/unittest.mock.rst:2184 msgid "sentinel" msgstr "" #: library/unittest.mock.rst:2188 msgid "" "The ``sentinel`` object provides a convenient way of providing unique " "objects for your tests." msgstr "" #: library/unittest.mock.rst:2191 msgid "" "Attributes are created on demand when you access them by name. Accessing the " "same attribute will always return the same object. The objects returned have " "a sensible repr so that test failure messages are readable." msgstr "" #: library/unittest.mock.rst:2195 msgid "" "The ``sentinel`` attributes now preserve their identity when they are :mod:" "`copied ` or :mod:`pickled `." msgstr "" #: library/unittest.mock.rst:2199 msgid "" "Sometimes when testing you need to test that a specific object is passed as " "an argument to another method, or returned. It can be common to create named " "sentinel objects to test this. :data:`sentinel` provides a convenient way of " "creating and testing the identity of objects like this." msgstr "" #: library/unittest.mock.rst:2204 msgid "" "In this example we monkey patch ``method`` to return ``sentinel." "some_object``:" msgstr "" #: library/unittest.mock.rst:2216 msgid "DEFAULT" msgstr "" #: library/unittest.mock.rst:2221 msgid "" "The :data:`DEFAULT` object is a pre-created sentinel (actually ``sentinel." "DEFAULT``). It can be used by :attr:`~Mock.side_effect` functions to " "indicate that the normal return value should be used." msgstr "" #: library/unittest.mock.rst:2227 msgid "call" msgstr "" #: library/unittest.mock.rst:2231 msgid "" ":func:`call` is a helper object for making simpler assertions, for comparing " "with :attr:`~Mock.call_args`, :attr:`~Mock.call_args_list`, :attr:`~Mock." "mock_calls` and :attr:`~Mock.method_calls`. :func:`call` can also be used " "with :meth:`~Mock.assert_has_calls`." msgstr "" #: library/unittest.mock.rst:2244 msgid "" "For a call object that represents multiple calls, :meth:`call_list` returns " "a list of all the intermediate calls as well as the final call." msgstr "" #: library/unittest.mock.rst:2248 msgid "" "``call_list`` is particularly useful for making assertions on \"chained " "calls\". A chained call is multiple calls on a single line of code. This " "results in multiple entries in :attr:`~Mock.mock_calls` on a mock. Manually " "constructing the sequence of calls can be tedious." msgstr "" #: library/unittest.mock.rst:2253 msgid "" ":meth:`~call.call_list` can construct the sequence of calls from the same " "chained call:" msgstr "" #: library/unittest.mock.rst:2270 msgid "" "A ``call`` object is either a tuple of (positional args, keyword args) or " "(name, positional args, keyword args) depending on how it was constructed. " "When you construct them yourself this isn't particularly interesting, but " "the ``call`` objects that are in the :attr:`Mock.call_args`, :attr:`Mock." "call_args_list` and :attr:`Mock.mock_calls` attributes can be introspected " "to get at the individual arguments they contain." msgstr "" #: library/unittest.mock.rst:2277 msgid "" "The ``call`` objects in :attr:`Mock.call_args` and :attr:`Mock." "call_args_list` are two-tuples of (positional args, keyword args) whereas " "the ``call`` objects in :attr:`Mock.mock_calls`, along with ones you " "construct yourself, are three-tuples of (name, positional args, keyword " "args)." msgstr "" #: library/unittest.mock.rst:2282 msgid "" "You can use their \"tupleness\" to pull out the individual arguments for " "more complex introspection and assertions. The positional arguments are a " "tuple (an empty tuple if there are no positional arguments) and the keyword " "arguments are a dictionary:" msgstr "" #: library/unittest.mock.rst:2315 msgid "create_autospec" msgstr "" #: library/unittest.mock.rst:2319 msgid "" "Create a mock object using another object as a spec. Attributes on the mock " "will use the corresponding attribute on the *spec* object as their spec." msgstr "" #: library/unittest.mock.rst:2323 msgid "" "Functions or methods being mocked will have their arguments checked to " "ensure that they are called with the correct signature." msgstr "" #: library/unittest.mock.rst:2326 msgid "" "If *spec_set* is ``True`` then attempting to set attributes that don't exist " "on the spec object will raise an :exc:`AttributeError`." msgstr "" #: library/unittest.mock.rst:2329 msgid "" "If a class is used as a spec then the return value of the mock (the instance " "of the class) will have the same spec. You can use a class as the spec for " "an instance object by passing ``instance=True``. The returned mock will only " "be callable if instances of the mock are callable." msgstr "" #: library/unittest.mock.rst:2334 msgid "" ":func:`create_autospec` also takes arbitrary keyword arguments that are " "passed to the constructor of the created mock." msgstr "" #: library/unittest.mock.rst:2337 msgid "" "See :ref:`auto-speccing` for examples of how to use auto-speccing with :func:" "`create_autospec` and the *autospec* argument to :func:`patch`." msgstr "" #: library/unittest.mock.rst:2343 msgid "" ":func:`create_autospec` now returns an :class:`AsyncMock` if the target is " "an async function." msgstr "" #: library/unittest.mock.rst:2348 msgid "ANY" msgstr "" #: library/unittest.mock.rst:2352 msgid "" "Sometimes you may need to make assertions about *some* of the arguments in a " "call to mock, but either not care about some of the arguments or want to " "pull them individually out of :attr:`~Mock.call_args` and make more complex " "assertions on them." msgstr "" #: library/unittest.mock.rst:2357 msgid "" "To ignore certain arguments you can pass in objects that compare equal to " "*everything*. Calls to :meth:`~Mock.assert_called_with` and :meth:`~Mock." "assert_called_once_with` will then succeed no matter what was passed in." msgstr "" #: library/unittest.mock.rst:2366 msgid "" ":data:`ANY` can also be used in comparisons with call lists like :attr:" "`~Mock.mock_calls`:" msgstr "" #: library/unittest.mock.rst:2379 msgid "FILTER_DIR" msgstr "" #: library/unittest.mock.rst:2383 msgid "" ":data:`FILTER_DIR` is a module level variable that controls the way mock " "objects respond to :func:`dir`. The default is ``True``, which uses the " "filtering described below, to only show useful members. If you dislike this " "filtering, or need to switch it off for diagnostic purposes, then set ``mock." "FILTER_DIR = False``." msgstr "" #: library/unittest.mock.rst:2389 msgid "" "With filtering on, ``dir(some_mock)`` shows only useful attributes and will " "include any dynamically created attributes that wouldn't normally be shown. " "If the mock was created with a *spec* (or *autospec* of course) then all the " "attributes from the original are shown, even if they haven't been accessed " "yet:" msgstr "" #: library/unittest.mock.rst:2416 msgid "" "Many of the not-very-useful (private to :class:`Mock` rather than the thing " "being mocked) underscore and double underscore prefixed attributes have been " "filtered from the result of calling :func:`dir` on a :class:`Mock`. If you " "dislike this behaviour you can switch it off by setting the module level " "switch :data:`FILTER_DIR`:" msgstr "" #: library/unittest.mock.rst:2437 msgid "" "Alternatively you can just use ``vars(my_mock)`` (instance members) and " "``dir(type(my_mock))`` (type members) to bypass the filtering irrespective " "of :data:`mock.FILTER_DIR`." msgstr "" #: library/unittest.mock.rst:2443 msgid "mock_open" msgstr "" #: library/unittest.mock.rst:2447 msgid "" "A helper function to create a mock to replace the use of :func:`open`. It " "works for :func:`open` called directly or used as a context manager." msgstr "" #: library/unittest.mock.rst:2450 msgid "" "The *mock* argument is the mock object to configure. If ``None`` (the " "default) then a :class:`MagicMock` will be created for you, with the API " "limited to methods or attributes available on standard file handles." msgstr "" #: library/unittest.mock.rst:2454 msgid "" "*read_data* is a string for the :meth:`~io.IOBase.read`, :meth:`~io.IOBase." "readline`, and :meth:`~io.IOBase.readlines` methods of the file handle to " "return. Calls to those methods will take data from *read_data* until it is " "depleted. The mock of these methods is pretty simplistic: every time the " "*mock* is called, the *read_data* is rewound to the start. If you need more " "control over the data that you are feeding to the tested code you will need " "to customize this mock for yourself. When that is insufficient, one of the " "in-memory filesystem packages on `PyPI `_ can offer a " "realistic filesystem for testing." msgstr "" #: library/unittest.mock.rst:2464 msgid "" "Added :meth:`~io.IOBase.readline` and :meth:`~io.IOBase.readlines` support. " "The mock of :meth:`~io.IOBase.read` changed to consume *read_data* rather " "than returning it on each call." msgstr "" #: library/unittest.mock.rst:2469 msgid "*read_data* is now reset on each call to the *mock*." msgstr "" #: library/unittest.mock.rst:2472 msgid "" "Added :meth:`__iter__` to implementation so that iteration (such as in for " "loops) correctly consumes *read_data*." msgstr "" #: library/unittest.mock.rst:2476 msgid "" "Using :func:`open` as a context manager is a great way to ensure your file " "handles are closed properly and is becoming common::" msgstr "" #: library/unittest.mock.rst:2482 msgid "" "The issue is that even if you mock out the call to :func:`open` it is the " "*returned object* that is used as a context manager (and has :meth:" "`__enter__` and :meth:`__exit__` called)." msgstr "" #: library/unittest.mock.rst:2486 msgid "" "Mocking context managers with a :class:`MagicMock` is common enough and " "fiddly enough that a helper function is useful. ::" msgstr "" #: library/unittest.mock.rst:2503 msgid "And for reading files::" msgstr "" #: library/unittest.mock.rst:2516 msgid "Autospeccing" msgstr "" #: library/unittest.mock.rst:2518 msgid "" "Autospeccing is based on the existing :attr:`spec` feature of mock. It " "limits the api of mocks to the api of an original object (the spec), but it " "is recursive (implemented lazily) so that attributes of mocks only have the " "same api as the attributes of the spec. In addition mocked functions / " "methods have the same call signature as the original so they raise a :exc:" "`TypeError` if they are called incorrectly." msgstr "" #: library/unittest.mock.rst:2525 msgid "Before I explain how auto-speccing works, here's why it is needed." msgstr "" #: library/unittest.mock.rst:2527 msgid "" ":class:`Mock` is a very powerful and flexible object, but it suffers from " "two flaws when used to mock out objects from a system under test. One of " "these flaws is specific to the :class:`Mock` api and the other is a more " "general problem with using mock objects." msgstr "" #: library/unittest.mock.rst:2532 msgid "" "First the problem specific to :class:`Mock`. :class:`Mock` has two assert " "methods that are extremely handy: :meth:`~Mock.assert_called_with` and :meth:" "`~Mock.assert_called_once_with`." msgstr "" #: library/unittest.mock.rst:2545 msgid "" "Because mocks auto-create attributes on demand, and allow you to call them " "with arbitrary arguments, if you misspell one of these assert methods then " "your assertion is gone:" msgstr "" #: library/unittest.mock.rst:2555 msgid "Your tests can pass silently and incorrectly because of the typo." msgstr "" #: library/unittest.mock.rst:2557 msgid "" "The second issue is more general to mocking. If you refactor some of your " "code, rename members and so on, any tests for code that is still using the " "*old api* but uses mocks instead of the real objects will still pass. This " "means your tests can all pass even though your code is broken." msgstr "" #: library/unittest.mock.rst:2562 msgid "" "Note that this is another reason why you need integration tests as well as " "unit tests. Testing everything in isolation is all fine and dandy, but if " "you don't test how your units are \"wired together\" there is still lots of " "room for bugs that tests might have caught." msgstr "" #: library/unittest.mock.rst:2567 msgid "" ":mod:`mock` already provides a feature to help with this, called speccing. " "If you use a class or instance as the :attr:`spec` for a mock then you can " "only access attributes on the mock that exist on the real class:" msgstr "" #: library/unittest.mock.rst:2578 msgid "" "The spec only applies to the mock itself, so we still have the same issue " "with any methods on the mock:" msgstr "" #: library/unittest.mock.rst:2587 msgid "" "Auto-speccing solves this problem. You can either pass ``autospec=True`` to :" "func:`patch` / :func:`patch.object` or use the :func:`create_autospec` " "function to create a mock with a spec. If you use the ``autospec=True`` " "argument to :func:`patch` then the object that is being replaced will be " "used as the spec object. Because the speccing is done \"lazily\" (the spec " "is created as attributes on the mock are accessed) you can use it with very " "complex or deeply nested objects (like modules that import modules that " "import modules) without a big performance hit." msgstr "" #: library/unittest.mock.rst:2596 msgid "Here's an example of it in use::" msgstr "" #: library/unittest.mock.rst:2606 msgid "" "You can see that :class:`request.Request` has a spec. :class:`request." "Request` takes two arguments in the constructor (one of which is *self*). " "Here's what happens if we try to call it incorrectly::" msgstr "" #: library/unittest.mock.rst:2615 msgid "" "The spec also applies to instantiated classes (i.e. the return value of " "specced mocks)::" msgstr "" #: library/unittest.mock.rst:2622 msgid "" ":class:`Request` objects are not callable, so the return value of " "instantiating our mocked out :class:`request.Request` is a non-callable " "mock. With the spec in place any typos in our asserts will raise the correct " "error::" msgstr "" #: library/unittest.mock.rst:2634 msgid "" "In many cases you will just be able to add ``autospec=True`` to your " "existing :func:`patch` calls and then be protected against bugs due to typos " "and api changes." msgstr "" #: library/unittest.mock.rst:2638 msgid "" "As well as using *autospec* through :func:`patch` there is a :func:" "`create_autospec` for creating autospecced mocks directly:" msgstr "" #: library/unittest.mock.rst:2646 msgid "" "This isn't without caveats and limitations however, which is why it is not " "the default behaviour. In order to know what attributes are available on the " "spec object, autospec has to introspect (access attributes) the spec. As you " "traverse attributes on the mock a corresponding traversal of the original " "object is happening under the hood. If any of your specced objects have " "properties or descriptors that can trigger code execution then you may not " "be able to use autospec. On the other hand it is much better to design your " "objects so that introspection is safe [#]_." msgstr "" #: library/unittest.mock.rst:2655 msgid "" "A more serious problem is that it is common for instance attributes to be " "created in the :meth:`__init__` method and not to exist on the class at all. " "*autospec* can't know about any dynamically created attributes and restricts " "the api to visible attributes. ::" msgstr "" #: library/unittest.mock.rst:2672 msgid "" "There are a few different ways of resolving this problem. The easiest, but " "not necessarily the least annoying, way is to simply set the required " "attributes on the mock after creation. Just because *autospec* doesn't allow " "you to fetch attributes that don't exist on the spec it doesn't prevent you " "setting them::" msgstr "" #: library/unittest.mock.rst:2683 msgid "" "There is a more aggressive version of both *spec* and *autospec* that *does* " "prevent you setting non-existent attributes. This is useful if you want to " "ensure your code only *sets* valid attributes too, but obviously it prevents " "this particular scenario:" msgstr "" #: library/unittest.mock.rst:2696 msgid "" "Probably the best way of solving the problem is to add class attributes as " "default values for instance members initialised in :meth:`__init__`. Note " "that if you are only setting default attributes in :meth:`__init__` then " "providing them via class attributes (shared between instances of course) is " "faster too. e.g." msgstr "" #: library/unittest.mock.rst:2706 msgid "" "This brings up another issue. It is relatively common to provide a default " "value of ``None`` for members that will later be an object of a different " "type. ``None`` would be useless as a spec because it wouldn't let you access " "*any* attributes or methods on it. As ``None`` is *never* going to be useful " "as a spec, and probably indicates a member that will normally of some other " "type, autospec doesn't use a spec for members that are set to ``None``. " "These will just be ordinary mocks (well - MagicMocks):" msgstr "" #: library/unittest.mock.rst:2721 msgid "" "If modifying your production classes to add defaults isn't to your liking " "then there are more options. One of these is simply to use an instance as " "the spec rather than the class. The other is to create a subclass of the " "production class and add the defaults to the subclass without affecting the " "production class. Both of these require you to use an alternative object as " "the spec. Thankfully :func:`patch` supports this - you can simply pass the " "alternative object as the *autospec* argument::" msgstr "" #: library/unittest.mock.rst:2742 msgid "" "This only applies to classes or already instantiated objects. Calling a " "mocked class to create a mock instance *does not* create a real instance. It " "is only attribute lookups - along with calls to :func:`dir` - that are done." msgstr "" #: library/unittest.mock.rst:2747 msgid "Sealing mocks" msgstr "" #: library/unittest.mock.rst:2756 msgid "" "Seal will disable the automatic creation of mocks when accessing an " "attribute of the mock being sealed or any of its attributes that are already " "mocks recursively." msgstr "" #: library/unittest.mock.rst:2759 msgid "" "If a mock instance with a name or a spec is assigned to an attribute it " "won't be considered in the sealing chain. This allows one to prevent seal " "from fixing part of the mock object. ::" msgstr "" #~ msgid "``__getformat__`` and ``__setformat__``" #~ msgstr "``__getformat__`` et ``__setformat__``"