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

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 MessageTCPNonBlockingSocketClient
-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

holado_rabbitmq/tools/rabbitmq/rabbitmq_client.py

@@ -209,7 +209,7 @@ class RMQClient(DeleteableObject):
     def _new_publisher_with_connection(self, connection, queue, queue_args=None, exchange="", exchange_args=None, routing_key=None, nb_runners=None):
         pub_channel = connection.channel()
         
-        queue_name = self.__prepare_queue(pub_channel, queue, queue_args, exchange, exchange_args, bind_args=None)
+        queue_name = self._prepare_queue(pub_channel, queue, queue_args, exchange, exchange_args, bind_args=None)
         if self.connection.publisher_confirms:
             pub_channel.set_confirm_delivery()
         else:
@@ -236,7 +236,7 @@ class RMQClient(DeleteableObject):
         
         if self.is_consuming:
             raise FunctionalException(f"[{self.name}] Not allowed to create a new consumer while consuming is started")
-        queue_name = self.__prepare_queue(con_channel, queue, queue_args, exchange, exchange_args, bind_args)
+        queue_name = self._prepare_queue(con_channel, queue, queue_args, exchange, exchange_args, bind_args)
         res = RMQConsumer(self, connection, con_channel, queue_name, message_callback)
         self.__consumer_and_kwargs.append( self.__new_object_kwargs(res, queue=queue, message_callback=message_callback, queue_args=queue_args, exchange=exchange, exchange_args=exchange_args, bind_args=bind_args) )
         return res
@@ -249,7 +249,7 @@ class RMQClient(DeleteableObject):
         
         if self.is_consuming:
             raise FunctionalException(f"[{self.name}] Not allowed to create a new consumer while consuming is started")
-        queue_name = self.__prepare_queue(con_channel, queue, queue_args, exchange, exchange_args, bind_args)
+        queue_name = self._prepare_queue(con_channel, queue, queue_args, exchange, exchange_args, bind_args)
         res = RMQBufferConsumer(self, connection, con_channel, queue_name)
         self.__buffer_consumer_and_kwargs.append( self.__new_object_kwargs(res, queue=queue, queue_args=queue_args, exchange=exchange, exchange_args=exchange_args, bind_args=bind_args) )
         return res
@@ -324,25 +324,31 @@ class RMQClient(DeleteableObject):
             if Tools.do_log(logger, logging.DEBUG):
                 logger.debug(f"[{self.name}] Finished stop data events processing")
 
-    def __prepare_queue(self, channel, queue, queue_args=None, exchange="", exchange_args=None, bind_args=None):
+    def _prepare_queue(self, channel, queue, queue_args=None, exchange="", exchange_args=None, bind_args=None):
         if exchange is not None and exchange != "":
-            self.__exchange_declare(channel, exchange, exchange_args)
+            self._exchange_declare(channel, exchange, exchange_args)
         
         if queue is not None and queue != "":
-            self.__queue_declare(channel, queue, queue_args)
+            self._queue_declare(channel, queue, queue_args)
             queue_name = queue
         else:
             q_args = dict(queue_args) if queue_args else {}
             q_args['exclusive'] = True
-            result = self.__queue_declare(channel, queue, q_args)
+            result = self._queue_declare(channel, queue, q_args)
             queue_name = result.method.queue
             
         if exchange is not None and exchange != "":
-            self.__queue_bind(channel, queue_name, exchange, bind_args)
+            self._queue_bind(channel, queue_name, exchange, bind_args)
             
         return queue_name
-
-    def __exchange_declare(self, channel, exchange, exchange_args=None):
+    
+    def delete_queue(self, queue):
+        self.connection.channel().queue_delete(queue=queue)
+    
+    def purge_queue(self, queue):
+        self.connection.channel().queue_purge(queue)
+        
+    def _exchange_declare(self, channel, exchange, exchange_args=None):
         kwargs = {}
         arguments = None
         if exchange_args:
@@ -352,7 +358,7 @@ class RMQClient(DeleteableObject):
                     kwargs[name] = arguments.pop(name)
         return channel.exchange_declare(exchange, arguments=arguments, **kwargs)
         
-    def __queue_declare(self, channel, queue, queue_args=None):
+    def _queue_declare(self, channel, queue, queue_args=None):
         kwargs = {}
         arguments = None
         if queue_args:
@@ -362,7 +368,7 @@ class RMQClient(DeleteableObject):
                     kwargs[name] = arguments.pop(name)
         return channel.queue_declare(queue, arguments=arguments, **kwargs)
         
-    def __queue_bind(self, channel, queue, exchange, bind_args=None):
+    def _queue_bind(self, channel, queue, exchange, bind_args=None):
         kwargs = {}
         arguments = None
         if bind_args:
@@ -374,7 +380,7 @@ class RMQClient(DeleteableObject):
     
     def get_queue_message_count(self, queue):
         channel = self.connection.channel()
-        status = self.__queue_declare(channel, queue, {'passive':True})
+        status = self._queue_declare(channel, queue, {'passive':True})
         return status.method.message_count
     
     def is_queue_empty(self, queue, raise_exception=False):

holado_rabbitmq/tools/rabbitmq/rabbitmq_manager.py

@@ -36,39 +36,12 @@ class RMQManager:
         return res
     
         
-    def wait_message_reception(self, consumers, timeout_seconds=None, polling_seconds=None, raise_exception=True):
+    def await_message_reception(self, consumers, timeout_seconds=None, polling_seconds=None, raise_exception=True):
         """Wait until one of the buffer consumers has received a message.
         @param consumers: list of buffer consumers
         @param timeout_seconds: wait timeout
         @param polling_seconds: time to wait between pollings of received messages of all consumers
         """
-        # res = 0
-        #
-        # if timeout_seconds is None:
-        #     timeout_seconds = Config.timeout_seconds
-        # if polling_seconds is None:
-        #     polling_seconds = timeout_seconds / 1000
-        #     if polling_seconds > 0.01:
-        #         polling_seconds = 0.01
-        #
-        # # Wait first message
-        # dt_begin = datetime.now()
-        # dt_last_poll = dt_begin
-        # while (dt_last_poll - dt_begin).total_seconds() < timeout_seconds:
-        #     nb_msg_by_consumer = {c.name: c.nb_messages for c in consumers if c.nb_messages > 0}
-        #     dt_last_poll = datetime.now()
-        #     if len(nb_msg_by_consumer) > 0:
-        #         if Tools.do_log(logger, logging.DEBUG):
-        #             logger.debug(f"Received messages: " + " ; ".join(f"{k}:{v}" for k,v in nb_msg_by_consumer.items()))
-        #         res = sum(nb_msg_by_consumer.values())
-        #         if res > 0:
-        #             break
-        #     time.sleep(polling_seconds)
-        #
-        # if res == 0 and raise_exception:
-        #     names = ",".join([c.name for c in consumers])
-        #     raise FunctionalException(f"[{names}] No message was received (timeout: {timeout_seconds} seconds)")
-        # return res
         if raise_exception is None:
             raise_exception = True
         
@@ -90,7 +63,7 @@ class RMQManager:
 
     #TODO EKL: add a first_accepted_seconds and a accepted_window_seconds to be able to raise an exception that first or next message arrived but too late
     #TODO EKL: change use of polling_seconds to something like a timer, rather than waiting polling_seconds
-    def wait_end_message_reception(self, consumers, first_timeout_seconds=None, window_seconds=None, polling_seconds=None, raise_exception=True):
+    def await_messages_reception(self, consumers, first_timeout_seconds=None, window_seconds=None, polling_seconds=None, raise_exception=True):
         """Wait until buffer consumers stop to receive messages.
         It begins by waiting a first message in any consumer, since their creation or last reset.
         If no consumer receives a first message during first_timeout_seconds period, wait stops.

holado_redis/tests/behave/steps/tools/redis_client_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_core.common.exceptions.technical_exception import TechnicalException
 from holado_scripting.text.interpreter.text_interpreter import TextInterpreter
 from holado_scripting.common.tools.variable_manager import VariableManager

holado_rest/api/rest/rest_client.py

@@ -15,6 +15,7 @@ from holado_core.common.exceptions.functional_exception import FunctionalExcepti
 from holado_core.common.exceptions.technical_exception import TechnicalException
 import logging
 from holado_core.common.tools.tools import Tools
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -56,6 +57,13 @@ class RestClient(object):
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"[{self.name}] Authenticate with token type '{token_type}' and access token '{access_token}'")
         self.__headers['Authorization'] = f'{token_type} {access_token}'
+    
+    def with_ssl(self, ssl_kwargs):
+        unexpected_keys = set(ssl_kwargs.keys()).difference(['verify', 'cert'])
+        if len(unexpected_keys) > 0:
+            raise TechnicalException(f"Unmanaged SSL arguments: {unexpected_keys}")
+        
+        self.__kwargs.update(ssl_kwargs)
         
     def response_result(self, response, status_ok=200):
         if response.status_code != status_ok:
@@ -63,8 +71,10 @@ class RestClient(object):
         
         if "application/json" in response.headers['Content-Type']:
             return response.json()
-        else:
+        elif response.headers['Content-Type'].startswith('text'):
             return response.text
+        else:
+            return response.content
     
     def request(self, method, path, **kwargs):
         url = self.__build_url(path=path)
@@ -104,6 +114,13 @@ 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 not isinstance(data, str):
+                    data = json.dumps(data)
+                res['data'] = data
+            
             for key in list(request_kwargs.keys()):
                 if key in res and isinstance(res[key], dict):
                     res[key].update(request_kwargs.pop(key))

holado_rest/api/rest/rest_manager.py

@@ -33,6 +33,7 @@ class RestManager(object):
         url = kwargs.pop("url")
         headers = Tools.pop_sub_kwargs(kwargs, "headers.")
         authentication = Tools.pop_sub_kwargs(kwargs, "authentication.")
+        ssl_kwargs = Tools.pop_sub_kwargs(kwargs, "ssl.")
         if len(kwargs) > 0:
             raise TechnicalException(f"Unmanaged arguments: {kwargs}")
     
@@ -53,6 +54,10 @@ class RestManager(object):
             else:
                 raise TechnicalException(f"Unmanaged authentication type '{authentication.keys()}' (possible authentication types: 'user', 'token'")
         
+        # Manage ssl if needed
+        if len(ssl_kwargs) > 0:
+            res.with_ssl(ssl_kwargs)
+        
         return res
     
     def _new_rest_client(self, name, url, headers):

holado_rest/tests/behave/steps/api/rest_client_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_core.common.exceptions.technical_exception import TechnicalException
 from holado_rest.api.rest.rest_client import RestClient
 import json
@@ -63,21 +63,62 @@ if RestClient.is_available():
         var_name = StepTools.evaluate_variable_name(var_name)
         path = StepTools.evaluate_scenario_parameter(path)
         client = StepTools.evaluate_variable_value(var_client)
+        
+        # Manage request arguments as step table
+        request_kwargs = {}
+        if hasattr(context, "table") and context.table is not None:
+            table = BehaveStepTools.convert_step_table_2_value_table_with_header(context.table)
+            request_kwargs = ValueTableConverter.convert_name_value_table_2_json_object(table)
+        
+        # Manage request arguments as json text
+        # Manage data as json text
+        text = BehaveStepTools.get_step_multiline_text(context, raise_exception_if_none=False)
+        if text is not None:
+            if len(request_kwargs) > 0:
+                raise TechnicalException(f"Request kwargs are already set to {request_kwargs}")
+            request_kwargs = json.loads(text)
+        
+        # Process request
+        res = client.request(request_method, path, **request_kwargs)
+        
+        # Store result
+        if Tools.do_log(logger, logging.DEBUG):
+            res_table = TableManager.convert_object_attributes_2_name_value_table(res)
+            logger.debug(f"Response of {request_method} {path}:\n{res_table.represent(4)}")
+        __get_variable_manager().register_variable(var_name, res)
+    
+    @Step(r"(?P<var_name>{Variable}) = (?P<request_method>delete|get|patch|post|put) (?P<path>{Str}) \(REST client: (?P<var_client>{Variable})\)")
+    def step_impl(context, var_name, request_method, path, var_client):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        client = StepTools.evaluate_variable_value(var_client)
 
-        # Manage data as table
+        execute_steps(format_step_with_context(context, 
+                u"__RESPONSE__@ = response of {request_method} {path} (REST client: {var_client})"
+                    .format(request_method=request_method, path=path, var_client=var_client) ))
+        
+        response = __get_variable_manager().get_variable_value("__RESPONSE__@")
+        res = client.response_result(response)
+        
+        __get_variable_manager().register_variable(var_name, res)
+    
+    @Step(r"(?P<var_name>{Variable}) = response of (?P<request_method>delete|get|patch|post|put) (?P<path>{Str}) with data \(REST client: (?P<var_client>{Variable})\)")
+    def step_impl(context, var_name, request_method, path, var_client):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        path = StepTools.evaluate_scenario_parameter(path)
+        client = StepTools.evaluate_variable_value(var_client)
+        
         data = None
+        
+        # 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)
-            data_obj = ValueTableConverter.convert_name_value_table_2_json_object(table)
-            data = json.dumps(data_obj)
-            if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-                logger.trace(f"Transformed parameters to JSON is: {data}")
-            
+            json_obj = ValueTableConverter.convert_name_value_table_2_json_object(table)
+            data = json.dumps(json_obj)
+        
+        # Manage request arguments as json text
         # Manage data as json text
         text = BehaveStepTools.get_step_multiline_text(context, raise_exception_if_none=False)
         if text is not None:
-            if request_method in ['delete', 'get']:
-                raise TechnicalException(f"Unexpected json text for request method '{request_method}'")
             if data is not None:
                 raise TechnicalException(f"Data is already set to [{data}]")
             data = text
@@ -91,13 +132,13 @@ if RestClient.is_available():
             logger.debug(f"Response of {request_method} {path}:\n{res_table.represent(4)}")
         __get_variable_manager().register_variable(var_name, res)
     
-    @When(r"(?P<var_name>{Variable}) = (?P<request_method>delete|get|patch|post|put) (?P<path>{Str}) \(REST client: (?P<var_client>{Variable})\)")
+    @Step(r"(?P<var_name>{Variable}) = (?P<request_method>delete|get|patch|post|put) (?P<path>{Str}) with data \(REST client: (?P<var_client>{Variable})\)")
     def step_impl(context, var_name, request_method, path, var_client):
         var_name = StepTools.evaluate_variable_name(var_name)
         client = StepTools.evaluate_variable_value(var_client)
 
         execute_steps(format_step_with_context(context, 
-                u"__RESPONSE__@ = response of {request_method} {path} (REST client: {var_client})"
+                u"__RESPONSE__@ = response of {request_method} {path} with data (REST client: {var_client})"
                     .format(request_method=request_method, path=path, var_client=var_client) ))
         
         response = __get_variable_manager().get_variable_value("__RESPONSE__@")

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

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

holado_s3/tests/behave/steps/private/tools/s3_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_scripting.common.tools.variable_manager import VariableManager
 import logging
 from holado_test.scenario.step_tools import StepTools

holado_s3/tests/behave/steps/tools/s3_client_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_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_scripting.common.tools.variable_manager import VariableManager

holado_s3/tests/behave/steps/tools/s3_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_s3.tools.s3.moto_server import MotoServer
 import logging
 from holado_test.behave.scenario.behave_step_tools import BehaveStepTools

holado_scripting/tests/behave/steps/common/tools/variable_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
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.exceptions.technical_exception import TechnicalException
 import base64
@@ -26,6 +26,7 @@ from holado_value.common.tables.value_table_with_header import ValueTableWithHea
 from holado_value.common.tables.value_table import ValueTable
 from holado_core.common.tools.tools import Tools
 from holado_python.standard_library.typing import Typing
+from holado_value.common.tables.value_table_manager import ValueTableManager
 
 logger = logging.getLogger(__name__)
 
@@ -98,7 +99,7 @@ def step_impl(context, var_name, object_value):
             row = None
             
         if row is not None:
-            if isinstance(table, ValueTable) or isinstance(table, ValueTableWithHeader):
+            if ValueTableManager.is_value_table(table):
                 res = [c.value for c in row]
             else:
                 res = [c.content for c in row]