robotframework-pabot 3.0.1__tar.gz → 4.0.0__tar.gz

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework-pabot
-Version: 3.0.1
+Version: 4.0.0
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -17,5 +17,8 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Robot Framework
 Requires-Python: >=3.6
 License-File: LICENSE.txt
+Requires-Dist: robotframework>=3.2
+Requires-Dist: robotframework-stacktrace>=0.4.1
+Requires-Dist: natsort>=8.2.0
 
 A parallel executor for Robot Framework tests. With Pabot you can split one execution into multiple and save test execution time.

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/README.md

@@ -55,14 +55,14 @@ There are several ways you can help in improving this tool:
 ## Command-line options
 
     pabot [--verbose|--testlevelsplit|--command .. --end-command|
-           --processes num|--pabotlib|--pabotlibhost host|--pabotlibport port|
+           --processes num|--no-pabotlib|--pabotlibhost host|--pabotlibport port|
            --processtimeout num|
            --shard i/n|
            --artifacts extensions|--artifactsinsubfolders|
            --resourcefile file|--argumentfile[num] file|--suitesfrom file] 
           [robot options] [path ...]
 
-Supports all [Robot Framework command line options](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#all-command-line-options) and also following options (these must be before RF options):
+Supports all [Robot Framework command line options](https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#all-command-line-options) and also following pabot options:
 
 --verbose     
   more output from the parallel execution
@@ -83,8 +83,11 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   Special option "all" will use as many processes as there are
   executable suites or tests.
 
---pabotlib          
-  Start PabotLib remote server. This enables locking and resource distribution between parallel test executions.
+PabotLib remote server is started by default to enable locking and resource distribution 
+between parallel test executions.
+
+--no-pabotlib
+  Disable the PabotLib remote server if you don't need locking or resource distribution features.
 
 --pabotlibhost   [HOSTNAME]          
   Host name of the PabotLib remote server (default is 127.0.0.1)
@@ -142,8 +145,9 @@ Example usages:
      pabot --command java -jar robotframework.jar --end-command --include SMOKE tests
      pabot --processes 10 tests     
      pabot --pabotlibhost 192.168.1.123 --pabotlibport 8271 --processes 10 tests
-     pabot --pabotlib --pabotlibhost 192.168.1.111 --pabotlibport 8272 --processes 10 tests
      pabot --artifacts png,mp4,txt --artifactsinsubfolders directory_to_tests
+     # To disable PabotLib:
+     pabot --no-pabotlib tests
 
 ### PabotLib
 

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/src/pabot/__init__.py

@@ -1,4 +1,4 @@
 from __future__ import absolute_import
 
 from .pabotlib import PabotLib
-__version__ = "3.0.1"
+__version__ = "4.0.0"

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/src/pabot/arguments.py

@@ -80,7 +80,7 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         "verbose": False,
         "help": False,
         "testlevelsplit": False,
-        "pabotlib": False,
+        "pabotlib": True,
         "pabotlibhost": "127.0.0.1",
         "pabotlibport": 8270,
         "processes": _processes_count(),
@@ -91,108 +91,100 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         "shardcount": 1,
         "chunk": False,
     }
+    # Explicitly define argument types for validation
+    flag_args = {
+        "verbose", "help", "testlevelsplit", "pabotlib", 
+        "artifactsinsubfolders", "chunk"
+    }
+    value_args = {
+        "hive": str,
+        "processes": lambda x: int(x) if x != 'all' else None,
+        "resourcefile": str,
+        "pabotlibhost": str,
+        "pabotlibport": int,
+        "processtimeout": int,
+        "ordering": _parse_ordering,
+        "suitesfrom": str,
+        "artifacts": lambda x: x.split(","),
+        "shard": _parse_shard
+    }
+
     argumentfiles = []
-    while args and (
-        args[0]
-        in [
-            "--" + param
-            for param in [
-                "hive",
-                "command",
-                "processes",
-                "verbose",
-                "resourcefile",
-                "testlevelsplit",
-                "pabotlib",
-                "pabotlibhost",
-                "pabotlibport",
-                "processtimeout",
-                "ordering",
-                "suitesfrom",
-                "artifacts",
-                "artifactsinsubfolders",
-                "help",
-                "shard",
-                "chunk",
-            ]
-        ]
-        or ARGSMATCHER.match(args[0])
-    ):
-        if args[0] == "--hive":
-            pabot_args["hive"] = args[1]
-            args = args[2:]
-            continue
-        if args[0] == "--command":
-            end_index = args.index("--end-command")
-            pabot_args["command"] = args[1:end_index]
-            args = args[end_index + 1 :]
-            continue
-        if args[0] == "--processes":
-            pabot_args["processes"] = int(args[1]) if args[1] != 'all' else None
-            args = args[2:]
-            continue
-        if args[0] == "--verbose":
-            pabot_args["verbose"] = True
-            args = args[1:]
-            continue
-        if args[0] == "--chunk":
-            pabot_args["chunk"] = True
-            args = args[1:]
-            continue
-        if args[0] == "--resourcefile":
-            pabot_args["resourcefile"] = args[1]
-            args = args[2:]
-            continue
-        if args[0] == "--pabotlib":
-            pabot_args["pabotlib"] = True
-            args = args[1:]
-            continue
-        if args[0] == "--ordering":
-            pabot_args["ordering"] = _parse_ordering(args[1])
-            args = args[2:]
+    remaining_args = []
+    i = 0
+
+    # Track conflicting options during parsing
+    saw_pabotlib_flag = False
+    saw_no_pabotlib = False
+
+    while i < len(args):
+        arg = args[i]
+        if not arg.startswith('--'):
+            remaining_args.append(arg)
+            i += 1
             continue
-        if args[0] == "--testlevelsplit":
-            pabot_args["testlevelsplit"] = True
+            
+        arg_name = arg[2:]  # Strip '--'
+
+        if arg_name == "no-pabotlib":
+            saw_no_pabotlib = True
+            pabot_args["pabotlib"] = False  # Just set the main flag
             args = args[1:]
             continue
-        if args[0] == "--pabotlibhost":
-            pabot_args["pabotlibhost"] = args[1]
-            args = args[2:]
-            continue
-        if args[0] == "--pabotlibport":
-            pabot_args["pabotlibport"] = int(args[1])
-            args = args[2:]
-            continue
-        if args[0] == "--processtimeout":
-            pabot_args["processtimeout"] = int(args[1])
-            args = args[2:]
-            continue
-        if args[0] == "--suitesfrom":
-            pabot_args["suitesfrom"] = args[1]
-            args = args[2:]
-            continue
-        if args[0] == "--artifacts":
-            pabot_args["artifacts"] = args[1].split(",")
-            args = args[2:]
-            continue
-        if args[0] == "--artifactsinsubfolders":
-            pabot_args["artifactsinsubfolders"] = True
+        if arg_name == "pabotlib":
+            saw_pabotlib_flag = True
             args = args[1:]
             continue
-        if args[0] == "--shard":
-            pabot_args["shardindex"], pabot_args["shardcount"] = _parse_shard(args[1])
-            args = args[2:]
-            continue
-        match = ARGSMATCHER.match(args[0])
+        
+        # Special case for command
+        if arg_name == "command":
+            try:
+                end_index = args.index("--end-command", i)
+                pabot_args["command"] = args[i+1:end_index]
+                i = end_index + 1
+                continue
+            except ValueError:
+                raise DataError("--command requires matching --end-command")
+                
+        # Handle flag arguments
+        if arg_name in flag_args:
+            pabot_args[arg_name] = True
+            i += 1
+            continue
+            
+        # Handle value arguments
+        if arg_name in value_args:
+            if i + 1 >= len(args):
+                raise DataError(f"--{arg_name} requires a value")
+            try:
+                value = value_args[arg_name](args[i + 1])
+                if arg_name == "shard":
+                    pabot_args["shardindex"], pabot_args["shardcount"] = value
+                else:
+                    pabot_args[arg_name] = value
+                i += 2
+                continue
+            except (ValueError, TypeError) as e:
+                raise DataError(f"Invalid value for --{arg_name}: {args[i + 1]}")
+                
+        # Handle argument files
+        match = ARGSMATCHER.match(arg)
         if match:
-            argumentfiles += [(match.group(1), args[1])]
-            args = args[2:]
-            continue
-        if args and args[0] == "--help":
-            pabot_args["help"] = True
-            args = args[1:]
+            if i + 1 >= len(args):
+                raise DataError(f"{arg} requires a value")
+            argumentfiles.append((match.group(1), args[i + 1]))
+            i += 2
+            continue
+            
+        # If we get here, it's a non-pabot argument
+        remaining_args.append(arg)
+        i += 1
+    
+    if saw_pabotlib_flag and saw_no_pabotlib:
+        raise DataError("Cannot use both --pabotlib and --no-pabotlib options together")
+    
     pabot_args["argumentfiles"] = argumentfiles
-    return args, pabot_args
+    return remaining_args, pabot_args
 
 
 def _parse_ordering(filename):  # type: (str) -> List[ExecutionItem]

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/src/pabot/pabot.py

@@ -1152,14 +1152,15 @@ def generate_suite_names_with_builder(outs_dir, datasources, options):
     settings = RobotSettings(opts)
 
     # Note: first argument (included_suites) is deprecated from RobotFramework 6.1
-    if ROBOT_VERSION < "6.1":
+    if ROBOT_VERSION >= "6.1":
         builder = TestSuiteBuilder(
-            settings["SuiteNames"], settings.extension, rpa=settings.rpa
+            included_extensions=settings.extension, rpa=settings.rpa, lang=opts.get("language")
         )
     else:
         builder = TestSuiteBuilder(
-            included_extensions=settings.extension, rpa=settings.rpa
-        )
+            settings["SuiteNames"], settings.extension, rpa=settings.rpa
+        ) 
+
     suite = builder.build(*datasources)
     settings.rpa = builder.rpa
     suite.configure(**settings.suite_config)
@@ -1775,7 +1776,7 @@ def _create_execution_items_for_dry_run(
         chunk_size = (
             round(len(items) / processes_count)
             if len(items) > processes_count
-            else len(items)
+            else 1
         )
         chunked_items = list(_chunk_items(items, chunk_size))
         _NUMBER_OF_ITEMS_TO_BE_EXECUTED += len(chunked_items)
@@ -2018,17 +2019,17 @@ def _verify_depends(suite_names):
         )
     )
     if suites_with_depends != suites_with_found_dependencies:
-        raise Exception("There are unmet dependencies using #DEPENDS")
+        raise DataError("Invalid test configuration: Some test suites have dependencies (#DEPENDS) that cannot be found.")
     suites_with_circular_dependencies = list(
         filter(lambda suite: suite.depends == suite.name, suites_with_depends)
     )
     if suites_with_circular_dependencies:
-        raise Exception("There are suites with circular dependencies using #DEPENDS")
+        raise DataError("Invalid test configuration: Test suites cannot depend on themselves.")
     grouped_suites = list(
         filter(lambda suite: isinstance(suite, GroupItem), suite_names)
     )
     if grouped_suites and suites_with_depends:
-        raise Exception("#DEPENDS and grouped suites are incompatible")
+        raise DataError("Invalid test configuration: Cannot use both #DEPENDS and grouped suites.")
 
 
 def _group_by_depend(suite_names):
@@ -2056,7 +2057,7 @@ def _group_by_depend(suite_names):
         dependency_tree += [dependent_on_last_stage]
     flattened_dependency_tree = sum(dependency_tree, [])
     if len(flattened_dependency_tree) != len(runnable_suites):
-        raise Exception("There are circular or unmet dependencies using #DEPENDS")
+        raise DataError("Invalid test configuration: Circular or unmet dependencies detected between test suites. Please check your #DEPENDS definitions.")
     return dependency_tree
 
 

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/src/robotframework_pabot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robotframework-pabot
-Version: 3.0.1
+Version: 4.0.0
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -17,5 +17,8 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: Robot Framework
 Requires-Python: >=3.6
 License-File: LICENSE.txt
+Requires-Dist: robotframework>=3.2
+Requires-Dist: robotframework-stacktrace>=0.4.1
+Requires-Dist: natsort>=8.2.0
 
 A parallel executor for Robot Framework tests. With Pabot you can split one execution into multiple and save test execution time.

{robotframework-pabot-3.0.1 → robotframework_pabot-4.0.0}/src/robotframework_pabot.egg-info/SOURCES.txt

@@ -25,4 +25,15 @@ src/robotframework_pabot.egg-info/SOURCES.txt
 src/robotframework_pabot.egg-info/dependency_links.txt
 src/robotframework_pabot.egg-info/entry_points.txt
 src/robotframework_pabot.egg-info/requires.txt
-src/robotframework_pabot.egg-info/top_level.txt
+src/robotframework_pabot.egg-info/top_level.txt
+tests/test_arguments_output.py
+tests/test_depends.py
+tests/test_functional.py
+tests/test_ordering.py
+tests/test_pabot.py
+tests/test_pabotlib.py
+tests/test_pabotsuitenames_io.py
+tests/test_resultmerger.py
+tests/test_stacktrace.py
+tests/test_testlevelsplit_include.py
+tests/test_testlevelsplit_output_task_order.py

robotframework_pabot-4.0.0/tests/test_arguments_output.py

@@ -0,0 +1,67 @@
+import sys
+import tempfile
+import textwrap
+import unittest
+import shutil
+import subprocess
+
+
+class PabotArgumentsOutputsTest(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+    def _run_tests_with(self, testfile, arg1file, arg2file):
+        robot_file = open("{}/test.robot".format(self.tmpdir), "w")
+        robot_file.write(textwrap.dedent(testfile))
+        robot_file.close()
+        with open("{}/arg1.txt".format(self.tmpdir), "w") as f:
+            f.write(textwrap.dedent(arg1file))
+        with open("{}/arg2.txt".format(self.tmpdir), "w") as f:
+            f.write(textwrap.dedent(arg2file))
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                "-m" "pabot.pabot",
+                "--processes",
+                "2",
+                "--argumentfile1",
+                "{}/arg1.txt".format(self.tmpdir),
+                "--argumentfile2",
+                "{}/arg2.txt".format(self.tmpdir),
+                "--outputdir",
+                self.tmpdir,
+                "--output",
+                "test.xml",
+                "{}/test.robot".format(self.tmpdir),
+            ],
+            cwd=self.tmpdir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return process.communicate(), process.returncode
+
+    def test_argumentfile_outputs(self):
+        (stdout, stderr), rc = self._run_tests_with(
+            """
+        *** Test Cases ***
+        Test 1
+            Log     ${VALUE}
+            Should Be True  ${VALUE} == 2
+        """,
+            """
+        --variable VALUE:1
+        """,
+            """
+        --variable VALUE:2
+        """,
+        )
+        self.assertEqual(rc, 1)
+        if sys.version_info < (3, 0):
+            self.assertIn("PASSED", stdout, stderr)
+            self.assertIn("failed", stdout, stderr)
+        else:
+            self.assertIn(b"PASSED", stdout, stderr)
+            self.assertIn(b"failed", stdout, stderr)

robotframework_pabot-4.0.0/tests/test_depends.py

@@ -0,0 +1,133 @@
+import subprocess
+import sys
+import textwrap
+import shutil
+import tempfile
+import unittest
+
+
+def _string_convert(byte_string):
+    legacy_python = sys.version_info < (3, 0)
+    return byte_string.decode() if legacy_python else byte_string
+
+
+class DependsTest(unittest.TestCase):
+    test_file = """
+        *** Settings ***
+        Test Template    Test1
+        *** Test Cases ***
+        The Test S1Test 01    1
+        The Test S1Test 02    1
+        The Test S1Test 03    1
+        The Test S1Test 04    1
+        The Test S1Test 05    1
+        The Test S1Test 06    1
+        The Test S1Test 07    1
+        The Test S1Test 08    1
+        The Test S1Test 09    1
+        The Test S1Test 10    1
+        The Test S1Test 11    1
+        The Test S1Test 12    1
+        *** Keywords ***
+        Test1
+            [Arguments]  ${arg}
+            Log  Test
+        """
+    passed = _string_convert(b"PASSED")
+    failed = _string_convert(b"FAILED")
+    test_01 = _string_convert(b"S1Test 01")
+    test_02 = _string_convert(b"S1Test 02")
+    test_08 = _string_convert(b"S1Test 08")
+
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)
+
+    def _run_tests_with(self, testfile, orderfile):
+        robot_file = open("{}/test.robot".format(self.tmpdir), "w")
+        robot_file.write(textwrap.dedent(testfile))
+        robot_file.close()
+        with open("{}/order.dat".format(self.tmpdir), "w") as f:
+            f.write(textwrap.dedent(orderfile))
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                "-m" "pabot.pabot",
+                "--testlevelsplit",
+                "--ordering",
+                "{}/order.dat".format(self.tmpdir),
+                "{}/test.robot".format(self.tmpdir),
+            ],
+            cwd=self.tmpdir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return process.communicate()
+
+    def test_dependency_ok(self):
+        stdout, stderr = self._run_tests_with(
+            self.test_file,
+            """
+        --test Test.The Test S1Test 01 #DEPENDS Test.The Test S1Test 02
+        --test Test.The Test S1Test 02 #DEPENDS Test.The Test S1Test 08
+        --test Test.The Test S1Test 08
+        """,
+        )
+        self.assertIn(self.passed, stdout, stderr)
+        self.assertNotIn(self.failed, stdout, stderr)
+        self.assertEqual(stdout.count(self.passed), 12)
+        test_01_index = stdout.find(self.test_01)
+        test_02_index = stdout.find(self.test_02)
+        test_08_index = stdout.find(self.test_08)
+        self.assertNotEqual(test_01_index, -1)
+        self.assertNotEqual(test_02_index, -1)
+        self.assertNotEqual(test_08_index, -1)
+        self.assertTrue(test_08_index < test_02_index)
+        self.assertTrue(test_02_index < test_01_index)
+
+    def test_circular_dependency(self):
+        stdout, stderr = self._run_tests_with(
+            self.test_file,
+            """
+        --test Test.The Test S1Test 01 #DEPENDS Test.The Test S1Test 02
+        --test Test.The Test S1Test 02 #DEPENDS Test.The Test S1Test 01
+        --test Test.The Test S1Test 08
+        """,
+        )
+        self.assertIn(b"Invalid test configuration: Circular or unmet dependencies detected between test suites", stdout)
+
+    def test_unmet_dependency(self):
+        stdout, stderr = self._run_tests_with(
+            self.test_file,
+            """
+        --test Test.The Test S1Test 01
+        --test Test.The Test S1Test 02 #DEPENDS Test.The Test S1Test 23
+        --test Test.The Test S1Test 08
+        """,
+        )
+        self.assertIn(b"Invalid test configuration: Circular or unmet dependencies detected between test suites. Please check your #DEPENDS definitions.", stdout)
+
+    def test_same_reference(self):
+        stdout, stderr = self._run_tests_with(
+            self.test_file,
+            """
+        --test Test.The Test S1Test 01
+        --test Test.The Test S1Test 02 #DEPENDS Test.The Test S1Test 02
+        --test Test.The Test S1Test 08
+        """,
+        )
+        self.assertIn(b"Invalid test configuration: Circular or unmet dependencies detected between test suites. Please check your #DEPENDS definitions.", stdout)
+
+    def test_wait(self):
+        stdout, stderr = self._run_tests_with(
+            self.test_file,
+            """
+        --test Test.The Test S1Test 01
+        --test Test.The Test S1Test 02 #DEPENDS Test.The Test S1Test 08
+        #WAIT
+        --test Test.The Test S1Test 08
+        """,
+        )
+        self.assertIn(b"Invalid test configuration: Circular or unmet dependencies detected between test suites", stdout)

robotframework_pabot-4.0.0/tests/test_functional.py

@@ -0,0 +1,51 @@
+import os
+import sys
+import tempfile
+import textwrap
+import unittest
+import shutil
+import subprocess
+
+
+if os.name != "posix":
+    raise unittest.SkipTest("Only posix test")
+
+
+class PabotPassJsonUsingVariableOptionTests(unittest.TestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        robot_file = open("{}/test.robot".format(self.tmpdir), "w")
+        robot_file.write(
+            textwrap.dedent(
+                """
+        *** Test Cases ***
+        Test Passing Json With -v option
+            Should Be Equal    ${custom_var}    {"key": "value"}
+        """
+            )
+        )
+        robot_file.close()
+
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                "-m" "pabot.pabot",
+                "-v",
+                'custom_var:{"key": "value"}',
+                "{}/test.robot".format(self.tmpdir),
+            ],
+            cwd=self.tmpdir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        self.stdout, self.stderr = process.communicate()
+
+    def test_stdout_should_display_passed_test(self):
+        if sys.version_info < (3, 0):
+            self.assertIn("PASSED Test", self.stdout, self.stderr)
+        else:
+            self.assertIn(b"PASSED Test", self.stdout, self.stderr)
+
+    def tearDown(self):
+        shutil.rmtree(self.tmpdir)