WIP: Support for V5 changes in client.

Author: Ivan Ivanou

robotframework_reportportal/listener.py

@@ -7,80 +7,75 @@
 ROBOT_LISTENER_API_VERSION = 2
 
 
-class ParentTypes(object):
-
-    items = []
-
-    @staticmethod
-    def push(item):
-        ParentTypes.items.append(item)
-
-    @staticmethod
-    def pop():
-        return ParentTypes.items.pop()
-
-    @staticmethod
-    def peek():
-        return ParentTypes.items[-1]
-
-    @staticmethod
-    def is_empty():
-        return ParentTypes.items == []
+items = []
 
 
 def start_suite(name, attributes):
     suite = Suite(attributes=attributes)
-    ParentTypes.push("SUITE")
-    if attributes["id"] == "s1":
+    if suite.robot_id == "s1":
         Variables.check_variables()
         RobotService.init_service(Variables.endpoint, Variables.project,
-                                  Variables.uuid, Variables.log_batch_size)
+                                  Variables.uuid)
         suite.doc = Variables.launch_doc
         logging.debug("ReportPortal - Start Launch: {0}".format(attributes))
         RobotService.start_launch(launch_name=Variables.launch_name,
                                   launch=suite)
+        if not suite.suites:
+            attributes['id'] = "s1-s1"
+            start_suite(name, attributes)
+
     else:
         logging.debug("ReportPortal - Start Suite: {0}".format(attributes))
-        RobotService.start_suite(name=name, suite=suite)
+        parent_id = items[-1][0] if items else None
+        item_id = RobotService.start_suite(name=name, suite=suite,
+                                           parent_item_id=parent_id)
+        items.append((item_id, parent_id))
 
 
-def end_suite(name, attributes):
+def end_suite(_, attributes):
     suite = Suite(attributes=attributes)
-    ParentTypes.pop()
-    if attributes["id"] == "s1":
+    if suite.robot_id == "s1":
         logging.debug(msg="ReportPortal - End Launch: {0}".format(attributes))
         RobotService.finish_launch(launch=suite)
         RobotService.terminate_service()
     else:
         logging.debug("ReportPortal - End Suite: {0}".format(attributes))
-        RobotService.finish_suite(suite=suite)
+        RobotService.finish_suite(item_id=items.pop()[0], suite=suite)
 
 
 def start_test(name, attributes):
     test = Test(name=name, attributes=attributes)
-    ParentTypes.push("TEST")
     logging.debug("ReportPortal - Start Test: {0}".format(attributes))
-    RobotService.start_test(test=test)
+    parent_item_id = items[-1][0]
+    items.append((
+        RobotService.start_test(test=test, parent_item_id=parent_item_id),
+        parent_item_id))
 
 
 def end_test(name, attributes):
     test = Test(name=name, attributes=attributes)
-    ParentTypes.pop()
+    item_id, _ = items.pop()
     logging.debug("ReportPortal - End Test: {0}".format(attributes))
-    RobotService.finish_test(test=test)
+    RobotService.finish_test(item_id=item_id, test=test)
 
 
 def start_keyword(name, attributes):
-    parent_type = "SUITE" if ParentTypes.is_empty() else ParentTypes.peek()
+    parent_type = 'SUITE' if not items else 'TEST'
+    parent_item_id = items[-1][0]
     kwd = Keyword(name=name, parent_type=parent_type, attributes=attributes)
+    has_stats = False if kwd.get_type() == "STEP" else True
     logging.debug("ReportPortal - Start Keyword: {0}".format(attributes))
-    RobotService.start_keyword(keyword=kwd)
+    items.append((
+        RobotService.start_keyword(keyword=kwd, parent_item_id=parent_item_id,
+                                   has_stats=has_stats),
+        parent_item_id))
 
 
 def end_keyword(name, attributes):
     kwd = Keyword(name=name, attributes=attributes)
+    item_id, _ = items.pop()
     logging.debug("ReportPortal - End Keyword: {0}".format(attributes))
-    RobotService.finish_keyword(keyword=kwd)
+    RobotService.finish_keyword(item_id=item_id, keyword=kwd)
 
 
 def log_message(message):
@@ -127,5 +122,5 @@ def xunit_file(path):
     logging.debug("ReportPortal - XUnit File: {0}".format(path))
 
 
-def debug_file(path):
-    logging.debug("ReportPortal - Debug File: {0}".format(path))
+def info_file(path):
+    logging.debug("ReportPortal - info File: {0}".format(path))

robotframework_reportportal/model.py

@@ -42,7 +42,7 @@ def __init__(self, name=None, attributes=None):
 
 
 class Keyword(object):
-    def __init__(self, name=None, parent_type="SUITE", attributes=None):
+    def __init__(self, name=None, parent_type="TEST", attributes=None):
         super(Keyword, self).__init__()
         self.name = name
         self.libname = attributes["libname"]

robotframework_reportportal/service.py

@@ -1,8 +1,7 @@
 import logging
 import traceback
 from time import time
-from reportportal_client import ReportPortalServiceAsync
-from .variables import Variables
+from reportportal_client import ReportPortalService
 
 
 def async_error_handler(exc_info):
@@ -34,18 +33,16 @@ class RobotService(object):
     }
 
     @staticmethod
-    def init_service(endpoint, project, uuid, log_batch_size):
+    def init_service(endpoint, project, uuid):
         if RobotService.rp is None:
             logging.debug(
                 "ReportPortal - Init service: "
                 "endpoint={0}, project={1}, uuid={2}"
                 .format(endpoint, project, uuid))
-            RobotService.rp = ReportPortalServiceAsync(
+            RobotService.rp = ReportPortalService(
                 endpoint=endpoint,
                 project=project,
-                token=uuid,
-                error_handler=async_error_handler,
-                log_batch_size=log_batch_size)
+                token=uuid)
         else:
             raise Exception("RobotFrameworkService is already initialized")
 
@@ -60,12 +57,11 @@ def start_launch(launch_name, mode=None, launch=None):
             "name": launch_name,
             "start_time": timestamp(),
             "description": launch.doc,
-            "mode": mode,
-            "tags": Variables.launch_tags
+            "mode": mode
         }
         logging.debug("ReportPortal - Start launch: "
                       "request_body={0}".format(sl_pt))
-        RobotService.rp.start_launch(**sl_pt)
+        return RobotService.rp.start_launch(**sl_pt)
 
     @staticmethod
     def finish_launch(launch=None):
@@ -78,77 +74,81 @@ def finish_launch(launch=None):
         RobotService.rp.finish_launch(**fl_rq)
 
     @staticmethod
-    def start_suite(name=None, suite=None):
+    def start_suite(name=None, suite=None, parent_item_id=None):
         start_rq = {
             "name": name,
             "description": suite.doc,
-            "tags": [],
             "start_time": timestamp(),
-            "item_type": "SUITE"
+            "item_type": "SUITE",
+            "parent_item_id": parent_item_id
         }
         logging.debug(
             "ReportPortal - Start suite: "
             "request_body={0}".format(start_rq))
-        RobotService.rp.start_test_item(**start_rq)
+        return RobotService.rp.start_test_item(**start_rq)
 
     @staticmethod
-    def finish_suite(issue=None, suite=None):
+    def finish_suite(item_id, issue=None, suite=None):
         fta_rq = {
             "end_time": timestamp(),
             "status": RobotService.status_mapping[suite.status],
-            "issue": issue
+            "issue": issue,
+            "item_id": item_id
         }
         logging.debug(
             "ReportPortal - Finish suite:"
             " request_body={0}".format(fta_rq))
         RobotService.rp.finish_test_item(**fta_rq)
 
     @staticmethod
-    def start_test(test=None):
+    def start_test(test=None, parent_item_id=None):
         start_rq = {
             "name": test.name,
             "description": test.doc,
-            "tags": test.tags,
             "start_time": timestamp(),
-            "item_type": "TEST"
+            "item_type": "TEST",
+            "parent_item_id": parent_item_id
         }
         logging.debug(
             "ReportPortal - Start test: "
             "request_body={0}".format(start_rq))
-        RobotService.rp.start_test_item(**start_rq)
+        return RobotService.rp.start_test_item(**start_rq)
 
     @staticmethod
-    def finish_test(issue=None, test=None):
+    def finish_test(item_id, issue=None, test=None):
         fta_rq = {
             "end_time": timestamp(),
             "status": RobotService.status_mapping[test.status],
-            "issue": issue
+            "issue": issue,
+            "item_id": item_id
         }
         logging.debug(
             "ReportPortal - Finish test:"
             " request_body={0}".format(fta_rq))
         RobotService.rp.finish_test_item(**fta_rq)
 
     @staticmethod
-    def start_keyword(keyword=None):
+    def start_keyword(keyword=None, parent_item_id=None, has_stats=True):
         start_rq = {
             "name": keyword.get_name(),
             "description": keyword.doc,
-            "tags": keyword.tags,
             "start_time": timestamp(),
-            "item_type": keyword.get_type()
+            "item_type": keyword.get_type(),
+            "parent_item_id": parent_item_id,
+            "has_stats": has_stats
         }
         logging.debug(
             "ReportPortal - Start keyword: "
             "request_body={0}".format(start_rq))
-        RobotService.rp.start_test_item(**start_rq)
+        return RobotService.rp.start_test_item(**start_rq)
 
     @staticmethod
-    def finish_keyword(issue=None, keyword=None):
+    def finish_keyword(item_id, issue=None, keyword=None):
         fta_rq = {
             "end_time": timestamp(),
             "status": RobotService.status_mapping[keyword.status],
-            "issue": issue
+            "issue": issue,
+            "item_id": item_id
         }
         logging.debug(
             "ReportPortal - Finish keyword:"

setup.py

@@ -1,19 +1,18 @@
 from setuptools import setup, find_packages
 
 
-__version__ = '3.1.1'
+__version__ = '5.0.0'
 
 requirements = [
-    "reportportal-client~=3.0",
+    "reportportal-client>=5.0.0",
     "six",
 ]
 
 setup(
     name='robotframework-reportportal',
     packages=find_packages(),
     version=__version__,
-    description='Listener for RobotFramework reporting to ReportPortal',
-    author='Artsiom Tkachou',
+    description='Listener for RobotFramework reporting to ReportPortal v5',
     author_email='[email protected]',
     url='https://github.com/reportportal/agent-Python-RobotFramework',
     download_url=(