test(orm): refactor DBSeedCommand tests to class-based app-driven style

Port the class-based unittest.TestCase refactor onto this branch:
setUp builds the app via fixtures.app.create_app(), happy-path
coverage runs through the registered console app against real fixture
seeders, and the option/argument-resolution tests assert the Seeder
call directly (autospec mock) instead of relying on console output.
Exception paths keep asserting via CommandTester.

Adapted to this branch's pre-rename masoniteorm.seeds module path
since it has not yet picked up the seeds -> seeders rename.

Author: tmgbedu

fastapi_startkit/tests/masoniteorm/commands/fixtures/databases/seeds/__init__.py

@@ -0,0 +1,8 @@
+from fastapi_startkit.masoniteorm.seeds import Seeder
+
+from .recorder import CALLS
+
+
+class DatabaseSeeder(Seeder):
+    async def run(self):
+        CALLS.append(("database", self.connection))

fastapi_startkit/tests/masoniteorm/commands/fixtures/databases/seeds/database_seeder.py

@@ -0,0 +1,3 @@
+"""Shared call recorder used by the fixture seeder classes below."""
+
+CALLS = []

fastapi_startkit/tests/masoniteorm/commands/fixtures/databases/seeds/recorder.py

@@ -0,0 +1,8 @@
+from fastapi_startkit.masoniteorm.seeds import Seeder
+
+from .recorder import CALLS
+
+
+class SampleSeeder(Seeder):
+    async def run(self):
+        CALLS.append(("sample", self.connection))

fastapi_startkit/tests/masoniteorm/commands/fixtures/databases/seeds/sample_seeder.py

@@ -0,0 +1,8 @@
+from fastapi_startkit.masoniteorm.seeds import Seeder
+
+from .recorder import CALLS
+
+
+class SpecialSeeder(Seeder):
+    async def run(self):
+        CALLS.append(("special", self.connection))

fastapi_startkit/tests/masoniteorm/commands/fixtures/databases/seeds/special_seeder.py

@@ -0,0 +1,8 @@
+from fastapi_startkit.masoniteorm.seeds import Seeder
+
+from .recorder import CALLS
+
+
+class UserTableSeeder(Seeder):
+    async def run(self):
+        CALLS.append(("user_table", self.connection))

fastapi_startkit/tests/masoniteorm/commands/fixtures/databases/seeds/user_table_seeder.py

@@ -1,96 +1,138 @@
+import io
 import unittest
+from contextlib import redirect_stdout
 from unittest import mock
 
 from cleo.testers.command_tester import CommandTester
 
 from fastapi_startkit.masoniteorm.commands.DBSeedCommand import DBSeedCommand
 
+from .fixtures.databases.seeds.recorder import CALLS
 
-class FakeSeeder:
-    """Records constructor args and awaited methods, mocking DB side effects."""
-
-    instances = []
-
-    def __init__(self, seed_path="databases/seeds", connection=None):
-        self.seed_path = seed_path
-        self.connection = connection
-        self.calls = []
-        FakeSeeder.instances.append(self)
-
-    async def run_database_seed(self):
-        self.calls.append(("run_database_seed", None))
-
-    async def run_specific_seed(self, seed):
-        self.calls.append(("run_specific_seed", seed))
+FIXTURE_SEED_PATH = "tests.masoniteorm.commands.fixtures.databases.seeds"
 
 
 class TestDBSeedCommand(unittest.TestCase):
     def setUp(self):
-        FakeSeeder.instances = []
-        patcher = mock.patch(
-            "fastapi_startkit.masoniteorm.seeds.Seeder",
-            FakeSeeder,
-        )
-        patcher.start()
-        self.addCleanup(patcher.stop)
+        from .fixtures.app import create_app
+
+        self.app = create_app()
+        CALLS.clear()
+
+    def tearDown(self):
+        CALLS.clear()
 
     def _run(self, args=""):
         tester = CommandTester(DBSeedCommand())
         tester.execute(args)
         return tester.io.fetch_output()
 
+    def _run_app(self, args=""):
+        buffer = io.StringIO()
+        with redirect_stdout(buffer):
+            self.app.run("db:seed", args)
+        return buffer.getvalue()
+
+    # -- option/argument resolution, exercised against a mocked Seeder --
+
     def test_runs_database_seeder_by_default(self):
-        output = self._run("")
+        with mock.patch("fastapi_startkit.masoniteorm.seeds.Seeder", autospec=True) as MockSeeder:
+            output = self._run("")
 
         self.assertIn("Database Seeder seeded!", output)
-        seeder = FakeSeeder.instances[-1]
-        self.assertEqual(seeder.calls, [("run_database_seed", None)])
-        self.assertEqual(seeder.seed_path, "databases/seeds")
-        self.assertEqual(seeder.connection, "default")
+        MockSeeder.assert_called_once_with(seed_path="databases/seeds", connection="default")
+        MockSeeder.return_value.run_database_seed.assert_awaited_once_with()
+        MockSeeder.return_value.run_specific_seed.assert_not_awaited()
 
     def test_seeds_specific_table_from_argument(self):
-        output = self._run("posts")
+        with mock.patch("fastapi_startkit.masoniteorm.seeds.Seeder", autospec=True) as MockSeeder:
+            output = self._run("posts")
 
         self.assertIn("PostsTableSeeder seeded!", output)
-        seeder = FakeSeeder.instances[-1]
-        self.assertEqual(
-            seeder.calls,
-            [("run_specific_seed", "posts_table_seeder.PostsTableSeeder")],
-        )
+        MockSeeder.return_value.run_specific_seed.assert_awaited_once_with("posts_table_seeder.PostsTableSeeder")
 
     def test_class_option_resolves_plain_class_name(self):
-        output = self._run("--class PostSeeder")
+        with mock.patch("fastapi_startkit.masoniteorm.seeds.Seeder", autospec=True) as MockSeeder:
+            output = self._run("--class PostSeeder")
 
         self.assertIn("PostSeeder seeded!", output)
-        seeder = FakeSeeder.instances[-1]
-        self.assertEqual(
-            seeder.calls,
-            [("run_specific_seed", "post_seeder.PostSeeder")],
-        )
+        MockSeeder.return_value.run_specific_seed.assert_awaited_once_with("post_seeder.PostSeeder")
 
     def test_class_option_resolves_table_seeder_suffix(self):
-        output = self._run("--class PostTableSeeder")
+        with mock.patch("fastapi_startkit.masoniteorm.seeds.Seeder", autospec=True) as MockSeeder:
+            output = self._run("--class PostTableSeeder")
 
         self.assertIn("PostTableSeeder seeded!", output)
-        seeder = FakeSeeder.instances[-1]
-        self.assertEqual(
-            seeder.calls,
-            [("run_specific_seed", "post_table_seeder.PostTableSeeder")],
-        )
+        MockSeeder.return_value.run_specific_seed.assert_awaited_once_with("post_table_seeder.PostTableSeeder")
 
     def test_class_option_accepts_dotted_path(self):
-        output = self._run("--class custom.MySeeder")
+        with mock.patch("fastapi_startkit.masoniteorm.seeds.Seeder", autospec=True) as MockSeeder:
+            output = self._run("--class custom.MySeeder")
 
         self.assertIn("MySeeder seeded!", output)
-        seeder = FakeSeeder.instances[-1]
-        self.assertEqual(seeder.calls, [("run_specific_seed", "custom.MySeeder")])
+        MockSeeder.return_value.run_specific_seed.assert_awaited_once_with("custom.MySeeder")
 
     def test_connection_and_directory_options_are_forwarded(self):
-        self._run("--connection sqlite --directory db/seeds")
+        with mock.patch("fastapi_startkit.masoniteorm.seeds.Seeder", autospec=True) as MockSeeder:
+            self._run("--connection sqlite --directory db/seeds")
+
+        MockSeeder.assert_called_once_with(seed_path="db/seeds", connection="sqlite")
+
+    # -- end-to-end, driven through the registered console app against real fixture seeders --
+
+    def test_runs_database_seeder_by_default_via_app(self):
+        output = self._run_app(f"--directory {FIXTURE_SEED_PATH} --connection sqlite")
+
+        self.assertIn("Database Seeder seeded!", output)
+        self.assertEqual(CALLS, [("database", "sqlite")])
+
+    def test_runs_seeder_for_table_argument_via_app(self):
+        output = self._run_app(f"user --directory {FIXTURE_SEED_PATH} --connection sqlite")
+
+        self.assertIn("UserTableSeeder seeded!", output)
+        self.assertEqual(CALLS, [("user_table", "sqlite")])
+
+    def test_runs_seeder_for_class_option_without_table_suffix_via_app(self):
+        output = self._run_app(f"--directory {FIXTURE_SEED_PATH} --class SampleSeeder --connection sqlite")
+
+        self.assertIn("SampleSeeder seeded!", output)
+        self.assertEqual(CALLS, [("sample", "sqlite")])
+
+    def test_runs_seeder_for_class_option_with_table_suffix_via_app(self):
+        output = self._run_app(f"--directory {FIXTURE_SEED_PATH} --class UserTableSeeder --connection sqlite")
+
+        self.assertIn("UserTableSeeder seeded!", output)
+        self.assertEqual(CALLS, [("user_table", "sqlite")])
+
+    def test_runs_seeder_for_fully_qualified_class_option_via_app(self):
+        output = self._run_app(
+            f"--directory {FIXTURE_SEED_PATH} --class special_seeder.SpecialSeeder --connection sqlite"
+        )
+
+        self.assertIn("SpecialSeeder seeded!", output)
+        self.assertEqual(CALLS, [("special", "sqlite")])
+
+    def test_class_option_takes_precedence_over_table_argument_via_app(self):
+        output = self._run_app(f"user --directory {FIXTURE_SEED_PATH} --class SampleSeeder --connection sqlite")
+
+        self.assertIn("SampleSeeder seeded!", output)
+        self.assertEqual(CALLS, [("sample", "sqlite")])
+
+    def test_uses_default_connection_option_via_app(self):
+        self._run_app(f"--directory {FIXTURE_SEED_PATH}")
+
+        self.assertEqual(CALLS, [("database", "default")])
+
+    # -- error paths: driven directly through CommandTester, since the console
+    # application catches command exceptions instead of propagating them --
+
+    def test_raises_when_seeder_class_cannot_be_found(self):
+        with self.assertRaises(ValueError):
+            self._run(f"--directory {FIXTURE_SEED_PATH} --class does_not_exist.NopeSeeder --connection sqlite")
 
-        seeder = FakeSeeder.instances[-1]
-        self.assertEqual(seeder.seed_path, "db/seeds")
-        self.assertEqual(seeder.connection, "sqlite")
+    def test_raises_when_database_seeder_missing_from_directory(self):
+        with self.assertRaises(ValueError):
+            self._run("--directory tests.masoniteorm.commands.fixtures.databases.migrations --connection sqlite")
 
 
 if __name__ == "__main__":