ansible-core 2.18.7rc1__py3-none-any.whl → 2.19.0__py3-none-any.whl

ansible/plugins/strategy/debug.py

@@ -14,14 +14,14 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: debug
     short_description: Executes tasks in interactive debug session.
     description:
         - Task execution is 'linear' but controlled by an interactive debug session.
     version_added: "2.1"
     author: Kishin Yagami (!UNKNOWN)
-'''
+"""
 
 from ansible.plugins.strategy.linear import StrategyModule as LinearStrategyModule
 

ansible/plugins/strategy/free.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: free
     short_description: Executes tasks without waiting for all hosts
     description:
@@ -27,7 +27,7 @@ DOCUMENTATION = '''
           won't hold up the rest of the hosts and tasks.
     version_added: "2.0"
     author: Ansible Core Team
-'''
+"""
 
 import time
 
@@ -37,8 +37,7 @@ from ansible.playbook.handler import Handler
 from ansible.playbook.included_file import IncludedFile
 from ansible.plugins.loader import action_loader
 from ansible.plugins.strategy import StrategyBase
-from ansible.template import Templar
-from ansible.module_utils.common.text.converters import to_text
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
 
 display = Display()
@@ -54,7 +53,7 @@ class StrategyModule(StrategyBase):
         self._host_pinned = False
 
     def run(self, iterator, play_context):
-        '''
+        """
         The "free" strategy is a bit more complex, in that it allows tasks to
         be sent to hosts as quickly as they can be processed. This means that
         some hosts may finish very quickly if run tasks result in little or no
@@ -65,7 +64,7 @@ class StrategyModule(StrategyBase):
         and starting the search from there as opposed to the top of the hosts
         list again, which would end up favoring hosts near the beginning of the
         list.
-        '''
+        """
 
         # the last host to be given a task
         last_host = 0
@@ -124,13 +123,13 @@ class StrategyModule(StrategyBase):
                                                                     _hosts=self._hosts_cache,
                                                                     _hosts_all=self._hosts_cache_all)
                         self.add_tqm_variables(task_vars, play=iterator._play)
-                        templar = Templar(loader=self._loader, variables=task_vars)
+                        templar = TemplateEngine(loader=self._loader, variables=task_vars)
                         display.debug("done getting variables", host=host_name)
 
                         try:
                             throttle = int(templar.template(task.throttle))
-                        except Exception as e:
-                            raise AnsibleError("Failed to convert the throttle value to an integer.", obj=task._ds, orig_exc=e)
+                        except Exception as ex:
+                            raise AnsibleError("Failed to convert the throttle value to an integer.", obj=task.throttle) from ex
 
                         if throttle > 0:
                             same_tasks = 0
@@ -155,13 +154,7 @@ class StrategyModule(StrategyBase):
                             # corresponding action plugin
                             action = None
 
-                        try:
-                            task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
-                            display.debug("done templating", host=host_name)
-                        except Exception:
-                            # just ignore any errors during task name templating,
-                            # we don't care if it just shows the raw name
-                            display.debug("templating failed for some reason", host=host_name)
+                        task.post_validate_attribute("name", templar=templar)
 
                         run_once = templar.template(task.run_once) or action and getattr(action, 'BYPASS_HOST_LOOP', False)
                         if run_once:
@@ -172,15 +165,6 @@ class StrategyModule(StrategyBase):
                                 display.warning("Using run_once with the free strategy is not currently supported. This task will still be "
                                                 "executed for every host in the inventory list.")
 
-                        # check to see if this task should be skipped, due to it being a member of a
-                        # role which has already run (and whether that role allows duplicate execution)
-                        if not isinstance(task, Handler) and task._role:
-                            role_obj = self._get_cached_role(task, iterator._play)
-                            if role_obj.has_run(host) and task._role._metadata.allow_duplicates is False:
-                                display.debug("'%s' skipped because role has already run" % task, host=host_name)
-                                del self._blocked_hosts[host_name]
-                                continue
-
                         if task.action in C._ACTION_META:
                             if self._host_pinned:
                                 meta_task_dummy_results_count += 1
@@ -264,14 +248,15 @@ class StrategyModule(StrategyBase):
                         iterator.handlers = [h for b in iterator._play.handlers for h in b.block]
                     except AnsibleParserError:
                         raise
-                    except AnsibleError as e:
-                        display.error(to_text(e), wrap_text=False)
+                    except AnsibleError as ex:
+                        # FIXME: send the error to the callback; don't directly write to display here
+                        display.error(ex)
                         for r in included_file._results:
-                            r._result['failed'] = True
-                            r._result['reason'] = str(e)
-                            self._tqm._stats.increment('failures', r._host.name)
+                            r._return_data['failed'] = True
+                            r._return_data['reason'] = str(ex)
+                            self._tqm._stats.increment('failures', r.host.name)
                             self._tqm.send_callback('v2_runner_on_failed', r)
-                            failed_includes_hosts.add(r._host)
+                            failed_includes_hosts.add(r.host)
                         continue
                     else:
                         # since we skip incrementing the stats when the task result is

ansible/plugins/strategy/host_pinned.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: host_pinned
     short_description: Executes tasks on each host without interruption
     description:
@@ -28,7 +28,7 @@ DOCUMENTATION = '''
           Other than that, it behaves just like the "free" strategy.
     version_added: "2.7"
     author: Ansible Core Team
-'''
+"""
 
 from ansible.plugins.strategy.free import StrategyModule as FreeStrategyModule
 from ansible.utils.display import Display

ansible/plugins/strategy/linear.py

@@ -16,7 +16,7 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import annotations
 
-DOCUMENTATION = '''
+DOCUMENTATION = """
     name: linear
     short_description: Executes tasks in a linear fashion
     description:
@@ -27,29 +27,34 @@ DOCUMENTATION = '''
     notes:
      - This was the default Ansible behaviour before 'strategy plugins' were introduced in 2.0.
     author: Ansible Core Team
-'''
+"""
 
 from ansible import constants as C
-from ansible.errors import AnsibleError, AnsibleAssertionError, AnsibleParserError
-from ansible.module_utils.common.text.converters import to_text
+from ansible.errors import AnsibleError, AnsibleAssertionError, AnsibleParserError, AnsibleValueOmittedError
 from ansible.playbook.handler import Handler
 from ansible.playbook.included_file import IncludedFile
 from ansible.plugins.loader import action_loader
 from ansible.plugins.strategy import StrategyBase
-from ansible.template import Templar
+from ansible._internal._templating._engine import TemplateEngine
 from ansible.utils.display import Display
+from ansible.inventory.host import Host
+from ansible.playbook.task import Task
+from ansible.executor.play_iterator import PlayIterator
+from ansible.playbook.play_context import PlayContext
+from ansible.executor import task_result as _task_result
 
 display = Display()
 
 
 class StrategyModule(StrategyBase):
 
-    def _get_next_task_lockstep(self, hosts, iterator):
-        '''
+    def _get_next_task_lockstep(self, hosts: list[Host], iterator: PlayIterator) -> list[tuple[Host, Task]]:
+        """
         Returns a list of (host, task) tuples, where the task may
         be a noop task to keep the iterator in lock step across
         all hosts.
-        '''
+        """
+
         state_task_per_host = {}
         for host in hosts:
             state, task = iterator.get_next_task_for_host(host, peek=True)
@@ -84,20 +89,20 @@ class StrategyModule(StrategyBase):
                 iterator.set_state_for_host(host.name, state)
                 host_tasks.append((host, task))
 
-        if cur_task.action in C._ACTION_META and cur_task.args.get('_raw_params') == 'flush_handlers':
+        if cur_task._get_meta() == 'flush_handlers':
             iterator.all_tasks[iterator.cur_task:iterator.cur_task] = [h for b in iterator._play.handlers for h in b.block]
 
         return host_tasks
 
-    def run(self, iterator, play_context):
-        '''
+    def run(self, iterator, play_context: PlayContext):  # type: ignore[override]
+        """
         The linear strategy is simple - get the next task and queue
         it for all hosts, then wait for the queue to drain before
         moving on to the next task
-        '''
+        """
 
         # iterate over each task, while there is one left to run
-        result = self._tqm.RUN_OK
+        result = int(self._tqm.RUN_OK)
         work_to_do = True
 
         self._set_hosts_cache(iterator._play)
@@ -122,7 +127,7 @@ class StrategyModule(StrategyBase):
                 # flag set if task is set to any_errors_fatal
                 any_errors_fatal = False
 
-                results = []
+                results: list[_task_result._RawTaskResult] = []
                 for (host, task) in host_tasks:
                     if self._tqm._terminated:
                         break
@@ -130,26 +135,23 @@ class StrategyModule(StrategyBase):
                     run_once = False
                     work_to_do = True
 
-                    # check to see if this task should be skipped, due to it being a member of a
-                    # role which has already run (and whether that role allows duplicate execution)
-                    if not isinstance(task, Handler) and task._role:
-                        role_obj = self._get_cached_role(task, iterator._play)
-                        if role_obj.has_run(host) and task._role._metadata.allow_duplicates is False:
-                            display.debug("'%s' skipped because role has already run" % task)
-                            continue
+                    host_name = host.get_name()
 
                     display.debug("getting variables")
                     task_vars = self._variable_manager.get_vars(play=iterator._play, host=host, task=task,
                                                                 _hosts=self._hosts_cache, _hosts_all=self._hosts_cache_all)
                     self.add_tqm_variables(task_vars, play=iterator._play)
-                    templar = Templar(loader=self._loader, variables=task_vars)
+                    templar = TemplateEngine(loader=self._loader, variables=task_vars)
                     display.debug("done getting variables")
 
                     # test to see if the task across all hosts points to an action plugin which
                     # sets BYPASS_HOST_LOOP to true, or if it has run_once enabled. If so, we
                     # will only send this task to the first host in the list.
 
-                    task_action = templar.template(task.action)
+                    try:
+                        task_action = templar.template(task.action)
+                    except AnsibleValueOmittedError:
+                        raise AnsibleParserError("Omit is not valid for the `action` keyword.", obj=task.action) from None
 
                     try:
                         action = action_loader.get(task_action, class_only=True, collection_list=task.collections)
@@ -162,7 +164,7 @@ class StrategyModule(StrategyBase):
                         # for the linear strategy, we run meta tasks just once and for
                         # all hosts currently being iterated over rather than one host
                         results.extend(self._execute_meta(task, play_context, iterator, host))
-                        if task.args.get('_raw_params', None) not in ('noop', 'reset_connection', 'end_host', 'role_complete', 'flush_handlers', 'end_role'):
+                        if task._get_meta() not in ('noop', 'reset_connection', 'end_host', 'role_complete', 'flush_handlers', 'end_role'):
                             run_once = True
                         if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                             any_errors_fatal = True
@@ -176,22 +178,20 @@ class StrategyModule(StrategyBase):
                                 break
 
                         run_once = action and getattr(action, 'BYPASS_HOST_LOOP', False) or templar.template(task.run_once)
-                        try:
-                            task.name = to_text(templar.template(task.name, fail_on_undefined=False), nonstring='empty')
-                        except Exception as e:
-                            display.debug(f"Failed to templalte task name ({task.name}), ignoring error and continuing: {e}")
 
                         if (task.any_errors_fatal or run_once) and not task.ignore_errors:
                             any_errors_fatal = True
 
                         if not callback_sent:
+                            task.post_validate_attribute("name", templar=templar)
+
                             if isinstance(task, Handler):
                                 self._tqm.send_callback('v2_playbook_on_handler_task_start', task)
                             else:
                                 self._tqm.send_callback('v2_playbook_on_task_start', task, is_conditional=False)
                             callback_sent = True
 
-                        self._blocked_hosts[host.get_name()] = True
+                        self._blocked_hosts[host_name] = True
                         self._queue_task(host, task, task_vars, play_context)
                         del task_vars
 
@@ -283,14 +283,15 @@ class StrategyModule(StrategyBase):
                             display.debug("done iterating over new_blocks loaded from include file")
                         except AnsibleParserError:
                             raise
-                        except AnsibleError as e:
-                            display.error(to_text(e), wrap_text=False)
+                        except AnsibleError as ex:
+                            # FIXME: send the error to the callback; don't directly write to display here
+                            display.error(ex)
                             for r in included_file._results:
-                                r._result['failed'] = True
-                                r._result['reason'] = str(e)
-                                self._tqm._stats.increment('failures', r._host.name)
+                                r._return_data['failed'] = True
+                                r._return_data['reason'] = str(ex)
+                                self._tqm._stats.increment('failures', r.host.name)
                                 self._tqm.send_callback('v2_runner_on_failed', r)
-                                failed_includes_hosts.add(r._host)
+                                failed_includes_hosts.add(r.host)
                         else:
                             # since we skip incrementing the stats when the task result is
                             # first processed, we do so now for each host in the list
@@ -321,9 +322,9 @@ class StrategyModule(StrategyBase):
                 unreachable_hosts = []
                 for res in results:
                     if res.is_failed():
-                        failed_hosts.append(res._host.name)
+                        failed_hosts.append(res.host.name)
                     elif res.is_unreachable():
-                        unreachable_hosts.append(res._host.name)
+                        unreachable_hosts.append(res.host.name)
 
                 if any_errors_fatal and (failed_hosts or unreachable_hosts):
                     for host in hosts_left:
@@ -355,10 +356,9 @@ class StrategyModule(StrategyBase):
                     return result
                 display.debug("done checking to see if all hosts have failed")
 
-            except (IOError, EOFError) as e:
-                display.debug("got IOError/EOFError in task loop: %s" % e)
-                # most likely an abort, return failed
-                return self._tqm.RUN_UNKNOWN_ERROR
+            finally:
+                # removed unnecessary exception handler, don't want to mis-attribute the entire code block by changing indentation
+                pass
 
         # run the base class run() method, which executes the cleanup function
         # and runs any outstanding handlers which have been triggered

ansible/plugins/terminal/__init__.py

@@ -26,7 +26,7 @@ from ansible.errors import AnsibleConnectionFailure
 
 
 class TerminalBase(ABC):
-    '''
+    """
     A base class for implementing cli connections
 
     .. note:: Unlike most of Ansible, nearly all strings in
@@ -36,7 +36,7 @@ class TerminalBase(ABC):
         :func:`~ansible.module_utils.common.text.converters.to_bytes` and
         :func:`~ansible.module_utils.common.text.converters.to_text` to avoid unexpected
         problems.
-    '''
+    """
 
     #: compiled bytes regular expressions as stdout
     terminal_stdout_re = []  # type: list[re.Pattern]
@@ -64,11 +64,11 @@ class TerminalBase(ABC):
         self._connection = connection
 
     def _exec_cli_command(self, cmd, check_rc=True):
-        '''
+        """
         Executes the CLI command on the remote device and returns the output
 
         :arg cmd: Byte string command to be executed
-        '''
+        """
         return self._connection.exec_command(cmd)
 
     def _get_prompt(self):

ansible/plugins/test/__init__.py

@@ -3,10 +3,15 @@
 
 from __future__ import annotations
 
+import typing as t
+
 from ansible.plugins import AnsibleJinja2Plugin
 
 
 class AnsibleJinja2Test(AnsibleJinja2Plugin):
+    @property
+    def plugin_type(self) -> str:
+        return "test"
 
-    def _no_options(self, *args, **kwargs):
-        raise NotImplementedError("Jinaj2 test plugins do not support option functions, they use direct arguments instead.")
+    def _no_options(self, *args, **kwargs) -> t.NoReturn:
+        raise NotImplementedError("Jinja2 test plugins do not support option functions, they use direct arguments instead.")

ansible/plugins/test/core.py

@@ -17,17 +17,22 @@
 
 from __future__ import annotations
 
+import functools
 import re
 import operator as py_operator
 
 from collections.abc import MutableMapping, MutableSequence
 
+from jinja2.tests import test_defined, test_undefined
+
 from ansible.module_utils.compat.version import LooseVersion, StrictVersion
 
 from ansible import errors
 from ansible.module_utils.common.text.converters import to_native, to_text, to_bytes
+from ansible._internal._templating._jinja_common import Marker, UndefinedMarker
 from ansible.module_utils.parsing.convert_bool import boolean
-from ansible.parsing.vault import is_encrypted_file
+from ansible.template import accept_args_markers
+from ansible.parsing.vault import is_encrypted_file, VaultHelper, VaultLib
 from ansible.utils.display import Display
 from ansible.utils.version import SemanticVersion
 
@@ -41,40 +46,44 @@ display = Display()
 
 
 def timedout(result):
-    ''' Test if task result yields a time out'''
+    """ Test if task result yields a time out"""
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'timedout' test expects a dictionary")
-    return result.get('timedout', False) and result['timedout'].get('period', False)
+
+    return bool(result.get('timedout') and bool(result['timedout'].get('period')))
 
 
 def failed(result):
-    ''' Test if task result yields failed '''
+    """ Test if task result yields failed """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'failed' test expects a dictionary")
-    return result.get('failed', False)
+
+    return bool(result.get('failed'))
 
 
 def success(result):
-    ''' Test if task result yields success '''
-    return not failed(result)
+    """ Test if task result yields success """
+    return not bool(failed(result))
 
 
 def unreachable(result):
-    ''' Test if task result yields unreachable '''
+    """ Test if task result yields unreachable """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'unreachable' test expects a dictionary")
-    return result.get('unreachable', False)
+
+    return bool(result.get('unreachable'))
 
 
 def reachable(result):
-    ''' Test if task result yields reachable '''
-    return not unreachable(result)
+    """ Test if task result yields reachable """
+    return bool(not unreachable(result))
 
 
 def changed(result):
-    ''' Test if task result yields changed '''
+    """ Test if task result yields changed """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'changed' test expects a dictionary")
+
     if 'changed' not in result:
         changed = False
         if (
@@ -83,29 +92,31 @@ def changed(result):
             isinstance(result['results'][0], MutableMapping)
         ):
             for res in result['results']:
-                if res.get('changed', False):
+                if res.get('changed'):
                     changed = True
                     break
     else:
-        changed = result.get('changed', False)
-    return changed
+        changed = result.get('changed')
+
+    return bool(changed)
 
 
 def skipped(result):
-    ''' Test if task result yields skipped '''
+    """ Test if task result yields skipped """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'skipped' test expects a dictionary")
-    return result.get('skipped', False)
+
+    return bool(result.get('skipped'))
 
 
 def started(result):
-    ''' Test if async task has started '''
+    """ Test if async task has started """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'started' test expects a dictionary")
+
     if 'started' in result:
         # For async tasks, return status
-        # NOTE: The value of started is 0 or 1, not False or True :-/
-        return result.get('started', 0) == 1
+        return bool(result.get('started'))
     else:
         # For non-async tasks, warn user, but return as if started
         display.warning("The 'started' test expects an async task, but a non-async task was tested")
@@ -113,13 +124,13 @@ def started(result):
 
 
 def finished(result):
-    ''' Test if async task has finished '''
+    """ Test if async task has finished """
     if not isinstance(result, MutableMapping):
         raise errors.AnsibleFilterError("The 'finished' test expects a dictionary")
+
     if 'finished' in result:
         # For async tasks, return status
-        # NOTE: The value of finished is 0 or 1, not False or True :-/
-        return result.get('finished', 0) == 1
+        return bool(result.get('finished'))
     else:
         # For non-async tasks, warn user, but return as if finished
         display.warning("The 'finished' test expects an async task, but a non-async task was tested")
@@ -127,12 +138,10 @@ def finished(result):
 
 
 def regex(value='', pattern='', ignorecase=False, multiline=False, match_type='search'):
-    ''' Expose `re` as a boolean filter using the `search` method by default.
+    """ Expose `re` as a boolean filter using the `search` method by default.
         This is likely only useful for `search` and `match` which already
         have their own filters.
-    '''
-    # In addition to ensuring the correct type, to_text here will ensure
-    # _fail_with_undefined_error happens if the value is Undefined
+    """
     value = to_text(value, errors='surrogate_or_strict')
     flags = 0
     if ignorecase:
@@ -143,12 +152,19 @@ def regex(value='', pattern='', ignorecase=False, multiline=False, match_type='s
     return bool(getattr(_re, match_type, 'search')(value))
 
 
-def vault_encrypted(value):
+@accept_args_markers
+def vault_encrypted(value: object) -> bool:
     """Evaluate whether a variable is a single vault encrypted value
 
     .. versionadded:: 2.10
     """
-    return getattr(value, '__ENCRYPTED__', False) and value.is_encrypted()
+    if ciphertext := VaultHelper.get_ciphertext(value, with_tags=False):
+        return VaultLib.is_encrypted(ciphertext)
+
+    if isinstance(value, Marker):
+        value.trip()
+
+    return False
 
 
 def vaulted_file(value):
@@ -159,22 +175,22 @@ def vaulted_file(value):
     try:
         with open(to_bytes(value), 'rb') as f:
             return is_encrypted_file(f)
-    except (OSError, IOError) as e:
-        raise errors.AnsibleFilterError(f"Cannot test if the file {value} is a vault", orig_exc=e)
+    except OSError as ex:
+        raise errors.AnsibleFilterError(f"Cannot test if the file {value!r} is a vault.") from ex
 
 
 def match(value, pattern='', ignorecase=False, multiline=False):
-    ''' Perform a `re.match` returning a boolean '''
+    """ Perform a `re.match` returning a boolean """
     return regex(value, pattern, ignorecase, multiline, 'match')
 
 
 def search(value, pattern='', ignorecase=False, multiline=False):
-    ''' Perform a `re.search` returning a boolean '''
+    """ Perform a `re.search` returning a boolean """
     return regex(value, pattern, ignorecase, multiline, 'search')
 
 
 def version_compare(value, version, operator='eq', strict=None, version_type=None):
-    ''' Perform a version comparison on a value '''
+    """ Perform a version comparison on a value """
     op_map = {
         '==': 'eq', '=': 'eq', 'eq': 'eq',
         '<': 'lt', 'lt': 'lt',
@@ -257,8 +273,28 @@ def falsy(value, convert_bool=False):
     return not truthy(value, convert_bool=convert_bool)
 
 
+@accept_args_markers
+@functools.wraps(test_defined)
+def wrapped_test_defined(value: object) -> Marker | bool:
+    """Wrapper around Jinja's `defined` test to avoid mutating the externally-owned function with our marker attribute."""
+    if isinstance(value, Marker) and not isinstance(value, UndefinedMarker):
+        return value
+
+    return test_defined(value)
+
+
+@accept_args_markers
+@functools.wraps(test_undefined)
+def wrapped_test_undefined(value: object) -> Marker | bool:
+    """Wrapper around Jinja's `undefined` test to avoid mutating the externally-owned function with our marker attribute."""
+    if isinstance(value, Marker) and not isinstance(value, UndefinedMarker):
+        return value
+
+    return test_undefined(value)
+
+
 class TestModule(object):
-    ''' Ansible core jinja2 tests '''
+    """ Ansible core jinja2 tests """
 
     def tests(self):
         return {
@@ -304,4 +340,8 @@ class TestModule(object):
             # vault
             'vault_encrypted': vault_encrypted,
             'vaulted_file': vaulted_file,
+
+            # overrides that require special arg handling
+            'defined': wrapped_test_defined,
+            'undefined': wrapped_test_undefined,
         }

ansible/plugins/test/files.py

@@ -21,7 +21,7 @@ from os.path import isdir, isfile, isabs, exists, lexists, islink, samefile, ism
 
 
 class TestModule(object):
-    ''' Ansible file jinja2 tests '''
+    """ Ansible file jinja2 tests """
 
     def tests(self):
         return {

ansible/plugins/test/finished.yml

@@ -5,7 +5,7 @@ DOCUMENTATION:
   short_description: Did async task finish
   description:
     - Used to test if an async task has finished, it will also work with normal tasks but will issue a warning.
-    - This test checks for the existence of a C(finished) key in the input dictionary and that it is V(1) if present
+    - This test checks for the existence of a C(finished) key in the input dictionary and that it is V(True) if present
   options:
     _input:
       description: registered result from an Ansible task