Add tests for masoniteorm Collection.load() and raise coverage to 100%

Cover the Collection subclass's post-query eager loading (load) and
with_relationship_autoloading no-op, which previously had ~28% coverage:

- has-one and has-many relations registered after load()
- loading multiple relations in one call
- empty-collection short-circuit and no-matching-records path
- non-Collection get_related result routed through add_relation

Author: tmgbedu

fastapi_startkit/tests/masoniteorm/collection/test_collection.py

@@ -1,7 +1,9 @@
+from unittest import IsolatedAsyncioTestCase
+
 from fastapi_startkit.masoniteorm.collection import Collection
 from fastapi_startkit.masoniteorm.models.model import Model
 
-from ..fixtures.model import User
+from ..fixtures.model import Articles, Profile, User
 from ..sqlite.test_case import TestCase
 
 
@@ -17,6 +19,54 @@ async def test_serialize_with_on_the_fly_appends(self):
         self.assertTrue(isinstance(serialized, list))
         self.assertTrue(len(serialized) > 0)
 
+    async def test_load_has_one_relationship(self):
+        users = await User.all()
+
+        result = await users.load("profile")
+
+        self.assertIs(result, users)
+        admin = users.where("email", "admin@admin.com").first()
+        self.assertIn("profile", admin._relationships)
+        self.assertIsInstance(admin.profile, Profile)
+
+    async def test_load_has_many_relationship(self):
+        users = await User.all()
+
+        result = await users.load("articles")
+
+        self.assertIs(result, users)
+        admin = users.where("email", "admin@admin.com").first()
+        self.assertIn("articles", admin._relationships)
+        self.assertEqual(len(admin.articles), 1)
+        self.assertIsInstance(admin.articles[0], Articles)
+
+    async def test_load_multiple_relationships_at_once(self):
+        users = await User.all()
+
+        await users.load("profile", "articles")
+
+        admin = users.where("email", "admin@admin.com").first()
+        self.assertIn("profile", admin._relationships)
+        self.assertIn("articles", admin._relationships)
+
+    async def test_load_without_matching_related_records(self):
+        # Jane (id 2) has no articles, so get_related returns an empty
+        # collection and no relation is registered.
+        users = await User.where("id", 2).get()
+
+        result = await users.load("articles")
+
+        self.assertIs(result, users)
+        self.assertNotIn("articles", users.first()._relationships)
+
+    async def test_load_on_empty_collection_returns_self(self):
+        users = await User.where("id", 9999).get()
+        self.assertTrue(users.is_empty())
+
+        result = await users.load("profile")
+
+        self.assertIs(result, users)
+
     def test_take(self):
         collection = Collection([1, 2, 3, 4])
         self.assertEqual(collection.take(2), [1, 2])
@@ -694,3 +744,43 @@ def test_eq(self):
         self.assertTrue(collection == other)
         different = Collection([1, 2, 3])
         self.assertFalse(collection == different)
+
+
+class _StubRelationship:
+    """Relationship whose get_related returns a non-Collection result."""
+
+    async def get_related(self, query, relation):
+        return {"id": 99}
+
+    def map_related(self, related_result):
+        return related_result
+
+
+class _StubModel:
+    stub = _StubRelationship()
+
+    def __init__(self):
+        self.relations = {}
+
+    def add_relation(self, data):
+        self.relations.update(data)
+
+
+class TestCollectionLoad(IsolatedAsyncioTestCase):
+    """Covers the load() paths that don't require a database."""
+
+    async def test_load_on_empty_collection_is_noop(self):
+        collection = Collection([])
+        self.assertIs(await collection.load("stub"), collection)
+
+    async def test_load_registers_non_collection_result_via_add_relation(self):
+        collection = Collection([_StubModel(), _StubModel()])
+
+        result = await collection.load("stub")
+
+        self.assertIs(result, collection)
+        for model in collection:
+            self.assertEqual(model.relations["stub"], {"id": 99})
+
+    def test_with_relationship_autoloading_is_noop(self):
+        self.assertIsNone(Collection([]).with_relationship_autoloading())