robotframework 6.1rc1__zip → 7.0a1__zip

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/bodyrunner.py

@@ -13,21 +13,21 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import re
+import time
 from collections import OrderedDict
 from contextlib import contextmanager
+from datetime import datetime
 from itertools import zip_longest
-import re
-import time
 
 from robot.errors import (BreakLoop, ContinueLoop, DataError, ExecutionFailed,
                           ExecutionFailures, ExecutionPassed, ExecutionStatus)
 from robot.result import (For as ForResult, While as WhileResult, If as IfResult,
-                          IfBranch as IfBranchResult, Try as TryResult,
-                          TryBranch as TryBranchResult)
+                          Try as TryResult)
 from robot.output import librarylogger as logger
-from robot.utils import (cut_assign_value, frange, get_error_message, get_timestamp,
-                         is_list_like, is_number, plural_or_not as s, secs_to_timestr,
-                         seq2str, split_from_equals, type_name, Matcher, timestr_to_secs)
+from robot.utils import (cut_assign_value, frange, get_error_message, is_list_like,
+                         is_number, plural_or_not as s, secs_to_timestr, seq2str,
+                         split_from_equals, type_name, Matcher, timestr_to_secs)
 from robot.variables import is_dict_variable, evaluate_expression
 
 from .statusreporter import StatusReporter
@@ -101,7 +101,7 @@ class ForInRunner:
                 error = DataError(data.error, syntax=True)
             else:
                 run = True
-        result = ForResult(data.variables, data.flavor, data.values, data.start,
+        result = ForResult(data.assign, data.flavor, data.values, data.start,
                            data.mode, data.fill)
         with StatusReporter(data, result, self._context, run) as status:
             if run:
@@ -143,7 +143,7 @@ class ForInRunner:
     def _get_values_for_rounds(self, data):
         if self._context.dry_run:
             return [None]
-        values_per_round = len(data.variables)
+        values_per_round = len(data.assign)
         if self._is_dict_iteration(data.values):
             values = self._resolve_dict_values(data.values)
             values = self._map_dict_values_to_rounds(values, values_per_round)
@@ -218,10 +218,10 @@ class ForInRunner:
             variables = self._context.variables
         else:    # Not really run (earlier failure, unexecuted IF branch, dry-run)
             variables = {}
-            values = [''] * len(data.variables)
-        for name, value in self._map_variables_and_values(data.variables, values):
+            values = [''] * len(data.assign)
+        for name, value in self._map_variables_and_values(data.assign, values):
             variables[name] = value
-            result.variables[name] = cut_assign_value(value)
+            result.assign[name] = cut_assign_value(value)
         runner = BodyRunner(self._context, run, self._templated)
         with StatusReporter(data, result, self._context, run):
             runner.run(data.body)
@@ -274,13 +274,13 @@ class ForInZipRunner(ForInRunner):
         if not mode or self._context.dry_run:
             return None
         try:
-            mode = self._context.variables.replace_string(mode).upper()
-            if mode in ('STRICT', 'SHORTEST', 'LONGEST'):
-                return mode
-            raise DataError(f"Mode must be 'STRICT', 'SHORTEST' or 'LONGEST', "
-                            f"got '{mode}'.")
+            mode = self._context.variables.replace_string(mode)
+            if mode.upper() in ('STRICT', 'SHORTEST', 'LONGEST'):
+                return mode.upper()
+            raise DataError(f"Value '{mode}' is not accepted. Valid values "
+                            f"are 'STRICT', 'SHORTEST' and 'LONGEST'.")
         except DataError as err:
-            raise DataError(f'Invalid mode: {err}')
+            raise DataError(f'Invalid FOR IN ZIP mode: {err}')
 
     def _resolve_fill(self, fill):
         if not fill or self._context.dry_run:
@@ -288,7 +288,7 @@ class ForInZipRunner(ForInRunner):
         try:
             return self._context.variables.replace_scalar(fill)
         except DataError as err:
-            raise DataError(f'Invalid fill value: {err}')
+            raise DataError(f'Invalid FOR IN ZIP fill value: {err}')
 
     def _resolve_dict_values(self, values):
         raise DataError('FOR IN ZIP loops do not support iterating over dictionaries.',
@@ -302,6 +302,8 @@ class ForInZipRunner(ForInRunner):
             return zip_longest(*values, fillvalue=self._fill)
         if self._mode == 'STRICT':
             self._validate_strict_lengths(values)
+        if self._mode is None:
+            self._deprecate_different_lengths(values)
         return zip(*values)
 
     def _validate_types(self, values):
@@ -316,12 +318,21 @@ class ForInZipRunner(ForInRunner):
             try:
                 lengths.append(len(item))
             except TypeError:
-                raise DataError(f"FOR IN ZIP items should have length in STRICT mode, "
-                                f"but item {index} does not.")
+                raise DataError(f"FOR IN ZIP items must have length in the STRICT "
+                                f"mode, but item {index} does not.")
         if len(set(lengths)) > 1:
-            raise DataError(f"FOR IN ZIP items should have equal lengths in STRICT "
+            raise DataError(f"FOR IN ZIP items must have equal lengths in the STRICT "
                             f"mode, but lengths are {seq2str(lengths, quote='')}.")
 
+    def _deprecate_different_lengths(self, values):
+        try:
+            self._validate_strict_lengths(values)
+        except DataError as err:
+            logger.warn(f"FOR IN ZIP default mode will be changed from SHORTEST to "
+                        f"STRICT in Robot Framework 8.0. Use 'mode=SHORTEST' to keep "
+                        f"using the SHORTEST mode. If the mode is not changed, "
+                        f"execution will fail like this in the future: {err}")
+
 
 class ForInEnumerateRunner(ForInRunner):
     flavor = 'IN ENUMERATE'
@@ -339,9 +350,9 @@ class ForInEnumerateRunner(ForInRunner):
             try:
                 return int(start)
             except ValueError:
-                raise DataError(f"Start value must be an integer, got '{start}'.")
+                raise DataError(f"Value must be an integer, got '{start}'.")
         except DataError as err:
-            raise DataError(f'Invalid start value: {err}')
+            raise DataError(f'Invalid FOR IN ENUMERATE start value: {err}')
 
     def _map_dict_values_to_rounds(self, values, per_round):
         if per_round > 3:
@@ -375,10 +386,12 @@ class WhileRunner:
         error = None
         run = False
         limit = None
-        loop_result = WhileResult(data.condition, data.limit,
-                                  data.on_limit, data.on_limit_message,
-                                  starttime=get_timestamp())
-        iter_result = loop_result.body.create_iteration(starttime=get_timestamp())
+        loop_result = WhileResult(data.condition,
+                                  data.limit,
+                                  data.on_limit,
+                                  data.on_limit_message,
+                                  start_time=datetime.now())
+        iter_result = loop_result.body.create_iteration(start_time=datetime.now())
         if self._run:
             if data.error:
                 error = DataError(data.error, syntax=True)
@@ -420,7 +433,7 @@ class WhileRunner:
                     errors.extend(failed.get_errors())
                     if not failed.can_continue(ctx, self._templated):
                         break
-                iter_result = loop_result.body.create_iteration(starttime=get_timestamp())
+                iter_result = loop_result.body.create_iteration(start_time=datetime.now())
                 if not self._should_run(data.condition, ctx.variables):
                     break
             if errors:
@@ -453,10 +466,11 @@ class IfRunner:
     def run(self, data):
         with self._dry_run_recursion_detection(data) as recursive_dry_run:
             error = None
-            with StatusReporter(data, IfResult(), self._context, self._run):
+            result = IfResult()
+            with StatusReporter(data, result, self._context, self._run):
                 for branch in data.body:
                     try:
-                        if self._run_if_branch(branch, recursive_dry_run, data.error):
+                        if self._run_if_branch(branch, result, recursive_dry_run, data.error):
                             self._run = False
                     except ExecutionStatus as err:
                         error = err
@@ -478,9 +492,9 @@ class IfRunner:
             if dry_run:
                 self._dry_run_stack.pop()
 
-    def _run_if_branch(self, branch, recursive_dry_run=False, syntax_error=None):
+    def _run_if_branch(self, branch, result, recursive_dry_run=False, syntax_error=None):
         context = self._context
-        result = IfBranchResult(branch.type, branch.condition, starttime=get_timestamp())
+        result = result.body.create_branch(branch.type, branch.condition, start_time=datetime.now())
         error = None
         if syntax_error:
             run_branch = False
@@ -525,28 +539,29 @@ class TryRunner:
 
     def run(self, data):
         run = self._run
-        with StatusReporter(data, TryResult(), self._context, run):
+        result = TryResult()
+        with StatusReporter(data, result, self._context, run):
             if data.error:
-                self._run_invalid(data)
+                self._run_invalid(data, result)
                 return
-            error = self._run_try(data, run)
+            error = self._run_try(data, result, run)
             run_excepts_or_else = self._should_run_excepts_or_else(error, run)
             if error:
-                error = self._run_excepts(data, error, run=run_excepts_or_else)
-                self._run_else(data, run=False)
+                error = self._run_excepts(data, result, error, run=run_excepts_or_else)
+                self._run_else(data, result, run=False)
             else:
-                self._run_excepts(data, error, run=False)
-                error = self._run_else(data, run=run_excepts_or_else)
-            error = self._run_finally(data, run) or error
+                self._run_excepts(data, result, error, run=False)
+                error = self._run_else(data, result, run=run_excepts_or_else)
+            error = self._run_finally(data, result, run) or error
             if error:
                 raise error
 
-    def _run_invalid(self, data):
+    def _run_invalid(self, data, result):
         error_reported = False
         for branch in data.body:
-            result = TryBranchResult(branch.type, branch.patterns, branch.pattern_type,
-                                     branch.variable)
-            with StatusReporter(branch, result, self._context, run=False, suppress=True):
+            branch_result = result.body.create_branch(branch.type, branch.patterns,
+                                                      branch.pattern_type, branch.assign)
+            with StatusReporter(branch, branch_result, self._context, run=False, suppress=True):
                 runner = BodyRunner(self._context, run=False, templated=self._templated)
                 runner.run(branch.body)
                 if not error_reported:
@@ -554,8 +569,8 @@ class TryRunner:
                     raise DataError(data.error, syntax=True)
         raise ExecutionFailed(data.error, syntax=True)
 
-    def _run_try(self, data, run):
-        result = TryBranchResult(data.TRY)
+    def _run_try(self, data, result, run):
+        result = result.body.create_branch(data.TRY)
         return self._run_branch(data.try_branch, result, run)
 
     def _should_run_excepts_or_else(self, error, run):
@@ -577,7 +592,7 @@ class TryRunner:
         else:
             return None
 
-    def _run_excepts(self, data, error, run):
+    def _run_excepts(self, data, result, error, run):
         for branch in data.except_branches:
             try:
                 run_branch = run and self._should_run_except(branch, error)
@@ -586,15 +601,15 @@ class TryRunner:
                 pattern_error = err
             else:
                 pattern_error = None
-            result = TryBranchResult(branch.type, branch.patterns,
-                                     branch.pattern_type, branch.variable)
+            branch_result = result.body.create_branch(branch.type, branch.patterns,
+                                                      branch.pattern_type, branch.assign)
             if run_branch:
-                if branch.variable:
-                    self._context.variables[branch.variable] = str(error)
-                error = self._run_branch(branch, result, error=pattern_error)
+                if branch.assign:
+                    self._context.variables[branch.assign] = str(error)
+                error = self._run_branch(branch, branch_result, error=pattern_error)
                 run = False
             else:
-                self._run_branch(branch, result, run=False)
+                self._run_branch(branch, branch_result, run=False)
         return error
 
     def _should_run_except(self, branch, error):
@@ -602,9 +617,9 @@ class TryRunner:
             return True
         matchers = {
             'GLOB': lambda m, p: Matcher(p, spaceless=False, caseless=False).match(m),
+            'REGEXP': lambda m, p: re.fullmatch(p, m) is not None,
+            'START': lambda m, p: m.startswith(p),
             'LITERAL': lambda m, p: m == p,
-            'REGEXP': lambda m, p: re.match(rf'{p}\Z', m) is not None,
-            'START': lambda m, p: m.startswith(p)
         }
         if branch.pattern_type:
             pattern_type = self._context.variables.replace_string(branch.pattern_type)
@@ -612,21 +627,21 @@ class TryRunner:
             pattern_type = 'LITERAL'
         matcher = matchers.get(pattern_type.upper())
         if not matcher:
-            raise DataError(f"Invalid EXCEPT pattern type '{pattern_type}', "
-                            f"expected {seq2str(matchers, lastsep=' or ')}.")
+            raise DataError(f"Invalid EXCEPT pattern type '{pattern_type}'. "
+                            f"Valid values are {seq2str(matchers)}.")
         for pattern in branch.patterns:
             if matcher(error.message, self._context.variables.replace_string(pattern)):
                 return True
         return False
 
-    def _run_else(self, data, run):
+    def _run_else(self, data, result, run):
         if data.else_branch:
-            result = TryBranchResult(data.ELSE)
+            result = result.body.create_branch(data.ELSE)
             return self._run_branch(data.else_branch, result, run)
 
-    def _run_finally(self, data, run):
+    def _run_finally(self, data, result, run):
         if data.finally_branch:
-            result = TryBranchResult(data.FINALLY)
+            result = result.body.create_branch(data.FINALLY)
             try:
                 with StatusReporter(data.finally_branch, result, self._context, run):
                     runner = BodyRunner(self._context, run, self._templated)
@@ -679,15 +694,15 @@ class WhileLimit:
             return None
         try:
             on_limit = variables.replace_string(on_limit)
-            if on_limit.upper() not in ['PASS', 'FAIL']:
-                raise DataError("Value must be 'PASS' or 'FAIL'.")
+            if on_limit.upper() in ('PASS', 'FAIL'):
+                return on_limit.upper()
+            raise DataError(f"Value '{on_limit}' is not accepted. Valid values "
+                            f"are 'PASS' and 'FAIL'.")
         except DataError as err:
-            raise DataError(f"Invalid WHILE loop 'on_limit' value '{on_limit}': {err}")
-        else:
-            return on_limit.lower()
+            raise DataError(f"Invalid WHILE loop 'on_limit' value: {err}")
 
     def limit_exceeded(self):
-        on_limit_pass = self.on_limit == 'pass'
+        on_limit_pass = self.on_limit == 'PASS'
         if self.on_limit_message:
             raise LimitExceeded(on_limit_pass, self.on_limit_message)
         else:

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/builder/builders.py

@@ -84,8 +84,8 @@ class TestSuiteBuilder:
             New in RF 6.1.
         :param rpa:
             Explicit execution mode. ``True`` for RPA and ``False`` for test
-            automation. By default, mode is got from data file headers and possible
-            conflicting headers cause an error. Same as ``--rpa`` or ``--norpa``.
+            automation. By default, mode is got from data file headers.
+            Same as ``--rpa`` or ``--norpa``.
         :param lang:
             Additional languages to be supported during parsing.
             Can be a string matching any of the supported language codes or names,
@@ -111,7 +111,7 @@ class TestSuiteBuilder:
         if included_suites != 'DEPRECATED':
             warnings.warn("'TestSuiteBuilder' argument 'included_suites' is deprecated "
                           "and has no effect. Use the new 'included_files' argument "
-                          "or filter the parsed suite instead.")
+                          "or filter the created suite instead.")
 
     def _get_standard_parsers(self, lang: LanguagesLike,
                               process_curdir: bool) -> 'dict[str, Parser]':
@@ -201,11 +201,11 @@ class TestSuiteBuilder:
 class SuiteStructureParser(SuiteStructureVisitor):
 
     def __init__(self, parsers: 'dict[str|None, Parser]',
-                 defaults: 'TestDefaults|None' = None, rpa: 'bool|None' = None):
+                 defaults: 'TestDefaults|None' = None,
+                 rpa: 'bool|None' = None):
         self.parsers = parsers
         self.rpa = rpa
         self.defaults = defaults
-        self._rpa_given = rpa is not None
         self.suite: 'TestSuite|None' = None
         self._stack: 'list[tuple[TestSuite, TestDefaults]]' = []
 
@@ -215,13 +215,13 @@ class SuiteStructureParser(SuiteStructureVisitor):
 
     def parse(self, structure: SuiteStructure) -> TestSuite:
         structure.visit(self)
-        suite = cast(TestSuite, self.suite)
-        suite.rpa = self.rpa
-        return suite
+        return cast(TestSuite, self.suite)
 
     def visit_file(self, structure: SuiteFile):
         LOGGER.info(f"Parsing file '{structure.source}'.")
         suite = self._build_suite_file(structure)
+        if self.rpa is not None:
+            suite.rpa = self.rpa
         if self.suite is None:
             self.suite = suite
         else:
@@ -239,8 +239,13 @@ class SuiteStructureParser(SuiteStructureVisitor):
 
     def end_directory(self, structure: SuiteDirectory):
         suite, _ = self._stack.pop()
-        if suite.rpa is None and suite.suites:
-            suite.rpa = suite.suites[0].rpa
+        if self.rpa is not None:
+            suite.rpa = self.rpa
+        elif suite.rpa is None and suite.suites:
+            if all(s.rpa is False for s in suite.suites):
+                suite.rpa = False
+            elif all(s.rpa is True for s in suite.suites):
+                suite.rpa = True
 
     def _build_suite_file(self, structure: SuiteFile):
         source = cast(Path, structure.source)
@@ -250,7 +255,6 @@ class SuiteStructureParser(SuiteStructureVisitor):
             suite = parser.parse_suite_file(source, defaults)
             if not suite.tests:
                 LOGGER.info(f"Data source '{source}' has no tests or tasks.")
-            self._validate_execution_mode(suite)
         except DataError as err:
             raise DataError(f"Parsing '{source}' failed: {err.message}")
         return suite
@@ -267,20 +271,6 @@ class SuiteStructureParser(SuiteStructureVisitor):
             raise DataError(f"Parsing '{source}' failed: {err.message}")
         return suite, defaults
 
-    def _validate_execution_mode(self, suite: TestSuite):
-        if self._rpa_given:
-            suite.rpa = self.rpa
-        elif suite.rpa is None:
-            pass
-        elif self.rpa is None:
-            self.rpa = suite.rpa
-        elif self.rpa is not suite.rpa:
-            this, that = ('tasks', 'tests') if suite.rpa else ('tests', 'tasks')
-            raise DataError(f"Conflicting execution modes. File has {this} "
-                            f"but files parsed earlier have {that}. Fix headers "
-                            f"or use '--rpa' or '--norpa' options to set the "
-                            f"execution mode explicitly.")
-
 
 class ResourceFileBuilder:
 

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/builder/parsers.py

@@ -53,22 +53,21 @@ class RobotParser(Parser):
     def parse_suite_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
         model = get_model(self._get_source(source), data_only=True,
                           curdir=self._get_curdir(source), lang=self.lang)
-        suite = TestSuite(name=TestSuite.name_from_source(source, self.extensions),
-                          source=source)
-        SuiteBuilder(suite, FileSettings(defaults)).build(model)
-        return suite
+        model.source = source
+        return self.parse_model(model, defaults)
 
     def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
         model = get_init_model(self._get_source(source), data_only=True,
                                curdir=self._get_curdir(source), lang=self.lang)
-        directory = source.parent
-        suite = TestSuite(name=TestSuite.name_from_source(directory), source=directory)
+        model.source = source
+        suite = TestSuite(name=TestSuite.name_from_source(source.parent),
+                          source=source.parent, rpa=None)
         SuiteBuilder(suite, InitFileSettings(defaults)).build(model)
         return suite
 
     def parse_model(self, model: File, defaults: 'TestDefaults|None' = None) -> TestSuite:
-        source = model.source
-        suite = TestSuite(name=TestSuite.name_from_source(source), source=source)
+        name = TestSuite.name_from_source(model.source, self.extensions)
+        suite = TestSuite(name=name, source=model.source)
         SuiteBuilder(suite, FileSettings(defaults)).build(model)
         return suite
 
@@ -81,7 +80,12 @@ class RobotParser(Parser):
     def parse_resource_file(self, source: Path) -> ResourceFile:
         model = get_resource_model(self._get_source(source), data_only=True,
                                    curdir=self._get_curdir(source), lang=self.lang)
-        resource = ResourceFile(source=source)
+        model.source = source
+        resource = self.parse_resource_model(model)
+        return resource
+
+    def parse_resource_model(self, model: File) -> ResourceFile:
+        resource = ResourceFile(source=model.source)
         ResourceBuilder(resource).build(model)
         return resource
 
@@ -112,7 +116,8 @@ class JsonParser(Parser):
 class NoInitFileDirectoryParser(Parser):
 
     def parse_init_file(self, source: Path, defaults: TestDefaults) -> TestSuite:
-        return TestSuite(name=TestSuite.name_from_source(source), source=source)
+        return TestSuite(name=TestSuite.name_from_source(source),
+                         source=source, rpa=None)
 
 
 class CustomParser(Parser):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/running/builder/settings.py

@@ -13,31 +13,23 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
 from collections.abc import Sequence
+from typing import TypedDict
 
 from ..model import TestCase
 
 
-if sys.version_info >= (3, 8):
-    from typing import TypedDict
+class OptionalItems(TypedDict, total=False):
+    args: 'Sequence[str]'
+    lineno: int
 
 
-    class OptionalItems(TypedDict, total=False):
-        args: 'Sequence[str]'
-        lineno: int
+class FixtureDict(OptionalItems):
+    """Dictionary containing setup or teardown info.
 
-
-    class FixtureDict(OptionalItems):
-        """Dictionary containing setup or teardown info.
-
-        :attr:`args` and :attr:`lineno` are optional.
-        """
-        name: str
-
-else:
-    class FixtureDict(dict):
-        pass
+    :attr:`args` and :attr:`lineno` are optional.
+    """
+    name: str
 
 
 class TestDefaults: