holado 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

holado_docker/tools/docker_controller/server/rest/openapi.yaml

@@ -9,6 +9,47 @@ info:
     For example, it is usefull for a testing solution needing to restart a microservice of the SUT (System Under Test),
     but the testing solution docker image has not the privileges to do it.
 paths:
+  /os/env:
+    get:
+      description: "Get environment variable values"
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: "array"
+              items:
+                type: "string"
+      responses:
+        200:
+          description: "Environment variable values"
+          content:
+            application/json:
+              schema:
+                type: "array"
+                items:
+                  type: "object"
+
+  /os/ls:
+    get:
+      description: "List directory filenames"
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: "object"
+              properties:
+                path:
+                  type: string
+      responses:
+        200:
+          description: "Directory filenames"
+          content:
+            application/text:
+              schema:
+                type: "array"
+                items:
+                  type: "string"
+
   /container:
     get:
       description: "List containers and their status"
@@ -143,6 +184,76 @@ paths:
             application/json:
               schema:
                 type: "string"
+                
+  /config/yaml_file:
+    get:
+      description: "Get content of a YAML file"
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: "object"
+              properties:
+                file_path:
+                  type: string
+      responses:
+        200:
+          description: ""
+          content:
+            application/text:
+              schema:
+                type: "string"
+    patch:
+      description: "Update a YAML file"
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: "object"
+              properties:
+                file_path:
+                  type: string
+                yaml_string:
+                  type: string
+                with_backup:
+                  type: "boolean"
+                  default: false
+                backup_extension:
+                  type: string
+                  default: '.bak'
+      responses:
+        200:
+          description: ""
+          content:
+            application/json:
+              schema:
+                type: "string"
+    put:
+      description: "Replace a YAML file"
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: "object"
+              properties:
+                action:
+                  description: "Action to perform"
+                  type: string
+                  enum:
+                    - "restore"
+                file_path:
+                  type: string
+                backup_extension:
+                  type: string
+                  default: '.bak'
+      responses:
+        200:
+          description: ""
+          content:
+            application/json:
+              schema:
+                type: "string"
+
 components:
   securitySchemes: {}
   schemas:

holado_docker/tools/docker_controller/server/run_docker_controller_in_docker.sh

@@ -12,6 +12,7 @@
 #     Have access to any HolAdo registry.
 #
 #     Optionally, define in .profile the following variables
+#         - HOLADO_DOCKER_CONTROLLER_NAME: name of the container
 #         - HOLADO_DOCKER_CONTROLLER_PORT: REST API port to use (default: 8000)
 #         - HOLADO_IMAGE_REGISTRY: docker image registry to use (default: holado/docker_controller)
 #         - HOLADO_IMAGE_TAG: docker image tag to use (default: latest)
@@ -89,7 +90,7 @@ echo "    port: ${HOLADO_DOCKER_CONTROLLER_PORT}"
 #echo "    NETWORK_DEF_COMMAND=${NETWORK_DEF_COMMAND}"
 echo
 docker run --rm --user root --name ${HOLADO_DOCKER_CONTROLLER_NAME} \
-    --privileged -v /var/run/docker.sock:/var/run/docker.sock \
+    --privileged -v $(docker info | grep -i rootless > /dev/null && echo -n "/run/user/$(id -u ${USER})/docker.sock" || echo -n "/var/run/docker.sock"):/var/run/docker.sock \
     -v "${OUTPUT_DIR}":/output \
     -v "${RESOURCES_DIR}":/resources \
     -e HOLADO_OUTPUT_BASEDIR=/output \

holado_helper/docker/run_holado_test_nonreg_in_docker.sh

@@ -109,7 +109,7 @@ echo
 echo "Running tests (docker name: ${HOLADO_RUNNER_NAME})..."
 echo
 # Note: In bellow command, some non-regression scenarios are skipped, those currently not working when run in docker
-docker run --rm -t $((docker info | grep -i rootless > /dev/null && echo -n "--user root") || echo -n "-u $(id -u ${USER}):$(id -g ${USER})") --name ${HOLADO_RUNNER_NAME} \
+docker run --rm -t $(docker info | grep -i rootless > /dev/null && echo -n "--user root" || echo -n "-u $(id -u ${USER}):$(id -g ${USER})") --name ${HOLADO_RUNNER_NAME} \
 	-v "${OUTPUT_DIR}":/output \
 	-v "${RESOURCES_DIR}":/resources \
 	${LOGGING_CONF_CMD} \

holado_helper/docker/run_terminal_in_docker.sh

@@ -90,7 +90,7 @@ fi
 echo
 echo "Running tests (docker name: ${HOLADO_RUNNER_NAME})..."
 echo
-docker run --rm -it $((docker info | grep -i rootless > /dev/null && echo -n "--user root") || echo -n "-u $(id -u ${USER}):$(id -g ${USER})") --name ${HOLADO_RUNNER_NAME} \
+docker run --rm -it $(docker info | grep -i rootless > /dev/null && echo -n "--user root" || echo -n "-u $(id -u ${USER}):$(id -g ${USER})") --name ${HOLADO_RUNNER_NAME} \
     -v "${OUTPUT_DIR}":/output \
     -v "${RESOURCES_DIR}":/resources \
     -e HOLADO_OUTPUT_BASEDIR=/output \

holado_json/tests/behave/steps/ipc/json_steps.py

@@ -22,6 +22,7 @@ import logging
 from holado_value.common.tables.converters.value_table_converter import ValueTableConverter
 from holado_core.common.tools.tools import Tools
 from holado_json.ipc.json_converter import JsonConverter
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 
 logger = logging.getLogger(__name__)
 
@@ -107,6 +108,16 @@ def step_impl(context, var_name, json_text):
     
     __get_variable_manager().register_variable(var_name, json_object)
     
+@Step(r"(?P<var_name>{Variable}) = json object")
+def step_impl(context, var_name):
+    var_name = StepTools.evaluate_variable_name(var_name)
+    json_text = BehaveStepTools.get_step_multiline_text(context)
+    
+    converter = JsonConverter()
+    json_object = converter.to_json(json_text)
+    
+    __get_variable_manager().register_variable(var_name, json_object)
+    
 @Step(r"(?P<var_name>{Variable}) = convert name/value table (?P<table_varname>{Variable}) to json")
 def step_impl(context, var_name, table_varname):
     var_name = StepTools.evaluate_variable_name(var_name)

holado_python/common/iterables.py

@@ -14,6 +14,8 @@
 
 
 import logging
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_python.standard_library.typing import Typing
 
 logger = logging.getLogger(__name__)
 
@@ -27,4 +29,10 @@ def is_sorted(iterable, key=lambda x:x, reverse=False):
     else:
         return all(key(iterable[i]) <= key(iterable[i+1]) for i in range(len(iterable) - 1))
     
+def remove_all(iterable, value):
+    if not isinstance(iterable, list):
+        raise TechnicalException(f"Unmanaged to remove all for iterable type {Typing.get_object_class_fullname(iterable)}")
     
+    new_list = [x for x in iterable if x != value]
+    del iterable[:]
+    iterable.extend(new_list)

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

@@ -2,20 +2,20 @@
 MIIDZTCCAk2gAwIBAgIBKjANBgkqhkiG9w0BAQsFADCBizELMAkGA1UEBhMCVVMx
 CzAJBgNVBAgMAkNBMRYwFAYDVQQHDA1TYW4gRnJhbmNpc2NvMQ8wDQYDVQQKDAZ0
 Y3BiaW4xDDAKBgNVBAsMA29wczETMBEGA1UEAwwKdGNwYmluLmNvbTEjMCEGCSqG
-SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUwODAxMTcyMTEzWhcN
-MjUwODAyMTcyMTEzWjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
-DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMb4NMxoGghdBn/I/dg0FERytyuY
-l9PilUcZ0T1nKSMACigQKW4uBUzWIhZ85j9Yseve7Cl3saJRsNegbhTpdhs+OVhV
-CtfLZewYsEi+lIe4d0+6hz9EZTtF/mOivygXpL7kQdjTPfxwUehFWi8fvzd8o2ow
-Bghd4o+IRY5/b2xUNoUTDesasn3yY39TjP0Qa1SesM/sjJMoO3Z6eUSNRodkm5FO
-F+tm2WSvYCITWg6BkYyvHMTVqANE1R81+kbJTo982El3aCCtIgufSAkKeST1L6DI
-Rrz+haVFUgIpMRm04VCqvCGALZz9of4uWCPTAeSQ0A7RWJSoTSTYJxIi69cCAwEA
-AaNCMEAwHQYDVR0OBBYEFCT97QJofAe/SSTXO+h61u42RjH7MB8GA1UdIwQYMBaA
-FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQAevYzyXKC4
-TFfdz5s65VJzA7Xhx7evKKfRZpbsEfFieiVS4toeunakJ95kjwkfcnFqklj5+McN
-RRZ57giTUJvjcHCFc3tNnA8TU+bfNakNuwrgBVE4XZk3VWD2/SMxHHa4um02n/D8
-sk/3/ZwvbPJ9uXxeg0Y2bzNLd1MUwkLRQNUI4UXmUZraSa71LgE+rFD8VMZRz+9m
-ZMi9XVEQr7w/gLNWWjb8VhiUPhWs7XpEVhXaKz5aGPOo96JuV0gilg86Df8Gy5B1
-GV+nJ2Sn8yFKAOg53oRn61SXRrRocjHKplIAoG718CwYjqyJPgWfx+86fU2CBa/6
-TYDSHo6NkkLD
+SIb3DQEJARYUaGFycnliYWdkaUBnbWFpbC5jb20wHhcNMjUwOTAxMTAxNDQ4WhcN
+MjUwOTAyMTAxNDQ4WjAcMRowGAYDVQQDDBF0Y3BiaW4uY29tLWNsaWVudDCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMHQeuEPAhoVTo8M3sAmA6gDvsz6
+6dZ8UvhuvT8euQWB2p37nrNy+/DskwdR5NYdyrqyJ8ZxgO9UGcOi6Kg/xpv5R4Hv
+DKL5PJ1zVsG10pAY3zbAyVuw03S++tXhG910pTTUQyMEgXTxg18PBaA9ocW5VRCJ
+cbjQVVLikaI+YzeeOmDbgEBys0svG5W8oDoTh+AcoKp6Jpoxh5mZ2TrVXgP0IAZY
+5I1S7HJLTtd7DOLiyWg3OydHNvvZaJ8MJPxZWtRqJbjRVfKbctgCgXDsH0YPHatX
+48Z7gOK17LUFQYOa4FAcT1wlrxKW6jE8tDRO3W4lyr7S3mzrsshxBzCcz7cCAwEA
+AaNCMEAwHQYDVR0OBBYEFO3W/Yg4a3z1jH7AZOpc38UZy9onMB8GA1UdIwQYMBaA
+FOLuMowBSAZfV5v82LmlaIIOvU/DMA0GCSqGSIb3DQEBCwUAA4IBAQAJ10bOcpm3
+/CqQSf2Lz1P0Fcf/I2o2TnCUgrkDDKUVOEK7txnpc6Djz9KxSJiePM/U9NYOzFX1
+48qpynGOlA2m/tR+56RVCvTI8yPIqKWk/NGU7TpDfxrbY4DKCqEnDewiiEx4+aJg
+kwvoH4qClrt+PWY3NKpvFI9Bh1ilRTEB/bGqTwOZWMpv+s215SxywjXcXsZ49dFm
+gebdkuQVnD4VkSvH8SjyT28H0Yk/GyCfjzRdKPR8PilHnkJLlO9tmBTyFJ6eSwdZ
+fSxNqDyv9JwK7uGUZv5k4A7QZMLkSJNwAxyck8lLNW9YpY74wpaDqTB+ZUy8XNai
+jpB+z/vD71Qg
 -----END CERTIFICATE-----

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

@@ -1,28 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDG+DTMaBoIXQZ/
-yP3YNBREcrcrmJfT4pVHGdE9ZykjAAooECluLgVM1iIWfOY/WLHr3uwpd7GiUbDX
-oG4U6XYbPjlYVQrXy2XsGLBIvpSHuHdPuoc/RGU7Rf5jor8oF6S+5EHY0z38cFHo
-RVovH783fKNqMAYIXeKPiEWOf29sVDaFEw3rGrJ98mN/U4z9EGtUnrDP7IyTKDt2
-enlEjUaHZJuRThfrZtlkr2AiE1oOgZGMrxzE1agDRNUfNfpGyU6PfNhJd2ggrSIL
-n0gJCnkk9S+gyEa8/oWlRVICKTEZtOFQqrwhgC2c/aH+Llgj0wHkkNAO0ViUqE0k
-2CcSIuvXAgMBAAECggEBAMYyy01uybfZCrdR/ONYhXPlneb0mxE7HR51bkQvNgAi
-cvuTleGmQCtZBx3Fjwo9DQb7yd5I2A7sNy+kJOP552ed5TvDgwiRGVdFBJ2CEqzb
-qSYnlcAFHp4bzBtuK+MBIl/xOlKForKLJFwucXaNtknMg3AspGXDOANoaHlZIiIS
-Q5TDBX+2twIWvTiSRB5TZrU9QCsKPXNt+jiFcVEt8fBSUIDALhipy/unWB5L40ku
-8xoURdelZkAvA5vW53FxSf0yxkZqgNEUWyKQuBH7mUo1yoDI6o+ANF5iwOdxDKwY
-9tmgIjhD0rK3Whq17Za0dp+U8DUSZ02jkhjpFXKbEGkCgYEA4n01+CQF0hfSaiH1
-lpSk5wnJelR4UE0MhZ3Z5zvAnqjSmT3eVbv2t4O61ZxceINDQ2eAm1fId7q16WYB
-pJmUO2K/X2J0gUtWetY1ZrD5klfSAdq249yKt1kjVzZRw46ulHEdlZDOhtSpHDmp
-S98fCpdYGx9FUjpdfcJWOhSsv+MCgYEA4OUNE/KJnArD8BjlzvjavS1pLU4X/6CA
-net7ipnUubnzkOpKKS5iMnXkZ83DFAQNdpcfvOjrXPUgM4JLjlfc/7MBZo+x1Hqd
-0lQbXBuwkFHcQ/pvuMLp2RY0j975Yfx0xBjJu5eTaO6qW8b1bQeyn6WMb+VOSvgP
-22LjHq/i/n0CgYBaQfWw9oIPUIj83J2nLYNtwvu0sVblAV99HAPLX4eKctLCWOJy
-nh5a0bcyC0bai8zRXrzkqx3rgM+fvJPpCX8GD3seQvkU0XYcK6NKUjqS9EZvkL6T
-nb72BCLOTYpV+VVfOJjGkteK6dKeuefaoYcYTGnDHTod476AMGL2cGjLawKBgCCk
-/u37UcBFy8VJR+pwMwgs1EyQPmmLub+yk989jyRaeqF5cMRjiDt842ex9XQtVmr1
-atT4FloK9t6jNiZ2WI0BRd3GU/Dcz5XdQY9wMYPxbgCsFJWELX+meoC7xAVWKPji
-BD5ntS0RH8dsrOljqakE1crURTYapeqZgxBMRa3dAoGARc3CFtg97dEF4hoppiUk
-q2+syv9KrBXef2WppvJQSc9H/EW3D32P6ypnEolAxeFYorOuboIJZ/gMwwVS+MxS
-DGe7ECMHAy5lqjVmr7eoIww9uF5TgRr2JLusBNx7yryxGoCVWSx8cCMU7aNEy50a
-WSQlBcP2uB80Va+Ms/NxWQ4=
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDB0HrhDwIaFU6P
+DN7AJgOoA77M+unWfFL4br0/HrkFgdqd+56zcvvw7JMHUeTWHcq6sifGcYDvVBnD
+ouioP8ab+UeB7wyi+Tydc1bBtdKQGN82wMlbsNN0vvrV4RvddKU01EMjBIF08YNf
+DwWgPaHFuVUQiXG40FVS4pGiPmM3njpg24BAcrNLLxuVvKA6E4fgHKCqeiaaMYeZ
+mdk61V4D9CAGWOSNUuxyS07Xewzi4sloNzsnRzb72WifDCT8WVrUaiW40VXym3LY
+AoFw7B9GDx2rV+PGe4Ditey1BUGDmuBQHE9cJa8SluoxPLQ0Tt1uJcq+0t5s67LI
+cQcwnM+3AgMBAAECggEAIIfVmCDkwWwCG5CVcrrusiyuwcj7pryHUJuFuCp386yv
+/QRWxtft4apTo07jkey+Mkfk1TIH6iO7j1KwqkzKETPuBKkS/efHfMX3MdxK01TZ
+Yl9JbNJpK5dCktON0cXaVNuryRzgfbhrzHDBCPxPQtiwpm3rYJHXQGo293xxOsxR
+MzVn4oGjQIxQc49QAs0Xgqxn38wUPcgej3vCtSlaUIDxTwfugEoQQ1x5n2D6k7Re
+7gPPrHskIr9YuuqQlDzyJ3qVAI/HQiQPQbJzwWgtRVSb12/Yzb0gSMi86kMvn4Oy
+Zb3S+PSM+dKhMNLG/7QZHyc3R+Us3PMOnS/QiidvgQKBgQDp0zIluHEVcN6+wHsD
+pugM4A1Rll1VY/tu8OIwb7X8Tb24wIKQyA64FkAz6BVriXBN5gqqgXclE5PNh34b
+0FVfv0t0Hm9aVzxKXlfDVEFzIMQammKHZuVyHILNxNqggnTC4zzqrxUlITzqb+kc
+7l0rb8aoc7HYsxq8ZWv6l+5LbwKBgQDUMegGYQ8S6QhJeRoO12E7tDFSJVXhjW3Z
+jXsZaXgENI3d3wk2WUSQZK8D8fFoRM41ctfn9c4xm3vj1iDaGIYox76FCE4QyXez
+mvQoVPz+3lBiTBQTQpcI3XLZPH+rjdM4M7WsAxd5yGaW2r23+8WNDdEdGd+P0sQ4
+GnIEuyA8OQKBgQCuLY+2f41lbl3O9GzuTH+hT6k8NGk0ObVLcA7eC+khl/uSy3y3
+Qv+L669Ju0FxiMDqlkktuCE7sjiwqpSrPWbLWyFmz2Edh8w2jc6Mh4/1pdvPAWAS
+Avk6JrjddR1y4Zr+re1r2J5EuVy6OkEJNxqaR7pRM1Ww2cI5wsdLta9h6wKBgQCl
+aYIF9wNZKm9bVxwJFbymXgFUl+YqvaU0QiYD2UPFg3JT0tnLlCrupI4J9UDKl1ho
+Me481FC4OwyIvxM88IEkqRDLg33XeDXnvJM4HYha5dKjzcqYeQBj2Lz+uzqK8TQG
+S8kDHiXeuWm/jyT1lz6YhnzMwq6T3yk20uau6XBngQKBgCpM3x2XqCiPzlQ/da84
+7SsCJ1jp4PJt1PCjFbp6jzPw9FD7lj1nSzGvVAEwKyL0OXq4k3+o9Nj/KYqncXzJ
+v8GmSyjEtSy1VynW8D1VAtCbfI7GHa+TflcjLqKb2BN+BpTGjeVPRbXVUlwqFF3I
+ughugjyndVciKdl7MmifCz92
 -----END PRIVATE KEY-----

holado_rabbitmq/tools/rabbitmq/rabbitmq_client.py

@@ -11,7 +11,6 @@
 # The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
 #################################################
 
-import time
 import logging
 from holado_core.common.exceptions.functional_exception import FunctionalException
 from holado_core.common.exceptions.technical_exception import TechnicalException
@@ -27,7 +26,6 @@ from holado_core.common.exceptions.verify_exception import VerifyException
 import abc
 from holado_multitask.multithreading.loopfunctionthreaded import LoopFunctionThreaded
 from holado_multitask.multitasking.multitask_manager import MultitaskManager
-from holado.common.tools.gc_manager import GcManager
 
 
 logger = logging.getLogger(__name__)

holado_system/tests/behave/steps/system/file_steps.py

@@ -46,6 +46,13 @@ def __get_path_manager():
     return SessionContext.instance().path_manager
 
 
+@Then(r"file (?P<path>{Str}) (?P<exists_str>exists|doesn't exist)")
+def step_impl(context, path, exists_str):  # @DuplicatedSignature
+    path = StepTools.evaluate_scenario_parameter(path)
+    exists = exists_str == "exists"
+    
+    __get_path_manager().check_file_exists(path, do_exist=exists, raise_exception=True)
+
 @Given(r"(?P<var_name>{Variable}) = is path (?P<path>{Str}) an absolute file path")
 def step_impl(context, var_name, path):  # @DuplicatedSignature
     var_name = StepTools.evaluate_variable_name(var_name)
@@ -112,27 +119,38 @@ def step_impl(context, data, file):
     
     file.write(data)
 
-@Given(r"(?P<var_name>{Variable}) = content of file (?P<path>{Str})")
-def step_impl(context, var_name, path):  # @DuplicatedSignature
+@Given(r"(?P<var_name>{Variable}) = content of(?:(?P<is_text_file_str> text))? file (?P<path>{Str})")
+def step_impl(context, var_name, is_text_file_str, path):  # @DuplicatedSignature
     var_name = StepTools.evaluate_variable_name(var_name)
+    is_text_file = is_text_file_str is not None
     path = StepTools.evaluate_scenario_parameter(path)
-    content = open(path, "rb").read()
-    __get_variable_manager().register_variable(var_name, content)
+    
+    mode = 'rt' if is_text_file else 'rb'
+    with open(path, mode) as fin:
+        res = fin.read()
+    
+    __get_variable_manager().register_variable(var_name, res)
 
 @Given(r"(?P<var_name>{Variable}) = content of file (?P<path>{Str}) in base 64")
 def step_impl(context, var_name, path):  # @DuplicatedSignature
     var_name = StepTools.evaluate_variable_name(var_name)
     path = StepTools.evaluate_scenario_parameter(path)
-    content = open(path, "rb").read()
-    content64 = base64.b64encode(content)
-    __get_variable_manager().register_variable(var_name, content64)
+
+    with open(path, "rb") as fin:
+        content = fin.read()
+    res = base64.b64encode(content)
+    
+    __get_variable_manager().register_variable(var_name, res)
 
 @Given(r"(?P<var_name>{Variable}) = lines of file (?P<path>{Str})")
 def step_impl(context, var_name, path):  # @DuplicatedSignature
     var_name = StepTools.evaluate_variable_name(var_name)
     path = StepTools.evaluate_scenario_parameter(path)
-    lines = open(path, "r").readlines()
+
+    with open(path, "r") as fin:
+        lines = fin.readlines()
     res = list(map(lambda x: x.strip('\n'), lines))
+    
     __get_variable_manager().register_variable(var_name, res)
 
 

holado_test/common/context/scenario_context.py

@@ -24,8 +24,6 @@ from holado_core.common.block.block_manager import BlockManager
 from datetime import datetime
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado_scripting.text.verifier.text_verifier import TextVerifier
-from holado_core.common.resource.persisted_method_to_call_manager import PersistedMethodToCallManager
-from holado_python.standard_library.typing import Typing
 from holado_multitask.multitasking.multitask_manager import MultitaskManager
 
 logger = logging.getLogger(__name__)
@@ -33,7 +31,7 @@ logger = logging.getLogger(__name__)
 
 class ScenarioContext(Context):
     def __init__(self, scenario):
-        super().__init__("Scenario")
+        super().__init__("Scenario", with_post_process=True)
         
         self.__scenario = scenario
         
@@ -43,14 +41,6 @@ class ScenarioContext(Context):
         self.__main_thread_uid = SessionContext.instance().multitask_manager.main_thread_uid
         self.__steps_by_thread_uid = {}
         
-        # Post process management
-        self.__persisted_method_to_call_manager = PersistedMethodToCallManager()
-        self.__persisted_method_to_call_manager.initialize(SessionContext.instance().resource_manager, SessionContext.instance().expression_evaluator)
-        self.__post_process_funcs = []
-        
-    def initialize(self):
-        self.__persisted_method_to_call_manager.ensure_persistent_db_exists()
-    
     def __str__(self):
         return f"{{ScenarioContext({id(self)}):{self.scenario.name}}}"
 
@@ -161,57 +151,6 @@ class ScenarioContext(Context):
     
     def end(self):
         self.__end_date = datetime.now()
-    
-    
-    ### Post process management
-    
-    def add_post_process(self, func):
-        success = self.__persist_function(func)
-        if not success:
-            logger.debug(f"Add scenario post process in memory, persistence in DB has failed (post process function: {func})")
-            self.__post_process_funcs.append(func)
-    
-    def __persist_function(self, func):
-        try:
-            if Typing.is_function(func._target):
-                func_qualname = Typing.get_function_fullname(func._target)
-                self.__persisted_method_to_call_manager.add_function_to_call(func_qualname, args_list=func._args, kwargs_dict=func._kwargs, use="scenario_post_process", use_index=None)
-                return True
-            elif Typing.is_method(func._target):
-                meth_func = Typing.get_method_function(func._target)
-                func_qualname = Typing.get_function_fullname(meth_func)
-                meth_obj = Typing.get_method_object_instance(func._target)
-                self_getter_eval_str = SessionContext.instance().get_object_getter_eval_string(meth_obj, raise_not_found=False)
-                if self_getter_eval_str is not None:
-                    self.__persisted_method_to_call_manager.add_method_to_call(func_qualname, self_getter_eval_str, args_list=func._args, kwargs_dict=func._kwargs, use="scenario_post_process", use_index=None)
-                    return True
-            else:
-                raise TechnicalException(f"Unmanaged target type '{Typing.get_object_class_fullname(func._target)}'")
-        except TechnicalException as exc:
-            raise exc
-        except Exception as exc:
-            logger.warning(f"Failed to persist function {func}: {exc}")
-        return False
-        
-    def do_post_processes(self):
-        # First call functions that were not persisted
-        for func in self.__post_process_funcs:
-            try:
-                func.run()
-            except Exception as exc:
-                # logger.error(f"Error while post processing [{func}]: {exc}")
-                logger.exception(f"Error while scenario post processing [{func}]: {exc}")
-        
-        # Call persisted functions and methods
-        try:
-            self.__persisted_method_to_call_manager.call_functions_and_methods(use="scenario_post_process", delete_after_call=True)
-        except Exception as exc:
-            logger.exception(f"Error while scenario post processing persisted methods: {exc}")
-        
-    def do_previous_scenario_post_processes(self):
-        """Call functions and methods persisted by a previous scenario
-        Note: This is useful especially when a scenario execution was interrupted before post processes could be performed
-        """
-        self.__persisted_method_to_call_manager.call_functions_and_methods(use="scenario_post_process", delete_after_call=True)
-        
+
+
         

holado_test/scenario/step_tools.py

@@ -398,6 +398,28 @@ class StepTools(object):
         except FunctionalException as exc:
             raise FunctionalException(f"Obtained table contains at least a row of expected table (obtained = table 1 ; expected = table 2):\n{Tools.indent_string(4, exc.message)}") from exc
     
+    @classmethod
+    def format_step(cls, step_str, keyword=None, table=None, text=None):
+        step_str = step_str.strip()
+        
+        if keyword is not None:
+            res = f"{keyword} {step_str}"
+        else:
+            res = step_str
+            
+        if table is not None:
+            if isinstance(table, Table):
+                rendered_table = table.represent(indent=4)
+            else:
+                raise TechnicalException(f"Unmanaged table of type '{Typing.get_object_class_fullname(table)}'")
+            res = u"{res}\n{table}".format(res=res, table=rendered_table)
+        elif text is not None:
+            rendered_text = text.replace(u'"""', u'\\"\\"\\"')
+            rendered_text = Tools.indent_string(4, u'"""\n' + rendered_text + '\n"""\n')
+            res = u"{res}\n{text}".format(res=res, text=rendered_text)
+            
+        return res
+        
     @classmethod
     def format_steps_with(cls, steps, format_with_list):
         res = steps

holado_yaml/tests/behave/steps/yaml_steps.py

@@ -18,6 +18,7 @@ from holado.common.context.session_context import SessionContext
 from holado_test.behave.behave import *  # @UnusedWildImport
 import logging
 from holado_yaml.yaml.yaml_manager import YAMLManager
+from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
 
 logger = logging.getLogger(__name__)
 
@@ -33,31 +34,127 @@ if YAMLManager.is_available():
     def __get_path_manager():
         return SessionContext.instance().path_manager
     
+    def __get_client(client_type, client):
+        client_type = StepTools.evaluate_scenario_parameter(client_type)
+        client = StepTools.evaluate_variable_name(client)
+        
+        if client is None:
+            return YAMLManager.get_client(client_type)
+        else:
+            return client
+    
+    
+    @Step(r"(?P<var_name>{Variable}) = new YAML client(?: \(client type: (?P<client_type>{Str})\))?")
+    def step_impl(context, var_name, client_type):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        client_type = StepTools.evaluate_scenario_parameter(client_type)
+        
+        res = YAMLManager.get_client(client_type)
+        
+        __get_variable_manager().register_variable(var_name, res)
+    
+    
+    # Manage YAML objects
+    
+    @Step(r"(?P<var_name>{Variable}) = YAML object(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, var_name, client_type, client):
+        var_name = StepTools.evaluate_variable_name(var_name)
+        client = __get_client(client_type, client)
+        text = BehaveStepTools.get_step_multiline_text(context)
+        
+        res = client.load_string(text)
+        
+        __get_variable_manager().register_variable(var_name, res)
+    
+    @Step(r"update YAML object (?P<obj>{Variable}) with data (?P<data>{Variable})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, obj, data, client_type, client):  # @DuplicatedSignature
+        obj = StepTools.evaluate_scenario_parameter(obj)
+        data = StepTools.evaluate_scenario_parameter(data)
+        client = __get_client(client_type, client)
+        
+        client.update_data(obj, data)
+    
+    @Step(r"(?P<var_name>{Variable}) = convert YAML object (?P<obj>{Variable}) to string(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, var_name, obj, client_type, client):  # @DuplicatedSignature
+        var_name = StepTools.evaluate_variable_name(var_name)
+        obj = StepTools.evaluate_scenario_parameter(obj)
+        client = __get_client(client_type, client)
+        
+        res = client.save_in_string(obj)
+        
+        __get_variable_manager().register_variable(var_name, res)
     
-    @Step(r"(?P<var_name>{Variable}) = load YAML file (?P<path>{Str})(?:(?P<with_only_strings_str> \(with only strings\))|(?P<with_full_yaml_features_str> \(with full YAML features\)))?")
-    def step_impl(context, var_name, path, with_only_strings_str, with_full_yaml_features_str):  # @DuplicatedSignature
+    
+    # Manage YAML strings
+    
+    @Step(r"(?P<var_name>{Variable}) = load YAML string (?P<text>{Str})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, var_name, text, client_type, client):  # @DuplicatedSignature
+        var_name = StepTools.evaluate_variable_name(var_name)
+        text = StepTools.evaluate_scenario_parameter(text)
+        client = __get_client(client_type, client)
+        
+        res = YAMLManager.load_string(text, client_type=client_type)
+        
+        __get_variable_manager().register_variable(var_name, res)
+    
+    @Step(r"(?P<var_name>{Variable}) = update YAML string (?P<text>{Str}) with data (?P<data>{Variable})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, var_name, text, data, client_type, client):  # @DuplicatedSignature
+        var_name = StepTools.evaluate_variable_name(var_name)
+        text = StepTools.evaluate_scenario_parameter(text)
+        data = StepTools.evaluate_scenario_parameter(data)
+        client = __get_client(client_type, client)
+        
+        res = YAMLManager.update_string(text, data, client=client)
+        
+        __get_variable_manager().register_variable(var_name, res)
+    
+    
+    # Manage YAML files
+    
+    @Step(r"(?P<var_name>{Variable}) = load YAML file (?P<path>{Str})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, var_name, path, client_type, client):  # @DuplicatedSignature
         var_name = StepTools.evaluate_variable_name(var_name)
         path = StepTools.evaluate_scenario_parameter(path)
+        client = __get_client(client_type, client)
         
-        res = YAMLManager.load_file(path, with_only_strings_str is not None, with_full_yaml_features_str is not None)
+        res = YAMLManager.load_file(path, client=client)
         
         __get_variable_manager().register_variable(var_name, res)
     
-    @Step(r"(?P<var_name>{Variable}) = load multiple documents YAML file (?P<path>{Str})(?:(?P<with_only_strings_str> \(with only strings\))|(?P<with_full_yaml_features_str> \(with full YAML features\)))?")
-    def step_impl(context, var_name, path, with_only_strings_str, with_full_yaml_features_str):  # @DuplicatedSignature
+    @Step(r"(?P<var_name>{Variable}) = load multiple documents YAML file (?P<path>{Str})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, var_name, path, client_type, client):  # @DuplicatedSignature
         var_name = StepTools.evaluate_variable_name(var_name)
         path = StepTools.evaluate_scenario_parameter(path)
+        client = __get_client(client_type, client)
         
-        res = YAMLManager.load_multiple_documents_file(path, with_only_strings_str is not None, with_full_yaml_features_str is not None)
+        res = YAMLManager.load_multiple_documents_file(path, client=client)
         
         __get_variable_manager().register_variable(var_name, res)
     
-    @Step(r"save (?P<data>{Variable}) in YAML file (?P<path>{Str})")
-    def step_impl(context, data, path):  # @DuplicatedSignature
+    @Step(r"save (?P<data>{Variable}) in YAML file (?P<path>{Str})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?\))?")
+    def step_impl(context, data, path, client_type, client):  # @DuplicatedSignature
         data = StepTools.evaluate_scenario_parameter(data)
         path = StepTools.evaluate_scenario_parameter(path)
+        client = __get_client(client_type, client)
+        
+        YAMLManager.save_in_file(path, data, client=client)
+    
+    @Step(r"update YAML file (?P<path>{Str}) with data (?P<data>{Variable})(?: \((?:client type: (?P<client_type>{Str}))?(?: ; )?(?:client: (?P<client>{Variable}))?(?: ; )?(?:(?P<with_backup_str>with backup))?(?: ; )?(?:backup extension: (?P<backup_extension>{Str}))?\))?")
+    def step_impl(context, path, data, client_type, client, with_backup_str, backup_extension):  # @DuplicatedSignature
+        path = StepTools.evaluate_scenario_parameter(path)
+        data = StepTools.evaluate_scenario_parameter(data)
+        client = __get_client(client_type, client)
+        with_backup = with_backup_str is not None
+        backup_extension = StepTools.evaluate_scenario_parameter(backup_extension)
+        
+        YAMLManager.update_file(path, data, client=client, with_backup=with_backup, backup_extension=backup_extension)
+    
+    @Step(r"restore YAML file (?P<path>{Str})(?: \((?:backup extension: (?P<backup_extension>{Str}))?\))?")
+    def step_impl(context, path, backup_extension):  # @DuplicatedSignature
+        path = StepTools.evaluate_scenario_parameter(path)
+        backup_extension = StepTools.evaluate_scenario_parameter(backup_extension)
         
-        YAMLManager.save_file(data, path)
+        YAMLManager.restore_file(path, backup_extension=backup_extension)