holado 0.4.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

holado_python/common/tools/datetime.py

@@ -158,26 +158,51 @@ class DateTime(object):
             res = dt_value.strftime(dt_format)
         return res
     
-    
-    ### Conversions to/from timestamp
+    @classmethod
+    def _get_datetime(cls, dt):
+        res = None
+        if dt is not None:
+            if isinstance(dt, datetime.datetime):
+                res = dt
+            elif isinstance(dt, str):
+                res = DateTime.str_2_datetime(dt)
+            else:
+                raise TechnicalException(f"Datetime can be a datetime, a str containing a datetime, or None")
+        return res
     
     @classmethod
     def _get_epoch_datetime(cls, epoch):
         res = None
         if epoch is not None:
-            if isinstance(epoch, str):
+            if isinstance(epoch, datetime.datetime):
+                res = epoch
+            elif isinstance(epoch, str):
                 if epoch in ['EPOCH_1970', 'EPOCH_JULIAN_CNES', 'EPOCH_JULIAN_NASA']:
                     res = eval(epoch)
                 else:
                     res = DateTime.str_2_datetime(epoch)
-            elif isinstance(epoch, datetime.datetime):
-                res = epoch
             else:
                 raise TechnicalException(f"Epoch can be a datetime, a str containing a datetime, a str containing an EPOCH name, or None")
         return res
         
+    @classmethod
+    def _get_timestamp(cls, ts):
+        res = None
+        if ts is not None:
+            if isinstance(ts, float) or isinstance(ts, int):
+                res = ts
+            elif isinstance(ts, str) and (Converter.is_float(ts) or Converter.is_integer(ts)):
+                res = Converter.to_float(ts)
+            else:
+                raise TechnicalException(f"Timestamp must be a float|int or a string containing a float|int (obtained type: {Typing.get_object_class_fullname(ts)})")
+        return res
+    
+    
+    ### Conversions to/from timestamp
+    
     @classmethod
     def datetime_to_timestamp(cls, dt, epoch=None):
+        dt = cls._get_datetime(dt)
         epoch = cls._get_epoch_datetime(epoch)
         
         if epoch is None:
@@ -190,16 +215,9 @@ class DateTime(object):
         """
         Convert timestamp to UTC datetime
         """
+        ts = cls._get_timestamp(ts)
         epoch = cls._get_epoch_datetime(epoch)
         
-        if isinstance(ts, str):
-            if Converter.is_float(ts) or Converter.is_integer(ts):
-                ts = Converter.to_float(ts)
-            else:
-                raise FunctionalException(f"Timestamp is a string that doesn't contain a float|int (obtained timestamp: '{ts}')")
-        if not isinstance(ts, float) and not isinstance(ts, int):
-            raise TechnicalException(f"Timestamp must be a float|int or a string containing a float|int (obtained type: {Typing.get_object_class_fullname(ts)})")
-        
         res = datetime.datetime.fromtimestamp(ts, tz=datetime.timezone.utc)
         if epoch is not None:
             res = epoch + (res - EPOCH_1970)

holado_python/standard_library/ssl/resources/certificates/tcpbin.crt

@@ -2,20 +2,20 @@
 MIIDZTCCAk2gAwIBAgIBKjANBgkqhkiG9w0BAQsFADCBizELMAkGA1UEBhMCVVMx
 CzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMQ8wDQYDVQQKDAZ0
 Y3BiaW4xDDAKBgNVBAsMA29wczETMBEGA1UEAwwKdGNwYmluLmNvbTEjMCEGCSqG
-SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUwNjI2MTYxMzE3WhcN
-MjUwNjI3MTYxMzE3WjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
-DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAO4WKCcsF4eCjLUeUT3/3IbM8m0N
-Z5Fgmqe3K9lDOXFQa/dX98/gGPswQiWkJ3ALspYgDGnfqEQEc5kBrTNpom0xoWPD
-vgv7M4O222bMtVvXyvE5/Absw/VYGhW5KGln2k/4hEl0Xl2kS7P0KMlrczrjDyqW
-NhGMvgWfSSF1D1fP1tx4E/74TnCrUQy332wlprxB567kIlPLUe4zbNT1PvAhXXj1
-r9kKYBy6ontb+VWnrYraD3YhLOsez3OocY32JfvB8jFgjaxKTFMCchOJaFuFZEl8
-/wCPawwCdG8aIvC+EVuttbA3F/s3vDjQRTKW9WJ1KoJhRIwYbwwmvNIycMkCAwEA
-AaNCMEAwHQYDVR0OBBYEFMXW798gAD4iFP15opS+N49NX/9HMB8GA1UdIwQYMBaA
-FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQAtxMjai8tc
-VEA0TTPeDplTyDUYZqwnb+wbxOmb8+CTwt7hj/o1vDS82QGoKINiHyRGhyJrfiTQ
-6TqBRxZMt52IdYwQoAMDnxyjxLdeVr0RNbxGziWBs3fjjahaEX/BMqzu5wd4mcpi
-UUmauULmYtY3vKiw8wsUEEkzzMM3fNJklMdMcR47cbH783FuJ7clhYaE/pJlq8RD
-wNIgume1u3BstRpIHafuZOy4Rg2nDiIuQoIORq7n8eRfgU9ZxVL7kZOgPFiTuokq
-0EgnEhwOTUahO6aFpN9j/wCIANLrf1bZWw7v80bno7aFQ1XOm2RW5yJywkc7LFqi
-Dia/obmoNitb
+SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUwNzI4MTUyNDU5WhcN
+MjUwNzI5MTUyNDU5WjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANUBILPvNb3OupTXJwW2AxwQhBWK
+mvQlRHiDEcQM1EHnhH1DjANCSgPoV6ngaGa1Vt+p5Qe1uXc54eJ7y5yJ00i8Lg5c
+L6t9fvhfjXCyWqh78XeL9jVTlwV9Bpz0BsfO91SSC7VEu/QA0syJGXTxdopnH0O0
+/Wy9IX+SeZQzKscwk2G8ceVB2R5bi+48u3BE5UuzLsyZaVfzMS4zwHm2ADY3wj02
+EmmTtQ0OMF8oxH1BP+UXwEX+Exen9i0VakBCgJqYzvy3tHrMZKylrVq5st46keSI
+7A666NMpEhMLI5kz25EDKlr7KVhim9jlfdUo1ASqN/7Bln158ycN0E6dObUCAwEA
+AaNCMEAwHQYDVR0OBBYEFGrQ9rG00D/5IFX1xGLoKNNXMKn4MB8GA1UdIwQYMBaA
+FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQACxSfDvc4P
+osb9nP+UZH7B3D895N6OG1f1HQcBHu5V6FxiUSmLFetdUOwV3DeHUHkX2uQ6gWrt
+EuhMI/BZQBI8tZvAe95Clfyxi0qGKoa0deyUdvAqdUoPGZJ9gAoSR/hb5e9zFjPk
+p5hEpwZnbQsCABlSwc3oS74W5iuelOZmA6elR6CDEnvlNlX/0FYXzbyKrNtSfDFG
+MgZv0lLSKkdtm0dgR7wgWmWf52ofG4hzDA9e1GtrAJ4SjVPy9hpOQu7syCNk8uCi
+LKmXoJ1iVPB46QStpwNjLb6Tgre92py1QdKGsiV+26X+KQh1G4bcD6YZQ6EDXwq9
+Hx7OyvVk0y8z
 -----END CERTIFICATE-----

holado_python/standard_library/ssl/resources/certificates/tcpbin.key

@@ -1,28 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDuFignLBeHgoy1
-HlE9/9yGzPJtDWeRYJqntyvZQzlxUGv3V/fP4Bj7MEIlpCdwC7KWIAxp36hEBHOZ
-Aa0zaaJtMaFjw74L+zODtttmzLVb18rxOfwG7MP1WBoVuShpZ9pP+IRJdF5dpEuz
-9CjJa3M64w8qljYRjL4Fn0khdQ9Xz9bceBP++E5wq1EMt99sJaa8Qeeu5CJTy1Hu
-M2zU9T7wIV149a/ZCmAcuqJ7W/lVp62K2g92ISzrHs9zqHGN9iX7wfIxYI2sSkxT
-AnITiWhbhWRJfP8Aj2sMAnRvGiLwvhFbrbWwNxf7N7w40EUylvVidSqCYUSMGG8M
-JrzSMnDJAgMBAAECggEAB6aan7ehAe/GCcPxpGZmdcZ8O9jkbR2HmsAeHps0a1nE
-PmyLQBjZdKj2VzNROR6HHJ/nBjfztkvWUyJkqHRKjeu8XfJaVxQ5cZAcuM73PP5Q
-PTQ5zxcorOep3uzWSZzWvR8lUR72MVgoPp4n+WEEkO3e/OVa03GMYa3esb6LQa0S
-QcPkMwsxgPZQ1V9s85IIyVBn2ebbOhDbU1mz0FhzWtJ18Jikm0KhJuHUwwXAwO4H
-aINMbSkckOtyJwQ2Iu2Me8/ZiFLUTCMkdym2fb3jkWS+uiHxJye0Pg4AnXtIZE+W
-cUwwrZE+TnhodiqoAc3CgD0ZkqIpp07KMl7FM9jGaQKBgQD7vQHHBHKLFbW6e9dT
-ruZR+4kwOeTA1jzKlr2D8/Y6XJAPVG2UCn1oxfMTp6NkqC9nmalct4FH6lzpleZG
-Duwm2kxhmI+kxPj5MXH/MDlMSL3nw06mQD8tWUM9u6M73Rm6DMg5VMH3WqcUzycl
-4FZDl0LcABDZsP+3f2A34l30uwKBgQDyHfxC5bA93cbvVzo3Qd5I611oKgg9J3vh
-/5I2bT3HKCIb7ruAthbDIO5/5K0ufIIzKAxcI9EJd2ViSO2MHhMQOfkrcKh6Kzb+
-u61r52ZRKN1aI2UiZzqtUTpkOetevRh1WMmH0CmItxZ/OpqDq/2OyQ6XedZWvd5t
-/PockMZaSwKBgBtZXWgRw5/4q9Wmvq4Iwl0FxtHGeGO64r/fwJclWgrdI4mG0qDS
-wu0vFEl+XPICk6Pdvdik1xbJD28RKgNSe7V84e94c6KjA6mPBaODybXP8VHMli7Z
-rANxPyzlxcYrLzBXUylnW+tTnfNUzhv/U1/kfw8HsszzvdRhskJgBXUhAoGBAIHU
-sHwS/PH/5fhcFvyglpkVlS4RM//PF3A2Auqqo7ETBU9jMiqv+f7CvwHX10IRRCQ4
-eoBCOIrR+oy8vJ0hV2mhHMs9iyqP19q7OyCcolItDp2SU14iauWbpCswn9Vaoy3x
-4YexiUQloaux+j9XUA1sJSX3EIfNIuRp/piozaSHAoGAWODO4Ug0aU3SxHoj3muQ
-dgQmAcwNKif7UOWCcB/6qQFDMqDqiWuqPX1x7sUYjN61Dd2AwoOanI8phDsp2R4/
-7ywBy2es5ePrk5Ma332QA/6rxkLVXGaGEV4mCVziF4PEGsbMZzx7YDIZoXUwuKw0
-JLVTXQhAmlEnNoMi1T/zLB8=
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDVASCz7zW9zrqU
+1ycFtgMcEIQVipr0JUR4gxHEDNRB54R9Q4wDQkoD6Fep4GhmtVbfqeUHtbl3OeHi
+e8ucidNIvC4OXC+rfX74X41wslqoe/F3i/Y1U5cFfQac9AbHzvdUkgu1RLv0ANLM
+iRl08XaKZx9DtP1svSF/knmUMyrHMJNhvHHlQdkeW4vuPLtwROVLsy7MmWlX8zEu
+M8B5tgA2N8I9NhJpk7UNDjBfKMR9QT/lF8BF/hMXp/YtFWpAQoCamM78t7R6zGSs
+pa1aubLeOpHkiOwOuujTKRITCyOZM9uRAypa+ylYYpvY5X3VKNQEqjf+wZZ9efMn
+DdBOnTm1AgMBAAECggEARaCzvv3P9HbSWPsnv18rDw57DsubMXnJMxetRAfpjo2O
+qp/c8efGaBaYKWi41/IpLr3Lp0SJFuct5qoO+eG31kvlRj5uOsGwMqKRiqhSqEaz
+vR9cYTws3tdqxP2kBcaq5NNEzoFkazOltMSQNMEFveJNvwU33kbI33nTElXTgv7O
+EPo/+Xz4Vktk3F5yFHTQi+cIiql6F4QOHmKxMLKRFt85IJ2UCK+aJc1ehzXeYWcZ
+YQbD4Xp0TpWopiv6YMJ+M+ibe+SjO9mA2nfEPn7s6DMEDRLNgxJjAkzuN3TACddY
+6jyyqVPN14axxWq2VMmmLPpMjBf4aaLDJPu07FlmVQKBgQD3lshvGvcgNBFlVjzB
+DMYpfFyk2QUUrBgj1r0bpf19vvpRr69HufkhaBCOdMILJCYud1CM7nMwM27oOKeO
+SGUGhaGBAAUa0eDgNyqxRX1lnClI7aUiAQlINoIBk6jb5qD62qnhHdoHCR4Ru8LY
+wdRhpf5w+jxLW/+PwK1Pv6tOnwKBgQDcPZJVgnlysfYthwcPFjqkz1riHtx8hh3U
+8gYqa7yZWCenvSNQZphVCOiY0J7wzcDyDBZF+AAFQjJAlohC/YfnrjA0a6lr2bzq
+tqWmGefoXVmK1JuOztnou4gSj27POY3EJTYhjaQ1hVuihp9Fo33/HmMzPfgQpC6/
+s/f3eEvbKwKBgQCP4CtxhTX+nMNPJCIB/S5ahU5A7WwqaydMDEmwe3EnVYeZWIJ/
+J+9CHnsgjXEFkGgvsF46x4ZgiEL255VW9XLfq2AC2sQcpcIMCYLhqQQJvAmxu4eu
+jvOZ5zL9P5Vs1ETQAamei/5bAE1c+MNtupV0eUW22XOYR0nne4w7P6KI+QKBgH6G
+WNULGd5MYpMRKXr/WD1qalnRRPW8ztKRH/2q2zR1MoLo46rC5eykK4vu/gB1E816
+KCmWKdzbhKcaU7m4kSUGKudSmog9FIz61PsxksspJdHeBmfqacGMSsXu5Mfj1o/C
+mPB5wMaGkHg0QrftDutLd83uYd6dk8XKDEB9OYb1AoGBAOzSZdMyFqhcks4y2UyO
+UN7XXJojGPdYVRlQcVtlsYARqdqzKDzRQ0xmchU6y8JpqkPC700UvWrDHjLYJe3N
+QBLk19dNseNEssiwESerWJVEk4QniGr2BnLboB3oWnUAvR+x5mVZJ1L9lXpFDmG5
+QEuVAN4VEgS37CP5U7+5MzJi
 -----END PRIVATE KEY-----

holado_rabbitmq/tools/rabbitmq/rabbitmq_blocking_client.py

@@ -47,7 +47,14 @@ if RMQClient.is_available():
         
         def close(self, reply_code=0, reply_text="Normal shutdown"):
             self.__is_closing = True
-            super().close(reply_code=reply_code, reply_text=reply_text)
+            try:
+                super().close(reply_code=reply_code, reply_text=reply_text)
+            except ValueError as exc:
+                if self.__rapid_close and "file descriptor cannot be a negative integer" in str(exc):
+                    # This exception can appear during channel close with rapid close option
+                    pass
+                else:
+                    raise exc
         
         def _flush_output(self, *waiters):
             if self.__rapid_close and self.__is_closing:
@@ -60,11 +67,18 @@ if RMQClient.is_available():
             """
             Override start_consuming method to add time_limit parameter.
             """
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"[{self}] Start consuming...")
             self.__is_consuming = True
             try:
                 if not self.__rapid_close and time_limit is None and time_limit_on_stop is None:
                     # Use pika implementation
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"[{self}] Start consuming with Pika implementation")
                     return super().start_consuming()
+                else:
+                    if Tools.do_log(logger, logging.DEBUG):
+                        logger.debug(f"[{self}] Start consuming with HolAdo implementation")
                     
                 # Check if called from the scope of an event dispatch callback
                 with self.connection._acquire_event_dispatch() as dispatch_allowed:
@@ -81,14 +95,22 @@ if RMQClient.is_available():
                     if self.__is_stopping_consuming:
                         t_limit = time_limit_on_stop
                         if self.__rapid_close and t_limit is None:
-                            # To ensure a rapid close, time_limit shouldn't be None, set it to 0
+                            # To ensure a rapid close, time_limit shouldn't be None, set it to 0 while stopping consuming
                             t_limit = 0
                     else:
                         t_limit = time_limit
+                    if t_limit is None and self.__rapid_close:
+                        # To ensure a rapid close, time_limit shouldn't be None, set it to 0.1s as a compromise between rapidity and resource cost 
+                        t_limit = 0.1
+                    
+                    if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+                        logger.trace(f"[{self}] Processing data events (time_limit={t_limit})")
                     self._process_data_events(time_limit=t_limit)
             finally:
                 self.__is_consuming = False
                 self.__is_stopping_consuming = False
+                if Tools.do_log(logger, logging.DEBUG):
+                    logger.debug(f"[{self}] Finished start consuming")
         
         def stop_consuming(self, consumer_tag=None):
             self.__is_stopping_consuming = True

holado_rabbitmq/tools/rabbitmq/rabbitmq_client.py

@@ -562,12 +562,12 @@ class RMQConsumer(DeleteableObject):
                         super().__init__(f"[{self.name}] Stop consuming on consumer {self.consumer_tag}")
                         
                     def _process(self2):  # @NoSelf
-                        time.sleep(0.1)
-                        GcManager.collect(max_duration_until_next_collect_in_seconds=0)
                         return self.is_consuming
                 redo = StopRedo()
                 redo.redo_while(True)
                 redo.with_timeout(30*60)    # Timeout of 30 min
+                redo.polling_every(0.01)     # Wait 0.1 s beetween each try
+                redo.with_process_in_thread(False)      # Run process in thread is not needed
                 redo.execute()
                 
                 if Tools.do_log(logger, logging.DEBUG):

holado_report/report/builders/failure_report_builder.py

@@ -0,0 +1,129 @@
+
+#################################################
+# 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.
+#################################################
+
+import logging
+from holado_report.report.builders.report_builder import ReportBuilder
+from holado_core.common.tools.tools import Tools
+from holado_core.common.exceptions.technical_exception import TechnicalException
+import json
+
+logger = logging.getLogger(__name__)
+
+
+
+class FailureReportBuilder(ReportBuilder):
+    """Failure report builder
+    Supported formats: 'txt', 'json', 'xml'
+    """
+    def __init__(self, filepath, file_format='xml'):
+        if file_format not in ['txt', 'json', 'xml']:
+            raise TechnicalException(f"Unmanaged format '{file_format}' (possible formats: 'txt', 'json')")
+        
+        self.__filepath = filepath
+        self.__file_format = file_format
+        self.__failures = {}
+        
+    def build(self):
+        '''
+        The file is built after each scenario
+        '''
+        pass
+        
+    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)
+        
+        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] = []
+            
+            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"    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))
+                msg_scenario = "\n".join(msg_list)
+                
+                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}",
+                    'scenario': f"{scenario.feature.name}  =>  {scenario.name}",
+                    'report': scenario_report.report_path,
+                    'tags': "-t " + " -t ".join(scenario.feature.tags + scenario.tags),
+                    }
+                self.__failures[step_error_message].append(scenario_info)
+            else:
+                raise TechnicalException(f"Unmanaged format '{self.__file_format}' (possible formats: 'txt', 'json')")
+            
+            self.__update_file()
+    
+    def __update_file(self):
+        with open(self.__filepath, "wt") as fout:
+            if self.__file_format == 'txt':
+                for failure, scenarios_messages in self.__failures.items():
+                    fout.write(failure + "\n")
+                    fout.write("\n")
+                    for msg in scenarios_messages:
+                        fout.write(Tools.indent_string(4, msg) + "\n")
+                        fout.write("\n")
+            elif self.__file_format == 'json':
+                json_str = json.dumps(self.__failures, ensure_ascii=False, indent=4)
+                fout.write(json_str)
+            elif self.__file_format == 'xml':
+                self.__file_write_failures(fout, self.__failures, sort_by_nb_scenario=True)
+            else:
+                raise TechnicalException(f"Unmanaged format '{self.__file_format}' (possible formats: 'txt', 'json')")
+
+    def __file_write_failures(self, fout, __failures, sort_by_nb_scenario=True):
+        fout.write("<failures>\n")
+        
+        if sort_by_nb_scenario:
+            for error_message, scenarios in sorted(self.__failures.items(), key=lambda item:-len(item[1])):
+                self.__file_write_failure(fout, error_message, scenarios)
+        else:
+            for error_message, scenarios in self.__failures.items():
+                self.__file_write_failure(fout, error_message, scenarios)
+    
+        fout.write("</failures>\n")
+    
+    def __file_write_failure(self, fout, error_message, scenarios):
+        msg_list = []
+        
+        msg_list.append("    <failure>")
+        
+        if "\n" in error_message:
+            msg_list.append(f"        <error_message>")
+            msg_list.append(Tools.indent_string(12, error_message))
+            msg_list.append(f"        </error_message>")
+        else:
+            msg_list.append(f"        <error_message>{error_message}</error_message>")
+        
+        msg_list.append(f"        <scenarios>")
+        for scenario_info in scenarios:
+            msg_list.append(f"            <scenario>")
+            for key, value in scenario_info.items():
+                msg_list.append(f"                <{key}>{value}</{key}>")
+            msg_list.append(f"            </scenario>")
+        msg_list.append(f"        </scenarios>")
+        
+        msg_list.append("    </failure>")
+        
+        msg = "\n".join(msg_list) + "\n"
+        fout.write(msg)
+    
+
+
+

holado_report/report/report_manager.py

@@ -23,6 +23,7 @@ from holado_report.report.builders.short_scenario_failed_report_builder import S
 from holado_report.report.reports.base_report import BaseReport
 from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
 from holado_report.report.builders.summary_scenario_report_builder import SummaryScenarioReportBuilder
+from holado_report.report.builders.failure_report_builder import FailureReportBuilder
 # from holado_core.scenario.scenario_duration_manager import ScenarioDurationManager
 
 logger = logging.getLogger(__name__)
@@ -65,6 +66,9 @@ class ReportManager(BaseReport):
             fn = self.get_path("report_summary_scenario_all.txt")
             self.add_report_builder(SummaryScenarioReportBuilder(fn))
             
+            fn = self.get_path("report_failures.xml")
+            self.add_report_builder(FailureReportBuilder(fn))
+            
             fn = self.get_path("report_short_scenario_failed.txt")
             self.add_report_builder(ShortScenarioFailedReportBuilder(fn))
             

holado_rest/api/rest/TODO.txt

@@ -1,2 +1,2 @@
-Client with library "requests"
 Client with library "httpx"
+

holado_rest/api/rest/rest_client.py

@@ -16,6 +16,8 @@ from holado_core.common.exceptions.technical_exception import TechnicalException
 import logging
 from holado_core.common.tools.tools import Tools
 import json
+from holado_core.common.tools.converters.converter import Converter
+from holado_json.ipc.json_converter import JsonConverter
 
 logger = logging.getLogger(__name__)
 
@@ -116,17 +118,27 @@ class RestClient(object):
         if self.__headers:
             res['headers'] = self.__headers
         if request_kwargs:
-            # Ensure data is in json string format
-            if 'data' in request_kwargs:
-                data = request_kwargs.pop('data')
-                if data is not None and not isinstance(data, str):
-                    data = json.dumps(data)
-                res['data'] = data
-            
+            # Add all kwargs except data
+            data = request_kwargs.pop('data', None)
             for key in list(request_kwargs.keys()):
                 if key in res and isinstance(res[key], dict):
                     res[key].update(request_kwargs.pop(key))
             res.update(request_kwargs)
+            
+            # Ensure data is in right format
+            if data is not None:
+                # Convert data to json object for types not supported by requests.request
+                if not (isinstance(data, str) or Converter.is_dict(data) or Converter.is_list(data) or isinstance(data, bytes) or Converter.is_file_like(data)):
+                    converter = JsonConverter()
+                    data = converter.to_json(data)
+                
+                # Convert data to string for some content types
+                if not isinstance(data, str):
+                    content_type = res['headers']['Content-Type'] if 'headers' in res and 'Content-Type' in res['headers'] else None
+                    if content_type is not None and 'application/json' in content_type:
+                        data = json.dumps(data)
+                res['data'] = data
+            
         return res 
         
         

holado_rest/tests/behave/steps/api/rest_client_steps.py

@@ -112,8 +112,7 @@ if RestClient.is_available():
         # Manage request arguments as step table
         if hasattr(context, "table") and context.table is not None:
             table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
-            json_obj = ValueTableConverter.convert_name_value_table_2_json_object(table)
-            data = json.dumps(json_obj)
+            data = ValueTableConverter.convert_name_value_table_2_json_object(table)
         
         # Manage request arguments as json text
         # Manage data as json text

holado_rest/tests/behave/steps/private/api/rest_steps.py

@@ -17,6 +17,7 @@ from holado_test.behave.behave import *  # @UnusedWildImport
 import os.path
 import logging
 from holado_test.scenario.step_tools import StepTools
+from holado_django.server.django_server import DjangoServer
 
 logger = logging.getLogger(__name__)
 
@@ -40,22 +41,19 @@ def step_impl(context, var_name):
     var_name = StepTools.evaluate_variable_name(var_name)
     
     here = os.path.abspath(os.path.dirname(__file__))
-    manage_path = os.path.normpath(os.path.join(here, "..", "..", "tools", "django", "api_rest", "manage.py"))
-    cmd = f"python {manage_path} runserver"
+    django_project_path = os.path.normpath(os.path.join(here, "..", "..", "..", "..", "..", "..", "..", "tests", "behave", "test_holado", "tools", "django", "api_rest"))
     
     execute_steps(u"""
-                      Given {var_name} = new command '{cmd}' with
-                          | Name        | Value |
-                          | 'auto_stop' | True  |
-                          | 'blocking'  | True  |
-                          | 'name'      | 'internal REST server' |
-                      Given run command {var_name}
-                      Then command {var_name} has status Ready
-                      When wait 5 seconds
-                      Then command {var_name} has status Running
-                      """.format(cmd=cmd, var_name=var_name))
-      
+        Given {var_name} = new Django server
+            | Name                   | Value                          |
+            | 'name'                 | 'REST server for holado tests' |
+            | 'django_project_path'  | '{django_project_path}'        |
+            | 'port'                 | 8000                           |
+        When start (Django server: {var_name})
+        """.format(var_name=var_name, django_project_path=django_project_path))
     
+
+
 @Given(r"(?P<var_name>{Variable}) = new internal REST client")
 def step_impl(context, var_name):
     var_name = StepTools.evaluate_variable_name(var_name)

holado_system/system/command/command.py

@@ -20,6 +20,9 @@ import time
 from enum import IntEnum
 from holado_core.common.exceptions.functional_exception import FunctionalException
 import copy
+import signal
+from holado_core.common.tools.tools import Tools
+from holado_multitask.multitasking.multitask_manager import MultitaskManager
 
 logger = logging.getLogger(__name__)
 
@@ -31,6 +34,7 @@ class CommandStates(IntEnum):
     Success = 3
     Error = 4
 
+
 class Command(threading.Thread):
     """
     Execute a command in a thread.
@@ -58,6 +62,7 @@ class Command(threading.Thread):
         self.__callback_delay_ms = None
         self.__external_parameters = {}
         self.__subprocess_kwargs = subprocess_kwargs
+        self.__stop_signal = signal.SIGTERM
 
  
     @property
@@ -94,29 +99,38 @@ class Command(threading.Thread):
             return self.__process.returncode
         else:
             return None
-  
+    
     @property
     def callback(self):
         return self.__callback
- 
+    
     @callback.setter
     def callback(self, callback):
         """Set callback called when execution end."""
         self.__callback = callback
- 
+    
     @property
     def callback_delay_ms(self):
         return self.__callback_delay_ms
- 
+    
     @callback_delay_ms.setter
     def callback_delay_ms(self, delay_ms):
         """Set callback delay in ms."""
         self.__callback_delay_ms = delay_ms
-  
+    
     @property
     def external_parameters(self):
         return self.__external_parameters
-       
+    
+    @property
+    def stop_signal(self):
+        return self.__stop_signal
+    
+    @stop_signal.setter
+    def stop_signal(self, stop_signal):
+        """Set stop signal."""
+        self.__stop_signal = stop_signal
+    
     def run(self):
         logger.debug("Call command: {}".format(self.cmd))
         try:
@@ -139,7 +153,7 @@ class Command(threading.Thread):
             
             self.__stdout = ""
             self.__stderr = ""
-            while (self.__process.returncode is None):
+            while self.__process.returncode is None:
                 # Wait a small time and in same time yield this thread
                 time.sleep(0.001)
                 
@@ -175,7 +189,7 @@ class Command(threading.Thread):
                     logger.debug(f"Command [{self.cmd}] has finished, calling callback...")
                     self.callback(self)
             elif self.error is not None:
-                logger.error(f"Command [{self.cmd}] has finished on error : {self.error}")
+                logger.error(f"Command [{self.cmd}] has finished on error: {self.error}")
             elif self.state == CommandStates.Error:
                 logger.error(f"Command [{self.cmd}] has finished on error code {self.return_code} and stderr: {self.stderr}")
             elif self.state != CommandStates.Success:
@@ -208,13 +222,21 @@ class Command(threading.Thread):
             raise FunctionalException(msg)
         
     def kill(self):
+        # Note: kill is equivalent to terminate in subprocess implementation
         if self.state == CommandStates.Running:
             self.__process.kill() 
                        
     def terminate(self):
         if self.state == CommandStates.Running:
             self.__process.terminate()
-
+    
+    def stop(self):
+        if self.state == CommandStates.Running:
+            if Tools.do_log(logger, logging.DEBUG):
+                logger.debug(f"Stopping command [{self.cmd}] with signal {self.__stop_signal} and PID {self.__process.pid}")
+            
+            MultitaskManager.kill_process(self.__process.pid, sig=self.__stop_signal, do_kill_children=True, recursively=True)
+    
     def __repr__(self):
         return pprint.pformat({'cmd' : self.cmd,
                                'is alive' : self.is_alive() })

holado_system/system/global_system.py

@@ -14,9 +14,7 @@
 import logging
 from holado.common.handlers.enums import AutoNumber
 import platform
-from holado_system.system.command.command import Command, CommandStates
 from holado_core.common.exceptions.technical_exception import TechnicalException
-from holado_system.system.command.command_result import CommandResult
 import time
 import os
 from holado_core.common.tools.tools import Tools
@@ -87,6 +85,9 @@ class GlobalSystem(object):
 
     @classmethod
     def execute_command(cls, cmd, do_log_output=False, do_raise_on_stderr=False):
+        from holado_system.system.command.command import Command, CommandStates
+        from holado_system.system.command.command_result import CommandResult
+        
         command = Command(cmd, do_log_output=do_log_output, do_raise_on_stderr=do_raise_on_stderr)
         command.start()
         command.join()
@@ -183,5 +184,4 @@ class GlobalSystem(object):
                 return port
         return None
     
-    
     

test_holado/environment.py

@@ -19,10 +19,12 @@ import logging
 
 # Add testing solution sources paths
 here = os.path.abspath(os.path.dirname(__file__))
-sys.path.append(here)
-holado_path = os.path.normpath(os.path.join(here, "..", "..", ".."))
-sys.path.append( os.path.join(holado_path, "src") )
-sys.path.append( os.path.join(holado_path, "tests", "behave") )
+sys.path.insert(0, here)
+
+# Add HolAdo source paths (needed when using a clone of HolAdo project)
+from initialize_holado import insert_holado_source_paths
+insert_holado_source_paths()
+
 
 # Configure HolAdo
 import holado