holado 0.2.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

holado_python/standard_library/ssl/resources/certificates/rootCACert.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIID7jCCAtagAwIBAgIJAJNpPsX/1B+fMA0GCSqGSIb3DQEBCwUAMIGLMQswCQYD
+VQQGEwJVUzELMAkGA1UECAwCQ0ExFjAUBgNVBAcMDVNhbiBGcmFuY2lzY28xDzAN
+BgNVBAoMBnRjcGJpbjEMMAoGA1UECwwDb3BzMRMwEQYDVQQDDAp0Y3BiaW4uY29t
+MSMwIQYJKoZIhvcNAQkBFhRoYXJyeWJhZ2RpQGdtYWlsLmNvbTAeFw0xOTA1MDUw
+NjI3NTlaFw0yOTA1MDIwNjI3NTlaMIGLMQswCQYDVQQGEwJVUzELMAkGA1UECAwC
+Q0ExFjAUBgNVBAcMDVNhbiBGcmFuY2lzY28xDzANBgNVBAoMBnRjcGJpbjEMMAoG
+A1UECwwDb3BzMRMwEQYDVQQDDAp0Y3BiaW4uY29tMSMwIQYJKoZIhvcNAQkBFhRo
+YXJyeWJhZ2RpQGdtYWlsLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAK0LTwoX+/d/QKJuIuvUw2gUBGwjeX8DM3OqagcmZutlq9VfSW1pkzNhCpFU
+1JQh/bJ3P97VTZn75H2zL4BQnAXaPSRoi0wOFsoEhzbIOAFELPq2TMoY9lvOLO9n
+4yt4Pz7AbFLhPDeltqb91S/18hN1YmVTDEuMCz4OGnJOf5NbmuVwmjMcDWiOwmjp
+dBYlwCMn/TRB3wUPSwafLef9EIJfm4uL0ruH3Rlhj8Lktt0YTvrA7M6URMcgFqYG
+wNNsYa9X88Js1nxlryvTputbVf6zL35S7CvTGc6fft/pfdSAu2KcmOd+C0dew1GI
+daM9tqTiqi6Tg+IA2t4eaA3tR2MCAwEAAaNTMFEwHQYDVR0OBBYEFOLuMowBSAZf
+V5v82LmlaIIOvU/DMB8GA1UdIwQYMBaAFOLuMowBSAZfV5v82LmlaIIOvU/DMA8G
+A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAEj3o18u8FQDrQu89Etk
+4sQgiZxtQ0C3OglCXP9kRGSBt8Ymd/2bmpGK2TsEpACkfpJLaFRVPek2302YQ8mc
+oj63wPTDYx1P/BSH+dPvDUXI9SePXcrFAPq9YemteQHE+WZ/PFe0wAq1ehziWgqQ
+OiMb1wydDbaRZF6jPPMW7cHCiUYceLBRO0ZTe9CsUPYw6A78QZnO6P7Cuc1SwkNv
+uejCGTfv5HP72/Jm24ifAMOoWXALmvIIAnOVTwpPEX2nEnr9H1S8Psi3+mqkGyC1
+RQXprzHkflCKHxjiNfNguHeC3x6l0LGWEShcemyDWCsTgCYNX6RMTWWcug3Vb/70
+BSs=
+-----END CERTIFICATE-----

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

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDZTCCAk2gAwIBAgIBKjANBgkqhkiG9w0BAQsFADCBizELMAkGA1UEBhMCVVMx
+CzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMQ8wDQYDVQQKDAZ0
+Y3BiaW4xDDAKBgNVBAsMA29wczETMBEGA1UEAwwKdGNwYmluLmNvbTEjMCEGCSqG
+SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUwNTI4MTMxODIwWhcN
+MjUwNTI5MTMxODIwWjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANvo9G/86es6qoCHTum0RAoqAAiY
+qnOCLgXmamgfQgbfYoBIkNTBBVzsZyoZIY4QuuO8E07VmbrnH23czCSAO5akPb7D
+teotATqDf4My0Ybht62nLoxhHBb9jrzSgv4+04gy/W6wu5diyfeY8BNopHkUkmEN
+WhmGkP9s9npUGaEfEeasuiB1JMkAEOWnw+kHqE3Us+4Av4Mht6srswst3B90WCIV
+Rry48gRJS4qZoAk1dwZHIcYSOfMJ8Pu69wS1qjRwRPLc3dfnUs2E3dAx1FDxDBkK
+eQ73VUm64A5AXLYRk3PvgPwbcgerkLAnYAb5o8YJmyufGXKQNhmZxcCt+t0CAwEA
+AaNCMEAwHQYDVR0OBBYEFDgjXXI6juiInalFSZEZM6BcEW9UMB8GA1UdIwQYMBaA
+FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQAu6SJ3OT6D
+fhjfg4wRMHZVsaYSF6Kwe0RNt6izRkv5MUGi6Ew0SK1Mm+qxE51G3aaVCE4G+P1e
+ACOiBL55saWDJtdng2VTKhUsFxIk2c/t+tuh7ttV7i0yGbaLGDP0N2FveBhKj/5d
+SaPpAQvZ1rFhXpUU1jQr+xi5pP/iOPH02O8A8VgHyGebDVXs8iWMHjozOrRhgQVJ
+YAl5lyYs+aj199p9ixwY3RPPWbUcggvAipv9bu6uEEIWMOMMERM2P7yFYaWJBcw5
+A/Uqu2bBLmOu9/qmlEj2uQfTeVhnoT/bZBfmPcrL64tHjw7G5u0WuooPNTI23z28
+3ttcr+fDbDR4
+-----END CERTIFICATE-----

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

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDb6PRv/OnrOqqA
+h07ptEQKKgAImKpzgi4F5mpoH0IG32KASJDUwQVc7GcqGSGOELrjvBNO1Zm65x9t
+3MwkgDuWpD2+w7XqLQE6g3+DMtGG4betpy6MYRwW/Y680oL+PtOIMv1usLuXYsn3
+mPATaKR5FJJhDVoZhpD/bPZ6VBmhHxHmrLogdSTJABDlp8PpB6hN1LPuAL+DIber
+K7MLLdwfdFgiFUa8uPIESUuKmaAJNXcGRyHGEjnzCfD7uvcEtao0cETy3N3X51LN
+hN3QMdRQ8QwZCnkO91VJuuAOQFy2EZNz74D8G3IHq5CwJ2AG+aPGCZsrnxlykDYZ
+mcXArfrdAgMBAAECggEAe76UfcfloTY752M8ZonHl6iWqD+v+puQZkWILtsX/mIJ
+PYKX7QBIkkd8rdXCafzEDY4xlzTe8qtHpjyOqyN1ZIk7LXNXlFSK0nBYem1INgwh
+nZfru5aRheZcQah7ibG0unlm3riYdtFiMO9geKtzkaafz/kBcEemo/SepatZWK3m
+DQX6okkpHh04GZNIO52K2QCaYpmj14fXIi2p5M4+KD+gmYbXhkmzNdcjz2l/wkqo
+SziZf31nzuoHd6FuQ6vAsmXU/m6jW7Nll0wsxTm5Ynw5SoIrAbreJJmSSD8o2Shj
+mvzWlurk1SgOhtoHP+AaVAn454x/Fn7+8u0f5ptNyQKBgQDvKc/3etCi22ntlgQM
+dIwxbUPnmSvwejpMPOq3kMGTQWUJcKFinbPC28s/lJGzVjMsH5VisjiprCt3TXGN
+XwmLNaUycWN3po9HyLSndAjHWM4aQ3yTOFKfLFEDUhKi8Dxy995KmHhgSSHd65qM
+PvnPhITZWfKLkItCOmNEULxE8wKBgQDrZCji91ztgNyN3MHDGN2o854lAvWc1l6s
+4L8ZwU/RCNYyvMkdhadASzLwVC44q/6txGjTHGjnJPdkzV2u+WsPVWG2uCaD9PV1
+3L8wyG9sJ2YoJE5QcAQ+1J+rRN3fluzSKFiQNDpf7C5YqCPvk7C7lXFllGHM6FmF
+hoYbyIb07wKBgQDKaF+qulViz0FqIwFQLT8NAcVrd7W5MyitpwyayLcbUkgZYioj
+lQYzDuOH7swUtApg+GXsfpr39k9fC7rjg6BHIeKqu04MUHmIrjM+WTSoyd68WYtP
+6WX7cn0py0ccgScXwfFuvnV6P8qaz7Afq5iuaSAp9zcPqQhCx7mFcrKzwwKBgQCo
+VH3woNgxd59BS4a8j8GjmmOTMCSYPayCkE3Yiyca4ujaa6qek/9guOX6exh6qnR7
+qyMTJRPXh9XqnfnKsM5grrwrwFC6uKf32x5WMl+LxjkFp8DhQNmoXMC554uK4xED
+0JpUtSSxh+I0wDjCkKkn29y1uYCe2eF63RJ2N9ZavQKBgQCbHI/bMIZw/fsaijg3
+676mpQqFPiQdXTogw8UWzZBAvP6eQOnqQ9aw4tJt6OZWnwCDMwXrEYk3H8qisZl7
+ou63o5t8bTrU4C6e1VIQ1XuQM4FEpx6/TFwBG2FXkgzGHUpHlR9+woxqvmQgfsiW
+tEJ/TZv7bU6s9FRLTzMspp+tIA==
+-----END PRIVATE KEY-----

holado_python/standard_library/ssl/ssl.py

@@ -13,13 +13,15 @@
 
 import logging
 import ssl
-from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.tools.tools import Tools
 from holado_json.ipc.json import set_object_attributes_with_json_dict
 from holado_core.common.exceptions.technical_exception import TechnicalException
 import os
 import copy
 from ssl import Purpose
+from holado_system.system.command.command import Command, CommandStates
+from holado.common.context.session_context import SessionContext
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -32,37 +34,67 @@ class SslManager(object):
     """
     
     @classmethod
-    def new_ssl_context(cls, server_side=False, flat_kwargs=None):
+    def __get_path_manager(cls):
+        return SessionContext.instance().path_manager
+    
+    @classmethod
+    def new_ssl_context(cls, server_side=False, ssl_kwargs=None, context_kwargs=None):
         res = None
         
-        if flat_kwargs is None:
-            flat_kwargs = {}
-        kwargs = copy.copy(flat_kwargs)
+        if ssl_kwargs is None:
+            ssl_kwargs = {}
+        kwargs = copy.copy(ssl_kwargs)
         
         try:
             activate_ssl = kwargs.pop('activate', True)
             if activate_ssl:
+                if Tools.has_sub_kwargs(kwargs, 'create_default_context.'):
+                    create_default_context_kwargs = Tools.pop_sub_kwargs(kwargs, 'create_default_context.')
+                else:
+                    create_default_context_kwargs = {}
+                
                 purpose = Purpose.CLIENT_AUTH if server_side else Purpose.SERVER_AUTH
-                res = ssl.create_default_context(purpose=purpose)
+                res = ssl.create_default_context(purpose=purpose, **create_default_context_kwargs)
+                
+                # res.set_default_verify_paths()
                 
-                if Tools.has_sub_kwargs(kwargs, 'context.'):
-                    context_kwargs = Tools.pop_sub_kwargs(kwargs, 'context.')
+                if context_kwargs:
+                    c_kwargs = copy.copy(context_kwargs)
                     
-                    ciphers = context_kwargs.pop('ciphers', None)
+                    ciphers = c_kwargs.pop('ciphers', None)
                     if ciphers is not None:
+                        if ciphers == 'OPENSSL_CIPHERS':
+                            ciphers = SslManager.get_openssl_ciphers()
+                            logger.debug(f"Using openssl ciphers: {ciphers}")
                         res.set_ciphers(ciphers)
-                    if Tools.has_sub_kwargs(context_kwargs, 'load_cert_chain.'):
-                        load_cert_chain_kwargs = Tools.pop_sub_kwargs(context_kwargs, 'load_cert_chain.')
+                    if Tools.has_sub_kwargs(c_kwargs, 'load_cert_chain.'):
+                        load_cert_chain_kwargs = Tools.pop_sub_kwargs(c_kwargs, 'load_cert_chain.')
                         res.load_cert_chain(**load_cert_chain_kwargs)
-                    if Tools.has_sub_kwargs(context_kwargs, 'load_verify_locations.'):
-                        load_verify_locations_kwargs = Tools.pop_sub_kwargs(context_kwargs, 'load_verify_locations.')
+                    if Tools.has_sub_kwargs(c_kwargs, 'load_verify_locations.'):
+                        load_verify_locations_kwargs = Tools.pop_sub_kwargs(c_kwargs, 'load_verify_locations.')
                         res.load_verify_locations(**load_verify_locations_kwargs)
                     
-                    # Set context attributes with remaining kwargs
-                    if len(context_kwargs) > 0:
-                        set_object_attributes_with_json_dict(res, context_kwargs)
+                    # Set context attributes with remaining c_kwargs
+                    if len(c_kwargs) > 0:
+                        set_object_attributes_with_json_dict(res, c_kwargs)
+                
+                logger.debug(f"Default verify paths: {ssl.get_default_verify_paths()})")
+                dvp = ssl.get_default_verify_paths()
+                if res.verify_mode != ssl.CERT_NONE and dvp.cafile is None and 'create_default_context.cafile' not in ssl_kwargs and 'load_verify_locations.cafile' not in context_kwargs:
+                    msg_list = [f"No CA file is defined, it is not possible to verify certificates.",
+                                f"Most common solutions:",
+                                f"  - Configure to not verify certificates, by adding/setting in table: | 'ssl.context.verify_mode' | ssl.CERT_NONE |",
+                                f"  - Be sure OpenSSL default CA file exists on system (configured path: '{dvp.openssl_cafile}'). Example of command (on Ubuntu): sudo ln -s /etc/ssl/certs/ca-certificates.crt {dvp.openssl_cafile}",
+                                f"  - Configure a CA file at context creation, by adding/setting in table: | 'ssl.create_default_context.cafile' | <path to CA file> |",
+                                f"  - Configure a CA file after context creation, by adding/setting in table: | 'ssl.context.load_verify_locations.cafile' | <path to CA file> |",
+                                f"Note: step 'Given CACERTS_PATH = CA certs file path (from certifi package)' can be used to get the path to CA file coming with 'certifi' package that is supposed to be installed when using ssl module",
+                                ]
+                    raise TechnicalException("\n".join(msg_list))
+                logger.debug(f"Loaded CA certificates: {res.get_ca_certs()})")
+                logger.debug(f"Loaded ciphers: {res.get_ciphers()})")
+                
         except Exception as exc:
-            msg = f"Failed to create SSL context with parameters {flat_kwargs}: {exc}"
+            msg = f"Failed to create SSL context with parameters ({ssl_kwargs}, {context_kwargs}): {exc}"
             logger.error(msg)
             raise TechnicalException(msg) from exc
         
@@ -73,9 +105,94 @@ class SslManager(object):
         return res
     
     @classmethod
-    def get_localhost_certificate(cls):
+    def get_openssl_ciphers(cls):
+        import subprocess
+        output = subprocess.run(["openssl", "ciphers"], capture_output=True).stdout
+        output_str = output.decode("utf-8")
+        return output_str.strip().split("\n")[0]
+    
+    @classmethod
+    def get_default_certificates(cls):
+        dvp = ssl.get_default_verify_paths()
+        if not os.path.exists(dvp.cafile):
+            raise TechnicalException(f"openssl CA file '{dvp.cafile}' doesn't exist. Example of resolution command (on Ubuntu): sudo ln -s /etc/ssl/certs/ca-certificates.crt {dvp.cafile}")
+        return (dvp.cafile, dvp.capath)
+    
+    @classmethod
+    def get_certifi_ca_certs_file_path(cls):
+        import certifi
+        return certifi.where()
+    
+    # @classmethod
+    # def get_localhost_certificate(cls):
+    #     here = os.path.abspath(os.path.dirname(__file__))
+    #     certfile_path = os.path.join(here, 'resources', 'certificates', 'localhost.crt')
+    #     keyfile_path = os.path.join(here, 'resources', 'certificates', 'localhost.key')
+    #     return (certfile_path, keyfile_path)
+    
+    @classmethod
+    def get_tcpbin_certificates(cls):
         here = os.path.abspath(os.path.dirname(__file__))
-        certfile_path = os.path.join(here, 'resources', 'certificates', 'localhost.crt')
-        keyfile_path = os.path.join(here, 'resources', 'certificates', 'localhost.key')
-        return (certfile_path, keyfile_path)
+        certfile_path = os.path.join(here, 'resources', 'certificates', 'tcpbin.crt')
+        keyfile_path = os.path.join(here, 'resources', 'certificates', 'tcpbin.key')
+        ca_certfile_path = os.path.join(here, 'resources', 'certificates', 'rootCACert.pem')
+        
+        cls.ensure_tcpbin_certificates_are_valid(certfile_path, keyfile_path)
+        
+        return (certfile_path, keyfile_path, ca_certfile_path)
+    
+    @classmethod
+    def ensure_tcpbin_certificates_are_valid(cls, public_key_path, private_key_path, duration_seconds=600):
+        cls.__get_path_manager().makedirs(public_key_path)
+        cls.__get_path_manager().makedirs(private_key_path)
+        
+        # Verify if certificate has expired
+        do_generate_certificates = True
+        if os.path.exists(public_key_path):
+            cmd = f"openssl x509 -checkend {duration_seconds} -noout -in '{public_key_path}'"
+            command = Command(cmd, do_log_output=True, do_raise_on_stderr=False, executable="/bin/bash")
+            command.start()
+            command.join()
+            if command.state is CommandStates.Success:
+                do_generate_certificates = False
+            elif command.return_code == 1:
+                do_generate_certificates = True
+            else:
+                raise TechnicalException(f"Error while executing openssl command [{cmd}]: error code={command.return_code} ; stdout: [{command.stdout}] ; stderr: [{command.stderr}]")
+        
+        # Generate new certificates if needed
+        if do_generate_certificates:
+            cmd = f"curl -s https://tcpbin.com/api/client-cert"
+            command = Command(cmd, do_log_output=True, do_raise_on_stderr=False, executable="/bin/bash")
+            command.start()
+            command.join()
+            if command.state is not CommandStates.Success:
+                raise TechnicalException(f"Error while executing command [{cmd}] : [{command.stderr}]")
+            
+            data = json.loads(command.stdout)
+            with open(public_key_path, 'wt') as fout:
+                fout.write(data['cert'])
+            with open(private_key_path, 'wt') as fout:
+                fout.write(data['key'])
+    
+    @classmethod
+    def generate_new_self_signed_key_files(cls, public_key_path, private_key_path, openssl_args):
+        cls.__get_path_manager().makedirs(public_key_path)
+        cls.__get_path_manager().makedirs(private_key_path)
+        
+        cmd = f"openssl req -out '{public_key_path}' -keyout '{private_key_path}' {openssl_args}"
+        command = Command(cmd, do_log_output=True, do_raise_on_stderr=False, executable="/bin/bash")
+        command.start()
+        command.join()
+        
+        if command.state is not CommandStates.Success:
+            raise TechnicalException(f"Error while executing openssl command [{cmd}] : [{command.stderr}]")
+    
+    @classmethod
+    def generate_new_self_signed_key_files_for_localhost(cls, public_key_path, private_key_path, algorithm='rsa:2048'):
+        SslManager.generate_new_self_signed_key_files(
+            public_key_path, private_key_path, 
+            f"-x509 -newkey {algorithm} -noenc -sha256 -subj '/CN=localhost' -extensions EXT \
+              -config <( printf \"[dn]\nCN=localhost\n[req]\ndistinguished_name = dn\n[EXT]\nsubjectAltName=DNS:localhost\nkeyUsage=digitalSignature\nextendedKeyUsage=serverAuth\")"
+            )
 

holado_python/tests/behave/steps/convert_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 from holado_core.common.tools.string_tools import StrTools
 

holado_python/tests/behave/steps/iterable_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 from holado_core.common.exceptions.verify_exception import VerifyException
 from holado_core.common.tools.converters.converter import Converter

holado_python/tests/behave/steps/standard_library/csv_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_test.behave.behave import render_step_table
 import logging
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools

holado_python/tests/behave/steps/standard_library/datetime_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from datetime import datetime, timedelta
 from holado_python.common.tools.datetime import DateTime, DurationUnit
 import logging

holado_python/tests/behave/steps/standard_library/hashlib_steps.py

@@ -15,7 +15,7 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 from holado_core.common.exceptions.verify_exception import VerifyException
 from holado_core.common.tools.converters.converter import Converter
@@ -40,7 +40,7 @@ def __get_variable_manager():
 def step_impl(context, var_name, code_size, content, prefix):
     """Return a code computed with content as input.
     Dynamic part of the code is computed with blake2b hash algorithm.
-    If code_size (minus length of prefix if defined) is not a multiple of 2, it is rounded to the multiple of 2 juste below.
+    If code_size (minus length of prefix if defined) is not a multiple of 2, it is rounded to the multiple of 2 just below.
     """
     var_name = StepTools.evaluate_variable_name(var_name)
     code_size = StepTools.evaluate_scenario_parameter(code_size)

holado_python/tests/behave/steps/standard_library/multiprocessing_steps.py

@@ -13,7 +13,7 @@
 #################################################
 
 
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado.common.context.session_context import SessionContext
 from holado_test.scenario.step_tools import StepTools
 import logging

holado_python/tests/behave/steps/standard_library/queue_steps.py

@@ -13,7 +13,7 @@
 #################################################
 
 
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado.common.context.session_context import SessionContext
 from holado_test.scenario.step_tools import StepTools
 import logging

holado_python/tests/behave/steps/standard_library/socket_steps.py

@@ -15,14 +15,14 @@
 
 from holado_test.scenario.step_tools import StepTools
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
 from holado_python.standard_library.socket.blocking_socket import TCPBlockingSocketClient
 from holado_python.standard_library.socket.echo_server import EchoTCPBlockingSocketServer
 from holado_python.standard_library.socket.message_socket import MessageTCPNonBlockingSocketClient, MessageTCPBlockingSocketClient
-from holado_core.common.handlers.wait import WaitEndChange
+from holado_core.common.handlers.wait import WaitEndChange, WaitChange
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_python.standard_library.socket.non_blocking_socket import TCPNonBlockingSocketClient
 
@@ -85,7 +85,9 @@ def step_impl(context, var_name):
 
 @Step(r"start \(socket client: (?P<server_varname>{Variable})\)")
 def step_impl(context, server_varname):
-    """Start a non blocking socket client.
+    """Start a socket client.
+    It starts a thread listening incoming data.
+    This step is needed for non blocking socket clients to manage incoming data.
     Note: current implementation uses 'start' method parameters default values.
     """
     server = StepTools.evaluate_scenario_parameter(server_varname)
@@ -173,6 +175,89 @@ def step_impl(context, var_name, socket_varname):
     
     __get_variable_manager().register_variable(var_name, res)
 
+@Step(r"(?P<var_name>{Variable}) = received data \(socket: (?P<socket_varname>{Variable})\)")
+def step_impl(context, var_name, socket_varname):
+    """Get currently received data
+    This step works only with clients that are started, so that listening thread is started.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    
+    res = sock.received_data
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Step(r"(?P<var_name>{Variable}) = size of received data \(socket: (?P<socket_varname>{Variable})\)")
+def step_impl(context, var_name, socket_varname):
+    """Get received messages without removing from socket
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    
+    res = sock.received_data_size
+    
+    __get_variable_manager().register_variable(var_name, res)
+
+@Step(r"socket (?P<socket_varname>{Variable}) doesn't receive any data(?: \((?:timeout: (?P<timeout_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
+def step_impl(context, socket_varname, timeout_sec, polling_sec):
+    """Wait and verify socket doesn't receive any data
+    """
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
+    polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
+    
+    if timeout_sec is None:
+        timeout_sec = 10
+    
+    wait = WaitChange(f"Verify no data is received (socket: {sock})",
+                      lambda: sock.received_data_size,
+                      timeout_seconds=timeout_sec, polling_seconds=polling_sec)
+    wait.without_raise_on_timeout()
+    data_size = wait.execute()
+    if data_size > 0:
+        raise FunctionalException(f"[{sock.name}] Socket has received data of size {data_size}")
+
+@Step(r"await socket (?P<socket_varname>{Variable}) receives a data(?: \((?:timeout: (?P<timeout_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
+def step_impl(context, socket_varname, timeout_sec, polling_sec):
+    """Wait socket receives at least one data
+    """
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
+    polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
+    
+    if timeout_sec is None:
+        timeout_sec = 10
+    
+    wait = WaitChange(f"Wait data reception (socket: {sock})",
+                      lambda: sock.received_data_size,
+                      timeout_seconds=timeout_sec, polling_seconds=polling_sec)
+    wait.without_raise_on_timeout()
+    data_size = wait.execute()
+    if data_size == 0:
+        raise FunctionalException(f"[{sock.name}] No data was received (timeout: {wait.timeout} seconds)")
+
+@Step(r"await socket (?P<socket_varname>{Variable}) receives data(?: \((?:first timeout: (?P<first_timeout_sec>{Float}) s)?(?: ; )?(?:window: (?P<window_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
+def step_impl(context, socket_varname, first_timeout_sec, window_sec, polling_sec):
+    """Wait socket stop to receive data
+    """
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    first_timeout_sec = StepTools.evaluate_scenario_parameter(first_timeout_sec)
+    window_sec = StepTools.evaluate_scenario_parameter(window_sec)
+    polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
+    
+    wait = WaitEndChange(f"Wait end of data reception (socket: {sock})",
+                         lambda: sock.received_data_size,
+                         first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec)
+    wait.without_raise_on_timeout()
+    data_size = wait.execute()
+    if data_size == 0:
+        raise FunctionalException(f"[{sock.name}] No data was received (timeout: {wait.timeout} seconds)")
+
+@Given(r"reset stored received data in socket (?P<socket_varname>{Variable})")
+def step_impl(context, socket_varname):
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    sock.reset_received_data()
+
 
 
 # For client and servers managing messages
@@ -232,39 +317,68 @@ def step_impl(context, var_name, socket_varname):
     
     __get_variable_manager().register_variable(var_name, res)
 
-@Step(r"wait socket (?P<socket_varname>{Variable}) stops to receive data(?: \((?:first timeout: (?P<first_timeout_sec>{Float}) s)?(?: ; )?(?:window: (?P<window_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
-def step_impl(context, socket_varname, first_timeout_sec, window_sec, polling_sec):
-    """Get received messages without removing from socket
+@Step(r"socket (?P<socket_varname>{Variable}) doesn't receive any message(?: \((?:timeout: (?P<timeout_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
+def step_impl(context, socket_varname, timeout_sec, polling_sec):
+    """Wait and verify socket doesn't receive any message
     """
     sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
+    polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
+    
+    if timeout_sec is None:
+        timeout_sec = 10
+    
+    wait = WaitChange(f"Wait end of message reception (socket: {sock})",
+                      lambda: sock.nb_messages,
+                      timeout_seconds=timeout_sec, polling_seconds=polling_sec)
+    wait.without_raise_on_timeout()
+    nb_messages = wait.execute()
+    if nb_messages > 0:
+        raise FunctionalException(f"[{sock.name}] Socket has received {nb_messages} messages (timeout: {wait.timeout} seconds)")
+
+@Step(r"await socket (?P<socket_varname>{Variable}) receives (?:(?P<no_str>no) )?messages(?: \((?:first timeout: (?P<first_timeout_sec>{Float}) s)?(?: ; )?(?:window: (?P<window_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
+def step_impl(context, socket_varname, no_str, first_timeout_sec, window_sec, polling_sec):
+    """Wait until socket receives messages or no messages.
+    Wait during max first_timeout_sec duration for a first message, then, and after each new message, wait during max window_sec duration for a new message.
+    If no message is received during first_timeout_sec duration, an error is raised only if messages are waited (ie 'no ' is not added when calling step).
+    """
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    no_messages = no_str is not None
     first_timeout_sec = StepTools.evaluate_scenario_parameter(first_timeout_sec)
     window_sec = StepTools.evaluate_scenario_parameter(window_sec)
     polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
     
-    wait = WaitEndChange(f"Wait end of data reception (socket: {sock})",
-                         lambda: sock.received_data_size,
+    wait = WaitEndChange(f"Wait until socket receives {no_str if no_str is not None else ''}messages (socket: {sock})",
+                         lambda: sock.nb_messages,
                          first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec)
     wait.without_raise_on_timeout()
-    data_size = wait.execute()
-    if data_size == 0:
-        raise FunctionalException(f"[{sock.name}] No data was received (timeout: {wait.timeout} seconds)")
+    nb_messages = wait.execute()
+    if not no_messages and nb_messages == 0:
+        raise FunctionalException(f"[{sock.name}] No message was received (timeout: {wait.timeout} seconds)")
 
-@Step(r"wait socket (?P<socket_varname>{Variable}) stops to receive messages(?: \((?:first timeout: (?P<first_timeout_sec>{Float}) s)?(?: ; )?(?:window: (?P<window_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
-def step_impl(context, socket_varname, first_timeout_sec, window_sec, polling_sec):
+@Step(r"await socket (?P<socket_varname>{Variable}) receives a message(?: \((?:timeout: (?P<timeout_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?\))?")
+def step_impl(context, socket_varname, timeout_sec, polling_sec):
     """Get received messages without removing from socket
     """
     sock = StepTools.evaluate_scenario_parameter(socket_varname)
-    first_timeout_sec = StepTools.evaluate_scenario_parameter(first_timeout_sec)
-    window_sec = StepTools.evaluate_scenario_parameter(window_sec)
+    timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
     polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
     
-    wait = WaitEndChange(f"Wait end of message reception (socket: {sock})",
-                         lambda: sock.nb_messages,
-                         first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec)
+    if timeout_sec is None:
+        timeout_sec = 10
+    
+    wait = WaitChange(f"Wait a message reception (socket: {sock})",
+                      lambda: sock.nb_messages,
+                      timeout_seconds=timeout_sec, polling_seconds=polling_sec)
     wait.without_raise_on_timeout()
     nb_messages = wait.execute()
     if nb_messages == 0:
         raise FunctionalException(f"[{sock.name}] No message was received (timeout: {wait.timeout} seconds)")
 
+@Given(r"reset stored received messages in socket (?P<socket_varname>{Variable})")
+def step_impl(context, socket_varname):
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    sock.reset_received_messages()
+