Change in core Thread to Process

Now step correct showing in Thread

Author: Glazov Nikolay

.gitignore

@@ -8,4 +8,5 @@
 *.egg-info
 
 */build
-*/dist
+*/dist
+.eggs

allure-pytest/src/listener.py

@@ -5,7 +5,7 @@
 from allure_commons.utils import uuid4
 from allure_commons.utils import represent
 from allure_commons.utils import platform_label
-from allure_commons.utils import host_tag, thread_tag
+from allure_commons.utils import host_tag, thread_tag, thread_tag_detail
 from allure_commons.reporter import AllureReporter
 from allure_commons.model2 import TestStepResult, TestResult, TestBeforeResult, TestAfterResult
 from allure_commons.model2 import TestResultContainer
@@ -22,7 +22,6 @@
 from allure_pytest.utils import get_outcome_status, get_outcome_status_details
 from allure_pytest.utils import get_pytest_report_status
 from allure_commons.utils import md5
-import threading
 
 
 class AllureListener(object):
@@ -37,13 +36,8 @@ def __init__(self, config):
     @allure_commons.hookimpl
     def start_step(self, uuid, title, params):
         parameters = [Parameter(name=name, value=value) for name, value in params.items()]
-        step = TestStepResult(name=title, start=now(), parameters=parameters, thrd=threading.current_thread().name)
-        if thread_tag() != self._thread:
-            self.allure_logger.start_step(self.allure_logger.last_with_thread(), uuid, step)
-        else:
-            self.allure_logger.start_step(None, uuid, step)
-        # step = TestStepResult(name=title, start=now(), parameters=parameters)
-        # self.allure_logger.start_step(None, uuid, step)
+        step = TestStepResult(name=title, start=now(), parameters=parameters, thrd=thread_tag_detail())
+        self.allure_logger.start_step(None, uuid, step)
 
     @allure_commons.hookimpl
     def stop_step(self, uuid, exc_type, exc_val, exc_tb):
@@ -54,7 +48,7 @@ def stop_step(self, uuid, exc_type, exc_val, exc_tb):
 
     @allure_commons.hookimpl
     def start_fixture(self, parent_uuid, uuid, name):
-        after_fixture = TestAfterResult(name=name, start=now())
+        after_fixture = TestAfterResult(name=name, start=now(), thrd=thread_tag_detail())
         self.allure_logger.start_after_fixture(parent_uuid, uuid, after_fixture)
 
     @allure_commons.hookimpl
@@ -67,15 +61,15 @@ def stop_fixture(self, parent_uuid, uuid, name, exc_type, exc_val, exc_tb):
     @pytest.hookimpl(hookwrapper=True, tryfirst=True)
     def pytest_runtest_protocol(self, item, nextitem):
         uuid = self._cache.push(item.nodeid)
-        test_result = TestResult(name=item.name, uuid=uuid, start=now(), stop=now())
+        test_result = TestResult(name=item.name, uuid=uuid, start=now(), stop=now(), thrd=thread_tag_detail())
         self.allure_logger.schedule_test(uuid, test_result)
         yield
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_setup(self, item):
         if not self._cache.get(item.nodeid):
             uuid = self._cache.push(item.nodeid)
-            test_result = TestResult(name=item.name, uuid=uuid, start=now(), stop=now())
+            test_result = TestResult(name=item.name, uuid=uuid, start=now(), stop=now(), thrd=thread_tag_detail())
             self.allure_logger.schedule_test(uuid, test_result)
 
         yield
@@ -86,7 +80,7 @@ def pytest_runtest_setup(self, item):
             group_uuid = self._cache.get(fixturedef)
             if not group_uuid:
                 group_uuid = self._cache.push(fixturedef)
-                group = TestResultContainer(uuid=group_uuid)
+                group = TestResultContainer(uuid=group_uuid, thrd=thread_tag_detail())
                 self.allure_logger.start_group(group_uuid, group)
             self.allure_logger.update_group(group_uuid, children=uuid)
         params = item.callspec.params if hasattr(item, 'callspec') else {}
@@ -134,13 +128,13 @@ def pytest_fixture_setup(self, fixturedef, request):
 
         if not container_uuid:
             container_uuid = self._cache.push(fixturedef)
-            container = TestResultContainer(uuid=container_uuid)
+            container = TestResultContainer(uuid=container_uuid, thrd=thread_tag_detail())
             self.allure_logger.start_group(container_uuid, container)
 
         self.allure_logger.update_group(container_uuid, start=now())
 
         before_fixture_uuid = uuid4()
-        before_fixture = TestBeforeResult(name=fixture_name, start=now())
+        before_fixture = TestBeforeResult(name=fixture_name, start=now(), thrd=thread_tag_detail())
         self.allure_logger.start_before_fixture(container_uuid, before_fixture_uuid, before_fixture)
 
         outcome = yield
@@ -247,12 +241,6 @@ def add_description_html(self, test_description_html):
         if test_result:
             test_result.descriptionHtml = test_description_html
 
-    @allure_commons.hookimpl
-    def add_thrd(self, test_description_html):
-        test_result = self.allure_logger.get_test(None)
-        if test_result:
-            test_result.descriptionHtml = test_description_html
-
     @allure_commons.hookimpl
     def add_link(self, url, link_type, name):
         test_result = self.allure_logger.get_test(None)

allure-python-commons/src/_allure.py

@@ -1,5 +1,6 @@
 from functools import wraps
 from typing import Any, Callable, TypeVar
+import threading
 
 from allure_commons._core import plugin_manager
 from allure_commons.types import LabelType, LinkType

allure-python-commons/src/_core.py

@@ -6,7 +6,7 @@
 
 
 class MetaPluginManager(type):
-    _storage = threading.local()
+    # _storage = threading.local()
     _storage = multiprocessing.Process
 
     @staticmethod

allure-python-commons/src/lifecycle.py

@@ -11,6 +11,7 @@
 from allure_commons.utils import uuid4
 from allure_commons.utils import now
 from allure_commons.types import AttachmentType
+import threading
 
 
 class AllureLifecycle(object):
@@ -52,7 +53,8 @@ def write_test_case(self, uuid=None):
     @contextmanager
     def start_step(self, parent_uuid=None, uuid=None):
         parent = self._get_item(uuid=parent_uuid, item_type=ExecutableItem)
-        step = TestStepResult()
+        # step = TestStepResult()
+        step = TestStepResult(thrd=threading.current_thread().name)
         step.start = now()
         parent.steps.append(step)
         self._items[uuid or uuid4()] = step

allure-python-commons/src/logger.py

@@ -13,13 +13,17 @@
 
 
 def delete_step_thrd(data):
-    if "steps" in data.keys():
-        for step in data['steps']:
-            step.pop("thrd", None)
-            step = delete_step_thrd(step)
+    if isinstance(data, list):
+        for field in data:
+            field = delete_step_thrd(field)
+    elif isinstance(data, dict):
+        for field in data.keys():
+            if field == 'thrd':
+                data.pop('thrd')
+                break
+            field = delete_step_thrd(data[field])
     return data
 
-
 class AllureFileLogger(object):
 
     def __init__(self, report_dir, clean=False):

allure-python-commons/src/model2.py

@@ -23,6 +23,7 @@ class TestResultContainer(object):
     links = attrib(default=Factory(list))
     start = attrib(default=None)
     stop = attrib(default=None)
+    thrd = attrib(default=None)
 
 
 @attrs

allure-python-commons/src/reporter.py

@@ -1,6 +1,16 @@
 from collections import OrderedDict
-import os
-import shutil
+# import os
+# import shutil
+# import threading
+# from termcolor import cprint
+# from pygments import highlight
+# from pygments.lexers import PythonLexer
+# from pygments.formatters import Terminal256Formatter
+# from pprint import pformat
+from allure_commons.utils import thread_tag, thread_tag_detail
+
+# def pprint_color(obj):
+#     print(highlight(pformat(obj), PythonLexer(), Terminal256Formatter()))
 
 from allure_commons.types import AttachmentType
 from allure_commons.model2 import ExecutableItem
@@ -14,6 +24,7 @@ class AllureReporter(object):
     def __init__(self):
         self._items = OrderedDict()
         self._orphan_items = []
+        self._thread = thread_tag_detail()
 
     def _update_item(self, uuid, **kwargs):
         item = self._items[uuid] if uuid else self._items[next(reversed(self._items))]
@@ -25,16 +36,20 @@ def _update_item(self, uuid, **kwargs):
                 setattr(item, name, value)
 
     def _last_executable(self):
-        for _uuid in reversed(self._items):
+        copy_items = self._items.copy()
+        for _uuid in reversed(copy_items):
+            if hasattr(self._items[_uuid], "thrd") and self._items[_uuid].thrd != thread_tag_detail():
+                continue
             if isinstance(self._items[_uuid], ExecutableItem):
                 return _uuid
-
-    def last_with_thread(self):
-        for _uuid in reversed(self._items):
-            if self._items[_uuid].thrd != "MainThread":
+        for _uuid in reversed(copy_items):
+            if hasattr(self._items[_uuid], "thrd") and self._items[_uuid].thrd != self._thread:
                 continue
             if isinstance(self._items[_uuid], ExecutableItem):
                 return _uuid
+        for _uuid in reversed(copy_items):
+            if isinstance(self._items[_uuid], ExecutableItem):
+                return _uuid
 
     def get_item(self, uuid):
         return self._items.get(uuid)
@@ -120,8 +135,6 @@ def _attach(self, uuid, name=None, attachment_type=None, extension=None):
     def attach_file(self, uuid, source, name=None, attachment_type=None, extension=None):
         file_name = self._attach(uuid, name=name, attachment_type=attachment_type, extension=extension)
         plugin_manager.hook.report_attached_file(source=source, file_name=file_name)
-        destination = os.path.join('./allure-results', file_name)
-        shutil.copy2(source, destination)
 
     def attach_data(self, uuid, body, name=None, attachment_type=None, extension=None):
         file_name = self._attach(uuid, name=name, attachment_type=attachment_type, extension=extension)

allure-python-commons/src/utils.py

@@ -96,6 +96,9 @@ def thread_tag():
     return '{0}-{1}'.format(os.getpid(), threading.current_thread().name)
 
 
+def thread_tag_detail():
+    return '{0}-{1}'.format(threading.get_native_id(), threading.current_thread().name)
+
 def host_tag():
     return socket.gethostname()