Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://robot-framework.readthedocs.org/en/master/autodoc/robot.running.html below:

Website Navigation

• Robot Framework

robot.running package — Robot Framework 7.3.3.dev1 documentation

Implements the core test execution logic.

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

• TestSuite for creating an executable test suite structure programmatically.

• TestSuiteBuilder for creating executable test suites based on data on a file system. Instead of using this class directly, it is possible to use the TestSuite.from_file_system classmethod that uses it internally.

• Classes used by TestSuite, such as TestCase, Keyword and If that are defined in the robot.running.model module. These classes are typically only needed in type hints.

• Keyword implementation related classes UserKeyword, LibraryKeyword, InvalidKeyword and their common base class KeywordImplementation. Also these classes are mainly needed in type hints.

• TestDefaults that is part of the external parsing API and also typically needed only in type hints.

TestSuite and TestSuiteBuilder can be imported also via the robot.api package.

Note

Prior to Robot Framework 6.1, only some classes in robot.running.model were exposed via robot.running. Keyword implementation related classes are new in Robot Framework 7.0.

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()

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

Bases: object

run(data, result)[source]

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

Bases: object

run(data, result, setup_or_teardown=False)[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, result)[source]

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

Bases: ForInRunner

flavor = 'IN RANGE'

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

Bases: ForInRunner

flavor = 'IN ZIP'

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

Bases: ForInRunner

flavor = 'IN ENUMERATE'

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

Bases: object

run(data, result)[source]

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

Bases: object

run(data, result)[source]

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

Bases: object

run(data, result)[source]

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

Bases: object

run(data, result)[source]

class robot.running.bodyrunner.WhileLimit(on_limit=None, on_limit_message=None)[source]

Bases: object

classmethod create(data, variables)[source]

limit_exceeded()[source]

class robot.running.bodyrunner.DurationLimit(max_time, on_limit, on_limit_message)[source]

Bases: WhileLimit

class robot.running.bodyrunner.IterationCountLimit(max_iterations, on_limit, on_limit_message)[source]

Bases: WhileLimit

class robot.running.bodyrunner.NoLimit(on_limit=None, on_limit_message=None)[source]

Bases: WhileLimit

exception robot.running.bodyrunner.LimitExceeded(on_limit_pass, message)[source]

Bases: ExecutionFailed

class robot.running.context.Asynchronous[source]

Bases: object

property event_loop

close_loop()[source]

run_until_complete(coroutine)[source]

is_loop_required(obj)[source]

class robot.running.context.ExecutionContexts[source]

Bases: object

property current

property top

property namespaces

start_suite(suite, namespace, output, dry_run=False)[source]

end_suite()[source]

robot.running.dynamicmethods.no_dynamic_method(*args)[source]

class robot.running.dynamicmethods.DynamicMethod(instance)[source]

Bases: object

property name

class robot.running.dynamicmethods.GetKeywordNames(instance)[source]

Bases: DynamicMethod

class robot.running.dynamicmethods.RunKeyword(instance, keyword_name: str | None = None, supports_named_args: bool | None = None)[source]

Bases: DynamicMethod

property supports_named_args: bool

class robot.running.dynamicmethods.GetKeywordDocumentation(instance)[source]

Bases: DynamicMethod

class robot.running.dynamicmethods.GetKeywordArguments(instance, supports_named_args: bool | None = None)[source]

Bases: DynamicMethod

class robot.running.dynamicmethods.GetKeywordTypes(instance)[source]

Bases: DynamicMethod

class robot.running.dynamicmethods.GetKeywordTags(instance)[source]

Bases: DynamicMethod

class robot.running.dynamicmethods.GetKeywordSource(instance)[source]

Bases: DynamicMethod

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]

class robot.running.invalidkeyword.InvalidKeyword(name: str = '', args: ArgumentSpec | None = None, doc: str = '', tags: Tags | Sequence[str] = (), lineno: int | None = None, owner: ResourceFile | TestLibrary | None = None, parent: BodyItemParent | None = None, error: str | None = None)[source]

Bases: KeywordImplementation

Represents an invalid keyword call.

Keyword may not have been found, there could have been multiple matches, or the keyword call itself could have been invalid.

type: Literal['USER KEYWORD', 'LIBRARY KEYWORD', 'INVALID KEYWORD'] = 'INVALID KEYWORD'

create_runner(name, languages=None)[source]

bind(data: Keyword) → InvalidKeyword[source]

embedded

owner

parent

error

class robot.running.invalidkeyword.InvalidKeywordRunner(keyword: InvalidKeyword, name: str | None = None)[source]

Bases: object

run(data: Keyword, result: Keyword, context, run=True)[source]

dry_run(data: Keyword, result: Keyword, context, run=True)

class robot.running.keywordfinder.KeywordFinder(owner: TestLibrary | ResourceFile)[source]

Bases: Generic[K]

find(name: str, count: Literal[1]) → K[source]

find(name: str, count: int | None = None) → list[K]

Find keywords based on the given name.

With normal keywords matching is a case, space and underscore insensitive string comparison and there cannot be more than one match. With keywords accepting embedded arguments, matching is done against the name and there can be multiple matches.

Returns matching keywords as a list, possibly as an empty list, without any validation by default. If the optional count is used, raises a ValueError if the number of found keywords does not match. If count is 1 and exactly one keyword is found, returns that keyword directly and not as a list.

invalidate_cache()[source]

class robot.running.keywordfinder.KeywordCache(keywords: list[K])[source]

Bases: Generic[K]

find(name: str, count: int | None = None) → list[K] | K[source]

class robot.running.keywordimplementation.KeywordImplementation(name: str = '', args: ArgumentSpec | None = None, doc: str = '', tags: Tags | Sequence[str] = (), lineno: int | None = None, owner: ResourceFile | TestLibrary | None = None, parent: BodyItemParent | None = None, error: str | None = None)[source]

Bases: ModelObject

Base class for different keyword implementations.

USER_KEYWORD = 'USER KEYWORD'

LIBRARY_KEYWORD = 'LIBRARY KEYWORD'

INVALID_KEYWORD = 'INVALID KEYWORD'

type: Literal['USER KEYWORD', 'LIBRARY KEYWORD', 'INVALID KEYWORD']

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

embedded

owner

parent

error

property name: str

property full_name: str

args

Information about accepted arguments.

It would be more correct to use term parameter instead of argument in this context, and this attribute may be renamed accordingly in the future. A forward compatible params attribute exists already now.

property params: ArgumentSpec

Keyword parameter information.

This is a forward compatible alias for args.

property doc: str

property short_doc: str

tags

property lineno: int | None

property private: bool

property source: Path | None

matches(name: str) → bool[source]

Returns true if name matches the keyword name.

With normal keywords matching is a case, space and underscore insensitive string comparison. With keywords accepting embedded arguments, matching is done against the name.

resolve_arguments(args: Sequence[str | Any], named_args: Mapping[str, Any] | None = None, variables=None, languages: LanguagesLike = None) → tuple[list, list][source]

create_runner(name: str | None, languages: LanguagesLike = None) → LibraryKeywordRunner | UserKeywordRunner[source]

bind(data: Keyword) → KeywordImplementation[source]

class robot.running.librarykeyword.LibraryKeyword(owner: TestLibrary, name: str = '', args: ArgumentSpec | None = None, doc: str = '', tags: Tags | Sequence[str] = (), resolve_args_until: int | None = None, parent: BodyItemParent | None = None, error: str | None = None)[source]

Bases: KeywordImplementation

Base class for different library keywords.

type: Literal['USER KEYWORD', 'LIBRARY KEYWORD', 'INVALID KEYWORD'] = 'LIBRARY KEYWORD'

property method: Callable[[...], Any]

property lineno: int | None

create_runner(name: str | None, languages: LanguagesLike = None) → LibraryKeywordRunner[source]

resolve_arguments(args: Sequence[str | Any], named_args: Mapping[str, Any] | None = None, variables=None, languages: LanguagesLike = None) → tuple[list, list][source]

bind(data: Keyword) → Self[source]

copy(**attributes) → Self[source]

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.

class robot.running.librarykeyword.StaticKeyword(method_name: str, owner: TestLibrary, name: str = '', args: ArgumentSpec | None = None, doc: str = '', tags: Tags | Sequence[str] = (), resolve_args_until: int | None = None, parent: BodyItemParent | None = None, error: str | None = None)[source]

Bases: LibraryKeyword

Represents a keyword in a static library.

method_name

property method: Callable[[...], Any]

Keyword method.

property source: Path | None

classmethod from_name(name: str, owner: TestLibrary) → StaticKeyword[source]

copy(**attributes) → StaticKeyword[source]

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.

class robot.running.librarykeyword.DynamicKeyword(owner: DynamicLibrary, name: str = '', args: ArgumentSpec | None = None, doc: str = '', tags: Tags | Sequence[str] = (), resolve_args_until: int | None = None, parent: BodyItemParent | None = None, error: str | None = None)[source]

Bases: LibraryKeyword

Represents a keyword in a dynamic library.

property method: Callable[[...], Any]

Dynamic run_keyword method.

property source: Path | None

property lineno: int | None

classmethod from_name(name: str, owner: DynamicLibrary) → DynamicKeyword[source]

resolve_arguments(args: Sequence[str | Any], named_args: Mapping[str, Any] | None = None, variables=None, languages: LanguagesLike = None) → tuple[list, list][source]

copy(**attributes) → DynamicKeyword[source]

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.

run_keyword

class robot.running.librarykeyword.LibraryInit(owner: TestLibrary, name: str = '', args: ArgumentSpec | None = None, doc: str = '', tags: Tags | Sequence[str] = (), positional: list | None = None, named: dict | None = None)[source]

Bases: LibraryKeyword

Represents a library initializer.

positional and named contain arguments used for initializing the library.

property doc: str

property method: Callable[[...], None] | None

Initializer method.

None with module based libraries and when class based libraries do not have __init__.

classmethod from_class(klass) → LibraryInit[source]

classmethod null() → LibraryInit[source]

copy(**attributes) → LibraryInit[source]

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.

class robot.running.librarykeyword.KeywordCreator(name: str, library: TestLibrary | None = None)[source]

Bases: Generic[K]

keyword_class: type[K]

property instance: Any

create(**extra) → K[source]

get_name() → str[source]

get_args() → ArgumentSpec[source]

get_doc() → str[source]

get_tags() → list[str][source]

class robot.running.librarykeyword.StaticKeywordCreator(name: str, library: TestLibrary)[source]

Bases: KeywordCreator[StaticKeyword]

keyword_class

alias of StaticKeyword

get_name() → str[source]

get_args() → ArgumentSpec[source]

get_doc() → str[source]

get_tags() → list[str][source]

class robot.running.librarykeyword.DynamicKeywordCreator(name: str, library: TestLibrary | None = None)[source]

Bases: KeywordCreator[DynamicKeyword]

keyword_class

alias of DynamicKeyword

library: DynamicLibrary

get_name() → str[source]

get_args() → ArgumentSpec[source]

get_doc() → str[source]

get_tags() → list[str][source]

class robot.running.librarykeyword.LibraryInitCreator(method: Callable[[...], None] | None)[source]

Bases: KeywordCreator[LibraryInit]

keyword_class

alias of LibraryInit

create(**extra) → LibraryInit[source]

get_name() → str[source]

get_args() → ArgumentSpec[source]

get_doc() → str[source]

get_tags() → list[str][source]

class robot.running.librarykeywordrunner.LibraryKeywordRunner(keyword: LibraryKeyword, name: str | None = None, languages=None)[source]

Bases: object

run(data: Keyword, result: Keyword, context, run=True)[source]

dry_run(data: Keyword, result: Keyword, context)[source]

class robot.running.librarykeywordrunner.EmbeddedArgumentsRunner(keyword: LibraryKeyword, name: str)[source]

Bases: LibraryKeywordRunner

class robot.running.librarykeywordrunner.RunKeywordRunner(keyword: LibraryKeyword, dry_run_children=False)[source]

Bases: LibraryKeywordRunner

class robot.running.libraryscopes.Scope(*values)[source]

Bases: Enum

GLOBAL = 1

SUITE = 2

TEST = 3

class robot.running.libraryscopes.ScopeManager(library: TestLibrary)[source]

Bases: object

classmethod for_library(library)[source]

start_suite()[source]

end_suite()[source]

start_test()[source]

end_test()[source]

close_global_listeners()[source]

register_listeners()[source]

unregister_listeners(close=False)[source]

class robot.running.libraryscopes.GlobalScopeManager(library: TestLibrary)[source]

Bases: ScopeManager

start_suite()[source]

end_suite()[source]

close_global_listeners()[source]

class robot.running.libraryscopes.SuiteScopeManager(library)[source]

Bases: ScopeManager

start_suite()[source]

end_suite()[source]

class robot.running.libraryscopes.TestScopeManager(library)[source]

Bases: SuiteScopeManager

start_test()[source]

end_test()[source]

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: TestSuite | TestCase | UserKeyword | For | ForIteration | If | IfBranch | Try | TryBranch | While | Group | WhileIteration | Keyword | Var | Return | Continue | Break | Error | None = None, items: Iterable[BodyItem | DataDict] = ())[source]

Bases: BaseBody[Keyword, For, While, Group, If, Try, Var, Return, Continue, Break, model.Message, Error]

break_class

alias of Break

continue_class

alias of Continue

error_class

alias of Error

for_class

alias of For

group_class

alias of Group

if_class

alias of If

keyword_class

alias of Keyword

return_class

alias of Return

try_class

alias of Try

var_class

alias of Var

while_class

alias of While

class robot.running.model.Branches(branch_class: Type[IT], parent: TestSuite | TestCase | UserKeyword | For | ForIteration | If | IfBranch | Try | TryBranch | While | Group | WhileIteration | Keyword | Var | Return | Continue | Break | Error | None = None, items: Iterable[IT | DataDict] = ())[source]

Bases: BaseBranches[Keyword, For, While, Group, If, Try, Var, Return, Continue, Break, model.Message, Error, IT]

class robot.running.model.WithSource[source]

Bases: object

parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None

property source: Path | None

class robot.running.model.Argument(name: str | None, value: Any)[source]

Bases: object

A temporary API for creating named arguments with non-string values.

This class was added in RF 7.0.1 (#5031) after a failed attempt to add a public API for this purpose in RF 7.0 (#5000). A better public API that allows passing named arguments separately was added in RF 7.1 (#5143).

If you need to support also RF 7.0, you can pass named arguments as two-item tuples like (name, value) and positional arguments as one-item tuples like (value,). That approach does not work anymore in RF 7.0.1, though, so the code needs to be conditional depending on Robot Framework version.

The main limitation of this class is that it is not compatible with the JSON model. The current plan is to remove this in the future, possibly already in RF 8.0, but we can consider preserving it if it turns out to be useful.

Parameters:

• name – Argument name. If None, argument is considered positional.

• value – Argument value.

class robot.running.model.Keyword(name: str = '', args: Sequence[str | Argument | Any] = (), named_args: Mapping[str, Any] | None = None, assign: Sequence[str] = (), type: str = 'KEYWORD', parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None)[source]

Bases: Keyword, WithSource

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.

Arguments originating from normal Robot Framework data are stored in the args attribute as a tuple of strings in the exact same format as in the data. This means that arguments can have variables and escape characters, and that named arguments are specified using the name=value syntax.

When creating keywords programmatically, it is possible to set named_args separately and use args only for positional arguments. Argument values do not need to be strings, but also in this case strings can contain variables and normal Robot Framework escaping rules must be taken into account.

named_args

lineno

to_dict() → Dict[str, Any][source]

Serialize this object into a dictionary.

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

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

run(result, context, run=True, templated=None)[source]

class robot.running.model.ForIteration(assign: Mapping[str, str] | None = None, parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None, error: str | None = None)[source]

Bases: ForIteration, WithSource

body_class

alias of Body

lineno

error

class robot.running.model.For(assign: Sequence[str] = (), flavor: Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP'] = 'IN', values: Sequence[str] = (), start: str | None = None, mode: str | None = None, fill: str | None = None, parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None, error: str | None = None)[source]

Bases: For, WithSource

body_class

alias of Body

lineno

error

classmethod from_dict(data: Dict[str, Any]) → For[source]

Create this object based on data in a dictionary.

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

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

to_dict() → Dict[str, Any][source]

Serialize this object into a dictionary.

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

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

run(result, context, run=True, templated=False)[source]

get_iteration(assign: Mapping[str, str] | None = None) → ForIteration[source]

class robot.running.model.WhileIteration(parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None, error: str | None = None)[source]

Bases: WhileIteration, WithSource

body_class

alias of Body

lineno

error

class robot.running.model.While(condition: str | None = None, limit: str | None = None, on_limit: str | None = None, on_limit_message: str | None = None, parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None, error: str | None = None)[source]

Bases: While, WithSource

body_class

alias of Body

lineno

error

to_dict() → Dict[str, Any][source]

Serialize this object into a dictionary.

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

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

run(result, context, run=True, templated=False)[source]

get_iteration() → WhileIteration[source]

class robot.running.model.Group(name: str = '', parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None, error: str | None = None)[source]

Bases: Group, WithSource

body_class

alias of Body

lineno

error

to_dict() → Dict[str, Any][source]

Serialize this object into a dictionary.

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

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

run(result, context, run=True, templated=False)[source]

class robot.running.model.IfBranch(type: str = 'IF', condition: str | None = None, parent: TestSuite | TestCase | UserKeyword | For | While | If | IfBranch | Try | TryBranch | Group | None = None, lineno: int | None = None)[source]

Bases: IfBranch, WithSource

body_class

alias of Body

lineno

to_dict() → Dict[str, Any][source]

Serialize this object into a dictionary.

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

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.