holado 0.22.3__tar.gz → 0.22.4.dev2__tar.gz

{holado-0.22.3 → holado-0.22.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: holado
-Version: 0.22.3
+Version: 0.22.4.dev2
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.22.4.dev2/packaging/VERSION

@@ -0,0 +1 @@
+0.22.4.dev2

holado-0.22.4.dev2/src/holado_data/data/version/version_manager.py

@@ -0,0 +1,115 @@
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+#
+# 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 logging
+import re
+
+from holado.common.handlers.object import Object
+from holado.common.handlers.undefined import default, undefined_argument
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado_core.common.tools.converters.converter import Converter
+from holado_resource.resource.table_data_manager import TableDataManager
+
+logger = logging.getLogger(__name__)
+
+
+
+class UIDHashVersionManager(Object):
+    """ Version manager for pairs (UID, hash)
+    When requesting version for a pair (UID, hash), it returns the version associated to pair (UID, hash),
+    else it returns last version increased and store the new tuple (UID, hash, version).
+    """
+    def __init__(self, name=None, scope=default, version_pattern=default, first_version=default, db_name=default):
+        super().__init__(name=name or "UID+hash version manager")
+        self.__scope = scope if scope is not default else "global"
+        self.__version_pattern = version_pattern if version_pattern is not default else r"(\d+)"
+        self.__first_version = first_version if first_version is not default else "0"
+        self.__db_name = db_name if db_name is not default else "default"
+        self.__resource_manager = None
+
+        # Initialize persisted data
+        self.__versions_table_manager = TableDataManager('version', 'uid_hash_versions', self.__get_table_sql_create(),
+                                                          table_unique_indexes=self.__get_table_unique_indexes(), table_indexes=None, db_name=self.__db_name)
+
+    def initialize(self, resource_manager):
+        self.__resource_manager = resource_manager
+
+        self.__versions_table_manager.initialize(resource_manager)
+        self.__versions_table_manager.ensure_db_exists(recreate_if_needed=False)
+
+    def __get_db_client(self):
+        return self.__resource_manager.get_db_client(self.__db_name)
+
+    def __get_table_sql_create(self):
+        return """CREATE TABLE uid_hash_versions (
+                id INTEGER PRIMARY KEY,
+                scope TEXT NOT NULL,
+                uid TEXT NOT NULL,
+                hash TEXT NOT NULL,
+                version TEXT NOT NULL
+            )"""
+
+    def __get_table_unique_indexes(self):
+        return [
+            ('scope', 'uid', 'hash'),
+            ('scope', 'uid', 'version')
+            ]
+
+    def get_version(self, uid, hash_):
+        res = self.__get_version(uid, hash_)
+        if res is None:
+            res = self.__next_version(uid, hash_)
+        return res
+
+    def get_versions(self, hash_by_uid):
+        res = {}
+        for uid, hash_ in hash_by_uid.items():
+            res[uid] = self.get_version(uid, hash_)
+        return res
+
+    def __get_version(self, uid, hash_):
+        data = self.__versions_table_manager.get_data(filter_data={'scope': self.__scope, 'uid': uid, 'hash': hash_})
+        if data is not None:
+            return data['version']
+        else:
+            return None
+
+    def __get_last_version(self, uid):
+        client = self.__get_db_client()
+        result = client.select("uid_hash_versions", where_data={'scope': self.__scope, 'uid': uid}, sql_return="max(version)")
+        if result.nb_rows == 0:
+            return None
+        else:
+            return result[0][0].content
+
+    def __next_version(self, uid, hash_):
+        # Compute next version from last version
+        last_version = self.__get_last_version(uid)
+        if last_version is None:
+            last_version = self.__first_version
+
+        if self.__version_pattern:
+            if m := re.match(self.__version_pattern, last_version):
+                ver_int = int(m.groups()[-1])
+                res = "".join(m.groups()[:-1] + (ver_int + 1,))
+            else:
+                raise TechnicalException(f"Last version '{last_version}' does not match pattern '{self.__version_pattern}'")
+        elif Converter.is_integer(last_version):
+            ver_int = Converter.to_integer(last_version)
+            res = str(ver_int + 1)
+        else:
+            raise TechnicalException(f"Unexpected last version '{last_version}'")
+
+        # Store next version association with hash
+        self.__versions_table_manager.add_data({'scope': self.__scope, 'uid': uid, 'hash': hash_, 'version': res})
+
+        return res

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_db/tools/db/clients/base/db_client.py

@@ -327,7 +327,7 @@ class DBClient(Object):
     def drop_table(self, table_name, raise_if_not_exist=False, do_commit=True, drop_indexes=True):
         # Drop table indexes before
         if drop_indexes:
-            self.drop_table_indexes(table_name, do_commit=do_commit)
+            self.drop_table_indexes(table_name, if_exists=True, do_commit=do_commit)
 
         if self.exist_table(table_name):
             sql = f"drop table {table_name};"

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_report/campaign/campaign_manager.py

@@ -63,9 +63,9 @@ class CampaignManager(object):
         self.__path_manager = path_manager
 
         self.__campaigns_table_manager.initialize(resource_manager)
-        self.__campaigns_table_manager.ensure_db_exists()
+        self.__campaigns_table_manager.ensure_db_exists(recreate_if_needed=False)
         self.__campaign_scenarios_table_manager.initialize(resource_manager)
-        self.__campaign_scenarios_table_manager.ensure_db_exists()
+        self.__campaign_scenarios_table_manager.ensure_db_exists(recreate_if_needed=False)
 
     @property
     def _path_manager(self) -> PathManager:

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_resource/resource/resource_manager.py

@@ -92,15 +92,17 @@ class ResourceManager(object):
         client = self.get_db_client(db_name, is_persistent=is_persistent)
         client.drop_table(table_name, raise_if_not_exist=raise_if_not_exist, do_commit=do_commit)
 
-    def check_data_table_schema(self, table_name, create_sql, db_name="default", is_persistent=False):
+    def get_data_table_schema(self, table_name, db_name="default", is_persistent=False):
         client = self.get_db_client(db_name, is_persistent=is_persistent)
-        result = client.select("sqlite_schema", where_data={'name':table_name}, sql_return='sql')
+        result = client.select("sqlite_schema", where_data={'name': table_name}, sql_return='sql')
         if not result:
-            return False
-        
-        sql = result[0][0].content
+            return None
+        return result[0][0].content
+
+    def check_data_table_schema(self, table_name, create_sql, db_name="default", is_persistent=False):
+        sql = self.get_data_table_schema(table_name, db_name=db_name, is_persistent=is_persistent)
         return sql == create_sql
-        
+
     def count_data(self, table_name, where_data: dict=None, where_compare_data: list=None, db_name="default", is_persistent=False):
         client = self.get_db_client(db_name, is_persistent=is_persistent)
         return client.count(table_name, where_data=where_data, where_compare_data=where_compare_data)

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_resource/resource/table_data_manager.py

@@ -46,7 +46,7 @@ class TableDataManager(object):
     def table_name(self):
         return self.__table_name
     
-    def ensure_db_exists(self):
+    def ensure_db_exists(self, recreate_if_needed=False):
         if self.__resource_manager.has_data_table(self.__table_name, db_name=self.__db_name, is_persistent=self.__is_persistent):
             if self.__resource_manager.check_data_table_schema(self.__table_name, self.__table_sql_create, db_name=self.__db_name, is_persistent=self.__is_persistent):
                 # Table already exists with the right schema
@@ -54,8 +54,12 @@ class TableDataManager(object):
                 self.__create_data_table_indexes(if_not_exists=True, raise_if_exist=False, do_commit=True)
                 return
             else:
-                # Table already exists but with wrong schema => delete table before creating it again
-                self.__resource_manager.delete_data_table(self.__table_name, db_name=self.__db_name, is_persistent=self.__is_persistent, raise_if_not_exist=True, do_commit=True)
+                if recreate_if_needed:
+                    # Table already exists but with wrong schema => delete table before creating it again
+                    self.__resource_manager.delete_data_table(self.__table_name, db_name=self.__db_name, is_persistent=self.__is_persistent, raise_if_not_exist=True, do_commit=True)
+                else:
+                    table_schema = self.__resource_manager.get_data_table_schema(self.__table_name, db_name=self.__db_name, is_persistent=self.__is_persistent)
+                    raise TechnicalException(f"Data table {self.__table_name} already exists but with wrong schema:\n    obtained:\n{Tools.indent_string(8, table_schema)} \n    expected:\n{Tools.indent_string(8, self.__table_sql_create)}")
         
         do_commit = True
         # noinspection PyBroadException

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_test/behave/scenario/behave_scenario_tools.py

@@ -106,6 +106,14 @@ class BehaveScenarioTools(ScenarioTools):
         else:
             return tuple(res)
 
+    @classmethod
+    def _get_scenario_version_in_instance(cls, scenario):
+        return scenario.scenario_version
+
+    @classmethod
+    def _set_scenario_version_in_instance(cls, scenario, version):
+        scenario.scenario_version = version
+
     @classmethod
     def compute_scenario_hash(cls, scenario):
         # Note: Round to upper value, to ensure all scenario hash digits have information.
@@ -171,7 +179,7 @@ class BehaveScenarioTools(ScenarioTools):
     def get_scenario_report_uid(cls, scenario):
         uid = cls.get_executed_scenario_uid(scenario)
         scenario_version = cls.get_scenario_version(scenario) or ""
-        res = f"{uid}:{scenario_version}"
+        res = f"{uid}:{scenario_version}" if scenario_version else uid
         return res
 
     @classmethod

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_test/scenario/scenario_tools.py

@@ -191,7 +191,7 @@ class ScenarioTools(object):
             case ManageScenarioVersionMethod.VersionInTag:
                 return cls._get_scenario_version_in_tag(scenario)
             case ManageScenarioVersionMethod.AutomaticByTestServer:
-                raise NotImplementedError()
+                raise cls._get_scenario_version_in_instance(scenario)
             case _:
                 raise TechnicalException(f"Unmanaged scenario version management method '{TestConfig.manage_scenario_version_method}'")
 
@@ -622,16 +622,53 @@ class ScenarioTools(object):
         res = False
 
         match TestConfig.manage_scenario_version_method:
-            case ManageScenarioVersionMethod.VersionInTag:
-                res = cls._manage_scenario_version_in_tag()
-            case ManageScenarioVersionMethod.Deactivated|ManageScenarioVersionMethod.AutomaticByTestServer:
+            case ManageScenarioVersionMethod.Deactivated:
                 # Nothing to do
                 pass
+            case ManageScenarioVersionMethod.VersionInTag:
+                res = cls._manage_scenario_version_in_tag()
+            case ManageScenarioVersionMethod.AutomaticByTestServer:
+                cls._manage_scenario_version_automatic_by_test_server()
             case _:
                 raise TechnicalException(f"Unmanaged scenario version management method '{TestConfig.manage_scenario_version_method}'")
 
         return res
 
+    @classmethod
+    def _manage_scenario_version_automatic_by_test_server(cls):
+        """ Manage scenario versions automatically by test-server.
+        Scenario versions are requested to test-server according their uid and hash,
+        and stored in Scenario instances as attribute 'scenario_version
+        """
+        if not cls._get_test_server_client().is_available:
+            raise TechnicalException(f"test-server is not available")
+
+        # Get elements info
+        scenario_by_uid = {}
+        hash_by_uid = {}
+        for scenario in cls.get_scenarios():
+            scenario_uid = cls.get_scenario_uid(scenario)
+            scenario_by_uid[scenario_uid] = scenario
+
+            scenario_hash = cls.compute_scenario_hash(scenario)
+            hash_by_uid[scenario_uid] = scenario_hash
+
+        # Request version to test-server
+        version_by_uid = cls._get_test_server_client().get_versions(scope='scenario', hash_by_uid=hash_by_uid)
+
+        for uid, scenario in scenario_by_uid.items():
+            if uid not in version_by_uid:
+                raise TechnicalException(f"Scenario version is missing for UID '{uid}' in returned versions by test-server: {version_by_uid}")
+            cls._set_scenario_version(scenario, version_by_uid[uid])
+
+    @classmethod
+    def _get_scenario_version_in_instance(cls, scenario):
+        raise NotImplementedError()
+
+    @classmethod
+    def _set_scenario_version_in_instance(cls, scenario, version):
+        raise NotImplementedError()
+
     @classmethod
     def _manage_scenario_version_in_tag(cls):
         """ Manage scenario versions in tag.
@@ -728,4 +765,5 @@ class ScenarioTools(object):
             ver_int = int(m.group(2))
             return f"{m.group(1)}{ver_int + 1}"
         else:
-            raise TechnicalException(f"Unexpected version '{version}'")
+            raise TechnicalException(f"Unexpected version '{version}'")
+

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_test/tools/test_server/client/rest/test_server_client.py

@@ -264,6 +264,20 @@ class TestServerClient(RestClient):
 
         return self.put(f"tools/uid", json=data)
 
+    def get_version(self, uid, hash_, scope=None):
+        data = {'uid': uid, 'hash':hash_}
+        if scope is not None:
+            data['scope'] = scope
+
+        return self.get(f"tools/version", json=data)
+
+    def get_versions(self, hash_by_uid, scope=None):
+        data = {'hash_by_uid': hash_by_uid}
+        if scope is not None:
+            data['scope'] = scope
+
+        return self.get(f"tools/versions", json=data)
+
 
 
 

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_test/tools/test_server/server/core/server_manager.py

@@ -15,6 +15,7 @@ import logging
 
 from holado.common.handlers.undefined import default
 from holado_data.data.uid.uid_generator import PersistedStandaloneUIDGenerator
+from holado_data.data.version.version_manager import UIDHashVersionManager
 from holado_report.campaign.campaign_manager import CampaignManager
 from holado_report.campaign.campaign_report_exporter import CampaignReportExporter
 
@@ -34,6 +35,7 @@ class TestServerManager(object):
         self.__campaign_report_exporter = CampaignReportExporter()
 
         self.__uid_generator_by_scope = {}
+        self.__version_manager_by_scope = {}
 
     def initialize(self, resource_manager, path_manager, expression_evaluator):
         self.__campaign_manager.initialize(resource_manager, path_manager)
@@ -53,5 +55,10 @@ class TestServerManager(object):
                                                                                    db_name="server/uid", is_persistent=False)
         return self.__uid_generator_by_scope[scope]
 
+    def get_version_manager(self, scope=default):
+        if scope not in self.__version_manager_by_scope:
+            self.__version_manager_by_scope[scope] = UIDHashVersionManager(f"VersionManager[{scope}]", scope=scope, db_name="server/versions")
+        return self.__version_manager_by_scope[scope]
+
 
 

holado-0.22.4.dev2/src/holado_test/tools/test_server/server/requirements.txt

@@ -0,0 +1,2 @@
+# HolAdo framework
+holado[api-connexion,ssl]>=0.22.4.dev1

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_test/tools/test_server/server/rest/api/tools/__init__.py

@@ -60,3 +60,44 @@ class UidView(MethodView):
             return str(exc), 500
 
 
+class VersionView(MethodView):
+
+    def get(self, body: dict):
+        try:
+            data = copy.copy(body)
+            scope = data.pop('scope', 'global')
+            uid = data.pop('uid')
+            hash_ = data.pop('hash')
+            if data:
+                raise FunctionalException(f"Unexpected parameters {data}")
+
+            manager = _get_session_context().server_manager.get_version_manager(scope)
+            res = manager.get_version(uid, hash_)
+
+            return res
+        except Exception as exc:
+            logger.exception(f"Failed to get version for {body}")
+            return str(exc), 500
+
+
+class VersionsView(MethodView):
+
+    def get(self, body: dict):
+        try:
+            data = copy.copy(body)
+            scope = data.pop('scope', 'global')
+            hash_by_uid = data.pop('hash_by_uid')
+            if data:
+                raise FunctionalException(f"Unexpected parameters {data}")
+
+            manager = _get_session_context().server_manager.get_version_manager(scope)
+            res = manager.get_versions(hash_by_uid)
+
+            return res
+        except Exception as exc:
+            logger.exception(f"Failed to get versions for {body}")
+            return str(exc), 500
+
+
+
+

{holado-0.22.3 → holado-0.22.4.dev2}/src/holado_test/tools/test_server/server/rest/openapi.yaml

@@ -257,6 +257,8 @@ paths:
                   description: Number of UID to generate
                   type: integer
                   default: 1
+              required:
+                - scope
       responses:
         200:
           description: List of new UIDs
@@ -282,6 +284,9 @@ paths:
                 last_uid:
                   description: Last UID
                   type: string
+              required:
+                - scope
+                - last_uid
       responses:
         200:
           description: List of new UIDs
@@ -292,6 +297,69 @@ paths:
                 items:
                   type: string
 
+  /tools/version:
+    get:
+      description: Get version of an element
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                scope:
+                  description: Scope of version
+                  type: string
+                  default: "global"
+                uid:
+                  description: UID of element
+                  type: string
+                hash:
+                  description: hash of element
+                  type: string
+              required:
+                - scope
+                - uid
+                - hash
+      responses:
+        200:
+          description: Version of element
+          content:
+            application/json:
+              schema:
+                type: string
+
+  /tools/versions:
+    get:
+      description: Get versions of many elements
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                scope:
+                  description: Scope of version
+                  type: string
+                  default: "global"
+                hash_by_uid:
+                  description: Dictionary of pairs (uid, hash) by element
+                  type: object
+                  additionalProperties:
+                    type: string
+              required:
+                - scope
+                - hash_by_uid
+      responses:
+        200:
+          description: Versions by element UID
+          content:
+            application/json:
+              schema:
+                type: object
+                additionalProperties:
+                  type: string
+
+
 components:
   schemas:
     SendEmailParameters:

holado-0.22.3/packaging/VERSION

@@ -1 +0,0 @@
-0.22.3

holado-0.22.3/src/holado_test/tools/test_server/server/requirements.txt

@@ -1,2 +0,0 @@
-# HolAdo framework
-holado[api-connexion,ssl]>=0.22.3