holado 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

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

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 MessageTCPSocketClient
-from holado_core.common.handlers.wait import WaitEndChange
+from holado_python.standard_library.socket.message_socket import MessageTCPNonBlockingSocketClient, MessageTCPBlockingSocketClient
+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
 
@@ -74,14 +74,20 @@ def step_impl(context, var_name):
     kwargs = ValueTableConverter.convert_name_value_table_2_dict(table)
     
     separator = kwargs.pop('separator') if 'separator' in kwargs else '\n'
-    res = MessageTCPSocketClient(separator, create_ipv4_socket_kwargs=kwargs)
+    blocking = kwargs.pop('blocking') if 'blocking' in kwargs else True
+    if blocking:
+        res = MessageTCPBlockingSocketClient(separator, create_ipv4_socket_kwargs=kwargs)
+    else:
+        res = MessageTCPNonBlockingSocketClient(separator, create_ipv4_socket_kwargs=kwargs)
     
     __get_variable_manager().register_variable(var_name, res)
 
 
 @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)
@@ -139,6 +145,14 @@ def step_impl(context, server_varname):
 ################################################################
 
 
+@Step(r"ensure SSL handshake is done \(socket: (?P<socket_varname>{Variable})\)")
+def step_impl(context, socket_varname):
+    """Ensure SSL handshake is done.
+    """
+    sock = StepTools.evaluate_scenario_parameter(socket_varname)
+    
+    sock.ensure_ssl_handshake_is_done()
+
 @Step(r"write (?P<data>{Bytes}) \(socket: (?P<socket_varname>{Variable})\)")
 def step_impl(context, data, socket_varname):
     """Send data
@@ -161,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
@@ -216,43 +313,72 @@ def step_impl(context, var_name, socket_varname):
     var_name = StepTools.evaluate_variable_name(var_name)
     sock = StepTools.evaluate_scenario_parameter(socket_varname)
     
-    res = len(sock.messages)
+    res = sock.nb_messages
     
     __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()
+    
 
 

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

@@ -15,16 +15,11 @@
 
 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_python.standard_library.ssl.ssl import SslManager
 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 MessageTCPSocketClient
-from holado_core.common.handlers.wait import WaitFuncResultVerifying, WaitEndChange
-from holado_core.common.exceptions.functional_exception import FunctionalException
-from holado_python.standard_library.ssl.ssl import SslManager
 
 logger = logging.getLogger(__name__)
 
@@ -40,28 +35,104 @@ def __get_variable_manager():
 
 
 
-@Given(r"(?P<var_name>{Variable}) = certfile path for localhost")
+@Given(r"(?P<var_name>{Variable}) = default CA certs file path")
 def step_impl(context, var_name):
-    """Return path to cert file for localhost stored in internal resources.
-    Note: It is an autosigned certificate.
+    """Return path to default cert file.
+    Note: It uses ssl.get_default_verify_paths method.
     """
     var_name = StepTools.evaluate_variable_name(var_name)
     
-    cert_paths = SslManager.get_localhost_certificate()
+    default_certs = SslManager.get_default_certificates()
     
-    __get_variable_manager().register_variable(var_name, cert_paths[0])
+    __get_variable_manager().register_variable(var_name, default_certs[0])
+
+
+@Given(r"(?P<var_name>{Variable}) = default certs directory path")
+def step_impl(context, var_name):
+    """Return path to default certs folder.
+    Note: It uses ssl.get_default_verify_paths method.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+    
+    default_certs = SslManager.get_default_certificates()
+    
+    __get_variable_manager().register_variable(var_name, default_certs[1])
 
 
-@Given(r"(?P<var_name>{Variable}) = keyfile path for localhost")
+@Given(r"(?P<var_name>{Variable}) = CA certs file path \(from certifi package\)")
 def step_impl(context, var_name):
-    """Return path to key file for localhost stored in internal resources.
-    Note: It is an autosigned certificate.
+    """Return path to CA certs file from 'certifi' package.
     """
     var_name = StepTools.evaluate_variable_name(var_name)
     
-    cert_paths = SslManager.get_localhost_certificate()
+    cacerts_path = SslManager.get_certifi_ca_certs_file_path()
     
+    __get_variable_manager().register_variable(var_name, cacerts_path)
+
+
+# @Given(r"(?P<var_name>{Variable}) = certfile path for localhost")
+# def step_impl(context, var_name):
+#     """Return path to cert file for localhost stored in internal resources.
+#     Note: It is an autosigned certificate.
+#     """
+#     var_name = StepTools.evaluate_variable_name(var_name)
+#
+#     cert_paths = SslManager.get_localhost_certificate()
+#
+#     __get_variable_manager().register_variable(var_name, cert_paths[0])
+#
+#
+# @Given(r"(?P<var_name>{Variable}) = keyfile path for localhost")
+# def step_impl(context, var_name):
+#     """Return path to key file for localhost stored in internal resources.
+#     Note: It is an autosigned certificate.
+#     """
+#     var_name = StepTools.evaluate_variable_name(var_name)
+#
+#     cert_paths = SslManager.get_localhost_certificate()
+#
+#     __get_variable_manager().register_variable(var_name, cert_paths[1])
+
+@Given(r"generate new self-signed key files for localhost")
+def step_impl(context):
+    """Generate public and private keys for a localhost use.
+    """
+    table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+    kwargs = ValueTableConverter.convert_name_value_table_2_dict(table)
+
+    SslManager.generate_new_self_signed_key_files_for_localhost(**kwargs)
+
+
+@Given(r"(?P<var_name>{Variable}) = certfile path for tcpbin.com")
+def step_impl(context, var_name):
+    """Return path to cert file for tcpbin.com stored in internal resources.
+    Note: If certificate has expired, a new one is generated.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+
+    cert_paths = SslManager.get_tcpbin_certificates()
+
+    __get_variable_manager().register_variable(var_name, cert_paths[0])
+
+@Given(r"(?P<var_name>{Variable}) = keyfile path for tcpbin.com")
+def step_impl(context, var_name):
+    """Return path to key file for tcpbin.com stored in internal resources.
+    Note: If certificate has expired, a new one is generated.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+
+    cert_paths = SslManager.get_tcpbin_certificates()
+
     __get_variable_manager().register_variable(var_name, cert_paths[1])
 
+@Given(r"(?P<var_name>{Variable}) = CA certfile path for tcpbin.com")
+def step_impl(context, var_name):
+    """Return path to cert file for tcpbin.com stored in internal resources.
+    Note: If certificate has expired, a new one is generated.
+    """
+    var_name = StepTools.evaluate_variable_name(var_name)
+
+    cert_paths = SslManager.get_tcpbin_certificates()
 
+    __get_variable_manager().register_variable(var_name, cert_paths[2])
 

holado_rabbitmq/tests/behave/steps/tools/rabbitmq_client_steps.py

@@ -16,7 +16,7 @@
 from holado_value.common.tables.comparators.table_2_value_table_comparator import Table2ValueTable_Comparator
 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_rabbitmq.tools.rabbitmq import rabbitmq_client
 from holado_core.common.tables.table_manager import TableManager
 from holado_core.common.exceptions.functional_exception import FunctionalException
@@ -369,43 +369,41 @@ if rabbitmq_client.RMQClient.is_available():
             rate = counter / (end - beg)
             logger.print(f"[Queue {q_name} -> Publisher {pub_name}] Mean rate: {int(rate)} msg/s ; Nb messages: {counter}")
     
-    @When(r"wait consumer (?P<var_con>{Variable}) receives messages(?: \(timeout: (?P<timeout_sec>{Float}) s(?: ; polling: (?P<polling_sec>{Float}) s)?(?: ; )?(?:raise: (?P<do_raise>{Boolean}))?\))?")
-    def step_impl(context, var_con, timeout_sec, polling_sec, do_raise):
+    @When(r"await consumer (?P<var_con>{Variable}) receives a message(?: \(timeout: (?P<timeout_sec>{Float}) s(?: ; polling: (?P<polling_sec>{Float}) s)?\))?")
+    def step_impl(context, var_con, timeout_sec, polling_sec):
         con = StepTools.evaluate_variable_value(var_con)
         timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
         polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
-        do_raise = StepTools.evaluate_scenario_parameter(do_raise)
         
-        __get_rabbitmq_manager().wait_message_reception([con], timeout_seconds=timeout_sec, polling_seconds=polling_sec, raise_exception=do_raise)
+        __get_rabbitmq_manager().await_message_reception([con], timeout_seconds=timeout_sec, polling_seconds=polling_sec)
     
-    @When(r"wait consumers (?P<list_consumers>{List}) receive messages(?: \(timeout: (?P<timeout_sec>{Float}) s(?: ; polling: (?P<polling_sec>{Float}) s)?(?: ; )?(?:raise: (?P<do_raise>{Boolean}))?\))?")
-    def step_impl(context, list_consumers, timeout_sec, polling_sec, do_raise):
+    @When(r"await consumers (?P<list_consumers>{List}) receive a message(?: \(timeout: (?P<timeout_sec>{Float}) s(?: ; polling: (?P<polling_sec>{Float}) s)?\))?")
+    def step_impl(context, list_consumers, timeout_sec, polling_sec):
         consumers = StepTools.evaluate_list_scenario_parameter(list_consumers, "list_consumers")
         timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
         polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
-        do_raise = StepTools.evaluate_scenario_parameter(do_raise)
         
-        __get_rabbitmq_manager().wait_message_reception(consumers, timeout_seconds=timeout_sec, polling_seconds=polling_sec, raise_exception=do_raise)
+        __get_rabbitmq_manager().await_message_reception(consumers, timeout_seconds=timeout_sec, polling_seconds=polling_sec)
     
-    @When(r"wait consumer (?P<var_con>{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)?(?: ; )?(?:raise: (?P<do_raise>{Boolean}))?\))?")
-    def step_impl(context, var_con, first_timeout_sec, window_sec, polling_sec, do_raise):
+    @When(r"await consumer (?P<var_con>{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, var_con, no_str, first_timeout_sec, window_sec, polling_sec):
         con = StepTools.evaluate_variable_value(var_con)
         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)
-        do_raise = StepTools.evaluate_scenario_parameter(do_raise)
+        do_raise = no_str is None
         
-        __get_rabbitmq_manager().wait_end_message_reception([con], first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec, raise_exception=do_raise)
+        __get_rabbitmq_manager().await_messages_reception([con], first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec, raise_exception=do_raise)
     
-    @When(r"wait consumers (?P<list_consumers>{List}) stop to receive messages(?: \((?:first timeout: (?P<first_timeout_sec>{Float}) s)?(?: ; )?(?:window: (?P<window_sec>{Float}) s)?(?: ; )?(?:polling: (?P<polling_sec>{Float}) s)?(?: ; )?(?:raise: (?P<do_raise>{Boolean}))?\))?")
-    def step_impl(context, list_consumers, first_timeout_sec, window_sec, polling_sec, do_raise):
+    @When(r"await consumers (?P<list_consumers>{List}) receive (?:(?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, list_consumers, no_str, first_timeout_sec, window_sec, polling_sec):
         consumers = StepTools.evaluate_list_scenario_parameter(list_consumers, "list_consumers")
         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)
-        do_raise = StepTools.evaluate_scenario_parameter(do_raise)
+        do_raise = no_str is None
         
-        __get_rabbitmq_manager().wait_end_message_reception(consumers, first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec, raise_exception=do_raise)
+        __get_rabbitmq_manager().await_messages_reception(consumers, first_timeout_seconds=first_timeout_sec, window_seconds=window_sec, polling_seconds=polling_sec, raise_exception=do_raise)
     
     @Then(r"consumer (?P<var_con>{Variable}) doesn't receive any message \(timeout: (?P<timeout_sec>{Float}) s ; polling: (?P<polling_sec>{Float}) s\)")
     def step_impl(context, var_con, timeout_sec, polling_sec):
@@ -413,7 +411,7 @@ if rabbitmq_client.RMQClient.is_available():
         timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
         polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
         
-        nb = __get_rabbitmq_manager().wait_message_reception([con], timeout_seconds=timeout_sec, polling_seconds=polling_sec, raise_exception=False)
+        nb = __get_rabbitmq_manager().await_message_reception([con], timeout_seconds=timeout_sec, polling_seconds=polling_sec, raise_exception=False)
         if nb > 0:
             raise FunctionalException(f"Consumer has received {nb} messages")
     
@@ -423,7 +421,7 @@ if rabbitmq_client.RMQClient.is_available():
         timeout_sec = StepTools.evaluate_scenario_parameter(timeout_sec)
         polling_sec = StepTools.evaluate_scenario_parameter(polling_sec)
         
-        nb = __get_rabbitmq_manager().wait_message_reception(consumers, timeout_seconds=timeout_sec, polling_seconds=polling_sec, raise_exception=False)
+        nb = __get_rabbitmq_manager().await_message_reception(consumers, timeout_seconds=timeout_sec, polling_seconds=polling_sec, raise_exception=False)
         if nb > 0:
             raise FunctionalException(f"Consumer has received {nb} messages")
     
@@ -533,5 +531,35 @@ if rabbitmq_client.RMQClient.is_available():
     def step_impl(context, queue, var_client):
         queue = StepTools.evaluate_scenario_parameter(queue)
         client = StepTools.evaluate_variable_value(var_client)
-        client.connection.channel().queue_purge(queue)
+        client.purge_queue(queue)
         
+    @Step(r"delete and recreate stream queue (?P<queue>{Str}) \(RMQ client: (?P<var_client>{Variable})\)")
+    def step_impl(context, queue, var_client):
+        queue_name = StepTools.evaluate_scenario_parameter(queue)
+        client = StepTools.evaluate_variable_value(var_client)
+        client.delete_queue(queue_name)
+        client._queue_declare(
+            channel=client.connection.channel(),
+            queue=queue_name,
+            queue_args={
+                'durable': True,
+                "x-queue-type": "stream",
+                "x-stream-max-segment-size-bytes": 100000000
+            })
+        
+    @Step(r"bind queue (?P<queue>{Str}) to exchange (?P<exchange>{Str})(?: with routine key (?P<routine_key>{Str}))? \(RMQ client: (?P<var_client>{Variable})\)")
+    def step_impl(context, queue, exchange, routine_key, var_client):
+        queue_name = StepTools.evaluate_scenario_parameter(queue)
+        exchange = StepTools.evaluate_scenario_parameter(exchange)
+        routine_key = StepTools.evaluate_scenario_parameter(routine_key)
+        client = StepTools.evaluate_variable_value(var_client)
+        bind_args={
+            'routing_key': routine_key
+            }
+        client._queue_bind(
+            channel=client.connection.channel(),
+            queue=queue_name,
+            exchange=exchange,
+            bind_args=bind_args
+        )
+        

holado_rabbitmq/tests/behave/steps/tools/rabbitmq_server_steps.py

@@ -14,7 +14,7 @@
 
 
 from holado.common.context.session_context import SessionContext
-from holado_test.behave.behave import *
+from holado_test.behave.behave import *  # @UnusedWildImport
 from holado_rabbitmq.tools.rabbitmq import rabbitmq_server
 import logging
 from holado_test.scenario.step_tools import StepTools