testit-adapter-pytest 4.2.8__py3-none-any.whl

testit_adapter_pytest/fixture_context.py

@@ -0,0 +1,33 @@
+from uuid import uuid4
+
+from testit_python_commons.services import Utils, TmsPluginManager
+
+
+class FixtureContext:
+    def __init__(self, fixture_function, parent_uuid=None, name=None):
+        self._fixture_function = fixture_function
+        self._parent_uuid = parent_uuid
+        self.__title = name if name else fixture_function.__name__
+        self.__description = fixture_function.__doc__
+        self._uuid = uuid4()
+        self.parameters = None
+
+    def __call__(self, *args, **kwargs):
+        self.parameters = Utils.get_function_parameters(self._fixture_function, *args, **kwargs)
+
+        with self:
+            return self._fixture_function(*args, **kwargs)
+
+    def __enter__(self):
+        TmsPluginManager.get_plugin_manager().hook.start_fixture(
+                                        parent_uuid=self._parent_uuid,
+                                        uuid=self._uuid,
+                                        title=self.__title,
+                                        parameters=self.parameters)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        TmsPluginManager.get_plugin_manager().hook.stop_fixture(
+                                        uuid=self._uuid,
+                                        exc_type=exc_type,
+                                        exc_val=exc_val,
+                                        exc_tb=exc_tb)

testit_adapter_pytest/listener.py

@@ -0,0 +1,388 @@
+import pickle
+from importlib.metadata import metadata
+from uuid import uuid4
+
+from packaging import version
+
+import pytest
+
+import testit_python_commons.services as adapter
+from testit_python_commons.models.outcome_type import OutcomeType
+from testit_python_commons.models.status_type import StatusType
+from testit_python_commons.models.fixture import FixtureResult, FixturesContainer
+from testit_python_commons.services import AdapterManager, StepManager, FixtureManager
+from testit_python_commons.services.logger import adapter_logger
+
+import testit_adapter_pytest.utils as utils
+from testit_adapter_pytest.fixture_context import FixtureContext
+
+
+STATUS_TYPE = {
+    'passed': StatusType.SUCCEEDED,
+    'failed': StatusType.FAILED,
+    'xfailed': StatusType.FAILED,
+    'skipped': StatusType.INCOMPLETE,
+}
+STEP_STATUS = {
+    'passed': OutcomeType.PASSED,
+    'failed': OutcomeType.FAILED,
+    'skipped': OutcomeType.SKIPPED,
+}
+
+
+class ItemCache:
+    def __init__(self):
+        self._items = dict()
+
+    def get(self, _id):
+        return self._items.get(id(_id))
+
+    def push(self, _id):
+        return self._items.setdefault(id(_id), uuid4())
+
+    def pop(self, _id):
+        return self._items.pop(id(_id), None)
+
+
+class SeparationOfTests:
+    def __init__(self):
+        self._selected_items = []
+        self._deselected_items = []
+
+    def add_item_to_selected_items(self, item):
+        self._selected_items.append(item)
+
+        return self
+
+    def add_item_to_deselected_items(self, item):
+        self._deselected_items.append(item)
+
+        return self
+
+    def get_selected_items(self) -> list:
+        return self._selected_items
+
+    def get_deselected_items(self) -> list:
+        return self._deselected_items
+
+
+class TmsListener(object):
+    __executable_test = None
+    __pytest_info = None
+    __pytest_check_info = None
+    __failures = None
+
+    def __init__(self, adapter_manager: AdapterManager, step_manager: StepManager, fixture_manager: FixtureManager):
+        self.__adapter_manager = adapter_manager
+        self.__step_manager = step_manager
+        self.__fixture_manager = fixture_manager
+        self._cache = ItemCache()
+
+    @pytest.hookimpl
+    def pytest_configure(self, config):
+        self.__pytest_info = metadata("pytest")
+
+        if hasattr(config, "workerinput"):
+            config.test_run_id = pickle.loads(config.workerinput["test_run_id"])
+        elif not hasattr(config, "test_run_id"):
+            config.test_run_id = self.__adapter_manager.get_test_run_id()
+
+        self.__adapter_manager.set_test_run_id(config.test_run_id)
+
+    @pytest.hookimpl
+    def pytest_configure_node(self, node):
+        if hasattr(node.config, "test_run_id"):
+            node.workerinput["test_run_id"] = pickle.dumps(node.config.test_run_id)
+
+    @adapter.hookimpl
+    def get_pytest_check_outcome(self):
+        if self.__pytest_check_info:
+            if version.parse(self.__pytest_check_info.version) < version.parse("1.1.0"):
+                from pytest_check import check_methods as logs
+            else:
+                from pytest_check import check_log as logs
+
+            failures = logs.get_failures()
+
+            if failures and self.__failures != failures:
+                self.__failures = failures[:]
+                return 'Failed'
+        return 'Passed'
+
+    @pytest.hookimpl
+    def pytest_collection_modifyitems(self, config, items):
+        self.__add_pytest_check_info(config.pluginmanager.list_plugin_distinfo())
+
+        resolved_autotests = self.__adapter_manager.get_autotests_for_launch()
+        separation_of_tests = self.__get_separation_of_tests(items, resolved_autotests)
+
+        if resolved_autotests:
+            if not separation_of_tests.get_selected_items():
+                raise Exception('The specified tests were not found!')
+
+            config.hook.pytest_deselected(items=separation_of_tests.get_deselected_items())
+            items[:] = separation_of_tests.get_selected_items()
+
+    def __add_pytest_check_info(self, plugin_info):
+        for plugin, dist in plugin_info:
+            if 'pytest-check' == dist.project_name:
+                self.__pytest_check_info = dist
+                return
+
+    @classmethod
+    @adapter_logger
+    def __get_separation_of_tests(cls, items, resolved_autotests) -> SeparationOfTests:
+        separation_of_tests = SeparationOfTests()
+        index = 0
+
+        for item in items:
+            if hasattr(item.function, 'test_external_id'):
+                item.test_external_id = item.function.test_external_id
+            else:
+                item.test_external_id = utils.get_hash(item.parent.nodeid + item.function.__name__)
+
+            if item.own_markers:
+                for mark in item.own_markers:
+                    if mark.name == 'parametrize':
+                        if not hasattr(item, 'array_parametrize_mark_id'):
+                            item.array_parametrize_mark_id = []
+                        item.array_parametrize_mark_id.append(
+                            item.own_markers.index(mark))
+
+            params = utils.get_all_parameters(item)
+            item.test_external_id = utils.collect_parameters_in_string_attribute(
+                item.test_external_id,
+                params)
+
+            item.index = index
+            item_id = items.index(item)
+            index = index + 1 if len(items) > item_id + 1 and items[item_id + 1].originalname == item.originalname \
+                else 0
+
+            if cls.__check_external_id_in_resolved_autotests(item.test_external_id, resolved_autotests):
+                separation_of_tests.add_item_to_selected_items(item)
+            else:
+                separation_of_tests.add_item_to_deselected_items(item)
+
+        return separation_of_tests
+
+    @staticmethod
+    @adapter_logger
+    def __check_external_id_in_resolved_autotests(external_id: str, resolved_autotests: dict) -> bool:
+        return resolved_autotests is not None and external_id in resolved_autotests
+
+    @pytest.hookimpl(tryfirst=True)
+    def pytest_runtest_protocol(self, item):
+        self.__executable_test = utils.form_test(item)
+        self.__adapter_manager.on_running_started()
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_setup(self, item):
+        if not self.__executable_test:
+            return
+
+        yield
+
+        self._update_fixtures_external_ids(item)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_fixture_setup(self, fixturedef):
+        fixture_name = getattr(fixturedef.func, 'test_displayname', fixturedef.argname)
+
+        container_uuid = self._cache.get(fixturedef)
+
+        if not container_uuid:
+            container_uuid = self._cache.push(fixturedef)
+            container = FixturesContainer(uuid=container_uuid)
+            self.__fixture_manager.start_group(container_uuid, container)
+
+        self.__fixture_manager.update_group(container_uuid)
+
+        before_fixture_uuid = uuid4()
+        before_fixture = FixtureResult(title=fixture_name)
+
+        self.__fixture_manager.start_before_fixture(container_uuid, before_fixture_uuid, before_fixture)
+
+        outcome = yield
+
+        results_steps_data = self.__step_manager.get_steps_tree()
+
+        self.__fixture_manager.stop_before_fixture(before_fixture_uuid,
+                                                   outcome=utils.get_outcome_status(outcome), steps=results_steps_data)
+
+        finalizers = getattr(fixturedef, '_finalizers', [])
+        for index, finalizer in enumerate(finalizers):
+            finalizer_name = getattr(finalizer, "__name__", index)
+            name = f'{fixture_name}::{finalizer_name}'
+            finalizers[index] = FixtureContext(finalizer, parent_uuid=container_uuid, name=name)
+
+    @pytest.hookimpl(hookwrapper=True, trylast=True)
+    def pytest_runtest_call(self):
+        yield
+
+        if not self.__executable_test:
+            return
+
+        test_results_steps = self.__step_manager.get_steps_tree()
+        self.__executable_test.step_results = test_results_steps
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_fixture_post_finalizer(self, fixturedef):
+        if not self.__executable_test:
+            return
+
+        yield
+
+        if hasattr(fixturedef, 'cached_result') and self._cache.get(fixturedef):
+            group_uuid = self._cache.pop(fixturedef)
+            self.__fixture_manager.stop_group(group_uuid)
+
+    @pytest.hookimpl
+    def pytest_runtest_logreport(self, report):
+        if self.__executable_test:
+            if report.when == 'setup':
+                self.__executable_test.outcome = report.outcome
+                self.__executable_test.status_type = STATUS_TYPE.get(report.outcome, None)
+                if report.longreprtext:
+                    self.__executable_test.message = report.longreprtext
+
+            if report.when == 'call':
+                self.__executable_test.outcome = report.outcome
+                self.__executable_test.status_type = STATUS_TYPE.get(report.outcome, None)
+
+            if report.failed or report.outcome == 'rerun':
+                self.__executable_test.outcome = 'failed'
+                self.__executable_test.status_type = STATUS_TYPE.get('failed', None)
+
+                if report.longreprtext:
+                    self.__executable_test.traces = report.longreprtext
+
+            if hasattr(report, 'wasxfail') and not report.passed:
+                self.__executable_test.outcome = 'xfailed'
+                self.__executable_test.status_type = STATUS_TYPE.get('xfailed', None)
+
+                if report.longreprtext:
+                    self.__executable_test.traces = report.longreprtext
+
+            self.__executable_test.duration += report.duration * 1000
+
+    @pytest.hookimpl
+    def pytest_runtest_logfinish(self):
+        if not self.__executable_test:
+            return
+
+        self.__adapter_manager.write_test(
+            utils.convert_executable_test_to_test_result_model(self.__executable_test))
+
+    @pytest.hookimpl
+    def pytest_sessionfinish(self, session):
+        self.__adapter_manager.on_block_completed()
+        self.__adapter_manager.write_tests()
+
+    @adapter.hookimpl
+    def add_link(self, link):
+        if self.__executable_test:
+            self.__executable_test.result_links.append(link)
+
+    @adapter.hookimpl
+    def add_message(self, test_message: str):
+        if self.__executable_test:
+            self.__executable_test.message = str(test_message)
+
+    @adapter.hookimpl
+    def add_attachments(self, attach_paths: list or tuple):
+        if self.__executable_test:
+            self.__executable_test.attachments += self.__adapter_manager.load_attachments(attach_paths)
+
+    @adapter.hookimpl
+    def create_attachment(self, body, name: str):
+        if self.__executable_test:
+            self.__executable_test.attachments += self.__adapter_manager.create_attachment(body, name)
+
+    @adapter.hookimpl
+    def add_work_item_id(self, test_work_item_id: str):
+        if self.__executable_test:
+            self.__executable_test.work_item_ids.append(test_work_item_id)
+
+    @adapter.hookimpl
+    def add_display_name(self, test_display_name: str):
+        if self.__executable_test:
+            self.__executable_test.name = test_display_name
+
+    @adapter.hookimpl
+    def add_namespace(self, test_namespace: str):
+        if self.__executable_test:
+            self.__executable_test.namespace = test_namespace
+
+    @adapter.hookimpl
+    def add_classname(self, test_classname: str):
+        if self.__executable_test:
+            self.__executable_test.classname = test_classname
+
+    @adapter.hookimpl
+    def add_external_id(self, test_external_id: str):
+        if self.__executable_test:
+            self.__executable_test.external_id = test_external_id
+
+    @adapter.hookimpl
+    def add_title(self, test_title: str):
+        if self.__executable_test:
+            self.__executable_test.title = str(test_title)
+
+    @adapter.hookimpl
+    def add_description(self, test_description: str):
+        if self.__executable_test:
+            self.__executable_test.description = test_description
+
+    @adapter.hookimpl
+    def add_label(self, test_label: str):
+        if self.__executable_test:
+            self.__executable_test.labels.append({'name': test_label})
+
+    @adapter.hookimpl
+    def add_parameter(self, name: str, value: str):
+        if self.__executable_test:
+            self.__executable_test.parameters[name] = value
+
+    @adapter.hookimpl
+    def start_fixture(self, parent_uuid, uuid, title):
+        after_fixture = FixtureResult(title=title)
+        self.__fixture_manager.start_after_fixture(parent_uuid, uuid, after_fixture)
+
+    @adapter.hookimpl
+    def stop_fixture(self, uuid, exc_type, exc_val, exc_tb):
+        results_steps_data = self.__step_manager.get_steps_tree()
+
+        self.__fixture_manager.stop_after_fixture(uuid,
+                                                  outcome=utils.get_status(exc_val),
+                                                  steps=results_steps_data,
+                                                  message=utils.get_message(exc_type, exc_val),
+                                                  stacktrace=utils.get_traceback(exc_tb))
+
+    def _update_fixtures_external_ids(self, item):
+        for fixturedef in self._test_fixtures(item):
+            group_uuid = self._cache.get(fixturedef)
+            if group_uuid:
+                group = self.__fixture_manager.get_item(group_uuid)
+            else:
+                group_uuid = self._cache.push(fixturedef)
+                group = FixturesContainer(uuid=group_uuid)
+                self.__fixture_manager.start_group(group_uuid, group)
+            if self.__executable_test.external_id not in group.external_ids:
+                self.__fixture_manager.update_group(group_uuid, external_ids=self.__executable_test.external_id)
+
+    def _test_fixtures(self, item):
+        fixturemanager = item.session._fixturemanager
+        fixturedefs = []
+
+        if hasattr(item, "_request") and hasattr(item._request, "fixturenames"):
+            for name in item._request.fixturenames:
+                if self.__pytest_info and version.parse(self.__pytest_info["version"]) >= version.parse("8.1.0"):
+                    fixturedefs_pytest = fixturemanager.getfixturedefs(name, item)
+                else:
+                    fixturedefs_pytest = fixturemanager.getfixturedefs(name, item.nodeid)
+
+                if fixturedefs_pytest:
+                    fixturedefs.extend(fixturedefs_pytest)
+
+        return fixturedefs

testit_adapter_pytest/models/executable_test.py

@@ -0,0 +1,33 @@
+from attr import attrs, attrib
+from attr import Factory
+
+
+@attrs
+class ExecutableTest:
+    external_id = attrib()
+    name = attrib()
+    steps = attrib(default=Factory(list))
+    step_results = attrib(default=Factory(list))
+    setup_steps = attrib(default=Factory(list))
+    setup_step_results = attrib(default=Factory(list))
+    teardown_steps = attrib(default=Factory(list))
+    teardown_step_results = attrib(default=Factory(list))
+    result_links = attrib(default=Factory(list))
+    duration = attrib(default=None)
+    outcome = attrib(default=None)
+    status_type = attrib(default=None)
+    failure_reason_names = attrib(default=Factory(list))
+    traces = attrib(default=None)
+    attachments = attrib(default=Factory(list))
+    parameters = attrib(default=Factory(dict))
+    properties = attrib(default=Factory(dict))
+    namespace = attrib(default=None)
+    classname = attrib(default=None)
+    title = attrib(default=None)
+    description = attrib(default=None)
+    links = attrib(default=Factory(list))
+    labels = attrib(default=Factory(list))
+    tags = attrib(default=Factory(list))
+    work_item_ids = attrib(default=Factory(list))
+    message = attrib(default=None)
+    node_id = attrib(default=None)

testit_adapter_pytest/plugin.py

@@ -0,0 +1,223 @@
+import re
+import json
+from urllib.parse import urlparse
+import pytest
+
+from testit_adapter_pytest.listener import TmsListener
+from testit_python_commons.services import TmsPluginManager
+
+
+def _adapter_mode_type(value):
+    if value is None:
+        raise ValueError("Adapter mode cannot be None! Valid modes: 0, 1, 2")
+    valid_modes = ['0', '1', '2']
+    if value not in valid_modes:
+        raise ValueError(f"Unknown adapter mode '{value}'! Valid modes: {', '.join(valid_modes)}")
+    return value
+
+
+def _boolean_type(value):
+    if value is None:
+        raise ValueError("Boolean value cannot be None! Must be 'true' or 'false'")
+    valid_values = ['true', 'false']
+    if value.lower() not in valid_values:
+        raise ValueError(f"Invalid value '{value}'! Must be 'true' or 'false'")
+    return value.lower()
+
+
+def _uuid_type(value):
+    if value is None:
+        raise ValueError("UUID cannot be None!")
+    uuid_pattern = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$', re.I)
+    if not uuid_pattern.match(value):
+        raise ValueError(f"Invalid UUID format: '{value}'!")
+    return value
+
+
+def _url_type(value):
+    if value is None:
+        raise ValueError("URL cannot be None!")
+    if not value.startswith(('http://', 'https://')):
+        raise ValueError(f"Invalid URL format: '{value}'!")
+    url = urlparse(value)
+    if not all([url.scheme, url.netloc]):
+        raise ValueError(f"Invalid URL format: '{value}'!")
+    return value
+
+
+def _proxy_type(value):
+    if value is None:
+        raise ValueError("Proxy cannot be None!")
+    try:
+        proxy_dict = json.loads(value)
+        if not isinstance(proxy_dict, dict):
+            raise ValueError(f"Proxy must be a JSON object, got {type(proxy_dict).__name__}")
+        
+        valid_keys = {'http', 'https'}
+        for key in proxy_dict.keys():
+            if key not in valid_keys:
+                raise ValueError(f"Invalid proxy key '{key}'! Must be 'http' or 'https'")
+        
+        for key, url in proxy_dict.items():
+            if not isinstance(url, str):
+                raise ValueError(f"Proxy URL for '{key}' must be string, got {type(url).__name__}")
+            if not url.startswith(('http://', 'https://')):
+                raise ValueError(f"Invalid {key} proxy URL: '{url}'! Must start with http:// or https://")
+            parsed = urlparse(url)
+            if not parsed.netloc:
+                raise ValueError(f"Invalid {key} proxy URL: '{url}'! Missing hostname")
+        
+        return value
+    except json.JSONDecodeError:
+        raise ValueError(f"Invalid JSON format for proxy: '{value}'!")
+    except ValueError as e:
+        raise ValueError(str(e))
+
+def pytest_addoption(parser):
+    parser.getgroup('testit').addoption(
+        '--testit',
+        action='store_true',
+        dest="tms_report",
+        help='Pytest plugin for Test IT'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsUrl',
+        action="store",
+        dest="set_url",
+        type=_url_type,
+        metavar="https://demo.testit.software",
+        help='Set location of the TMS instance'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsPrivateToken',
+        action="store",
+        dest="set_private_token",
+        metavar="T2lKd2pLZGI4WHRhaVZUejNl",
+        help='Set API secret key'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsProjectId',
+        action="store",
+        dest="set_project_id",
+        type=_uuid_type,
+        metavar="15dbb164-c1aa-4cbf-830c-8c01ae14f4fb",
+        help='Set project ID'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsConfigurationId',
+        action="store",
+        dest="set_configuration_id",
+        type=_uuid_type,
+        metavar="d354bdac-75dc-4e3d-84d4-71186c0dddfc",
+        help='Set configuration ID'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsTestRunId',
+        action="store",
+        dest="set_test_run_id",
+        type=_uuid_type,
+        metavar="5236eb3f-7c05-46f9-a609-dc0278896464",
+        help='Set test run ID (optional)'
+    )
+    parser.getgroup('debug').addoption(
+        '--tmsProxy',
+        action="store",
+        dest="set_tms_proxy",
+        type=_proxy_type,
+        metavar='{"http":"http://localhost:8888","https":"http://localhost:8888"}',
+        help='Set proxy for sending requests (optional)'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsTestRunName',
+        action="store",
+        dest="set_test_run_name",
+        metavar="Custom name of test run",
+        help='Set custom name of test run (optional)'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsAdapterMode',
+        action="store",
+        type=_adapter_mode_type,
+        dest="set_adapter_mode",
+        metavar="1",
+        help="""
+        Set adapter mode with test run (optional):
+        0 - with filtering autotests by launch\'s suite in TMS (Default)
+        1 - without filtering autotests by launch\'s suite in TMS
+        2 - create new test run in TMS
+        """
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsConfigFile',
+        action="store",
+        dest="set_config_file",
+        metavar="tmsConfigFile",
+        help='Set custom name of configuration file'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsCertValidation',
+        action="store",
+        dest="set_cert_validation",
+        type=_boolean_type,
+        metavar="false",
+        help='Set certificate validation (true/false)'
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsAutomaticCreationTestCases',
+        action="store",
+        dest="set_automatic_creation_test_cases",
+        type=_boolean_type,
+        metavar="false",
+        help="""
+        Set mode of automatic creation test cases (optional):
+        true - create a test case linked to the created autotest (not to the updated autotest)
+        false - not create a test case (Default)
+        """
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsAutomaticUpdationLinksToTestCases',
+        action="store",
+        dest="set_automatic_updation_links_to_test_cases",
+        type=_boolean_type,
+        metavar="false",
+        help="""
+        Set mode of automatic updation links to test cases (optional):
+        true - update links to test cases
+        false - not update links to test cases (Default)
+        """
+    )
+    parser.getgroup('testit').addoption(
+        '--tmsImportRealtime',
+        action="store",
+        dest="set_import_realtime",
+        type=_boolean_type,
+        metavar="false",
+        help="""
+        Set mode of import type selection when launching autotests (optional):
+        true - the adapter will create/update each autotest in real time (Default)
+        false - the adapter will create/update multiple autotests
+        """
+    )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_load_initial_conftests(early_config, parser, args):
+    ns = getattr(early_config, "known_args_namespace", None)
+    if ns is not None and hasattr(ns, "tms_report"):
+        TmsPluginManager.set_pytest_tms_report(ns.tms_report)
+
+
+def pytest_unconfigure(config):
+    TmsPluginManager.set_pytest_tms_report(None)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_cmdline_main(config):
+    if config.option.tms_report:
+        listener = TmsListener(
+            TmsPluginManager.get_adapter_manager(config.option),
+            TmsPluginManager.get_step_manager(),
+            TmsPluginManager.get_fixture_manager())
+
+        config.pluginmanager.register(listener)
+        TmsPluginManager.get_plugin_manager().register(listener)