Merge branch 'master' into dev-greg

3 files changed, 246 insertions, 145 deletions

diff --git a/tests/managers/gr/test_authentication.py b/tests/managers/gr/test_authentication.py
index 53b6931..1310c79 100644
--- a/tests/managers/gr/test_authentication.py
+++ b/tests/managers/gr/test_authentication.py
@@ -1,120 +1,150 @@
 import logging
-from random import randint
+from collections.abc import Callable
 from uuid import uuid4
 
 import pytest
 
-from generalresearch.models.gr.authentication import GRUser
-from test_utils.models.conftest import gr_user
+from generalresearch.managers.gr.authentication import GRTokenManager, GRUserManager
+from generalresearch.managers.gr.team import TeamManager
+from generalresearch.models.gr.authentication import GRToken, GRUser
+from generalresearch.pg_helper import PostgresConfig
+from generalresearch.redis_helper import RedisConfig
 
 SSO_ISSUER = ""
 
 
 class TestGRUserManager:
 
-    def test_create(self, gr_um):
-        from generalresearch.models.gr.authentication import GRUser
-
-        user: GRUser = gr_um.create_dummy()
-        instance = gr_um.get_by_id(user.id)
-        assert user.id == instance.id
+    def test_create(self, gr_user: GRUser, gr_user_manager: GRUserManager):
+        instance = gr_user_manager.get_by_id(gr_user.id)
+        assert isinstance(instance, GRUser)
+        assert gr_user.id == instance.id
 
-        instance2 = gr_um.get_by_id(user.id)
-        assert user.model_dump_json() == instance2.model_dump_json()
+        instance2 = gr_user_manager.get_by_id(gr_user.id)
+        assert isinstance(instance2, GRUser)
+        assert gr_user.model_dump_json() == instance2.model_dump_json()
 
-    def test_get_by_id(self, gr_user, gr_um):
+    def test_get_by_id(self, gr_user: GRUser, gr_user_manager: GRUserManager):
         with pytest.raises(expected_exception=ValueError) as cm:
-            gr_um.get_by_id(gr_user_id=999_999_999)
+            gr_user_manager.get_by_id(gr_user_id=999_999_999)
         assert "GRUser not found" in str(cm.value)
 
-        instance = gr_um.get_by_id(gr_user_id=gr_user.id)
+        instance = gr_user_manager.get_by_id(gr_user_id=gr_user.id)
+        assert isinstance(instance, GRUser)
         assert instance.sub == gr_user.sub
 
-    def test_get_by_sub(self, gr_user, gr_um):
+    def test_get_by_sub(self, gr_user: GRUser, gr_user_manager: GRUserManager):
         with pytest.raises(expected_exception=ValueError) as cm:
-            gr_um.get_by_sub(sub=uuid4().hex)
+            gr_user_manager.get_by_sub(sub=uuid4().hex)
         assert "GRUser not found" in str(cm.value)
 
-        instance = gr_um.get_by_sub(sub=gr_user.sub)
+        instance = gr_user_manager.get_by_sub(sub=gr_user.sub)
+        assert isinstance(instance, GRUser)
         assert instance.id == gr_user.id
 
-    def test_get_by_sub_or_create(self, gr_user, gr_um):
+    def test_get_by_sub_or_create(
+        self, gr_user: GRUser, gr_user_manager: GRUserManager
+    ):
         sub = f"{uuid4().hex}-{uuid4().hex}"
 
         with pytest.raises(expected_exception=ValueError) as cm:
-            gr_um.get_by_sub(sub=sub)
+            gr_user_manager.get_by_sub(sub=sub)
         assert "GRUser not found" in str(cm.value)
 
-        instance = gr_um.get_by_sub_or_create(sub=sub)
+        instance = gr_user_manager.get_by_sub_or_create(sub=sub)
         assert isinstance(instance, GRUser)
         assert instance.sub == sub
 
-    def test_get_all(self, gr_um):
-        res1 = gr_um.get_all()
+    def test_get_all(
+        self, gr_user_factory: Callable[..., GRUser], gr_user_manager: GRUserManager
+    ):
+        res1 = gr_user_manager.get_all()
         assert isinstance(res1, list)
 
-        gr_um.create_dummy()
-        res2 = gr_um.get_all()
+        gr_user_factory(save=True)
+        res2 = gr_user_manager.get_all()
         assert len(res1) == len(res2) - 1
 
-    def test_get_by_team(self, gr_um):
-        res = gr_um.get_by_team(team_id=999_999_999)
+    def test_get_by_team(self, gr_user_manager: GRUserManager):
+        res = gr_user_manager.get_by_team(team_id=999_999_999)
         assert isinstance(res, list)
         assert res == []
 
-    def test_list_product_uuids(self, caplog, gr_user, gr_um, thl_web_rr):
+    def test_list_product_uuids(
+        self,
+        caplog,
+        gr_user: GRUser,
+        gr_user_manager: GRUserManager,
+        thl_web_rr: PostgresConfig,
+    ):
         with caplog.at_level(logging.WARNING):
-            gr_um.list_product_uuids(user=gr_user, thl_pg_config=thl_web_rr)
+            gr_user_manager.list_product_uuids(user=gr_user, thl_pg_config=thl_web_rr)
         assert "prefetch not run" in caplog.text
 
 
 class TestGRTokenManager:
 
-    def test_create(self, gr_user, gr_tm):
-        assert gr_tm.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_tm.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, gr_tm):
-        assert gr_tm.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_tm.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, gr_tm, gr_db, gr_redis_config):
-        from generalresearch.models.gr.authentication import GRToken
+    def test_prefetch_user(
+        self,
+        gr_user: GRUser,
+        gr_token_manager: GRTokenManager,
+        gr_db: PostgresConfig,
+        gr_redis_config: RedisConfig,
+    ):
 
-        gr_tm.create(user_id=gr_user.id)
+        gr_token_manager.create(user_id=gr_user.id)
 
-        token: GRToken = gr_tm.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)
         assert token.user.id == gr_user.id
 
-    def test_get_by_key(self, gr_user, gr_um, gr_tm):
-        gr_tm.create(user_id=gr_user.id)
-        token = gr_tm.get_by_user_id(user_id=gr_user.id)
+    def test_get_by_key(
+        self,
+        gr_user: GRUser,
+        gr_token_manager: GRTokenManager,
+    ):
+        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_tm.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_tm.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...")
-    def test_get_by_sso_key(self, gr_user, gr_um, gr_tm, gr_redis_config):
-        from generalresearch.models.gr.authentication import GRToken
+    def test_get_by_sso_key(
+        self,
+        gr_team_manager: TeamManager,
+        gr_redis_config: RedisConfig,
+    ):
 
         api_key = "..."
         jwks = {
             # ...
         }
 
-        instance = gr_tm.get_by_key(
+        instance = gr_team_manager.get_by_key(
             api_key=api_key,
             jwks=jwks,
             audience="...",
diff --git a/tests/managers/gr/test_business.py b/tests/managers/gr/test_business.py
index 7eb77f8..022086a 100644
--- a/tests/managers/gr/test_business.py
+++ b/tests/managers/gr/test_business.py
@@ -1,30 +1,52 @@
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
 import pytest
 
-from test_utils.models.conftest import business
+from generalresearch.models.gr.business import (
+    Business,
+    BusinessAddress,
+    BusinessBankAccount,
+)
+from generalresearch.models.gr.definitions import TransferMethod
+from generalresearch.models.gr.team import Team
+
+if TYPE_CHECKING:
+    from generalresearch.managers.gr.business import (
+        BusinessAddressManager,
+        BusinessBankAccountManager,
+        BusinessManager,
+    )
+    from generalresearch.managers.gr.team import MembershipManager, TeamManager
+    from generalresearch.models.gr.authentication import GRUser
+    from generalresearch.pg_helper import PostgresConfig
 
 
 class TestBusinessBankAccountManager:
 
-    def test_init(self, business_bank_account_manager, gr_db):
-        assert business_bank_account_manager.pg_config == gr_db
+    def test_init(
+        self,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
+        gr_db: PostgresConfig,
+    ):
+        assert gr_business_bank_account_manager.pg_config == gr_db
 
-    def test_create(self, business, business_bank_account_manager):
-        from generalresearch.models.gr.business import (
-            TransferMethod,
-            BusinessBankAccount,
-        )
+    def test_create(
+        self,
+        gr_business: Business,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
+    ):
 
-        instance = business_bank_account_manager.create(
-            business_id=business.id,
+        instance = gr_business_bank_account_manager.create(
+            business_id=gr_business.id,
             uuid=uuid4().hex,
             transfer_method=TransferMethod.ACH,
         )
         assert isinstance(instance, BusinessBankAccount)
         assert isinstance(instance.id, int)
 
-        res = business_bank_account_manager.get_by_business_id(
+        res = gr_business_bank_account_manager.get_by_business_id(
             business_id=instance.business_id
         )
         assert isinstance(res, list)
@@ -35,42 +57,49 @@ class TestBusinessBankAccountManager:
 
 class TestBusinessAddressManager:
 
-    def test_create(self, business, business_address_manager):
-        from generalresearch.models.gr.business import BusinessAddress
-
-        res = business_address_manager.create(uuid=uuid4().hex, business_id=business.id)
+    def test_create(
+        self, gr_business: Business, gr_business_address_manager: BusinessAddressManager
+    ):
+        assert gr_business.id
+        res = gr_business_address_manager.create(
+            uuid=uuid4().hex, business_id=gr_business.id
+        )
         assert isinstance(res, BusinessAddress)
         assert isinstance(res.id, int)
 
 
 class TestBusinessManager:
 
-    def test_create(self, business_manager):
-        from generalresearch.models.gr.business import Business
+    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)
 
-    def test_get_or_create(self, business_manager):
+    def test_get_or_create(self, gr_business_manager: BusinessManager):
         uuid_key = uuid4().hex
 
-        assert business_manager.get_by_uuid(business_uuid=uuid_key) is None
+        assert gr_business_manager.get_by_uuid(business_uuid=uuid_key) is None
 
-        instance = business_manager.get_or_create(
+        instance = gr_business_manager.get_or_create(
             uuid=uuid_key,
             name=f"name-{uuid4().hex[:6]}",
         )
 
-        res = business_manager.get_by_uuid(business_uuid=uuid_key)
+        res = gr_business_manager.get_by_uuid(business_uuid=uuid_key)
+        assert isinstance(res, Business)
         assert res.id == instance.id
 
-    def test_get_all(self, business_manager):
-        res1 = business_manager.get_all()
+    def test_get_all(
+        self,
+        gr_business_manager: BusinessManager,
+        gr_business_factory: Callable[..., Business],
+    ):
+        res1 = gr_business_manager.get_all()
         assert isinstance(res1, list)
 
-        business_manager.create_dummy()
-        res2 = business_manager.get_all()
+        gr_business_factory()
+        res2 = gr_business_manager.get_all()
         assert len(res1) == len(res2) - 1
 
     @pytest.mark.skip(reason="TODO")
@@ -78,53 +107,65 @@ class TestBusinessManager:
         pass
 
     def test_get_by_user_id(
-        self, business_manager, gr_user, team_manager, membership_manager
+        self,
+        gr_business_manager: BusinessManager,
+        gr_user: GRUser,
+        gr_team_manager: TeamManager,
+        gr_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)
+        res = gr_business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 0
 
-        # Create a Business, but don't add it to anything
-        b1 = business_manager.create_dummy()
-        res = business_manager.get_by_user_id(user_id=gr_user.id)
+        # Create a business: Business, but don't add it to anything
+        b1 = gr_business_factory()
+        res = gr_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()
-        res = business_manager.get_by_user_id(user_id=gr_user.id)
+        t1 = gr_team_factory()
+        res = gr_business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 0
 
         # Create a Membership for the gr_user to the Team... but it doesn't
         #   matter because the Team doesn't have any Business yet
-        m1 = membership_manager.create(team=t1, gr_user=gr_user)
-        res = business_manager.get_by_user_id(user_id=gr_user.id)
+        _ = gr_membership_manager.create(team=t1, gr_user=gr_user)
+        res = gr_business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 0
 
         # Add the Business to the Team... now the Business should be available
         # to the gr_user
-        team_manager.add_business(team=t1, business=b1)
-        res = business_manager.get_by_user_id(user_id=gr_user.id)
+        gr_team_manager.add_business(team=t1, business=b1)
+        res = gr_business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 1
 
         # Add another Business to the Team!
-        b2 = business_manager.create_dummy()
-        team_manager.add_business(team=t1, business=b2)
-        res = business_manager.get_by_user_id(user_id=gr_user.id)
+        b2 = gr_business_factory()
+        gr_team_manager.add_business(team=t1, business=b2)
+        res = gr_business_manager.get_by_user_id(user_id=gr_user.id)
         assert len(res) == 2
 
     @pytest.mark.skip(reason="TODO")
     def test_get_uuids_by_user_id(self):
         pass
 
-    def test_get_by_uuid(self, business, business_manager):
-        instance = business_manager.get_by_uuid(business_uuid=business.uuid)
-        assert business.id == instance.id
+    def test_get_by_uuid(
+        self, gr_business: Business, gr_business_manager: BusinessManager
+    ):
+        instance = gr_business_manager.get_by_uuid(business_uuid=gr_business.uuid)
+        assert isinstance(instance, Business)
+        assert gr_business.id == instance.id
 
-    def test_get_by_id(self, business, business_manager):
-        instance = business_manager.get_by_id(business_id=business.id)
-        assert business.uuid == instance.uuid
+    def test_get_by_id(
+        self, gr_business: Business, gr_business_manager: BusinessManager
+    ):
+        instance = gr_business_manager.get_by_id(business_id=gr_business.id)
+        assert isinstance(instance, Business)
+        assert gr_business.uuid == instance.uuid
 
-    def test_cache_key(self, business):
-        assert "business:" in business.cache_key
+    def test_cache_key(self, gr_business: Business):
+        assert "business:" in gr_business.cache_key
 
     # def test_create_raise_on_duplicate(self):
     #     b_uuid = uuid4().hex
@@ -133,7 +174,7 @@ class TestBusinessManager:
     #     business = BusinessManager.create(
     #         uuid=b_uuid,
     #         name=f"test-{b_uuid[:6]}")
-    #     assert isinstance(business, Business)
+    #     assert isinstance(gr_business: Business, Business)
     #
     #     # Try to make it again
     #     with pytest.raises(expected_exception=psycopg.errors.UniqueViolation):
diff --git a/tests/managers/gr/test_team.py b/tests/managers/gr/test_team.py
index 9215da4..878a9ca 100644
--- a/tests/managers/gr/test_team.py
+++ b/tests/managers/gr/test_team.py
@@ -1,105 +1,135 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
-from test_utils.models.conftest import team
+from generalresearch.models.gr.authentication import GRUser
+from generalresearch.models.gr.team import Membership, Team
+
+if TYPE_CHECKING:
+    from generalresearch.managers.gr.authentication import GRUserManager
+    from generalresearch.managers.gr.team import MembershipManager, TeamManager
+    from generalresearch.models.gr.authentication import GRUser
+    from generalresearch.models.thl.product import Product
+    from generalresearch.pg_helper import PostgresConfig
+    from generalresearch.redis_helper import RedisConfig
 
 
 class TestMembershipManager:
 
-    def test_init(self, membership_manager, gr_db):
-        assert membership_manager.pg_config == gr_db
+    def test_init(
+        self, gr_membership_manager: MembershipManager, gr_db: PostgresConfig
+    ):
+        assert gr_membership_manager.pg_config == gr_db
 
 
 class TestTeamManager:
 
-    def test_init(self, team_manager, gr_db):
-        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):
+    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):
-        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):
-        from generalresearch.models.gr.team import Team
+    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_manager, gr_um, gr_db, gr_redis_config):
-        from generalresearch.models.gr.authentication import GRUser
-        from generalresearch.models.gr.team import Membership
+    def test_add_user(
+        self,
+        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):
-        from generalresearch.models.gr.team import Team
+    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):
-        from generalresearch.models.gr.team import Team
+    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_manager, gr_um):
-        from generalresearch.models.gr.authentication import GRUser
-        from generalresearch.models.gr.team import Team
-
-        user: GRUser = gr_um.create_dummy()
-        team_manager.add_user(team=team, gr_user=user)
+    def test_get_by_user(
+        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
+        )
 
-        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_token,
-        gr_user,
-        membership,
-        product_factory,
-        membership_factory,
-        team,
-        thl_web_rr,
-        gr_redis_config,
-        gr_db,
+        gr_user: GRUser,
+        product_factory: Callable[..., Product],
+        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,