django-fast-treenode 2.1.2__py3-none-any.whl → 2.1.3__py3-none-any.whl

{django_fast_treenode-2.1.2.dist-info → django_fast_treenode-2.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-fast-treenode
-Version: 2.1.2
+Version: 2.1.3
 Summary: Application for supporting tree (hierarchical) data structure in Django projects
 Home-page: https://django-fast-treenode.readthedocs.io/
 Author: Timur Kady
@@ -63,6 +63,10 @@ Requires-Dist: xlsxwriter; extra == "import-export"
 # Django-fast-treenode 
 **Combining Adjacency List and Closure Table for Optimal Performance**
 
+[![Tests](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/TimurKady/django-fast-treenode/actions/workflows/test.yaml)
+[![Docs](https://readthedocs.org/projects/django-fast-treenode/badge/?version=latest)](https://django-fast-treenode.readthedocs.io/)
+[![PyPI](https://img.shields.io/pypi/v/django-fast-treenode.svg)](https://pypi.org/project/django-fast-treenode/)
+[![Published on Django Packages](https://img.shields.io/badge/Published%20on-Django%20Packages-0c3c26)](https://djangopackages.org/packages/p/django-fast-treenode/)
 
 **Django Fast TreeNode** is a high-performance Django application for working with tree structures, combining **Adjacency List** and **Closure Table** models. Each **TreeNodeModel** instance maintains two synchronized tables, enabling most operations to be performed with a single database query.
 

{django_fast_treenode-2.1.2.dist-info → django_fast_treenode-2.1.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
 treenode/__init__.py,sha256=CZ-0uZyhi8OZJP8xmqbTqXrZUjcQ4SNAXhKFgM0qw2M,99
 treenode/apps.py,sha256=a7UasXiZZudPccjmHEudP79TkhR_53Mvnb-dBXLHRRQ,862
-treenode/cache.py,sha256=utTmMJ87fjbutaKbOcSp8bHqIDbI_Yr2nPXJoZLAqlQ,7213
+treenode/cache.py,sha256=JLbI0EWq1XmH24SF46glC6e7sdizmfObbFA5vQJvMiY,7213
 treenode/forms.py,sha256=Mjrpuyd1CPsitcElDVagE3k-p2kU4xIlRuy1f5Zgt3c,3800
 treenode/signals.py,sha256=ERrlKjGqhYaPYVKKRk1JBBlPFOmJKpJ6bXsJavcTlo0,518
 treenode/urls.py,sha256=CsgX0hRyDVrMS8YnRlr_CxmDlgGIhDpqZ9ldoMYZCac,866
-treenode/version.py,sha256=Q1ilorcSAKP3-SntEXcfmFMj0ClySSAldpayaO22S8E,222
+treenode/version.py,sha256=PBeSQ_6jPFoS_aURwvCBCsE-VlTS5vbGFlvnO41XfMY,222
 treenode/views.py,sha256=rEZEgdbEA3AJDHrvtrAm-t60QTJcJ4JEhNsNMR1Y_I4,5549
 treenode/widgets.py,sha256=Mi0F-AK_UcmU6C50ENK9vv6xGQNuDtrtzXSnXSOXhLM,4760
 treenode/admin/__init__.py,sha256=TdlPIyRW8i9qTVqGLmLWiBw4DyoGHUYZErE6rCyGOPE,119
@@ -25,7 +25,7 @@ treenode/models/mixins/children.py,sha256=OchaH6m6pOr6uuiZRRBHoZXoCSWM-ENTNWu1iL
 treenode/models/mixins/descendants.py,sha256=2mhnIhC8VJomTqntzzAwFFW_CcMiwujzQoD5_mfMsK0,2208
 treenode/models/mixins/family.py,sha256=h2IRRADkQxve97QqBHKv0evVz4cFQtcNR8CbPi9Ri_w,1645
 treenode/models/mixins/logical.py,sha256=jlhBSq3AfCYNyNjqyKM9siyioS3SYcGD-aG2b4MV2RM,2169
-treenode/models/mixins/node.py,sha256=E-eUgZoqKlyaCaDk0H7VQg6tDnfeufyGHn7hjTxIDqM,7694
+treenode/models/mixins/node.py,sha256=wgLbFKA99QuLV4l32GR3JZ5gYIVKUbfDzM8iDw4C8Bs,7694
 treenode/models/mixins/properties.py,sha256=pfv80KLXcPeGx00IFCBcst1_cf0AmzhjshFjq1XQWMY,3876
 treenode/models/mixins/roots.py,sha256=MoFQq1fph70awc26UMUbfeTpt0ToUOvMz1c7LlDyIP8,2956
 treenode/models/mixins/siblings.py,sha256=fh0ZrlFXKxOQ4Qrp6sElTMvRhU5PyRRykLHDcbH-3Rk,3113
@@ -48,7 +48,6 @@ treenode/templates/admin/tree_node_import_report.html,sha256=azHJ8JFrSRu60lF1Uh2
 treenode/templates/admin/treenode_ajax_rows.html,sha256=zFyPaTbSyxRjOqQ85SMv__qTIYDjEna6chYODBypDZA,224
 treenode/templates/widgets/tree_widget.css,sha256=2bEaxu1x7QJZ7erbs2SLMaxeaiMkjQXadfcDEW8wfok,551
 treenode/templates/widgets/tree_widget.html,sha256=GKcCU-B2FkkJ2BSOuXOw9e_PdYTtADcvyITEXqOlZ9Y,723
-treenode/tests/tests.py,sha256=9Bd2BhvwtVhYBp5DEtkzKPpAP1iFo4asMsydzuIRASM,19316
 treenode/utils/__init__.py,sha256=B4bv96ivtHELPv0_DllJa5z-k1QMo7z-MKuvj-3NdtI,356
 treenode/utils/aid.py,sha256=o8Jgc1vDRtQpx4XYdv0qR5Lqvens55Jfbdca1nr-EOA,1013
 treenode/utils/base16.py,sha256=U1PMit2aZOpYusG_u1c7eVpXO-cFrFPyVyk9zdHrehg,817
@@ -57,8 +56,8 @@ treenode/utils/db.py,sha256=36q4OckKmEd6uHTbMTxdKpV9nOIZ55DAantRWR9bxWg,4297
 treenode/utils/exporter.py,sha256=mV6Gch7XfW8f_1x3WqWgtV0qekMLdo-_n9gz6GJjXjw,7259
 treenode/utils/importer.py,sha256=Hvirbd6NyZ2MHa56_jOrUF3kYFeby1DbSLR3mhHy-9s,12891
 treenode/utils/radix.py,sha256=zHpOuDxsebiv9Gza6snNhAtBKiex6CDrAVRtB6esaWo,1642
-django_fast_treenode-2.1.2.dist-info/LICENSE,sha256=T0evsb7y-63fg18ovdNSx3wwWWRwyluQvN9J4zFSvfE,1093
-django_fast_treenode-2.1.2.dist-info/METADATA,sha256=68M56fkOFsBldq0sybbmXF0mG0m3HDHvsDs6Ofk9cDU,7558
-django_fast_treenode-2.1.2.dist-info/WHEEL,sha256=EaM1zKIUYa7rQnxGiOCGhzJABRwy4WO57rWMR3_tj4I,91
-django_fast_treenode-2.1.2.dist-info/top_level.txt,sha256=fmgxHbXyx1O2MPi_9kjx8aL9L-8TmV0gre4Go8XgqFk,9
-django_fast_treenode-2.1.2.dist-info/RECORD,,
+django_fast_treenode-2.1.3.dist-info/LICENSE,sha256=T0evsb7y-63fg18ovdNSx3wwWWRwyluQvN9J4zFSvfE,1093
+django_fast_treenode-2.1.3.dist-info/METADATA,sha256=glnnVS6RVwKFZkbQOLVkcow74o-MKFS_AsPTY_smBd4,8165
+django_fast_treenode-2.1.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+django_fast_treenode-2.1.3.dist-info/top_level.txt,sha256=fmgxHbXyx1O2MPi_9kjx8aL9L-8TmV0gre4Go8XgqFk,9
+django_fast_treenode-2.1.3.dist-info/RECORD,,

{django_fast_treenode-2.1.2.dist-info → django_fast_treenode-2.1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.9.1)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

treenode/cache.py

@@ -12,7 +12,7 @@ Features:
 - Automatic cache eviction when memory limits are exceeded.
 - Decorator `@cached_method` for caching method results.
 
-Version: 2.0.0
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """

treenode/models/mixins/node.py

@@ -23,7 +23,7 @@ class TreeNodeNodeMixin(models.Model):
         abstract = True
 
     @cached_method
-    def get_breadcrumbs(self, attr='pk'):
+    def get_breadcrumbs(self, attr='id'):
         """Optimized breadcrumbs retrieval with direct cache check."""
         try:
             self._meta.get_field(attr)

treenode/version.py

@@ -10,4 +10,4 @@ Email: timurkady@yandex.com
 """
 
 
-__version__ = '2.1.2'
+__version__ = '2.1.3'

treenode/tests/tests.py

@@ -1,488 +0,0 @@
-import time
-import traceback
-from django.test import TestCase, TransactionTestCase
-from devapp.models import Entity
-
-
-class BasicOperationsTest(TestCase):
-    """
-    Tests basic operations with nodes: insertion (using three methods), deletion,
-    moving, as well as the functionality of QuerySet methods (e.g. retrieving children).
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== BasicOperationsTest ===")
-
-        # 1. Insertion via node.save()
-        try:
-            node1 = Entity(name='Node via save()')
-            node1.save()
-            if not node1.pk:
-                errors.append("Insertion via save() did not assign a PK.")
-        except Exception as e:
-            errors.append("Insertion via save() raised an exception: " + str(e))
-
-        # 2. Insertion via objects.create()
-        try:
-            node2 = Entity.objects.create(name='Node via create()')
-            if not node1.pk:
-                errors.append(
-                    "Insertion via objects.create() did not assign a PK.")
-        except Exception as e:
-            errors.append(
-                "Insertion via objects.create() raised an exception: " + str(e))
-
-        # 3. Alternative method (insert_at or get_or_create)
-        try:
-            # For demonstration, use node1 as the parent if the insert_at method exists
-            if hasattr(Entity, 'insert_at'):
-                node3 = Entity(name='Node via insert_at()')
-                node3.insert_at(node1)
-            elif hasattr(Entity.objects, 'get_or_create'):
-                node3, created = Entity.objects.get_or_create(
-                    name='Node via get_or_create()', defaults={'tn_parent': node1})
-            else:
-                errors.append(
-                    "No alternative insertion method found (insert_at/get_or_create).")
-        except Exception as e:
-            errors.append(
-                "Alternative insertion raised an exception: " + str(e))
-
-        # Checking access methods (e.g. get_children)
-        try:
-            # Create a small tree
-            root = Entity.objects.create(name='Root')
-            child = Entity.objects.create(name='Child', tn_parent=root)
-            # If the model defines a get_children() method, check its functionality
-            if hasattr(root, 'get_children'):
-                children = root.get_children()
-                if child not in children:
-                    errors.append(
-                        "Method get_children() did not return the added child.")
-            else:
-                # If the method does not exist, perform a simple filter by parent
-                children = Entity.objects.filter(tn_parent=root)
-                if child not in children:
-                    errors.append(
-                        "Filter by parent did not return the added child.")
-        except Exception as e:
-            errors.append("Access methods check raised an exception: " + str(e))
-
-        # Tests for node deletion and moving can be added in a similar manner
-
-        # Output report for basic operations
-        if errors:
-            print("BasicOperationsTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("BasicOperationsTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "BasicOperationsTest: errors - " + ", ".join(errors))
-
-
-class DeepTreePerformanceTest(TransactionTestCase):
-    """
-    Performance test for a deep tree:
-    - A tree is created with one root and 100 levels of nesting.
-    - The insertion time for nodes is measured at levels: 0 (root), 1, 10, 50, 100.
-    - Results are printed to the console with absolute values and as a percentage of the root insertion time.
-    """
-
-    def runTest(self):
-        print("\n=== DeepTreePerformanceTest ===")
-        timings = {}  # dictionary: level -> insertion time (in seconds)
-        nodes = []    # storing references to nodes for potential read tests
-
-        try:
-            # Insertion of the root node
-            start = time.time()
-            root = Entity.objects.create(name="Deep Root")
-            end = time.time()
-            timings[0] = end - start
-            nodes.append(root)
-
-            current_parent = root
-
-            for level in range(1, 201):
-                start = time.time()
-                new_node = Entity.objects.create(
-                    name=f"Node Level {level}", tn_parent=current_parent)
-                end = time.time()
-                timings[level] = end - start
-                nodes.append(new_node)
-                current_parent = new_node  # the next node will be a child of the one just created
-
-            # Generate report for levels: 0, 1, 10, 20, 30, 40, 50, 70, 80, 90, 100, 150, 200
-            levels_to_report = [0, 1, 10, 20, 30,
-                                40, 50, 70, 80, 90, 100, 150, 200]
-            # to avoid division by zero
-            root_time = timings[0] if timings[0] > 0 else 1e-6
-            print("Deep tree - node insertion times:")
-            print("Level\tInsertion time (s)\t% of root time")
-            for lvl in levels_to_report:
-                t = timings.get(lvl, None)
-                if t is not None:
-                    perc = (t / root_time) * 100
-                    print(f"{lvl}\t{t:.6f}\t\t{perc:.2f}%")
-                else:
-                    print(f"{lvl}\tNo data")
-
-            # Additionally, one can measure node reading times using a similar approach.
-        except Exception as e:
-            print("DeepTreePerformanceTest: exception:", e)
-            traceback.print_exc()
-
-        # Since the test is exploratory in nature, simply assert True.
-        self.assertTrue(True)
-
-
-class WideTreePerformanceTest(TransactionTestCase):
-    """
-    Performance test for a wide tree:
-    - 100 roots are created, each with a tree of up to 5 levels of nesting.
-    - The total tree creation time is measured, then the average time per tree is calculated.
-    - Results are printed to the console.
-    """
-
-    def runTest(self):
-        print("\n=== WideTreePerformanceTest ===")
-        tree_times = []
-        try:
-            # For 100 trees
-            for root_index in range(1, 101):
-                tree_start = time.time()
-                root = Entity.objects.create(name=f"Wide Root {root_index}")
-                current_parent = root
-                # Create 5 levels of nesting for each root
-                for level in range(1, 6):
-                    new_node = Entity.objects.create(
-                        name=f"Node {root_index}-{level}", tn_parent=current_parent)
-                    current_parent = new_node
-                tree_end = time.time()
-                tree_times.append(tree_end - tree_start)
-
-            avg_time = sum(tree_times) / len(tree_times)
-            print("Wide tree:")
-            print(
-                f"100 trees (each with 5 levels) created with an average creation time of: {avg_time:.6f} s")
-        except Exception as e:
-            print("WideTreePerformanceTest: exception:", e)
-            traceback.print_exc()
-
-        self.assertTrue(True)
-
-
-class MassInsertionTest(TestCase):
-    """
-    Mass insertion test:
-    - Inserts nodes from 50 to 75 using all three methods (save, create, alternative method).
-    - If an error occurs with any method, it is recorded but the test continues.
-    - A detailed report is printed at the end.
-    """
-
-    def runTest(self):
-        print("\n=== MassInsertionTest ===")
-        errors = []
-        try:
-            for i in range(50, 76):
-                # 1. Insertion via save()
-                try:
-                    node = Entity(name=f"Mass Node {i} via save()")
-                    node.save()
-                except Exception as e:
-                    errors.append(f"Error inserting node {i} via save(): {e}")
-
-                # 2. Insertion via objects.create()
-                try:
-                    Entity.objects.create(name=f"Mass Node {i} via create()")
-                except Exception as e:
-                    errors.append(f"Error inserting node {i} via create(): {e}")
-
-                # 3. Alternative method (insert_at or get_or_create)
-                try:
-                    # Take the first node in the database or create a parent
-                    parent = Entity.objects.first()
-                    if not parent:
-                        parent = Entity.objects.create(name="Default Parent")
-
-                    if hasattr(Entity, 'insert_at'):
-                        node = Entity(name=f"Mass Node {i} via insert_at()")
-                        node.insert_at(parent)
-                    elif hasattr(Entity.objects, 'get_or_create'):
-                        Entity.objects.get_or_create(
-                            name=f"Mass Node {i} via get_or_create()", defaults={'tn_parent': parent})
-                    else:
-                        errors.append(
-                            f"No alternative insertion method found for node {i}.")
-                except Exception as e:
-                    errors.append(
-                        f"Error in alternative insertion for node {i}: {e}")
-        except Exception as e:
-            errors.append("General exception in MassInsertionTest: " + str(e))
-
-        if errors:
-            print("MassInsertionTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("MassInsertionTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "MassInsertionTest: errors - " + ", ".join(errors))
-
-
-class NodeDeletionTest(TestCase):
-    """
-    Tests node deletion:
-    - A parent and children are created.
-    - One of the children is deleted and it is verified that it is absent from the query.
-    - Then the parent is deleted and it is verified that cascading deletion worked (if provided).
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== NodeDeletionTest ===")
-        try:
-            parent = Entity.objects.create(name="Deletion Parent")
-            child1 = Entity.objects.create(name="Child 1", tn_parent=parent)
-            child2 = Entity.objects.create(name="Child 2", tn_parent=parent)
-
-            # Delete child1
-            child1.delete()
-            remaining_children = Entity.objects.filter(tn_parent=parent)
-            if child1 in remaining_children:
-                errors.append(
-                    "The deleted child1 is still present among the parent's children.")
-
-            # Delete the parent and check cascading deletion
-            parent.delete()
-            if Entity.objects.filter(pk=child2.pk).exists():
-                errors.append(
-                    "Child2 was not deleted after the parent was deleted (cascading deletion was expected).")
-        except Exception as e:
-            errors.append("Exception in NodeDeletionTest: " + str(e))
-
-        if errors:
-            print("NodeDeletionTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("NodeDeletionTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "NodeDeletionTest: errors - " + ", ".join(errors))
-
-
-class NodeMovingTest(TestCase):
-    """
-    Tests moving of nodes:
-    - Two parents are created.
-    - A node is moved from the first parent to the second.
-    - It is verified that the node appears in the new parent's children list and is absent from the old parent's list.
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== NodeMovingTest ===")
-        try:
-            parent1 = Entity.objects.create(name="Original Parent")
-            parent2 = Entity.objects.create(name="New Parent")
-            child = Entity.objects.create(
-                name="Movable Child", tn_parent=parent1)
-
-            # Moving the node
-            child.set_parent(parent2)
-            child.save()
-
-            children1 = Entity.objects.filter(tn_parent=parent1)
-            children2 = Entity.objects.filter(tn_parent=parent2)
-            if child in children1:
-                errors.append(
-                    "The node is still present in the original parent's children after moving.")
-            if child not in children2:
-                errors.append(
-                    "The node was not found among the new parent's children after moving.")
-        except Exception as e:
-            errors.append("Exception in NodeMovingTest: " + str(e))
-
-        if errors:
-            print("NodeMovingTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("NodeMovingTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "NodeMovingTest: errors - " + ", ".join(errors))
-
-
-class NodeUpdateTest(TestCase):
-    """
-    Tests node update:
-    - A node is created, then its attribute (e.g. name) is updated.
-    - It is verified that the change is saved in the database.
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== NodeUpdateTest ===")
-        try:
-            node = Entity.objects.create(name="Original Name")
-            node.name = "Updated Name"
-            node.save()
-            updated_node = Entity.objects.get(pk=node.pk)
-            if updated_node.name != "Updated Name":
-                errors.append("The node's name was not updated correctly.")
-        except Exception as e:
-            errors.append("Exception in NodeUpdateTest: " + str(e))
-
-        if errors:
-            print("NodeUpdateTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("NodeUpdateTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "NodeUpdateTest: errors - " + ", ".join(errors))
-
-
-class DataIntegrityTest(TestCase):
-    """
-    Tests data integrity:
-    - A small tree is created.
-    - Operations of moving, updating, and deletion are performed.
-    - The correctness of relationships between parents and children after the operations is verified.
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== DataIntegrityTest ===")
-        try:
-            root = Entity.objects.create(name="Integrity Root")
-            child1 = Entity.objects.create(
-                name="Integrity Child 1", tn_parent=root)
-            child2 = Entity.objects.create(
-                name="Integrity Child 2", tn_parent=root)
-            grandchild = Entity.objects.create(
-                name="Integrity Grandchild", tn_parent=child1)
-
-            # Move child2 under child1
-            child2.set_parent(child1)
-
-            # Update child1's name
-            child1.name = "Integrity Child 1 Updated"
-            child1.save()
-
-            # Delete grandchild
-            grandchild.delete()
-
-            # Verify relationships
-            root_children = Entity.objects.filter(tn_parent=root)
-            if child1 not in root_children:
-                errors.append(
-                    "Child1 not found among the root node's children.")
-            if child2 in root_children:
-                errors.append(
-                    "Child2 is present among the root node's children after moving.")
-
-            child1_children = Entity.objects.filter(tn_parent=child1)
-            if child2 not in child1_children:
-                errors.append(
-                    "Child2 not found among child1's children after moving.")
-
-            if Entity.objects.filter(name="Integrity Grandchild").exists():
-                errors.append("Grandchild still exists after deletion.")
-        except Exception as e:
-            errors.append("Exception in DataIntegrityTest: " + str(e))
-
-        if errors:
-            print("DataIntegrityTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("DataIntegrityTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "DataIntegrityTest: errors - " + ", ".join(errors))
-
-
-class LargeVolumeTest(TransactionTestCase):
-    """
-    Test with large data volume:
-    - Performs mass insertion of 1000 nodes.
-    - Verifies that the number of inserted nodes matches the expected count.
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== LargeVolumeTest ===")
-        try:
-            initial_count = Entity.objects.count()
-            for i in range(1000):
-                try:
-                    Entity.objects.create(name=f"Large Node {i}")
-                except Exception as e:
-                    errors.append(
-                        f"Error inserting node {i} in large data volume: {e}")
-            final_count = Entity.objects.count()
-            if final_count - initial_count != 1000:
-                errors.append(
-                    f"Expected 1000 new nodes, but got {final_count - initial_count}.")
-        except Exception as e:
-            errors.append("Exception in LargeVolumeTest: " + str(e))
-
-        if errors:
-            print("LargeVolumeTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("LargeVolumeTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "LargeVolumeTest: errors - " + ", ".join(errors))
-
-
-class InvalidDataTest(TestCase):
-    """
-    Tests handling of invalid data:
-    - Attempts to create a node with None in a required field (e.g. name).
-    - Verifies that the expected exception is raised.
-    """
-
-    def runTest(self):
-        errors = []
-        print("\n=== InvalidDataTest ===")
-        try:
-            try:
-                # Attempt to create a node with invalid data
-                Entity.objects.create(name=None)
-                errors.append(
-                    "Creating a node with None for name did not raise an exception as expected.")
-            except Exception:
-                # Expected behavior: an exception should occur
-                pass
-
-            # Additionally, one can test creating a node with an empty string if that is not allowed
-            try:
-                node = Entity(name="")
-                node.save()
-                # If an empty string is allowed, then no error should be recorded
-            except Exception as e:
-                # If an exception occurs, that may also be considered acceptable
-                pass
-        except Exception as e:
-            errors.append("Exception in InvalidDataTest: " + str(e))
-
-        if errors:
-            print("InvalidDataTest: FAILED. Errors detected:")
-            for err in errors:
-                print(" -", err)
-        else:
-            print("InvalidDataTest: PASSED.")
-
-        self.assertEqual(
-            len(errors), 0, "InvalidDataTest: errors - " + ", ".join(errors))