robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/message.py

@@ -13,12 +13,18 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import html_escape
+from datetime import datetime
+from typing import Literal
+
+from robot.utils import html_escape, setter
 
 from .body import BodyItem
 from .itemlist import ItemList
 
 
+MessageLevel = Literal['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FAIL', 'SKIP']
+
+
 class Message(BodyItem):
     """A message created during the test execution.
 
@@ -27,22 +33,25 @@ class Message(BodyItem):
     """
     type = BodyItem.MESSAGE
     repr_args = ('message', 'level')
-    __slots__ = ['message', 'level', 'html', 'timestamp']
+    __slots__ = ['message', 'level', 'html', '_timestamp']
 
-    def __init__(self, message='', level='INFO', html=False, timestamp=None, parent=None):
-        #: The message content as a string.
+    def __init__(self, message: str = '',
+                 level: MessageLevel = 'INFO',
+                 html: bool = False,
+                 timestamp: 'datetime|str|None' = None,
+                 parent: 'BodyItem|None' = None):
         self.message = message
-        #: Severity of the message. Either ``TRACE``, ``DEBUG``, ``INFO``,
-        #: ``WARN``, ``ERROR``, ``FAIL`` or ``SKIP`. The last two are only used
-        #: with keyword failure messages.
         self.level = level
-        #: ``True`` if the content is in HTML, ``False`` otherwise.
         self.html = html
-        #: Timestamp in format ``%Y%m%d %H:%M:%S.%f``.
         self.timestamp = timestamp
-        #: The object this message was triggered by.
         self.parent = parent
 
+    @setter
+    def timestamp(self, timestamp: 'datetime|str|None') -> 'datetime|None':
+        if isinstance(timestamp, str):
+            return datetime.fromisoformat(timestamp)
+        return timestamp
+
     @property
     def html_message(self):
         """Returns the message content as HTML."""

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/modelobject.py

@@ -35,6 +35,9 @@ class ModelObject(metaclass=SetterAwareType):
         """Create this object based on data in a dictionary.
 
         Data can be got from the :meth:`to_dict` method or created externally.
+
+        With ``robot.running`` model objects new in Robot Framework 6.1,
+        with ``robot.result`` new in Robot Framework 7.0.
         """
         try:
             return cls().config(**data)
@@ -49,7 +52,7 @@ class ModelObject(metaclass=SetterAwareType):
         The data is given as the ``source`` parameter. It can be:
 
         - a string (or bytes) containing the data directly,
-        - an open file object where to read the data, or
+        - an open file object where to read the data from, or
         - a path (``pathlib.Path`` or string) to a UTF-8 encoded file to read.
 
         The JSON data is first converted to a Python dictionary and the object
@@ -58,6 +61,9 @@ class ModelObject(metaclass=SetterAwareType):
         Notice that the ``source`` is considered to be JSON data if it is
         a string and contains ``{``. If you need to use ``{`` in a file system
         path, pass it in as a ``pathlib.Path`` instance.
+
+        With ``robot.running`` model objects new in Robot Framework 6.1,
+        with ``robot.result`` new in Robot Framework 7.0.
         """
         try:
             data = JsonLoader().load(source)
@@ -69,6 +75,9 @@ class ModelObject(metaclass=SetterAwareType):
         """Serialize this object into a dictionary.
 
         The object can be later restored by using the :meth:`from_dict` method.
+
+        With ``robot.running`` model objects new in Robot Framework 6.1,
+        with ``robot.result`` new in Robot Framework 7.0.
         """
         raise NotImplementedError
 
@@ -84,7 +93,7 @@ class ModelObject(metaclass=SetterAwareType):
 
     def to_json(self, file: 'None|TextIO|Path|str' = None, *,
                 ensure_ascii: bool = False, indent: int = 0,
-                separators: 'tuple[str, str]' = (',', ':')) -> 'None|str':
+                separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
         """Serialize this object into JSON.
 
         The object is first converted to a Python dictionary using the
@@ -94,7 +103,7 @@ class ModelObject(metaclass=SetterAwareType):
         It can be:
 
         - ``None`` (default) to return the data as a string,
-        - an open file object where to write the data, or
+        - an open file object where to write the data to, or
         - a path (``pathlib.Path`` or string) to a file where to write
           the data using UTF-8 encoding.
 
@@ -102,6 +111,9 @@ class ModelObject(metaclass=SetterAwareType):
         are passed directly to the underlying json__ module. Notice that
         the defaults differ from what ``json`` uses.
 
+        With ``robot.running`` model objects new in Robot Framework 6.1,
+        with ``robot.result`` new in Robot Framework 7.0.
+
         __ https://docs.python.org/3/library/json.html
         """
         return JsonDumper(ensure_ascii=ensure_ascii, indent=indent,
@@ -150,10 +162,7 @@ class ModelObject(metaclass=SetterAwareType):
 
         __ https://docs.python.org/3/library/copy.html
         """
-        copied = copy.copy(self)
-        for name in attributes:
-            setattr(copied, name, attributes[name])
-        return copied
+        return copy.copy(self).config(**attributes)
 
     def deepcopy(self: T, **attributes) -> T:
         """Return a deep copy of this object.
@@ -167,20 +176,23 @@ class ModelObject(metaclass=SetterAwareType):
 
         __ https://docs.python.org/3/library/copy.html
         """
-        copied = copy.deepcopy(self)
-        for name in attributes:
-            setattr(copied, name, attributes[name])
-        return copied
+        return copy.deepcopy(self).config(**attributes)
 
     def __repr__(self) -> str:
-        arguments = [(name, getattr(self, name)) for name in self.repr_args]
-        args_repr = ', '.join(f'{name}={value!r}' for name, value in arguments
-                              if self._include_in_repr(name, value))
-        return f"{full_name(self)}({args_repr})"
+        args = []
+        for name in self.repr_args:
+            value = getattr(self, name)
+            if self._include_in_repr(name, value):
+                value = self._repr_format(name, value)
+                args.append(f'{name}={value}')
+        return f"{full_name(self)}({', '.join(args)})"
 
     def _include_in_repr(self, name: str, value: Any) -> bool:
         return True
 
+    def _repr_format(self, name: str, value: Any) -> str:
+        return repr(value)
+
 
 def full_name(obj_or_cls):
     cls = type(obj_or_cls) if not isinstance(obj_or_cls, type) else obj_or_cls

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/modifier.py

@@ -35,7 +35,7 @@ class ModelModifier(SuiteVisitor):
                 message, details = get_error_details()
                 self._log_error(f"Executing model modifier '{type_name(visitor)}' "
                                 f"failed: {message}\n{details}")
-        if not (suite.test_count or self._empty_suite_ok):
+        if not (suite.has_tests or self._empty_suite_ok):
             raise DataError(f"Suite '{suite.name}' contains no tests after "
                             f"model modifiers.")
 

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/namepatterns.py

@@ -23,15 +23,9 @@ class NamePatterns(Iterable[str]):
     def __init__(self, patterns: Sequence[str] = (), ignore: Sequence[str] = '_'):
         self.matcher = MultiMatcher(patterns, ignore)
 
-    def match(self, name: str, longname: 'str|None' = None) -> bool:
-        return bool(self._match(name) or
-                    longname and self._match_longname(longname))
-
-    def _match(self, name: str) -> bool:
-        return self.matcher.match(name)
-
-    def _match_longname(self, name: str) -> bool:
-        raise NotImplementedError
+    def match(self, name: str, full_name: 'str|None' = None) -> bool:
+        match = self.matcher.match
+        return bool(match(name) or full_name and match(full_name))
 
     def __bool__(self) -> bool:
         return bool(self.matcher)
@@ -39,19 +33,3 @@ class NamePatterns(Iterable[str]):
     def __iter__(self) -> Iterator[str]:
         for matcher in self.matcher:
             yield matcher.pattern
-
-
-class SuiteNamePatterns(NamePatterns):
-
-    def _match_longname(self, name):
-        while '.' in name:
-            if self._match(name):
-                return True
-            name = name.split('.', 1)[1]
-        return False
-
-
-class TestNamePatterns(NamePatterns):
-
-    def _match_longname(self, name):
-        return self._match(name)

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/stats.py

@@ -13,6 +13,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from datetime import timedelta
+
 from robot.utils import (Sortable, elapsed_time_to_string, html_escape,
                          is_string, normalize)
 
@@ -31,14 +33,10 @@ class Stat(Sortable):
         #: or name of the tag for
         #: :class:`~robot.model.tagstatistics.TagStatistics`
         self.name = name
-        #: Number of passed tests.
         self.passed = 0
-        #: Number of failed tests.
         self.failed = 0
-        #: Number of skipped tests.
         self.skipped = 0
-        #: Number of milliseconds it took to execute.
-        self.elapsed = 0
+        self.elapsed = timedelta()
         self._norm_name = normalize(name, ignore='_')
 
     def get_attributes(self, include_label=False, include_elapsed=False,
@@ -49,8 +47,7 @@ class Stat(Sortable):
         if include_label:
             attrs['label'] = self.name
         if include_elapsed:
-            attrs['elapsed'] = elapsed_time_to_string(self.elapsed,
-                                                      include_millis=False)
+            attrs['elapsed'] = elapsed_time_to_string(self.elapsed, include_millis=False)
         if exclude_empty:
             attrs = dict((k, v) for k, v in attrs.items() if v not in ('', None))
         if values_as_strings:
@@ -83,7 +80,7 @@ class Stat(Sortable):
             self.failed += 1
 
     def _update_elapsed(self, test):
-        self.elapsed += test.elapsedtime
+        self.elapsed += test.elapsed_time
 
     @property
     def _sort_key(self):
@@ -106,12 +103,9 @@ class SuiteStat(Stat):
     type = 'suite'
 
     def __init__(self, suite):
-        Stat.__init__(self, suite.longname)
-        #: Identifier of the suite, e.g. `s1-s2`.
+        super().__init__(suite.full_name)
         self.id = suite.id
-        #: Number of milliseconds it took to execute this suite,
-        #: including sub-suites.
-        self.elapsed = suite.elapsedtime
+        self.elapsed = suite.elapsed_time
         self._name = suite.name
 
     def _get_custom_attrs(self):
@@ -131,7 +125,7 @@ class TagStat(Stat):
     type = 'tag'
 
     def __init__(self, name, doc='', links=None, combined=None):
-        Stat.__init__(self, name)
+        super().__init__(name)
         #: Documentation of tag as a string.
         self.doc = doc
         #: List of tuples in which the first value is the link URL and
@@ -164,7 +158,7 @@ class TagStat(Stat):
 class CombinedTagStat(TagStat):
 
     def __init__(self, pattern, name=None, doc='', links=None):
-        TagStat.__init__(self, name or pattern, doc, links, combined=pattern)
+        super().__init__(name or pattern, doc, links, combined=pattern)
         self.pattern = TagPattern.from_string(pattern)
 
     def match(self, tags):

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/tags.py

@@ -105,7 +105,7 @@ class Tags(Sequence[str]):
 
 class TagPatterns(Sequence['TagPattern']):
 
-    def __init__(self, patterns: Iterable[str]):
+    def __init__(self, patterns: Iterable[str] = ()):
         self._patterns = tuple(TagPattern.from_string(p) for p in Tags(patterns))
 
     def match(self, tags: Iterable[str]) -> bool:

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/testcase.py

@@ -13,7 +13,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from pathlib import Path
 from typing import Any, Generic, Sequence, Type, TYPE_CHECKING, TypeVar
 
@@ -22,7 +21,7 @@ from robot.utils import setter
 from .body import Body, BodyItem
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
+from .keyword import Keyword
 from .modelobject import DataDict, ModelObject
 from .tags import Tags
 
@@ -35,7 +34,7 @@ TC = TypeVar('TC', bound='TestCase')
 KW = TypeVar('KW', bound='Keyword', covariant=True)
 
 
-class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else object):
+class TestCase(ModelObject, Generic[KW]):
     """Base model for a single test case.
 
     Extended by :class:`robot.running.model.TestCase` and
@@ -43,16 +42,16 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
     """
     body_class = Body
     # See model.TestSuite on removing the type ignore directive
-    fixture_class: Type[KW] = Keyword # type: ignore
+    fixture_class: Type[KW] = Keyword    # type: ignore
     repr_args = ('name',)
     __slots__ = ['parent', 'name', 'doc', 'timeout', 'lineno', '_setup', '_teardown']
 
     def __init__(self, name: str = '',
                  doc: str = '',
-                 tags: Sequence[str] = (),
+                 tags: 'Tags|Sequence[str]' = (),
                  timeout: 'str|None' = None,
                  lineno: 'int|None' = None,
-                 parent: 'TestSuite|None' = None):
+                 parent: 'TestSuite[KW, TestCase[KW]]|None' = None):
         self.name = name
         self.doc = doc
         self.tags = tags
@@ -69,7 +68,7 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return self.body_class(self, body)
 
     @setter
-    def tags(self, tags: Sequence[str]) -> Tags:
+    def tags(self, tags: 'Tags|Sequence[str]') -> Tags:
         """Test tags as a :class:`~.model.tags.Tags` object."""
         return Tags(tags)
 
@@ -121,7 +120,7 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return bool(self._setup)
 
     @property
-    def teardown(self) -> Keyword:
+    def teardown(self) -> KW:
         """Test teardown as a :class:`~.model.keyword.Keyword` object.
 
         See :attr:`setup` for more information.
@@ -144,19 +143,6 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         """
         return bool(self._teardown)
 
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0
-
-        Use :attr:`body`, :attr:`setup` or :attr:`teardown` instead.
-        """
-        keywords = [self.setup] + list(self.body) + [self.teardown]
-        return Keywords(self, [kw for kw in keywords if kw])
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     @property
     def id(self) -> str:
         """Test case id in format like ``s1-t3``.
@@ -171,11 +157,16 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         return f'{self.parent.id}-t{index + 1}'
 
     @property
-    def longname(self) -> str:
-        """Test name prefixed with the long name of the parent suite."""
+    def full_name(self) -> str:
+        """Test name prefixed with the full name of the parent suite."""
         if not self.parent:
             return self.name
-        return f'{self.parent.longname}.{self.name}'
+        return f'{self.parent.full_name}.{self.name}'
+
+    @property
+    def longname(self) -> str:
+        """Deprecated since Robot Framework 7.0. Use :attr:`full_name` instead."""
+        return self.full_name
 
     @property
     def source(self) -> 'Path|None':
@@ -185,9 +176,6 @@ class TestCase(ModelObject, Generic[KW] if sys.version_info >= (3, 7) else objec
         """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
         visitor.visit_test(self)
 
-    def __str__(self) -> str:
-        return self.name
-
     def to_dict(self) -> 'dict[str, Any]':
         data: 'dict[str, Any]' = {'name': self.name}
         if self.doc:

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/testsuite.py

@@ -13,18 +13,18 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any, Generic, Iterator, Sequence, Type, TypeVar
 
+from robot.errors import DataError
 from robot.utils import seq2str, setter
 
 from .configurer import SuiteConfigurer
 from .filter import Filter, EmptySuiteRemover
 from .fixture import create_fixture
 from .itemlist import ItemList
-from .keyword import Keyword, Keywords
+from .keyword import Keyword
 from .metadata import Metadata
 from .modelobject import DataDict, ModelObject
 from .tagsetter import TagSetter
@@ -36,14 +36,14 @@ KW = TypeVar('KW', bound=Keyword, covariant=True)
 TC = TypeVar('TC', bound=TestCase, covariant=True)
 
 
-class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else object):
+class TestSuite(ModelObject, Generic[KW, TC]):
     """Base model for single suite.
 
     Extended by :class:`robot.running.model.TestSuite` and
     :class:`robot.result.model.TestSuite`.
     """
     # FIXME: Type Ignore declarations: Typevars only accept subclasses of the bound class
-    # assiging `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
+    # assigning `Type[KW]` to `Keyword` results in an error. In RF 7 the class should be
     # made impossible to instantiate directly, and the assignments can be replaced with
     # KnownAtRuntime
     fixture_class: Type[KW] = Keyword  # type: ignore
@@ -56,8 +56,8 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
                  doc: str = '',
                  metadata: 'Mapping[str, str]|None' = None,
                  source: 'Path|str|None' = None,
-                 rpa: 'bool|None' = None,
-                 parent: 'TestSuite|None' = None):
+                 rpa: 'bool|None' = False,
+                 parent: 'TestSuite[KW, TC]|None' = None):
         self._name = name
         self.doc = doc
         self.metadata = metadata
@@ -191,17 +191,51 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
             suite.adjust_source(relative_to, root)
 
     @property
-    def longname(self) -> str:
-        """Suite name prefixed with the long name of the parent suite."""
+    def full_name(self) -> str:
+        """Suite name prefixed with the full name of the possible parent suite.
+
+        Just :attr:`name` of the suite if it has no :attr:`parent`.
+        """
         if not self.parent:
             return self.name
-        return f'{self.parent.longname}.{self.name}'
+        return f'{self.parent.full_name}.{self.name}'
+
+    @property
+    def longname(self) -> str:
+        """Deprecated since Robot Framework 7.0. Use :attr:`full_name` instead."""
+        return self.full_name
 
     @setter
     def metadata(self, metadata: 'Mapping[str, str]|None') -> Metadata:
         """Free suite metadata as a :class:`~.metadata.Metadata` object."""
         return Metadata(metadata)
 
+    def validate_execution_mode(self) -> 'bool|None':
+        """Validate that suite execution mode is set consistently.
+
+        Raise an exception if the execution mode is not set (i.e. the :attr:`rpa`
+        attribute is ``None``) and child suites have conflicting execution modes.
+
+        The execution mode is returned. New in RF 6.1.1.
+        """
+        if self.rpa is None:
+            rpa = name = None
+            for suite in self.suites:
+                suite.validate_execution_mode()
+                if rpa is None:
+                    rpa = suite.rpa
+                    name = suite.full_name
+                elif rpa is not suite.rpa:
+                    mode1, mode2 = ('tasks', 'tests') if rpa else ('tests', 'tasks')
+                    raise DataError(
+                        f"Conflicting execution modes: Suite '{name}' has {mode1} but "
+                        f"suite '{suite.full_name}' has {mode2}. Resolve the conflict "
+                        f"or use '--rpa' or '--norpa' options to set the execution "
+                        f"mode explicitly."
+                    )
+            self.rpa = rpa
+        return self.rpa
+
     @setter
     def suites(self, suites: 'Sequence[TestSuite|DataDict]') -> 'TestSuites[TestSuite[KW, TC]]':
         return TestSuites['TestSuite'](self.__class__, self, suites)
@@ -282,19 +316,6 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
         """
         return bool(self._teardown)
 
-    @property
-    def keywords(self) -> Keywords:
-        """Deprecated since Robot Framework 4.0.
-
-        Use :attr:`setup` or :attr:`teardown` instead.
-        """
-        keywords = [self.setup, self.teardown]
-        return Keywords(self, [kw for kw in keywords if kw])
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     @property
     def id(self) -> str:
         """An automatically generated unique id.
@@ -331,9 +352,7 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
 
     @property
     def has_tests(self) -> bool:
-        if self.tests:
-            return True
-        return any(s.has_tests for s in self.suites)
+        return bool(self.tests) or any(s.has_tests for s in self.suites)
 
     def set_tags(self, add: Sequence[str] = (), remove: Sequence[str] = (),
                  persist: bool = False):
@@ -400,9 +419,6 @@ class TestSuite(ModelObject, Generic[KW, TC] if sys.version_info >= (3, 7)  else
         """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
         visitor.visit_suite(self)
 
-    def __str__(self) -> str:
-        return self.name
-
     def to_dict(self) -> 'dict[str, Any]':
         data: 'dict[str, Any]' = {'name': self.name}
         if self.doc:

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/visitor.py

@@ -21,7 +21,7 @@ and the :mod:`result model <robot.result.model>`, but the objects passed to
 the visitor methods are slightly different depending on the model they are
 used with. The main differences are that on the execution side keywords do
 not have child keywords nor messages, and that only the result objects have
-status related attributes like :attr:`status` and :attr:`starttime`.
+status related attributes like :attr:`status` and :attr:`start_time`.
 
 This module contains :class:`SuiteVisitor` that implements the core logic to
 visit a test suite structure, and the :mod:`~robot.result` package contains
@@ -80,19 +80,19 @@ Type hints
 
 Visitor methods have type hints to give more information about the model objects
 they receive to editors. Because visitors can be used with both running and result
-models, the types that are used are base classes from the :mod:`robot.model`
-module. Actual visitors may want to import appropriate types from
-:mod:`robot.running.model` or from :mod:`robot.result.model` modules instead.
-For example, this code that prints failed tests uses result side model objects::
+models, the types that are used as type hints are base classes from the
+:mod:`robot.model` module. Actual visitor implementations can import appropriate
+types from the :mod:`robot.running` or the :mod:`robot.result` module instead.
+For example, this visitor uses the result side model objects::
 
     from robot.api import SuiteVisitor
-    from robot.result.model import TestCase, TestSuite
+    from robot.result import TestCase, TestSuite
 
 
     class FailurePrinter(SuiteVisitor):
 
         def start_suite(self, suite: TestSuite):
-            print(f"{suite.longname}: {suite.statistics.failed} failed")
+            print(f"{suite.full_name}: {suite.statistics.failed} failed")
 
         def visit_test(self, test: TestCase):
             if test.failed:
@@ -107,7 +107,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from robot.model import (Break, BodyItem, Continue, Error, For, If, IfBranch,
                              Keyword, Message, Return, TestCase, TestSuite, Try,
-                             TryBranch, While)
+                             TryBranch, Var, While)
     from robot.result import ForIteration, WhileIteration
 
 
@@ -178,10 +178,15 @@ class SuiteVisitor:
         the body of the keyword
         """
         if self.start_keyword(keyword) is not False:
+            self._possible_setup(keyword)
             self._possible_body(keyword)
             self._possible_teardown(keyword)
             self.end_keyword(keyword)
 
+    def _possible_setup(self, item: 'BodyItem'):
+        if getattr(item, 'has_setup', False):
+            item.setup.visit(self)    # type: ignore
+
     def _possible_body(self, item: 'BodyItem'):
         if hasattr(item, 'body'):
             item.body.visit(self)    # type: ignore
@@ -422,6 +427,28 @@ class SuiteVisitor:
         """
         self.end_body_item(iteration)
 
+    def visit_var(self, var: 'Var'):
+        """Visits a VAR elements."""
+        if self.start_var(var) is not False:
+            self._possible_body(var)
+            self.end_var(var)
+
+    def start_var(self, var: 'Var') -> 'bool|None':
+        """Called when a VAR element starts.
+
+        By default, calls :meth:`start_body_item` which, by default, does nothing.
+
+        Can return explicit ``False`` to stop visiting.
+        """
+        return self.start_body_item(var)
+
+    def end_var(self, var: 'Var'):
+        """Called when a VAR element ends.
+
+        By default, calls :meth:`end_body_item` which, by default, does nothing.
+        """
+        self.end_body_item(var)
+
     def visit_return(self, return_: 'Return'):
         """Visits a RETURN elements."""
         if self.start_return(return_) is not False: