holado 0.2.4__tar.gz → 0.2.5__tar.gz

{holado-0.2.4 → holado-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.2.4
+Version: 0.2.5
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.2.5/packaging/VERSION

@@ -0,0 +1 @@
+0.2.5

{holado-0.2.4 → holado-0.2.5}/src/holado/__init__.py

@@ -27,7 +27,7 @@ except:
     with_behave = False
 
 logger = None
-
+__initialized = False
 
 def __initialize_holado_loggers():
     global logger
@@ -38,27 +38,29 @@ def __initialize_holado_loggers():
     
     
     
-def _initialize_logging(initialize_logging=True, logging_config_file=None, log_level=None, log_on_console=False, log_in_file=True):
+def _initialize_logging(use_holado_logger=True, logging_config_file_path=None, log_level=None, log_on_console=False, log_in_file=True):
     # print_imported_modules("[initialize]")
     import holado_logging
     # print_imported_modules("[after import holado_logging]")
 
     # Configure logging module
-    holado_logging.configure(initialize_logging=initialize_logging, log_level=log_level)
+    holado_logging.configure(use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path, log_level=log_level, log_on_console=log_on_console, log_in_file=log_in_file)
     # print_imported_modules("[after import holado_logging]")
 
     # Initialize holado loggers
     __initialize_holado_loggers()
     
-    # Register LogManager in SessionContext
-    holado_logging.register()
-    
-    # Configure log manager
+    # Create session context
     from holado.common.context.session_context import SessionContext
-    SessionContext.instance().log_manager.on_console = log_on_console
-    SessionContext.instance().log_manager.in_file = log_in_file
-    if logging_config_file is not None:
-        SessionContext.instance().log_manager.set_config_file_path(logging_config_file, update_default_level=False)
+    if SessionContext.has_instance():
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        raise TechnicalException(f"Session context was initialized to early (before logging configuration)")
+    SessionContext.instance()
+    
+    # Initialize log manager and register it in session context
+    holado_logging.initialize_and_register()
+    
+    # Set whole logging configuration
     SessionContext.instance().log_manager.set_config()
     
 def change_logging_config(log_level=None, log_on_console=False, log_in_file=True):
@@ -70,54 +72,78 @@ def change_logging_config(log_level=None, log_on_console=False, log_in_file=True
 
 
 def initialize_minimal():
-    _initialize_logging(initialize_logging=False, logging_config_file=None,
-                        log_level=None, log_on_console=True, log_in_file=False)
+    # initialize(TSessionContext=None, use_holado_logger=False, logging_config_file_path=None,
+    #            log_level=None, log_on_console=True, log_in_file=False,
+    #            session_kwargs={'with_session_path':False}, 
+    #            garbage_collector_periodicity=None)
+    initialize(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None,
+               log_level=None, log_on_console=True, log_in_file=False,
+               garbage_collector_periodicity=None)
 
-def initialize(TSessionContext=None, initialize_logging=True, logging_config_file=None, 
+def initialize(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None, 
                log_level=None, log_on_console=False, log_in_file=True, session_kwargs=None,
                garbage_collector_periodicity=default_value):
+    global __initialized
+    if __initialized:
+        from holado_core.common.exceptions.technical_exception import TechnicalException
+        raise TechnicalException(f"HolAdo was already initialized")
+    
     from holado_core.common.tools.tools import Tools
     
     if session_kwargs is None:
         session_kwargs = {}
     with_session_path = session_kwargs.get("with_session_path", True)
     
+    # Reset session context before initializing logging
+    # Note: Session context must not be created before logging initialization
+    from holado.common.context.session_context import SessionContext
+    SessionContext._reset_instance()
     if TSessionContext is not None:
         if isinstance(TSessionContext, str):
             module_name, class_type = TSessionContext.rsplit('.', maxsplit=1)
             module = importlib.import_module(module_name)
             TSessionContext = getattr(module, class_type)
-
-        from holado.common.context.session_context import SessionContext
+        
         SessionContext.TSessionContext = TSessionContext
     
     # Initialize logging
-    _initialize_logging(initialize_logging=initialize_logging, logging_config_file=logging_config_file,
+    _initialize_logging(use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path,
                         log_level=log_level, log_on_console=log_on_console, log_in_file=log_in_file and with_session_path)
     if Tools.do_log(logger, logging.DEBUG):
         logger.debug("Configured logging")
     
     if Tools.do_log(logger, logging.DEBUG):
         logger.debug("Importing HolAdo modules")
-    import_modules(get_holado_module_names())
+    _import_modules(get_holado_module_names())
     
-    initialize_session_context(session_kwargs)
+    _initialize_session_context(session_kwargs)
     
     # Initialize garbage collector
     if garbage_collector_periodicity is not None:
         GcManager.collect_periodically(garbage_collector_periodicity)
         logger.debug(f"Garbage collector is disabled, and collects are automatically done in a dedicated thread (periodicity: {GcManager.get_collect_periodicity()} s)")
     
-def initialize_for_script(TSessionContext=None, initialize_logging=True, logging_config_file=None, log_level=logging.WARNING, log_on_console=True, log_in_file=False, session_kwargs=None):
+    if with_behave:
+        # Register default behave parameter types
+        #TODO: make step tools a service
+        from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
+        BehaveStepTools.register_default_types()
+    
+    __initialized = True
+    
+def initialize_for_script(TSessionContext=None, use_holado_logger=True, logging_config_file_path=None, 
+                          log_level=logging.WARNING, log_on_console=True, log_in_file=False, session_kwargs=None,
+                          garbage_collector_periodicity=None):
     if session_kwargs is None:
         session_kwargs={'with_session_path':log_in_file, 'raise_if_not_exist':False}
         
-    initialize(TSessionContext=TSessionContext, initialize_logging=initialize_logging, logging_config_file=logging_config_file, 
+    initialize(TSessionContext=TSessionContext, use_holado_logger=use_holado_logger, logging_config_file_path=logging_config_file_path, 
                log_level=log_level, log_on_console=log_on_console, log_in_file=log_in_file,
-               session_kwargs=session_kwargs )
+               session_kwargs=session_kwargs,
+               garbage_collector_periodicity=garbage_collector_periodicity )
     
     
-def initialize_session_context(session_kwargs=None):
+def _initialize_session_context(session_kwargs=None):
     from holado_core.common.tools.tools import Tools
     
     if Tools.do_log(logger, logging.DEBUG):
@@ -143,7 +169,7 @@ def get_holado_module_names():
     lp = sorted(os.listdir(get_holado_src_path()))
     return [name for name in lp if name.startswith("holado_") and name not in ['holado_logging']]
 
-def import_modules(module_names):
+def _import_modules(module_names):
     from holado_core.common.tools.tools import Tools
     
     imported_modules = __import_modules(module_names)
@@ -272,6 +298,8 @@ def print_imported_modules(prefix):
     
 
 # Process minimal initialization of HolAdo
-initialize_minimal()
+# Note: Currently, initialization can be done only once, thus minimal initialization is commented.
+#       As a consequence, the call of an initialize method is mandatory
+# initialize_minimal()
 
 

{holado-0.2.4 → holado-0.2.5}/src/holado/common/context/service_manager.py

@@ -170,13 +170,21 @@ class ServiceManager(object):
         return context.get_object(name)
     
     def add_context_property(self, name, context_type, raise_if_service_exist=None):
-        if raise_if_service_exist is None or raise_if_service_exist:
-            self.__verify_service_doesnt_exist(name, context_type, raise_if_service_exist)
+        # Note: next lines are commented, to allow to set again the service in context type
+        # if raise_if_service_exist is None or raise_if_service_exist:
+        #     self.__verify_service_doesnt_exist(name, context_type, raise_if_service_exist)
+        if hasattr(context_type, name):
+            logger.debug(f"Set again the property '{name}' in context type {context_type}")
         
         @property
         def context_service_property(self_context):
             return self._get_context_service(name, self_context)
         setattr(context_type, name, context_service_property)
+        
+        @property
+        def context_has_service_property(self_context):
+            return self_context.has_object(name)
+        setattr(context_type, 'has_' + name, context_has_service_property)
     
     def add_shortcut_property_to_context_service(self, name, dst_type, context_type, raise_if_service_exist=None):
         from holado_multitask.multiprocessing.context.process_context import ProcessContext

{holado-0.2.4 → holado-0.2.5}/src/holado/common/context/session_context.py

@@ -18,6 +18,7 @@ import os.path
 from holado.common.context.context import Context
 from holado_core.common.tools.tools import Tools
 import threading
+from holado.common.handlers.enums import ObjectStates
 
 
 logger = logging
@@ -32,16 +33,37 @@ class SessionContext(Context):
     
     # Singleton management
     __instance = None
+    __is_resetting_instance = False
     
     @staticmethod
     def instance() -> TSessionContext:
+        # Note: If session context istance is under reset, consider it is already None
+        if SessionContext.__is_resetting_instance:
+            return None
+        
         if SessionContext.__instance is None:
             SessionContext.__instance = SessionContext.TSessionContext()
-            # print(f"Created session context of type {SessionContext.TSessionContext}")
+            logger.debug(f"Created session context of type {SessionContext.TSessionContext}")
+            # logging.log(45, f"Created session context of type {SessionContext.TSessionContext}")
             # import traceback
-            # print("".join(traceback.format_list(traceback.extract_stack())))
+            # logging.log(45, "".join(traceback.format_list(traceback.extract_stack())))
         return SessionContext.__instance
     
+    @staticmethod
+    def has_instance() -> bool:
+        if SessionContext.__is_resetting_instance:
+            return False
+        else:
+            return SessionContext.__instance is not None
+    
+    @staticmethod
+    def _reset_instance():
+        if SessionContext.__instance is not None:
+            logger.debug(f"Resetting session context")
+            SessionContext.__is_resetting_instance = True
+            SessionContext.__instance = None
+            SessionContext.__is_resetting_instance = False
+            logger.debug(f"Reset of session context")
     
     def __init__(self, name="Session"):
         super().__init__(name)
@@ -55,12 +77,27 @@ class SessionContext(Context):
         self.__multitask_lock = threading.RLock()
         self.__multitask_step_lock = threading.RLock()
         
+    def __del__(self):
+        # Note: Override Object.__del__ since it supposes that SessionContext is initialized, whereas SessionContext is deleting
+        try:
+            if self.object_state in [ObjectStates.Deleting, ObjectStates.Deleted]:
+                return
+    
+            self.delete_object()
+        except Exception as exc:
+            if "Python is likely shutting down" in str(exc):
+                # Simply return
+                return
+            else:
+                raise exc
+    
     def _delete_object(self):
-        logger.info(f"Delete session context - Interrupting and unregistering all threads...")
         # if Tools.do_log(logger, logging.DEBUG):
         #     logger.debug("Interrupting and unregistering all threads for scenario [{}]".format(scenario.name))
-        self.threads_manager.interrupt_all_threads(scope="Session")
-        self.threads_manager.unregister_all_threads(scope="Session", keep_alive=False)
+        if self.has_threads_manager:
+            logger.info(f"Delete session context - Interrupting and unregistering all threads...")
+            self.threads_manager.interrupt_all_threads(scope="Session")
+            self.threads_manager.unregister_all_threads(scope="Session", keep_alive=False)
         
         # Delete session context
         logger.info(f"Delete session context - Deleting context objects...")
@@ -76,11 +113,6 @@ class SessionContext(Context):
             
         self.__with_session_path = session_kwargs.get("with_session_path", True)
         
-        # Register default behave parameter types
-        #TODO: make step tools a service
-        from holado_test.behave.scenario.behave_step_tools import BehaveStepTools
-        BehaveStepTools.register_default_types()
-        
         # Create this thread context
         self.multitask_manager.get_thread_context()
     
@@ -122,14 +154,13 @@ class SessionContext(Context):
             name = "session_{}".format(datetime.now().strftime("%Y-%m-%d_%H-%M-%S"))
             report_path = self.path_manager.get_reports_path(name)
             logger.info(f"Reports location: {report_path}")
-            # print(f"Reports location: {report_path}")
+            print(f"Reports location: {report_path}")
         self.report_manager.new_session(report_path)
             
         # Logging configuration
         if self.with_session_path and SessionContext.instance().log_manager.in_file:
             log_filename = os.path.join(report_path, "logs", "report.log")
             self.path_manager.makedirs(log_filename)
-            SessionContext.instance().log_manager.on_console = False
             SessionContext.instance().log_manager.set_root_log_file(log_filename)
             SessionContext.instance().log_manager.set_config()
     

{holado-0.2.4 → holado-0.2.5}/src/holado/common/handlers/object.py

@@ -66,15 +66,23 @@ class DeleteableObject(Object):
     
     def __del__(self):
         try:
-            from holado_multitask.multithreading.functionthreaded import FunctionThreaded
-            
             if self.object_state in [ObjectStates.Deleting, ObjectStates.Deleted]:
                 return
             
-            # Note: Garbage collector default mecanism is incompatible with custom object finalizers (cf GcManager.Method __del__ is called by garbage collector. This call can be done in any thread at any moment.
-            if GcManager.is_collect_threaded():
+            if logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"Deleting object of ID {id(self)} and type {type(self)}")
+            if logger.isEnabledFor(logging.TRACE):  # @UndefinedVariable
+                import traceback
+                logger.trace("".join(traceback.format_list(traceback.extract_stack())))
+            
+            # Notes: 
+            #   - Garbage collector default mecanism is incompatible with custom object finalizers (cf GcManager.Method __del__ is called by garbage collector. This call can be done in any thread at any moment.
+            #   - When SessionContext is under deletion, delete any object by thread is not possible
+            from holado.common.context.session_context import SessionContext
+            if GcManager.is_collect_threaded() or isinstance(self, SessionContext.TSessionContext) or not SessionContext.has_instance():
                 self.__delete()
             else:
+                from holado_multitask.multithreading.functionthreaded import FunctionThreaded
                 func = FunctionThreaded(self.__delete, name=f"delete object '{self.name}'", register_thread=False)
                 func.start()
                 func.join(timeout=30, raise_if_still_alive=False)   # timeout of 30s to limit deadlock impact ; raise to False since exceptions are omitted in gc collect context

{holado-0.2.4 → holado-0.2.5}/src/holado/holado_config.py

@@ -16,6 +16,7 @@ class Config(object):
     """HolAdo project configuration"""
 
     # Timeouts
+    session_timeout_seconds = 7 * 24 * 3600     # Session timeout is by default to 7 days
     timeout_seconds = 240            # Default timeout
     join_timeout_seconds = 1800      # Long timeout used when a join should stop without deadlock. When this timeout is reached, a TimeoutTechnicalException is raised
 

{holado-0.2.4 → holado-0.2.5}/src/holado_core/common/tools/path_manager.py

@@ -122,10 +122,14 @@ class PathManager(object):
         else:
             os.replace(src, dst)
     
+    def get_user_home_path(self):
+        import pathlib
+        return str(pathlib.Path.home())
+    
     def get_local_resources_path(self, name=None):
-        base_path = os.getenv('HOLADO_TEST_LOCAL_RESOURCES_BASEDIR')
+        base_path = os.getenv('HOLADO_LOCAL_RESOURCES_BASEDIR')
         if base_path is None:
-            raise Exception("Missing environment variable HOLADO_TEST_LOCAL_RESOURCES_BASEDIR with HolAdo local resources base path")
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'resources')
         
         if name is not None:
             return os.path.join(base_path, name)
@@ -133,9 +137,9 @@ class PathManager(object):
             return base_path
     
     def get_reports_path(self, name=None):
-        base_path = os.getenv('HOLADO_TEST_OUTPUT_BASEDIR')
+        base_path = os.getenv('HOLADO_OUTPUT_BASEDIR')
         if base_path is None:
-            raise Exception("Missing environment variable HOLADO_TEST_OUTPUT_BASEDIR with HolAdo output base path")
+            base_path = os.path.join(self.get_user_home_path(), '.holado', 'output')
         
         if name is not None:
             return os.path.join(base_path, "reports", name)

holado-0.2.5/src/holado_examples/scripts/script_custom_initialization.py

@@ -0,0 +1,16 @@
+import holado
+
+
+# Initialize HolAdo with default behaviours and custom parameters
+
+holado.initialize_for_script(log_on_console=True, log_in_file=True)
+
+import logging
+logging.print("After 'holado.initialize_for_script(log_on_console=True, log_in_file=True)', HolAdo is initialized for scripts with:")
+logging.print("  - add logging levels 'trace' and 'print'")
+logging.print("  - do logs on console and in file")
+logging.print("  - a default session context is initialialized with all available HolAdo services")
+logging.print("  - a session folder is created that will contains at least log files")
+logging.print("  - launch garbage collector periodically (without specifying garbage_collector_periodicity, default periodicity is 10 s)")
+
+

holado-0.2.5/src/holado_examples/scripts/script_minimal_initialization.py

@@ -0,0 +1,23 @@
+import holado
+
+
+# Minimal HolAdo initialization for scripts
+holado.initialize_for_script()
+
+import logging
+logging.print("After 'holado.initialize_for_script()', HolAdo is initialized minimally for scripts with:")
+logging.print("  - add logging levels 'trace' and 'print'")
+logging.print("  - do logs on console but not in file")
+logging.print("  - a default session context is initialialized with all available HolAdo services")
+logging.print("  - no session folder is created")
+
+
+# Launch manually garbage collector periodically
+from holado.common.tools.gc_manager import GcManager
+from holado.common.handlers.undefined import default_value
+GcManager.collect_periodically(collect_periodicity=default_value) 
+logging.print("After 'GcManager.collect_periodically(collect_periodicity=default_value)', garbage collector is launched periodically (with default periodicity that is 10 s)")
+
+
+
+

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/__main__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+
+# This main is only needed to debug behave execution (and thus testing solution) with breakpoints
+
+import re
+import sys
+
+from behave.__main__ import main
+
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/behave_environment.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+import holado_test.behave.behave_environment
+
+
+# Import default hook implementation
+from holado_test.behave.behave_environment import *
+
+# Redefine specific hook implementation
+def before_all(context):
+    holado_test.behave.behave_environment.before_all(context)
+
+def after_all(context):
+    holado_test.behave.behave_environment.after_all(context)
+
+def before_feature(context, feature):
+    holado_test.behave.behave_environment.before_feature(context, feature)
+
+def after_feature(context, feature):
+    holado_test.behave.behave_environment.after_feature(context, feature)
+
+def before_scenario(context, scenario):
+    holado_test.behave.behave_environment.before_scenario(context, scenario)
+
+def after_scenario(context, scenario):
+    holado_test.behave.behave_environment.after_scenario(context, scenario)
+
+def before_step(context, step):
+    holado_test.behave.behave_environment.before_step(context, step)
+
+def after_step(context, step):
+    holado_test.behave.behave_environment.after_step(context, step)
+
+    
+

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/environment.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import logging
+
+
+
+# Add testing solution project source path
+here = os.path.abspath(os.path.dirname(__file__))
+source_path = os.path.normpath(os.path.join(here, 'src'))
+sys.path.insert(0, source_path)
+
+
+# Add HolAdo project paths
+# holado_path = os.getenv('HOLADO_PATH')
+holado_path = None
+if holado_path is None:
+    from holado import get_holado_path
+    holado_path = get_holado_path()
+sys.path.insert(0, holado_path)
+sys.path.insert(0, os.path.join(holado_path, "src") )
+sys.path.insert(0, os.path.join(holado_path, "tests", "behave") )
+
+
+# Configure HolAdo
+import holado
+from context.session_context import TSSessionContext
+# holado.initialize(TSessionContext=TSSessionContext, 
+holado.initialize(TSessionContext=None, 
+                  logging_config_file_path=os.path.join(here, 'logging.conf'), log_level=logging.INFO,
+                  garbage_collector_periodicity=None)
+
+
+# Import generic environment methods
+from behave_environment import *
+
+# Define project specific environment methods
+# TestConfig.profile_memory_in_features = True
+# TestConfig.profile_memory_in_scenarios = True
+
+
+

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/features/Configuration/Actions/configure_system.feature

@@ -0,0 +1,10 @@
+@configure_system
+Feature: Configure system
+
+    @default_settings
+    Scenario: Configure system with default settings
+        Given ensure system is configured with default settings
+        
+        
+        
+        

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/features/NonReg/example.feature

@@ -0,0 +1,26 @@
+@example
+Feature: Example of feature
+
+    Scenario: Get and verify file content
+        ### PRECONDITIONS - BEGIN
+        Given begin preconditions
+        
+        Given DT_NOW = datetime now
+        Given DT_NOW_STR = convert datetime DT_NOW to string with format '%Y-%m-%dT%H-%M-%S-%f'
+        Given FILENAME = 'test_${DT_NOW_STR}.xml'
+        
+        Given TEXT = 'text'
+        Given FILE_PATH = create file with name FILENAME
+            """
+            <node>${TEXT}</node>
+            """
+            
+        Given end preconditions
+        ### PRECONDITIONS - END
+        
+        Given FILE_CONTENT = content of file FILE_PATH
+        Given FILE_CONTENT_STR = convert object value FILE_CONTENT to string
+        Then FILE_CONTENT_STR == '<node>text</node>'
+
+        
+        

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/logging.conf

@@ -0,0 +1,102 @@
+[holado]
+level=INFO
+#level=DEBUG
+log_on_console=False
+log_in_file=True
+
+[loggers_levels]
+common=DEBUG
+config=DEBUG
+context=DEBUG
+
+
+# Set HolAdo modules levels
+# In case default level is set to DEBUG to debug KSC testing solution but not HolAdo, level is defined for each HolAdo module (usually: INFO)
+holado=INFO
+holado.common.context=INFO
+holado.common.context.session_context=DEBUG
+holado.common.handlers.object=DEBUG
+holado_ais=INFO
+#holado_ais.ais=DEBUG
+holado_binary=INFO
+holado_context=INFO
+# Note: set DEBUG level in SessionContext in order to analyze a bug in feature context lifecycle resulting randomly to hook errors until end of session
+holado_context.common.context.session_context=DEBUG
+
+#holado_core=INFO
+holado_core=DEBUG
+#holado_core.common.tables.comparators=DEBUG
+holado_core.common.tools=DEBUG
+holado_core.common.tools.comparators=INFO
+#holado_core.common.transport=DEBUG
+holado_core.scenario=DEBUG
+
+holado_data=INFO
+holado_db=INFO
+holado_db.tools=DEBUG
+holado_docker=INFO
+holado_docker.sdk=DEBUG
+holado_grpc=INFO
+holado_grpc.ipc=DEBUG
+holado_helper=INFO
+holado_json=INFO
+holado_keycloak=INFO
+holado_keycloak.tools=DEBUG
+holado_logging=DEBUG
+#holado_logging.common.logging.log_manager=DEBUG
+holado_multitask=INFO
+holado_multitask.multithreading.threadsmanager=DEBUG
+holado_protobuf=INFO
+holado_protobuf.ipc=DEBUG
+#holado_protobuf.ipc.protobuf.protobuf_converter=TRACE
+#holado_protobuf.ipc.protobuf.protobuf_messages=TRACE
+holado_python=INFO
+holado_rabbitmq=INFO
+holado_rabbitmq.tools=DEBUG
+holado_redis=INFO
+holado_redis.tools=DEBUG
+holado_report=INFO
+holado_rest=INFO
+#holado_rest.api=DEBUG
+holado_s3=INFO
+holado_s3.tools=DEBUG
+#holado_s3.tools.s3.minio_client=DEBUG
+#holado_s3.tools.s3.minio_client.trace=DEBUG
+
+holado_scripting=INFO
+#holado_scripting.common.tools=DEBUG
+#holado_scripting.common.tools.expression_evaluator=INFO
+holado_scripting.common.tools.expression_evaluator=DEBUG
+#holado_scripting.common.tools.expression_evaluator=TRACE
+#holado_scripting.common.tools.variable_manager=DEBUG
+#holado_scripting.common.tools.variable_manager=TRACE
+#holado_scripting.interpreter=TRACE
+#holado_scripting.interpreter.functions=DEBUG
+
+holado_sftp=INFO
+holado_sftp.tools=DEBUG
+holado_swagger=INFO
+holado_system=INFO
+holado_system.system.global_system=DEBUG
+#holado_test=INFO
+holado_test=DEBUG
+
+# UI modules are not operational yet
+holado_ui=ERROR
+holado_ui_mss=ERROR
+holado_ui_selenium=ERROR
+holado_ui_selenium_angular=ERROR
+holado_ui_selenium_html=ERROR
+
+holado_value=DEBUG
+#holado_value.common.tables.converters.value_table_converter=TRACE
+holado_ws=ERROR
+
+
+# External libraries
+chardet=WARNING
+docker=INFO
+grpc_requests=DEBUG
+pika=WARN
+psycopg=INFO
+urllib3=INFO

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/requirements.txt

@@ -0,0 +1,5 @@
+# HolAdo framework
+holado[db]
+
+
+

holado-0.2.5/src/holado_examples/tests/behave/testing_solution/run_test.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+DIR="$(dirname "${BASH_SOURCE[0]}")"
+cd ${DIR}
+
+behave --no-source --no-skipped --no-logcapture "$@"
+