Skip to content

settings

FixtureDict

Bases: OptionalItems

Dictionary containing setup or teardown info.

:attr:args and :attr:lineno are optional.

Source code in src/robot/running/builder/settings.py 
27
28
29
30
31
32
class FixtureDict(OptionalItems):
    """Dictionary containing setup or teardown info.

    :attr:`args` and :attr:`lineno` are optional.
    """
    name: str

TestDefaults

Represents default values for test related settings set in init files.

Parsers parsing suite files can read defaults and parsers parsing init files can set them. The easiest way to set defaults to a test is using the :meth:set_to method.

This class is part of the public parser API__. When implementing parse or parse_init method so that they accept two arguments, the second is an instance of this class. If the class is needed as a type hint, it can be imported via :mod:robot.running or :mod:robot.api.interfaces.

__ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#parser-interface

Source code in src/robot/running/builder/settings.py 
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 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
 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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
class TestDefaults:
    """Represents default values for test related settings set in init files.

    Parsers parsing suite files can read defaults and parsers parsing init
    files can set them. The easiest way to set defaults to a test is using
    the :meth:`set_to` method.

    This class is part of the `public parser API`__. When implementing ``parse``
    or ``parse_init`` method so that they accept two arguments, the second is
    an instance of this class. If the class is needed as a type hint, it can
    be imported via :mod:`robot.running` or :mod:`robot.api.interfaces`.

    __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#parser-interface
    """

    def __init__(self, parent: 'TestDefaults|None' = None,
                 setup: 'FixtureDict|None' = None,
                 teardown: 'FixtureDict|None' = None,
                 tags: 'Sequence[str]' = (), timeout: 'str|None' = None):
        self.parent = parent
        self.setup = setup
        self.teardown = teardown
        self.tags = tags
        self.timeout = timeout

    @property
    def setup(self) -> 'FixtureDict|None':
        """Default setup as a ``Keyword`` object or ``None`` when not set.

        Can be set also using a dictionary.
        """
        if self._setup:
            return self._setup
        if self.parent:
            return self.parent.setup
        return None

    @setup.setter
    def setup(self, setup: 'FixtureDict|None'):
        self._setup = setup

    @property
    def teardown(self) -> 'FixtureDict|None':
        """Default teardown as a ``Keyword`` object or ``None`` when not set.

        Can be set also using a dictionary.
        """
        if self._teardown:
            return self._teardown
        if self.parent:
            return self.parent.teardown
        return None

    @teardown.setter
    def teardown(self, teardown: 'FixtureDict|None'):
        self._teardown = teardown

    @property
    def tags(self) -> 'tuple[str, ...]':
        """Default tags. Can be set also as a sequence."""
        return self._tags + self.parent.tags if self.parent else self._tags

    @tags.setter
    def tags(self, tags: 'Sequence[str]'):
        self._tags = tuple(tags)

    @property
    def timeout(self) -> 'str|None':
        """Default timeout."""
        if self._timeout:
            return self._timeout
        if self.parent:
            return self.parent.timeout
        return None

    @timeout.setter
    def timeout(self, timeout: 'str|None'):
        self._timeout = timeout

    def set_to(self, test: TestCase):
        """Sets defaults to the given test.

        Tags are always added to the test. Setup, teardown and timeout are
        set only if the test does not have them set initially.
        """
        if self.tags:
            test.tags += self.tags
        if self.setup and not test.has_setup:
            test.setup.config(**self.setup)
        if self.teardown and not test.has_teardown:
            test.teardown.config(**self.teardown)
        if self.timeout and not test.timeout:
            test.timeout = self.timeout

setup: FixtureDict | None property writable

Default setup as a Keyword object or None when not set.

Can be set also using a dictionary.

tags: tuple[str, ...] property writable

Default tags. Can be set also as a sequence.

teardown: FixtureDict | None property writable

Default teardown as a Keyword object or None when not set.

Can be set also using a dictionary.

timeout: str | None property writable

Default timeout.

set_to(test)

Sets defaults to the given test.

Tags are always added to the test. Setup, teardown and timeout are set only if the test does not have them set initially.

Source code in src/robot/running/builder/settings.py 
114
115
116
117
118
119
120
121
122
123
124
125
126
127
def set_to(self, test: TestCase):
    """Sets defaults to the given test.

    Tags are always added to the test. Setup, teardown and timeout are
    set only if the test does not have them set initially.
    """
    if self.tags:
        test.tags += self.tags
    if self.setup and not test.has_setup:
        test.setup.config(**self.setup)
    if self.teardown and not test.has_teardown:
        test.teardown.config(**self.teardown)
    if self.timeout and not test.timeout:
        test.timeout = self.timeout