Merge branch 'master' into dev-greg

1 files changed, 229 insertions, 108 deletions

diff --git a/test_utils/models/gr/conftest.py b/test_utils/models/gr/conftest.py
index df97306..f5dcaa1 100644
--- a/test_utils/models/gr/conftest.py
+++ b/test_utils/models/gr/conftest.py
@@ -1,31 +1,34 @@
 from __future__ import annotations
 
-from typing import Callable
+from collections.abc import Callable
+from random import randint
+from typing import TYPE_CHECKING
 from uuid import uuid4
 
 import pytest
 from pydantic import PositiveInt
 from pydantic_extra_types.phone_numbers import PhoneNumber
 
-from generalresearch.managers.gr.authentication import GRTokenManager, GRUserManager
-from generalresearch.managers.gr.business import (
-    BusinessAddressManager,
-    BusinessBankAccountManager,
-    BusinessManager,
-)
-from generalresearch.managers.gr.team import MembershipManager, TeamManager
 from generalresearch.models.custom_types import UUIDStr
-from generalresearch.models.gr.authentication import GRToken, GRUser
-from generalresearch.models.gr.business import (
-    Business,
-    BusinessAddress,
-    BusinessBankAccount,
-    BusinessType,
-    TransferMethod,
-)
-from generalresearch.models.gr.team import Membership, Team
-from generalresearch.pg_helper import PostgresConfig
-from generalresearch.redis_helper import RedisConfig
+from generalresearch.models.gr.definitions import TransferMethod
+
+if TYPE_CHECKING:
+    from generalresearch.managers.gr.authentication import GRTokenManager, GRUserManager
+    from generalresearch.managers.gr.business import (
+        BusinessAddressManager,
+        BusinessBankAccountManager,
+        BusinessManager,
+    )
+    from generalresearch.managers.gr.team import MembershipManager, TeamManager
+    from generalresearch.models.gr.authentication import GRToken, GRUser
+    from generalresearch.models.gr.business import (
+        Business,
+        BusinessAddress,
+        BusinessBankAccount,
+    )
+    from generalresearch.models.gr.team import Membership, Team
+    from generalresearch.pg_helper import PostgresConfig
+    from generalresearch.redis_helper import RedisConfig
 
 # --- Static ---
 
@@ -33,68 +36,57 @@ from generalresearch.redis_helper import RedisConfig
 # --- Factory / Database ---
 
 
-@pytest.fixture
-def gr_user_factory(gr_user_manager: GRUserManager) -> Callable[..., GRUser]:
-
-    def _inner(
-        sub: str | None = None,
-        is_superuser: bool = False,
-    ) -> GRUser:
-        sub = sub or f"{uuid4().hex}-{uuid4().hex}"
-
-        return gr_user_manager.create(
-            sub=sub,
-            is_superuser=is_superuser,
-        )
-
-    return _inner
-
-
-@pytest.fixture
-def gr_user_cache(
-    gr_user: GRUser,
-    gr_db: PostgresConfig,
-    thl_web_rr: PostgresConfig,
-    gr_redis_config: RedisConfig,
-) -> GRUser:
-    gr_user.set_cache(
-        pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
-    )
-    return gr_user
+# --- Business Bank Account ---
 
 
 @pytest.fixture
 def gr_business_bank_account_factory(
-    gr_bbam: BusinessBankAccountManager,
+    gr_business_bank_account_manager: BusinessBankAccountManager,
 ) -> Callable[..., BusinessBankAccount]:
 
     def _inner(
         business_id: PositiveInt,
+        save: bool = True,
         uuid: UUIDStr | None = None,
         transfer_method: TransferMethod | None = None,
         account_number: str | None = None,
         routing_number: str | None = None,
         iban: str | None = None,
         swift: str | None = None,
-    ):
-        from generalresearch.models.gr.business import TransferMethod
-
-        return gr_bbam.create(
-            business_id=business_id,
-            uuid=uuid or uuid4().hex,
-            transfer_method=transfer_method or TransferMethod.ACH,
-            account_number=account_number or uuid4().hex[:6],
-            routing_number=routing_number or uuid4().hex[:6],
-            iban=iban or uuid4().hex[:6],
-            swift=swift or uuid4().hex[:6],
-        )
+        **kwargs,
+    ) -> BusinessBankAccount:
+
+        if save:
+            return gr_business_bank_account_manager.create(
+                business_id=business_id,
+                uuid=uuid or uuid4().hex,
+                transfer_method=transfer_method or TransferMethod.ACH,
+                account_number=account_number or uuid4().hex[:6],
+                routing_number=routing_number or uuid4().hex[:6],
+                iban=iban or uuid4().hex[:6],
+                swift=swift or uuid4().hex[:6],
+                **kwargs,
+            )
+        else:
+            raise ValueError("Unsaved BusinessBankAccount not supported yet")
 
     return _inner
 
 
 @pytest.fixture
+def gr_business_bank_account(
+    gr_business_bank_account_factory: Callable[..., BusinessBankAccount],
+    gr_business: Business,
+) -> BusinessBankAccount:
+    return gr_business_bank_account_factory(save=True, business_id=gr_business.id)
+
+
+# --- Business Address ---
+
+
+@pytest.fixture
 def gr_business_address_factory(
-    gr_bam: BusinessAddressManager,
+    gr_business_address_manager: BusinessAddressManager,
 ) -> Callable[..., BusinessAddress]:
 
     def _inner(
@@ -107,7 +99,7 @@ def gr_business_address_factory(
         postal_code: str | None = None,
         phone_number: PhoneNumber | None = None,
         country: str | None = None,
-    ):
+    ) -> BusinessAddress:
         uuid = uuid or uuid4().hex
         line_1 = line_1 or "abc"
         line_2 = line_2 or "bczx"
@@ -117,7 +109,7 @@ def gr_business_address_factory(
         phone_number = None
         country = country or "US"
 
-        return gr_bam.create(
+        return gr_business_address_manager.create(
             business_id=business_id,
             uuid=uuid,
             line_1=line_1,
@@ -133,54 +125,175 @@ def gr_business_address_factory(
 
 
 @pytest.fixture
+def gr_business_address(
+    gr_business_address_factory: Callable[..., BusinessAddress], gr_business: Business
+) -> BusinessAddress:
+    return gr_business_address_factory(business_id=gr_business.id)
+
+
+# --- Business ---
+
+
+@pytest.fixture
 def gr_business_factory(
-    gr_bm: BusinessManager,
+    gr_business_manager: BusinessManager,
 ) -> Callable[..., Business]:
 
     def _inner(
+        save: bool = True, name: str | None = None, team: Team | None = None, **kwargs
+    ) -> Business:
+        name = name or f"<Unknown {uuid4().hex[:12]}>"
+        tax_number = str(randint(1, 999_999_999))
+
+        if save:
+            return gr_business_manager.create(
+                name=name,
+                kind="c",
+                uuid=uuid4().hex,
+                team=team,
+                tax_number=tax_number,
+                **kwargs,
+            )
+        else:
+            raise ValueError("Unsaved Business not supported yet")
+
+    return _inner
+
+
+@pytest.fixture
+def gr_business(gr_business_factory: Callable[..., Business]) -> Business:
+    return gr_business_factory(save=True)
+
+
+@pytest.fixture
+def unsaved_gr_business(gr_business_factory: Callable[..., Business]) -> Business:
+    return gr_business_factory(save=False)
+
+
+# --- GR Team ---
+
+
+@pytest.fixture
+def gr_team_factory(
+    gr_team_manager: TeamManager,
+) -> Callable[..., Team]:
+
+    def _inner(
+        save: bool = True,
         uuid: UUIDStr | None = None,
         name: str | None = None,
-        team: Team | None = None,
-        kind: BusinessType | None = None,
-        tax_number: str | None = None,
-    ) -> Business:
-        from random import randint
+        **kwargs,
+    ) -> Team:
 
-        uuid = uuid or uuid4().hex
-        name = name or "< Unknown >"
-        tax_number = tax_number or str(randint(1, 999_999_999))
+        name = name or f"<Team ({uuid4().hex[:6]})>"
 
-        return gr_bm.create(
-            uuid=uuid, name=name, team=team, kind=kind, tax_number=tax_number
-        )
+        if save:
+            return gr_team_manager.create(name=name, uuid=uuid, **kwargs)
+
+        else:
+            raise ValueError("BusinessBankAccount Business not supported yet")
 
     return _inner
 
 
 @pytest.fixture
-def gr_team(
-    gr_tm: TeamManager,
-) -> Callable[..., Team]:
+def gr_team(gr_team_factory: Callable[..., Team]) -> Team:
+    return gr_team_factory(save=True)
 
-    def _inner(uuid: UUIDStr | None = None, name: str | None = None) -> Team:
-        uuid = uuid or uuid4().hex
-        name = name or f"name-{uuid4().hex[:12]}"
 
-        return gr_tm.create(uuid=uuid, name=name)
+@pytest.fixture
+def unsaved_gr_team(
+    gr_team_factory: Callable[..., Team],
+) -> Team:
+    return gr_team_factory(save=False)
+
+
+# --- GR User ---
+
+
+@pytest.fixture
+def gr_user_factory(gr_user_manager: GRUserManager) -> Callable[..., GRUser]:
+
+    def _inner(
+        save: bool = True,
+        sub: str | None = None,
+        is_superuser: bool = False,
+    ) -> GRUser:
+        sub = sub or f"{uuid4().hex}-{uuid4().hex}"
+
+        if save:
+            return gr_user_manager.create(
+                sub=sub,
+                is_superuser=is_superuser,
+            )
+        else:
+            raise ValueError("Unsaved GR User not supported yet")
 
     return _inner
 
 
-@pytest.fixture()
-def gr_user_token(
-    gr_user: GRUser, gr_tm: GRTokenManager, gr_db: PostgresConfig
-) -> GRToken:
-    gr_tm.create(user_id=gr_user.id)
-    gr_user.prefetch_token(pg_config=gr_db)
+@pytest.fixture
+def gr_user_cache(
+    gr_user: GRUser,
+    gr_db: PostgresConfig,
+    thl_web_rr: PostgresConfig,
+    gr_redis_config: RedisConfig,
+) -> GRUser:
+    gr_user.set_cache(
+        pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
+    )
+    return gr_user
 
-    res = gr_user.token
-    assert res is not None, "GRToken should exist after creation and prefetching"
-    return res
+
+@pytest.fixture
+def gr_user(gr_user_factory: Callable[..., GRUser]) -> GRUser:
+    return gr_user_factory(save=True)
+
+
+@pytest.fixture
+def unsaved_gr_user(
+    gr_user_factory: Callable[..., GRUser],
+) -> GRUser:
+    return gr_user_factory(save=False)
+
+
+# --- GR User Token ---
+
+
+@pytest.fixture
+def gr_user_token_factory(
+    gr_user: GRUser, gr_token_manager: GRTokenManager, gr_db: PostgresConfig
+) -> Callable[..., GRToken]:
+
+    def _inner(
+        save: bool = True,
+    ) -> GRToken:
+
+        if save:
+            assert gr_user.id
+            gr_token_manager.create(user_id=gr_user.id)
+            gr_user.prefetch_token(pg_config=gr_db)
+
+            res = gr_user.token
+            assert res is not None, (
+                "GRToken should exist after creation and prefetching"
+            )
+            return res
+
+        else:
+            raise ValueError("Unsaved GR User not supported yet")
+
+    return _inner
+
+
+@pytest.fixture
+def gr_user_token(gr_user_token_factory: Callable[..., GRToken]) -> GRToken:
+    return gr_user_token_factory(save=True)
+
+
+@pytest.fixture
+def unsaved_gr_user_token(gr_user_token_factory: Callable[..., GRToken]) -> GRToken:
+    return gr_user_token_factory(save=False)
 
 
 @pytest.fixture()
@@ -188,26 +301,34 @@ def gr_user_token_header(gr_user_token: GRToken) -> dict[str, str]:
     return gr_user_token.auth_header
 
 
-@pytest.fixture(scope="function")
-def membership(team: Team, gr_user: GRUser, team_manager: TeamManager) -> Membership:
-    assert team.id, "Team must be saved"
-    assert gr_user.id, "GRUser must be saved"
-    return team_manager.add_user(team=team, gr_user=gr_user)
+# --- GR Membership ---
 
 
-@pytest.fixture(scope="function")
-def membership_factory(
-    team: Team,
-    gr_user: GRUser,
-    membership_manager: MembershipManager,
-    team_manager: TeamManager,
-    gr_um: GRUserManager,
+@pytest.fixture()
+def gr_membership_factory(
+    gr_membership_manager: MembershipManager,
 ) -> Callable[..., Membership]:
 
-    def _inner(**kwargs) -> Membership:
-        _team = kwargs.get("team", team_manager.create_dummy())
-        _gr_user = kwargs.get("gr_user", gr_um.create_dummy())
-
-        return membership_manager.create(team=_team, gr_user=_gr_user)
+    def _inner(
+        gr_team: Team, gr_user: GRUser, save: bool = True, **kwargs
+    ) -> Membership:
+        if save:
+            return gr_membership_manager.create(team=gr_team, gr_user=gr_user, **kwargs)
+        else:
+            raise ValueError("Unsaved GR Membership not supported yet")
 
     return _inner
+
+
+@pytest.fixture()
+def gr_membership(
+    gr_membership_factory: Callable[..., Membership], gr_team: Team, gr_user: GRUser
+) -> Membership:
+    return gr_membership_factory(gr_team=gr_team, gr_user=gr_user, save=True)
+
+
+@pytest.fixture()
+def unsaved_gr_membership(
+    gr_membership_factory: Callable[..., Membership],
+) -> Membership:
+    return gr_membership_factory(save=False)