holado 0.8.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

holado_report/campaign/campaign_manager.py

@@ -0,0 +1,194 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+from holado.common.context.session_context import SessionContext
+import logging
+from holado_core.common.resource.table_data_manager import TableDataManager
+from holado_python.common.tools.datetime import DateTime, TIMEZONE_LOCAL
+import os
+from holado_system.system.filesystem.file import File
+import re
+
+
+logger = logging.getLogger(__name__)
+
+
+
+class CampaignManager(object):
+    """ Manage all campaigns
+    """
+    
+    def __init__(self, db_name="campaigns"):
+        super().__init__()
+        
+        self.__db_name = db_name
+        self.__resource_manager = None
+        
+        self.__campaigns_table_manager = TableDataManager('campaign', 'campaigns', self.__get_campaigns_table_sql_create(), db_name=self.__db_name)
+        self.__campaign_scenarios_table_manager = TableDataManager('campaign scenario', 'campaign_scenarios', self.__get_campaign_scenarios_table_sql_create(), db_name=self.__db_name)
+    
+    def initialize(self, resource_manager):
+        self.__resource_manager = resource_manager
+        
+        self.__campaigns_table_manager.initialize(resource_manager)
+        self.__campaigns_table_manager.ensure_db_exists()
+        self.__campaign_scenarios_table_manager.initialize(resource_manager)
+        self.__campaign_scenarios_table_manager.ensure_db_exists()
+    
+    def __get_db_client(self):
+        return self.__resource_manager.get_db_client(self.__db_name)
+    
+    def __get_campaigns_table_sql_create(self):
+        return """CREATE TABLE campaigns (
+                id INTEGER PRIMARY KEY,
+                name TEXT NOT NULL,
+                report_path TEXT NOT NULL
+            )"""
+
+    def __get_campaign_scenarios_table_sql_create(self):
+        return """CREATE TABLE campaign_scenarios (
+                id INTEGER PRIMARY KEY,
+                campaign_id INTEGER NOT NULL,
+                name TEXT NOT NULL,
+                report_path TEXT,
+                status TEXT,
+                status_at TEXT,
+                details TEXT
+            )"""
+
+    def update_stored_campaigns(self):
+        """ Update stored reports in DB with new campaigns
+        """
+        # Get report paths of campaigns to import
+        dt_last_camp = self.__get_last_campaign_scenario_status_datetime()
+        report_paths = self.__get_campaigns_report_paths(since_datetime=dt_last_camp)
+        
+        # Sort reports in time order
+        report_paths = sorted(report_paths, key=lambda p: os.path.getmtime(os.path.join(p, 'report_summary_scenario_all.txt')))
+        logger.info(f"reports to import: {report_paths}", msg_size_limit=None)
+        
+        # Import reports
+        for report_path in report_paths:
+            self.import_campaign_reports(report_path)
+    
+    def __get_campaigns_report_paths(self, since_datetime):
+        reports_path = SessionContext.instance().path_manager.get_reports_path()
+        file_paths = SessionContext.instance().path_manager.find_files(reports_path, subdir_relative_path='report_summary_scenario_all.txt', since_datetime=since_datetime)
+        return [os.path.dirname(p) for p in file_paths]
+    
+    def __get_last_campaign_scenario_status_datetime(self):
+        """ From stored campaigns, return the datetime of the last scenario with an execution status
+        """
+        client = self.__get_db_client()
+        
+        query_str = f'''
+            SELECT status_at
+            FROM campaign_scenarios
+            ORDER BY status_at DESC 
+            LIMIT 1
+        '''
+        res_dict_list = client.execute(query_str, result_as_dict_list=True, as_generator=False)
+        
+        status_dt_str = res_dict_list[0]['status_at'] if res_dict_list else None
+        status_dt = DateTime.str_2_datetime(status_dt_str, tz=TIMEZONE_LOCAL) if status_dt_str else None
+        return status_dt
+        
+    def import_campaign_reports(self, report_path):
+        """ Import reports of a campaign
+        @param report_path Path to the campaign report
+        """
+        logger.info(f"Import campaign report '{report_path}'")
+        
+        # Add campaign
+        camp_name = os.path.basename(report_path)
+        camp_id = self.add_campaign_if_needed(camp_name, report_path)
+        
+        # Import scenario status
+        self.__import_campaign_report_summary_scenario_all(report_path, camp_id)
+    
+    def get_scenario_history(self, scenario_name=None, size=None):
+        client = self.__get_db_client()
+        placeholder = client._get_sql_placeholder()
+        
+        # Get data from DB
+        where_clause = ""
+        where_data = []
+        if scenario_name is not None:
+            where_clause = f"where name = {placeholder}"
+            where_data.append(scenario_name)
+        
+        query_str = f'''
+            SELECT *
+            FROM campaign_scenarios
+            {where_clause}
+            ORDER BY name, status_at DESC 
+        '''
+        camp_scenarios_gen = client.execute(query_str, *where_data, result_as_dict_list=True, as_generator=True)
+        
+        # Build result
+        res = []
+        cur_scenario_name = None
+        cur_scenario_statuses = None
+        for cs in camp_scenarios_gen:
+            # Manage new scenario
+            if cur_scenario_name is None or cur_scenario_name != cs['name']:
+                cur_scenario_statuses = []
+                cur_scenario_name = cs['name']
+                res.append({'name':cur_scenario_name, 'statuses':cur_scenario_statuses})
+            
+            # Add campaign info for this scenario execution if size limit is not reached
+            if size is None or len(cur_scenario_statuses) < size:
+                cur_scenario_statuses.append({'at':cs['status_at'], 'status':cs['status']})
+            
+        return res
+        
+    def add_campaign_if_needed(self, name, report_path):
+        filter_data = {'report_path': report_path}
+        if not self.__campaigns_table_manager.has_data(filter_data):
+            self.__campaigns_table_manager.add_data(filter_data, {'name': name})
+        camp = self.__campaigns_table_manager.get_data(filter_data)
+        return camp['id']
+    
+    def update_or_add_campaign_scenario(self, campaign_id, name, *, report_path=None, status=None, status_at_str=None, details=None):
+        filter_data = {'campaign_id': campaign_id, 'name': name}
+        data = {}
+        if report_path is not None:
+            data['report_path'] = report_path
+        if status is not None:
+            data['status'] = status
+        if status_at_str is not None:
+            data['status_at'] = status_at_str
+        if details is not None:
+            data['details'] = details
+        
+        self.__campaign_scenarios_table_manager.update_or_add_data(filter_data, data)
+        # camp_sce = self.__campaign_scenarios_table_manager.get_data(filter_data)
+        # return camp_sce['id']
+    
+    def __import_campaign_report_summary_scenario_all(self, report_path, camp_id):
+        file_path = os.path.join(report_path, 'report_summary_scenario_all.txt')
+        lines = File(file_path, mode='rt').readlines(strip_newline=True)
+        
+        for line in lines:
+            parts = line.split(' - ')
+            status_dt_str = parts[0]
+            scenario_name = parts[1]
+            status_info = parts[-1]
+            
+            m = re.match(r"^(.*?)(?: \(.*\))?$", status_info)
+            status = m.group(1)
+            
+            self.update_or_add_campaign_scenario(camp_id, scenario_name, status=status, status_at_str=status_dt_str)
+        
+
+

holado_report/report/builders/detailed_scenario_failed_report_builder.py

@@ -33,10 +33,10 @@ class DetailedScenarioFailedReportBuilder(ReportBuilder):
         
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
+        category_validation, status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
         
         if status_validation != "Passed":
-            self.__file_fail_add_scenario(scenario, scenario_report, status_validation, step_failed, step_number)
+            self.__file_fail_add_scenario(scenario, scenario_report, category_validation, status_validation, step_failed, step_number)
             
     def after_all(self):
         # Manage file fail
@@ -44,13 +44,13 @@ class DetailedScenarioFailedReportBuilder(ReportBuilder):
             self.__file_fail.close()
             self.__file_fail = None
         
-    def __file_fail_add_scenario(self, scenario, scenario_report, status_validation, step_failed, step_number):
+    def __file_fail_add_scenario(self, scenario, scenario_report, category_validation, status_validation, step_failed, step_number):
         if self.__is_format_xml:
-            self.__file_fail_add_scenario_xml(scenario, scenario_report, status_validation, step_failed, step_number)
+            self.__file_fail_add_scenario_xml(scenario, scenario_report, category_validation, status_validation, step_failed, step_number)
         else:
-            self.__file_fail_add_scenario_txt(scenario, scenario_report, status_validation, step_failed, step_number)
+            self.__file_fail_add_scenario_txt(scenario, scenario_report, category_validation, status_validation, step_failed, step_number)
         
-    def __file_fail_add_scenario_xml(self, scenario, scenario_report, status_validation, step_failed, step_number):
+    def __file_fail_add_scenario_xml(self, scenario, scenario_report, category_validation, status_validation, step_failed, step_number):
         from holado_report.report.report_manager import ReportManager
         
         self.__open_file_if_needed()
@@ -61,6 +61,8 @@ class DetailedScenarioFailedReportBuilder(ReportBuilder):
         msg_list.append(f"    <scenario>{scenario.name}</scenario>")
         msg_list.append(f"    <report>{scenario_report.report_path}</report>")
         msg_list.append(f"    <tags>-t " + " -t ".join(scenario.feature.tags + scenario.tags) + "</tags>")
+        if category_validation:
+            msg_list.append(f"    <validation_category>{category_validation}</validation_category>")
         msg_list.append(f"    <validation_status>{status_validation}</validation_status>")
         if step_failed is not None:
             msg_list.append(f"    <failure>")
@@ -102,7 +104,7 @@ class DetailedScenarioFailedReportBuilder(ReportBuilder):
         self.__file_fail.write(msg)
         self.__file_fail.flush()
         
-    def __file_fail_add_scenario_txt(self, scenario, scenario_report, status_validation, step_failed, step_number):
+    def __file_fail_add_scenario_txt(self, scenario, scenario_report, category_validation, status_validation, step_failed, step_number):
         from holado_report.report.report_manager import ReportManager
         
         self.__open_file_if_needed()
@@ -112,6 +114,8 @@ class DetailedScenarioFailedReportBuilder(ReportBuilder):
         msg_list.append(f"    Scenario: {scenario.name}")
         msg_list.append(f"    Report: {scenario_report.report_path}")
         msg_list.append(f"    Tags: -t " + " -t ".join(scenario.feature.tags + scenario.tags))
+        if category_validation:
+            msg_list.append(f"    Validation category: {category_validation}")
         msg_list.append(f"    Validation status: {status_validation}")
         if step_failed is not None:
             msg_list.append(f"    Failure:")

holado_report/report/builders/failure_report_builder.py

@@ -41,16 +41,17 @@ class FailureReportBuilder(ReportBuilder):
         
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
+        category_validation, status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
         
         if status_validation != "Passed":
             step_error_message = ReportManager.get_step_error_message(step_failed).strip()
             if step_error_message not in self.__failures:
                 self.__failures[step_error_message] = []
             
+            category_str = f" ({category_validation})" if category_validation else ""
             if self.__file_format == 'txt':
                 msg_list = []
-                msg_list.append(f"scenario in {scenario.filename} at l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}")
+                msg_list.append(f"scenario in {scenario.filename} at l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}{category_str}")
                 msg_list.append(f"    Feature/Scenario: {scenario.feature.name}  =>  {scenario.name}")
                 msg_list.append(f"    Report: {scenario_report.report_path}")
                 msg_list.append(f"    Tags: -t " + " -t ".join(scenario.feature.tags + scenario.tags))
@@ -59,7 +60,7 @@ class FailureReportBuilder(ReportBuilder):
                 self.__failures[step_error_message].append(msg_scenario)
             elif self.__file_format in ['json', 'xml']:
                 scenario_info = {
-                    'title': f"{scenario.filename} - l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}",
+                    'title': f"{scenario.filename} - l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}{category_str}",
                     'scenario': f"{scenario.feature.name}  =>  {scenario.name}",
                     'report': scenario_report.report_path,
                     'tags': "-t " + " -t ".join(scenario.feature.tags + scenario.tags),

holado_report/report/builders/short_scenario_failed_report_builder.py

@@ -32,10 +32,10 @@ class ShortScenarioFailedReportBuilder(ReportBuilder):
         
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
+        category_validation, status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
         
         if status_validation != "Passed":
-            self.__file_fail_add_scenario(scenario, scenario_report, status_validation, step_failed, step_number)
+            self.__file_fail_add_scenario(scenario, scenario_report, category_validation, status_validation, step_failed, step_number)
             
     def after_all(self):
         # Manage file fail
@@ -43,16 +43,17 @@ class ShortScenarioFailedReportBuilder(ReportBuilder):
             self.__file_fail.close()
             self.__file_fail = None
         
-    def __file_fail_add_scenario(self, scenario, scenario_report, status_validation, step_failed, step_number):
+    def __file_fail_add_scenario(self, scenario, scenario_report, category_validation, status_validation, step_failed, step_number):
         from holado_report.report.report_manager import ReportManager
         
         self.__open_file_if_needed()
         
         msg_list = []
+        category_str = f" ({category_validation})" if category_validation else ""
         if step_failed is not None:
-            msg_list.append(f"scenario in {scenario.filename} at l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}")
+            msg_list.append(f"scenario in {scenario.filename} at l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}{category_str}")
         else:
-            msg_list.append(f"scenario in {scenario.filename} at l.{scenario.line} - step ? (missing step implementation ?) - {status_validation}")
+            msg_list.append(f"scenario in {scenario.filename} at l.{scenario.line} - step ? (missing step implementation ?) - {status_validation}{category_str}")
         msg_list.append(f"    Feature/Scenario: {scenario.feature.name}  =>  {scenario.name}")
         msg_list.append(f"    Report: {scenario_report.report_path}")
         msg_list.append(f"    Tags: -t " + " -t ".join(scenario.feature.tags + scenario.tags))

holado_report/report/builders/summary_report_builder.py

@@ -63,7 +63,7 @@ class SummaryReportBuilder(ReportBuilder):
         
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_name, _, _ = ReportManager.get_current_scenario_status_information(scenario)
+        _, status_name, _, _ = ReportManager.get_current_scenario_status_information(scenario)
         
         if status_name not in self.__scenarios:
             self.__scenarios[status_name] = 0

holado_report/report/builders/summary_scenario_failed_report_builder.py

@@ -31,10 +31,10 @@ class SummaryScenarioFailedReportBuilder(ReportBuilder):
         
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
+        category_validation, status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
         
         if status_validation != "Passed":
-            self.__file_fail_add_scenario(scenario, status_validation, step_failed, step_number)
+            self.__file_fail_add_scenario(scenario, category_validation, status_validation, step_failed, step_number)
             
     def after_all(self):
         # Manage file fail
@@ -42,12 +42,13 @@ class SummaryScenarioFailedReportBuilder(ReportBuilder):
             self.__file_fail.close()
             self.__file_fail = None
         
-    def __file_fail_add_scenario(self, scenario, status_validation, step_failed, step_number):
+    def __file_fail_add_scenario(self, scenario, category_validation, status_validation, step_failed, step_number):
         self.__open_file_if_needed()
+        category_str = f" ({category_validation})" if category_validation else ""
         if step_failed is not None:
-            self.__file_fail.write(f"scenario in {scenario.filename} at l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}\n")
+            self.__file_fail.write(f"scenario in {scenario.filename} at l.{scenario.line} - step {step_number} (l.{step_failed.line}) - {status_validation}{category_str}\n")
         else:
-            self.__file_fail.write(f"scenario in {scenario.filename} at l.{scenario.line} - step ? (missing step implementation ?) - {status_validation}\n")
+            self.__file_fail.write(f"scenario in {scenario.filename} at l.{scenario.line} - step ? (missing step implementation ?) - {status_validation}{category_str}\n")
         self.__file_fail.flush()
     
     def __open_file_if_needed(self):

holado_report/report/builders/summary_scenario_report_builder.py

@@ -33,12 +33,12 @@ class SummaryScenarioReportBuilder(ReportBuilder):
         
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
+        category_validation, status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
         
         if status_validation == "Passed":
-            self.__file_add_scenario_success(scenario, status_validation)
+            self.__file_add_scenario_success(scenario, category_validation, status_validation)
         else:
-            self.__file_add_scenario_fail(scenario, status_validation, step_failed, step_number)
+            self.__file_add_scenario_fail(scenario, category_validation, status_validation, step_failed, step_number)
             
     def after_all(self):
         # Manage file fail
@@ -46,27 +46,28 @@ class SummaryScenarioReportBuilder(ReportBuilder):
             self.__file.close()
             self.__file = None
         
-    def __file_add_scenario_success(self, scenario, status_validation):
+    def __file_add_scenario_success(self, scenario, category_validation, status_validation):
         self.__open_file_if_needed()
-        self.__file_write(scenario, None, status_validation)
+        self.__file_write(scenario, None, category_validation, status_validation)
         self.__file.flush()
         
-    def __file_add_scenario_fail(self, scenario, status_validation, step_failed, step_number):
+    def __file_add_scenario_fail(self, scenario, category_validation, status_validation, step_failed, step_number):
         self.__open_file_if_needed()
         if step_failed is not None:
-            self.__file_write(scenario, f"step {step_number} (l.{step_failed.line})", status_validation)
+            self.__file_write(scenario, f"step {step_number} (l.{step_failed.line})", category_validation, status_validation)
         else:
-            self.__file_write(scenario, f"step ? (missing step implementation ?)", status_validation)
+            self.__file_write(scenario, f"step ? (missing step implementation ?)", category_validation, status_validation)
         self.__file.flush()
     
-    def __file_write(self, scenario, text, status_validation):
+    def __file_write(self, scenario, text, category_validation, status_validation):
         dt = DateTime.now()
         dt_str = DateTime.datetime_2_str(dt, FORMAT_DATETIME_HUMAN_SECOND)
         
+        category_str = f" ({category_validation})" if category_validation else ""
         if text:
-            self.__file.write(f"{dt_str} - {scenario.filename} at l.{scenario.line} - {text} - {status_validation}\n")
+            self.__file.write(f"{dt_str} - {scenario.filename} at l.{scenario.line} - {text} - {status_validation}{category_str}\n")
         else:
-            self.__file.write(f"{dt_str} - {scenario.filename} at l.{scenario.line} - {status_validation}\n")
+            self.__file.write(f"{dt_str} - {scenario.filename} at l.{scenario.line} - {status_validation}{category_str}\n")
     
     def __open_file_if_needed(self):
         if self.__file is None:

holado_report/report/execution_historic.py

@@ -56,11 +56,12 @@ class ExecutionHistoric():
         self.__get_execution_historic_current_feature_scenarios().append(seh)
     
     def __new_ScenarioExecutionHistoric(self, scenario_context, scenario, scenario_report):
-        res = NamedTuple("ScenarioExecutionHistoric", scenario_context=object, scenario=object, scenario_report=object, steps_by_scope=dict, status_validation=str, step_failed=object, step_failed_number=int)
+        res = NamedTuple("ScenarioExecutionHistoric", scenario_context=object, scenario=object, scenario_report=object, steps_by_scope=dict, category_validation=str, status_validation=str, step_failed=object, step_failed_number=int)
         res.scenario_context = scenario_context
         res.scenario = scenario
         res.scenario_report = scenario_report
         res.steps_by_scope = {}
+        res.category_validation = None
         res.status_validation = None
         res.step_failed = None
         res.step_failed_number = None
@@ -87,10 +88,11 @@ class ExecutionHistoric():
     
     def after_scenario(self, scenario, scenario_report=None):
         from holado_report.report.report_manager import ReportManager
-        status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
+        category_validation, status_validation, step_failed, step_number = ReportManager.get_current_scenario_status_information(scenario)
         
         # Update execution historic
         current_scenario = self.__get_execution_historic_current_scenario()
+        current_scenario.category_validation = category_validation
         current_scenario.status_validation = status_validation
         current_scenario.step_failed = step_failed
         current_scenario.step_failed_number = step_number

holado_report/report/report_manager.py

@@ -12,7 +12,6 @@
 #################################################
 
 from holado.common.context.session_context import SessionContext
-from behave.model_core import Status
 from holado_core.common.tools.tools import Tools
 import logging
 # from holado_report.report.builders.json_execution_historic_report_builder import JsonExecutionHistoricReportBuilder
@@ -32,9 +31,13 @@ logger = logging.getLogger(__name__)
 
 
 class ReportManager(BaseReport):
+    """ Manage reports of current session
+    """
     TFeatureReport = None
     TStepTools = None
     
+    _scenario_status_information_by_uid = {}
+    
     def __init__(self):
         super().__init__()
         
@@ -183,6 +186,10 @@ class ReportManager(BaseReport):
         # scenario_duration_tags = sdm.compute_scenario_duration_tags(duration_limit_tags, "long", missing_tag=True, new_tag=True, unchanged_tag=True, with_failed=True)
         # sdm.create_file_scenario_duration_tags(fn, scenario_duration_tags)
         
+        # Update campaigns stored in test server
+        if self._get_test_server_client().is_available:
+            self._get_test_server_client().update_stored_campaigns()
+        
     def __enter_current_scenario_log_file(self):
         if SessionContext.instance().log_manager.in_file and self.has_report_path:
             log_filename = self.current_scenario_report.get_path("logs", "report.log")
@@ -195,21 +202,66 @@ class ReportManager(BaseReport):
         if SessionContext.instance().log_manager.in_file and self.has_report_path:
             log_filename = self.current_scenario_report.get_path("logs", "report.log")
             SessionContext.instance().log_manager.leave_log_file(log_filename, do_remove_log_file=True)
-        
+    
+    @classmethod
+    def _get_test_server_client(cls):
+        return SessionContext.instance().test_server_client
+    
+    @classmethod
+    def _get_scenario_uid(cls, scenario):
+        return f"{scenario.filename} at l.{scenario.line}"
+    
     @classmethod
     def get_current_scenario_status_information(cls, scenario):
-        step_failed, step_nb = cls.get_step_failed_info(scenario)
-        
-        if step_failed is not None and hasattr(SessionContext.instance().get_scenario_context(), "is_in_preconditions") and SessionContext.instance().get_scenario_context().is_in_preconditions:
-            status = "Failed in Preconditions"
-        elif step_failed is not None and step_failed.keyword == "Given":
-            status = "Failed in Given"
-        elif step_failed is not None or scenario.status.has_failed():
-            status = "Failed"
-        else:
-            status = scenario.status.name.capitalize()
+        scenario_uid = cls._get_scenario_uid(scenario)
+        if scenario_uid not in cls._scenario_status_information_by_uid:
+            step_failed, step_nb = cls.get_step_failed_info(scenario)
             
-        return [status, step_failed, step_nb]
+            # Define scenario status
+            if step_failed is not None and hasattr(SessionContext.instance().get_scenario_context(), "is_in_preconditions") and SessionContext.instance().get_scenario_context().is_in_preconditions:
+                status = "Failed in Preconditions"
+            elif step_failed is not None and step_failed.keyword == "Given":
+                status = "Failed in Given"
+            elif step_failed is not None or scenario.status.has_failed():
+                status = "Failed"
+            else:
+                status = scenario.status.name.capitalize()
+            
+            # Define scenario category
+            category = None
+            if cls._get_test_server_client().is_available:
+                # Get scenario execution statuses
+                scenario_name = f"{scenario.filename} at l.{scenario.line}"
+                sce_hist = cls._get_test_server_client().get_scenario_history(scenario_name=scenario_name, size=10)
+                statuses = [s['status'] for s in sce_hist[0]['statuses']] if sce_hist else []
+                statuses.append(status)
+                
+                # Get scenario status sequences
+                passed_sequences = []
+                for status in statuses:
+                    if status == 'Passed':
+                        passed = True
+                    elif status.startswith("Failed"):
+                        passed = False
+                    else:
+                        continue
+                    if len(passed_sequences) == 0 or passed != passed_sequences[-1]:
+                        passed_sequences.append(passed)
+                
+                # Compute category
+                if passed_sequences:
+                    if len(passed_sequences) == 1:
+                        category = 'Success' if passed_sequences[0] else 'Failed'
+                    elif len(passed_sequences) > 2:
+                        category = 'Randomly Failed'
+                    elif passed_sequences[-1]:
+                        category = 'Newly Success'
+                    else:
+                        category = 'Newly Failed'
+            
+            cls._scenario_status_information_by_uid[scenario_uid] = [category, status, step_failed, step_nb]
+        
+        return cls._scenario_status_information_by_uid[scenario_uid]
         
     @classmethod
     def get_step_failed_info(cls, scenario):

holado_rest/api/rest/rest_client.py

@@ -55,7 +55,11 @@ class RestClient(Object):
         self.__kwargs = {}
             
         self.__request_log_level = Config.log_level_rest_request
-        
+    
+    @property
+    def url(self):
+        return self.__url
+    
     @property
     def request_log_level(self):
         return self.__request_log_level

holado_system/system/filesystem/file.py

@@ -81,8 +81,11 @@ class File(DeleteableObject):
     def readline(self, limit: int = -1) -> AnyStr:
         return self.internal_file.readline(limit)
 
-    def readlines(self, hint: int = -1) -> List[AnyStr]:
-        return self.internal_file.readlines(hint)
+    def readlines(self, hint: int = -1, strip_newline=False) -> List[AnyStr]:
+        res = self.internal_file.readlines(hint)
+        if strip_newline:
+            res = [l.strip('\n') for l in res]
+        return res
 
 
 

holado_test/__init__.py

@@ -23,5 +23,8 @@ def register():
     from holado_test.behave.behave_manager import BehaveManager
     SessionContext.instance().services.register_service_type("behave_manager", BehaveManager)
     
+    from holado_test.test_server.client.rest.test_server_client import TestServerClient
+    SessionContext.instance().services.register_service_type("test_server_client", TestServerClient.new_client)
+    
 
 

holado_test/common/context/feature_context.py

@@ -13,10 +13,10 @@
 
 from builtins import super
 from holado.common.context.context import Context
-from datetime import datetime
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_scripting.common.tools.variable_manager import VariableManager
 from holado.common.context.session_context import SessionContext
+from holado_python.common.tools.datetime import DateTime
 
 class FeatureContext(Context):
     def __init__(self, feature):
@@ -24,7 +24,7 @@ class FeatureContext(Context):
         
         self.__feature = feature
         
-        self.__start_date = datetime.now()
+        self.__start_date = DateTime.now()
         self.__end_date = None
         self.__scenarios = []
     
@@ -64,7 +64,7 @@ class FeatureContext(Context):
         self.__scenarios.append(scenario_context)
     
     def end(self):
-        self.__end_date = datetime.now()
+        self.__end_date = DateTime.now()
         
     def has_variable_manager(self):
         return self.has_object("variable_manager")

holado_test/common/context/scenario_context.py

@@ -21,10 +21,10 @@ from holado_scripting.common.tools.expression_evaluator import ExpressionEvaluat
 from holado.common.context.session_context import SessionContext
 from holado_core.common.block.scope_manager import ScopeManager
 from holado_core.common.block.block_manager import BlockManager
-from datetime import datetime
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_scripting.text.verifier.text_verifier import TextVerifier
 from holado_multitask.multitasking.multitask_manager import MultitaskManager
+from holado_python.common.tools.datetime import DateTime
 
 logger = logging.getLogger(__name__)
 
@@ -35,7 +35,7 @@ class ScenarioContext(Context):
         
         self.__scenario = scenario
         
-        self.__start_date = datetime.now()
+        self.__start_date = DateTime.now()
         self.__end_date = None
         
         self.__main_thread_uid = SessionContext.instance().multitask_manager.main_thread_uid
@@ -150,7 +150,7 @@ class ScenarioContext(Context):
         return self.get_object("expression_evaluator")
     
     def end(self):
-        self.__end_date = datetime.now()
+        self.__end_date = DateTime.now()