holado 0.18.20.dev1__tar.gz → 0.18.22.dev1__tar.gz

{holado-0.18.20.dev1 → holado-0.18.22.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.18.20.dev1
+Version: 0.18.22.dev1
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.18.22.dev1/packaging/VERSION

@@ -0,0 +1 @@
+0.18.22.dev1

{holado-0.18.20.dev1 → holado-0.18.22.dev1}/src/holado_report/campaign/campaign_manager.py

@@ -207,13 +207,16 @@ class CampaignManager(object):
 
     def get_scenario_names(self, since=None, until=None):
         client = self.__get_db_client()
-        placeholder = client._get_sql_placeholder()
 
         # Get data from DB
         w_compare_data = []
         if since:
+            if isinstance(since, datetime):
+                since = DateTime.datetime_2_str(since)
             w_compare_data.append(('status_at', CompareOperator.SuperiorOrEqual, since))
         if until:
+            if isinstance(until, datetime):
+                until = DateTime.datetime_2_str(until)
             w_compare_data.append(('status_at', CompareOperator.Inferior, until))
         camp_names_gen = client.select("campaign_scenarios", where_compare_data=w_compare_data, sql_return='name',
                                        result_as_dict_list=True, as_generator=True, order_bys=['name'], distinct=True)
@@ -223,18 +226,46 @@ class CampaignManager(object):
 
         return res
 
-    def get_scenario_history(self, scenario_name=None, size=None, since=None, until=None, with_details=None):
+    def get_scenario_history(self, scenario_name=None, size=None, since=None, until=None,
+                             since_history=None, until_history=None, with_details=None):
+        """
+        Get history of a campaign scenario or of all scenarios run during a period of time.
+
+        :param scenario_name: If defined, get history of scenario with this name
+        :param size: Size max of each scenario history
+        :param since: Begin of period to find scenarios for which return history (and history if since_history is not defined)
+        :param until: End of period to find scenarios for which return history (and history if since_history is not defined)
+        :param since_history: If defined, begin of history period
+        :param until_history: If defined, end of history period
+        :param with_details: If True, add details in result
+        :return:
+        """
+        if since_history is None:
+            since_history = since
+        if until_history is None:
+            until_history = until
+
         client = self.__get_db_client()
 
+        # Get scenario names for which return history
+        if scenario_name is not None:
+            scenario_names = [scenario_name]
+        else:
+            scenario_names = self.get_scenario_names(since=since, until=until)
+
         # Get data from DB
         w_data = {}
         w_compare_data = []
         if scenario_name is not None:
             w_data['name'] = scenario_name
-        if since:
-            w_compare_data.append( ('status_at', CompareOperator.SuperiorOrEqual, since) )
-        if until:
-            w_compare_data.append( ('status_at', CompareOperator.Inferior, until) )
+        if since_history:
+            if isinstance(since_history, datetime):
+                since_history = DateTime.datetime_2_str(since_history)
+            w_compare_data.append( ('status_at', CompareOperator.SuperiorOrEqual, since_history) )
+        if until_history:
+            if isinstance(until_history, datetime):
+                until_history = DateTime.datetime_2_str(until_history)
+            w_compare_data.append( ('status_at', CompareOperator.Inferior, until_history) )
         camp_scenarios_gen = client.select("campaign_scenarios", where_data=w_data, where_compare_data=w_compare_data,
                                            result_as_dict_list=True, as_generator=True,
                                            order_bys=['name', ('status_at', 'DESC')])
@@ -244,6 +275,10 @@ class CampaignManager(object):
         cur_scenario_name = None
         cur_scenario_data = None
         for cs in camp_scenarios_gen:
+            # Skip unwanted scenarios
+            if cs['name'] not in scenario_names:
+                continue
+
             # Manage new scenario
             if cur_scenario_name is None or cur_scenario_name != cs['name']:
                 cur_scenario_data = []
@@ -388,19 +423,19 @@ class CampaignManager(object):
         
         return file_modified_dt
 
-    def get_qa_data(self, qa_report_type, size=None, since=None, until=None, round_nb_decimal=None, with_details=False):
-        match qa_report_type:
+    def get_qa_data(self, qa_data_type, size=None, since=None, until=None, since_history=None, until_history=None, round_nb_decimal=None, with_details=False):
+        match qa_data_type:
             case QAReportType.NumberByQAStatus:
-                return self.__get_qa_data_nb_by_qa_status(size=size, since=since, until=until, with_details=with_details)
+                return self.__get_qa_data_nb_by_qa_status(size=size, since=since, until=until, since_history=since_history, until_history=until_history, with_details=with_details)
             case QAReportType.RatioOfFailedAndSuccess:
-                return self.__get_qa_data_ratio_failed_success(size=size, since=since, until=until, round_nb_decimal=round_nb_decimal, with_details=with_details)
+                return self.__get_qa_data_ratio_failed_success(size=size, since=since, until=until, since_history=since_history, until_history=until_history, round_nb_decimal=round_nb_decimal, with_details=with_details)
             case _:
-                raise TechnicalException(f"Unmanaged QA report type '{qa_report_type}'")
+                raise TechnicalException(f"Unmanaged QA data type '{qa_data_type}'")
 
-    def __get_qa_data_nb_by_qa_status(self, size=None, since=None, until=None, with_details=False):
+    def __get_qa_data_nb_by_qa_status(self, size=None, since=None, until=None, since_history=None, until_history=None, with_details=False):
         # Compute counters
         counter_by_qa_status, counter_by_category = {}, {}
-        all_history = self.get_scenario_history(size=size, since=since, until=until)
+        all_history = self.get_scenario_history(size=size, since=since, until=until, since_history=since_history, until_history=until_history)
         for scenario_history in all_history:
             sce_hist = scenario_history['history']
             sce_cat = ScenarioTools.compute_validation_category_for_scenario_history(sce_hist)
@@ -429,13 +464,13 @@ class CampaignManager(object):
 
         return res
 
-    def __get_qa_data_ratio_failed_success(self, size=None, since=None, until=None, round_nb_decimal=None, with_details=False):
+    def __get_qa_data_ratio_failed_success(self, size=None, since=None, until=None, since_history=None, until_history=None, round_nb_decimal=None, with_details=False):
         if round_nb_decimal is None:
             round_nb_decimal = 0
 
         # Compute counters
         ratio_failed, ratio_success, ratio_by_status = 0, 0, Counter()
-        all_history = self.get_scenario_history(size=size, since=since, until=until)
+        all_history = self.get_scenario_history(size=size, since=since, until=until, since_history=since_history, until_history=until_history)
         for scenario_history in all_history:
             sce_hist = scenario_history['history']
             nb_success = sum(1 for x in sce_hist if x['status'] == 'Passed')

holado-0.18.22.dev1/src/holado_report/qa/qa_report.py

@@ -0,0 +1,150 @@
+import datetime
+from prettytable import PrettyTable, TableStyle, HRuleStyle
+import logging
+from holado_python.common.enums import ArithmeticOperator
+from holado_python.common.tools.datetime import DateTime, DurationUnit
+from holado_core.common.exceptions.technical_exception import TechnicalException
+
+
+logger = logging.getLogger(__name__)
+
+
+class QAReport(object):
+    """ Manage QA report
+    Data are retrieved locally or remotely depending on initialized campaign_manager or test_server_client respectively.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self.__campaign_manager = None
+        self.__test_server_client = None
+
+    def initialize(self, campaign_manager=None, test_server_client=None):
+        self.__campaign_manager = campaign_manager
+        self.__test_server_client = test_server_client
+
+    def __get_data_client(self):
+        if self.__campaign_manager:
+            return self.__campaign_manager
+        elif self.__test_server_client:
+            return self.__test_server_client
+        else:
+            raise TechnicalException("'campaign_manager' and 'test_server_client' are both not defined. Please call 'initialize' method to define campaign_manager or test_server_client")
+
+    def get_report_data(self, qa_report_type, period_unit, period_number,
+                        data_window_days, data_window_size, data_window_in_period,
+                        since, until, round_nb_decimal, with_details):
+        if self.__test_server_client:
+            return self.__test_server_client.get_report_data(qa_report_type, period_unit,)
+
+        if since is not None and isinstance(since, str):
+            since = DateTime.str_2_datetime(since)
+        if until is not None and isinstance(until, str):
+            until = DateTime.str_2_datetime(until)
+
+        # Compute base datetimes
+        dt_now = DateTime.now(tz=None) if until is None else until
+        dt_now_period_start, dt_format = None, None
+        match period_unit:
+            case DurationUnit.Month:
+                dt_now_period_start = datetime.datetime(year=dt_now.year, month=dt_now.month, day=1, tzinfo=dt_now.tzinfo)
+                dt_format = '%Y-%m'
+            case DurationUnit.Week:
+                dt_now_isocalendar = dt_now.isocalendar()
+                dt_now_period_start = datetime.datetime.fromisocalendar(year=dt_now_isocalendar.year, week=dt_now_isocalendar.week, day=1)
+                dt_format = '%Y-W%W'
+            case DurationUnit.Day:
+                dt_now_period_start = datetime.datetime(year=dt_now.year, month=dt_now.month, day=dt_now.day, tzinfo=dt_now.tzinfo)
+                dt_format = '%Y-%m-%d'
+            case _:
+                raise TechnicalException(f"Unmanaged periodicity unit {period_unit}")
+        dt_now_start = dt_now_period_start
+        if data_window_days is not None and dt_now - dt_now_start < datetime.timedelta(days=data_window_days):
+            dt_now_start = DateTime.apply_delta_on_datetime(dt_now, ArithmeticOperator.Subtraction, data_window_days, DurationUnit.Day)
+        if since is not None:
+            if dt_now_period_start < since:
+                dt_now_period_start = since
+            if dt_now_start < since:
+                dt_now_start = since
+
+        # Get data
+        dt_period_start, dt_start, dt_end = dt_now_period_start, dt_now_start, dt_now
+        res = []
+        while True:
+            # Note: If 'until' is a period start, dt_start is equal to dt_end => Skip this empty period
+            if dt_start < dt_end:
+                qa_data = {period_unit.name: DateTime.datetime_2_str(dt_period_start, dt_format)}
+                # Note: if data window size is defined, do not request period data with 'since' parameter, so that request includes runs until window size is reached
+                #       even if it means to use runs executed before this period
+                if data_window_size is None or data_window_days:
+                    q_since = dt_start
+                else:
+                    # Limit to last 'data_window_size' days (1 run per day)
+                    q_since = DateTime.apply_delta_on_datetime(dt_end, ArithmeticOperator.Subtraction, data_window_size, DurationUnit.Day)
+                if data_window_in_period and q_since < dt_period_start:
+                    q_since = dt_period_start
+                data = self.__get_data_client().get_qa_data(qa_data_type=qa_report_type, size=data_window_size,
+                                                            since=dt_period_start, until=dt_end, since_history=q_since, until_history=dt_end,
+                                                            round_nb_decimal=round_nb_decimal, with_details=with_details)
+                qa_data.update(data)
+                res.append(qa_data)
+
+            dt_end = dt_period_start
+            dt_period_start = DateTime.apply_delta_on_datetime(dt_end, ArithmeticOperator.Subtraction, 1, period_unit)
+            if data_window_days is not None:
+                dt_start = DateTime.apply_delta_on_datetime(dt_end, ArithmeticOperator.Subtraction, data_window_days, DurationUnit.Day)
+            else:
+                dt_start = dt_period_start
+            if since is not None and dt_end > since:
+                if dt_period_start < since:
+                    dt_period_start = since
+                if dt_start < since:
+                    dt_start = since
+
+            if since is not None:
+                if dt_period_start < since:
+                    break
+            elif period_number is not None:
+                if len(res) >= period_number:
+                    break
+            else:
+                raise TechnicalException("Unexpected case")
+
+        return res
+
+    @classmethod
+    def output(cls, report_data, path_out):
+        # Sort received data
+        fields_order = ['Month', 'Week', 'Day', 'Failed', 'NewlyFailed', 'Random', 'Success', 'Mean run number', 'details']
+        field_names = list(sorted(report_data[0].keys(), key=lambda k: fields_order.index(k)))
+
+        if path_out is not None and path_out.lower().endswith('.csv'):
+            with open(path_out, 'w') as fout:
+                import csv
+                dw = csv.DictWriter(fout, fieldnames=field_names, delimiter=';', quoting=csv.QUOTE_NONE)
+                dw.writeheader()
+                for row_data in report_data:
+                    dw.writerow(row_data)
+        else:
+            # Format data as a table
+            table = PrettyTable()
+            table.field_names = field_names
+            for row_data in report_data:
+                table.add_row([row_data[k] for k in field_names])
+
+            # Output table as string
+            table.set_style(TableStyle.ORGMODE)
+            table.align = 'l'
+            table.hrules = HRuleStyle.NONE
+            table_str = table.get_string()
+
+            if path_out is not None:
+                with open(path_out, 'wt') as fout:
+                    fout.write(table_str)
+                    fout.write('\n')
+            else:
+                print(f"QA Report:\n{table_str}")
+
+
+

{holado-0.18.20.dev1 → holado-0.18.22.dev1}/src/holado_rest/api/rest/rest_client.py

@@ -133,14 +133,14 @@ class RestClient(Object):
         """Return the result of the request associated to given response
         @param response Response of the request
         @param status_ok The status code, or a list of status codes, for which the request is considered in success
-        @param result_on_statuses A dictionary with defined result associated to a status
+        @param result_on_statuses A dictionary with defined result associated to statuses for which no error is raised
         Notes:
-          - If response status is not status_ok (or in status_ok if it is a list), an exception is raised telling request has failed
+          - If response status is not status_ok (or in status_ok if it is a list) and not in result_on_statuses, an exception is raised telling request has failed and the reason
           - result_on_statuses is by default RestClient.default_result_on_statuses (={204: None})
           - When holado.common.handlers.undefined.default is in result_on_statuses as status, the associated result is returned in any other case and no failing exception is raised
         """
         res = to_be_defined
-        is_res_default = False
+        is_res_on_statuses = False
         is_ok = Converter.is_iterable(status_ok) and response.status_code in status_ok or response.status_code == status_ok
 
         # Find a result associated to response status
@@ -151,13 +151,14 @@ class RestClient(Object):
             for status, status_result in result_on_statuses.items():
                 if response.status_code == status:
                     res = status_result
+                    is_res_on_statuses = True
                     break
                 elif status is default:
                     default_result = status_result
-            # Note: special status 'default' is applied for statuses that are not in result_on_statuses and not in status_ok
+            # Note: special status 'default' is applied for statuses that are not in status_ok and not in result_on_statuses
             if res is to_be_defined and default_result is not to_be_defined and not is_ok:
                 res = default_result
-                is_res_default = True
+                is_res_on_statuses = True
 
         # If result is not defined, get it from response
         if res is to_be_defined:
@@ -169,9 +170,9 @@ class RestClient(Object):
                 res = response.content
 
         # Verify status
-        if not is_ok and not is_res_default:
+        if not is_ok and not is_res_on_statuses:
             req_descr = f"{request_description} " if request_description is not None else ""
-            raise FunctionalException(f"[{self.name}] Request {req_descr}failed with status {response.status_code} (expected success status: {status_ok}) on error: {res}")
+            raise FunctionalException(f"[{self.name}] Request {req_descr}failed with status {response.status_code} (expected success status: {status_ok} ; statuses with specific result: {result_on_statuses}) on error: {res}")
 
         return res
 

holado-0.18.22.dev1/src/holado_test/tools/scripts/reporting_qa.py

@@ -0,0 +1,96 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "holado[rest]",
+# ]
+# ///
+
+import datetime
+
+from prettytable import PrettyTable, TableStyle, HRuleStyle
+import os
+import logging
+
+
+logger = None
+
+
+def __get_work_dir_path():
+    here = os.path.abspath(os.path.dirname(__file__))
+    return os.path.abspath(here)
+
+def _initialize():
+    from holado_helper.script.initialize_script import initialize, parse_logging_args  # @UnresolvedImport
+    log_args = parse_logging_args()
+    res = initialize(work_dir_path=__get_work_dir_path(),
+                     log_level=log_args.log_level, log_in_file=log_args.log_in_file, with_session_path=log_args.log_in_file)
+
+    global logger
+    logger = logging.getLogger(__name__)
+
+    return res
+
+
+def generate_qa_report(qa_report_type, period_unit, period_number, data_window_days, data_window_size, data_window_in_period,
+                       since, until, round_nb_decimal, with_details, path_out):
+    from holado.common.context.session_context import SessionContext
+    from holado_report.qa.qa_report import QAReport
+
+    report = QAReport()
+    report.initialize(test_server_client=SessionContext.instance().test_server_client)
+
+    data = report.get_report_data(qa_report_type=qa_report_type, period_unit=period_unit, period_number=period_number,
+                                  data_window_days=data_window_days, data_window_size=data_window_size, data_window_in_period=data_window_in_period,
+                                  since=since, until=until, round_nb_decimal=round_nb_decimal, with_details=with_details)
+    report.output(report_data=data, path_out=path_out)
+
+
+if __name__ == "__main__":
+    user_work_dir = _initialize()
+
+    from holado_helper.script.initialize_script import get_logging_argument_parser
+    from holado_report.report.enums import QAReportType
+    from holado_python.common.tools.datetime import DurationUnit
+
+    qa_report_types = [x.name for x in QAReportType]
+    possible_units = [DurationUnit.Month.value, DurationUnit.Week.value, DurationUnit.Day.value]
+
+    parser = get_logging_argument_parser(add_help=True)
+    parser.add_argument('-t', '--qa-report-type', dest='qa_report_type', type=str, default=qa_report_types[0], choices=qa_report_types,
+                        help='Type of QA report')
+    parser.add_argument('-pu', '--period-unit', dest='period_unit', type=str, default=possible_units[0], choices=possible_units,
+                        help='Report period unit')
+    parser.add_argument('-pn', '--period-number', dest='period_number', type=int, default=6,
+                        help='Number of period to include in report (used only if parameter --datetime-since is not defined)')
+    parser.add_argument('-ws', '--data-window-size', dest='data_window_size', type=int, default=None,
+                        help='Max size of the data window used to compute each period data (used only if parameter --qa-report-type=NumberByQAStatus)')
+    parser.add_argument('-wd', '--data-window-days', dest='data_window_days', type=int, default=None,
+                        help='Number of days used as data window to compute each period data (used only if parameter --qa-report-type=NumberByQAStatus)')
+    parser.add_argument('-wp', '--data-window-in-period', dest='data_window_in_period', default=False, action="store_true",
+                        help='If set, force data window to keep inside each period')
+    parser.add_argument('-ds', '--datetime-since', dest='datetime_since', type=str, default=None,
+                        help='Report since this datetime')
+    parser.add_argument('-du', '--datetime-until', dest='datetime_until', type=str, default=None,
+                        help='Report until this datetime')
+    parser.add_argument('-r', '--round-nb-decimal', dest='round_nb_decimal', type=int, default=1,
+                        help='Round number of decimal')
+    parser.add_argument('-d', '--with-details', dest='with_details', default=False, action="store_true",
+                        help='If set, include details in report')
+    parser.add_argument('-o', '--path-out', dest='path_out', default=None,
+                        help='Output file path (relative or absolute)')
+    args = parser.parse_args()
+
+    qa_report_type = QAReportType[args.qa_report_type]
+    period_unit = DurationUnit(args.period_unit)
+    if args.path_out is not None:
+        path_out = args.path_out if os.path.isabs(args.path_out) else os.path.join(user_work_dir, args.path_out)
+    else:
+        path_out = None
+
+    generate_qa_report(qa_report_type=qa_report_type,
+                       period_unit=period_unit, period_number=args.period_number,
+                       data_window_days=args.data_window_days, data_window_size=args.data_window_size, data_window_in_period=args.data_window_in_period,
+                       since=args.datetime_since, until=args.datetime_until,
+                       round_nb_decimal=args.round_nb_decimal, with_details=args.with_details,
+                       path_out=path_out)
+

{holado-0.18.20.dev1 → holado-0.18.22.dev1}/src/holado_test/tools/test_server/client/rest/test_server_client.py

@@ -13,7 +13,7 @@
 
 import logging
 
-from holado_python.common.tools.datetime import DateTime
+from holado_python.common.tools.datetime import DateTime, DurationUnit
 from holado_report.report.enums import QAReportType
 from holado_rest.api.rest.rest_client import RestClient
 import socket
@@ -133,16 +133,28 @@ class TestServerClient(RestClient):
     def update_stored_campaigns(self):
         return self.put(f"campaign/update")
 
-    def get_scenario_history(self, scenario_name=None, size=None, since=None, until=None, with_details=None):
+    def get_scenario_history(self, scenario_name=None, size=None, since=None, until=None, since_history=None, until_history=None, with_details=None):
         data = {}
         if scenario_name is not None:
             data['scenario_name'] = scenario_name
         if size is not None:
             data['size'] = size
         if since is not None:
+            if isinstance(since, datetime):
+                since = DateTime.datetime_2_str(since)
             data['since'] = since
         if until is not None:
+            if isinstance(until, datetime):
+                until = DateTime.datetime_2_str(until)
             data['until'] = until
+        if since_history is not None:
+            if isinstance(since_history, datetime):
+                since_history = DateTime.datetime_2_str(since_history)
+            data['since_history'] = since_history
+        if until_history is not None:
+            if isinstance(until_history, datetime):
+                until_history = DateTime.datetime_2_str(until_history)
+            data['until_history'] = until_history
         if with_details is not None:
             data['with_details'] = with_details
 
@@ -151,11 +163,13 @@ class TestServerClient(RestClient):
         else:
             return self.get(f"campaign/scenario/history")
 
-    def get_qa_data(self, qa_report_type, size=None, since=None, until=None, round_nb_decimal=None, with_details=False):
-        if isinstance(qa_report_type, QAReportType):
-            qa_report_type = qa_report_type.name
+    def get_qa_data(self, qa_data_type=QAReportType.NumberByQAStatus, size=None,
+                    since=None, until=None, since_history=None, until_history=None,
+                    round_nb_decimal=None, with_details=False):
+        if isinstance(qa_data_type, QAReportType):
+            qa_data_type = qa_data_type.name
 
-        data = {'qa_report_type': qa_report_type}
+        data = {'qa_data_type': qa_data_type}
         if size is not None:
             data['size'] = size
         if since is not None:
@@ -166,13 +180,53 @@ class TestServerClient(RestClient):
             if isinstance(until, datetime):
                 until = DateTime.datetime_2_str(until)
             data['until'] = until
+        if since_history is not None:
+            if isinstance(since_history, datetime):
+                since_history = DateTime.datetime_2_str(since_history)
+            data['since_history'] = since_history
+        if until_history is not None:
+            if isinstance(until_history, datetime):
+                until_history = DateTime.datetime_2_str(until_history)
+            data['until_history'] = until_history
         if round_nb_decimal is not None:
             data['round_nb_decimal'] = round_nb_decimal
         if with_details is not None:
             data['with_details'] = with_details
 
-        return self.get(f"report/qa", json=data)
+        return self.get(f"campaign/qa_data", json=data)
+
+    def get_report_qa(self, qa_report_type=QAReportType.NumberByQAStatus,
+                      period_unit=DurationUnit.Month, period_number=10,
+                      data_window_days=None, data_window_size=None, data_window_in_period=False,
+                      since=None, until=None, round_nb_decimal=None, with_details=False):
+        if isinstance(qa_report_type, QAReportType):
+            qa_report_type = qa_report_type.name
+        if isinstance(period_unit, DurationUnit):
+            period_unit = period_unit.name
+
+        data = {'qa_report_type': qa_report_type,
+                'period_unit': period_unit,
+                'period_number': period_number,}
+        if data_window_days is not None:
+            data['data_window_days'] = data_window_days
+        if data_window_size is not None:
+            data['data_window_size'] = data_window_size
+        if data_window_in_period is not None:
+            data['data_window_in_period'] = data_window_in_period
+        if since is not None:
+            if isinstance(since, datetime):
+                since = DateTime.datetime_2_str(since)
+            data['since'] = since
+        if until is not None:
+            if isinstance(until, datetime):
+                until = DateTime.datetime_2_str(until)
+            data['until'] = until
+        if round_nb_decimal is not None:
+            data['round_nb_decimal'] = round_nb_decimal
+        if with_details is not None:
+            data['with_details'] = with_details
 
+        return self.get(f"report/qa", json=data)
 
     
     

holado-0.18.22.dev1/src/holado_test/tools/test_server/server/requirements.txt

@@ -0,0 +1,2 @@
+# HolAdo framework
+holado[api-connexion,ssl]>=0.18.20

{holado-0.18.20.dev1/src/holado_test/tools/test_server/server/rest/api/report → holado-0.18.22.dev1/src/holado_test/tools/test_server/server/rest/api/campaign}/__init__.py

@@ -23,21 +23,34 @@ def _get_session_context():
     return SessionContext.instance()
 
 
-class QaView(MethodView):
-    
+class QaDataView(MethodView):
+
     def get(self, body: dict):
         try:
-            qa_report_type = QAReportType[body['qa_report_type']]
+            qa_data_type = QAReportType[body['qa_data_type']]
             size = body.get('size', None)
             since = body.get('since', None)
             until = body.get('until', None)
+            since_history = body.get('since_history', None)
+            until_history = body.get('until_history', None)
             round_nb_decimal = body.get('round_nb_decimal', None)
             with_details = body.get('with_details', False)
 
-            res = _get_session_context().server_manager.campaign_manager.get_qa_data(qa_report_type=qa_report_type, size=size, since=since, until=until,
+            res = _get_session_context().server_manager.campaign_manager.get_qa_data(qa_data_type=qa_data_type, size=size, since=since, until=until,
+                                                                                     since_history=since_history, until_history=until_history,
                                                                                      round_nb_decimal=round_nb_decimal, with_details=with_details)
 
             return res
+        except Exception as exc:
+            logger.exception(f"Failed to get QA data for {body}")
+            return str(exc), 500
+
+
+class UpdateView(MethodView):
+    
+    def put(self):
+        try:
+            _get_session_context().server_manager.campaign_manager.update_stored_campaigns()
         except Exception as exc:
             logger.exception("Failed to update stored campaigns")
             return str(exc), 500

{holado-0.18.20.dev1 → holado-0.18.22.dev1}/src/holado_test/tools/test_server/server/rest/api/campaign/scenario.py

@@ -27,12 +27,15 @@ class HistoryView(MethodView):
     def get(self, body: dict=None):
         try:
             scenario_name = body.get('scenario_name') if body else None
-            size = body.get('size') if body else None
-            since = body.get('since') if body else None
-            until = body.get('until') if body else None
-            with_details = body.get('with_details') if body else None
-
-            return _get_session_context().server_manager.campaign_manager.get_scenario_history(scenario_name=scenario_name, size=size, since=since, until=until, with_details=with_details)
+            size = body.get('size', None) if body else None
+            since = body.get('since', None) if body else None
+            until = body.get('until', None) if body else None
+            since_history = body.get('since_history', None) if body else None
+            until_history = body.get('until_history', None) if body else None
+            with_details = body.get('with_details', None) if body else None
+
+            return _get_session_context().server_manager.campaign_manager.get_scenario_history(scenario_name=scenario_name, size=size, since=since, until=until,
+                                                                                               since_history=since_history, until_history=until_history, with_details=with_details)
         except Exception as exc:
             logger.exception(f"Failed to get scenario history (parameters: {body})")
             return str(exc), 500