chore: restructure tests dir

Author: matmoncon

pyneo4j_ogm/core/base.py

@@ -35,7 +35,11 @@
     RelationshipPropertyCardinality,
     RelationshipPropertyDirection,
 )
-from pyneo4j_ogm.fields.settings import BaseModelSettings
+from pyneo4j_ogm.fields.settings import (
+    BaseModelSettings,
+    NodeModelSettings,
+    RelationshipModelSettings,
+)
 from pyneo4j_ogm.logger import logger
 from pyneo4j_ogm.pydantic_utils import (
     IS_PYDANTIC_V2,
@@ -236,7 +240,7 @@ class ModelBase(BaseModel, Generic[V]):
     directly and is only used as a base class for `NodeModel` and `RelationshipModel`.
     """
 
-    _settings: BaseModelSettings = PrivateAttr()
+    _settings: Union[NodeModelSettings, RelationshipModelSettings] = PrivateAttr()
     _client: Pyneo4jClient = PrivateAttr()
     _query_builder: QueryBuilder = PrivateAttr()
     _db_properties: Dict[str, Any] = PrivateAttr(default={})

pyneo4j_ogm/core/client.py

@@ -153,22 +153,22 @@ async def register_models(self, models: List[Type[Union[NodeModel, RelationshipM
         logger.info("Registering models %s with client %s", models, self)
 
         for model in models:
-            for registered_model in self.models:
-                registered_model_settings = registered_model.model_settings()
-                model_settings = model.model_settings()
-
-                if (
-                    isinstance(registered_model_settings, RelationshipModelSettings)
-                    and isinstance(model_settings, RelationshipModelSettings)
-                    and registered_model_settings.type == model_settings.type
-                ):
-                    raise AlreadyRegistered(cast(str, model_settings.type))
-                elif (
-                    isinstance(registered_model_settings, NodeModelSettings)
-                    and isinstance(model_settings, NodeModelSettings)
-                    and set(registered_model_settings.labels) == set(model_settings.labels)
-                ):
-                    raise AlreadyRegistered(cast(str, model_settings.labels))
+            # for registered_model in self.models:
+            #     registered_model_settings = registered_model.model_settings()
+            #     model_settings = model.model_settings()
+
+            #     if (
+            #         isinstance(registered_model_settings, RelationshipModelSettings)
+            #         and isinstance(model_settings, RelationshipModelSettings)
+            #         and registered_model_settings.type == model_settings.type
+            #     ):
+            #         raise AlreadyRegistered(cast(str, model_settings.type))
+            #     elif (
+            #         isinstance(registered_model_settings, NodeModelSettings)
+            #         and isinstance(model_settings, NodeModelSettings)
+            #         and set(registered_model_settings.labels) == set(model_settings.labels)
+            #     ):
+            #         raise AlreadyRegistered(cast(str, model_settings.labels))
 
             if issubclass(model, (NodeModel, RelationshipModel)):
                 logger.debug("Found valid mode %s, registering with client", model.__name__)

pyneo4j_ogm/core/node.py

@@ -100,7 +100,7 @@ class NodeModel(ModelBase[NodeModelSettings]):
     model and are defined in `pyneo4j_ogm.fields.settings.NodeModelSettings`.
     """
 
-    _settings: NodeModelSettings
+    _settings: NodeModelSettings = PrivateAttr()
     _relationship_properties: Set[str] = PrivateAttr()
     Settings: ClassVar[Type[NodeModelSettings]]
 
@@ -196,6 +196,8 @@ async def create(self: T) -> T:
         if len(results) == 0 or len(results[0]) == 0 or results[0][0] is None:
             raise UnexpectedEmptyResult()
 
+        # Since the instance is now hydrated, we can set the element id and id and reset the modified properties
+        # to the current instance values
         logger.debug("Hydrating instance values")
         setattr(self, "_element_id", getattr(cast(T, results[0][0]), "_element_id"))
         setattr(self, "_id", getattr(cast(T, results[0][0]), "_id"))
@@ -230,6 +232,8 @@ async def update(self) -> None:
             ]
         )
 
+        # We return the updated node to check if the query was successful
+        # since Neo4j does not raise any exceptions if the node does not exist
         results, _ = await self._client.cypher(
             query=f"""
                 MATCH {self._query_builder.node_match(list(self._settings.labels))}
@@ -269,6 +273,7 @@ async def delete(self) -> None:
             parameters={"element_id": self._element_id},
         )
 
+        # If the returned value is empty, the node does not exist and the query failed
         logger.debug("Checking if query returned a result")
         if len(results) == 0 or len(results[0]) == 0 or results[0][0] is None:
             raise UnexpectedEmptyResult()
@@ -296,6 +301,8 @@ async def refresh(self) -> None:
             parameters={"element_id": self._element_id},
         )
 
+        # If the returned value is empty, we can not refresh the instance
+        # since the node does not exist anymore
         logger.debug("Checking if query returned a result")
         if len(results) == 0 or len(results[0]) == 0 or results[0][0] is None:
             raise UnexpectedEmptyResult()
@@ -520,6 +527,7 @@ async def find_one(
         )
 
         if do_auto_fetch:
+            # If auto-fetch is enabled, we need to build the auto-fetch queries in addition to the normal query
             logger.debug("Querying database with auto-fetch enabled")
             projection_query = (
                 "RETURN n" if cls._query_builder.query["projections"] == "" else cls._query_builder.query["projections"]
@@ -562,10 +570,12 @@ async def find_one(
             or results[0][0] is None
             or (isinstance(results[0][0], dict) and len(results[0][0]) == 0)
         ):
+            # If no results are found, we return None or raise an exception
             if raise_on_empty:
                 raise NoResultFound(filters)
             return None
 
+        # Normalize results to a single instance
         if isinstance(results[0][0], Node):
             instance = cls._inflate(graph_entity=results[0][0])
         elif isinstance(results[0][0], list):

pyneo4j_ogm/core/relationship.py

@@ -3,6 +3,7 @@
 relationships. It provides base functionality like de-/inflation and validation and methods for interacting with
 the database for CRUD operations on relationships.
 """
+
 import json
 import re
 from functools import wraps
@@ -83,7 +84,7 @@ class RelationshipModel(ModelBase[RelationshipModelSettings]):
     `pyneo4j_ogm.fields.settings.RelationshipModelSettings`.
     """
 
-    _settings: RelationshipModelSettings
+    _settings: RelationshipModelSettings = PrivateAttr()
     _start_node_element_id: Optional[str] = PrivateAttr(default=None)
     _start_node_id: Optional[int] = PrivateAttr(default=None)
     _end_node_element_id: Optional[str] = PrivateAttr(default=None)
@@ -427,6 +428,7 @@ async def find_many(
             parameters=cls._query_builder.parameters,
         )
 
+        # Normalize results to instance classes
         logger.debug("Building instances from query results")
         for result_list in results:
             for result in result_list:

pyneo4j_ogm/migrations/actions/down.py

@@ -35,6 +35,7 @@ async def down(down_count: RunMigrationCount = "all", config_path: Optional[str]
 
         logger.debug("Filtering migration files for applied migrations")
         applied_migration_identifiers = migration_node.get_applied_migration_identifiers
+        # Remove all migration files that have not been applied
         for identifier in deepcopy(migration_files).keys():
             if identifier not in applied_migration_identifiers:
                 migration_files.pop(identifier, None)
@@ -43,6 +44,8 @@ async def down(down_count: RunMigrationCount = "all", config_path: Optional[str]
             if down_count != "all" and count >= down_count:
                 break
 
+            # We can get the current migration by getting the max identifier, which is a
+            # UNIX timestamp meaning the highest value is the most recent migration
             current_migration_identifier = max(migration_files.keys())
             current_migration = migration_files[current_migration_identifier]
 

pyneo4j_ogm/migrations/actions/up.py

@@ -41,6 +41,8 @@ async def up(up_count: RunMigrationCount = "all", config_path: Optional[str] = N
             if up_count != "all" and count >= up_count:
                 break
 
+            # Since the migration files are sorted by identifier, we can get the current migration
+            # by getting the min identifier, which is a UNIX timestamp meaning the lowest value is the oldest migration
             current_migration_identifier = min(migration_files.keys())
             current_migration = migration_files[current_migration_identifier]
 

tests/test_model_base_internals.py tests/core/test_base.pytests/test_model_base_internals.py renamed to tests/core/test_base.py

@@ -2,15 +2,168 @@
 # pyright: reportGeneralTypeIssues=false
 
 import json
-from platform import node
+from typing import Union, cast
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from pyneo4j_ogm.core.base import ModelBase
+from pyneo4j_ogm.core.base import ModelBase, hooks
 from pyneo4j_ogm.core.node import NodeModel
 from pyneo4j_ogm.core.relationship import RelationshipModel
 from pyneo4j_ogm.exceptions import ListItemNotEncodable, UnregisteredModel
+from pyneo4j_ogm.fields.settings import BaseModelSettings
 from pyneo4j_ogm.pydantic_utils import get_model_dump, get_model_dump_json
+from tests.fixtures.db_setup import Developer
+
+
+def hook_func():
+    pass
+
+
+def test_pre_hooks():
+    Developer.register_pre_hooks("test_hook", lambda: None)
+    assert len(Developer._settings.pre_hooks["test_hook"]) == 1
+    assert all(callable(func) for func in Developer._settings.pre_hooks["test_hook"])
+    Developer._settings.pre_hooks["test_hook"] = []
+
+    Developer.register_pre_hooks("test_hook", [lambda: None, lambda: None])
+    assert len(Developer._settings.pre_hooks["test_hook"]) == 2
+    assert all(callable(func) for func in Developer._settings.pre_hooks["test_hook"])
+    Developer._settings.pre_hooks["test_hook"] = []
+
+    Developer.register_pre_hooks("test_hook", [lambda: None, "invalid"])  # type: ignore
+    assert len(Developer._settings.pre_hooks["test_hook"]) == 1
+    assert all(callable(func) for func in Developer._settings.pre_hooks["test_hook"])
+    Developer._settings.pre_hooks["test_hook"] = []
+
+    Developer.register_pre_hooks("test_hook", lambda: None)
+    Developer.register_pre_hooks("test_hook", lambda: None, overwrite=True)
+    assert len(Developer._settings.pre_hooks["test_hook"]) == 1
+    assert all(callable(func) for func in Developer._settings.pre_hooks["test_hook"])
+    Developer._settings.pre_hooks["test_hook"] = []
+
+    Developer.register_pre_hooks("test_hook", lambda: None)
+    Developer.register_pre_hooks("test_hook", lambda: None)
+    assert len(Developer._settings.pre_hooks["test_hook"]) == 2
+    assert all(callable(func) for func in Developer._settings.pre_hooks["test_hook"])
+    Developer._settings.pre_hooks["test_hook"] = []
+
+
+def test_post_hooks():
+    Developer.register_post_hooks("test_hook", lambda: None)
+    assert len(Developer._settings.post_hooks["test_hook"]) == 1
+    assert all(callable(func) for func in Developer._settings.post_hooks["test_hook"])
+    Developer._settings.post_hooks["test_hook"] = []
+
+    Developer.register_post_hooks("test_hook", [lambda: None, lambda: None])
+    assert len(Developer._settings.post_hooks["test_hook"]) == 2
+    assert all(callable(func) for func in Developer._settings.post_hooks["test_hook"])
+    Developer._settings.post_hooks["test_hook"] = []
+
+    Developer.register_post_hooks("test_hook", [lambda: None, "invalid"])  # type: ignore
+    assert len(Developer._settings.post_hooks["test_hook"]) == 1
+    assert all(callable(func) for func in Developer._settings.post_hooks["test_hook"])
+    Developer._settings.post_hooks["test_hook"] = []
+
+    Developer.register_post_hooks("test_hook", lambda: None)
+    Developer.register_post_hooks("test_hook", lambda: None, overwrite=True)
+    assert len(Developer._settings.post_hooks["test_hook"]) == 1
+    assert all(callable(func) for func in Developer._settings.post_hooks["test_hook"])
+    Developer._settings.post_hooks["test_hook"] = []
+
+    Developer.register_post_hooks("test_hook", lambda: None)
+    Developer.register_post_hooks("test_hook", lambda: None)
+    assert len(Developer._settings.post_hooks["test_hook"]) == 2
+    assert all(callable(func) for func in Developer._settings.post_hooks["test_hook"])
+    Developer._settings.post_hooks["test_hook"] = []
+
+
+def test_model_settings():
+    class ModelSettingsTest(NodeModel):
+        pass
+
+        class Settings:
+            pre_hooks = {"test_hook": [hook_func]}
+            post_hooks = {"test_hook": [hook_func, hook_func]}
+
+    assert ModelSettingsTest.model_settings().pre_hooks == {"test_hook": [hook_func]}
+    assert ModelSettingsTest.model_settings().post_hooks == {"test_hook": [hook_func, hook_func]}
+
+
+def test_node_model_modified_properties():
+    class ModifiedPropertiesTest(NodeModel):
+        a: str = "a"
+        b: int = 1
+        c: bool = True
+
+    setattr(ModifiedPropertiesTest, "_client", None)
+
+    model = ModifiedPropertiesTest()
+    model.a = "modified"
+    assert model.modified_properties == {"a"}
+
+    model.b = 2
+    assert model.modified_properties == {"a", "b"}
+
+
+def test_relationship_model_modified_properties():
+    class ModifiedPropertiesTest(RelationshipModel):
+        a: str = "a"
+        b: int = 1
+        c: bool = True
+
+    setattr(ModifiedPropertiesTest, "_client", None)
+
+    model = ModifiedPropertiesTest()
+    model.a = "modified"
+    assert model.modified_properties == {"a"}
+
+    model.b = 2
+    assert model.modified_properties == {"a", "b"}
+
+
+async def test_hooks_decorator():
+    class TestClass:
+        def __init__(self):
+            self._client = None  # type: ignore
+            self._settings = BaseModelSettings()
+            self._settings.pre_hooks["async_test_func"] = [MagicMock(__name__="MagicMock"), AsyncMock(), AsyncMock()]
+            self._settings.post_hooks["async_test_func"] = [MagicMock(__name__="MagicMock"), AsyncMock(), AsyncMock()]
+            self._settings.pre_hooks["sync_test_func"] = [
+                MagicMock(__name__="MagicMock"),
+                MagicMock(__name__="MagicMock"),
+                AsyncMock(),
+            ]
+            self._settings.post_hooks["sync_test_func"] = [
+                MagicMock(__name__="MagicMock"),
+                MagicMock(__name__="MagicMock"),
+                AsyncMock(),
+            ]
+
+        @hooks
+        async def async_test_func(self):
+            pass
+
+        @hooks
+        def sync_test_func(self):
+            pass
+
+    test_instance = TestClass()
+    await test_instance.async_test_func()
+
+    for hook_function in test_instance._settings.pre_hooks["async_test_func"]:
+        cast(Union[MagicMock, AsyncMock], hook_function).assert_called_once_with(test_instance)
+
+    for hook_function in test_instance._settings.post_hooks["async_test_func"]:
+        cast(Union[MagicMock, AsyncMock], hook_function).assert_called_once_with(test_instance, None)
+
+    test_instance.sync_test_func()
+
+    for hook_function in test_instance._settings.pre_hooks["sync_test_func"]:
+        cast(Union[MagicMock, AsyncMock], hook_function).assert_called_once_with(test_instance)
+
+    for hook_function in test_instance._settings.post_hooks["sync_test_func"]:
+        cast(Union[MagicMock, AsyncMock], hook_function).assert_called_once_with(test_instance, None)
 
 
 def test_unregistered_model_exc():