diff --git a/dictionaries/library_unittest.mock.txt b/dictionaries/library_unittest.mock.txt new file mode 100644 index 0000000000..04768a2701 --- /dev/null +++ b/dictionaries/library_unittest.mock.txt @@ -0,0 +1,27 @@ +adjuntarlos +Aserta +asertar +autospec +autoespecificación +Autoespecificación +backport +configurarlos +desparchear +django +introspeccionará +MagicMock +mock +parcheadores +Parcheadores +patch +Patch +preconfigurados +refactorizas +seal +Seal +settings +síncronas +sizeof +start +stop +stubs diff --git a/library/unittest.mock.po b/library/unittest.mock.po index db04d04cd8..522abced7a 100644 --- a/library/unittest.mock.po +++ b/library/unittest.mock.po @@ -6,27 +6,29 @@ # Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to # get the list of volunteers # -#, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.8\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-05-05 12:54+0200\n" -"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" -"Last-Translator: FULL NAME \n" +"PO-Revision-Date: 2020-10-03 23:50+0200\n" "Language-Team: python-doc-es\n" "MIME-Version: 1.0\n" -"Content-Type: text/plain; charset=utf-8\n" +"Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Generated-By: Babel 2.8.0\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"Last-Translator: Francisco Jesús Sevilla García \n" +"Language: es\n" +"X-Generator: Poedit 2.4.1\n" #: ../Doc/library/unittest.mock.rst:3 msgid ":mod:`unittest.mock` --- mock object library" -msgstr "" +msgstr ":mod:`unittest.mock` --- Biblioteca de objetos simulados" #: ../Doc/library/unittest.mock.rst:13 msgid "**Source code:** :source:`Lib/unittest/mock.py`" -msgstr "" +msgstr "**Source code:** :source:`Lib/unittest/mock.py`" #: ../Doc/library/unittest.mock.rst:17 msgid "" @@ -34,6 +36,9 @@ msgid "" "replace parts of your system under test with mock objects and make " "assertions about how they have been used." msgstr "" +":mod:`unittest.mock` es una biblioteca para pruebas de software en Python. " +"Te permite reemplazar partes del sistema bajo prueba con objetos simulados y " +"hacer aserciones sobre cómo se han utilizado." #: ../Doc/library/unittest.mock.rst:21 msgid "" @@ -43,6 +48,12 @@ msgid "" "and arguments they were called with. You can also specify return values and " "set needed attributes in the normal way." msgstr "" +"El módulo :mod:`unittest.mock` proporciona una clase principal :class:`Mock` " +"eliminando la necesidad de crear una gran cantidad de stubs en todo el " +"conjunto de pruebas. Después de realizar una determinada acción, puedes " +"hacer aserciones sobre qué métodos/atributos se usaron y los argumentos con " +"los que se llamaron. También puedes especificar valores de retorno y " +"establecer los atributos necesarios de la forma habitual." #: ../Doc/library/unittest.mock.rst:27 msgid "" @@ -52,6 +63,11 @@ msgid "" "some examples of how to use :class:`Mock`, :class:`MagicMock` and :func:" "`patch`." msgstr "" +"Además, mock proporciona un decorador :func:`patch` que puede manejar el " +"parcheo de atributos a nivel de clase y de módulo dentro del ámbito de una " +"prueba, junto con :const:`sentinel` para crear objetos únicos. Consulta " +"`quick guide`_ para ver algunos ejemplos de cómo utilizar :class:`Mock`, :" +"class:`MagicMock` y :func:`patch`." #: ../Doc/library/unittest.mock.rst:33 msgid "" @@ -59,16 +75,22 @@ msgid "" "is based on the 'action -> assertion' pattern instead of 'record -> replay' " "used by many mocking frameworks." msgstr "" +"Mock es muy fácil de usar y está diseñado para ser utilizado junto a :mod:" +"`unittest`. Mock se basa en el patrón 'acción -> aserción' en lugar de usar " +"el patrón 'grabación -> reproducción' utilizado por muchos frameworks de " +"simulación." #: ../Doc/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 "" +"Hay un backport del módulo :mod:`unittest.mock` para versiones anteriores de " +"Python `disponible en PyPI `_." #: ../Doc/library/unittest.mock.rst:42 msgid "Quick Guide" -msgstr "" +msgstr "Guía rápida" #: ../Doc/library/unittest.mock.rst:60 msgid "" @@ -77,12 +99,19 @@ msgid "" "can configure them, to specify return values or limit what attributes are " "available, and then make assertions about how they have been used:" msgstr "" +"Los objetos de las clases :class:`Mock` y :class:`MagicMock` van creando " +"todos los atributos y métodos a medida que se accede a ellos y almacenan " +"detalles de cómo se han utilizado. Puedes configurarlos para especificar " +"valores de retorno o limitar qué atributos están disponibles y " +"posteriormente hacer aserciones sobre cómo han sido utilizados:" #: ../Doc/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 "" +":attr:`side_effect` te permite implementar efectos colaterales, lo que " +"incluye lanzar una excepción cuando se llama a un objeto simulado:" #: ../Doc/library/unittest.mock.rst:92 msgid "" @@ -91,6 +120,11 @@ msgid "" "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 "" +"Existen muchas otras formas de configurar y controlar el comportamiento de " +"Mock. Por ejemplo, el argumento *spec* configura el objeto simulado para que " +"tome su especificación de otro objeto. Cualquier intento de acceder a " +"atributos o métodos en el objeto simulado que no existan en la " +"especificación fallará lanzando una excepción :exc:`AttributeError`." #: ../Doc/library/unittest.mock.rst:97 msgid "" @@ -99,6 +133,10 @@ msgid "" "with a mock (or other object) during the test and restored when the test " "ends::" msgstr "" +"El decorador / gestor de contexto :func:`patch` facilita la simulación de " +"clases u objetos en un módulo bajo prueba. El objeto que especifiques será " +"reemplazado por un objeto simulado (u otro objeto) durante la prueba y será " +"restaurado cuando esta finalice:" #: ../Doc/library/unittest.mock.rst:116 msgid "" @@ -107,6 +145,11 @@ msgid "" "decorators are applied). This means from the bottom up, so in the example " "above the mock for ``module.ClassName1`` is passed in first." msgstr "" +"Cuando anidas decoradores patch, los objetos simulados se pasan a la función " +"decorada en el mismo orden en el que fueron aplicados (el orden normal en el " +"que se aplican los decoradores en *Python*). Esto significa de abajo hacia " +"arriba, por lo que en el ejemplo anterior se pasa primero el objeto simulado " +"para ``module.ClassName1``." #: ../Doc/library/unittest.mock.rst:121 msgid "" @@ -114,12 +157,17 @@ msgid "" "they are looked up. This is normally straightforward, but for a quick guide " "read :ref:`where to patch `." msgstr "" +"Al usar :func:`patch` es importante que parchees los objetos en el espacio " +"de nombres donde son buscados. Esto normalmente es sencillo, pero para una " +"guía rápida, lee :ref:`dónde parchear `." #: ../Doc/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 "" +"Además de decorador, la función :func:`patch` se puede usar como gestor de " +"contexto en una declaración with:" #: ../Doc/library/unittest.mock.rst:135 msgid "" @@ -127,6 +175,9 @@ msgid "" "during a scope and restoring the dictionary to its original state when the " "test ends:" msgstr "" +"También existe la función :func:`patch.dict` que permite establecer valores " +"en un diccionario dentro de un ámbito y restaurar el diccionario a su estado " +"original cuando finaliza la prueba:" #: ../Doc/library/unittest.mock.rst:146 msgid "" @@ -134,6 +185,9 @@ msgid "" "The easiest way of using magic methods is with the :class:`MagicMock` class. " "It allows you to do things like:" msgstr "" +"Mock admite la simulación de los :ref:`métodos mágicos ` de " +"Python. La forma más sencilla de utilizar métodos mágicos es mediante la " +"clase :class:`MagicMock`. Te permite hacer cosas como:" #: ../Doc/library/unittest.mock.rst:156 msgid "" @@ -142,12 +196,19 @@ msgid "" "is just a Mock variant that has all of the magic methods pre-created for you " "(well, all the useful ones anyway)." msgstr "" +"Mock también permite asignar funciones (u otras instancias de Mock) a " +"métodos mágicos y se asegura de que serán llamadas de forma apropiada. La " +"clase :class:`MagicMock` es solo una variante de Mock con la diferencia de " +"que tiene todos los métodos mágicos previamente creados para ti (bueno, " +"todos los que son útiles)." #: ../Doc/library/unittest.mock.rst:161 msgid "" "The following is an example of using magic methods with the ordinary Mock " "class:" msgstr "" +"El siguiente es un ejemplo de uso de métodos mágicos utilizando la clase " +"Mock ordinaria:" #: ../Doc/library/unittest.mock.rst:169 msgid "" @@ -159,12 +220,22 @@ msgid "" "replacing, and any functions and methods (including constructors) have the " "same call signature as the real object." msgstr "" +"Para asegurarte de que los objetos simulados en tus pruebas tienen " +"exactamente la misma API que los objetos que están reemplazando, puedes " +"usar :ref:`autoespecificación `. La autoespecificación se " +"puede realizar a través del argumento *autospec* de patch, o mediante la " +"función :func:`create_autospec`. La autoespecificación crea objetos " +"simulados que tienen los mismos atributos y métodos que los objetos que " +"están reemplazando, y todas las función y métodos (incluidos los " +"constructores) tienen la misma firma de llamada que los objetos reales." #: ../Doc/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 "" +"Esto asegura que tus simulaciones fallarán, si se utilizan incorrectamente, " +"de la misma manera que lo haría tu código en producción:" #: ../Doc/library/unittest.mock.rst:193 msgid "" @@ -172,10 +243,13 @@ msgid "" "signature of the ``__init__`` method, and on callable objects where it " "copies the signature of the ``__call__`` method." msgstr "" +":func:`create_autospec` también se puede usar en clases, donde copia la " +"firma del método ``__init__``, y en objetos invocables, donde copia la firma " +"del método ``__call__``." #: ../Doc/library/unittest.mock.rst:200 msgid "The Mock Class" -msgstr "" +msgstr "La clase Mock" #: ../Doc/library/unittest.mock.rst:211 msgid "" @@ -185,6 +259,12 @@ msgid "" "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 "" +":class:`Mock` es un objeto simulado flexible, destinado a reemplazar el uso " +"de stubs y dobles de prueba en todo tu código. Los objetos Mock son " +"invocables y crean atributos en el mismo momento que se accede a ellos como " +"nuevos objetos Mock [#]_. Acceder al mismo atributo siempre retornará el " +"mismo objeto Mock. Además, registran cómo los usas, lo que te permite hacer " +"aserciones sobre cómo tu código ha interaccionado con ellos." #: ../Doc/library/unittest.mock.rst:217 msgid "" @@ -193,6 +273,10 @@ msgid "" "when you are mocking out objects that aren't callable: :class:" "`NonCallableMock` and :class:`NonCallableMagicMock`" msgstr "" +":class:`MagicMock` es una subclase de :class:`Mock` con todos los métodos " +"mágicos creados previamente y listos para ser usados. También hay variantes " +"no invocables, útiles cuando se están simulando objetos que no se pueden " +"llamar: :class:`NonCallableMock` y :class:`NonCallableMagicMock`" #: ../Doc/library/unittest.mock.rst:222 msgid "" @@ -201,12 +285,19 @@ msgid "" "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 "" +"Los decoradores :func:`patch` facilitan la sustitución temporal de clases en " +"un módulo en particular con un objeto :class:`Mock`. Por defecto, :func:" +"`patch` creará un objeto :class:`MagicMock` automáticamente. Se puede " +"especificar una clase alternativa a :class:`Mock` usando el argumento " +"*new_callable* de :func:`patch`." #: ../Doc/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 "" +"Crea un nuevo objeto :class:`Mock`. :class:`Mock` toma varios argumentos " +"opcionales que especifican el comportamiento del objeto Mock:" #: ../Doc/library/unittest.mock.rst:233 msgid "" @@ -216,6 +307,12 @@ msgid "" "(excluding unsupported magic attributes and methods). Accessing any " "attribute not in this list will raise an :exc:`AttributeError`." msgstr "" +"*spec*: Puede ser una lista de cadenas de caracteres o un objeto existente " +"previamente (una clase o una instancia) que actúa como la especificación del " +"objeto simulado. Si pasas un objeto, se forma una lista de cadenas llamando " +"a la función *dir* en el objeto (excluyendo los métodos y atributos mágicos " +"no admitidos). Acceder a cualquier atributo que no esté en esta lista " +"generará una excepción :exc:`AttributeError`." #: ../Doc/library/unittest.mock.rst:239 msgid "" @@ -223,6 +320,9 @@ msgid "" "__class__` returns the class of the spec object. This allows mocks to pass :" "func:`isinstance` tests." msgstr "" +"Si *spec* es un objeto (en lugar de una lista de cadenas de caracteres), :" +"attr:`~instance.__class__` retorna la clase del objeto especificado. Esto " +"permite que los objetos simulados pasen las pruebas de :func:`isinstance`." #: ../Doc/library/unittest.mock.rst:243 msgid "" @@ -230,6 +330,10 @@ msgid "" "get an attribute on the mock that isn't on the object passed as *spec_set* " "will raise an :exc:`AttributeError`." msgstr "" +"*spec_set*: Una variante más estricta de *spec*. Si se utiliza, cualquier " +"intento de *establecer* u obtener un atributo del objeto simulado que no " +"esté en el objeto pasado como *spec_set* lanzará una excepción :exc:" +"`AttributeError`." #: ../Doc/library/unittest.mock.rst:247 msgid "" @@ -239,22 +343,32 @@ msgid "" "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*: Una función que se llamará cada vez que el objeto simulado " +"sea invocado. Consultar el atributo :attr:`~Mock.side_effect` para más " +"información. Es útil para lanzar excepciones o para cambiar dinámicamente " +"valores de retorno. La función se llama con los mismos argumentos que el " +"objeto simulado, y a menos que retorne :data:`DEFAULT`, su valor de retorno " +"se utiliza como valor de retorno del propio objeto simulado." #: ../Doc/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 "" +"Alternativamente *side_effect* puede ser una clase o instancia de excepción. " +"En este caso, se lanza la excepción cuando se llama al objeto simulado." #: ../Doc/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* es un iterable, cada llamada al objeto simulado retornará " +"el siguiente valor del iterable." #: ../Doc/library/unittest.mock.rst:259 msgid "A *side_effect* can be cleared by setting it to ``None``." -msgstr "" +msgstr "Un *side_effect* se puede desactivar estableciéndolo en ``None``." #: ../Doc/library/unittest.mock.rst:261 msgid "" @@ -262,6 +376,9 @@ msgid "" "is a new Mock (created on first access). See the :attr:`return_value` " "attribute." msgstr "" +"*return_value*: El valor retornado cuando se llama al objeto simulado. Por " +"defecto, este es una nueva instancia de la clase Mock (creada en el primer " +"acceso). Consultar el atributo :attr:`return_value` para más detalles." #: ../Doc/library/unittest.mock.rst:265 msgid "" @@ -269,6 +386,10 @@ msgid "" "raise an :exc:`AttributeError`. Passing ``unsafe=True`` will allow access to " "these attributes." msgstr "" +"*unsafe*: Por defecto, si cualquier atributo comienza con *assert* o " +"*assret* y se intenta acceder a él, se lanza una excepción :exc:" +"`AttributeError`. Pasar ``unsafe=True`` permitirá el acceso a estos " +"atributos." #: ../Doc/library/unittest.mock.rst:271 msgid "" @@ -279,18 +400,30 @@ msgid "" "to access an attribute that doesn't exist will raise an :exc:" "`AttributeError`)." msgstr "" +"*wraps*: objeto a envolver (simular) por la instancia de Mock. Si *wraps* no " +"es ``None``, al llamar al objeto Mock se pasa la llamada a través del objeto " +"envuelto (retornando el resultado real). Acceder a un atributo del objeto " +"simulado retornará otro objeto Mock que envuelve al atributo correspondiente " +"del objeto real envuelto (de modo que intentar acceder a un atributo que no " +"existe lanzará una excepción :exc:`AttributeError`)." #: ../Doc/library/unittest.mock.rst:278 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 el objeto simulado tiene un *return_value* explícito establecido, las " +"llamadas no se pasan al objeto envuelto y *return_value* se retorna en su " +"lugar." #: ../Doc/library/unittest.mock.rst:281 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 el objeto simulado tiene un nombre, será utilizado en la " +"representación imprimible del mismo. Esto puede ser útil para la depuración. " +"El nombre se propaga a los objetos simulados hijos." #: ../Doc/library/unittest.mock.rst:285 msgid "" @@ -298,30 +431,39 @@ msgid "" "used to set attributes on the mock after it is created. See the :meth:" "`configure_mock` method for details." msgstr "" +"Los objetos simulados también pueden ser invocados con argumentos por " +"palabra clave arbitrarios. Estos serán utilizados para establecer atributos " +"en el objeto simulado una vez creado. Consultar el método :meth:" +"`configure_mock` para más detalles." #: ../Doc/library/unittest.mock.rst:291 msgid "Assert that the mock was called at least once." -msgstr "" +msgstr "Aserta si el objeto simulado se ha invocado al menos una vez." #: ../Doc/library/unittest.mock.rst:302 msgid "Assert that the mock was called exactly once." -msgstr "" +msgstr "Aserta si el objeto simulado se ha invocado exactamente una vez." #: ../Doc/library/unittest.mock.rst:320 msgid "" "This method is a convenient way of asserting that the last call has been " "made in a particular way:" msgstr "" +"Este método es una manera apropiada de asertar si la última llamada se ha " +"realizado de una manera particular:" #: ../Doc/library/unittest.mock.rst:330 msgid "" "Assert that the mock was called exactly once and that that call was with the " "specified arguments." msgstr "" +"Aserta si el objeto simulado se ha invocado exactamente una vez y si esa " +"llamada se realizó con los argumentos especificados." #: ../Doc/library/unittest.mock.rst:345 msgid "assert the mock has been called with the specified arguments." msgstr "" +"Aserta si el objeto simulado se ha invocado con los argumentos especificados." #: ../Doc/library/unittest.mock.rst:347 msgid "" @@ -330,36 +472,51 @@ msgid "" "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 "" +"La aserción pasa si el objeto simulado se ha invocado *en algún momento*, a " +"diferencia de :meth:`assert_called_with` y :meth:`assert_called_once_with`, " +"con los que sólo pasa la aserción si la llamada es la más reciente, y en el " +"caso de :meth:`assert_called_once_with` también debe ser la única llamada " +"realizada." #: ../Doc/library/unittest.mock.rst:360 msgid "" "assert the mock has been called with the specified calls. The :attr:" "`mock_calls` list is checked for the calls." msgstr "" +"Aserta si el objeto simulado se ha invocado con las llamadas especificadas. " +"La lista :attr:`mock_calls` se compara con la lista de llamadas." #: ../Doc/library/unittest.mock.rst:363 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* es falso entonces las llamadas deben ser secuenciales. No " +"puede haber llamadas adicionales antes o después de las llamadas " +"especificadas." #: ../Doc/library/unittest.mock.rst:367 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* es verdadero, las llamadas pueden estar en cualquier orden, " +"pero deben aparecer todas en :attr:`mock_calls`." #: ../Doc/library/unittest.mock.rst:382 msgid "Assert the mock was never called." -msgstr "" +msgstr "Aserta si el objeto simulado nunca fue invocado." #: ../Doc/library/unittest.mock.rst:397 msgid "The reset_mock method resets all the call attributes on a mock object:" msgstr "" +"El método *reset_mock* restablece todos los atributos de llamada en un " +"objeto simulado:" #: ../Doc/library/unittest.mock.rst:407 msgid "Added two keyword only argument to the reset_mock function." msgstr "" +"Se añadieron dos argumentos por palabra clave a la función *reset_mock*." #: ../Doc/library/unittest.mock.rst:410 msgid "" @@ -370,20 +527,35 @@ msgid "" "`side_effect`, then pass the corresponding parameter as ``True``. Child " "mocks and the return value mock (if any) are reset as well." msgstr "" +"Esto puede ser útil cuando se quiere hacer una serie de aserciones que " +"reutilizan el mismo objeto. Ten en cuenta que por defecto :meth:`reset_mock` " +"*no* borra el valor de retorno, :attr:`side_effect`, ni cualquier atributo " +"hijo que hayas establecido mediante asignación normal. En caso de que " +"quieras restablecer *return_value* o :attr:`side_effect`, debes pasar el " +"parámetro correspondiente como ``True``. Los objetos simulados hijos y el " +"objeto simulado que conforma el valor de retorno (si los hay) se restablecen " +"también." #: ../Doc/library/unittest.mock.rst:418 msgid "*return_value*, and :attr:`side_effect` are keyword only argument." msgstr "" +"*return_value* y :attr:`side_effect` son argumentos por palabra clave " +"exclusivamente." #: ../Doc/library/unittest.mock.rst:424 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 "" +"Agrega una especificación a un objeto simulado. *spec* puede ser un objeto o " +"una lista de cadenas de caracteres. Sólo los atributos presentes en *spec* " +"pueden ser obtenidos desde el objeto simulado." #: ../Doc/library/unittest.mock.rst:428 msgid "If *spec_set* is true then only attributes on the spec can be set." msgstr "" +"Si *spec_set* es verdadero, solo los atributos de la especificación pueden " +"ser establecidos." #: ../Doc/library/unittest.mock.rst:433 msgid "" @@ -391,26 +563,39 @@ msgid "" "Calls to the attached mock will be recorded in the :attr:`method_calls` and :" "attr:`mock_calls` attributes of this one." msgstr "" +"Adjunta otro objeto simulado como un atributo de la instancia actual, " +"substituyendo su nombre y su padre. Las llamadas al objeto simulado " +"adjuntado se registrarán en los atributos :attr:`method_calls` y :attr:" +"`mock_calls` del padre." #: ../Doc/library/unittest.mock.rst:440 msgid "Set attributes on the mock through keyword arguments." msgstr "" +"Establece los atributos del objeto simulado por medio de argumentos por " +"palabra clave." #: ../Doc/library/unittest.mock.rst:442 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 "" +"Los atributos, los valores de retorno y los efectos de colaterales se pueden " +"configurar en los objetos simulados hijos usando la notación de punto " +"estándar y desempaquetando un diccionario en la llamada al método:" #: ../Doc/library/unittest.mock.rst:456 msgid "The same thing can be achieved in the constructor call to mocks:" msgstr "" +"Lo mismo se puede lograr en la llamada al constructor de los objetos " +"simulados:" #: ../Doc/library/unittest.mock.rst:469 msgid "" ":meth:`configure_mock` exists to make it easier to do configuration after " "the mock has been created." msgstr "" +":meth:`configure_mock` existe con el fin de facilitar la configuración " +"después de que el objeto simulado haya sido creado." #: ../Doc/library/unittest.mock.rst:475 msgid "" @@ -418,12 +603,17 @@ msgid "" "results. For mocks with a *spec* this includes all the permitted attributes " "for the mock." msgstr "" +"Los objetos :class:`Mock` limitan los resultados de ``dir(some_mock)`` a " +"resultados útiles. Para los objetos simulados con una especificación " +"(*spec*), esto incluye todos los atributos permitidos para el mismo." #: ../Doc/library/unittest.mock.rst:479 msgid "" "See :data:`FILTER_DIR` for what this filtering does, and how to switch it " "off." msgstr "" +"Consultar :data:`FILTER_DIR` para conocer que hace este filtrado y la forma " +"de desactivarlo." #: ../Doc/library/unittest.mock.rst:485 msgid "" @@ -431,40 +621,56 @@ msgid "" "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 "" +"Crea los objetos simulados hijos para los atributos y el valor de retorno. " +"Por defecto los objetos simulados hijos serán del mismo tipo que el padre. " +"Las subclases de Mock pueden redefinir este método para personalizar la " +"forma en la que se construye el objeto simulado hijo." #: ../Doc/library/unittest.mock.rst:490 msgid "" "For non-callable mocks the callable variant will be used (rather than any " "custom subclass)." msgstr "" +"Para objetos simulados no invocables la variante invocable será utilizada " +"(en lugar de cualquier subclase personalizada)." #: ../Doc/library/unittest.mock.rst:496 msgid "A boolean representing whether or not the mock object has been called:" msgstr "" +"Un booleano que representa si el objeto simulado ha sido invocado o no:" #: ../Doc/library/unittest.mock.rst:507 msgid "An integer telling you how many times the mock object has been called:" msgstr "" +"Un entero que le indica cuántas veces el objeto simulado ha sido invocado:" #: ../Doc/library/unittest.mock.rst:519 msgid "Set this to configure the value returned by calling the mock:" msgstr "" +"Establece este atributo para configurar el valor a retornar cuando se llama " +"al objeto simulado:" #: ../Doc/library/unittest.mock.rst:526 msgid "" "The default return value is a mock object and you can configure it in the " "normal way:" msgstr "" +"El valor de retorno por defecto es otro objeto simulado y se puede " +"configurar de forma habitual:" #: ../Doc/library/unittest.mock.rst:535 msgid ":attr:`return_value` can also be set in the constructor:" msgstr "" +":attr:`return_value` también se puede establecer directamente en el " +"constructor:" #: ../Doc/library/unittest.mock.rst:546 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 "" +"Este atributo puede ser una función a ser llamada cuando se llame al objeto " +"simulado, un iterable o una excepción (clase o instancia) para ser lanzada." #: ../Doc/library/unittest.mock.rst:549 msgid "" @@ -474,6 +680,11 @@ msgid "" "returns :data:`DEFAULT` then the mock will return its normal value (from " "the :attr:`return_value`)." msgstr "" +"Si pasas una función, será llamada con los mismos argumentos que el objeto " +"simulado y, a menos que la función retorne el singleton :data:`DEFAULT`, la " +"llamada al objeto simulado retornará lo mismo que retorna la función. En " +"cambio, si la función retorna :data:`DEFAULT`, entonces el objeto simulado " +"retornará su valor normal (el del atributo :attr:`return_value`)." #: ../Doc/library/unittest.mock.rst:555 msgid "" @@ -482,30 +693,39 @@ msgid "" "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 pasas un iterable, se utiliza para obtener un iterador a partir del mismo " +"que debe producir un valor en cada llamada. Este valor puede ser una " +"instancia de la excepción a ser lanzada o un valor a retornar al llamar al " +"objeto simulado (el manejo de :data:`DEFAULT` es igual que en el caso en el " +"que se pasa una función)." #: ../Doc/library/unittest.mock.rst:560 msgid "" "An example of a mock that raises an exception (to test exception handling of " "an API):" msgstr "" +"Un ejemplo de un objeto simulado que genera una excepción (para probar el " +"manejo de excepciones de una API):" #: ../Doc/library/unittest.mock.rst:570 msgid "Using :attr:`side_effect` to return a sequence of values:" -msgstr "" +msgstr "Usando :attr:`side_effect` para retornar una secuencia de valores:" #: ../Doc/library/unittest.mock.rst:577 msgid "Using a callable:" -msgstr "" +msgstr "Usando un objeto invocable:" #: ../Doc/library/unittest.mock.rst:587 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 "" +":attr:`side_effect` se puede establecer en el constructor. Aquí hay un " +"ejemplo que suma uno al valor del objeto simulado invocado y lo retorna:" #: ../Doc/library/unittest.mock.rst:597 msgid "Setting :attr:`side_effect` to ``None`` clears it:" -msgstr "" +msgstr "Establecer :attr:`side_effect` en ``None`` lo desactiva:" #: ../Doc/library/unittest.mock.rst:611 msgid "" @@ -516,6 +736,14 @@ msgid "" "second member, which can also be accessed through the ``kwargs`` property, " "is any keyword arguments (or an empty dictionary)." msgstr "" +"Este atributo es ``None`` (si el objeto simulado no ha sido invocado) o los " +"argumentos con los que se llamó por última vez. En este último caso, será " +"una tupla con dos elementos: el primer miembro, que también es accesible a " +"través de la propiedad ``args``, son los argumentos posicionales con los que " +"el objeto simulado se llamó (o una tupla vacía si no se pasó ninguno) y el " +"segundo miembro, que también es accesible mediante la propiedad ``kwargs``, " +"son los argumento por palabra clave pasados (o un diccionario vacío si no se " +"pasó ninguno)." #: ../Doc/library/unittest.mock.rst:644 msgid "" @@ -524,6 +752,12 @@ msgid "" "are tuples, so they can be unpacked to get at the individual arguments and " "make more complex assertions. See :ref:`calls as tuples `." msgstr "" +"El atributo :attr:`call_args`, junto con los miembros de las listas :attr:" +"`call_args_list`, :attr:`method_calls` y :attr:`mock_calls` son objetos :" +"data:`call`. Estos objetos son tuplas, con la finalidad de que puedan ser " +"desempaquetadas para acceder a los argumentos individuales y hacer " +"aserciones más complejas. Consultar :ref:`objetos call como tuplas ` para más información." #: ../Doc/library/unittest.mock.rst:653 msgid "" @@ -533,6 +767,12 @@ msgid "" "used for conveniently constructing lists of calls to compare with :attr:" "`call_args_list`." msgstr "" +"Este argumento es una lista de todas las llamadas consecutivas realizadas al " +"objeto simulado (por lo que la longitud de la lista es el número de veces " +"que se ha invocado). Previamente a que se hayan realizado llamadas es una " +"lista vacía. El objeto :data:`call` se puede utilizar para construir " +"convenientemente las listas de llamadas a comparar con :attr:" +"`call_args_list`." #: ../Doc/library/unittest.mock.rst:669 msgid "" @@ -540,12 +780,19 @@ msgid "" "unpacked as tuples to get at the individual arguments. See :ref:`calls as " "tuples `." msgstr "" +"Los miembros de :attr:`call_args_list` son objetos :data:`call`. Estos " +"pueden ser desempaquetados como tuplas para acceder a los argumentos " +"individuales. Consultar :ref:`objetos call como tuplas ` " +"para más información." #: ../Doc/library/unittest.mock.rst:676 msgid "" "As well as tracking calls to themselves, mocks also track calls to methods " "and attributes, and *their* methods and attributes:" msgstr "" +"Igual que realizan un seguimiento de las llamadas hechas a sí mismos, los " +"objetos simulados también realizan un seguimiento a *sus* métodos y " +"atributos, así como de las llamadas hechas a los mismos:" #: ../Doc/library/unittest.mock.rst:687 msgid "" @@ -553,12 +800,18 @@ msgid "" "unpacked as tuples to get at the individual arguments. See :ref:`calls as " "tuples `." msgstr "" +"Los miembros de :attr:`method_calls` son objetos :data:`call`. Estos pueden " +"ser desempaquetados como tuplas para acceder a los atributos individuales. " +"Consultar :ref:`objetos call como tuplas ` para más " +"información." #: ../Doc/library/unittest.mock.rst:694 msgid "" ":attr:`mock_calls` records *all* calls to the mock object, its methods, " "magic methods *and* return value mocks." msgstr "" +":attr:`mock_calls` registra *todas* las llamadas al objeto simulado, sus " +"métodos, métodos mágicos *y* objetos simulados del valor de retorno." #: ../Doc/library/unittest.mock.rst:712 msgid "" @@ -566,6 +819,10 @@ msgid "" "unpacked as tuples to get at the individual arguments. See :ref:`calls as " "tuples `." msgstr "" +"Los miembros de :attr:`mock_calls` son objetos :data:`call`. Estos pueden " +"ser desempaquetados como tuplas para acceder a los argumentos individuales. " +"Consultar :ref:`objetos call como tuplas ` para más " +"información." #: ../Doc/library/unittest.mock.rst:718 msgid "" @@ -573,6 +830,9 @@ msgid "" "made, the parameters of ancestor calls are not recorded and so will always " "compare equal:" msgstr "" +"La forma como se registra el atributo :attr:`mock_calls` implica que cuando " +"se realizan llamadas anidadas, los parámetros de las llamadas previas no se " +"registran, por lo que siempre resultan iguales al comparar:" #: ../Doc/library/unittest.mock.rst:732 msgid "" @@ -581,12 +841,20 @@ msgid "" "instead. This allows mock objects to pass :func:`isinstance` tests for the " "object they are replacing / masquerading as:" msgstr "" +"Normalmente, el atributo de un objeto :attr:`__class__` retornará su tipo. " +"Para un objeto simulado con un :attr:`spec`, ``__class__`` retorna la clase " +"especificada en su lugar. Esto permite a los objetos simulados pasar los " +"test de :func:`isinstance` para el objeto que están reemplazando / " +"enmascarando:" #: ../Doc/library/unittest.mock.rst:741 msgid "" ":attr:`__class__` is assignable to, this allows a mock to pass an :func:" "`isinstance` check without forcing you to use a spec:" msgstr "" +"El atributo :attr:`__class__` es asignable, esto permite al objeto simulado " +"pasar una verificación de :func:`isinstance` sin verse forzado a utilizar " +"una especificación:" #: ../Doc/library/unittest.mock.rst:751 msgid "" @@ -594,18 +862,27 @@ msgid "" "same meaning of :class:`Mock`, with the exception of *return_value* and " "*side_effect* which have no meaning on a non-callable mock." msgstr "" +"Una versión no invocable de :class:`Mock`. Los parámetros del constructor " +"tienen el mismo significado que en :class:`Mock`, con la excepción de " +"*return_value* y *side_effect* que no tienen sentido en un objeto simulado " +"no invocable." #: ../Doc/library/unittest.mock.rst:755 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 "" +"Los objetos simulados que usan una clase o una instancia como :attr:`spec` " +"o :attr:`spec_set` son capaces de pasar los test de :func:`isinstance`:" #: ../Doc/library/unittest.mock.rst:765 msgid "" "The :class:`Mock` classes have support for mocking magic methods. See :ref:" "`magic methods ` for the full details." msgstr "" +"Las clases :class:`Mock` tienen soporte para simular los métodos mágicos. " +"Consultar la sección dedicada a los :ref:`métodos mágicos ` " +"para ver los detalles." #: ../Doc/library/unittest.mock.rst:768 msgid "" @@ -614,6 +891,11 @@ msgid "" "are passed to the constructor of the mock being created. The keyword " "arguments are for configuring attributes of the mock:" msgstr "" +"Las clases simuladas y los decoradores :func:`patch` aceptan todas " +"argumentos por palabra clave arbitrarios para la configuración. En los " +"decoradores :func:`patch` los argumentos por palabra clave se pasan al " +"constructor del objeto simulado creado. Estos argumentos se usan para " +"configurar los atributos del propio objeto simulado:" #: ../Doc/library/unittest.mock.rst:779 msgid "" @@ -621,6 +903,11 @@ msgid "" "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 "" +"Tanto el valor de retorno como el efecto colateral del objeto simulado " +"pueden ser establecidos de la misma manera, mediante notación de punto. En " +"cambio, si se quieren establecer mediante el constructor, dado que no se " +"puede utilizar notación de punto directamente en una llamada, se tiene que " +"crear un diccionario y desempaquetarlo usando ``**``:" #: ../Doc/library/unittest.mock.rst:794 msgid "" @@ -629,6 +916,11 @@ msgid "" "mock. Therefore, it can match the actual call's arguments regardless of " "whether they were passed positionally or by name::" msgstr "" +"Un objeto simulado invocable que fue creado con un *spec* (o un *spec_set*) " +"introspeccionará la firma del objeto de la especificación en el momento de " +"emparejar las llamadas al objeto simulado. Esto le permite hacer coincidir " +"sus argumentos con los argumentos de la llamada real, independientemente de " +"si se pasaron por posición o por nombre:" #: ../Doc/library/unittest.mock.rst:807 msgid "" @@ -637,10 +929,16 @@ msgid "" "assert_any_call`. When :ref:`auto-speccing`, it will also apply to method " "calls on the mock object." msgstr "" +"Esto se aplica a :meth:`~Mock.assert_called_with`, :meth:`~Mock." +"assert_called_once_with`, :meth:`~Mock.assert_has_calls` y :meth:`~Mock." +"assert_any_call`. Cuando se hace uso de :ref:`auto-speccing`, también se " +"aplicará a las llamadas a los métodos del objeto simulado." #: ../Doc/library/unittest.mock.rst:812 msgid "Added signature introspection on specced and autospecced mock objects." msgstr "" +"Se añadió introspección de firma en objetos simulados especificados y " +"autoespecificados." #: ../Doc/library/unittest.mock.rst:818 msgid "" @@ -648,12 +946,19 @@ msgid "" "class:`PropertyMock` provides :meth:`__get__` and :meth:`__set__` methods so " "you can specify a return value when it is fetched." msgstr "" +"Un objeto simulado destinado a ser utilizado en una clase como una " +"propiedad, u otro descriptor. La clase :class:`PropertyMock` proporciona los " +"métodos :meth:`__get__` y :meth:`__set__`, por lo que puedes especificar un " +"valor de retorno para cuando su valor es requerido." #: ../Doc/library/unittest.mock.rst:822 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 "" +"La obtención de una instancia :class:`PropertyMock` desde un objeto ocasiona " +"una llamada al objeto simulado, sin argumentos. Establecer su valor también " +"llama al objeto simulado, con el valor a establecer como argumento." #: ../Doc/library/unittest.mock.rst:843 msgid "" @@ -661,6 +966,9 @@ msgid "" "class:`PropertyMock` to a mock object. Instead you can attach it to the mock " "type object::" msgstr "" +"Debido a la forma en que se almacenan los atributos simulados, no es posible " +"conectar directamente un :class:`PropertyMock` a un objeto simulado. En su " +"lugar se puede conectar al tipo (type) del objeto simulado:" #: ../Doc/library/unittest.mock.rst:857 msgid "" @@ -668,24 +976,34 @@ msgid "" "behave so the object is recognized as an async function, and the result of a " "call is an awaitable." msgstr "" +"Una versión asíncrona de :class:`Mock`. El objeto :class:`AsyncMock` se " +"comportará de tal modo que el objeto es reconocido como una función " +"asíncrona y el resultado de su llamada es un objeto aguardable (awaitable)." #: ../Doc/library/unittest.mock.rst:867 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 "" +"El resultado de ``mock()`` es una función asíncrona que proporcionará el " +"resultado de ``side_effect`` o de ``return_value`` después de haber sido " +"aguardada:" #: ../Doc/library/unittest.mock.rst:870 msgid "" "if ``side_effect`` is a function, the async function will return the result " "of that function," msgstr "" +"si ``side_effect`` es una función, la función asíncrona retornará el " +"resultado de esa función," #: ../Doc/library/unittest.mock.rst:872 msgid "" "if ``side_effect`` is an exception, the async function will raise the " "exception," msgstr "" +"si ``side_effect`` es una excepción, la función asíncrona lanzará la " +"excepción," #: ../Doc/library/unittest.mock.rst:874 msgid "" @@ -693,6 +1011,9 @@ msgid "" "value of the iterable, however, if the sequence of result is exhausted, " "``StopAsyncIteration`` is raised immediately," msgstr "" +"si ``side_effect`` es un iterable, la función asíncrona retornará el " +"siguiente valor del iterable, sin embargo, si se agota la secuencia de " +"resultados, se lanza una excepción ``StopAsyncIteration`` inmediatamente," #: ../Doc/library/unittest.mock.rst:877 msgid "" @@ -700,12 +1021,18 @@ msgid "" "defined by ``return_value``, hence, by default, the async function returns a " "new :class:`AsyncMock` object." msgstr "" +"si ``side_effect`` no está definido, la función asíncrona retornará el valor " +"definido por ``return_value``, por lo tanto, la función asíncrona retorna un " +"nuevo objeto :class:`AsyncMock` por defecto." #: ../Doc/library/unittest.mock.rst:882 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 "" +"Establecer el argumento *spec* de un objeto :class:`Mock` o :class:" +"`MagicMock` en una función asíncrona resultará en que un objeto corrutina " +"será retornado después de la llamada al objeto." #: ../Doc/library/unittest.mock.rst:894 msgid "" @@ -716,63 +1043,89 @@ msgid "" "or :class:`Mock` (if the parent mock is :class:`Mock`). All asynchronous " "functions will be :class:`AsyncMock`." msgstr "" +"Establecer el argumento *spec* de un objeto :class:`Mock`, :class:" +"`MagicMock` o :class:`AsyncMock` en una clase que tiene simultáneamente " +"funciones asíncronas y síncronas hará que se detecten automáticamente las " +"funciones sincrónicas y las establecerá como :class:`MagicMock` (si el " +"objeto simulado padre es :class:`AsyncMock` o :class:`MagicMock`) o :class:" +"`Mock` (si el objeto simulado padre es :class:`Mock`) . Todas las funciones " +"asíncronas serán :class:`AsyncMock`." #: ../Doc/library/unittest.mock.rst:922 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 "" +"Aserta si el objeto simulado fue aguardado al menos una vez. Ten en cuenta " +"que, independientemente del objeto que ha sido invocado, la palabra clave " +"``await`` debe ser utilizada:" #: ../Doc/library/unittest.mock.rst:941 msgid "Assert that the mock was awaited exactly once." -msgstr "" +msgstr "Aserta si el objeto simulado fue aguardado exactamente una vez." #: ../Doc/library/unittest.mock.rst:957 msgid "Assert that the last await was with the specified arguments." msgstr "" +"Aserta si el último aguardo (await) fue con los argumentos especificados." #: ../Doc/library/unittest.mock.rst:974 msgid "" "Assert that the mock was awaited exactly once and with the specified " "arguments." msgstr "" +"Aserta si que el objeto simulado se ha aguardado exactamente una vez y con " +"los argumentos especificados." #: ../Doc/library/unittest.mock.rst:991 msgid "Assert the mock has ever been awaited with the specified arguments." msgstr "" +"Aserta si el objeto simulado nunca se ha aguardado con los argumentos " +"especificados." #: ../Doc/library/unittest.mock.rst:1007 msgid "" "Assert the mock has been awaited with the specified calls. The :attr:" "`await_args_list` list is checked for the awaits." msgstr "" +"Aserta si el objeto simulado ha sido aguardado con las llamadas " +"especificadas. Para comprobar los aguardos (awaits) se utiliza la lista :" +"attr:`await_args_list`." #: ../Doc/library/unittest.mock.rst:1010 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* es falso, los aguardos (awaits) deben ser secuenciales. No " +"puede haber llamadas adicionales antes o después de los aguardos " +"especificados." #: ../Doc/library/unittest.mock.rst:1014 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* es verdadero, entonces los aguardos (awaits) pueden estar en " +"cualquier orden, pero deben aparecer todos en :attr:`await_args_list`." #: ../Doc/library/unittest.mock.rst:1034 msgid "Assert that the mock was never awaited." -msgstr "" +msgstr "Aserta si el objeto simulado nunca ha sido aguardado." #: ../Doc/library/unittest.mock.rst:1041 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 "" +"Consultar :func:`Mock.reset_mock`. Además, también establece :attr:" +"`await_count` a 0, :attr:`await_args` a None y borra :attr:`await_args_list`." #: ../Doc/library/unittest.mock.rst:1046 msgid "" "An integer keeping track of how many times the mock object has been awaited." msgstr "" +"Un registro entero de cuántas veces se ha aguardado el objeto simulado." #: ../Doc/library/unittest.mock.rst:1061 msgid "" @@ -780,6 +1133,9 @@ msgid "" "that the mock was last awaited with. Functions the same as :attr:`Mock." "call_args`." msgstr "" +"Este atributo es ``None`` (si el objeto simulado no se ha aguardado) o los " +"argumentos con los que fue aguardado la última vez. Su funcionamiento es " +"idéntico al de :attr:`Mock.call_args`." #: ../Doc/library/unittest.mock.rst:1079 msgid "" @@ -787,10 +1143,14 @@ msgid "" "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 "" +"Es una lista de todas los aguardos (awaits) realizados en el objeto simulado " +"de forma secuencial (por lo que la longitud de la lista es el número de " +"veces que se ha aguardado el objeto). Si no se han realizado aguardos " +"previos, es una lista vacía." #: ../Doc/library/unittest.mock.rst:1098 msgid "Calling" -msgstr "" +msgstr "Llamar a los objetos simulados" #: ../Doc/library/unittest.mock.rst:1100 msgid "" @@ -800,12 +1160,20 @@ msgid "" "explicitly or by calling the Mock) - but it is stored and the same one " "returned each time." msgstr "" +"Los objetos Mock son invocables. La llamada a uno retornará el valor " +"establecido en el atributo :attr:`~Mock.return_value`. El valor de retorno " +"por defecto es un nuevo objeto Mock, el cual se crea la primera vez que se " +"accede al valor de retorno (ya sea explícitamente o llamando al objeto " +"Mock). Una vez creado, se almacena y el mismo objeto es retornado cada vez " +"que se solicita." #: ../Doc/library/unittest.mock.rst:1106 msgid "" "Calls made to the object will be recorded in the attributes like :attr:" "`~Mock.call_args` and :attr:`~Mock.call_args_list`." msgstr "" +"Las llamadas realizadas al objeto serán registradas en los atributos :attr:" +"`~Mock.call_args` y :attr:`~Mock.call_args_list`." #: ../Doc/library/unittest.mock.rst:1109 msgid "" @@ -813,12 +1181,18 @@ msgid "" "has been recorded, so if :attr:`side_effect` raises an exception the call is " "still recorded." msgstr "" +"Si :attr:`~Mock.side_effect` se establece, será invocado después de que la " +"llamada haya sido registrada, por lo que la llamada se registra aunque :attr:" +"`side_effect` lance una excepción." #: ../Doc/library/unittest.mock.rst:1113 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 "" +"La forma más sencilla de hacer que un objeto simulado lance de una excepción " +"cuando sea invocado es establecer su atributo :attr:`~Mock.side_effect` como " +"una clase o instancia de excepción:" #: ../Doc/library/unittest.mock.rst:1131 msgid "" @@ -827,6 +1201,11 @@ msgid "" "with the same arguments as the mock. This allows you to vary the return " "value of the call dynamically, based on the input:" msgstr "" +"Si :attr:`side_effect` es una función, la llamada al objeto simulado " +"retornará lo que sea que esta función retorne. La función establecida en :" +"attr:`side_effect` se llama con los mismos argumentos con los que el objeto " +"simulado ha sido invocado. Esto te permite variar el valor de retorno de la " +"llamada dinámicamente, en función de la entrada:" #: ../Doc/library/unittest.mock.rst:1147 msgid "" @@ -835,12 +1214,18 @@ msgid "" "return :attr:`mock.return_value` from inside :attr:`side_effect`, or return :" "data:`DEFAULT`:" msgstr "" +"Si se desea que el objeto simulado aún retorne el valor por defecto (un " +"nuevo objeto simulado), o cualquier valor de retorno establecido, entonces " +"existen dos maneras de proceder. Se puede retornar tanto el atributo :attr:" +"`mock.return_value` como :data:`DEFAULT` desde :attr:`side_effect`:" #: ../Doc/library/unittest.mock.rst:1166 msgid "" "To remove a :attr:`side_effect`, and return to the default behaviour, set " "the :attr:`side_effect` to ``None``:" msgstr "" +"Para eliminar un :attr:`side_effect`, volviendo al comportamiento " +"predeterminado, establece el atributo :attr:`side_effect` en ``None``:" #: ../Doc/library/unittest.mock.rst:1180 msgid "" @@ -848,22 +1233,30 @@ msgid "" "the mock will return values from the iterable (until the iterable is " "exhausted and a :exc:`StopIteration` is raised):" msgstr "" +"El atributo :attr:`side_effect` también puede ser cualquier objeto iterable. " +"En este caso, las llamadas repetidas al objeto simulado irán retornando " +"valores del iterable (hasta que el iterable se agote, momento en el que se " +"lanza una excepción :exc:`StopIteration`):" #: ../Doc/library/unittest.mock.rst:1196 msgid "" "If any members of the iterable are exceptions they will be raised instead of " "returned::" msgstr "" +"Si cualquier miembro del iterable es una excepción, se lanzará en lugar de " +"retornarse:" #: ../Doc/library/unittest.mock.rst:1214 msgid "Deleting Attributes" -msgstr "" +msgstr "Eliminar atributos" #: ../Doc/library/unittest.mock.rst:1216 msgid "" "Mock objects create attributes on demand. This allows them to pretend to be " "objects of any type." msgstr "" +"Los objetos simulados crean atributos en demanda. Esto les permite hacerse " +"pasar por objetos de cualquier tipo." #: ../Doc/library/unittest.mock.rst:1219 msgid "" @@ -872,16 +1265,23 @@ msgid "" "by providing an object as a :attr:`spec` for a mock, but that isn't always " "convenient." msgstr "" +"Es posible que desees que un objeto simulado retorne ``False`` al llamar a :" +"func:`hasattr`, o que lance una excepción :exc:`AttributeError` cuando se " +"intenta obtener un atributo. Puedes hacer todo esto proporcionando un objeto " +"adecuado al atributo :attr:`spec` del objeto simulado, pero no siempre es " +"conveniente." #: ../Doc/library/unittest.mock.rst:1223 msgid "" "You \"block\" attributes by deleting them. Once deleted, accessing an " "attribute will raise an :exc:`AttributeError`." msgstr "" +"Puedes \"bloquear\" atributos eliminándolos. Una vez eliminado, el acceso a " +"un atributo lanzará una excepción :exc:`AttributeError`." #: ../Doc/library/unittest.mock.rst:1240 msgid "Mock names and the name attribute" -msgstr "" +msgstr "Los nombres de los objetos simulados y el atributo *name*" #: ../Doc/library/unittest.mock.rst:1242 msgid "" @@ -890,16 +1290,22 @@ msgid "" "creation time. There are two alternatives. One option is to use :meth:`~Mock." "configure_mock`::" msgstr "" +"Dado que \"name\" es un argumento para el constructor de la clase :class:" +"`Mock`, si quieres que tu objeto simulado tenga un atributo \"name\", no " +"puedes simplemente pasarlo al constructor en tiempo de creación. Hay dos " +"alternativas. Una opción es usar el método :meth:`~Mock.configure_mock`:" #: ../Doc/library/unittest.mock.rst:1252 msgid "" "A simpler option is to simply set the \"name\" attribute after mock " "creation::" msgstr "" +"Una opción más sencilla es simplemente establecer el atributo \"name\" " +"después de la creación del objeto simulado:" #: ../Doc/library/unittest.mock.rst:1259 msgid "Attaching Mocks as Attributes" -msgstr "" +msgstr "Adjuntar objetos simulados como atributos" #: ../Doc/library/unittest.mock.rst:1261 msgid "" @@ -911,12 +1317,23 @@ msgid "" "calls to the children and allows you to make assertions about the order of " "calls between mocks:" msgstr "" +"Cuando se adjunta un objeto simulado como un atributo de otro objeto " +"simulado (o como su valor de retorno) se convierte en un \"hijo\" del mismo. " +"Las llamadas a los hijos se registran en los atributos :attr:`~Mock." +"method_calls` y :attr:`~Mock.mock_calls` del padre. Esto es útil para " +"configurar objetos simulados hijos para después adjuntarlos al padre, o para " +"adjuntar objetos simulados a un padre que se encargará de registrar todas " +"las llamadas a los hijos, permitiéndote hacer aserciones sobre el orden de " +"las llamadas entre objetos simulados:" #: ../Doc/library/unittest.mock.rst:1279 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 "" +"La excepción a lo anterior es si el objeto simulado tiene un nombre. Esto te " +"permite evitar el comportamiento de \"parentesco\" explicado previamente, si " +"por alguna razón no deseas que suceda." #: ../Doc/library/unittest.mock.rst:1290 msgid "" @@ -924,6 +1341,9 @@ msgid "" "attach mocks that have names to a parent you use the :meth:`~Mock." "attach_mock` method::" msgstr "" +"Los objetos simulados creados automáticamente por la función :func:`patch` " +"también reciben nombres automáticamente. Para adjuntar un objeto simulado " +"con nombre a un padre debes utilizar el método :meth:`~Mock.attach_mock`:" #: ../Doc/library/unittest.mock.rst:1308 msgid "" @@ -934,10 +1354,17 @@ msgid "" "a new Mock object when it expects a magic method. If you need magic method " "support see :ref:`magic methods `." msgstr "" +"Las únicas excepciones son los métodos y atributos mágicos (aquellos que " +"tienen doble subrayado al principio y al final). Mock no los crea " +"automáticamente, sino que lanza una excepción :exc:`AttributeError`. Esto se " +"debe a que el intérprete a menudo solicitará implícitamente estos métodos y " +"terminaría *muy* confundido si obtiene un nuevo objeto Mock cuando espera un " +"método mágico. Si necesitas soporte para métodos mágicos, consulta :ref:" +"`métodos mágicos `." #: ../Doc/library/unittest.mock.rst:1317 msgid "The patchers" -msgstr "" +msgstr "Parcheadores" #: ../Doc/library/unittest.mock.rst:1319 msgid "" @@ -946,16 +1373,24 @@ msgid "" "you, even if exceptions are raised. All of these functions can also be used " "in with statements or as class decorators." msgstr "" +"Los decoradores patch se utilizan para parchear los objetos sólo dentro del " +"ámbito de la función que decoran. Se encargan automáticamente de desparchear " +"una vez terminada la prueba, incluso si se lanzan excepciones. Todas estas " +"funciones también se pueden utilizar con declaraciones o como decoradores de " +"clase." #: ../Doc/library/unittest.mock.rst:1326 msgid "patch" -msgstr "" +msgstr "patch" #: ../Doc/library/unittest.mock.rst:1330 msgid "" ":func:`patch` is straightforward to use. The key is to do the patching in " "the right namespace. See the section `where to patch`_." msgstr "" +"La función :func:`patch` es sencilla de usar. La clave es realizar la " +"aplicación de parches en el espacio de nombres correcto. Consulta la sección " +"`where to patch`_ para más detalles." #: ../Doc/library/unittest.mock.rst:1335 msgid "" @@ -964,6 +1399,11 @@ msgid "" "patched with a *new* object. When the function/with statement exits the " "patch is undone." msgstr "" +":func:`patch` actúa como decorador de función, decorador de clase o como " +"gestor de contexto. Ya sea en el interior del cuerpo de una función o dentro " +"de una declaración with, *target* es parcheado con un objeto *new*. Cuando " +"la función / declaración with termina su ejecución el parche se deshace " +"automáticamente." #: ../Doc/library/unittest.mock.rst:1340 msgid "" @@ -974,6 +1414,13 @@ msgid "" "If :func:`patch` is used as a context manager the created mock is returned " "by the context manager." msgstr "" +"Si se omite *new*, entonces el objetivo se reemplaza por un objeto :class:" +"`AsyncMock` si el objeto parcheado es una función asíncrona, o con un " +"objeto :class:`MagicMock` en caso contrario. Si se utiliza :func:`patch` " +"como decorador y se omite *new*, el objeto simulado creado se pasa como un " +"argumento adicional a la función decorada. Si se utiliza :func:`patch` como " +"un gestor de contexto, el objeto simulado creado es retornado por el gestor " +"de contexto." #: ../Doc/library/unittest.mock.rst:1348 msgid "" @@ -983,18 +1430,28 @@ msgid "" "calling :func:`patch` from. The target is imported when the decorated " "function is executed, not at decoration time." msgstr "" +"*target* debe ser una cadena de la forma ``'paquete.modulo." +"NombreDeLaClase'``. *target* es importado y el objeto especificado " +"reemplazado por el objeto *new*, por lo que *target* debe ser importable " +"desde el entorno desde el cual estás llamando a :func:`patch`. Hay que tener " +"presente que *target* es importado cuando se ejecuta la función decorada, no " +"en tiempo de decoración." #: ../Doc/library/unittest.mock.rst:1354 msgid "" "The *spec* and *spec_set* keyword arguments are passed to the :class:" "`MagicMock` if patch is creating one for you." msgstr "" +"Los argumentos *spec* y *spec_set* se pasan a :class:`MagicMock` si patch " +"está creando automáticamente uno para ti." #: ../Doc/library/unittest.mock.rst:1357 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 "" +"Además, puedes pasar ``spec=True`` o ``spec_set=True``, lo que causa que " +"patch pase el objeto que está siendo simulado como el objeto spec/spec_set." #: ../Doc/library/unittest.mock.rst:1360 msgid "" @@ -1002,6 +1459,10 @@ msgid "" "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 "" +"*new_callable* te permite especificar una clase diferente, o un objeto " +"invocable, que será invocada para crear el objeto *new*. Por defecto se " +"utiliza :class:`AsyncMock` para las funciones asíncronas y :class:" +"`MagicMock` para el resto." #: ../Doc/library/unittest.mock.rst:1364 msgid "" @@ -1014,12 +1475,25 @@ msgid "" "return value (the 'instance') will have the same spec as the class. See the :" "func:`create_autospec` function and :ref:`auto-speccing`." msgstr "" +"Una variante más poderosa de *spec* es *autospec*. Si estableces " +"``autospec=True`` el objeto simulado se creará con una especificación del " +"objeto que está siendo reemplazado. Todos los atributos del objeto simulado " +"también tendrán la especificación del atributo correspondiente del objeto " +"que está siendo reemplazado. Los argumentos de los métodos y funciones " +"simulados son comprobados y se lanzará una excepción :exc:`TypeError` si se " +"les llama con la firma incorrecta. Para los objetos simulados que sustituyen " +"a una clase, su valor de retorno (la 'instancia') tendrá la misma " +"especificación que la clase. Consultar la función :func:`create_autospec` y :" +"ref:`auto-speccing` para más detalles." #: ../Doc/library/unittest.mock.rst:1374 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 "" +"En lugar de ``autospec=True``, puedes pasar ``autospec=some_object`` para " +"utilizar un objeto arbitrario como especificación en lugar del objeto " +"reemplazado." #: ../Doc/library/unittest.mock.rst:1377 msgid "" @@ -1031,12 +1505,22 @@ msgid "" "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 "" +"Por defecto, :func:`patch` fallará al intentar reemplazar atributos que no " +"existen. Si pasas ``create=True`` y no existe el atributo, patch crea el " +"atributo cuando la función se llama y lo elimina de nuevo en cuanto termina " +"de ejecutarse . Esto es útil para implementar pruebas para atributos que tu " +"código de producción crea en tiempo de ejecución. Está desactivado por " +"defecto, ya que puede ser peligroso. ¡Al activarlo se pueden implementar " +"pruebas que validen APIs que en realidad no existen!" #: ../Doc/library/unittest.mock.rst:1387 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 "" +"Si estás parcheando objetos incorporados (builtins) en un módulo, no es " +"necesario pasar ``create=True``, ya que en este caso se agrega de forma " +"predeterminada." #: ../Doc/library/unittest.mock.rst:1391 msgid "" @@ -1048,6 +1532,14 @@ msgid "" "tests. You can specify an alternative prefix by setting ``patch." "TEST_PREFIX``." msgstr "" +"Patch puede ser usado como un decorador de la clase :class:`TestCase`. " +"Funciona decorando cada uno de los métodos de prueba presentes en la clase. " +"Esto reduce el código repetitivo cuando tus métodos de prueba comparten un " +"conjunto de parcheo común. :func:`patch` encuentra las pruebas mediante la " +"búsqueda de métodos cuyos nombres comienzan con ``patch.TEST_PREFIX``. Por " +"defecto es ``'test'``, que coincide con la forma en que :mod:`unittest` " +"busca las pruebas. Se puede especificar un prefijo alternativo estableciendo " +"un nuevo valor para el atributo ``patch.TEST_PREFIX``." #: ../Doc/library/unittest.mock.rst:1398 msgid "" @@ -1056,24 +1548,35 @@ msgid "" "\"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 "" +"Patch puede ser usado como un gestor de contexto, con la declaración with. " +"En este caso el parcheo se aplica al bloque sangrado inmediatamente después " +"de la declaración with. Si utilizas \"as\", el objeto parcheado será " +"enlazado al nombre especificado después de \"as\"; muy útil si :func:`patch` " +"está creando un objeto simulado automáticamente." #: ../Doc/library/unittest.mock.rst:1403 msgid "" ":func:`patch` takes arbitrary keyword arguments. These will be passed to " "the :class:`Mock` (or *new_callable*) on construction." msgstr "" +":func:`patch` toma argumentos por palabra clave arbitrarios. Estos serán " +"pasados ​​a :class:`Mock` (o a *new_callable*) durante la construcción." #: ../Doc/library/unittest.mock.rst:1406 msgid "" "``patch.dict(...)``, ``patch.multiple(...)`` and ``patch.object(...)`` are " "available for alternate use-cases." msgstr "" +"``patch.dict(...)``, ``patch.multiple(...)`` y ``patch.object(...)`` están " +"disponibles para casos de uso alternativos." #: ../Doc/library/unittest.mock.rst:1409 msgid "" ":func:`patch` as function decorator, creating the mock for you and passing " "it into the decorated function::" msgstr "" +":func:`patch` como decorador de función, crea el objeto simulado por ti y lo " +"pasa a la función decorada:" #: ../Doc/library/unittest.mock.rst:1419 msgid "" @@ -1081,6 +1584,9 @@ msgid "" "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 "" +"Parchear una clase sustituye a la clase por una *instancia* de :class:" +"`MagicMock`. Si la clase se instancia en el código bajo prueba, el atributo :" +"attr:`~Mock.return_value` del objeto simulado será el utilizado." #: ../Doc/library/unittest.mock.rst:1423 msgid "" @@ -1088,18 +1594,27 @@ msgid "" "side_effect` to return a new mock each time. Alternatively you can set the " "*return_value* to be anything you want." msgstr "" +"Si la clase se instancia en múltiples ocasiones, puedes utilizar el " +"atributo :attr:`~Mock.side_effect` para retornar un nuevo objeto simulado " +"cada vez. O también puedes establecer *return_value* para que sea lo que tu " +"quieras." #: ../Doc/library/unittest.mock.rst:1427 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 "" +"Para configurar valores de retorno de métodos en *instancias* de la clase " +"parcheada debes hacer uso del atributo :attr:`return_value`. Por ejemplo:" #: ../Doc/library/unittest.mock.rst:1441 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 "" +"Si utilizas *spec* o *spec_set* y :func:`patch` está reemplazando una " +"*clase*, el valor de retorno del objeto simulado creado tendrá las mismas " +"especificaciones:" #: ../Doc/library/unittest.mock.rst:1451 msgid "" @@ -1107,12 +1622,18 @@ msgid "" "class to the default :class:`MagicMock` for the created mock. For example, " "if you wanted a :class:`NonCallableMock` to be used::" msgstr "" +"El argumento *new_callable* es útil cuando deseas utilizar una clase por " +"defecto alternativa a :class:`MagicMock` para el objeto simulado creado. Por " +"ejemplo, si quieres que se use una clase :class:`NonCallableMock` por " +"defecto:" #: ../Doc/library/unittest.mock.rst:1464 msgid "" "Another use case might be to replace an object with an :class:`io.StringIO` " "instance::" msgstr "" +"Otro caso de uso podría ser la sustitución de un objeto por una instancia " +"de :class:`io.StringIO`:" #: ../Doc/library/unittest.mock.rst:1477 msgid "" @@ -1121,6 +1642,11 @@ msgid "" "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 "" +"Cuando :func:`patch` crea un objeto simulado para ti, a menudo lo primero " +"que tienes que hacer es configurar el objeto simulado recién creado. Parte " +"de la configuración se puede hacer en la propia llamada a patch. Cualquier " +"palabra clave arbitraria que pases a la llamada será utilizada para " +"establecer los atributos del objeto simulado creado:" #: ../Doc/library/unittest.mock.rst:1489 msgid "" @@ -1130,6 +1656,13 @@ msgid "" "arguments, but a dictionary with these as keys can still be expanded into a :" "func:`patch` call using ``**``::" msgstr "" +"Los atributos de los objetos simulados hijos, como :attr:`~Mock." +"return_value` y :attr:`~Mock.side_effect`, también puede ser configurados en " +"la llamada, dado que los objetos simulados hijos son atributos en si mismos " +"del objeto simulado padre creado. Eso si, estos no son sintácticamente " +"válidos para ser pasados directamente como argumentos por palabras clave a " +"la función patch, pero un diccionario con ellos como claves si que puede ser " +"expandido en una llama a :func:`patch` usando ``**``:" #: ../Doc/library/unittest.mock.rst:1505 msgid "" @@ -1137,28 +1670,37 @@ msgid "" "attribute in a class) that does not exist will fail with :exc:" "`AttributeError`::" msgstr "" +"Por defecto, el intento de parchear una función en un módulo (o un método o " +"atributo en una clase) que no existe fallará lanzando una excepción :exc:" +"`AttributeError`:" #: ../Doc/library/unittest.mock.rst:1517 msgid "" "but adding ``create=True`` in the call to :func:`patch` will make the " "previous example work as expected::" msgstr "" +"pero añadir ``create=True`` en la llamada a :func:`patch` hará que el " +"ejemplo previo funcione como se esperaba:" #: ../Doc/library/unittest.mock.rst:1528 msgid "" ":func:`patch` now returns an :class:`AsyncMock` if the target is an async " "function." msgstr "" +":func:`patch` ahora retorna una instancia de :class:`AsyncMock` si el " +"objetivo es una función asíncrona." #: ../Doc/library/unittest.mock.rst:1532 msgid "patch.object" -msgstr "" +msgstr "patch.object" #: ../Doc/library/unittest.mock.rst:1536 msgid "" "patch the named member (*attribute*) on an object (*target*) with a mock " "object." msgstr "" +"parchea el miembro *attribute* invocado de un objeto *target* con un objeto " +"simulado." #: ../Doc/library/unittest.mock.rst:1539 msgid "" @@ -1168,12 +1710,20 @@ msgid "" "`patch`, :func:`patch.object` takes arbitrary keyword arguments for " "configuring the mock object it creates." msgstr "" +":func:`patch.object` se puede utilizar como un decorador, decorador de clase " +"o un gestor de contexto. Los argumentos *new*, *spec*, *create*, *spec_set*, " +"*autospec* y *new_callable* tienen el mismo significado que en la función :" +"func:`patch`. Al igual que :func:`patch`, :func:`patch.object` toma " +"argumentos por palabras clave arbitrarios para la configuración del objeto " +"simulado que crea." #: ../Doc/library/unittest.mock.rst:1545 msgid "" "When used as a class decorator :func:`patch.object` honours ``patch." "TEST_PREFIX`` for choosing which methods to wrap." msgstr "" +"Cuando se utiliza como un decorador de clase :func:`patch.object` se rige " +"por ``patch.TEST_PREFIX`` a la hora de elegir los métodos a envolver." #: ../Doc/library/unittest.mock.rst:1548 msgid "" @@ -1181,6 +1731,9 @@ msgid "" "arguments. The three argument form takes the object to be patched, the " "attribute name and the object to replace the attribute with." msgstr "" +"Puedes llamar a :func:`patch.object` con tres argumentos o con dos " +"argumentos. La forma de tres argumento toma el objeto a parchear, el nombre " +"del atributo y el objeto con el que reemplazar el atributo." #: ../Doc/library/unittest.mock.rst:1552 msgid "" @@ -1188,22 +1741,29 @@ msgid "" "a mock is created for you and passed in as an extra argument to the " "decorated function:" msgstr "" +"Al llamar usando la variante de dos argumento se omite el objeto de " +"sustitución, por lo tanto se crea un objeto simulado automáticamente y se " +"pasa como argumento adicional a la función decorada:" #: ../Doc/library/unittest.mock.rst:1563 msgid "" "*spec*, *create* and the other arguments to :func:`patch.object` have the " "same meaning as they do for :func:`patch`." msgstr "" +"*spec*, *create* y el resto de argumentos de :func:`patch.object` tienen el " +"mismo significado que en la función :func:`patch`." #: ../Doc/library/unittest.mock.rst:1568 msgid "patch.dict" -msgstr "" +msgstr "patch.dict" #: ../Doc/library/unittest.mock.rst:1572 msgid "" "Patch a dictionary, or dictionary like object, and restore the dictionary to " "its original state after the test." msgstr "" +"Parchea un diccionario o un objeto similar a un diccionario y posteriormente " +"lo restaura a su estado original una vez terminada la prueba." #: ../Doc/library/unittest.mock.rst:1575 msgid "" @@ -1211,48 +1771,69 @@ msgid "" "mapping then it must at least support getting, setting and deleting items " "plus iterating over keys." msgstr "" +"*in_dict* puede ser un diccionario o un contenedor similar a uno. Si se " +"trata de un objeto similar a un diccionario, debe soportar como mínimo el " +"establecimiento, la obtención y la eliminación de elementos, además de " +"permitir la iteración sobre las claves." #: ../Doc/library/unittest.mock.rst:1579 msgid "" "*in_dict* can also be a string specifying the name of the dictionary, which " "will then be fetched by importing it." msgstr "" +"*in_dict* también puede ser una cadena que especifique el nombre del " +"diccionario a parchear, el nombre es usado para obtener el diccionario " +"mediante importación." #: ../Doc/library/unittest.mock.rst:1582 msgid "" "*values* can be a dictionary of values to set in the dictionary. *values* " "can also be an iterable of ``(key, value)`` pairs." msgstr "" +"*values* puede ser otro diccionario con valores para ser añadidos al " +"diccionario. *values* también puede ser un iterable de parejas ``(clave, " +"valor)``." #: ../Doc/library/unittest.mock.rst:1585 msgid "" "If *clear* is true then the dictionary will be cleared before the new values " "are set." msgstr "" +"Si *clear* es verdadero, el contenido del diccionario se borrará antes de " +"establecer los nuevos valores." #: ../Doc/library/unittest.mock.rst:1588 msgid "" ":func:`patch.dict` can also be called with arbitrary keyword arguments to " "set values in the dictionary." msgstr "" +"La función :func:`patch.dict` también puede ser invocada con argumentos por " +"palabra clave arbitrarios para establecer los valores en el diccionario." #: ../Doc/library/unittest.mock.rst:1593 msgid "" ":func:`patch.dict` now returns the patched dictionary when used as a context " "manager." msgstr "" +"La función :func:`patch.dict` ahora retorna el diccionario parcheado cuando " +"se utiliza como gestor de contexto." #: ../Doc/library/unittest.mock.rst:1596 msgid "" ":func:`patch.dict` can be used as a context manager, decorator or class " "decorator:" msgstr "" +":func:`patch.dict` se puede utilizar como gestor de contexto, decorador o " +"decorador de clase:" #: ../Doc/library/unittest.mock.rst:1606 msgid "" "When used as a class decorator :func:`patch.dict` honours ``patch." "TEST_PREFIX`` (default to ``'test'``) for choosing which methods to wrap:" msgstr "" +"Cuando se utiliza :func:`patch.dict` como decorador de clase, se rige por " +"``patch.TEST_PREFIX`` (por defecto ``'test'``) a la hora de elegir qué " +"métodos envolver:" #: ../Doc/library/unittest.mock.rst:1617 msgid "" @@ -1260,6 +1841,10 @@ msgid "" "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 "" +"Si deseas utilizar un prefijo diferente para tu prueba, puede informar a los " +"parcheadores del nuevo prefijo a usar estableciendo ``patch.TEST_PREFIX``. " +"Para más detalles sobre cómo cambiar el valor del atributo consultar :ref:" +"`test-prefix`." #: ../Doc/library/unittest.mock.rst:1621 msgid "" @@ -1267,12 +1852,17 @@ msgid "" "a test change a dictionary, and ensure the dictionary is restored when the " "test ends." msgstr "" +":func:`patch.dict` puede utilizarse para agregar miembros a un diccionario, " +"o simplemente para dejar que una prueba modifique un diccionario y " +"asegurarte de que el diccionario será restablecido cuando finalice la misma." #: ../Doc/library/unittest.mock.rst:1642 msgid "" "Keywords can be used in the :func:`patch.dict` call to set values in the " "dictionary:" msgstr "" +"Se pueden utilizar argumentos por palabra clave en la llamada a :func:`patch." +"dict` para establecer valores en el diccionario:" #: ../Doc/library/unittest.mock.rst:1652 msgid "" @@ -1282,10 +1872,16 @@ msgid "" "to the magic methods :meth:`__getitem__`, :meth:`__setitem__`, :meth:" "`__delitem__` and either :meth:`__iter__` or :meth:`__contains__`." msgstr "" +":func:`patch.dict` se puede utilizar con objetos similares a un diccionario, " +"que no son realmente diccionarios. Estos objetos como mínimo deben permitir " +"obtener, establecer y borrar elementos, además de soportar la iteración o la " +"prueba de pertenencia. Dichas funcionalidades se corresponden a los métodos " +"mágicos :meth:`__getitem__`, :meth:`__setitem__`, :meth:`__delitem__` e :" +"meth:`__iter__` o :meth:`__contains__`." #: ../Doc/library/unittest.mock.rst:1681 msgid "patch.multiple" -msgstr "" +msgstr "patch.multiple" #: ../Doc/library/unittest.mock.rst:1685 msgid "" @@ -1293,6 +1889,10 @@ msgid "" "(either as an object or a string to fetch the object by importing) and " "keyword arguments for the patches::" msgstr "" +"Realiza múltiples parches en una sola llamada. Se toma el objeto a ser " +"parcheado (ya sea como un objeto o una cadena de caracteres con el nombre " +"del mismo para obtener el objeto mediante importación) y los argumentos por " +"palabras clave para los parches:" #: ../Doc/library/unittest.mock.rst:1692 msgid "" @@ -1301,6 +1901,11 @@ msgid "" "decorated function by keyword, and a dictionary is returned when :func:" "`patch.multiple` is used as a context manager." msgstr "" +"Usa :data:`DEFAULT` como valor si deseas que la función :func:`patch." +"multiple` cree objetos simulados automáticamente por ti. En este caso, los " +"objetos simulados creados son pasados ​​a la función decorada mediante palabra " +"clave y se retorna un diccionario cuando :func:`patch.multiple` se utiliza " +"como gestor de contexto." #: ../Doc/library/unittest.mock.rst:1697 msgid "" @@ -1309,12 +1914,19 @@ msgid "" "*new_callable* have the same meaning as for :func:`patch`. These arguments " "will be applied to *all* patches done by :func:`patch.multiple`." msgstr "" +"La función :func:`patch.multiple` se puede utilizar como un decorador, " +"decorador de clase o como gestor de contexto. La argumentos *spec*, " +"*spec_set*, *create*, *autospec* y *new_callable* tienen el mismo " +"significado que en la función :func:`patch`. Estos argumentos se aplicarán a " +"*todos* los parches realizados por :func:`patch.multiple`." #: ../Doc/library/unittest.mock.rst:1702 msgid "" "When used as a class decorator :func:`patch.multiple` honours ``patch." "TEST_PREFIX`` for choosing which methods to wrap." msgstr "" +"Cuando se utiliza como decorador de clase, :func:`patch.multiple` se rige " +"por ``patch.TEST_PREFIX`` a la hora de elegir qué métodos envolver." #: ../Doc/library/unittest.mock.rst:1705 msgid "" @@ -1323,6 +1935,10 @@ msgid "" "decorator then the created mocks are passed into the decorated function by " "keyword. ::" msgstr "" +"Si deseas que :func:`patch.multiple` cree objetos simulados automáticamente " +"por ti, puedes utilizar :data:`DEFAULT` como valor. Si utilizas :func:`patch." +"multiple` como decorador, entonces los objetos simulados creados se pasan a " +"la función decorada por palabra clave:" #: ../Doc/library/unittest.mock.rst:1719 msgid "" @@ -1330,6 +1946,9 @@ msgid "" "put arguments passed by keyword *after* any of the standard arguments " "created by :func:`patch`::" msgstr "" +":func:`patch.multiple` se puede anidar junto a otros decoradores ``patch``, " +"pero los argumentos pasados ​​por palabra clave se deben agregar *después* de " +"cualquier argumento estándar creado por :func:`patch`:" #: ../Doc/library/unittest.mock.rst:1731 msgid "" @@ -1337,10 +1956,13 @@ msgid "" "by the context manager is a dictionary where created mocks are keyed by " "name::" msgstr "" +"Si :func:`patch.multiple` se utiliza como un gestor de contexto, el valor " +"retornado por el mismo es un diccionario en el que los objetos simulados " +"creados son almacenados, usando sus nombres como claves:" #: ../Doc/library/unittest.mock.rst:1745 msgid "patch methods: start and stop" -msgstr "" +msgstr "Métodos start y stop de patch" #: ../Doc/library/unittest.mock.rst:1747 msgid "" @@ -1348,6 +1970,9 @@ msgid "" "simpler to do patching in ``setUp`` methods or where you want to do multiple " "patches without nesting decorators or with statements." msgstr "" +"Todos los parcheadores tienen los métodos :meth:`start` y :meth:`stop`. Esto " +"facilita parchear en los métodos ``setUp`` o cuando deseas hacer múltiples " +"parches sin usar decoradores anidados o declaraciones with." #: ../Doc/library/unittest.mock.rst:1751 msgid "" @@ -1356,18 +1981,26 @@ msgid "" "then call :meth:`start` to put the patch in place and :meth:`stop` to undo " "it." msgstr "" +"Para utilizar estos métodos, llama a :func:`patch`, :func:`patch.object` o :" +"func:`patch.dict` como haces normalmente y mantén una referencia al objeto " +"``patcher`` retornado. A continuación, puedes llamar al método :meth:`start` " +"para aplicar el parche y a :meth:`stop` para deshacerlo." #: ../Doc/library/unittest.mock.rst:1755 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 "" +"Si estás utilizando :func:`patch` para crear un objeto simulado " +"automáticamente, este será retornado por la llamada a ``patcher.start``:" #: ../Doc/library/unittest.mock.rst:1769 msgid "" "A typical use case for this might be for doing multiple patches in the " "``setUp`` method of a :class:`TestCase`::" msgstr "" +"Un uso típico de esto podría ser realizar múltiples parches en el método " +"``setUp`` de un :class:`TestCase`:" #: ../Doc/library/unittest.mock.rst:1791 msgid "" @@ -1376,36 +2009,49 @@ msgid "" "exception is raised in the ``setUp`` then ``tearDown`` is not called. :meth:" "`unittest.TestCase.addCleanup` makes this easier::" msgstr "" +"Si se utiliza esta técnica debes asegurarte de que el parcheo está \"sin " +"aplicar\" llamando a ``stop``. Esto puede ser más complicado de lo que " +"parece, ya que si se produce una excepción en el ``setUp`` no se llama a " +"``tearDown`` a continuación. :meth:`unittest.TestCase.addCleanup` hace que " +"esto sea más fácil:" #: ../Doc/library/unittest.mock.rst:1806 msgid "" "As an added bonus you no longer need to keep a reference to the ``patcher`` " "object." msgstr "" +"Como beneficio adicional, ya no es necesario mantener una referencia al " +"objeto ``patcher``." #: ../Doc/library/unittest.mock.rst:1809 msgid "" "It is also possible to stop all patches which have been started by using :" "func:`patch.stopall`." msgstr "" +"También es posible detener todos los parches que han sido iniciados usando :" +"func:`patch.stopall`." #: ../Doc/library/unittest.mock.rst:1814 msgid "Stop all active patches. Only stops patches started with ``start``." msgstr "" +"Detiene todos los parches activos. Sólo se detienen parches iniciados con " +"``start``." #: ../Doc/library/unittest.mock.rst:1820 msgid "patch builtins" -msgstr "" +msgstr "Parchear objetos incorporados (builtins)" #: ../Doc/library/unittest.mock.rst:1821 msgid "" "You can patch any builtins within a module. The following example patches " "builtin :func:`ord`::" msgstr "" +"Puedes parchear cualquier objeto incorporado dentro de un módulo. El " +"siguiente ejemplo parchea la función incorporada :func:`ord`:" #: ../Doc/library/unittest.mock.rst:1836 msgid "TEST_PREFIX" -msgstr "" +msgstr "TEST_PREFIX" #: ../Doc/library/unittest.mock.rst:1838 msgid "" @@ -1414,6 +2060,11 @@ msgid "" "that start with ``'test'`` as being test methods. This is the same way that " "the :class:`unittest.TestLoader` finds test methods by default." msgstr "" +"Todos los parcheadores se puede utilizar como decoradores de clase. Cuando " +"se usan de esta forma, todos los métodos a probar en la clase son envueltos. " +"Los parcheadores reconocen los métodos que comienzan con ``'test'`` como " +"métodos a probar. Esta es la misma forma que la clase :class:`unittest." +"TestLoader` usa para encontrar métodos de prueba por defecto." #: ../Doc/library/unittest.mock.rst:1843 msgid "" @@ -1421,20 +2072,24 @@ msgid "" "can inform the patchers of the different prefix by setting ``patch." "TEST_PREFIX``::" msgstr "" +"Cabe la posibilidad de que desees utilizar un prefijo diferente para las " +"pruebas. Puedes informar a los parcheadores del cambio de prefijo " +"estableciendo el atributo ``patch.TEST_PREFIX``:" #: ../Doc/library/unittest.mock.rst:1866 msgid "Nesting Patch Decorators" -msgstr "" +msgstr "Anidando decoradores patch" #: ../Doc/library/unittest.mock.rst:1868 msgid "" "If you want to perform multiple patches then you can simply stack up the " "decorators." msgstr "" +"Si deseas aplicar múltiples parches, solo tienes que apilar los decoradores." #: ../Doc/library/unittest.mock.rst:1871 msgid "You can stack up multiple patch decorators using this pattern:" -msgstr "" +msgstr "Puede apilar múltiples decoradores patch usando el siguiente patrón:" #: ../Doc/library/unittest.mock.rst:1887 msgid "" @@ -1442,10 +2097,14 @@ msgid "" "standard way that Python applies decorators. The order of the created mocks " "passed into your test function matches this order." msgstr "" +"Ten en cuenta que los decoradores se aplican desde abajo hacia arriba. Esta " +"es la manera estándar de Python para aplicar decoradores. El orden en el que " +"los objetos simulados generados se pasan a la función de prueba coincide con " +"este orden." #: ../Doc/library/unittest.mock.rst:1895 msgid "Where to patch" -msgstr "" +msgstr "Dónde parchear" #: ../Doc/library/unittest.mock.rst:1897 msgid "" @@ -1454,6 +2113,11 @@ msgid "" "individual object, so for patching to work you must ensure that you patch " "the name used by the system under test." msgstr "" +":func:`patch` funciona cambiando (temporalmente) el objeto al que apunta " +"*name* con otro. Puede haber muchos nombres apuntando a cualquier objeto " +"individual, por lo que para que el parcheo funcione, debes asegurarte de " +"parchear el nombre utilizado para el objeto por el sistema concreto bajo " +"prueba." #: ../Doc/library/unittest.mock.rst:1902 msgid "" @@ -1461,11 +2125,16 @@ msgid "" "is not necessarily the same place as where it is defined. A couple of " "examples will help to clarify this." msgstr "" +"El principio básico es parchear donde un objeto es *buscado*, que no es " +"necesariamente el mismo lugar donde está definido. Un par de ejemplos " +"ayudarán a aclarar esto." #: ../Doc/library/unittest.mock.rst:1906 msgid "" "Imagine we have a project that we want to test with the following structure::" msgstr "" +"Imaginemos que tenemos un proyecto, que queremos probar, con la siguiente " +"estructura:" #: ../Doc/library/unittest.mock.rst:1915 msgid "" @@ -1476,6 +2145,13 @@ msgid "" "module b already has a reference to the *real* ``SomeClass`` and it looks " "like our patching had no effect." msgstr "" +"Ahora queremos probar ``some_function``, pero queremos simular ``SomeClass`` " +"utilizando :func:`patch`. El problema es que cuando importamos el módulo b, " +"lo cual tenemos que hacer obligatoriamente, se importa ``SomeClass`` del " +"módulo a. Si utilizamos :func:`patch` para simular ``a.SomeClass``, no " +"tendrá ningún efecto en nuestra prueba; el módulo b ya tiene una referencia " +"a la ``SomeClass`` *real*, por lo que parece que nuestro parcheo no tuvo " +"ningún efecto." #: ../Doc/library/unittest.mock.rst:1922 msgid "" @@ -1484,6 +2160,9 @@ msgid "" "``SomeClass`` in module b, where we have imported it. The patching should " "look like::" msgstr "" +"La clave es parchear ``SomeClass`` donde se utiliza (o donde es buscado). En " +"este caso ``some_function`` realmente va a buscar ``SomeClass`` en el módulo " +"b, donde lo hemos importado. La aplicación de parches debe ser similar a:" #: ../Doc/library/unittest.mock.rst:1928 msgid "" @@ -1493,10 +2172,15 @@ msgid "" "we want to patch is being looked up in the module and so we have to patch " "``a.SomeClass`` instead::" msgstr "" +"Sin embargo, ten en cuenta el escenario alternativo donde en el módulo b en " +"lugar de ``from a import SomeClass`` se hace ``import a`` y " +"``some_function`` usa ``a.SomeClass``. Ambas formas de importación son " +"comunes. En este caso, la clase que queremos parchear está siendo buscada en " +"el módulo, por lo que tenemos que parchear ``a.SomeClass``:" #: ../Doc/library/unittest.mock.rst:1937 msgid "Patching Descriptors and Proxy Objects" -msgstr "" +msgstr "Parcheando descriptores y objetos proxy" #: ../Doc/library/unittest.mock.rst:1939 msgid "" @@ -1506,14 +2190,21 @@ msgid "" "proxy attribute access, like the `django settings object `_." msgstr "" +"Tanto patch_ como patch.object_ parchean descriptores correctamente y los " +"restauran posteriormente: métodos de clase, métodos estáticos y propiedades. " +"Los descriptores deben ser parcheados en la *clase* y no en una instancia. " +"También funcionan con *algunos* objetos que actúan como proxy en el acceso a " +"atributos, como el objeto de configuraciones de django (`django settings " +"object `_)." #: ../Doc/library/unittest.mock.rst:1947 msgid "MagicMock and magic method support" -msgstr "" +msgstr "MagicMock y el soporte de métodos mágicos" #: ../Doc/library/unittest.mock.rst:1952 msgid "Mocking Magic Methods" -msgstr "" +msgstr "Simular métodos mágicos" #: ../Doc/library/unittest.mock.rst:1954 msgid "" @@ -1521,6 +2212,10 @@ msgid "" "\"magic methods\". This allows mock objects to replace containers or other " "objects that implement Python protocols." msgstr "" +":class:`Mock` soporta la simulación de los métodos de protocolo de Python, " +"también conocidos como \"métodos mágicos\". Esto permite a los objetos " +"simulados reemplazar contenedores u otros objetos que implementan protocolos " +"de Python." #: ../Doc/library/unittest.mock.rst:1958 msgid "" @@ -1529,6 +2224,11 @@ msgid "" "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 "" +"Dado que los métodos mágicos se buscan de manera diferente a los métodos " +"normales [#]_, este soporte ha sido especialmente implementado. Esto " +"significa que sólo es compatible con métodos mágicos específicos. La lista " +"de métodos soportados incluye *casi* todos los existentes. Si hay alguno que " +"falta y que consideras necesario, por favor háznoslo saber." #: ../Doc/library/unittest.mock.rst:1963 msgid "" @@ -1536,18 +2236,25 @@ msgid "" "function or a mock instance. If you are using a function then it *must* take " "``self`` as the first argument [#]_." msgstr "" +"Puedes simular métodos mágicos estableciendo el método que te interesa en " +"una función o en una instancia simulada. Si utilizas una función, *debe* " +"aceptar ``self`` como primer argumento [#]_." #: ../Doc/library/unittest.mock.rst:1986 msgid "" "One use case for this is for mocking objects used as context managers in a :" "keyword:`with` statement:" msgstr "" +"Un caso de uso para esto es simular objetos usados ​​como gestores de contexto " +"en una declaración :keyword:`with`:" #: ../Doc/library/unittest.mock.rst:1998 msgid "" "Calls to magic methods do not appear in :attr:`~Mock.method_calls`, but they " "are recorded in :attr:`~Mock.mock_calls`." msgstr "" +"Las llamadas a métodos mágicos no aparecen registradas en :attr:`~Mock." +"method_calls`, aunque si se registran en :attr:`~Mock.mock_calls`." #: ../Doc/library/unittest.mock.rst:2003 msgid "" @@ -1555,28 +2262,33 @@ msgid "" "set a magic method that isn't in the spec will raise an :exc:" "`AttributeError`." msgstr "" +"Si se utiliza el argumento por palabra clave *spec* para crear un objeto " +"simulado, intentar después establecer un método mágico que no está en la " +"especificación lanzará una excepción :exc:`AttributeError`." #: ../Doc/library/unittest.mock.rst:2006 msgid "The full list of supported magic methods is:" -msgstr "" +msgstr "La lista completa de los métodos mágicos soportados es la siguiente:" #: ../Doc/library/unittest.mock.rst:2008 msgid "``__hash__``, ``__sizeof__``, ``__repr__`` and ``__str__``" -msgstr "" +msgstr "``__hash__``, ``__sizeof__``, ``__repr__`` y ``__str__``" #: ../Doc/library/unittest.mock.rst:2009 msgid "``__dir__``, ``__format__`` and ``__subclasses__``" -msgstr "" +msgstr "``__dir__``, ``__format__`` y ``__subclasses__``" #: ../Doc/library/unittest.mock.rst:2010 msgid "``__round__``, ``__floor__``, ``__trunc__`` and ``__ceil__``" -msgstr "" +msgstr "``__round__``, ``__floor__``, ``__trunc__`` y ``__ceil__``" #: ../Doc/library/unittest.mock.rst:2011 msgid "" "Comparisons: ``__lt__``, ``__gt__``, ``__le__``, ``__ge__``, ``__eq__`` and " "``__ne__``" msgstr "" +"Comparaciones: ``__lt__``, ``__gt__``, ``__le__``, ``__ge__``, ``__eq__`` y " +"``__ne__``" #: ../Doc/library/unittest.mock.rst:2013 msgid "" @@ -1584,16 +2296,21 @@ msgid "" "``__contains__``, ``__len__``, ``__iter__``, ``__reversed__`` and " "``__missing__``" msgstr "" +"Métodos de contenedores: ``__getitem__``, ``__setitem__``, ``__delitem__``, " +"``__contains__``, ``__len__``, ``__iter__``, ``__reversed__`` y " +"``__missing__``" #: ../Doc/library/unittest.mock.rst:2016 msgid "" "Context manager: ``__enter__``, ``__exit__``, ``__aenter__`` and " "``__aexit__``" msgstr "" +"Administrador de contexto: ``__enter__``, ``__exit__``, ``__aenter__`` y " +"``__aexit__``" #: ../Doc/library/unittest.mock.rst:2017 msgid "Unary numeric methods: ``__neg__``, ``__pos__`` and ``__invert__``" -msgstr "" +msgstr "Métodos numéricos unarios: ``__neg__``, ``__pos__`` y ``__invert__``" #: ../Doc/library/unittest.mock.rst:2018 msgid "" @@ -1603,65 +2320,82 @@ msgid "" "``__lshift__``, ``__rshift__``, ``__and__``, ``__xor__``, ``__or__``, and " "``__pow__``" msgstr "" +"Los métodos numéricos (incluyendo los métodos estándar y las variantes in-" +"place): ``__add__``, ``__sub__``, ``__mul__``, ``__matmul__``, ``__div__``, " +"``__truediv__``, ``__floordiv__``, ``__mod__``, ``__divmod__``, " +"``__lshift__``, ``__rshift__``, ``__and__``, ``__xor__``, ``__or__``, y " +"``__pow__``" #: ../Doc/library/unittest.mock.rst:2022 msgid "" "Numeric conversion methods: ``__complex__``, ``__int__``, ``__float__`` and " "``__index__``" msgstr "" +"Métodos de conversión numérica: ``__complex__``, ``__int__``, ``__float__`` " +"y ``__index__``" #: ../Doc/library/unittest.mock.rst:2024 msgid "Descriptor methods: ``__get__``, ``__set__`` and ``__delete__``" -msgstr "" +msgstr "Métodos de descriptores: ``__get__``, ``__set__`` y ``__delete__``" #: ../Doc/library/unittest.mock.rst:2025 msgid "" "Pickling: ``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, " "``__getnewargs__``, ``__getstate__`` and ``__setstate__``" msgstr "" +"Pickling: ``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, " +"``__getnewargs__``, ``__getstate__`` y ``__setstate__``" #: ../Doc/library/unittest.mock.rst:2027 msgid "File system path representation: ``__fspath__``" -msgstr "" +msgstr "Representación de rutas del sistema de archivos: ``__fspath__``" #: ../Doc/library/unittest.mock.rst:2028 msgid "Asynchronous iteration methods: ``__aiter__`` and ``__anext__``" -msgstr "" +msgstr "Métodos de iteración asíncronos: ``__aiter__`` y ``__anext__``" #: ../Doc/library/unittest.mock.rst:2030 msgid "Added support for :func:`os.PathLike.__fspath__`." -msgstr "" +msgstr "Se añadió soporte para :func:`os.PathLike.__fspath__`." #: ../Doc/library/unittest.mock.rst:2033 msgid "" "Added support for ``__aenter__``, ``__aexit__``, ``__aiter__`` and " "``__anext__``." msgstr "" +"Se añadió soporte para ``__aenter__``, ``__aexit__``, ``__aiter__`` y " +"``__anext__``." #: ../Doc/library/unittest.mock.rst:2037 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 "" +"Los siguientes métodos existen pero *no* están soportados, ya sea porque son " +"usados por el propio objeto simulado, porque no se pueden establecer " +"dinámicamente o porque pueden causar problemas:" #: ../Doc/library/unittest.mock.rst:2040 msgid "``__getattr__``, ``__setattr__``, ``__init__`` and ``__new__``" -msgstr "" +msgstr "``__getattr__``, ``__setattr__``, ``__init__`` y ``__new__``" #: ../Doc/library/unittest.mock.rst:2041 msgid "" "``__prepare__``, ``__instancecheck__``, ``__subclasscheck__``, ``__del__``" msgstr "" +"``__prepare__``, ``__instancecheck__``, ``__subclasscheck__`` y ``__del__``" #: ../Doc/library/unittest.mock.rst:2046 msgid "Magic Mock" -msgstr "" +msgstr "Magic Mock" #: ../Doc/library/unittest.mock.rst:2048 msgid "" "There are two ``MagicMock`` variants: :class:`MagicMock` and :class:" "`NonCallableMagicMock`." msgstr "" +"Hay dos variantes de ``MagicMock``: :class:`MagicMock` y :class:" +"`NonCallableMagicMock`." #: ../Doc/library/unittest.mock.rst:2053 msgid "" @@ -1669,20 +2403,28 @@ msgid "" "most of the magic methods. You can use ``MagicMock`` without having to " "configure the magic methods yourself." msgstr "" +"``MagicMock`` es una subclase de :class:`Mock` con implementaciones por " +"defecto de la mayoría de los métodos mágicos. Puedes utilizar ``MagicMock`` " +"para crear objetos simulados sin tener que establecer los métodos mágicos " +"por ti mismo." #: ../Doc/library/unittest.mock.rst:2057 msgid "The constructor parameters have the same meaning as for :class:`Mock`." msgstr "" +"Los parámetros del constructor tienen el mismo significado que en :class:" +"`Mock`." #: ../Doc/library/unittest.mock.rst:2059 msgid "" "If you use the *spec* or *spec_set* arguments then *only* magic methods that " "exist in the spec will be created." msgstr "" +"Si utilizas los argumentos *spec* o *spec_set* entonces *solo* los métodos " +"mágicos que existan en la especificación serán creados." #: ../Doc/library/unittest.mock.rst:2065 msgid "A non-callable version of :class:`MagicMock`." -msgstr "" +msgstr "Una versión no invocable de :class:`MagicMock`." #: ../Doc/library/unittest.mock.rst:2067 msgid "" @@ -1690,12 +2432,17 @@ msgid "" "with the exception of *return_value* and *side_effect* which have no meaning " "on a non-callable mock." msgstr "" +"Los parámetros del constructor tienen el mismo significado que en :class:" +"`MagicMock`, con la excepción de *return_value* y *side_effect* que no " +"tienen significado en un objeto simulado no invocable." #: ../Doc/library/unittest.mock.rst:2071 msgid "" "The magic methods are setup with :class:`MagicMock` objects, so you can " "configure them and use them in the usual way:" msgstr "" +"Los métodos mágicos están implementados mediante objetos :class:`MagicMock`, " +"por lo que puedes configurarlos y utilizarlos de la forma habitual:" #: ../Doc/library/unittest.mock.rst:2081 msgid "" @@ -1705,82 +2452,88 @@ msgid "" "interested in the return value. You can still *set* the return value " "manually if you want to change the default." msgstr "" +"Por defecto, muchos de los métodos de protocolo están obligados a retornar " +"objetos de un tipo específico. Estos métodos están preconfigurados con un " +"valor de retorno por defecto, de manera que puedan ser utilizados sin tener " +"que hacer nada más, siempre que no estés interesado en el valor de retorno. " +"En todo caso, puedes *establecer* el valor de retorno de forma manual si " +"deseas cambiar el valor predeterminado." #: ../Doc/library/unittest.mock.rst:2087 msgid "Methods and their defaults:" -msgstr "" +msgstr "Métodos y sus valores por defecto:" #: ../Doc/library/unittest.mock.rst:2089 msgid "``__lt__``: ``NotImplemented``" -msgstr "" +msgstr "``__lt__``: ``NotImplemented``" #: ../Doc/library/unittest.mock.rst:2090 msgid "``__gt__``: ``NotImplemented``" -msgstr "" +msgstr "``__gt__``: ``NotImplemented``" #: ../Doc/library/unittest.mock.rst:2091 msgid "``__le__``: ``NotImplemented``" -msgstr "" +msgstr "``__le__``: ``NotImplemented``" #: ../Doc/library/unittest.mock.rst:2092 msgid "``__ge__``: ``NotImplemented``" -msgstr "" +msgstr "``__ge__``: ``NotImplemented``" #: ../Doc/library/unittest.mock.rst:2093 msgid "``__int__``: ``1``" -msgstr "" +msgstr "``__int__``: ``1``" #: ../Doc/library/unittest.mock.rst:2094 msgid "``__contains__``: ``False``" -msgstr "" +msgstr "``__contains__``: ``False``" #: ../Doc/library/unittest.mock.rst:2095 msgid "``__len__``: ``0``" -msgstr "" +msgstr "``__len__``: ``0``" #: ../Doc/library/unittest.mock.rst:2096 msgid "``__iter__``: ``iter([])``" -msgstr "" +msgstr "``__iter__``: ``iter([])``" #: ../Doc/library/unittest.mock.rst:2097 msgid "``__exit__``: ``False``" -msgstr "" +msgstr "``__exit__``: ``False``" #: ../Doc/library/unittest.mock.rst:2098 msgid "``__aexit__``: ``False``" -msgstr "" +msgstr "``__aexit__``: ``False``" #: ../Doc/library/unittest.mock.rst:2099 msgid "``__complex__``: ``1j``" -msgstr "" +msgstr "``__complex__``: ``1j``" #: ../Doc/library/unittest.mock.rst:2100 msgid "``__float__``: ``1.0``" -msgstr "" +msgstr "``__float__``: ``1.0``" #: ../Doc/library/unittest.mock.rst:2101 msgid "``__bool__``: ``True``" -msgstr "" +msgstr "``__bool__``: ``True``" #: ../Doc/library/unittest.mock.rst:2102 msgid "``__index__``: ``1``" -msgstr "" +msgstr "``__index__``: ``1``" #: ../Doc/library/unittest.mock.rst:2103 msgid "``__hash__``: default hash for the mock" -msgstr "" +msgstr "``__hash__``: hash predeterminado del objeto simulado" #: ../Doc/library/unittest.mock.rst:2104 msgid "``__str__``: default str for the mock" -msgstr "" +msgstr "``__str__``: str predeterminado del objeto simulado" #: ../Doc/library/unittest.mock.rst:2105 msgid "``__sizeof__``: default sizeof for the mock" -msgstr "" +msgstr "``__sizeof__``: sizeof predeterminado del objeto simulado" #: ../Doc/library/unittest.mock.rst:2107 msgid "For example:" -msgstr "" +msgstr "Por ejemplo:" #: ../Doc/library/unittest.mock.rst:2119 msgid "" @@ -1789,18 +2542,26 @@ msgid "" "side_effect` attribute, unless you change their return value to return " "something else::" msgstr "" +"Los dos métodos de igualdad, :meth:`__eq__` y :meth:`__ne__`, son " +"especiales. Realizan la comparación de igualdad predeterminada basada en la " +"identidad, utilizando el atributo :attr:`~Mock.side_effect`, a menos que " +"cambies su valor de retorno para que retorne alguna otra cosa:" #: ../Doc/library/unittest.mock.rst:2133 msgid "" "The return value of :meth:`MagicMock.__iter__` can be any iterable object " "and isn't required to be an iterator:" msgstr "" +"El valor de retorno de :meth:`MagicMock.__iter__` puede ser cualquier objeto " +"iterable, no se requiere que sea un iterador:" #: ../Doc/library/unittest.mock.rst:2143 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 "" +"Si el valor de retorno *es* un iterador, iterar sobre él una vez que se " +"consume, y cualquier iteración posterior, resultará en una lista vacía:" #: ../Doc/library/unittest.mock.rst:2152 msgid "" @@ -1808,42 +2569,49 @@ msgid "" "some of the obscure and obsolete ones. You can still set these up if you " "want." msgstr "" +"``MagicMock`` tiene todos los métodos mágicos soportados configurados a " +"excepción de algunos de los más oscuros y obsoletos. De todas formas, puedes " +"configurar estos también si lo deseas." #: ../Doc/library/unittest.mock.rst:2155 msgid "" "Magic methods that are supported but not setup by default in ``MagicMock`` " "are:" msgstr "" +"Los métodos mágicos que son compatibles, pero que no están configurados por " +"defecto en ``MagicMock`` son:" #: ../Doc/library/unittest.mock.rst:2157 msgid "``__subclasses__``" -msgstr "" +msgstr "``__subclasses__``" #: ../Doc/library/unittest.mock.rst:2158 msgid "``__dir__``" -msgstr "" +msgstr "``__dir__``" #: ../Doc/library/unittest.mock.rst:2159 msgid "``__format__``" -msgstr "" +msgstr "``__format__``" #: ../Doc/library/unittest.mock.rst:2160 msgid "``__get__``, ``__set__`` and ``__delete__``" -msgstr "" +msgstr "``__get__``, ``__set__`` y ``__delete__``" #: ../Doc/library/unittest.mock.rst:2161 msgid "``__reversed__`` and ``__missing__``" -msgstr "" +msgstr "``__reversed__`` y ``__missing__``" #: ../Doc/library/unittest.mock.rst:2162 msgid "" "``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, ``__getnewargs__``, " "``__getstate__`` and ``__setstate__``" msgstr "" +"``__reduce__``, ``__reduce_ex__``, ``__getinitargs__``, ``__getnewargs__``, " +"``__getstate__`` y ``__setstate__``" #: ../Doc/library/unittest.mock.rst:2164 msgid "``__getformat__`` and ``__setformat__``" -msgstr "" +msgstr "``__getformat__`` y ``__setformat__``" #: ../Doc/library/unittest.mock.rst:2168 msgid "" @@ -1851,26 +2619,34 @@ msgid "" "Different versions of Python are inconsistent about applying this rule. The " "supported protocol methods should work with all supported versions of Python." msgstr "" +"Los métodos mágicos *deben* ser buscados en la clase en lugar de en la " +"instancia. Diferentes versiones de Python son inconsistentes sobre la " +"aplicación de esta regla. Los métodos de protocolo soportados deben trabajar " +"con todas las versiones de Python." #: ../Doc/library/unittest.mock.rst:2172 msgid "" "The function is basically hooked up to the class, but each ``Mock`` instance " "is kept isolated from the others." msgstr "" +"La función está básicamente conectada a la clase, pero cada instancia " +"``Mock`` se mantiene aislada de las demás." #: ../Doc/library/unittest.mock.rst:2177 msgid "Helpers" -msgstr "" +msgstr "Ayudantes" #: ../Doc/library/unittest.mock.rst:2180 msgid "sentinel" -msgstr "" +msgstr "sentinel" #: ../Doc/library/unittest.mock.rst:2184 msgid "" "The ``sentinel`` object provides a convenient way of providing unique " "objects for your tests." msgstr "" +"El objeto ``sentinel`` proporciona una manera conveniente de proporcionar " +"objetos únicos para tus pruebas." #: ../Doc/library/unittest.mock.rst:2187 msgid "" @@ -1878,12 +2654,18 @@ msgid "" "same attribute will always return the same object. The objects returned have " "a sensible repr so that test failure messages are readable." msgstr "" +"Los atributos se crean a demanda, en el instante en el que se accede a ellos " +"por su nombre por primera vez. El acceso al mismo atributo siempre retornará " +"el mismo objeto. Los objetos retornados tienen una reproducción (repr) " +"apropiada para que los mensajes de error de la prueba sean legibles." #: ../Doc/library/unittest.mock.rst:2191 msgid "" "The ``sentinel`` attributes now preserve their identity when they are :mod:" "`copied ` or :mod:`pickled `." msgstr "" +"Los atributos ``sentinel`` ahora preservan su identidad cuando son :mod:" +"`copiados ` o :mod:`serializados con pickle `." #: ../Doc/library/unittest.mock.rst:2195 msgid "" @@ -1892,16 +2674,23 @@ msgid "" "sentinel objects to test this. :data:`sentinel` provides a convenient way of " "creating and testing the identity of objects like this." msgstr "" +"A veces, cuando implementas pruebas, necesitas probar que un determinado " +"objeto se pasa como argumento a otro método, o se retorna. Crear objetos " +"centinela con un nombre para probar esto puede ser una práctica común. :data:" +"`sentinel` proporciona una manera conveniente de crear y probar la identidad " +"de este tipo de objetos." #: ../Doc/library/unittest.mock.rst:2200 msgid "" "In this example we monkey patch ``method`` to return ``sentinel." "some_object``:" msgstr "" +"En el siguiente ejemplo, parcheamos ``method`` para retornar ``sentinel." +"some_object``:" #: ../Doc/library/unittest.mock.rst:2212 msgid "DEFAULT" -msgstr "" +msgstr "DEFAULT" #: ../Doc/library/unittest.mock.rst:2217 msgid "" @@ -1909,10 +2698,13 @@ msgid "" "DEFAULT``). It can be used by :attr:`~Mock.side_effect` functions to " "indicate that the normal return value should be used." msgstr "" +"El objeto :data:`DEFAULT` es un centinela pre-creado (actualmente ``sentinel." +"DEFAULT``). Puede ser usado por las funciones :attr:`~Mock.side_effect` para " +"indicar que el valor de retorno normal debe ser utilizado." #: ../Doc/library/unittest.mock.rst:2223 msgid "call" -msgstr "" +msgstr "call" #: ../Doc/library/unittest.mock.rst:2227 msgid "" @@ -1921,12 +2713,19 @@ msgid "" "mock_calls` and :attr:`~Mock.method_calls`. :func:`call` can also be used " "with :meth:`~Mock.assert_has_calls`." msgstr "" +":func:`call` es un objeto ayudante que puede usarse para hacer aserciones " +"simples, para comparar con :attr:`~Mock.call_args`, :attr:`~Mock." +"call_args_list`, :attr:`~Mock.mock_calls` y :attr:`~Mock.method_calls`. :" +"func:`call` y también se puede utilizar con :meth:`~Mock.assert_has_calls`." #: ../Doc/library/unittest.mock.rst:2240 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 "" +"Para un objeto call que representa múltiples llamadas, el método :meth:" +"`call_list` retorna una lista con todas las llamadas intermedias, así como " +"la llamada final." #: ../Doc/library/unittest.mock.rst:2244 msgid "" @@ -1935,12 +2734,19 @@ msgid "" "in multiple entries in :attr:`~Mock.mock_calls` on a mock. Manually " "constructing the sequence of calls can be tedious." msgstr "" +"``call_list`` es particularmente útil para hacer aserciones sobre \"llamadas " +"encadenadas\". Una llamada encadenada es varias llamadas en una sola línea " +"de código. Esto resulta en múltiples entradas en el atributo :attr:`~Mock." +"mock_calls` de un objeto simulado. Construir manualmente la secuencia de " +"llamadas puede ser tedioso." #: ../Doc/library/unittest.mock.rst:2249 msgid "" ":meth:`~call.call_list` can construct the sequence of calls from the same " "chained call:" msgstr "" +":meth:`~call.call_list` puede construir la secuencia de llamadas desde la " +"misma llamada encadenada:" #: ../Doc/library/unittest.mock.rst:2266 msgid "" @@ -1951,6 +2757,14 @@ msgid "" "call_args_list` and :attr:`Mock.mock_calls` attributes can be introspected " "to get at the individual arguments they contain." msgstr "" +"Un objeto ``call``, dependiendo de cómo fuera construido, puede ser una " +"tupla de la forma (argumentos posicionales, argumentos por palabras clave) o " +"bien de la forma (nombre, argumentos posicionales, argumentos por palabras " +"clave). Esto no es particularmente interesante cuando los construyes por ti " +"mismo, pero la introspección de los objetos ``call`` que conforman los " +"atributos :attr:`Mock.call_args`, :attr:`Mock.call_args_list` y :attr:`Mock." +"mock_calls` si pueden ser de utilidad para para acceder a los argumentos " +"individuales que contienen." #: ../Doc/library/unittest.mock.rst:2273 msgid "" @@ -1960,6 +2774,11 @@ msgid "" "construct yourself, are three-tuples of (name, positional args, keyword " "args)." msgstr "" +"Los objetos ``call`` en :attr:`Mock.call_args` y :attr:`Mock.call_args_list` " +"están conformados por dos tuplas (argumentos posicionales, argumentos por " +"palabra clave) mientras que los objetos ``call`` en :attr:`Mock.mock_calls`, " +"junto con los que construyas por ti mismo, constan de tres tuplas (nombre, " +"argumentos posicionales, argumentos por palabra clave)." #: ../Doc/library/unittest.mock.rst:2278 msgid "" @@ -1968,28 +2787,39 @@ msgid "" "tuple (an empty tuple if there are no positional arguments) and the keyword " "arguments are a dictionary:" msgstr "" +"Puedes utilizar esta presentación en forma de tuplas para obtener los " +"argumentos individuales, con la finalidad de llevar a cabo introspección y " +"aserciones más complejas. Los argumentos posicionales son una tupla (vacía " +"si no hay ninguno) y los argumentos por palabra clave son un diccionario:" #: ../Doc/library/unittest.mock.rst:2311 msgid "create_autospec" -msgstr "" +msgstr "create_autospec" #: ../Doc/library/unittest.mock.rst:2315 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 "" +"Crea un nuevo objeto simulado utilizando otro objeto (*spec*) como " +"especificación. Los atributos del objeto simulado utilizarán el atributo " +"correspondiente del objeto *spec* como su especificación." #: ../Doc/library/unittest.mock.rst:2319 msgid "" "Functions or methods being mocked will have their arguments checked to " "ensure that they are called with the correct signature." msgstr "" +"Los argumentos de las funciones o métodos simulados se validarán para " +"asegurarse de que son invocados con la firma correcta." #: ../Doc/library/unittest.mock.rst:2322 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 "" +"Si *spec_set* es ``True``, tratar de establecer atributos que no existen en " +"el objeto especificado lanzará una excepción :exc:`AttributeError`." #: ../Doc/library/unittest.mock.rst:2325 msgid "" @@ -1998,28 +2828,40 @@ msgid "" "an instance object by passing ``instance=True``. The returned mock will only " "be callable if instances of the mock are callable." msgstr "" +"Si se utiliza una clase como especificación, el valor de retorno del objeto " +"simulado (la instancia de la clase) tendrá la misma especificación. Se puede " +"utilizar una clase como especificación de una instancia pasando " +"``instance=True``. El objeto simulado retornado sólo será invocable si las " +"instancias del objeto simulado son también invocables." #: ../Doc/library/unittest.mock.rst:2330 msgid "" ":func:`create_autospec` also takes arbitrary keyword arguments that are " "passed to the constructor of the created mock." msgstr "" +":func:`create_autospec` también acepta argumentos por palabra clave " +"arbitrarios, que son pasados al constructor del objeto simulado creado." #: ../Doc/library/unittest.mock.rst:2333 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 "" +"Consultar :ref:`auto-speccing` para ver ejemplos de cómo utilizar la " +"autoespecificación mediante :func:`create_autospec` y el argumento " +"*autospec* de :func:`patch`." #: ../Doc/library/unittest.mock.rst:2339 msgid "" ":func:`create_autospec` now returns an :class:`AsyncMock` if the target is " "an async function." msgstr "" +":func:`create_autospec` ahora retorna un objeto :class:`AsyncMock` si el " +"objetivo a simular es una función asíncrona." #: ../Doc/library/unittest.mock.rst:2344 msgid "ANY" -msgstr "" +msgstr "ANY" #: ../Doc/library/unittest.mock.rst:2348 msgid "" @@ -2028,6 +2870,10 @@ msgid "" "pull them individually out of :attr:`~Mock.call_args` and make more complex " "assertions on them." msgstr "" +"A veces puede que necesites hacer aserciones sobre *algunos* de los " +"argumentos de una llamada al objeto simulado, pero sin preocuparte por el " +"resto, o puede que quieras hacer uso de ellos de forma individual fuera de :" +"attr:`~Mock.call_args` y hacer aserciones más complejas con ellos." #: ../Doc/library/unittest.mock.rst:2353 msgid "" @@ -2035,16 +2881,22 @@ msgid "" "*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 "" +"Para ignorar ciertos argumentos puedes pasar objetos que se comparan como " +"iguales con *cualquier cosa*. En este caso, las llamadas a :meth:`~Mock." +"assert_called_with` y :meth:`~Mock.assert_called_once_with` tendrán éxito " +"sin importar lo que se haya pasado realmente." #: ../Doc/library/unittest.mock.rst:2362 msgid "" ":data:`ANY` can also be used in comparisons with call lists like :attr:" "`~Mock.mock_calls`:" msgstr "" +":data:`ANY` también se puede utilizar en las comparaciones con las listas de " +"llamadas, como :attr:`~Mock.mock_calls`:" #: ../Doc/library/unittest.mock.rst:2375 msgid "FILTER_DIR" -msgstr "" +msgstr "FILTER_DIR" #: ../Doc/library/unittest.mock.rst:2379 msgid "" @@ -2054,6 +2906,13 @@ msgid "" "useful members. If you dislike this filtering, or need to switch it off for " "diagnostic purposes, then set ``mock.FILTER_DIR = False``." msgstr "" +":data:`FILTER_DIR` es una variable definida a nivel de módulo que controla " +"la forma en la que los objetos simulados responden a :func:`dir` (sólo para " +"Python 2.6 y en adelante). El valor predeterminado es ``True``, que utiliza " +"el filtrado descrito a continuación, con la finalidad de mostrar solo los " +"miembros considerados como útiles. Si no te gusta este filtrado, o necesitas " +"desactivarlo con fines de diagnóstico, simplemente establece ``mock." +"FILTER_DIR = False``." #: ../Doc/library/unittest.mock.rst:2385 msgid "" @@ -2063,6 +2922,11 @@ msgid "" "attributes from the original are shown, even if they haven't been accessed " "yet:" msgstr "" +"Con el filtrado activado, ``dir(some_mock)`` mostrará solo atributos útiles " +"y además incluirá cualquier atributo creado dinámicamente, que normalmente " +"no se mostraría. Si el objeto simulado fue creado con un *spec* (o " +"*autospec*) se muestran todos los atributos del objeto original, incluso si " +"no se ha accedido a ellos todavía:" #: ../Doc/library/unittest.mock.rst:2412 msgid "" @@ -2072,6 +2936,12 @@ msgid "" "dislike this behaviour you can switch it off by setting the module level " "switch :data:`FILTER_DIR`:" msgstr "" +"Muchos de los atributos con subrayado y doble subrayado no muy útiles " +"(atributos privados de :class:`Mock` y no del objeto real que se está " +"simulando) se han filtrado del resultado de llamar a :func:`dir` en un " +"objeto :class:`Mock`. Si no te gusta este comportamiento, puedes " +"desactivarlo estableciendo el modificador a nivel de módulo :data:" +"`FILTER_DIR`:" #: ../Doc/library/unittest.mock.rst:2433 msgid "" @@ -2079,16 +2949,23 @@ msgid "" "``dir(type(my_mock))`` (type members) to bypass the filtering irrespective " "of :data:`mock.FILTER_DIR`." msgstr "" +"Como alternativa, puedes usar ``vars(my_mock)`` (miembros de instancia) y " +"``dir(type(my_mock))`` (miembros de tipo) para omitir el filtrado con " +"independencia del valor de :data:`mock.FILTER_DIR`." #: ../Doc/library/unittest.mock.rst:2439 msgid "mock_open" -msgstr "" +msgstr "mock_open" #: ../Doc/library/unittest.mock.rst:2443 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 "" +"Una función auxiliar que permite crear un objeto simulado con la finalidad " +"de reemplazar el uso de :func:`open`. Funciona para simular llamadas " +"directas a :func:`open` y para aquellos casos en los que es utilizada como " +"gestor de contexto." #: ../Doc/library/unittest.mock.rst:2446 msgid "" @@ -2096,6 +2973,9 @@ msgid "" "default) then a :class:`MagicMock` will be created for you, with the API " "limited to methods or attributes available on standard file handles." msgstr "" +"El argumento *mock* es el objeto simulado a configurar. Si es ``None`` (por " +"defecto) un objeto :class:`MagicMock` se creará para ti, con la API limitada " +"a métodos o atributos disponibles en los gestores de fichero estándares." #: ../Doc/library/unittest.mock.rst:2450 msgid "" @@ -2109,6 +2989,17 @@ msgid "" "in-memory filesystem packages on `PyPI `_ can offer a " "realistic filesystem for testing." msgstr "" +"*read_data* es una cadena de caracteres para los métodos :meth:`~io.IOBase." +"read`, :meth:`~io.IOBase.readline` y :meth:`~io.IOBase.readlines` del gestor " +"de fichero a retornar. Las llamadas a los métodos tomarán datos de " +"*read_data* hasta que se agote. El objeto simulado de estos métodos es " +"bastante simple: cada vez que el *mock* se llama, *read_data* se rebobina " +"hasta el principio. Si necesitas más control sobre los datos que estás " +"proporcionando al código de prueba tendrás que personalizar el objeto " +"simulado. Cuando eso no sea suficiente, alguno de los paquetes que " +"implementan sistemas de archivos en memoria disponible en `PyPI `_ puede ofrecer un sistema de archivos realista para usar en las " +"pruebas." #: ../Doc/library/unittest.mock.rst:2460 msgid "" @@ -2116,22 +3007,30 @@ msgid "" "The mock of :meth:`~io.IOBase.read` changed to consume *read_data* rather " "than returning it on each call." msgstr "" +"Se añadió soporte para :meth:`~io.IOBase.readline` y :meth:`~io.IOBase." +"readlines`. El objeto simulado de :meth:`~io.IOBase.read` ahora consume " +"datos de *read_data*, en lugar de retornarlo en cada llamada." #: ../Doc/library/unittest.mock.rst:2465 msgid "*read_data* is now reset on each call to the *mock*." -msgstr "" +msgstr "*read_data* ahora es restablecido en cada llamada al *mock*." #: ../Doc/library/unittest.mock.rst:2468 msgid "" "Added :meth:`__iter__` to implementation so that iteration (such as in for " "loops) correctly consumes *read_data*." msgstr "" +"Se añadió el método :meth:`__iter__` a la implementación, de manera que la " +"iteración (como ocurre en los bucles) consume apropiadamente *read_data*." #: ../Doc/library/unittest.mock.rst:2472 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 "" +"Usar :func:`open` como gestor de contexto es una buena manera de asegurarse " +"de que los gestores de archivos se cierren correctamente al terminar y se " +"está convirtiendo en una práctica común:" #: ../Doc/library/unittest.mock.rst:2478 msgid "" @@ -2139,20 +3038,25 @@ msgid "" "*returned object* that is used as a context manager (and has :meth:" "`__enter__` and :meth:`__exit__` called)." msgstr "" +"El problema es que, incluso si simulas la llamada a :func:`open`, es el " +"*objeto retornado* el que se utiliza como gestor de contexto (lo que " +"conlleva que sus métodos :meth:`__enter__` y :meth:`__exit__` son invocados)." #: ../Doc/library/unittest.mock.rst:2482 msgid "" "Mocking context managers with a :class:`MagicMock` is common enough and " "fiddly enough that a helper function is useful. ::" msgstr "" +"Simular gestores de contexto con un :class:`MagicMock` es lo suficientemente " +"común y complicado como para que una función auxiliar sea útil:" #: ../Doc/library/unittest.mock.rst:2499 msgid "And for reading files::" -msgstr "" +msgstr "Y para la lectura de archivos:" #: ../Doc/library/unittest.mock.rst:2512 msgid "Autospeccing" -msgstr "" +msgstr "Autoespecificación" #: ../Doc/library/unittest.mock.rst:2514 msgid "" @@ -2163,10 +3067,19 @@ msgid "" "methods have the same call signature as the original so they raise a :exc:" "`TypeError` if they are called incorrectly." msgstr "" +"La autoespecificación se basa en la característica :attr:`spec` ya existente " +"en el objeto simulado. Limita la API de los objetos simulados a la API del " +"objeto original (la especificación), pero es recursiva (implementada de " +"forma perezosa), de modo que los atributos del objeto simulado sólo tienen " +"la misma API que los atributos de la especificación. Además, las funciones / " +"métodos simuladas tienen la misma firma de llamada que la original y lanzan " +"una excepción :exc:`TypeError` si se les llama incorrectamente." #: ../Doc/library/unittest.mock.rst:2521 msgid "Before I explain how auto-speccing works, here's why it is needed." msgstr "" +"Antes de explicar cómo funciona la autoespecificación, he aquí por qué se " +"necesita." #: ../Doc/library/unittest.mock.rst:2523 msgid "" @@ -2175,6 +3088,10 @@ msgid "" "these flaws is specific to the :class:`Mock` api and the other is a more " "general problem with using mock objects." msgstr "" +":class:`Mock` es un objeto muy potente y flexible, pero adolece de dos " +"defectos cuando se utiliza para simular objetos de un sistema bajo prueba. " +"Uno de estos defectos es específico de la API de :class:`Mock` y el otro es " +"un problema más genérico referente al uso de objetos simulados." #: ../Doc/library/unittest.mock.rst:2528 msgid "" @@ -2182,6 +3099,9 @@ msgid "" "methods that are extremely handy: :meth:`~Mock.assert_called_with` and :meth:" "`~Mock.assert_called_once_with`." msgstr "" +"En primer lugar, el problema específico a :class:`Mock`. :class:`Mock` tiene " +"dos métodos de aserción que son extremadamente útiles: :meth:`~Mock." +"assert_called_with` y :meth:`~Mock.assert_called_once_with`." #: ../Doc/library/unittest.mock.rst:2541 msgid "" @@ -2189,10 +3109,16 @@ msgid "" "with arbitrary arguments, if you misspell one of these assert methods then " "your assertion is gone:" msgstr "" +"Debido a que los objetos simulados crean automáticamente atributos según " +"demanda y además permiten que se les llame con argumentos arbitrarios, si " +"escribes mal uno de estos métodos de aserción, la utilidad de esa aserción " +"desaparece:" #: ../Doc/library/unittest.mock.rst:2551 msgid "Your tests can pass silently and incorrectly because of the typo." msgstr "" +"Tus pruebas pueden pasar silenciosamente y de forma incorrecta debido al " +"error tipográfico." #: ../Doc/library/unittest.mock.rst:2553 msgid "" @@ -2201,6 +3127,12 @@ msgid "" "*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 "" +"El segundo problema es algo más general en las simulaciones. Si refactorizas " +"parte de tu código, cambias el nombre de los miembros, etc., las pruebas " +"para el código que siguen utilizando la *antigua API*, pero utilizan objetos " +"simulados en lugar de los objetos reales, todavía pasarán las pruebas. Esto " +"significa que tus pruebas pueden validarlo todo sin problemas, a pesar de " +"que el código esté roto." #: ../Doc/library/unittest.mock.rst:2558 msgid "" @@ -2209,6 +3141,11 @@ msgid "" "you don't test how your units are \"wired together\" there is still lots of " "room for bugs that tests might have caught." msgstr "" +"Ten en cuenta que esta es otra razón por la que necesitas pruebas de " +"integración además de pruebas unitarias. Probar todo de forma aislada está " +"muy bien, pero si no pruebas cómo están \"conectadas entre sí\" tus " +"unidades, todavía hay mucho espacio para errores que las pruebas deberían " +"haber detectado." #: ../Doc/library/unittest.mock.rst:2563 msgid "" @@ -2216,12 +3153,18 @@ msgid "" "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 "" +":mod:`mock` ya proporciona una característica para ayudar con esto, llamada " +"especificación. Si se utiliza una clase o instancia como atributo :attr:" +"`spec` de un objeto simulado, entonces solo puedes acceder a los atributos " +"del mismo que existe en la clase real:" #: ../Doc/library/unittest.mock.rst:2574 msgid "" "The spec only applies to the mock itself, so we still have the same issue " "with any methods on the mock:" msgstr "" +"La especificación sólo se aplica al propio objeto simulado, por lo que aún " +"tenemos el mismo problema con cualquiera de los métodos del mismo:" #: ../Doc/library/unittest.mock.rst:2583 msgid "" @@ -2234,10 +3177,20 @@ msgid "" "complex or deeply nested objects (like modules that import modules that " "import modules) without a big performance hit." msgstr "" +"La autoespecificación resuelve este problema. Puedes pasar ``autospec=True`` " +"a :func:`patch` / :func:`patch.object` o utilizar la función :func:" +"`create_autospec` para crear un objeto simulado con una especificación. Si " +"utilizas el argumento ``autospec=True`` de :func:`patch`, el objeto que se " +"va a reemplazar se utiliza como objeto de especificación. Debido a que la " +"especificación se hace \"perezosamente\" (la especificación se crea en el " +"instante en el que se accede a los atributos del objeto simulado, no antes), " +"se puede utilizar con objetos muy complejos o anidadas (como módulos que " +"importan módulos que, a su vez, importan otros módulos) sin un gran impacto " +"en el rendimiento." #: ../Doc/library/unittest.mock.rst:2592 msgid "Here's an example of it in use::" -msgstr "" +msgstr "He aquí un ejemplo de ello en acción:" #: ../Doc/library/unittest.mock.rst:2602 msgid "" @@ -2245,12 +3198,18 @@ msgid "" "Request` takes two arguments in the constructor (one of which is *self*). " "Here's what happens if we try to call it incorrectly::" msgstr "" +"Se puede ver que :class:`request.Request` tiene una especificación. :class:" +"`request.Request` toma dos argumentos en el constructor (uno de los cuales " +"es *self*). Esto es lo que sucede si tratamos de llamarlo de forma " +"incorrecta:" #: ../Doc/library/unittest.mock.rst:2611 msgid "" "The spec also applies to instantiated classes (i.e. the return value of " "specced mocks)::" msgstr "" +"La especificación también se aplica a las clases instanciadas (es decir, el " +"valor de retorno de los objetos simulados especificados):" #: ../Doc/library/unittest.mock.rst:2618 msgid "" @@ -2259,6 +3218,11 @@ msgid "" "mock. With the spec in place any typos in our asserts will raise the correct " "error::" msgstr "" +"Los objetos de la clase :class:`Request` no son invocables, por lo que el " +"valor de retorno de una instancia de nuestro objeto simulado de :class:" +"`request.Request` no es invocable. Con la especificación, en cambio, " +"cualquier error tipográfico en nuestras aserciones generará el error " +"correcto:" #: ../Doc/library/unittest.mock.rst:2630 msgid "" @@ -2266,12 +3230,18 @@ msgid "" "existing :func:`patch` calls and then be protected against bugs due to typos " "and api changes." msgstr "" +"En muchos casos, podrás simplemente añadir ``autospec=True`` a tus llamadas :" +"func:`patch` existentes y así estar protegido contra errores tipográficos y " +"cambios de la API." #: ../Doc/library/unittest.mock.rst:2634 msgid "" "As well as using *autospec* through :func:`patch` there is a :func:" "`create_autospec` for creating autospecced mocks directly:" msgstr "" +"Además de poder usar *autospec* a través de :func:`patch`, existe la " +"función :func:`create_autospec` para crear directamente objetos simulados " +"autoespecificados:" #: ../Doc/library/unittest.mock.rst:2642 msgid "" @@ -2284,6 +3254,16 @@ msgid "" "be able to use autospec. On the other hand it is much better to design your " "objects so that introspection is safe [#]_." msgstr "" +"Sin embargo, este no es el comportamiento predeterminado, ya que no está " +"exento de advertencias y restricciones. Con el fin de conocer qué atributos " +"están disponibles en el objeto especificado, autospec tiene que hacer uso de " +"introspección sobre la especificación (acceder a los atributos). A medida " +"que recorres los atributos en el objeto simulado, se produce paralelamente y " +"de forma soterrada un recorrido del objeto original. Si alguno de tus " +"objetos especificados tienen propiedades o descriptores que puedan " +"desencadenar la ejecución de código, quizás no deberías utilizar la " +"autoespecificación. De todas formas, es siempre mucho mejor diseñar tus " +"objetos de modo que la introspección sea segura [#]_." #: ../Doc/library/unittest.mock.rst:2651 msgid "" @@ -2292,6 +3272,10 @@ msgid "" "*autospec* can't know about any dynamically created attributes and restricts " "the api to visible attributes. ::" msgstr "" +"Un problema más serio es que es común que los atributos de instancia sean " +"creados en el método :meth:`__init__` y que no existan a nivel de clase. " +"*autospec* no puede tener conocimiento de ningún atributo creado " +"dinámicamente, por lo que restringe la API a atributos visibles:" #: ../Doc/library/unittest.mock.rst:2668 msgid "" @@ -2301,6 +3285,11 @@ msgid "" "you to fetch attributes that don't exist on the spec it doesn't prevent you " "setting them::" msgstr "" +"Hay diferentes formas de resolver este problema. La forma más sencilla, pero " +"no necesariamente la menos molesta, es simplemente establecer los atributos " +"necesarios en el objeto simulado después de la creación del mismo. El hecho " +"de que *autospec* no te permita buscar atributos que no existen en la " +"especificación no impide que los establezcas manualmente después:" #: ../Doc/library/unittest.mock.rst:2679 msgid "" @@ -2309,6 +3298,10 @@ msgid "" "ensure your code only *sets* valid attributes too, but obviously it prevents " "this particular scenario:" msgstr "" +"Existe una versión más agresiva de *spec* y *autospec* que impide establecer " +"atributos inexistentes. Esto es útil si deseas asegurarte de que tu código " +"solo *establece* atributos válidos, pero obviamente evitando este escenario " +"en particular:" #: ../Doc/library/unittest.mock.rst:2692 msgid "" @@ -2318,6 +3311,12 @@ msgid "" "providing them via class attributes (shared between instances of course) is " "faster too. e.g." msgstr "" +"Probablemente la mejor manera de resolver el problema es añadir atributos de " +"clase como valores por defecto para los miembros de instancia inicializados " +"en el método :meth:`__init__`. Ten en cuenta que, si sólo estás " +"estableciendo atributos predeterminados en :meth:`__init__`, proporcionarlos " +"a través de atributos de clase (que , por supuesto, son compartidos entre " +"instancias) también es más rápido." #: ../Doc/library/unittest.mock.rst:2702 msgid "" @@ -2329,6 +3328,15 @@ msgid "" "type, autospec doesn't use a spec for members that are set to ``None``. " "These will just be ordinary mocks (well - MagicMocks):" msgstr "" +"Esto nos plantea otro problema. Es relativamente común proporcionar un valor " +"predeterminado de ``None`` para los miembros que posteriormente se " +"convertirán en objetos de un tipo diferente. ``None`` es inútil como " +"especificación dado que no permite acceder a *ningún* atributo o método. " +"Como ``None`` *nunca* será útil como especificación, y probablemente indica " +"un miembro que normalmente será de algún otro tipo en el futuro, la " +"autoespecificación no usa una especificación para aquellos miembros " +"configurados con ``None`` como valor. Estos serán simplemente objetos " +"simulados ordinarios (MagicMocks en realidad):" #: ../Doc/library/unittest.mock.rst:2717 msgid "" @@ -2340,6 +3348,14 @@ msgid "" "the spec. Thankfully :func:`patch` supports this - you can simply pass the " "alternative object as the *autospec* argument::" msgstr "" +"Si modificar tus clases en producción para agregar valores predeterminados " +"no es de tu agrado, dispones de otras opciones. Una de ellas es simplemente " +"usar una instancia como especificación en lugar de la clase. La otra es " +"crear una subclase de la clase en producción y agregar los valores " +"predeterminados a la subclase, sin afectar a la clase en producción. Ambas " +"alternativas requieren que uses un objeto alternativo como especificación. " +"Afortunadamente :func:`patch` admite esto, simplemente tienes que pasar el " +"objeto alternativo mediante el argumento *autospec*:" #: ../Doc/library/unittest.mock.rst:2738 msgid "" @@ -2347,10 +3363,14 @@ msgid "" "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 "" +"Esto sólo se aplica a las clases u objetos ya instanciados. Llamar a una " +"clase simulada para crear una instancia simulada *no* crea una instancia " +"real. Solo se llevan a cabo las búsqueda de atributos (mediante llamadas a :" +"func:`dir`)." #: ../Doc/library/unittest.mock.rst:2743 msgid "Sealing mocks" -msgstr "" +msgstr "Sellar objetos simulados" #: ../Doc/library/unittest.mock.rst:2752 msgid "" @@ -2358,6 +3378,9 @@ msgid "" "attribute of the mock being sealed or any of its attributes that are already " "mocks recursively." msgstr "" +"Seal desactivará la creación automática de objetos simulados al acceder a un " +"atributo del objeto simulado que está siendo sellado, o a cualquiera de sus " +"atributos que ya sean objetos simulados de forma recursiva." #: ../Doc/library/unittest.mock.rst:2755 msgid "" @@ -2365,3 +3388,6 @@ msgid "" "won't be considered in the sealing chain. This allows one to prevent seal " "from fixing part of the mock object. ::" msgstr "" +"Si una instancia simulada con un nombre o una especificación es asignada a " +"un atributo no será considerada en la cadena de sellado. Esto permite evitar " +"que seal fije partes del objeto simulado. ::"