robot.running package

Implements the core test execution logic.

The public API of this module consists of the following objects:

TestSuite and TestSuiteBuilder can be imported via the robot.api package. If other classes are needed directly, they can be imported via robot.running.

Note

Prior to Robot Framework 6.1, only some classes in robot.running.model were exposed via robot.running.

Examples

First, let’s assume we have the following test suite in file activate_skynet.robot:

*** Settings ***
Library    OperatingSystem

*** Test Cases ***
Should Activate Skynet
    [Tags]    smoke
    [Setup]    Set Environment Variable    SKYNET    activated
    Environment Variable Should Be Set    SKYNET

We can easily create an executable test suite based on the above file:

from robot.api import TestSuite

suite = TestSuite.from_file_system('path/to/activate_skynet.robot')

That was easy. Let’s next generate the same test suite from scratch:

from robot.api import TestSuite

suite = TestSuite('Activate Skynet')
suite.resource.imports.library('OperatingSystem')
test = suite.tests.create('Should Activate Skynet', tags=['smoke'])
test.setup.config(name='Set Environment Variable', args=['SKYNET', 'activated'])
test.body.create_keyword('Environment Variable Should Be Set', args=['SKYNET'])

Not that complicated either, especially considering the flexibility. Notice that the suite created based on the file could also be edited further using the same API.

Now that we have a test suite ready, let’s execute it and verify that the returned Result object contains correct information:

result = suite.run(output='skynet.xml')

assert result.return_code == 0
assert result.suite.name == 'Activate Skynet'
test = result.suite.tests[0]
assert test.name == 'Should Activate Skynet'
assert test.passed
stats = result.suite.statistics
assert stats.total == 1 and stats.passed == 1 and stats.failed == 0

Running the suite generates a normal output XML file, unless it is disabled by using output=None. Generating log, report, and xUnit files based on the results is possible using the ResultWriter class:

from robot.api import ResultWriter

# Report and xUnit files can be generated based on the result object.
ResultWriter(result).write_results(report='skynet.html', log=None)
# Generating log files requires processing the earlier generated output XML.
ResultWriter('skynet.xml').write_results()

Submodules

robot.running.bodyrunner module

class robot.running.bodyrunner.BodyRunner(context, run=True, templated=False)[source]

Bases: object

run(body)[source]
class robot.running.bodyrunner.KeywordRunner(context, run=True)[source]

Bases: object

run(step, name=None)[source]
robot.running.bodyrunner.ForRunner(context, flavor='IN', run=True, templated=False)[source]
class robot.running.bodyrunner.ForInRunner(context, run=True, templated=False)[source]

Bases: object

flavor = 'IN'
run(data)[source]
class robot.running.bodyrunner.ForInRangeRunner(context, run=True, templated=False)[source]

Bases: robot.running.bodyrunner.ForInRunner

flavor = 'IN RANGE'
run(data)
class robot.running.bodyrunner.ForInZipRunner(context, run=True, templated=False)[source]

Bases: robot.running.bodyrunner.ForInRunner

flavor = 'IN ZIP'
run(data)
class robot.running.bodyrunner.ForInEnumerateRunner(context, run=True, templated=False)[source]

Bases: robot.running.bodyrunner.ForInRunner

flavor = 'IN ENUMERATE'
run(data)
class robot.running.bodyrunner.WhileRunner(context, run=True, templated=False)[source]

Bases: object

run(data)[source]
class robot.running.bodyrunner.IfRunner(context, run=True, templated=False)[source]

Bases: object

run(data)[source]
class robot.running.bodyrunner.TryRunner(context, run=True, templated=False)[source]

Bases: object

run(data)[source]
class robot.running.bodyrunner.WhileLimit[source]

Bases: object

classmethod create(limit, variables)[source]
limit_exceeded()[source]
class robot.running.bodyrunner.DurationLimit(max_time)[source]

Bases: robot.running.bodyrunner.WhileLimit

classmethod create(limit, variables)
limit_exceeded()
class robot.running.bodyrunner.IterationCountLimit(max_iterations)[source]

Bases: robot.running.bodyrunner.WhileLimit

classmethod create(limit, variables)
limit_exceeded()
class robot.running.bodyrunner.NoLimit[source]

Bases: robot.running.bodyrunner.WhileLimit

classmethod create(limit, variables)
limit_exceeded()

robot.running.context module

class robot.running.context.ExecutionContexts[source]

Bases: object

current
top
namespaces
start_suite(suite, namespace, output, dry_run=False)[source]
end_suite()[source]

robot.running.dynamicmethods module

robot.running.dynamicmethods.no_dynamic_method(*args)[source]
class robot.running.dynamicmethods.GetKeywordNames(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

name
class robot.running.dynamicmethods.RunKeyword(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

supports_kwargs
name
class robot.running.dynamicmethods.GetKeywordDocumentation(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

name
class robot.running.dynamicmethods.GetKeywordArguments(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

name
class robot.running.dynamicmethods.GetKeywordTypes(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

name
class robot.running.dynamicmethods.GetKeywordTags(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

name
class robot.running.dynamicmethods.GetKeywordSource(lib)[source]

Bases: robot.running.dynamicmethods._DynamicMethod

name

robot.running.handlers module

robot.running.handlers.Handler(library, name, method)[source]
robot.running.handlers.DynamicHandler(library, name, method, doc, argspec, tags=None)[source]
robot.running.handlers.InitHandler(library, method=None, docgetter=None)[source]
class robot.running.handlers.EmbeddedArgumentsHandler(embedded, orig_handler)[source]

Bases: object

supports_embedded_args = True
library
matches(name)[source]
create_runner(name, languages=None)[source]
resolve_arguments(args, variables=None, languages=None)[source]

robot.running.handlerstore module

class robot.running.handlerstore.HandlerStore[source]

Bases: object

add(handler, embedded=False)[source]
get_handlers(name)[source]

robot.running.importer module

class robot.running.importer.Importer[source]

Bases: object

reset()[source]
close_global_library_listeners()[source]
import_library(name, args, alias, variables)[source]
import_resource(path, lang=None)[source]
class robot.running.importer.ImportCache[source]

Bases: object

Keeps track on and optionally caches imported items.

Handles paths in keys case-insensitively on case-insensitive OSes. Unlike dicts, this storage accepts mutable values in keys.

add(key, item=None)[source]
values()[source]

robot.running.librarykeywordrunner module

class robot.running.librarykeywordrunner.LibraryKeywordRunner(handler, name=None, languages=None)[source]

Bases: object

library
libname
longname
run(kw, context, run=True)[source]
dry_run(kw, context)[source]
class robot.running.librarykeywordrunner.EmbeddedArgumentsRunner(handler, name)[source]

Bases: robot.running.librarykeywordrunner.LibraryKeywordRunner

dry_run(kw, context)
libname
library
longname
run(kw, context, run=True)
class robot.running.librarykeywordrunner.RunKeywordRunner(handler, execute_in_dry_run=False)[source]

Bases: robot.running.librarykeywordrunner.LibraryKeywordRunner

dry_run(kw, context)
libname
library
longname
run(kw, context, run=True)

robot.running.libraryscopes module

robot.running.libraryscopes.LibraryScope(libcode, library)[source]
class robot.running.libraryscopes.GlobalScope(library)[source]

Bases: object

is_global = True
start_suite()[source]
end_suite()[source]
start_test()[source]
end_test()[source]
class robot.running.libraryscopes.TestSuiteScope(library)[source]

Bases: robot.running.libraryscopes.GlobalScope

is_global = False
start_suite()[source]
end_suite()[source]
end_test()
start_test()
class robot.running.libraryscopes.TestCaseScope(library)[source]

Bases: robot.running.libraryscopes.TestSuiteScope

start_test()[source]
end_test()[source]
end_suite()
is_global = False
start_suite()

robot.running.model module

Module implementing test execution related model objects.

When tests are executed by Robot Framework, a TestSuite structure using classes defined in this module is created by TestSuiteBuilder based on data on a file system. In addition to that, external tools can create executable suite structures programmatically.

Regardless the approach to construct it, a TestSuite object is executed by calling its run() method as shown in the example in the robot.running package level documentation. When a suite is run, test, keywords, and other objects it contains can be inspected and modified by using pre-run modifiers and listeners.

The TestSuite class is exposed via the robot.api package. If other classes are needed, they can be imported from robot.running.

class robot.running.model.Body(parent=None, items=None)[source]

Bases: robot.model.body.Body

append(item)

S.append(value) – append value to the end of the sequence

break_class

alias of Break

clear() → None -- remove all items from S
continue_class

alias of Continue

count(value) → integer -- return number of occurrences of value
create

Create a new item using the provided arguments.

create_break(*args, **kwargs)
create_continue(*args, **kwargs)
create_error(*args, **kwargs)
create_for(*args, **kwargs)
create_if(*args, **kwargs)
create_keyword(*args, **kwargs)
create_message(*args, **kwargs)
create_return(*args, **kwargs)
create_try(*args, **kwargs)
create_while(*args, **kwargs)
error_class

alias of Error

extend(items)

S.extend(iterable) – extend sequence by appending elements from the iterable

filter(keywords=None, messages=None, predicate=None)

Filter body items based on type and/or custom predicate.

To include or exclude items based on types, give matching arguments True or False values. For example, to include only keywords, use body.filter(keywords=True) and to exclude messages use body.filter(messages=False). Including and excluding by types at the same time is not supported and filtering my messages is supported only if the Body object actually supports messages.

Custom predicate is a callable getting each body item as an argument that must return True/False depending on should the item be included or not.

Selected items are returned as a list and the original body is not modified.

It was earlier possible to filter also based on FOR and IF types. That support was removed in RF 5.0 because it was not considered useful in general and because adding support for all new control structures would have required extra work. To exclude all control structures, use body.filter(keywords=True, messages=True) and to only include them use body.filter(keywords=False, messages=False)``. For more detailed filtering it is possible to use predicate.

flatten()

Return steps so that IF and TRY structures are flattened.

Basically the IF/ELSE and TRY/EXCEPT root elements are replaced with their branches. This is how they are shown in log files.

for_class

alias of For

if_class

alias of If

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

insert(index, item)

S.insert(index, value) – insert value before index

keyword_class

alias of Keyword

message_class = None
pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

classmethod register(item_class)

Register a virtual subclass of an ABC.

Returns the subclass, to allow usage as a class decorator.

remove(value)

S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

return_class

alias of Return

reverse()

S.reverse() – reverse IN PLACE

sort()
to_dicts()

Return list of items converted to dictionaries.

Items are converted to dictionaries using the to_dict method, if they have it, or the built-in vars().

New in Robot Framework 6.1.

try_class

alias of Try

visit(visitor)
while_class

alias of While

class robot.running.model.Keyword(name='', args=(), assign=(), type='KEYWORD', parent=None, lineno=None)[source]

Bases: robot.model.keyword.Keyword

Represents an executable keyword call.

A keyword call consists only of a keyword name, arguments and possible assignment in the data:

Keyword    arg
${result} =    Another Keyword    arg1    arg2

The actual keyword that is executed depends on the context where this model is executed.

lineno
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

run(context, run=True, templated=None)[source]
BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
args
assign
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

name
parent
repr_args = ('name', 'args', 'assign')
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 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, or
  • a path 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.

type
visit(visitor)[source]

Visitor interface entry-point.

class robot.running.model.For(variables=(), flavor='IN', values=(), start=None, mode=None, fill=None, parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.For

body_class

alias of Body

lineno
error
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

run(context, run=True, templated=False)[source]
BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

fill
flavor
classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

keywords

Deprecated since Robot Framework 4.0. Use body instead.

mode
parent
repr_args = ('variables', 'flavor', 'values', 'start', 'mode', 'fill')
start
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 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, or
  • a path 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.

type = 'FOR'
values
variables
visit(visitor)[source]
class robot.running.model.While(condition=None, limit=None, parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.While

body_class

alias of Body

lineno
error
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

run(context, run=True, templated=False)[source]
BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
body
condition
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

limit
parent
repr_args = ('condition', 'limit')
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 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, or
  • a path 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.

type = 'WHILE'
visit(visitor)[source]
class robot.running.model.IfBranch(type='IF', condition=None, parent=None, lineno=None)[source]

Bases: robot.model.control.IfBranch

body_class

alias of Body

lineno
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
body
condition
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Branch id omits IF/ELSE root from the parent id part.

parent
repr_args = ('type', 'condition')
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 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, or
  • a path 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.

type
visit(visitor)[source]
class robot.running.model.If(parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.If

branch_class

alias of IfBranch

lineno
error
source
run(context, run=True, templated=False)[source]
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
body
branches_class

alias of robot.model.body.Branches

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Root IF/ELSE id is always None.

parent
repr_args = ()
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 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, or
  • a path 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.

type = 'IF/ELSE ROOT'
visit(visitor)[source]
class robot.running.model.TryBranch(type='TRY', patterns=(), pattern_type=None, variable=None, parent=None, lineno=None)[source]

Bases: robot.model.control.TryBranch

body_class

alias of Body

lineno
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Branch id omits TRY/EXCEPT root from the parent id part.

parent
pattern_type
patterns
repr_args = ('type', 'patterns', 'pattern_type', 'variable')
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 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, or
  • a path 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.

type
variable
visit(visitor)[source]
class robot.running.model.Try(parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.Try

branch_class

alias of TryBranch

lineno
error
source
run(context, run=True, templated=False)[source]
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
body
branches_class

alias of robot.model.body.Branches

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

else_branch
except_branches
finally_branch
classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Root TRY/EXCEPT id is always None.

parent
repr_args = ()
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 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, or
  • a path 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.

try_branch
type = 'TRY/EXCEPT ROOT'
visit(visitor)[source]
class robot.running.model.Return(values=(), parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.Return

lineno
error
source
run(context, run=True, templated=False)[source]
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

parent
repr_args = ('values',)
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 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, or
  • a path 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.

type = 'RETURN'
values
visit(visitor)[source]
class robot.running.model.Continue(parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.Continue

lineno
error
source
run(context, run=True, templated=False)[source]
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

parent
repr_args = ()
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 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, or
  • a path 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.

type = 'CONTINUE'
visit(visitor)[source]
class robot.running.model.Break(parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.Break

lineno
error
source
run(context, run=True, templated=False)[source]
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

parent
repr_args = ()
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 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, or
  • a path 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.

type = 'BREAK'
visit(visitor)[source]
class robot.running.model.Error(values, parent=None, lineno=None, error=None)[source]

Bases: robot.model.control.Error

lineno
error
source
run(context, run=True, templated=False)[source]
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

BREAK = 'BREAK'
CONTINUE = 'CONTINUE'
ELSE = 'ELSE'
ELSE_IF = 'ELSE IF'
ERROR = 'ERROR'
EXCEPT = 'EXCEPT'
FINALLY = 'FINALLY'
FOR = 'FOR'
IF = 'IF'
IF_ELSE_ROOT = 'IF/ELSE ROOT'
ITERATION = 'ITERATION'
KEYWORD = 'KEYWORD'
MESSAGE = 'MESSAGE'
RETURN = 'RETURN'
SETUP = 'SETUP'
TEARDOWN = 'TEARDOWN'
TRY = 'TRY'
TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
WHILE = 'WHILE'
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

id

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

parent
repr_args = ()
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 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, or
  • a path 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.

type = 'ERROR'
values
visit(visitor)[source]
class robot.running.model.TestCase(name='', doc='', tags=None, timeout=None, template=None, lineno=None, error=None)[source]

Bases: robot.model.testcase.TestCase

Represents a single executable test case.

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

body_class

Internal usage only.

alias of Body

fixture_class

Internal usage only.

alias of Keyword

template
error
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

body

Test body as a Body object.

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

doc
classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

has_setup

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 setup attribute creates a 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

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

See has_setup for more information.

New in Robot Framework 5.0.

id

Test case id in format like s1-t3.

See TestSuite.id for more information.

keywords

Deprecated since Robot Framework 4.0

Use body, setup or teardown instead.

lineno
longname

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

name
parent
repr_args = ('name',)
setup

Test setup as a 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:

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

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

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:

test.setup = None

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

tags

Test tags as a Tags object.

teardown

Test teardown as a Keyword object.

See setup for more information.

timeout
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 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, or
  • a path 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.

visit(visitor)[source]

Visitor interface entry-point.

class robot.running.model.TestSuite(name='', doc='', metadata=None, source=None, rpa=None)[source]

Bases: robot.model.testsuite.TestSuite

Represents a single executable test suite.

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

test_class

Internal usage only.

alias of TestCase

fixture_class

Internal usage only.

alias of Keyword

resource

ResourceFile instance containing imports, variables and keywords the suite owns. When data is parsed from the file system, this data comes from the same test case file that creates the suite.

classmethod from_file_system(*paths, **config)[source]

Create a TestSuite object based on the given paths.

paths are file or directory paths where to read the data from.

Internally utilizes the TestSuiteBuilder class and config can be used to configure how it is initialized.

New in Robot Framework 3.2.

classmethod from_model(model, name=None)[source]

Create a TestSuite object based on the given model.

The model can be created by using the get_model() function and possibly modified by other tooling in the robot.parsing module.

The name argument is deprecated since Robot Framework 6.1. Users should set the name and possible other attributes to the returned suite separately. One easy way is using the config() method like this:

suite = TestSuite.from_model(model).config(name='X', doc='Example')

New in Robot Framework 3.2.

classmethod from_string(string, **config)[source]

Create a TestSuite object based on the given string.

The string is internally parsed into a model by using the get_model() function and config can be used to configure it. The model is then converted into a suite by using from_model().

New in Robot Framework 6.1.

configure(randomize_suites=False, randomize_tests=False, randomize_seed=None, **options)[source]

A shortcut to configure a suite using one method call.

Can only be used with the root test suite.

Parameters:

Example:

suite.configure(included_tags=['smoke'],
                doc='Smoke test results.')

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

randomize(suites=True, tests=True, seed=None)[source]

Randomizes the order of suites and/or tests, recursively.

Parameters:
  • suites – Boolean controlling should suites be randomized.
  • tests – Boolean controlling should tests be randomized.
  • seed – Random seed. Can be given if previous random order needs to be re-created. Seed value is always shown in logs and reports.
run(settings=None, **options)[source]

Executes the suite based on the given settings or options.

Parameters:
  • settingsRobotSettings object to configure test execution.
  • options – Used to construct new RobotSettings object if settings are not given.
Returns:

Result object with information about executed suites and tests.

If options are used, their names are the same as long command line options except without hyphens. Some options are ignored (see below), but otherwise they have the same semantics as on the command line. Options that can be given on the command line multiple times can be passed as lists like variable=['VAR1:value1', 'VAR2:value2']. If such an option is used only once, it can be given also as a single string like variable='VAR:value'.

Additionally listener option allows passing object directly instead of listener name, e.g. run('tests.robot', listener=Listener()).

To capture stdout and/or stderr streams, pass open file objects in as special keyword arguments stdout and stderr, respectively.

Only options related to the actual test execution have an effect. For example, options related to selecting or modifying test cases or suites (e.g. --include, --name, --prerunmodifier) or creating logs and reports are silently ignored. The output XML generated as part of the execution can be configured, though. This includes disabling it with output=None.

Example:

stdout = StringIO()
result = suite.run(variable='EXAMPLE:value',
                   output='example.xml',
                   exitonfailure=True,
                   stdout=stdout)
print(result.return_code)

To save memory, the returned Result object does not have any information about the executed keywords. If that information is needed, the created output XML file needs to be read using the ExecutionResult factory method.

See the package level documentation for more examples, including how to construct executable test suites and how to create logs and reports based on the execution results.

See the robot.run function for a higher-level API for executing tests in files or directories.

to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

all_tests

Yields all tests this suite and its child suites contain.

New in Robot Framework 6.1.

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

doc
filter(included_suites=None, included_tests=None, included_tags=None, excluded_tags=None)[source]

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')
classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

has_setup

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 setup attribute creates a Keyword object representing the setup even when the suite actually does not have one. This typically does not matter, but with bigger suite structures containing a huge about of suites it can have some effect on memory usage.

New in Robot Framework 5.0.

has_teardown

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

See has_setup for more information.

New in Robot Framework 5.0.

has_tests
id

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.

keywords

Deprecated since Robot Framework 4.0

Use setup or teardown instead.

longname

Suite name prefixed with the long name of the parent suite.

metadata

Free test suite metadata as a dictionary.

name

Test suite name.

If name is not set, it is constructed from source. If source is not set, name is constructed from child suite names or.

static name_from_source(source: pathlib.Path)[source]
parent
remove_empty_suites(preserve_direct_children=False)[source]

Removes all child suites not containing any tests, recursively.

repr_args = ('name',)
rpa
set_tags(add=None, remove=None, persist=False)[source]

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

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

Suite setup as a Keyword object.

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

Setup can be modified by setting attributes directly:

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

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

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:

suite.setup = None

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

source
suites

Child suites as a TestSuites object.

teardown

Suite teardown as a Keyword object.

See setup for more information.

test_count

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

tests

Tests as a TestCases object.

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 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, or
  • a path 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.

visit(visitor)[source]

Visitor interface entry-point.

class robot.running.model.Variable(name, value=(), parent=None, lineno=None, error=None)[source]

Bases: robot.model.modelobject.ModelObject

repr_args = ('name', 'value')
source
report_invalid_syntax(message, level='ERROR')[source]
classmethod from_dict(data)[source]

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

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 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, or
  • a path 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.

class robot.running.model.ResourceFile(source=None, parent=None, doc='')[source]

Bases: robot.model.modelobject.ModelObject

repr_args = ('source',)
parent
doc
source
imports
variables
keywords
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

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 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, or
  • a path 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.

class robot.running.model.UserKeyword(name='', args=(), doc='', tags=(), return_=None, timeout=None, lineno=None, parent=None, error=None)[source]

Bases: robot.model.modelobject.ModelObject

repr_args = ('name', 'args')
fixture_class

alias of Keyword

name
args
doc
return_
timeout
lineno
parent
error
body

Child keywords as a Body object.

keywords

Deprecated since Robot Framework 4.0.

Use body or teardown instead.

teardown
has_teardown

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

A difference between using if uk.has_teardown: and if uk.teardown: is that accessing the teardown attribute creates a Keyword object representing the teardown even when the user keyword actually does not have one. This can have an effect on memory usage.

New in Robot Framework 6.1.

tags
source
to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

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 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, or
  • a path 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.

class robot.running.model.Import(type, name, args=(), alias=None, parent=None, lineno=None)[source]

Bases: robot.model.modelobject.ModelObject

repr_args = ('type', 'name', 'args', 'alias')
LIBRARY = 'LIBRARY'
RESOURCE = 'RESOURCE'
VARIABLES = 'VARIABLES'
source
directory
setting_name
select(library, resource, variables)[source]
report_invalid_syntax(message, level='ERROR')[source]
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.

copy(**attributes)

Return a shallow copy of this object.

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

See also deepcopy(). The difference between copy and deepcopy is the same as with the methods having same names in the copy module.

deepcopy(**attributes)

Return a deep copy of this object.

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

See also copy(). The difference between deepcopy and copy is the same as with the methods having same names in the copy module.

classmethod from_dict(data)[source]

Create this object based on data in a dictionary.

Data can be got from the to_dict() method or created externally.

classmethod from_json(source)

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, or
  • a path (string or pathlib.Path) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the 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.

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 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, or
  • a path 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.

to_dict()[source]

Serialize this object into a dictionary.

The object can be later restored by using the from_dict() method.

class robot.running.model.Imports(parent, imports=None)[source]

Bases: robot.model.itemlist.ItemList

append(item)

S.append(value) – append value to the end of the sequence

clear() → None -- remove all items from S
count(value) → integer -- return number of occurrences of value
extend(items)

S.extend(iterable) – extend sequence by appending elements from the iterable

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

insert(index, item)

S.insert(index, value) – insert value before index

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

remove(value)

S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

reverse()

S.reverse() – reverse IN PLACE

sort()
to_dicts()

Return list of items converted to dictionaries.

Items are converted to dictionaries using the to_dict method, if they have it, or the built-in vars().

New in Robot Framework 6.1.

visit(visitor)
library(name, args=(), alias=None, lineno=None)[source]

Create library import.

resource(name, lineno=None)[source]

Create resource import.

variables(name, args=(), lineno=None)[source]

Create variables import.

create(*args, **kwargs)[source]

Generic method for creating imports.

Import type specific methods library(), resource() and variables() are recommended over this method.

robot.running.modelcombiner module

class robot.running.modelcombiner.ModelCombiner(data, result, **priority)[source]

Bases: object

data
result
priority

robot.running.namespace module

class robot.running.namespace.Namespace(variables, suite, resource, languages)[source]

Bases: object

libraries
handle_imports()[source]
import_resource(name, overwrite=True)[source]
import_variables(name, args, overwrite=False)[source]
import_library(name, args=(), alias=None, notify=True)[source]
set_search_order(new_order)[source]
start_test()[source]
end_test()[source]
start_suite()[source]
end_suite(suite)[source]
start_user_keyword()[source]
end_user_keyword()[source]
get_library_instance(libname)[source]
get_library_instances()[source]
reload_library(libname_or_instance)[source]
get_runner(name, recommend_on_failure=True)[source]
class robot.running.namespace.KeywordStore(resource, languages)[source]

Bases: object

get_library(name_or_instance)[source]
get_runner(name, recommend=True)[source]
class robot.running.namespace.KeywordRecommendationFinder(user_keywords, libraries, resources)[source]

Bases: object

recommend_similar_keywords(name, message)[source]

Return keyword names similar to name.

static format_recommendations(message, recommendations)[source]

robot.running.outputcapture module

class robot.running.outputcapture.OutputCapturer(library_import=False)[source]

Bases: object

class robot.running.outputcapture.PythonCapturer(stdout=True)[source]

Bases: object

release()[source]

robot.running.randomizer module

class robot.running.randomizer.Randomizer(randomize_suites=True, randomize_tests=True, seed=None)[source]

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]

Called when a suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_test(test)[source]

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting the body of the test.

visit_keyword(kw)[source]

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting the body of the keyword

end_body_item(item: robot.model.body.BodyItem)

Called, by default, when keywords, messages or control structures end.

More specific end_keyword(), end_message(), :meth:`end_for, etc. can be implemented to visit only keywords, messages or specific control structures.

Default implementation does nothing.

end_break(break_: robot.model.control.Break)

Called when a BREAK element ends.

By default, calls end_body_item() which, by default, does nothing.

end_continue(continue_: robot.model.control.Continue)

Called when a CONTINUE element ends.

By default, calls end_body_item() which, by default, does nothing.

end_error(error: robot.model.control.Error)

Called when a ERROR element ends.

By default, calls end_body_item() which, by default, does nothing.

end_for(for_: robot.model.control.For)

Called when a FOR loop ends.

By default, calls end_body_item() which, by default, does nothing.

end_for_iteration(iteration: ForIteration)

Called when a FOR loop iteration ends.

By default, calls end_body_item() which, by default, does nothing.

end_if(if_: robot.model.control.If)

Called when an IF/ELSE structure ends.

By default, calls end_body_item() which, by default, does nothing.

end_if_branch(branch: robot.model.control.IfBranch)

Called when an IF/ELSE branch ends.

By default, calls end_body_item() which, by default, does nothing.

end_keyword(keyword: robot.model.keyword.Keyword)

Called when a keyword ends.

By default, calls end_body_item() which, by default, does nothing.

end_message(message: robot.model.message.Message)

Called when a message ends.

By default, calls end_body_item() which, by default, does nothing.

end_return(return_: robot.model.control.Return)

Called when a RETURN element ends.

By default, calls end_body_item() which, by default, does nothing.

end_suite(suite: TestSuite)

Called when a suite ends. Default implementation does nothing.

end_test(test: robot.model.testcase.TestCase)

Called when a test ends. Default implementation does nothing.

end_try(try_: robot.model.control.Try)

Called when a TRY/EXCEPT structure ends.

By default, calls end_body_item() which, by default, does nothing.

end_try_branch(branch: robot.model.control.TryBranch)

Called when TRY, EXCEPT, ELSE and FINALLY branches end.

By default, calls end_body_item() which, by default, does nothing.

end_while(while_: robot.model.control.While)

Called when a WHILE loop ends.

By default, calls end_body_item() which, by default, does nothing.

end_while_iteration(iteration: WhileIteration)

Called when a WHILE loop iteration ends.

By default, calls end_body_item() which, by default, does nothing.

start_body_item(item: robot.model.body.BodyItem)

Called, by default, when keywords, messages or control structures start.

More specific start_keyword(), start_message(), :meth:`start_for, etc. can be implemented to visit only keywords, messages or specific control structures.

Can return explicit False to stop visiting. Default implementation does nothing.

start_break(break_: robot.model.control.Break)

Called when a BREAK element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_continue(continue_: robot.model.control.Continue)

Called when a CONTINUE element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_error(error: robot.model.control.Error)

Called when a ERROR element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_for(for_: robot.model.control.For)

Called when a FOR loop starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration: ForIteration)

Called when a FOR loop iteration starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_if(if_: robot.model.control.If)

Called when an IF/ELSE structure starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch: robot.model.control.IfBranch)

Called when an IF/ELSE branch starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword: robot.model.keyword.Keyword)

Called when a keyword starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_message(message: robot.model.message.Message)

Called when a message starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_return(return_: robot.model.control.Return)

Called when a RETURN element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_test(test: robot.model.testcase.TestCase)

Called when a test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_try(try_: robot.model.control.Try)

Called when a TRY/EXCEPT structure starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_try_branch(branch: robot.model.control.TryBranch)

Called when TRY, EXCEPT, ELSE or FINALLY branches start.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_while(while_: robot.model.control.While)

Called when a WHILE loop starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_while_iteration(iteration: WhileIteration)

Called when a WHILE loop iteration starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

visit_break(break_: robot.model.control.Break)

Visits BREAK elements.

visit_continue(continue_: robot.model.control.Continue)

Visits CONTINUE elements.

visit_error(error: robot.model.control.Error)

Visits body items resulting from invalid syntax.

Examples include syntax like END or ELSE in wrong place and invalid setting like [Invalid].

visit_for(for_: robot.model.control.For)

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration: ForIteration)

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_: robot.model.control.If)

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and they are visited separately using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch: robot.model.control.IfBranch)

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(message: robot.model.message.Message)

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_return(return_: robot.model.control.Return)

Visits a RETURN elements.

visit_suite(suite: TestSuite)

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or setup and teardown at all.

visit_try(try_: robot.model.control.Try)

Implements traversing through TRY/EXCEPT structures.

This method is used with the TRY/EXCEPT root element. Actual TRY, EXCEPT, ELSE and FINALLY branches are visited separately using visit_try_branch().

visit_try_branch(branch: robot.model.control.TryBranch)

Visits individual TRY, EXCEPT, ELSE and FINALLY branches.

visit_while(while_: robot.model.control.While)

Implements traversing through WHILE loops.

Can be overridden to allow modifying the passed in while_ without calling start_while() or end_while() nor visiting body.

visit_while_iteration(iteration: WhileIteration)

Implements traversing through single WHILE loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_while_iteration() or end_while_iteration() nor visiting body.

robot.running.runkwregister module

robot.running.signalhandler module

robot.running.status module

class robot.running.status.Failure[source]

Bases: object

class robot.running.status.Exit(failure_mode=False, error_mode=False, skip_teardown_mode=False)[source]

Bases: object

failure_occurred(fatal=False)[source]
error_occurred()[source]
teardown_allowed
class robot.running.status.SuiteStatus(parent=None, exit_on_failure=False, exit_on_error=False, skip_teardown_on_exit=False)[source]

Bases: robot.running.status._ExecutionStatus

error_occurred()
failed
failure_occurred()
message
passed
setup_executed(error=None)
status
teardown_allowed
teardown_executed(error=None)
class robot.running.status.TestStatus(parent, test, skip_on_failure=None, rpa=False)[source]

Bases: robot.running.status._ExecutionStatus

test_failed(message=None, error=None)[source]
test_skipped(message)[source]
skip_on_failure_after_tag_changes
error_occurred()
failed
failure_occurred()
message
passed
setup_executed(error=None)
status
teardown_allowed
teardown_executed(error=None)
class robot.running.status.TestMessage(status)[source]

Bases: robot.running.status._Message

setup_message = 'Setup failed:\n%s'
teardown_message = 'Teardown failed:\n%s'
setup_skipped_message = '%s'
teardown_skipped_message = '%s'
also_teardown_message = '%s\n\nAlso teardown failed:\n%s'
also_teardown_skip_message = 'Skipped in teardown:\n%s\n\nEarlier message:\n%s'
exit_on_fatal_message = 'Test execution stopped due to a fatal error.'
exit_on_failure_message = 'Failure occurred and exit-on-failure mode is in use.'
exit_on_error_message = 'Error occurred and exit-on-error mode is in use.'
message
class robot.running.status.SuiteMessage(status)[source]

Bases: robot.running.status._Message

setup_message = 'Suite setup failed:\n%s'
setup_skipped_message = 'Skipped in suite setup:\n%s'
teardown_skipped_message = 'Skipped in suite teardown:\n%s'
teardown_message = 'Suite teardown failed:\n%s'
also_teardown_message = '%s\n\nAlso suite teardown failed:\n%s'
also_teardown_skip_message = 'Skipped in suite teardown:\n%s\n\nEarlier message:\n%s'
message
class robot.running.status.ParentMessage(status)[source]

Bases: robot.running.status.SuiteMessage

setup_message = 'Parent suite setup failed:\n%s'
setup_skipped_message = 'Skipped in parent suite setup:\n%s'
teardown_skipped_message = 'Skipped in parent suite teardown:\n%s'
teardown_message = 'Parent suite teardown failed:\n%s'
also_teardown_message = '%s\n\nAlso parent suite teardown failed:\n%s'
also_teardown_skip_message = 'Skipped in suite teardown:\n%s\n\nEarlier message:\n%s'
message

robot.running.statusreporter module

class robot.running.statusreporter.StatusReporter(data, result, context, run=True, suppress=False)[source]

Bases: object

robot.running.suiterunner module

class robot.running.suiterunner.SuiteRunner(output, settings)[source]

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]

Called when a suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]

Called when a suite ends. Default implementation does nothing.

visit_test(test)[source]

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting the body of the test.

end_body_item(item: robot.model.body.BodyItem)

Called, by default, when keywords, messages or control structures end.

More specific end_keyword(), end_message(), :meth:`end_for, etc. can be implemented to visit only keywords, messages or specific control structures.

Default implementation does nothing.

end_break(break_: robot.model.control.Break)

Called when a BREAK element ends.

By default, calls end_body_item() which, by default, does nothing.

end_continue(continue_: robot.model.control.Continue)

Called when a CONTINUE element ends.

By default, calls end_body_item() which, by default, does nothing.

end_error(error: robot.model.control.Error)

Called when a ERROR element ends.

By default, calls end_body_item() which, by default, does nothing.

end_for(for_: robot.model.control.For)

Called when a FOR loop ends.

By default, calls end_body_item() which, by default, does nothing.

end_for_iteration(iteration: ForIteration)

Called when a FOR loop iteration ends.

By default, calls end_body_item() which, by default, does nothing.

end_if(if_: robot.model.control.If)

Called when an IF/ELSE structure ends.

By default, calls end_body_item() which, by default, does nothing.

end_if_branch(branch: robot.model.control.IfBranch)

Called when an IF/ELSE branch ends.

By default, calls end_body_item() which, by default, does nothing.

end_keyword(keyword: robot.model.keyword.Keyword)

Called when a keyword ends.

By default, calls end_body_item() which, by default, does nothing.

end_message(message: robot.model.message.Message)

Called when a message ends.

By default, calls end_body_item() which, by default, does nothing.

end_return(return_: robot.model.control.Return)

Called when a RETURN element ends.

By default, calls end_body_item() which, by default, does nothing.

end_test(test: robot.model.testcase.TestCase)

Called when a test ends. Default implementation does nothing.

end_try(try_: robot.model.control.Try)

Called when a TRY/EXCEPT structure ends.

By default, calls end_body_item() which, by default, does nothing.

end_try_branch(branch: robot.model.control.TryBranch)

Called when TRY, EXCEPT, ELSE and FINALLY branches end.

By default, calls end_body_item() which, by default, does nothing.

end_while(while_: robot.model.control.While)

Called when a WHILE loop ends.

By default, calls end_body_item() which, by default, does nothing.

end_while_iteration(iteration: WhileIteration)

Called when a WHILE loop iteration ends.

By default, calls end_body_item() which, by default, does nothing.

start_body_item(item: robot.model.body.BodyItem)

Called, by default, when keywords, messages or control structures start.

More specific start_keyword(), start_message(), :meth:`start_for, etc. can be implemented to visit only keywords, messages or specific control structures.

Can return explicit False to stop visiting. Default implementation does nothing.

start_break(break_: robot.model.control.Break)

Called when a BREAK element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_continue(continue_: robot.model.control.Continue)

Called when a CONTINUE element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_error(error: robot.model.control.Error)

Called when a ERROR element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_for(for_: robot.model.control.For)

Called when a FOR loop starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration: ForIteration)

Called when a FOR loop iteration starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_if(if_: robot.model.control.If)

Called when an IF/ELSE structure starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch: robot.model.control.IfBranch)

Called when an IF/ELSE branch starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword: robot.model.keyword.Keyword)

Called when a keyword starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_message(message: robot.model.message.Message)

Called when a message starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_return(return_: robot.model.control.Return)

Called when a RETURN element starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_test(test: robot.model.testcase.TestCase)

Called when a test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_try(try_: robot.model.control.Try)

Called when a TRY/EXCEPT structure starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_try_branch(branch: robot.model.control.TryBranch)

Called when TRY, EXCEPT, ELSE or FINALLY branches start.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_while(while_: robot.model.control.While)

Called when a WHILE loop starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

start_while_iteration(iteration: WhileIteration)

Called when a WHILE loop iteration starts.

By default, calls start_body_item() which, by default, does nothing.

Can return explicit False to stop visiting.

visit_break(break_: robot.model.control.Break)

Visits BREAK elements.

visit_continue(continue_: robot.model.control.Continue)

Visits CONTINUE elements.

visit_error(error: robot.model.control.Error)

Visits body items resulting from invalid syntax.

Examples include syntax like END or ELSE in wrong place and invalid setting like [Invalid].

visit_for(for_: robot.model.control.For)

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration: ForIteration)

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_: robot.model.control.If)

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and they are visited separately using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch: robot.model.control.IfBranch)

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(keyword: robot.model.keyword.Keyword)

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting the body of the keyword

visit_message(message: robot.model.message.Message)

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_return(return_: robot.model.control.Return)

Visits a RETURN elements.

visit_suite(suite: TestSuite)

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or setup and teardown at all.

visit_try(try_: robot.model.control.Try)

Implements traversing through TRY/EXCEPT structures.

This method is used with the TRY/EXCEPT root element. Actual TRY, EXCEPT, ELSE and FINALLY branches are visited separately using visit_try_branch().

visit_try_branch(branch: robot.model.control.TryBranch)

Visits individual TRY, EXCEPT, ELSE and FINALLY branches.

visit_while(while_: robot.model.control.While)

Implements traversing through WHILE loops.

Can be overridden to allow modifying the passed in while_ without calling start_while() or end_while() nor visiting body.

visit_while_iteration(iteration: WhileIteration)

Implements traversing through single WHILE loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_while_iteration() or end_while_iteration() nor visiting body.

robot.running.testlibraries module

robot.running.testlibraries.TestLibrary(name, args=None, variables=None, create_handlers=True, logger=<robot.output.logger.Logger object>)[source]

robot.running.usererrorhandler module

class robot.running.usererrorhandler.UserErrorHandler(error, name, libname=None, source=None, lineno=None)[source]

Bases: object

Created if creating handlers fail. Running it raises DataError.

The idea is not to raise DataError at processing time and prevent all tests in affected test case file from executing. Instead, UserErrorHandler is created and if it is ever run DataError is raised then.

Parameters:
  • error (robot.errors.DataError) – Occurred error.
  • name (str) – Name of the affected keyword.
  • libname (str) – Name of the affected library or resource.
  • source (str) – Path to the source file.
  • lineno (int) – Line number of the failing keyword.
supports_embedded_arguments = False
longname
doc
shortdoc
create_runner(name, languages=None)[source]
run(kw, context, run=True)[source]
dry_run(kw, context, run=True)

robot.running.userkeyword module

class robot.running.userkeyword.UserLibrary(resource, resource_file=True)[source]

Bases: object

handlers_for(name)[source]
class robot.running.userkeyword.UserKeywordHandler(keyword, libname)[source]

Bases: object

supports_embedded_args = False
longname
shortdoc
private
create_runner(name, languages=None)[source]
class robot.running.userkeyword.EmbeddedArgumentsHandler(keyword, libname, embedded)[source]

Bases: robot.running.userkeyword.UserKeywordHandler

supports_embedded_args = True
matches(name)[source]
create_runner(name, languages=None)[source]
longname
private
shortdoc

robot.running.userkeywordrunner module

class robot.running.userkeywordrunner.UserKeywordRunner(handler, name=None)[source]

Bases: object

longname
libname
tags
source
arguments
Return type:robot.running.arguments.ArgumentSpec
run(kw, context, run=True)[source]
dry_run(kw, context)[source]
class robot.running.userkeywordrunner.EmbeddedArgumentsRunner(handler, name)[source]

Bases: robot.running.userkeywordrunner.UserKeywordRunner

arguments
Return type:robot.running.arguments.ArgumentSpec
dry_run(kw, context)
libname
longname
run(kw, context, run=True)
source
tags