Skip to content

model

Module implementing result related model objects.

During test execution these objects are created internally by various runners. At that time they can be inspected and modified by listeners__.

When results are parsed from XML output files after execution to be able to create logs and reports, these objects are created by the :func:~.resultbuilder.ExecutionResult factory method. At that point they can be inspected and modified by pre-Rebot modifiers__.

The :func:~.resultbuilder.ExecutionResult factory method can also be used by custom scripts and tools. In such usage it is often easiest to inspect and modify these objects using the :mod:visitor interface <robot.model.visitor>.

If classes defined here are needed, for example, as type hints, they can be imported via the :mod:robot.running module.

__ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#listener-interface __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#programmatic-modification-of-results

Break

Bases: Break, StatusMixin, DeprecatedAttributesMixin

Source code in src/robot/result/model.py 
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
@Body.register
class Break(model.Break, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
    body_class = Body

    def __init__(self, status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: BodyItemParent = None):
        super().__init__(parent)
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time
        self.body = ()

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Child keywords and messages as a :class:`~.Body` object.

        Typically empty. Only contains something if running BREAK has failed
        due to a syntax error or listeners have logged messages or executed
        keywords.
        """
        return self.body_class(self, body)

    def to_dict(self) -> DataDict:
        data = {**super().to_dict(), **StatusMixin.to_dict(self)}
        if self.body:
            data['body'] = self.body.to_dicts()
        return data

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

id: str | None property

Item id in format like s1-t3-k1.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

id is None only in these special cases:

  • Keyword uses a placeholder for setup or teardown when a setup or teardown is not actually used.
  • With :class:~robot.model.control.If and :class:~robot.model.control.Try instances representing IF/TRY structure roots.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

body(body)

Child keywords and messages as a :class:~.Body object.

Typically empty. Only contains something if running BREAK has failed due to a syntax error or listeners have logged messages or executed keywords.

Source code in src/robot/result/model.py 
642
643
644
645
646
647
648
649
650
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Child keywords and messages as a :class:`~.Body` object.

    Typically empty. Only contains something if running BREAK has failed
    due to a syntax error or listeners have logged messages or executed
    keywords.
    """
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

Continue

Bases: Continue, StatusMixin, DeprecatedAttributesMixin

Source code in src/robot/result/model.py 
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
@Body.register
class Continue(model.Continue, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
    body_class = Body

    def __init__(self, status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: BodyItemParent = None):
        super().__init__(parent)
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time
        self.body = ()

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Child keywords and messages as a :class:`~.Body` object.

        Typically empty. Only contains something if running CONTINUE has failed
        due to a syntax error or listeners have logged messages or executed
        keywords.
        """
        return self.body_class(self, body)

    def to_dict(self) -> DataDict:
        data = {**super().to_dict(), **StatusMixin.to_dict(self)}
        if self.body:
            data['body'] = self.body.to_dicts()
        return data

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

id: str | None property

Item id in format like s1-t3-k1.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

id is None only in these special cases:

  • Keyword uses a placeholder for setup or teardown when a setup or teardown is not actually used.
  • With :class:~robot.model.control.If and :class:~robot.model.control.Try instances representing IF/TRY structure roots.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

body(body)

Child keywords and messages as a :class:~.Body object.

Typically empty. Only contains something if running CONTINUE has failed due to a syntax error or listeners have logged messages or executed keywords.

Source code in src/robot/result/model.py 
606
607
608
609
610
611
612
613
614
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Child keywords and messages as a :class:`~.Body` object.

    Typically empty. Only contains something if running CONTINUE has failed
    due to a syntax error or listeners have logged messages or executed
    keywords.
    """
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

Error

Bases: Error, StatusMixin, DeprecatedAttributesMixin

Source code in src/robot/result/model.py 
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
@Body.register
class Error(model.Error, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
    body_class = Body

    def __init__(self, values: Sequence[str] = (),
                 status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: BodyItemParent = None):
        super().__init__(values, parent)
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time
        self.body = ()

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Messages as a :class:`~.Body` object.

        Typically contains the message that caused the error.
        """
        return self.body_class(self, body)

    def to_dict(self) -> DataDict:
        data = {**super().to_dict(), **StatusMixin.to_dict(self)}
        if self.body:
            data['body'] = self.body.to_dicts()
        return data

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

id: str | None property

Item id in format like s1-t3-k1.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

id is None only in these special cases:

  • Keyword uses a placeholder for setup or teardown when a setup or teardown is not actually used.
  • With :class:~robot.model.control.If and :class:~robot.model.control.Try instances representing IF/TRY structure roots.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

body(body)

Messages as a :class:~.Body object.

Typically contains the message that caused the error.

Source code in src/robot/result/model.py 
679
680
681
682
683
684
685
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Messages as a :class:`~.Body` object.

    Typically contains the message that caused the error.
    """
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

Keyword

Bases: Keyword, StatusMixin

Represents an executed library or user keyword.

Source code in src/robot/result/model.py 
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
@Body.register
@Branches.register
@Iterations.register
class Keyword(model.Keyword, StatusMixin):
    """Represents an executed library or user keyword."""
    body_class = Body
    __slots__ = ['owner', 'source_name', 'doc', 'timeout', 'status', 'message',
                 '_start_time', '_end_time', '_elapsed_time', '_setup', '_teardown']

    def __init__(self, name: 'str|None' = '',
                 owner: 'str|None' = None,
                 source_name: 'str|None' = None,
                 doc: str = '',
                 args: Sequence[str] = (),
                 assign: Sequence[str] = (),
                 tags: Sequence[str] = (),
                 timeout: 'str|None' = None,
                 type: str = BodyItem.KEYWORD,
                 status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: BodyItemParent = None):
        super().__init__(name, args, assign, type, parent)
        #: Name of the library or resource containing this keyword.
        self.owner = owner
        #: Original name of keyword with embedded arguments.
        self.source_name = source_name
        self.doc = doc
        self.tags = tags
        self.timeout = timeout
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time
        self._setup = None
        self._teardown = None
        self.body = ()

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Possible keyword body as a :class:`~.Body` object.

        Body can consist of child keywords, messages, and control structures
        such as IF/ELSE. Library keywords typically have an empty body.
        """
        return self.body_class(self, body)

    @property
    def messages(self) -> 'list[Message]':
        """Keyword's messages.

        Starting from Robot Framework 4.0 this is a list generated from messages
        in :attr:`body`.
        """
        return self.body.filter(messages=True)    # type: ignore

    @property
    def full_name(self) -> 'str|None':
        """Keyword name in format ``owner.name``.

        Just ``name`` if :attr:`owner` is not set. In practice this is the
        case only with user keywords in the suite file.

        Cannot be set directly. Set :attr:`name` and :attr:`owner` separately
        instead.

        Notice that prior to Robot Framework 7.0, the ``name`` attribute contained
        the full name and keyword and owner names were in ``kwname`` and ``libname``,
        respectively.
        """
        return f'{self.owner}.{self.name}' if self.owner else self.name

    # TODO: Deprecate 'kwname', 'libname' and 'sourcename' loudly in RF 8.
    @property
    def kwname(self) -> 'str|None':
        """Deprecated since Robot Framework 7.0. Use :attr:`name` instead."""
        return self.name

    @kwname.setter
    def kwname(self, name: 'str|None'):
        self.name = name

    @property
    def libname(self) -> 'str|None':
        """Deprecated since Robot Framework 7.0. Use :attr:`owner` instead."""
        return self.owner

    @libname.setter
    def libname(self, name: 'str|None'):
        self.owner = name

    @property
    def sourcename(self) -> str:
        """Deprecated since Robot Framework 7.0. Use :attr:`source_name` instead."""
        return self.source_name

    @sourcename.setter
    def sourcename(self, name: str):
        self.source_name = name

    @property
    def setup(self) -> 'Keyword':
        """Keyword setup as a :class:`Keyword` object.

        See :attr:`teardown` for more information. New in Robot Framework 7.0.
        """
        if self._setup is None:
            self.setup = None
        return self._setup

    @setup.setter
    def setup(self, setup: 'Keyword|DataDict|None'):
        self._setup = create_fixture(self.__class__, setup, self, self.SETUP)

    @property
    def has_setup(self) -> bool:
        """Check does a keyword have a setup without creating a setup object.

        See :attr:`has_teardown` for more information. New in Robot Framework 7.0.
        """
        return bool(self._setup)

    @property
    def teardown(self) -> 'Keyword':
        """Keyword teardown as a :class:`Keyword` object.

        Teardown can be modified by setting attributes directly::

            keyword.teardown.name = 'Example'
            keyword.teardown.args = ('First', 'Second')

        Alternatively the :meth:`config` method can be used to set multiple
        attributes in one call::

            keyword.teardown.config(name='Example', args=('First', 'Second'))

        The easiest way to reset the whole teardown is setting it to ``None``.
        It will automatically recreate the underlying ``Keyword`` object::

            keyword.teardown = None

        This attribute is a ``Keyword`` object also when a keyword has no teardown
        but in that case its truth value is ``False``. If there is a need to just
        check does a keyword have a teardown, using the :attr:`has_teardown`
        attribute avoids creating the ``Keyword`` object and is thus more memory
        efficient.

        New in Robot Framework 4.0. Earlier teardown was accessed like
        ``keyword.keywords.teardown``. :attr:`has_teardown` is new in Robot
        Framework 4.1.2.
        """
        if self._teardown is None:
            self.teardown = None
        return self._teardown

    @teardown.setter
    def teardown(self, teardown: 'Keyword|DataDict|None'):
        self._teardown = create_fixture(self.__class__, teardown, self, self.TEARDOWN)

    @property
    def has_teardown(self) -> bool:
        """Check does a keyword have a teardown without creating a teardown object.

        A difference between using ``if kw.has_teardown:`` and ``if kw.teardown:``
        is that accessing the :attr:`teardown` attribute creates a :class:`Keyword`
        object representing a teardown even when the keyword actually does not
        have one. This typically does not matter, but with bigger suite structures
        having lots of keywords it can have a considerable effect on memory usage.

        New in Robot Framework 4.1.2.
        """
        return bool(self._teardown)

    @setter
    def tags(self, tags: Sequence[str]) -> model.Tags:
        """Keyword tags as a :class:`~.model.tags.Tags` object."""
        return Tags(tags)

    def to_dict(self) -> DataDict:
        data = {**super().to_dict(), **StatusMixin.to_dict(self)}
        if self.owner:
            data['owner'] = self.owner
        if self.source_name:
            data['source_name'] = self.source_name
        if self.doc:
            data['doc'] = self.doc
        if self.tags:
            data['tags'] = list(self.tags)
        if self.timeout:
            data['timeout'] = self.timeout
        if self.body:
            data['body'] = self.body.to_dicts()
        if self.has_setup:
            data['setup'] = self.setup.to_dict()
        if self.has_teardown:
            data['teardown'] = self.teardown.to_dict()
        return data

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

full_name: str | None property

Keyword name in format owner.name.

Just name if :attr:owner is not set. In practice this is the case only with user keywords in the suite file.

Cannot be set directly. Set :attr:name and :attr:owner separately instead.

Notice that prior to Robot Framework 7.0, the name attribute contained the full name and keyword and owner names were in kwname and libname, respectively.

has_setup: bool property

Check does a keyword have a setup without creating a setup object.

See :attr:has_teardown for more information. New in Robot Framework 7.0.

has_teardown: bool property

Check does a keyword have a teardown without creating a teardown object.

A difference between using if kw.has_teardown: and if kw.teardown: is that accessing the :attr:teardown attribute creates a :class:Keyword object representing a teardown even when the keyword actually does not have one. This typically does not matter, but with bigger suite structures having lots of keywords it can have a considerable effect on memory usage.

New in Robot Framework 4.1.2.

kwname: str | None property writable

Deprecated since Robot Framework 7.0. Use :attr:name instead.

libname: str | None property writable

Deprecated since Robot Framework 7.0. Use :attr:owner instead.

messages: list[Message] property

Keyword's messages.

Starting from Robot Framework 4.0 this is a list generated from messages in :attr:body.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

setup: Keyword property writable

Keyword setup as a :class:Keyword object.

See :attr:teardown for more information. New in Robot Framework 7.0.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

sourcename: str property writable

Deprecated since Robot Framework 7.0. Use :attr:source_name instead.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

teardown: Keyword property writable

Keyword teardown as a :class:Keyword object.

Teardown can be modified by setting attributes directly::

1
2
keyword.teardown.name = 'Example'
keyword.teardown.args = ('First', 'Second')

Alternatively the :meth:config method can be used to set multiple attributes in one call::

1
keyword.teardown.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole teardown is setting it to None. It will automatically recreate the underlying Keyword object::

1
keyword.teardown = None

This attribute is a Keyword object also when a keyword has no teardown but in that case its truth value is False. If there is a need to just check does a keyword have a teardown, using the :attr:has_teardown attribute avoids creating the Keyword object and is thus more memory efficient.

New in Robot Framework 4.0. Earlier teardown was accessed like keyword.keywords.teardown. :attr:has_teardown is new in Robot Framework 4.1.2.

body(body)

Possible keyword body as a :class:~.Body object.

Body can consist of child keywords, messages, and control structures such as IF/ELSE. Library keywords typically have an empty body.

Source code in src/robot/result/model.py 
735
736
737
738
739
740
741
742
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Possible keyword body as a :class:`~.Body` object.

    Body can consist of child keywords, messages, and control structures
    such as IF/ELSE. Library keywords typically have an empty body.
    """
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

tags(tags)

Keyword tags as a :class:~.model.tags.Tags object.

Source code in src/robot/result/model.py 
870
871
872
873
@setter
def tags(self, tags: Sequence[str]) -> model.Tags:
    """Keyword tags as a :class:`~.model.tags.Tags` object."""
    return Tags(tags)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

visit(visitor)

:mod:Visitor interface <robot.model.visitor> entry-point.

Source code in src/robot/model/keyword.py 
52
53
54
55
def visit(self, visitor: 'SuiteVisitor'):
    """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
    if self:
        visitor.visit_keyword(self)

Return

Bases: Return, StatusMixin, DeprecatedAttributesMixin

Source code in src/robot/result/model.py 
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
@Body.register
class Return(model.Return, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
    body_class = Body

    def __init__(self, values: Sequence[str] = (),
                 status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: BodyItemParent = None):
        super().__init__(values, parent)
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time
        self.body = ()

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Child keywords and messages as a :class:`~.Body` object.

        Typically empty. Only contains something if running RETURN has failed
        due to a syntax error or listeners have logged messages or executed
        keywords.
        """
        return self.body_class(self, body)

    def to_dict(self) -> DataDict:
        data = {**super().to_dict(), **StatusMixin.to_dict(self)}
        if self.body:
            data['body'] = self.body.to_dicts()
        return data

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

id: str | None property

Item id in format like s1-t3-k1.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

id is None only in these special cases:

  • Keyword uses a placeholder for setup or teardown when a setup or teardown is not actually used.
  • With :class:~robot.model.control.If and :class:~robot.model.control.Try instances representing IF/TRY structure roots.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

body(body)

Child keywords and messages as a :class:~.Body object.

Typically empty. Only contains something if running RETURN has failed due to a syntax error or listeners have logged messages or executed keywords.

Source code in src/robot/result/model.py 
570
571
572
573
574
575
576
577
578
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Child keywords and messages as a :class:`~.Body` object.

    Typically empty. Only contains something if running RETURN has failed
    due to a syntax error or listeners have logged messages or executed
    keywords.
    """
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

StatusMixin

Source code in src/robot/result/model.py 
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
class StatusMixin:
    PASS = 'PASS'
    FAIL = 'FAIL'
    SKIP = 'SKIP'
    NOT_RUN = 'NOT RUN'
    NOT_SET = 'NOT SET'
    status: Literal['PASS', 'FAIL', 'SKIP', 'NOT RUN', 'NOT SET']
    __slots__ = ()

    @property
    def start_time(self) -> 'datetime|None':
        """Execution start time as a ``datetime`` or as a ``None`` if not set.

        If start time is not set, it is calculated based :attr:`end_time`
        and :attr:`elapsed_time` if possible.

        Can be set either directly as a ``datetime`` or as a string in ISO 8601
        format.

        New in Robot Framework 6.1. Heavily enhanced in Robot Framework 7.0.
        """
        if self._start_time:
            return self._start_time
        if self._end_time:
            return self._end_time - self.elapsed_time
        return None

    @start_time.setter
    def start_time(self, start_time: 'datetime|str|None'):
        if isinstance(start_time, str):
            start_time = datetime.fromisoformat(start_time)
        self._start_time = start_time

    @property
    def end_time(self) -> 'datetime|None':
        """Execution end time as a ``datetime`` or as a ``None`` if not set.

        If end time is not set, it is calculated based :attr:`start_time`
        and :attr:`elapsed_time` if possible.

        Can be set either directly as a ``datetime`` or as a string in ISO 8601
        format.

        New in Robot Framework 6.1. Heavily enhanced in Robot Framework 7.0.
        """
        if self._end_time:
            return self._end_time
        if self._start_time:
            return self._start_time + self.elapsed_time
        return None

    @end_time.setter
    def end_time(self, end_time: 'datetime|str|None'):
        if isinstance(end_time, str):
            end_time = datetime.fromisoformat(end_time)
        self._end_time = end_time

    @property
    def elapsed_time(self) -> timedelta:
        """Total execution time as a ``timedelta``.

        If not set, calculated based on :attr:`start_time` and :attr:`end_time`
        if possible. If that fails, calculated based on the elapsed time of
        child items.

        Can be set either directly as a ``timedelta`` or as an integer or a float
        representing seconds.

        New in Robot Framework 6.1. Heavily enhanced in Robot Framework 7.0.
        """
        if self._elapsed_time is not None:
            return self._elapsed_time
        if self._start_time and self._end_time:
            return self._end_time - self._start_time
        return self._elapsed_time_from_children()

    def _elapsed_time_from_children(self) -> timedelta:
        elapsed = timedelta()
        for child in self.body:
            if hasattr(child, 'elapsed_time'):
                elapsed += child.elapsed_time
        if getattr(self, 'has_setup', False):
            elapsed += self.setup.elapsed_time
        if getattr(self, 'has_teardown', False):
            elapsed += self.teardown.elapsed_time
        return elapsed

    @elapsed_time.setter
    def elapsed_time(self, elapsed_time: 'timedelta|int|float|None'):
        if isinstance(elapsed_time, (int, float)):
            elapsed_time = timedelta(seconds=elapsed_time)
        self._elapsed_time = elapsed_time

    @property
    def starttime(self) -> 'str|None':
        """Execution start time as a string or as a ``None`` if not set.

        The string format is ``%Y%m%d %H:%M:%S.%f``.

        Considered deprecated starting from Robot Framework 7.0.
        :attr:`start_time` should be used instead.
        """
        return self._datetime_to_timestr(self.start_time)

    @starttime.setter
    def starttime(self, starttime: 'str|None'):
        self.start_time = self._timestr_to_datetime(starttime)

    @property
    def endtime(self) -> 'str|None':
        """Execution end time as a string or as a ``None`` if not set.

        The string format is ``%Y%m%d %H:%M:%S.%f``.

        Considered deprecated starting from Robot Framework 7.0.
        :attr:`end_time` should be used instead.
        """
        return self._datetime_to_timestr(self.end_time)

    @endtime.setter
    def endtime(self, endtime: 'str|None'):
        self.end_time = self._timestr_to_datetime(endtime)

    @property
    def elapsedtime(self) -> int:
        """Total execution time in milliseconds.

        Considered deprecated starting from Robot Framework 7.0.
        :attr:`elapsed_time` should be used instead.
        """
        return round(self.elapsed_time.total_seconds() * 1000)

    def _timestr_to_datetime(self, ts: 'str|None') -> 'datetime|None':
        if not ts:
            return None
        ts = ts.ljust(24, '0')
        return datetime(int(ts[:4]), int(ts[4:6]), int(ts[6:8]),
                        int(ts[9:11]), int(ts[12:14]), int(ts[15:17]), int(ts[18:24]))

    def _datetime_to_timestr(self, dt: 'datetime|None') -> 'str|None':
        if not dt:
            return None
        return dt.isoformat(' ', timespec='milliseconds').replace('-', '')

    @property
    def passed(self) -> bool:
        """``True`` when :attr:`status` is 'PASS', ``False`` otherwise."""
        return self.status == self.PASS

    @passed.setter
    def passed(self, passed: bool):
        self.status = self.PASS if passed else self.FAIL

    @property
    def failed(self) -> bool:
        """``True`` when :attr:`status` is 'FAIL', ``False`` otherwise."""
        return self.status == self.FAIL

    @failed.setter
    def failed(self, failed: bool):
        self.status = self.FAIL if failed else self.PASS

    @property
    def skipped(self) -> bool:
        """``True`` when :attr:`status` is 'SKIP', ``False`` otherwise.

        Setting to ``False`` value is ambiguous and raises an exception.
        """
        return self.status == self.SKIP

    @skipped.setter
    def skipped(self, skipped: Literal[True]):
        if not skipped:
            raise ValueError(f"`skipped` value must be truthy, got '{skipped}'.")
        self.status = self.SKIP

    @property
    def not_run(self) -> bool:
        """``True`` when :attr:`status` is 'NOT RUN', ``False`` otherwise.

        Setting to ``False`` value is ambiguous and raises an exception.
        """
        return self.status == self.NOT_RUN

    @not_run.setter
    def not_run(self, not_run: Literal[True]):
        if not not_run:
            raise ValueError(f"`not_run` value must be truthy, got '{not_run}'.")
        self.status = self.NOT_RUN

    def to_dict(self):
        data = {'status': self.status,
                'elapsed_time': self.elapsed_time.total_seconds()}
        if self.start_time:
            data['start_time'] = self.start_time.isoformat()
        if self.message:
            data['message'] = self.message
        return data

elapsed_time: timedelta property writable

Total execution time as a timedelta.

If not set, calculated based on :attr:start_time and :attr:end_time if possible. If that fails, calculated based on the elapsed time of child items.

Can be set either directly as a timedelta or as an integer or a float representing seconds.

New in Robot Framework 6.1. Heavily enhanced in Robot Framework 7.0.

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

end_time: datetime | None property writable

Execution end time as a datetime or as a None if not set.

If end time is not set, it is calculated based :attr:start_time and :attr:elapsed_time if possible.

Can be set either directly as a datetime or as a string in ISO 8601 format.

New in Robot Framework 6.1. Heavily enhanced in Robot Framework 7.0.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

start_time: datetime | None property writable

Execution start time as a datetime or as a None if not set.

If start time is not set, it is calculated based :attr:end_time and :attr:elapsed_time if possible.

Can be set either directly as a datetime or as a string in ISO 8601 format.

New in Robot Framework 6.1. Heavily enhanced in Robot Framework 7.0.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

TestCase

Bases: TestCase[Keyword], StatusMixin

Represents results of a single test case.

See the base class for documentation of attributes not documented here.

Source code in src/robot/result/model.py 
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
class TestCase(model.TestCase[Keyword], StatusMixin):
    """Represents results of a single test case.

    See the base class for documentation of attributes not documented here.
    """
    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
    body_class = Body
    fixture_class = Keyword

    def __init__(self, name: str = '',
                 doc: str = '',
                 tags: Sequence[str] = (),
                 timeout: 'str|None' = None,
                 lineno: 'int|None' = None,
                 status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: 'TestSuite|None' = None):
        super().__init__(name, doc, tags, timeout, lineno, parent)
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time

    @property
    def not_run(self) -> bool:
        return False

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Test body as a :class:`~robot.result.Body` object."""
        return self.body_class(self, body)

    def to_dict(self) -> DataDict:
        return {**super().to_dict(), **StatusMixin.to_dict(self)}

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

full_name: str property

Test name prefixed with the full name of the parent suite.

has_setup: bool property

Check does a suite have a setup without creating a setup object.

A difference between using if test.has_setup: and if test.setup: is that accessing the :attr:setup attribute creates a :class:Keyword object representing the setup even when the test actually does not have one. This typically does not matter, but with bigger suite structures containing a huge about of tests it can have an effect on memory usage.

New in Robot Framework 5.0.

has_teardown: bool property

Check does a test have a teardown without creating a teardown object.

See :attr:has_setup for more information.

New in Robot Framework 5.0.

id: str property

Test case id in format like s1-t3.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

longname: str property

Deprecated since Robot Framework 7.0. Use :attr:full_name instead.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

setup: KW property writable

Test setup as a :class:~.model.keyword.Keyword object.

This attribute is a Keyword object also when a test has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly::

1
2
test.setup.name = 'Example'
test.setup.args = ('First', 'Second')

Alternatively the :meth:config method can be used to set multiple attributes in one call::

1
test.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object::

1
test.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like test.keywords.setup.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

teardown: KW property writable

Test teardown as a :class:~.model.keyword.Keyword object.

See :attr:setup for more information.

body(body)

Test body as a :class:~robot.result.Body object.

Source code in src/robot/result/model.py 
927
928
929
930
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Test body as a :class:`~robot.result.Body` object."""
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

tags(tags)

Test tags as a :class:~.model.tags.Tags object.

Source code in src/robot/model/testcase.py 
70
71
72
73
@setter
def tags(self, tags: 'Tags|Sequence[str]') -> Tags:
    """Test tags as a :class:`~.model.tags.Tags` object."""
    return Tags(tags)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

visit(visitor)

:mod:Visitor interface <robot.model.visitor> entry-point.

Source code in src/robot/model/testcase.py 
175
176
177
def visit(self, visitor: 'SuiteVisitor'):
    """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
    visitor.visit_test(self)

TestSuite

Bases: TestSuite[Keyword, TestCase], StatusMixin

Represents results of a single test suite.

See the base class for documentation of attributes not documented here.

Source code in src/robot/result/model.py 
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
class TestSuite(model.TestSuite[Keyword, TestCase], StatusMixin):
    """Represents results of a single test suite.

    See the base class for documentation of attributes not documented here.
    """
    __slots__ = ['message', '_start_time', '_end_time', '_elapsed_time']
    test_class = TestCase
    fixture_class = Keyword

    def __init__(self, name: str = '',
                 doc: str = '',
                 metadata: 'Mapping[str, str]|None' = None,
                 source: 'Path|str|None' = None,
                 rpa: bool = False,
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: 'TestSuite|None' = None):
        super().__init__(name, doc, metadata, source, rpa, parent)
        #: Possible suite setup or teardown error message.
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time

    def _elapsed_time_from_children(self) -> timedelta:
        elapsed = timedelta()
        if self.has_setup:
            elapsed += self.setup.elapsed_time
        if self.has_teardown:
            elapsed += self.teardown.elapsed_time
        for child in chain(self.suites, self.tests):
            elapsed += child.elapsed_time
        return elapsed

    @property
    def passed(self) -> bool:
        """``True`` if no test has failed but some have passed, ``False`` otherwise."""
        return self.status == self.PASS

    @property
    def failed(self) -> bool:
        """``True`` if any test has failed, ``False`` otherwise."""
        return self.status == self.FAIL

    @property
    def skipped(self) -> bool:
        """``True`` if there are no passed or failed tests, ``False`` otherwise."""
        return self.status == self.SKIP

    @property
    def not_run(self) -> bool:
        return False

    @property
    def status(self) -> Literal['PASS', 'SKIP', 'FAIL']:
        """'PASS', 'FAIL' or 'SKIP' depending on test statuses.

        - If any test has failed, status is 'FAIL'.
        - If no test has failed but at least some test has passed, status is 'PASS'.
        - If there are no failed or passed tests, status is 'SKIP'. This covers both
          the case when all tests have been skipped and when there are no tests.
        """
        stats = self.statistics  # Local variable avoids recreating stats.
        if stats.failed:
            return self.FAIL
        if stats.passed:
            return self.PASS
        return self.SKIP

    @property
    def statistics(self) -> TotalStatistics:
        """Suite statistics as a :class:`~robot.model.totalstatistics.TotalStatistics` object.

        Recreated every time this property is accessed, so saving the results
        to a variable and inspecting it is often a good idea::

            stats = suite.statistics
            print(stats.failed)
            print(stats.total)
            print(stats.message)
        """
        return TotalStatisticsBuilder(self, bool(self.rpa)).stats

    @property
    def full_message(self) -> str:
        """Combination of :attr:`message` and :attr:`stat_message`."""
        if not self.message:
            return self.stat_message
        return f'{self.message}\n\n{self.stat_message}'

    @property
    def stat_message(self) -> str:
        """String representation of the :attr:`statistics`."""
        return self.statistics.message

    @setter
    def suites(self, suites: 'Sequence[TestSuite|DataDict]') -> TestSuites['TestSuite']:
        return TestSuites['TestSuite'](self.__class__, self, suites)

    def remove_keywords(self, how: str):
        """Remove keywords based on the given condition.

        :param how: Which approach to use when removing keywords. Either
            ``ALL``, ``PASSED``, ``FOR``, ``WUKS``, or ``NAME:<pattern>``.

        For more information about the possible values see the documentation
        of the ``--removekeywords`` command line option.
        """
        self.visit(KeywordRemover.from_config(how))

    def filter_messages(self, log_level: str = 'TRACE'):
        """Remove log messages below the specified ``log_level``."""
        self.visit(MessageFilter(log_level))

    def configure(self, **options):
        """A shortcut to configure a suite using one method call.

        Can only be used with the root test suite.

        :param options: Passed to
            :class:`~robot.result.configurer.SuiteConfigurer` that will then
            set suite attributes, call :meth:`filter`, etc. as needed.

        Example::

            suite.configure(remove_keywords='PASSED',
                            doc='Smoke test results.')

        Not to be confused with :meth:`config` method that suites, tests,
        and keywords have to make it possible to set multiple attributes in
        one call.
        """
        super().configure()    # Parent validates is call allowed.
        self.visit(SuiteConfigurer(**options))

    def handle_suite_teardown_failures(self):
        """Internal usage only."""
        self.visit(SuiteTeardownFailureHandler())

    def suite_teardown_failed(self, message: str):
        """Internal usage only."""
        self.visit(SuiteTeardownFailed(message))

    def suite_teardown_skipped(self, message: str):
        """Internal usage only."""
        self.visit(SuiteTeardownFailed(message, skipped=True))

    def to_dict(self) -> DataDict:
        return {**super().to_dict(), **StatusMixin.to_dict(self)}

    @classmethod
    def from_dict(cls, data: DataDict) -> 'TestSuite':
        """Create suite based on result data in a dictionary.

        ``data`` can either contain only the suite data got, for example, from
        the :meth:`to_dict` method, or it can contain full result data with
        execution errors and other such information in addition to the suite data.
        In the latter case only the suite data is used, though.

        Support for full result data is new in Robot Framework 7.2.
        """
        if 'suite' in data:
            data = data['suite']
        return super().from_dict(data)

    @classmethod
    def from_json(cls, source: 'str|bytes|TextIO|Path') -> 'TestSuite':
        """Create suite based on results in JSON.

        The data is given as the ``source`` parameter. It can be:

        - a string containing the data directly,
        - 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.

        Supports JSON produced by :meth:`to_json` that contains only the suite
        information, as well as full result JSON that contains also execution
        errors and other information. In the latter case errors and all other
        information is silently ignored, though. If that is a problem,
        :class:`~robot.result.resultbuilder.ExecutionResult` should be used
        instead.

        Support for full result JSON is new in Robot Framework 7.2.
        """
        return super().from_json(source)

    @overload
    def to_xml(self, file: None = None) -> str:
        ...

    @overload
    def to_xml(self, file: 'TextIO|Path|str') -> None:
        ...

    def to_xml(self, file: 'None|TextIO|Path|str' = None) -> 'str|None':
        """Serialize suite into XML.

        The format is the same that is used with normal output.xml files, but
        the ``<robot>`` root node is omitted and the result contains only
        the ``<suite>`` structure.

        The ``file`` parameter controls what to do with the resulting XML data.
        It can be:

        - ``None`` (default) to return the data as a string,
        - 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.

        A serialized suite can be recreated by using the :meth:`from_xml` method.

        New in Robot Framework 7.0.
        """
        from robot.reporting.outputwriter import OutputWriter

        output, close = self._get_output(file)
        try:
            self.visit(OutputWriter(output, suite_only=True))
        finally:
            if close:
                output.close()
        return output.getvalue() if file is None else None

    def _get_output(self, output) -> 'tuple[TextIO|StringIO, bool]':
        close = False
        if output is None:
            output = StringIO()
        elif isinstance(output, (Path, str)):
            output = open(output, 'w', encoding='UTF-8')
            close = True
        return output, close

    @classmethod
    def from_xml(cls, source: 'str|TextIO|Path') -> 'TestSuite':
        """Create suite based on results in XML.

        The data is given as the ``source`` parameter. It can be:

        - a string containing the data directly,
        - 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.

        Supports both normal output.xml files and files containing only the
        ``<suite>`` structure created, for example, with the :meth:`to_xml`
        method. When using normal output.xml files, possible execution errors
        listed in ``<errors>`` are silently ignored. If that is a problem,
        :class:`~robot.result.resultbuilder.ExecutionResult` should be used
        instead.

        New in Robot Framework 7.0.
        """
        from .resultbuilder import ExecutionResult

        return ExecutionResult(source).suite

all_tests: Iterator[TestCase] property

Yields all tests this suite and its child suites contain.

New in Robot Framework 6.1.

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property

True if any test has failed, False otherwise.

full_message: str property

Combination of :attr:message and :attr:stat_message.

full_name: str property

Suite name prefixed with the full name of the possible parent suite.

Just :attr:name of the suite if it has no :attr:parent.

has_setup: bool property

Check does a suite have a setup without creating a setup object.

A difference between using if suite.has_setup: and if suite.setup: is that accessing the :attr:setup attribute creates a :class:Keyword object representing the setup even when the suite actually does not have one. This typically does not matter, but with bigger suite structures it can have some effect on memory usage.

New in Robot Framework 5.0.

has_teardown: bool property

Check does a suite have a teardown without creating a teardown object.

See :attr:has_setup for more information.

New in Robot Framework 5.0.

id: str property

An automatically generated unique id.

The root suite has id s1, its child suites have ids s1-s1, s1-s2, ..., their child suites get ids s1-s1-s1, s1-s1-s2, ..., s1-s2-s1, ..., and so on.

The first test in a suite has an id like s1-t1, the second has an id s1-t2, and so on. Similarly, keywords in suites (setup/teardown) and in tests get ids like s1-k1, s1-t1-k1, and s1-s4-t2-k5.

longname: str property

Deprecated since Robot Framework 7.0. Use :attr:full_name instead.

name: str property writable

Suite name.

If name is not set, it is constructed from source. If source is not set, name is constructed from child suite names by concatenating them with &. If there are no child suites, name is an empty string.

passed: bool property

True if no test has failed but some have passed, False otherwise.

setup: KW property writable

Suite setup.

This attribute is a Keyword object also when a suite has no setup but in that case its truth value is False. The preferred way to check does a suite have a setup is using :attr:has_setup.

Setup can be modified by setting attributes directly::

1
2
suite.setup.name = 'Example'
suite.setup.args = ('First', 'Second')

Alternatively the :meth:config method can be used to set multiple attributes in one call::

1
suite.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object::

1
suite.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like suite.keywords.setup.

skipped: bool property

True if there are no passed or failed tests, False otherwise.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

stat_message: str property

String representation of the :attr:statistics.

statistics: TotalStatistics property

Suite statistics as a :class:~robot.model.totalstatistics.TotalStatistics object.

Recreated every time this property is accessed, so saving the results to a variable and inspecting it is often a good idea::

1
2
3
4
stats = suite.statistics
print(stats.failed)
print(stats.total)
print(stats.message)

status: Literal['PASS', 'SKIP', 'FAIL'] property

'PASS', 'FAIL' or 'SKIP' depending on test statuses.

  • If any test has failed, status is 'FAIL'.
  • If no test has failed but at least some test has passed, status is 'PASS'.
  • If there are no failed or passed tests, status is 'SKIP'. This covers both the case when all tests have been skipped and when there are no tests.

teardown: KW property writable

Suite teardown.

See :attr:setup for more information.

test_count: int property

Total number of the tests in this suite and in its child suites.

adjust_source(relative_to=None, root=None)

Adjust suite source and child suite sources, recursively.

:param relative_to: Make suite source relative to the given path. Calls pathlib.Path.relative_to()__ internally. Raises ValueError if creating a relative path is not possible. :param root: Make given path a new root directory for the source. Raises ValueError if suite source is absolute.

Adjusting the source is especially useful when moving data around as JSON::

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from robot.api import TestSuite

# Create a suite, adjust source and convert to JSON.
suite = TestSuite.from_file_system('/path/to/data')
suite.adjust_source(relative_to='/path/to')
suite.to_json('data.rbt')

# Recreate suite elsewhere and adjust source accordingly.
suite = TestSuite.from_json('data.rbt')
suite.adjust_source(root='/new/path/to')

New in Robot Framework 6.1.

__ https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.relative_to

Source code in src/robot/model/testsuite.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
def adjust_source(self, relative_to: 'Path|str|None' = None,
                  root: 'Path|str|None' = None):
    """Adjust suite source and child suite sources, recursively.

    :param relative_to: Make suite source relative to the given path. Calls
        `pathlib.Path.relative_to()`__ internally. Raises ``ValueError``
        if creating a relative path is not possible.
    :param root: Make given path a new root directory for the source. Raises
        ``ValueError`` if suite source is absolute.

    Adjusting the source is especially useful when moving data around as JSON::

        from robot.api import TestSuite

        # Create a suite, adjust source and convert to JSON.
        suite = TestSuite.from_file_system('/path/to/data')
        suite.adjust_source(relative_to='/path/to')
        suite.to_json('data.rbt')

        # Recreate suite elsewhere and adjust source accordingly.
        suite = TestSuite.from_json('data.rbt')
        suite.adjust_source(root='/new/path/to')

    New in Robot Framework 6.1.

    __ https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.relative_to
    """
    if not self.source:
        raise ValueError('Suite has no source.')
    if relative_to:
        self.source = self.source.relative_to(relative_to)
    if root:
        if self.source.is_absolute():
            raise ValueError(f"Cannot set root for absolute source '{self.source}'.")
        self.source = root / self.source
    for suite in self.suites:
        suite.adjust_source(relative_to, root)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

configure(**options)

A shortcut to configure a suite using one method call.

Can only be used with the root test suite.

:param options: Passed to :class:~robot.result.configurer.SuiteConfigurer that will then set suite attributes, call :meth:filter, etc. as needed.

Example::

1
2
suite.configure(remove_keywords='PASSED',
                doc='Smoke test results.')

Not to be confused with :meth:config method that suites, tests, and keywords have to make it possible to set multiple attributes in one call.

Source code in src/robot/result/model.py 
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
def configure(self, **options):
    """A shortcut to configure a suite using one method call.

    Can only be used with the root test suite.

    :param options: Passed to
        :class:`~robot.result.configurer.SuiteConfigurer` that will then
        set suite attributes, call :meth:`filter`, etc. as needed.

    Example::

        suite.configure(remove_keywords='PASSED',
                        doc='Smoke test results.')

    Not to be confused with :meth:`config` method that suites, tests,
    and keywords have to make it possible to set multiple attributes in
    one call.
    """
    super().configure()    # Parent validates is call allowed.
    self.visit(SuiteConfigurer(**options))

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

filter(included_suites=None, included_tests=None, included_tags=None, excluded_tags=None)

Select test cases and remove others from this suite.

Parameters have the same semantics as --suite, --test, --include, and --exclude command line options. All of them can be given as a list of strings, or when selecting only one, as a single string.

Child suites that contain no tests after filtering are automatically removed.

Example::

1
2
suite.filter(included_tests=['Test 1', '* Example'],
             included_tags='priority-1')
Source code in src/robot/model/testsuite.py 
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
def filter(self, included_suites: 'Sequence[str]|None' = None,
           included_tests: 'Sequence[str]|None' = None,
           included_tags: 'Sequence[str]|None' = None,
           excluded_tags: 'Sequence[str]|None' = None):
    """Select test cases and remove others from this suite.

    Parameters have the same semantics as ``--suite``, ``--test``,
    ``--include``, and ``--exclude`` command line options. All of them
    can be given as a list of strings, or when selecting only one, as
    a single string.

    Child suites that contain no tests after filtering are automatically
    removed.

    Example::

        suite.filter(included_tests=['Test 1', '* Example'],
                     included_tags='priority-1')
    """
    self.visit(Filter(included_suites, included_tests,
                      included_tags, excluded_tags))

filter_messages(log_level='TRACE')

Remove log messages below the specified log_level.

Source code in src/robot/result/model.py 
1048
1049
1050
def filter_messages(self, log_level: str = 'TRACE'):
    """Remove log messages below the specified ``log_level``."""
    self.visit(MessageFilter(log_level))

from_dict(data) classmethod

Create suite based on result data in a dictionary.

data can either contain only the suite data got, for example, from the :meth:to_dict method, or it can contain full result data with execution errors and other such information in addition to the suite data. In the latter case only the suite data is used, though.

Support for full result data is new in Robot Framework 7.2.

Source code in src/robot/result/model.py 
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
@classmethod
def from_dict(cls, data: DataDict) -> 'TestSuite':
    """Create suite based on result data in a dictionary.

    ``data`` can either contain only the suite data got, for example, from
    the :meth:`to_dict` method, or it can contain full result data with
    execution errors and other such information in addition to the suite data.
    In the latter case only the suite data is used, though.

    Support for full result data is new in Robot Framework 7.2.
    """
    if 'suite' in data:
        data = data['suite']
    return super().from_dict(data)

from_json(source) classmethod

Create suite based on results in JSON.

The data is given as the source parameter. It can be:

  • a string containing the data directly,
  • 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.

Supports JSON produced by :meth:to_json that contains only the suite information, as well as full result JSON that contains also execution errors and other information. In the latter case errors and all other information is silently ignored, though. If that is a problem, :class:~robot.result.resultbuilder.ExecutionResult should be used instead.

Support for full result JSON is new in Robot Framework 7.2.

Source code in src/robot/result/model.py 
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
@classmethod
def from_json(cls, source: 'str|bytes|TextIO|Path') -> 'TestSuite':
    """Create suite based on results in JSON.

    The data is given as the ``source`` parameter. It can be:

    - a string containing the data directly,
    - 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.

    Supports JSON produced by :meth:`to_json` that contains only the suite
    information, as well as full result JSON that contains also execution
    errors and other information. In the latter case errors and all other
    information is silently ignored, though. If that is a problem,
    :class:`~robot.result.resultbuilder.ExecutionResult` should be used
    instead.

    Support for full result JSON is new in Robot Framework 7.2.
    """
    return super().from_json(source)

from_xml(source) classmethod

Create suite based on results in XML.

The data is given as the source parameter. It can be:

  • a string containing the data directly,
  • 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.

Supports both normal output.xml files and files containing only the <suite> structure created, for example, with the :meth:to_xml method. When using normal output.xml files, possible execution errors listed in <errors> are silently ignored. If that is a problem, :class:~robot.result.resultbuilder.ExecutionResult should be used instead.

New in Robot Framework 7.0.

Source code in src/robot/result/model.py 
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
@classmethod
def from_xml(cls, source: 'str|TextIO|Path') -> 'TestSuite':
    """Create suite based on results in XML.

    The data is given as the ``source`` parameter. It can be:

    - a string containing the data directly,
    - 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.

    Supports both normal output.xml files and files containing only the
    ``<suite>`` structure created, for example, with the :meth:`to_xml`
    method. When using normal output.xml files, possible execution errors
    listed in ``<errors>`` are silently ignored. If that is a problem,
    :class:`~robot.result.resultbuilder.ExecutionResult` should be used
    instead.

    New in Robot Framework 7.0.
    """
    from .resultbuilder import ExecutionResult

    return ExecutionResult(source).suite

handle_suite_teardown_failures()

Internal usage only.

Source code in src/robot/result/model.py 
1073
1074
1075
def handle_suite_teardown_failures(self):
    """Internal usage only."""
    self.visit(SuiteTeardownFailureHandler())

metadata(metadata)

Free suite metadata as a :class:~.metadata.Metadata object.

Source code in src/robot/model/testsuite.py 
208
209
210
211
@setter
def metadata(self, metadata: 'Mapping[str, str]|None') -> Metadata:
    """Free suite metadata as a :class:`~.metadata.Metadata` object."""
    return Metadata(metadata)

name_from_source(source, extension=()) staticmethod

Create suite name based on the given source.

This method is used by Robot Framework itself when it builds suites. External parsers and other tools that want to produce suites with names matching names created by Robot Framework can use this method as well. This method is also used if :attr:name is not set and someone accesses it.

The algorithm is as follows:

  • If the source is None or empty, return an empty string.
  • Get the base name of the source. Read more below.
  • Remove possible prefix separated with __.
  • Convert underscores to spaces.
  • If the name is all lower case, title case it.

The base name of files is got by calling Path.stem__ that drops the file extension. It typically works fine, but gives wrong result if the extension has multiple parts like in tests.robot.zip. That problem can be avoided by giving valid file extension or extensions as the optional extension argument.

Examples::

1
2
3
TestSuite.name_from_source(source)
TestSuite.name_from_source(source, extension='.robot.zip')
TestSuite.name_from_source(source, ('.robot', '.robot.zip'))

__ https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.stem

Source code in src/robot/model/testsuite.py 
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
@staticmethod
def name_from_source(source: 'Path|str|None', extension: Sequence[str] = ()) -> str:
    """Create suite name based on the given ``source``.

    This method is used by Robot Framework itself when it builds suites.
    External parsers and other tools that want to produce suites with
    names matching names created by Robot Framework can use this method as
    well. This method is also used if :attr:`name` is not set and someone
    accesses it.

    The algorithm is as follows:

    - If the source is ``None`` or empty, return an empty string.
    - Get the base name of the source. Read more below.
    - Remove possible prefix separated with ``__``.
    - Convert underscores to spaces.
    - If the name is all lower case, title case it.

    The base name of files is got by calling `Path.stem`__ that drops
    the file extension. It typically works fine, but gives wrong result
    if the extension has multiple parts like in ``tests.robot.zip``.
    That problem can be avoided by giving valid file extension or extensions
    as the optional ``extension`` argument.

    Examples::

        TestSuite.name_from_source(source)
        TestSuite.name_from_source(source, extension='.robot.zip')
        TestSuite.name_from_source(source, ('.robot', '.robot.zip'))

    __ https://docs.python.org/3/library/pathlib.html#pathlib.PurePath.stem
    """
    if not source:
        return ''
    if not isinstance(source, Path):
        source = Path(source)
    name = TestSuite._get_base_name(source, extension)
    if '__' in name:
        name = name.split('__', 1)[1] or name
    name = name.replace('_', ' ').strip()
    return name.title() if name.islower() else name

remove_empty_suites(preserve_direct_children=False)

Removes all child suites not containing any tests, recursively.

Source code in src/robot/model/testsuite.py 
414
415
416
def remove_empty_suites(self, preserve_direct_children: bool = False):
    """Removes all child suites not containing any tests, recursively."""
    self.visit(EmptySuiteRemover(preserve_direct_children))

remove_keywords(how)

Remove keywords based on the given condition.

:param how: Which approach to use when removing keywords. Either ALL, PASSED, FOR, WUKS, or NAME:<pattern>.

For more information about the possible values see the documentation of the --removekeywords command line option.

Source code in src/robot/result/model.py 
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
def remove_keywords(self, how: str):
    """Remove keywords based on the given condition.

    :param how: Which approach to use when removing keywords. Either
        ``ALL``, ``PASSED``, ``FOR``, ``WUKS``, or ``NAME:<pattern>``.

    For more information about the possible values see the documentation
    of the ``--removekeywords`` command line option.
    """
    self.visit(KeywordRemover.from_config(how))

set_tags(add=(), remove=(), persist=False)

Add and/or remove specified tags to the tests in this suite.

:param add: Tags to add as a list or, if adding only one, as a single string. :param remove: Tags to remove as a list or as a single string. Can be given as patterns where * and ? work as wildcards. :param persist: Add/remove specified tags also to new tests added to this suite in the future.

Source code in src/robot/model/testsuite.py 
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
def set_tags(self, add: Sequence[str] = (), remove: Sequence[str] = (),
             persist: bool = False):
    """Add and/or remove specified tags to the tests in this suite.

    :param add: Tags to add as a list or, if adding only one,
        as a single string.
    :param remove: Tags to remove as a list or as a single string.
        Can be given as patterns where ``*`` and ``?`` work as wildcards.
    :param persist: Add/remove specified tags also to new tests added
        to this suite in the future.
    """
    setter = TagSetter(add, remove)
    self.visit(setter)
    if persist:
        self._my_visitors.append(setter)

suite_teardown_failed(message)

Internal usage only.

Source code in src/robot/result/model.py 
1077
1078
1079
def suite_teardown_failed(self, message: str):
    """Internal usage only."""
    self.visit(SuiteTeardownFailed(message))

suite_teardown_skipped(message)

Internal usage only.

Source code in src/robot/result/model.py 
1081
1082
1083
def suite_teardown_skipped(self, message: str):
    """Internal usage only."""
    self.visit(SuiteTeardownFailed(message, skipped=True))

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)

to_xml(file=None)

Serialize suite into XML.

The format is the same that is used with normal output.xml files, but the <robot> root node is omitted and the result contains only the <suite> structure.

The file parameter controls what to do with the resulting XML data. It can be:

  • None (default) to return the data as a string,
  • 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.

A serialized suite can be recreated by using the :meth:from_xml method.

New in Robot Framework 7.0.

Source code in src/robot/result/model.py 
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
def to_xml(self, file: 'None|TextIO|Path|str' = None) -> 'str|None':
    """Serialize suite into XML.

    The format is the same that is used with normal output.xml files, but
    the ``<robot>`` root node is omitted and the result contains only
    the ``<suite>`` structure.

    The ``file`` parameter controls what to do with the resulting XML data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    A serialized suite can be recreated by using the :meth:`from_xml` method.

    New in Robot Framework 7.0.
    """
    from robot.reporting.outputwriter import OutputWriter

    output, close = self._get_output(file)
    try:
        self.visit(OutputWriter(output, suite_only=True))
    finally:
        if close:
            output.close()
    return output.getvalue() if file is None else None

validate_execution_mode()

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.

Source code in src/robot/model/testsuite.py 
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
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

visit(visitor)

:mod:Visitor interface <robot.model.visitor> entry-point.

Source code in src/robot/model/testsuite.py 
418
419
420
def visit(self, visitor: SuiteVisitor):
    """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
    visitor.visit_suite(self)

Var

Bases: Var, StatusMixin, DeprecatedAttributesMixin

Source code in src/robot/result/model.py 
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
@Body.register
class Var(model.Var, StatusMixin, DeprecatedAttributesMixin):
    __slots__ = ['status', 'message', '_start_time', '_end_time', '_elapsed_time']
    body_class = Body

    def __init__(self, name: str = '',
                 value: 'str|Sequence[str]' = (),
                 scope: 'str|None' = None,
                 separator: 'str|None' = None,
                 status: str = 'FAIL',
                 message: str = '',
                 start_time: 'datetime|str|None' = None,
                 end_time: 'datetime|str|None' = None,
                 elapsed_time: 'timedelta|int|float|None' = None,
                 parent: BodyItemParent = None):
        super().__init__(name, value, scope, separator, parent)
        self.status = status
        self.message = message
        self.start_time = start_time
        self.end_time = end_time
        self.elapsed_time = elapsed_time
        self.body = ()

    @setter
    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
        """Child keywords and messages as a :class:`~.Body` object.

        Typically empty. Only contains something if running VAR has failed
        due to a syntax error or listeners have logged messages or executed
        keywords.
        """
        return self.body_class(self, body)

    @property
    def _log_name(self):
        return str(self)[7:]    # Drop 'VAR    ' prefix.

    def to_dict(self) -> DataDict:
        data = {**super().to_dict(), **StatusMixin.to_dict(self)}
        if self.body:
            data['body'] = self.body.to_dicts()
        return data

elapsedtime: int property

Total execution time in milliseconds.

Considered deprecated starting from Robot Framework 7.0. :attr:elapsed_time should be used instead.

endtime: str | None property writable

Execution end time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:end_time should be used instead.

failed: bool property writable

True when :attr:status is 'FAIL', False otherwise.

id: str | None property

Item id in format like s1-t3-k1.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

id is None only in these special cases:

  • Keyword uses a placeholder for setup or teardown when a setup or teardown is not actually used.
  • With :class:~robot.model.control.If and :class:~robot.model.control.Try instances representing IF/TRY structure roots.

not_run: bool property writable

True when :attr:status is 'NOT RUN', False otherwise.

Setting to False value is ambiguous and raises an exception.

passed: bool property writable

True when :attr:status is 'PASS', False otherwise.

skipped: bool property writable

True when :attr:status is 'SKIP', False otherwise.

Setting to False value is ambiguous and raises an exception.

starttime: str | None property writable

Execution start time as a string or as a None if not set.

The string format is %Y%m%d %H:%M:%S.%f.

Considered deprecated starting from Robot Framework 7.0. :attr:start_time should be used instead.

body(body)

Child keywords and messages as a :class:~.Body object.

Typically empty. Only contains something if running VAR has failed due to a syntax error or listeners have logged messages or executed keywords.

Source code in src/robot/result/model.py 
529
530
531
532
533
534
535
536
537
@setter
def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
    """Child keywords and messages as a :class:`~.Body` object.

    Typically empty. Only contains something if running VAR has failed
    due to a syntax error or listeners have logged messages or executed
    keywords.
    """
    return self.body_class(self, body)

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

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.

Source code in src/robot/model/modelobject.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """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)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

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 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 created using the :meth:from_dict method.

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.

Source code in src/robot/model/modelobject.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    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 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
    created using the :meth:`from_dict` method.

    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)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

  • None (default) to return the data as a string,
  • 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.

JSON formatting can be configured using optional parameters that 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

Source code in src/robot/model/modelobject.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - 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.

    JSON formatting can be configured using optional parameters that
    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,
                      separators=separators).dump(self.to_dict(), file)