gr mangers all green ✅

3 files changed, 87 insertions, 58 deletions

diff --git a/tests/managers/gr/test_authentication.py b/tests/managers/gr/test_authentication.py
index 0bcabc5..1310c79 100644
--- a/tests/managers/gr/test_authentication.py
+++ b/tests/managers/gr/test_authentication.py
@@ -84,29 +84,32 @@ class TestGRUserManager:
 
 class TestGRTokenManager:
 
-    def test_create(self, gr_user: GRUser, gr_team_manager: TeamManager):
-        assert gr_team_manager.create(user_id=gr_user.id) is None
+    def test_create(self, gr_user: GRUser, gr_token_manager: GRTokenManager):
+        assert gr_token_manager.create(user_id=gr_user.id) is None
 
-        token = gr_team_manager.get_by_user_id(user_id=gr_user.id)
+        token = gr_token_manager.get_by_user_id(user_id=gr_user.id)
+        assert isinstance(token, GRToken)
         assert gr_user.id == token.user_id
 
-    def test_get_by_user_id(self, gr_user: GRUser, gr_team_manager: TeamManager):
-        assert gr_team_manager.create(user_id=gr_user.id) is None
+    def test_get_by_user_id(self, gr_user: GRUser, gr_token_manager: GRTokenManager):
+        assert gr_token_manager.create(user_id=gr_user.id) is None
 
-        token = gr_team_manager.get_by_user_id(user_id=gr_user.id)
+        token = gr_token_manager.get_by_user_id(user_id=gr_user.id)
+        assert isinstance(token, GRToken)
         assert gr_user.id == token.user_id
 
     def test_prefetch_user(
         self,
         gr_user: GRUser,
-        gr_team_manager: TeamManager,
+        gr_token_manager: GRTokenManager,
         gr_db: PostgresConfig,
         gr_redis_config: RedisConfig,
     ):
 
-        gr_team_manager.create(user_id=gr_user.id)
+        gr_token_manager.create(user_id=gr_user.id)
 
-        token: GRToken = gr_team_manager.get_by_user_id(user_id=gr_user.id)
+        token: GRToken | None = gr_token_manager.get_by_user_id(user_id=gr_user.id)
+        assert isinstance(token, GRToken)
         assert token.user is None
 
         token.prefetch_user(pg_config=gr_db, redis_config=gr_redis_config)
@@ -115,17 +118,18 @@ class TestGRTokenManager:
     def test_get_by_key(
         self,
         gr_user: GRUser,
-        gr_team_manager: TeamManager,
+        gr_token_manager: GRTokenManager,
     ):
-        gr_team_manager.create(user_id=gr_user.id)
-        token = gr_team_manager.get_by_user_id(user_id=gr_user.id)
+        gr_token_manager.create(user_id=gr_user.id)
+        token = gr_token_manager.get_by_user_id(user_id=gr_user.id)
+        assert isinstance(token, GRToken)
 
-        instance = gr_team_manager.get_by_key(api_key=token.key)
+        instance = gr_token_manager.get_by_key(api_key=token.key)
         assert token.created == instance.created
 
         # Search for non-existent key
         with pytest.raises(expected_exception=Exception) as cm:
-            gr_team_manager.get_by_key(api_key=uuid4().hex)
+            gr_token_manager.get_by_key(api_key=uuid4().hex)
         assert "No GRUser with token of " in str(cm.value)
 
     @pytest.mark.skip(reason="no idea how to actually test this...")
diff --git a/tests/managers/gr/test_business.py b/tests/managers/gr/test_business.py
index 3513af5..0d5b0d5 100644
--- a/tests/managers/gr/test_business.py
+++ b/tests/managers/gr/test_business.py
@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from typing import TYPE_CHECKING
 from uuid import uuid4
 
@@ -9,6 +10,7 @@ from generalresearch.models.gr.business import (
     BusinessBankAccount,
 )
 from generalresearch.models.gr.definitions import TransferMethod
+from generalresearch.models.gr.team import Team
 
 if TYPE_CHECKING:
     from generalresearch.managers.gr.business import (
@@ -68,9 +70,9 @@ class TestBusinessAddressManager:
 
 class TestBusinessManager:
 
-    def test_create(self, business_manager: BusinessManager):
+    def test_create(self, gr_business_factory: Callable[..., Business]):
 
-        instance = business_manager.create_dummy()
+        instance = gr_business_factory()
         assert isinstance(instance, Business)
         assert isinstance(instance.id, int)
 
@@ -88,11 +90,15 @@ class TestBusinessManager:
         assert isinstance(res, Business)
         assert res.id == instance.id
 
-    def test_get_all(self, business_manager: BusinessManager):
+    def test_get_all(
+        self,
+        business_manager: BusinessManager,
+        gr_business_factory: Callable[..., Business],
+    ):
         res1 = business_manager.get_all()
         assert isinstance(res1, list)
 
-        business_manager.create_dummy()
+        gr_business_factory()
         res2 = business_manager.get_all()
         assert len(res1) == len(res2) - 1
 
@@ -106,17 +112,19 @@ class TestBusinessManager:
         gr_user: GRUser,
         team_manager: TeamManager,
         membership_manager: MembershipManager,
+        gr_business_factory: Callable[..., Business],
+        gr_team_factory: Callable[..., Team],
     ):
         res = business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 0
 
         # Create a business: Business, but don't add it to anything
-        b1 = business_manager.create_dummy()
+        b1 = gr_business_factory()
         res = business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 0
 
         # Create a Team, but don't create any Memberships
-        t1 = team_manager.create_dummy()
+        t1 = gr_team_factory()
         res = business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 0
 
@@ -133,7 +141,7 @@ class TestBusinessManager:
         assert len(res) == 1
 
         # Add another Business to the Team!
-        b2 = business_manager.create_dummy()
+        b2 = gr_business_factory()
         team_manager.add_business(team=t1, business=b2)
         res = business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 2
diff --git a/tests/managers/gr/test_team.py b/tests/managers/gr/test_team.py
index 17e0470..751e33c 100644
--- a/tests/managers/gr/test_team.py
+++ b/tests/managers/gr/test_team.py
@@ -4,6 +4,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING
 from uuid import uuid4
 
+from generalresearch.models.gr.authentication import GRUser
 from generalresearch.models.gr.team import Membership, Team
 
 if TYPE_CHECKING:
@@ -23,94 +24,110 @@ class TestMembershipManager:
 
 class TestTeamManager:
 
-    def test_init(self, team_manager: TeamManager, gr_db: PostgresConfig):
-        assert team_manager.pg_config == gr_db
+    def test_init(self, gr_team_manager: TeamManager, gr_db: PostgresConfig):
+        assert gr_team_manager.pg_config == gr_db
 
-    def test_get_or_create(self, team_manager: TeamManager):
+    def test_get_or_create(self, gr_team_manager: TeamManager):
         from generalresearch.models.gr.team import Team
 
         new_uuid = uuid4().hex
 
-        team: Team = team_manager.get_or_create(uuid=new_uuid)
+        team: Team = gr_team_manager.get_or_create(uuid=new_uuid)
 
         assert isinstance(team, Team)
         assert isinstance(team.id, int)
         assert team.uuid == new_uuid
         assert team.name == "< Unknown >"
 
-    def test_get_all(self, team_manager: TeamManager):
-        res1 = team_manager.get_all()
+    def test_get_all(
+        self, gr_team_factory: Callable[..., Team], gr_team_manager: TeamManager
+    ):
+        res1 = gr_team_manager.get_all()
         assert isinstance(res1, list)
 
-        team_manager.create_dummy()
-        res2 = team_manager.get_all()
+        gr_team_factory()
+        res2 = gr_team_manager.get_all()
         assert len(res1) == len(res2) - 1
 
-    def test_create(self, team_manager: TeamManager):
+    def test_create(
+        self, gr_team_factory: Callable[..., Team], gr_team_manager: TeamManager
+    ):
 
-        team: Team = team_manager.create_dummy()
+        team: Team = gr_team_factory()
         assert isinstance(team, Team)
         assert isinstance(team.id, int)
 
     def test_add_user(
         self,
-        team: Team,
-        team_manager: TeamManager,
-        gr_um: GRUserManager,
-        gr_db: PostgresConfig,
-        gr_redis_config: RedisConfig,
+        gr_team: Team,
+        gr_team_manager: TeamManager,
+        gr_user_manager: GRUserManager,
+        gr_user_factory: Callable[..., GRUser],
     ):
 
-        user: GRUser = gr_um.create_dummy()
+        user: GRUser = gr_user_factory()
 
-        instance = team_manager.add_user(team=team, gr_user=user)
+        instance = gr_team_manager.add_user(
+            gr_user_manager=gr_user_manager, team=gr_team, gr_user=user
+        )
         assert isinstance(instance, Membership)
 
         # assert team.gr_users is None
-        team.prefetch_gr_users(pg_config=gr_db, redis_config=gr_redis_config)
-        assert isinstance(team.gr_users, list)
-        assert len(team.gr_users)
-        assert team.gr_users == [user]
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert isinstance(gr_team.gr_users, list)
+        assert len(gr_team.gr_users)
+        assert gr_team.gr_users == [user]
 
-    def test_get_by_uuid(self, team_manager: TeamManager):
+    def test_get_by_uuid(
+        self, gr_team_factory: Callable[..., Team], gr_team_manager: TeamManager
+    ):
 
-        team: Team = team_manager.create_dummy()
+        team: Team = gr_team_factory()
 
-        instance = team_manager.get_by_uuid(team_uuid=team.uuid)
+        instance = gr_team_manager.get_by_uuid(team_uuid=team.uuid)
+        assert isinstance(instance, Team)
         assert team.id == instance.id
 
-    def test_get_by_id(self, team_manager: TeamManager):
+    def test_get_by_id(
+        self, gr_team_factory: Callable[..., Team], gr_team_manager: TeamManager
+    ):
 
-        team: Team = team_manager.create_dummy()
+        team: Team = gr_team_factory()
 
-        instance = team_manager.get_by_id(team_id=team.id)
+        instance = gr_team_manager.get_by_id(team_id=team.id)
+        assert isinstance(instance, Team)
         assert team.uuid == instance.uuid
 
     def test_get_by_user(
-        self, team: Team, team_manager: TeamManager, gr_um: GRUserManager
+        self,
+        gr_team: Team,
+        gr_user_factory: Callable[..., GRUser],
+        gr_team_manager: TeamManager,
+        gr_user_manager: GRUserManager,
     ):
+        user: GRUser = gr_user_factory()
+        gr_team_manager.add_user(
+            gr_user_manager=gr_user_manager, team=gr_team, gr_user=user
+        )
 
-        user: GRUser = gr_um.create_dummy()
-        team_manager.add_user(team=team, gr_user=user)
-
-        res = team_manager.get_by_user(gr_user=user)
+        res = gr_team_manager.get_by_user(gr_user=user)
         assert isinstance(res, list)
         assert len(res) == 1
         instance = res[0]
         assert isinstance(instance, Team)
-        assert instance.uuid == team.uuid
+        assert instance.uuid == gr_team.uuid
 
     def test_get_by_user_duplicates(
         self,
         gr_user: GRUser,
         product_factory: Callable[..., Product],
-        membership_factory: Callable[..., Membership],
-        team: Team,
+        gr_membership_factory: Callable[..., Membership],
+        gr_team: Team,
         gr_redis_config: RedisConfig,
         gr_db: PostgresConfig,
     ):
-        product_factory(team=team)
-        membership_factory(team=team, gr_user=gr_user)
+        product_factory(team=gr_team)
+        gr_membership_factory(gr_team=gr_team, gr_user=gr_user)
 
         gr_user.prefetch_teams(
             pg_config=gr_db,