robotframework-pabot 3.1.0__py3-none-any.whl

pabot/SharedLibrary.py

@@ -0,0 +1,62 @@
+from __future__ import absolute_import
+
+from robot import __version__ as ROBOT_VERSION
+from robot.api import logger
+from robot.libraries.BuiltIn import BuiltIn
+from robot.libraries.Remote import Remote
+from robot.running.testlibraries import TestLibrary
+
+from .pabotlib import PABOT_QUEUE_INDEX
+from .robotremoteserver import RemoteLibraryFactory
+
+
+class SharedLibrary(object):
+
+    ROBOT_LIBRARY_SCOPE = "GLOBAL"
+
+    def __init__(self, name, args=None):
+        """
+        Import a library so that the library instance is shared between executions.
+        [https://pabot.org/PabotLib.html?ref=log#import-shared-library|Open online docs.]
+        """
+        # FIXME: RELATIVE IMPORTS WITH FILE NAME
+        self._remote = None
+        if BuiltIn().get_variable_value("${%s}" % PABOT_QUEUE_INDEX) is None:
+            logger.debug(
+                "Not currently running pabot. Importing library for this process."
+            )
+            self._lib = RemoteLibraryFactory(
+                TestLibrary.from_name(name, args=args, variables=None, create_keywords=True).instance 
+                if ROBOT_VERSION >= "7.0" 
+                else TestLibrary(name, args=args).get_instance()
+            )
+            return
+        uri = BuiltIn().get_variable_value("${PABOTLIBURI}")
+        logger.debug("PabotLib URI %r" % uri)
+        remotelib = Remote(uri) if uri else None
+        if remotelib:
+            try:
+                port = remotelib.run_keyword("import_shared_library", [name], {"args": args})
+            except RuntimeError:
+                logger.error("No connection - is pabot called with --pabotlib option?")
+                raise
+            self._remote = Remote("http://127.0.0.1:%s" % port)
+            logger.debug(
+                "Lib imported with name %s from http://127.0.0.1:%s" % (name, port)
+            )
+        else:
+            logger.error("No connection - is pabot called with --pabotlib option?")
+            raise AssertionError("No connection to pabotlib")
+
+    def get_keyword_names(self):
+        if self._remote:
+            return self._remote.get_keyword_names()
+        return self._lib.get_keyword_names()
+
+    def run_keyword(self, name, args, kwargs):
+        if self._remote:
+            return self._remote.run_keyword(name, args, kwargs)
+        result = self._lib.run_keyword(name, args, kwargs)
+        if result["status"] == "FAIL":
+            raise AssertionError(result["error"])
+        return result.get("return")

pabot/__init__.py

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

pabot/arguments.py

@@ -0,0 +1,236 @@
+import multiprocessing
+import re
+from typing import Dict, List, Optional, Tuple
+
+from robot import __version__ as ROBOT_VERSION
+from robot.errors import DataError
+from robot.run import USAGE
+from robot.utils import ArgumentParser
+
+from .execution_items import (
+    DynamicTestItem,
+    ExecutionItem,
+    GroupEndItem,
+    GroupStartItem,
+    IncludeItem,
+    SuiteItem,
+    TestItem,
+    WaitItem,
+)
+
+ARGSMATCHER = re.compile(r"--argumentfile(\d+)")
+
+
+def _processes_count():  # type: () -> int
+    try:
+        return max(multiprocessing.cpu_count(), 2)
+    except NotImplementedError:
+        return 2
+
+
+def _filter_argument_parser_options(**options):
+    # Note: auto_pythonpath is deprecated since RobotFramework 5.0, but only
+    # communicated to users from 6.1
+    if ROBOT_VERSION >= "5.0" and "auto_pythonpath" in options:
+        del options["auto_pythonpath"]
+    return options
+
+
+def parse_args(
+    args,
+):  # type: (List[str]) -> Tuple[Dict[str, object], List[str], Dict[str, object], Dict[str, object]]
+    args, pabot_args = _parse_pabot_args(args)
+    options, datasources = ArgumentParser(
+        USAGE,
+        **_filter_argument_parser_options(
+            auto_pythonpath=False,
+            auto_argumentfile=True,
+            env_options="ROBOT_OPTIONS",
+        ),
+    ).parse_args(args)
+    options_for_subprocesses, sources_without_argfile = ArgumentParser(
+        USAGE,
+        **_filter_argument_parser_options(
+            auto_pythonpath=False,
+            auto_argumentfile=False,
+            env_options="ROBOT_OPTIONS",
+        ),
+    ).parse_args(args)
+    if len(datasources) != len(sources_without_argfile):
+        raise DataError(
+            "Pabot does not support datasources in argumentfiles.\nPlease move datasources to commandline."
+        )
+    if len(datasources) > 1 and options["name"] is None:
+        options["name"] = "Suites"
+        options_for_subprocesses["name"] = "Suites"
+    opts = _delete_none_keys(options)
+    opts_sub = _delete_none_keys(options_for_subprocesses)
+    return opts, datasources, pabot_args, opts_sub
+
+
+def _parse_shard(arg):
+    # type: (str) -> Tuple[int, int]
+    parts = arg.split("/")
+    return int(parts[0]), int(parts[1])
+
+
+def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str, object]]
+    pabot_args = {
+        "command": ["pybot" if ROBOT_VERSION < "3.1" else "robot"],
+        "verbose": False,
+        "help": False,
+        "testlevelsplit": False,
+        "pabotlib": False,
+        "pabotlibhost": "127.0.0.1",
+        "pabotlibport": 8270,
+        "processes": _processes_count(),
+        "processtimeout": None,
+        "artifacts": ["png"],
+        "artifactsinsubfolders": False,
+        "shardindex": 0,
+        "shardcount": 1,
+        "chunk": False,
+    }
+    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:]
+            continue
+        if args[0] == "--testlevelsplit":
+            pabot_args["testlevelsplit"] = True
+            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
+            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])
+        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:]
+    pabot_args["argumentfiles"] = argumentfiles
+    return args, pabot_args
+
+
+def _parse_ordering(filename):  # type: (str) -> List[ExecutionItem]
+    try:
+        with open(filename, "r") as orderingfile:
+            return [
+                parse_execution_item_line(line.strip())
+                for line in orderingfile.readlines()
+            ]
+    except:
+        raise DataError("Error parsing ordering file '%s'" % filename)
+
+
+def _delete_none_keys(d):  # type: (Dict[str, Optional[object]]) -> Dict[str, object]
+    keys = set()
+    for k in d:
+        if d[k] is None:
+            keys.add(k)
+    for k in keys:
+        del d[k]
+    return d
+
+
+def parse_execution_item_line(text):  # type: (str) -> ExecutionItem
+    if text.startswith("--suite "):
+        return SuiteItem(text[8:])
+    if text.startswith("--test "):
+        return TestItem(text[7:])
+    if text.startswith("--include "):
+        return IncludeItem(text[10:])
+    if text.startswith("DYNAMICTEST"):
+        suite, test = text[12:].split(" :: ")
+        return DynamicTestItem(test, suite)
+    if text == "#WAIT":
+        return WaitItem()
+    if text == "{":
+        return GroupStartItem()
+    if text == "}":
+        return GroupEndItem()
+    # Assume old suite name
+    return SuiteItem(text)

pabot/clientwrapper.py

@@ -0,0 +1,10 @@
+import sys
+
+try:
+    from .py3.client import make_order
+except SyntaxError:
+
+    def make_order(*args):
+        print("Client needs to be run in Python >= 3.6")
+        print("You are running %s" % sys.version)
+        sys.exit(1)

pabot/coordinatorwrapper.py

@@ -0,0 +1,8 @@
+import sys
+
+try:
+    from .py3.coordinator import main
+except SyntaxError:
+    print("Coordinator needs to be run in Python >= 3.6")
+    print("You are running %s" % sys.version)
+    sys.exit(1)

pabot/execution_items.py

@@ -0,0 +1,320 @@
+from functools import total_ordering
+from typing import Dict, List, Optional, Tuple, Union
+
+from robot import __version__ as ROBOT_VERSION
+from robot.errors import DataError
+from robot.utils import PY2, is_unicode
+
+
+@total_ordering
+class ExecutionItem(object):
+
+    isWait = False
+    type = None  # type: str
+    name = None  # type: str
+
+    def top_name(self):
+        # type: () -> str
+        return self.name.split(".")[0]
+
+    def contains(self, other):
+        # type: (ExecutionItem) -> bool
+        return False
+
+    def difference(self, from_items):
+        # type: (List[ExecutionItem]) -> List[ExecutionItem]
+        return []
+
+    def line(self):
+        # type: () -> str
+        return ""
+
+    def modify_options_for_executor(self, options):
+        options[self.type] = self.name
+
+    def __eq__(self, other):
+        if isinstance(other, ExecutionItem):
+            return (self.name, self.type) == (other.name, other.type)
+        return NotImplemented
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __lt__(self, other):
+        return (self.name, self.type) < (other.name, other.type)
+
+    def __hash__(self):
+        return hash(self.name) | hash(self.type)
+
+    def __repr__(self):
+        return "<" + self.type + ":" + self.name + ">"
+
+
+class HivedItem(ExecutionItem):
+
+    type = "hived"
+
+    def __init__(self, item, hive):
+        self._item = item
+        self._hive = hive
+
+    def modify_options_for_executor(self, options):
+        self._item.modify_options_for_executor(options)
+
+    @property
+    def name(self):
+        return self._item.name
+
+
+class GroupItem(ExecutionItem):
+
+    type = "group"
+
+    def __init__(self):
+        self.name = "Group_"
+        self._items = []
+        self._element_type = None
+
+    def add(self, item):
+        if item.isWait:
+            raise DataError("[EXCEPTION] Ordering : Group can not contain #WAIT")
+        if self._element_type and self._element_type != item.type:
+            raise DataError(
+                "[EXCEPTION] Ordering : Group can contain only test or suite elements. Not bouth"
+            )
+        if len(self._items) > 0:
+            self.name += "_"
+        self.name += item.name
+        self._element_type = item.type
+        self._items.append(item)
+
+    def modify_options_for_executor(self, options):
+        for item in self._items:
+            if item.type not in options:
+                options[item.type] = []
+            opts = {}
+            item.modify_options_for_executor(opts)
+            options[item.type].append(opts[item.type])
+
+
+class RunnableItem(ExecutionItem):
+    pass
+
+    depends = None  # type: str
+    depends_keyword = "#DEPENDS"
+
+    def set_name_and_depends(self, name):
+        line_name = name.encode("utf-8") if PY2 and is_unicode(name) else name
+        depends_begin_index = line_name.find(self.depends_keyword)
+        self.name = (
+            line_name
+            if depends_begin_index == -1
+            else line_name[0:depends_begin_index].strip()
+        )
+        self.depends = (
+            line_name[depends_begin_index + len(self.depends_keyword) :].strip()
+            if depends_begin_index != -1
+            else None
+        )
+
+    def line(self):
+        # type: () -> str
+        line_without_depends = "--" + self.type + " " + self.name
+        return (
+            line_without_depends + " " + self.depends_keyword + " " + self.depends
+            if self.depends
+            else line_without_depends
+        )
+
+
+class SuiteItem(RunnableItem):
+
+    type = "suite"
+
+    def __init__(self, name, tests=None, suites=None, dynamictests=None):
+        # type: (str, Optional[List[str]], Optional[List[str]], Optional[List[str]]) -> None
+        assert (PY2 and isinstance(name, basestring)) or isinstance(name, str)
+        self.set_name_and_depends(name)
+        testslist = [
+            TestItem(t) for t in tests or []
+        ]  # type: List[Union[TestItem, DynamicTestItem]]
+        dynamictestslist = [
+            DynamicTestItem(t, self.name) for t in dynamictests or []
+        ]  # type: List[Union[TestItem, DynamicTestItem]]
+        self.tests = testslist + dynamictestslist
+        self.suites = [SuiteItem(s) for s in suites or []]
+
+    def difference(self, from_items):
+        # type: (List[ExecutionItem]) -> List[ExecutionItem]
+        if self.tests:
+            return [t for t in self.tests if t not in from_items]
+        if self.suites:
+            return [s for s in self.suites if s not in from_items]
+        return []
+
+    def contains(self, other):
+        # type: (ExecutionItem) -> bool
+        if self == other:
+            return True
+        return other.name.startswith(self.name + ".")
+
+    def __eq__(self, other):
+        if not isinstance(other, SuiteItem):
+            return False
+        if self.name == other.name:
+            return True
+        if other.name.endswith('.'+self.name):
+            return True
+        if self.name.endswith('.'+other.name):
+            return True
+        return False
+
+    def __hash__(self):
+        return RunnableItem.__hash__(self)
+
+    def tags(self):
+        # TODO Make this happen
+        return []
+
+
+class TestItem(RunnableItem):
+
+    type = "test"
+
+    def __init__(self, name):
+        # type: (str) -> None
+        self.set_name_and_depends(name)
+
+    if ROBOT_VERSION >= "3.1":
+
+        def modify_options_for_executor(self, options):
+            if "rerunfailed" in options:
+                del options["rerunfailed"]
+            name = self.name
+            for char in ["[", "?", "*"]:
+                name = name.replace(char, "[" + char + "]")
+            options[self.type] = name
+
+    else:
+
+        def modify_options_for_executor(self, options):
+            if "rerunfailed" in options:
+                del options["rerunfailed"]
+
+    def difference(self, from_items):
+        # type: (List[ExecutionItem]) -> List[ExecutionItem]
+        return []
+
+    def contains(self, other):
+        # type: (ExecutionItem) -> bool
+        return self == other
+
+    def tags(self):
+        # TODO Make this happen
+        return []
+
+
+class DynamicSuiteItem(SuiteItem):
+    type = "dynamicsuite"
+
+    def __init__(self, name, variables):
+        SuiteItem.__init__(self, name)
+        self._variables = variables
+
+    def modify_options_for_executor(self, options):
+        variables = options.get("variable", [])[:]
+        variables.extend(self._variables)
+        options["variable"] = variables
+        options["suite"] = self.name
+
+
+class DynamicTestItem(ExecutionItem):
+
+    type = "dynamictest"
+
+    def __init__(self, name, suite):
+        # type: (str, str) -> None
+        self.name = name.encode("utf-8") if PY2 and is_unicode(name) else name
+        self.suite = suite  # type:str
+
+    def line(self):
+        return "DYNAMICTEST %s :: %s" % (self.suite, self.name)
+
+    def modify_options_for_executor(self, options):
+        options["suite"] = self.suite
+        variables = options.get("variable", [])[:]
+        variables.append("DYNAMICTEST:" + self.name)
+        options["variable"] = variables
+
+    def difference(self, from_items):
+        return []
+
+    def contains(self, other):
+        return self == other
+
+    def tags(self):
+        # TODO Make this happen
+        return []
+
+
+class WaitItem(ExecutionItem):
+
+    type = "wait"
+    isWait = True
+
+    def __init__(self):
+        self.name = "#WAIT"
+
+    def line(self):
+        return self.name
+
+
+class GroupStartItem(ExecutionItem):
+
+    type = "group"
+
+    def __init__(self):
+        self.name = "#START"
+
+    def line(self):
+        return "{"
+
+
+class GroupEndItem(ExecutionItem):
+
+    type = "group"
+
+    def __init__(self):
+        self.name = "#END"
+
+    def line(self):
+        return "}"
+
+
+class IncludeItem(ExecutionItem):
+
+    type = "include"
+
+    def __init__(self, tag):
+        self.name = tag
+
+    def line(self):
+        return "--include " + self.name
+
+    def contains(self, other):
+        return self.name in other.tags()
+
+    def tags(self):
+        return [self.name]
+
+
+class SuiteItems(ExecutionItem):
+
+    type = "suite"
+
+    def __init__(self, suites):
+        self.suites = suites
+        self.name = " ".join([suite.name for suite in suites])
+
+    def modify_options_for_executor(self, options):
+        options["suite"] = [suite.name for suite in self.suites]