holado 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

holado_test/scenario/step_tools.py

@@ -78,7 +78,6 @@ class StepTools(object):
         res = text.encode('latin-1').decode('unicode-escape')
         
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-        
             logger.trace("unescaping string [{}] -> [{}]".format(text, res))
         return res
     
@@ -88,8 +87,8 @@ class StepTools(object):
     
     @staticmethod
     def evaluate_string_parameter(text_param, do_interpret=True, log_level=logging.DEBUG):
-        eval_params = EvaluateParameters.default().with_interpret(do_interpret).with_eval(False)
-        res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        eval_params = EvaluateParameters.default().with_interpret(do_interpret).with_eval(False).with_result_type(str)
+        _, res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, "evaluate_string_parameter: [{}] -> [{}]".format(text_param, res))
         return res
@@ -99,8 +98,8 @@ class StepTools(object):
         if text_param is None:
             return None
         
-        eval_params = EvaluateParameters.default_without_eval(False)
-        res = StepTools._get_text_interpreter().interpret(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        eval_params = EvaluateParameters.default_without_eval(False).with_result_type(str)
+        res = StepTools._get_text_interpreter().interpret(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_variable_name: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
@@ -111,7 +110,7 @@ class StepTools(object):
             return None
         
         eval_params = EvaluateParameters.default_without_eval(False)
-        res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        _, res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_variable_name: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
@@ -122,14 +121,14 @@ class StepTools(object):
             return None
         
         eval_params = EvaluateParameters.default().with_raise_on_eval_error(False)
-        res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=logging.TRACE)  # @UndefinedVariable
+        _, res = StepTools._get_expression_evaluator().evaluate_expression(text_param, eval_params=eval_params, log_level=Tools.do_log_level(log_level, logging.TRACE))  # @UndefinedVariable
         if Tools.do_log_if_objects_are_different(logger, log_level, text_param, res):
             logger.log(log_level, f"evaluate_scenario_parameter: [{text_param}] -> [{res}] (type: {Typing.get_object_class_fullname(res)})")
         return res
  
     @staticmethod
     def evaluate_list_scenario_parameter(text_param, param_name, log_level=logging.DEBUG):
-        res = StepTools.evaluate_scenario_parameter(text_param)
+        res = StepTools.evaluate_scenario_parameter(text_param, log_level=log_level)
         if isinstance(res, str):
             regex = re.compile(r"^\s*\[(.*)\]\s*$")
             m = regex.match(res)
@@ -294,8 +293,8 @@ class StepTools(object):
     @classmethod
     def has_table_header(cls, table):
         """
-        Return True if scenario table has a header (for testing solution).
-        For testing solution, table header names are all texts without quotes.
+        Return True if scenario table has a header (for HolAdo framework).
+        For HolAdo framework, table header names are all texts without quotes.
         """
         internal_header = cls._get_table_header(table)
         if internal_header is None:
@@ -303,7 +302,7 @@ class StepTools(object):
         
         for cell in internal_header:
             scell = ValueTableCell(cell)
-            if scell.value_type not in [ValueTypes.Symbol]:
+            if not ( scell.content_type == ValueTypes.Symbol and scell.value_type == ValueTypes.String ):
                 return False
         
         return True
@@ -402,7 +401,7 @@ class StepTools(object):
     def format_steps_with(cls, steps, format_with_list):
         res = steps
         for form in format_with_list:
-            form_eval = cls._get_expression_evaluator().evaluate_expression(form)
+            _, form_eval = cls._get_expression_evaluator().evaluate_expression(form, log_level=logging.TRACE)  # @UndefinedVariable
             if form_eval == form:
                 raise FunctionalException(f"Not able to evaluation expression [{form}]. Is missing its initialization ?")
             res = res.replace(f"${{{form}}}", str(form_eval))
@@ -426,6 +425,8 @@ class StepTools(object):
         new_type = {'pattern':pattern, 'function':func}
         if type_name in cls.__registered_types:
             logger.warning(f"Overriding step parameter type '{type_name}': {cls.__registered_types[type_name]['pattern']} -> {new_type['pattern']}")
+            import traceback
+            logging.warning("".join(traceback.format_list(traceback.extract_stack())))
         cls.__registered_types[type_name] = new_type
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Registered step parameter type '{type_name}'")

holado_test/scenario/tester_tools.py

@@ -14,6 +14,7 @@
 from holado.common.context.session_context import SessionContext
 import logging
 from holado_core.common.tables.table import Table
+from holado_core.common.tools.tools import Tools
 
 logger = logging.getLogger(__name__)
 
@@ -47,6 +48,7 @@ class TesterTools(object):
         if isinstance(obj, Table):
             res = obj.represent()
         else:
-            res = str(obj)
+            # res = str(obj)
+            res = Tools.represent_object(obj)
         return res
 

holado_value/common/tables/comparators/table_2_value_table_cell_comparator.py

@@ -121,7 +121,7 @@ class Table2ValueTable_CellComparator(TableCellComparator):
                 res = comparator.equals(cell_1_value, cell_2_value, is_obtained_vs_expected=is_obtained_vs_expected, raise_exception=raise_exception)
             elif value_type == ValueTypes.Merged:
                 return super().equals(cell_1, cell_2, is_obtained_vs_expected, raise_exception)
-            elif value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+            elif ValueTypes.is_string(value_type):
                 res = self._equals_string(cell_1, cell_2, is_obtained_vs_expected, raise_exception)
             elif value_type == ValueTypes.Symbol:
                 res = self._equals_symbol(cell_1, cell_2, is_obtained_vs_expected, raise_exception)

holado_value/common/tables/converters/value_table_converter.py

@@ -158,7 +158,7 @@ class ValueTableConverter(TableConverter):
             
             if row.get_cell(1).value_type in [ValueTypes.NotApplicable, ValueTypes.Merged]:
                 pass
-            elif row.get_cell(1).value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+            elif ValueTypes.is_string(row.get_cell(1).value_type):
                 name = row.get_cell(0).value
                 value = row.get_cell(1).value
                 

holado_value/common/tables/value_table_cell.py

@@ -31,7 +31,7 @@ class ValueTableCell(TableCell):
         super().__init__(cell_content)
         
         self.__value = Value(original_value=cell_content, value=cell_value, do_eval_once=do_eval_once)
-        self.content = self.__value.value_original
+        self.content = self.__value.original_value
         
     def __eq__(self, other):
         self._verify_valid_compared_object(other)
@@ -51,6 +51,10 @@ class ValueTableCell(TableCell):
     def string_content(self):
         return self.__value.string_value
     
+    @property
+    def content_type(self):
+        return self.__value.original_value_type
+    
     @property
     def value_type(self):
         return self.__value.value_type

holado_value/common/tools/value.py

@@ -20,7 +20,7 @@ from holado_value.common.tools.value_types import ValueTypes
 from functools import total_ordering
 from holado_scripting.common.tools.evaluate_parameters import EvaluateParameters
 from holado.holado_config import Config
-from holado.common.handlers.undefined import undefined_value
+from holado.common.handlers.undefined import undefined_value, undefined_argument, to_be_defined, not_applicable, is_undefined
 from holado_python.standard_library.typing import Typing
 
 logger = logging.getLogger(__name__)
@@ -29,26 +29,27 @@ logger = logging.getLogger(__name__)
 @total_ordering
 class Value(object):
     
-    def __init__(self, original_value=undefined_value, value=undefined_value, do_eval_once=True, eval_params=undefined_value):
+    def __init__(self, original_value=undefined_argument, value=undefined_argument, do_eval_once=True, eval_params=undefined_argument):
         """
         @summary: Constructor
-        @param original_value: Original value - can be a string or any object
+        @param original_value: Original value (before value expression evaluation) - can be a string or any object
         @param value: Value - can be a string or any object
         """
-        self.__value_original = undefined_value
-        self.__type = None
-        self.__value = undefined_value
+        self.__original_value = to_be_defined
+        self.__value = to_be_defined
+        self.__value_type = None
         
         # Manage value evaluation
-        self.__value_to_eval = undefined_value
-        self.__value_evaluated = undefined_value
+        self.__value_to_eval = to_be_defined
+        self.__evaluated_value = to_be_defined
+        self.__evaluated_value_type = to_be_defined
         # By default, raise on interpret and variable evaluation error, but not on eval error
-        self.__eval_params_default = eval_params if eval_params is not undefined_value else EvaluateParameters.default().with_raise_on_eval_error(False)
+        self.__eval_params_default = eval_params if eval_params is not undefined_argument else EvaluateParameters.default().with_raise_on_eval_error(False)
         self.__do_eval_once = do_eval_once
         
         self.__extract_value_information(original_value, value)
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
-            logger.trace(f"New Value: value_original=[{self.__value_original}] ; type=[{self.value_type.name}] ; value=[{self.__value}] ; value_to_eval=[{self.__value_to_eval}]")
+            logger.trace(f"New Value: original_value=[{self.__original_value}] ; type=[{self.value_type.name}] ; value=[{self.__value}] ; value_to_eval=[{self.__value_to_eval}]")
         
     def _verify_valid_compared_object(self, other, raise_exception=True):
         res = isinstance(other, Value)
@@ -73,7 +74,7 @@ class Value(object):
     def string_value(self):
         value = self.get_value()
         
-        if value is undefined_value:
+        if value in [undefined_value, not_applicable]:
             return Config.NOT_APPLICABLE_SYMBOL
         if value is None:
             return Config.NONE_SYMBOL
@@ -81,15 +82,22 @@ class Value(object):
             return str(value)
     
     @property
-    def value_original(self):
+    def original_value(self):
         """
         @summary: Return the original value
         """
-        return self.__value_original
+        return self.__original_value
+    
+    @property
+    def original_value_type(self):
+        """
+        @summary: Return the original value type
+        """
+        return self.__value_type
     
     @property
     def value_type(self):
-        return self.__type
+        return self.get_value_type()
     
     @property
     def value_before_eval(self):
@@ -105,56 +113,71 @@ class Value(object):
         """
         return self.get_value(raise_if_undefined=True)
     
-    def get_value(self, raise_if_undefined=False, eval_params=undefined_value):
+    def get_value(self, raise_if_undefined=False, eval_params=undefined_argument):
         if self.__value_to_eval is not undefined_value:
-            if self.__value_evaluated is undefined_value or not self.__do_eval_once:
-                eval_params = eval_params if eval_params is not undefined_value else self.__eval_params_default
-                self.__value_evaluated = self.__get_expression_evaluator().evaluate_expression_of_information(self.__type, self.__value_to_eval, eval_params=eval_params)
-            res = self.__value_evaluated
+            self.__evaluate_value_if_needed(eval_params=eval_params)
+            res = self.__evaluated_value
         else:
             res = self.__value
         
-        if res is undefined_value and raise_if_undefined:
+        if is_undefined(res) and raise_if_undefined:
             msg = "Value is undefined"
             if self.value_type == ValueTypes.NotApplicable:
                 msg += " (Not Applicable)"
-            raise ValueError(f"Value is undefined (value type: {self.value_type.name} ; original value: [{self.value_original}] (type: {Typing.get_object_class_fullname(self.value_original)}))")
+            raise ValueError(f"Value is undefined (value type: {self.value_type.name} ; original value: [{self.original_value}] (type: {Typing.get_object_class_fullname(self.original_value)}))")
+        return res
+    
+    def get_value_type(self, eval_params=undefined_argument):
+        if self.__value_to_eval is not undefined_value:
+            self.__evaluate_value_if_needed(eval_params=eval_params)
+            res = self.__evaluated_value_type
+        else:
+            res = self.__value_type
         return res
     
+    def __evaluate_value_if_needed(self, eval_params=undefined_argument):
+        if self.__evaluated_value is to_be_defined or not self.__do_eval_once:
+            eval_params = eval_params if eval_params is not undefined_argument else self.__eval_params_default
+            if ValueTypes.is_string(self.__value_type):
+                eval_params = eval_params.with_result_type(str)
+            self.__evaluated_value_type, self.__evaluated_value = self.__get_expression_evaluator().evaluate_expression_of_information(self.__value_type, self.__value_to_eval, eval_params=eval_params)
+        
     def represent(self, indent = 0, do_evaluation = False):
         res_list = []
         
         res_list.append(Tools.get_indent_string(indent))
         
-        if self.__type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]:
+        if ValueTypes.is_string(self.__value_type):
             if do_evaluation:
                 res_list.append("'")
                 res_list.append(self.string_value)
                 res_list.append("'")
             else:
-                res_list.append(str(self.value_original))
-        elif self.__type in [ValueTypes.Boolean, ValueTypes.Integer, ValueTypes.Float, ValueTypes.Null, ValueTypes.NotApplicable, ValueTypes.Symbol, ValueTypes.Generic]:
+                res_list.append(str(self.original_value))
+        elif self.__value_type in [ValueTypes.Boolean, ValueTypes.Integer, ValueTypes.Float, ValueTypes.Null, ValueTypes.NotApplicable, ValueTypes.Symbol, ValueTypes.Generic]:
             if do_evaluation:
                 res_list.append(self.string_value)
             else:
-                res_list.append(str(self.value_original))
+                res_list.append(str(self.original_value))
         else:
-            raise TechnicalException("Unmanaged value type '{}'".format(self.__type.name))
+            raise TechnicalException("Unmanaged value type '{}'".format(self.__value_type.name))
         
         return "".join(res_list)
         
-    def __extract_value_information(self, value_original, value):
+    def __extract_value_information(self, original_value, value):
         # Define original value
-        if value_original is not undefined_value and not (value_original is None and value not in [undefined_value, None]):
-            self.__value_original = value_original
-        elif value is not undefined_value:
+        if original_value is not undefined_argument and not (original_value in [undefined_value, None] and value not in [undefined_argument, undefined_value, None]):
+            self.__original_value = original_value
+        elif value is not undefined_argument:
             if value is not None and isinstance(value, str):
-                self.__value_original = f"'{value}'"
+                self.__original_value = f"'{value}'"
             else:
-                self.__value_original = value
+                self.__original_value = value
         
         # Define value information from original value
-        self.__type, self.__value, self.__value_to_eval = self.__get_expression_evaluator().extract_expression_information(self.value_original)
+        self.__value_type, self.__value, self.__value_to_eval = self.__get_expression_evaluator().extract_expression_information(self.original_value)
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"extracted value info: {self.__value_type=}, {self.__value=}, {self.__value_to_eval=}")
         
     def __get_expression_evaluator(self):
         if SessionContext.instance().has_scenario_context():

holado_value/common/tools/value_types.py

@@ -32,4 +32,10 @@ class ValueTypes(AutoNumber):
     Merged = ()
     Symbol = ()
     Generic = ()
+    
+    @classmethod
+    def is_string(cls, value_type):
+        return value_type in [ValueTypes.String, ValueTypes.DynamicString, ValueTypes.ThreadDynamicString, ValueTypes.UniqueString]
+
+
 

test_holado/environment.py

@@ -31,7 +31,7 @@ import holado
 #    - log_on_console is True for initialization phase, it will be set to False when root log file will be defined
 #    - logging config file
 from test_holado.test_holado_session_context import TestHoladoSessionContext
-holado.initialize(TSessionContext=TestHoladoSessionContext, logging_config_file=os.path.join(here, 'logging.conf'), log_level=logging.INFO, log_on_console=True)
+holado.initialize(TSessionContext=TestHoladoSessionContext, logging_config_file_path=os.path.join(here, 'logging.conf'), log_level=logging.INFO, log_on_console=True)
 
 
 

test_holado/features/NonReg/{ipc → holado_binary}/bit_series.feature

@@ -3,6 +3,7 @@
 @go_nogo
 Feature: Test bit_series module
 
+    @to_hexadecimal_string
     Scenario: Create and convert bit-series to hexa
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type | Value |
@@ -24,6 +25,9 @@ Feature: Test bit_series module
         Given RAW_TM = convert bit series BIT_SERIES to hexadecimal string
         Then RAW_TM == '99FFFFAE1B'
 
+    
+    @to_hexadecimal_string
+    @padding
     Scenario: Create and convert to hexa bit-series of bit length out of bytes array length
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type | Value |
@@ -56,6 +60,8 @@ Feature: Test bit_series module
         Given RAW_TM = convert bit series BIT_SERIES to hexadecimal string (right padded)
         Then RAW_TM == '92'
 
+    
+    @from_hexadecimal_string
     Scenario: Create a bit-series from hexa
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type |
@@ -71,6 +77,9 @@ Feature: Test bit_series module
             | 'F3'    | 2          | int  | 0     |
             | 'F4'    | 2          | int  | 2     |
 
+
+    @from_hexadecimal_string
+    @padding
     Scenario: Create from hexa bit-series of bit length out of bytes array length
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type |
@@ -99,6 +108,8 @@ Feature: Test bit_series module
             | 'F2'    | 1          | int  | 1     |
             | 'F3'    | 1          | int  | 1     |
 
+
+    @is_bit_series
     Scenario: Verify hexa string is bit series
         Then hexadecimal string '92' is bit series
             | Name    | Bit length | Type | Value |
@@ -107,6 +118,8 @@ Feature: Test bit_series module
             | 'F3'    | 2          | int  | 0     |
             | 'F4'    | 2          | int  | 2     |
 
+
+    @set_field
     Scenario: Set bit-series field by variable expression
         Given BIT_SERIES = bit series
             | Name    | Bit length | Type | Value |

test_holado/features/NonReg/test_steps/common.feature

@@ -51,7 +51,7 @@ Feature: Steps in common_steps.py
             """
             Given TOTO = 'TITI'
             """
-        When wait until wait 0.5 seconds (timeout: 0.7 s)
+        When wait until wait 0.5 seconds (timeout: 0.75 s)
             """
             Given TOTO = 'TITI'
             """

test_holado/logging.conf

@@ -1,7 +1,9 @@
-[logger_root]
+[holado]
 #level=INFO
 level=DEBUG
 #level=TRACE
+log_on_console=False
+log_in_file=True
 
 [loggers_levels]
 holado=INFO