Merge pull request #13 from frizzby/async_requests

Async requests and log attachements

Author: Alexander.Iljushkin

README.rst

@@ -60,9 +60,10 @@ logging handler privided by plugin like bellow:
 .. code-block:: python
 
     import logging
-    # Import Report Portal handler to the test module.
-    from pytest_reportportal import RPlogHandler
+    # Import Report Portal logger and handler to the test module.
+    from pytest_reportportal import RPLogger, RPLogHandler
     # Setting up a logging.
+    logging.setLoggerClass(RPLogger)
     logger = logging.getLogger(__name__)
     logger.setLevel(logging.DEBUG)
     # Create handler for Report Portal.
@@ -79,6 +80,19 @@ logging handler privided by plugin like bellow:
         x = "this"
         logger.info("x is: %s", x)
         assert 'h' in x
+
+        # Message with an attachment.
+        import subprocess
+        free_memory = subprocess.check_output("free -h".split())
+        logger.info(
+            "Case1. Memory consumption",
+            attachment={
+                "name": "free_memory.txt",
+                "data": free_memory,
+                "mime": "application/octet-stream",
+            },
+        )
+
         # This debug message will not be sent to the Report Portal.
         logger.debug("Case1. Debug message")
 
@@ -98,4 +112,4 @@ Copyright Notice
 
 Licensed under the GPLv3_ license (see the LICENSE file).
 
-.. _GPLv3:  https://www.gnu.org/licenses/quick-guide-gplv3.html
+.. _GPLv3:  https://www.gnu.org/licenses/quick-guide-gplv3.html

pytest_reportportal/__init__.py

@@ -1,9 +1,42 @@
+import sys
 import logging
 
 from .service import PyTestService
 
 
-class RPlogHandler(logging.Handler):
+class RPLogger(logging.getLoggerClass()):
+
+    def __init__(self, name, level=0):
+        super(RPLogger, self).__init__(name, level=level)
+
+    def _log(self, level, msg, args, exc_info=None, extra=None,
+             attachment=None):
+        """
+        Low-level logging routine which creates a LogRecord and then calls
+        all the handlers of this logger to handle the record.
+        """
+        if logging._srcfile:
+            # IronPython doesn't track Python frames, so findCaller raises an
+            # exception on some versions of IronPython. We trap it here so that
+            # IronPython can use logging.
+            try:
+                fn, lno, func = self.findCaller()
+            except ValueError:
+                fn, lno, func = "(unknown file)", 0, "(unknown function)"
+        else:
+            fn, lno, func = "(unknown file)", 0, "(unknown function)"
+
+        if exc_info and not isinstance(exc_info, tuple):
+            exc_info = sys.exc_info()
+
+        record = self.makeRecord(
+            self.name, level, fn, lno, msg, args, exc_info, func, extra
+        )
+        record.attachment = attachment
+        self.handle(record)
+
+
+class RPLogHandler(logging.Handler):
 
     # Map loglevel codes from `logging` module to ReportPortal text names:
     _loglevel_map = {
@@ -17,7 +50,7 @@ class RPlogHandler(logging.Handler):
     _sorted_levelnos = sorted(_loglevel_map.keys(), reverse=True)
 
     def __init__(self, level=logging.NOTSET):
-        super(RPlogHandler, self).__init__(level)
+        super(RPLogHandler, self).__init__(level)
 
     def emit(self, record):
         try:
@@ -31,4 +64,8 @@ def emit(self, record):
             if level <= record.levelno:
                 break
 
-        return PyTestService.post_log(msg, loglevel=self._loglevel_map[level])
+        return PyTestService.post_log(
+            msg,
+            loglevel=self._loglevel_map[level],
+            attachment=record.__dict__.get("attachment", None),
+        )

pytest_reportportal/plugin.py

@@ -23,7 +23,10 @@ def pytest_runtest_makereport(self, item, call):
         report = (yield).get_result()
 
         if report.longrepr:
-            PyTestService.post_log(cgi.escape(report.longreprtext), loglevel='ERROR')
+            PyTestService.post_log(
+                cgi.escape(report.longreprtext),
+                loglevel='ERROR',
+            )
 
         if report.when == "setup":
 
@@ -91,6 +94,10 @@ def pytest_configure(config):
 
 
 def pytest_unconfigure(config):
+    rp_launch = config.getoption("rp_launch")
+    if rp_launch:
+        PyTestService.terminate_service()
+
     if hasattr(config, "_reporter"):
         reporter = config._reporter
         del config._reporter

pytest_reportportal/service.py

@@ -1,9 +1,15 @@
 import logging
+import traceback
 from time import time
+
 from six import with_metaclass
-from reportportal_client import (
-    ReportPortalService, FinishExecutionRQ, StartLaunchRQ, StartTestItemRQ,
-    FinishTestItemRQ, SaveLogRQ)
+
+from reportportal_client import ReportPortalServiceAsync
+
+
+def async_error_handler(exc_info):
+    exc, msg, tb = exc_info
+    traceback.print_exception(exc, msg, tb)
 
 
 def timestamp():
@@ -26,125 +32,99 @@ class PyTestServiceClass(with_metaclass(Singleton, object)):
 
     def __init__(self):
         self.RP = None
-        self.TEST_ITEM_STACK = []
-        self.launch_id = None
 
     def init_service(self, endpoint, project, uuid):
-
         if self.RP is None:
             logging.debug(
                 msg="ReportPortal - Init service: "
                     "endpoint={0}, project={1}, uuid={2}".
                     format(endpoint, project, uuid))
-            self.RP = ReportPortalService(
+            self.RP = ReportPortalServiceAsync(
                 endpoint=endpoint,
                 project=project,
-                token=uuid)
+                token=uuid,
+                error_handler=async_error_handler)
         else:
             logging.debug("The pytest is already initialized")
         return self.RP
 
+    def terminate_service(self):
+        if self.RP is not None:
+            self.RP.terminate()
+
     def start_launch(
-            self, launch_name=None, mode=None, tags=None, launch=None):
+            self, launch_name, mode=None, tags=None):
         # In next versions launch object(suite, testcase)
         # could be set as parameter
-        sl_pt = StartLaunchRQ(
-            name=launch_name,
-            start_time=timestamp(),
-            description='Pytest Launch',
-            mode=mode,
-            tags=tags)
-        logging.debug(msg="ReportPortal - Start launch: "
-                          "request_body={0}".format(sl_pt.data))
-        req_data = self.RP.start_launch(sl_pt)
-        logging.debug(msg="ReportPortal - Launch started: "
-                          "response_body={0}".format(req_data.raw))
-        self.launch_id = req_data.id
-
-        self.TEST_ITEM_STACK.append((None, "SUITE"))
-        logging.debug(
-            msg="ReportPortal - Stack: {0}".
-                format(self.TEST_ITEM_STACK))
+        sl_pt = {
+            "name": launch_name,
+            "start_time": timestamp(),
+            "description": 'Pytest Launch',
+            "mode": mode,
+            "tags": tags
+        }
+        logging.debug("ReportPortal - Start launch: "
+                      "request_body=%s", sl_pt)
+        req_data = self.RP.start_launch(**sl_pt)
+        logging.debug("ReportPortal - Launch started: "
+                      "response_body=%s", req_data)
 
     def start_pytest_item(self, test_item=None):
         try:
             # for common items
             item_description = test_item.function.__doc__
         except AttributeError:
-            # doctest  has no `function` attribute
+            # doctest has no `function` attribute
             item_description = test_item.reportinfo()[2]
-        start_rq = StartTestItemRQ(
-            name=test_item.name,
-            description=item_description,
-            tags=['PyTest Item Tag'],
-            start_time=timestamp(),
-            launch_id=self.launch_id,
-            type="TEST")
-
-        parent_item_id = self._get_top_id_from_stack()
+        start_rq = {
+            "name": test_item.name,
+            "description": item_description,
+            "tags": ['PyTest Item Tag'],
+            "start_time": timestamp(),
+            "item_type": "TEST"
+        }
 
         logging.debug(
-            msg="ReportPortal - Start TestItem: "
-            "request_body={0}, parent_item={1}".format(
-                start_rq.data, parent_item_id))
+            "ReportPortal - Start TestItem: "
+            "request_body=%s", start_rq)
 
-        req_data = self.RP.start_test_item(
-            parent_item_id=parent_item_id, start_test_item_rq=start_rq)
-
-        self.TEST_ITEM_STACK.append((req_data.id, "TEST"))
-        logging.debug(
-            msg="ReportPortal - Stack: {0}".
-                format(self.TEST_ITEM_STACK))
+        self.RP.start_test_item(**start_rq)
 
     def finish_pytest_item(self, status, issue=None):
-        fta_rq = FinishTestItemRQ(end_time=timestamp(),
-                                  status=status,
-                                  issue=issue)
+        fta_rq = {
+            "end_time": timestamp(),
+            "status": status,
+            "issue": issue
+        }
 
-        test_item_id = self._get_top_id_from_stack()
         logging.debug(
-            msg="ReportPortal - Finish TetsItem:"
-                " request_body={0}, test_id={1}".
-                format(fta_rq.data, test_item_id))
-        self.RP.finish_test_item(
-            item_id=test_item_id,
-            finish_test_item_rq=fta_rq)
-        self.TEST_ITEM_STACK.pop()
-        logging.debug(
-            msg="ReportPortal - Stack: {0}".
-                format(self.TEST_ITEM_STACK))
+            "ReportPortal - Finish TestItem:"
+            " request_body=%s", fta_rq)
+        self.RP.finish_test_item(**fta_rq)
 
     def finish_launch(self, launch=None, status="rp_launch"):
         # TO finish launch session str parameter is needed
-        fl_rq = FinishExecutionRQ(
-            end_time=timestamp(),
-            status=status)
-        launch_id = self.launch_id
-        logging.debug(msg="ReportPortal - Finish launch: "
-                          "request_body={0}, launch_id={1}".format(fl_rq.data,
-                                                                   launch_id))
-        self.RP.finish_launch(launch_id, fl_rq)
-        self.TEST_ITEM_STACK.pop()
-        logging.debug(
-            msg="ReportPortal - Stack: {0}".
-                format(self.TEST_ITEM_STACK))
-
-    def _get_top_id_from_stack(self):
-        try:
-            return self.TEST_ITEM_STACK[-1][0]
-        except IndexError:
-            return None
-
-    def post_log(self, message, loglevel='INFO'):
+        fl_rq = {
+            "end_time": timestamp(),
+            "status": status
+        }
+        logging.debug("ReportPortal - Finish launch: "
+                      "request_body=%s", fl_rq)
+        self.RP.finish_launch(**fl_rq)
+
+    def post_log(self, message, loglevel='INFO', attachment=None):
         if loglevel not in self._loglevels:
-            logging.warning('Incorrect loglevel = {}. Force set to INFO. Avaliable levels: '
-                            '{}.'.format(loglevel, self._loglevels))
+            logging.warning('Incorrect loglevel = %s. Force set to INFO. '
+                            'Avaliable levels: %s.', loglevel, self._loglevels)
             loglevel = 'INFO'
 
-        sl_rq = SaveLogRQ(item_id=self._get_top_id_from_stack(),
-                          time=timestamp(), message=message,
-                          level=loglevel)
-        self.RP.log(sl_rq)
+        sl_rq = {
+            "time": timestamp(),
+            "message": message,
+            "level": loglevel,
+            "attachment": attachment,
+        }
+        self.RP.log(**sl_rq)
 
 
 PyTestService = PyTestServiceClass()