robotframework 6.1.1__zip → 7.0a1__zip

{robotframework-6.1.1 → 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.1.1 → robotframework-7.0a1}/src/robot/running/builder/parsers.py

@@ -53,23 +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, rpa=None)
+        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
 
@@ -82,8 +80,8 @@ 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)
+        model.source = source
         resource = self.parse_resource_model(model)
-        resource.source = source
         return resource
 
     def parse_resource_model(self, model: File) -> ResourceFile:

{robotframework-6.1.1 → 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: