robotframework-pabot 4.3.0__tar.gz → 4.3.2__tar.gz

{robotframework_pabot-4.3.0/src/robotframework_pabot.egg-info → robotframework_pabot-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-pabot
-Version: 4.3.0
+Version: 4.3.2
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -273,7 +273,7 @@ There different possibilities to influence the execution:
   * The order of suites can be changed.
   * If a directory (or a directory structure) should be executed sequentially, add the directory suite name to a row as a ```--suite``` option.
   * If the base suite name is changing with robot option [```--name / -N```](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#setting-the-name) you can also give partial suite name without the base suite.
-  * You can add a line with text  to force executor to wait until all previous suites have been executed.
+  * You can add a line with text `#WAIT` to force executor to wait until all previous suites have been executed.
   * You can group suites and tests together to same executor process by adding line `{` before the group and `}` after. Note that `#WAIT` cannot be used inside a group.
   * You can introduce dependencies using the word `#DEPENDS` after a test declaration. This keyword can be used several times if it is necessary to refer to several different tests. Please take care that in case of circular dependencies an exception will be thrown. Note that each `#WAIT` splits suites into separate execution blocks, and it's not possible to define dependencies for suites or tests that are inside another `#WAIT` block or inside another `{}` brackets.
   * Note: Within a group `{}`, neither execution order nor the `#DEPENDS` keyword currently works. This is due to limitations in Robot Framework, which is invoked within Pabot subprocesses. These limitations may be addressed in a future release of Robot Framework. For now, tests or suites within a group will be executed in the order Robot Framework discovers them — typically in alphabetical order.

{robotframework_pabot-4.3.0 → robotframework_pabot-4.3.2}/README.md

@@ -247,7 +247,7 @@ There different possibilities to influence the execution:
   * The order of suites can be changed.
   * If a directory (or a directory structure) should be executed sequentially, add the directory suite name to a row as a ```--suite``` option.
   * If the base suite name is changing with robot option [```--name / -N```](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#setting-the-name) you can also give partial suite name without the base suite.
-  * You can add a line with text  to force executor to wait until all previous suites have been executed.
+  * You can add a line with text `#WAIT` to force executor to wait until all previous suites have been executed.
   * You can group suites and tests together to same executor process by adding line `{` before the group and `}` after. Note that `#WAIT` cannot be used inside a group.
   * You can introduce dependencies using the word `#DEPENDS` after a test declaration. This keyword can be used several times if it is necessary to refer to several different tests. Please take care that in case of circular dependencies an exception will be thrown. Note that each `#WAIT` splits suites into separate execution blocks, and it's not possible to define dependencies for suites or tests that are inside another `#WAIT` block or inside another `{}` brackets.
   * Note: Within a group `{}`, neither execution order nor the `#DEPENDS` keyword currently works. This is due to limitations in Robot Framework, which is invoked within Pabot subprocesses. These limitations may be addressed in a future release of Robot Framework. For now, tests or suites within a group will be executed in the order Robot Framework discovers them — typically in alphabetical order.

{robotframework_pabot-4.3.0 → robotframework_pabot-4.3.2}/src/pabot/__init__.py

@@ -7,4 +7,4 @@ try:
 except ImportError:
     pass
 
-__version__ = "4.3.0"
+__version__ = "4.3.2"

{robotframework_pabot-4.3.0 → robotframework_pabot-4.3.2}/src/pabot/pabot.py

@@ -2122,19 +2122,23 @@ def _parse_ordering(filename):  # type: (str) -> List[ExecutionItem]
         raise DataError("Error parsing ordering file '%s'" % filename)
 
 
+# TODO: After issue #646, it seems necessary to thoroughly rethink how this functionality should work.
 def _check_ordering(ordering_file, suite_names):  # type: (List[ExecutionItem], List[ExecutionItem]) -> None
     list_of_suite_names = [s.name for s in suite_names]
-    number_of_tests_or_suites = 0
+    skipped_runnable_items = []
     if ordering_file:
         for item in ordering_file:
             if item.type in ['suite', 'test']:
                 if not any((s == item.name or s.endswith("." + item.name)) for s in list_of_suite_names):
                     # If test name is too long, it gets name ' Invalid', so skip that
-                    if item.name != ' Invalid':
-                        raise DataError("%s item '%s' in --ordering file does not match suite or test names in .pabotsuitenames file.\nPlease verify content of --ordering file." % (item.type.title(), item.name))
-                number_of_tests_or_suites += 1
-        if number_of_tests_or_suites > len(list_of_suite_names):
-            raise DataError('Ordering file contains more tests and/or suites than exists. Check that there is no duplicates etc. in ordering file and that to .pabotsuitenames.')
+                    # Additionally, the test is skipped also if the user wants a higher-level suite to be executed sequentially by using 
+                    # the --suite option, and the given name is part of the full name of any test or suite.
+                    if item.name != ' Invalid' and not (item.type == 'suite' and any((s == item.name or s.startswith(item.name + ".")) for s in list_of_suite_names)):
+                        skipped_runnable_items.append(f"{item.type.title()} item: '{item.name}'")
+    if skipped_runnable_items:
+        _write("Note: The ordering file contains test or suite items that are not included in the current test run. The following items will be ignored/skipped:")
+        for item in skipped_runnable_items:
+            _write(f"  - {item}")
 
 
 def _group_suites(outs_dir, datasources, options, pabot_args):
@@ -2143,7 +2147,8 @@ def _group_suites(outs_dir, datasources, options, pabot_args):
     ordering_arg = _parse_ordering(pabot_args.get("ordering")) if (pabot_args.get("ordering")) is not None else None
     if ordering_arg:
         _verify_depends(ordering_arg)
-        _check_ordering(ordering_arg, suite_names)
+        # TODO: After issue #646, it seems necessary to thoroughly rethink how this functionality should work.
+        #_check_ordering(ordering_arg, suite_names)
     ordering_arg_with_sleep = _set_sleep_times(ordering_arg)
     ordered_suites = _preserve_order(suite_names, ordering_arg_with_sleep)
     shard_suites = solve_shard_suites(ordered_suites, pabot_args)

{robotframework_pabot-4.3.0 → robotframework_pabot-4.3.2/src/robotframework_pabot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-pabot
-Version: 4.3.0
+Version: 4.3.2
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -273,7 +273,7 @@ There different possibilities to influence the execution:
   * The order of suites can be changed.
   * If a directory (or a directory structure) should be executed sequentially, add the directory suite name to a row as a ```--suite``` option.
   * If the base suite name is changing with robot option [```--name / -N```](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#setting-the-name) you can also give partial suite name without the base suite.
-  * You can add a line with text  to force executor to wait until all previous suites have been executed.
+  * You can add a line with text `#WAIT` to force executor to wait until all previous suites have been executed.
   * You can group suites and tests together to same executor process by adding line `{` before the group and `}` after. Note that `#WAIT` cannot be used inside a group.
   * You can introduce dependencies using the word `#DEPENDS` after a test declaration. This keyword can be used several times if it is necessary to refer to several different tests. Please take care that in case of circular dependencies an exception will be thrown. Note that each `#WAIT` splits suites into separate execution blocks, and it's not possible to define dependencies for suites or tests that are inside another `#WAIT` block or inside another `{}` brackets.
   * Note: Within a group `{}`, neither execution order nor the `#DEPENDS` keyword currently works. This is due to limitations in Robot Framework, which is invoked within Pabot subprocesses. These limitations may be addressed in a future release of Robot Framework. For now, tests or suites within a group will be executed in the order Robot Framework discovers them — typically in alphabetical order.

{robotframework_pabot-4.3.0 → robotframework_pabot-4.3.2}/tests/test_ordering.py

@@ -34,6 +34,29 @@ class PabotOrderingGroupTest(unittest.TestCase):
             stderr=subprocess.PIPE,
         )
         return process.communicate()
+    
+    def _run_tests_with_root_level_suites(self, testfiles_dict, orderfile):
+        for key, testfile in testfiles_dict.items():
+            with open("{}/{}.robot".format(self.tmpdir, key), "w") as f:
+                f.write(textwrap.dedent(testfile))
+        with open("{}/order.dat".format(self.tmpdir), "w") as f:
+            f.write(textwrap.dedent(orderfile))
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                "-m" "pabot.pabot",
+                "--testlevelsplit",
+                "--name",
+                "Top Suite",
+                "--ordering",
+                "{}/order.dat".format(self.tmpdir),
+                "{}/".format(self.tmpdir),
+            ],
+            cwd=self.tmpdir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return process.communicate()
 
     def test_orders(self):
         stdout, stderr = self._run_tests_with(
@@ -68,6 +91,81 @@ class PabotOrderingGroupTest(unittest.TestCase):
             self.assertNotIn(b"FAILED", stdout, stderr)
             self.assertEqual(stdout.count(b"PASSED"), 2)
 
+    def NOT_VALID_test_sequential_suite_execution_invalid_name(self):
+        stdout, stderr = self._run_tests_with(
+            """
+        *** Variables ***
+        ${SCALAR}  Hello, globe!
+        *** Test Cases ***
+        First Test
+            Set Suite Variable	${SCALAR}	Hello, world!
+        Second Test
+            Should Be Equal  ${SCALAR}	Hello, world!
+        Third Test
+            Should Be Equal  ${SCALAR}	Hello, world!
+        """,
+            """
+        --suite Invalid Name
+        """,
+        )
+        self.assertIn(b"Suite item 'Invalid Name' in --ordering file does not match suite or test names in .pabotsuitenames file.", stdout)
+        self.assertEqual(b"", stderr)
+
+    def test_multiple_suites_and_ordering_ok(self):
+        testfiles = {
+            "Suite 1":
+            """
+            *** Variables ***
+            ${SCALAR}  Hello, globe!
+
+            *** Test Cases ***
+            First Test
+                Set Suite Variable	${SCALAR}	Hello, world!
+
+            Second Test
+                Should Be Equal  ${SCALAR}	Hello, world!
+
+            Second And Quarter
+                Should Be Equal  ${SCALAR}	Hello, globe!
+
+            Second And Half
+                Should Be Equal  ${SCALAR}	Hello, globe!
+
+            Third Test
+                Should Be Equal  ${SCALAR}	Hello, globe!
+            """,
+            "Suite 2":
+            """
+            *** Variables ***
+            ${SCALAR}  Hello, globe!
+            *** Test Cases ***
+            First Test
+                Set Suite Variable	${SCALAR}	Hello, world!
+            Second Test
+                Should Be Equal  ${SCALAR}	Hello, world!
+            Third Test
+                Should Be Equal  ${SCALAR}	Hello, world!
+            """,
+        }
+        ordering_file = """
+        {
+        --test Top Suite.Suite 1.First Test
+        --test Top Suite.Suite 1.Second Test
+        }
+        {
+        --test Top Suite.Suite 1.Second And Quarter
+        --test Top Suite.Suite 1.Second And Half
+        }
+        --test Top Suite.Suite 1.Third Test
+        --suite Top Suite.Suite 2
+        """
+        stdout, stderr = self._run_tests_with_root_level_suites(testfiles, ordering_file)
+        self.assertIn(b"PASSED", stdout, stderr)
+        self.assertNotIn(b"FAILED", stdout, stderr)
+        self.assertEqual(stdout.count(b"PASSED"), 4)
+        self.assertIn(b"8 tests, 8 passed, 0 failed, 0 skipped.", stdout)
+        self.assertEqual(b"", stderr)
+
     def test_two_orders(self):
         stdout, stderr = self._run_tests_with(
             """
@@ -338,7 +436,7 @@ class PabotOrderingMalformedTest(unittest.TestCase):
         )
         return process.communicate()
 
-    def test_ordering_file_contains_not_existing_test(self):
+    def NOT_VALID_test_ordering_file_contains_not_existing_test(self):
         stdout, stderr = self._run_tests_with(
             """
         *** Test Cases ***
@@ -363,7 +461,7 @@ class PabotOrderingMalformedTest(unittest.TestCase):
         )
         self.assertIn(b"Test item 'Test.Test Case E' in --ordering file does not match suite or test names in .pabotsuitenames file.", stdout, stderr)
 
-    def test_ordering_file_contains_not_existing_default_item(self):
+    def NOT_VALID_test_ordering_file_contains_not_existing_default_item(self):
         # Default item is suite
         stdout, stderr = self._run_tests_with(
             """
@@ -416,7 +514,7 @@ class PabotOrderingMalformedTest(unittest.TestCase):
         )
         self.assertIn(b"Suite or test name cannot be empty and then contain #DEPENDS like:   #DEPENDS Test.Test Case D", stdout, stderr)
 
-    def test_ordering_file_contains_too_many_runnable_items(self):
+    def NOT_VALID_test_ordering_file_contains_too_many_runnable_items(self):
         # Default item is suite
         stdout, stderr = self._run_tests_with(
             """