WIP tests/models/gr

9 files changed, 185 insertions, 208 deletions

diff --git a/generalresearch/models/gr/business.py b/generalresearch/models/gr/business.py
index 73a2f27..2104650 100644
--- a/generalresearch/models/gr/business.py
+++ b/generalresearch/models/gr/business.py
@@ -302,7 +302,10 @@ class Business(BaseModel):
         #   of knowing if a new Product has been added since the last time it
         #   ran.
         self.prefetch_products(product_manager=product_manager)
+        assert isinstance(self.products, list)
         product_lookup = {p.uuid: p for p in self.products}
+        assert isinstance(self.product_uuids, list)
+        assert thl_lm.currency
 
         accounts = thl_lm.get_accounts_if_exists(
             qualified_names=[
@@ -339,7 +342,7 @@ class Business(BaseModel):
 
     def prebuild_balance(
         self,
-        thl_pg_config: PostgresConfig,
+        product_manager: ProductManager,
         lm: LedgerManager,
         ds: GRLDatasets,
         client: DaskClient,
@@ -369,8 +372,9 @@ class Business(BaseModel):
         volume levels.
         """
         LOG.debug(f"Business.prebuild_balance({self.uuid=})")
+        assert lm.currency
 
-        self.prefetch_products(thl_pg_config=thl_pg_config)
+        self.prefetch_products(product_manager=product_manager)
 
         accounts: list[LedgerAccount] = lm.get_accounts_if_exists(
             qualified_names=(
@@ -425,7 +429,7 @@ class Business(BaseModel):
         df = df.groupby("account_id").sum()
 
         self.balance = BusinessBalances.from_pandas(
-            input_data=df, accounts=accounts, thl_pg_config=thl_pg_config
+            input_data=df, accounts=accounts, product_manager=product_manager
         )
 
         return
@@ -462,6 +466,7 @@ class Business(BaseModel):
         """
         if self.bp_accounts is None:
             self.prefetch_bp_accounts(thl_lm=thl_lm, product_manager=product_manager)
+        assert isinstance(self.bp_accounts, list)
 
         from generalresearch.models.admin.request import (
             ReportRequest,
@@ -504,13 +509,13 @@ class Business(BaseModel):
 
     def prebuild_enriched_session_parquet(
         self,
-        thl_pg_config: PostgresConfig,
+        product_manager: ProductManager,
         ds: GRLDatasets,
         client: DaskClient,
         mnt_gr_api: Path,
         enriched_session: EnrichedSessionMerge | None = None,
     ) -> None:
-        self.prefetch_products(thl_pg_config=thl_pg_config)
+        self.prefetch_products(product_manager=product_manager)
 
         if enriched_session is None:
             from generalresearch.incite.defaults import (
@@ -547,13 +552,13 @@ class Business(BaseModel):
 
     def prebuild_enriched_wall_parquet(
         self,
-        thl_pg_config: PostgresConfig,
+        product_manager: ProductManager,
         ds: GRLDatasets,
         client: DaskClient,
         mnt_gr_api: Path,
         enriched_wall: EnrichedWallMerge | None = None,
     ) -> None:
-        self.prefetch_products(thl_pg_config=thl_pg_config)
+        self.prefetch_products(product_manager=product_manager)
 
         if enriched_wall is None:
             from generalresearch.incite.defaults import (
@@ -619,6 +624,8 @@ class Business(BaseModel):
     def set_cache(
         self,
         pg_config: PostgresConfig,
+        product_manager: ProductManager,
+        business_bank_account_manager: BusinessBankAccountManager,
         thl_web_rr: PostgresConfig,
         redis_config: RedisConfig,
         client: DaskClient,
@@ -637,12 +644,14 @@ class Business(BaseModel):
 
         self.prefetch_addresses(pg_config=pg_config)
         self.prefetch_teams(pg_config=pg_config)
-        self.prefetch_products(thl_pg_config=thl_web_rr)
-        self.prefetch_bank_accounts(pg_config=pg_config)
-        self.prefetch_bp_accounts(thl_lm=thl_lm, thl_pg_config=thl_web_rr)
+        self.prefetch_products(product_manager=product_manager)
+        self.prefetch_bank_accounts(
+            business_bank_account_manager=business_bank_account_manager
+        )
+        self.prefetch_bp_accounts(thl_lm=thl_lm, product_manager=product_manager)
 
         self.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=lm,
             ds=ds,
             client=client,
@@ -650,7 +659,7 @@ class Business(BaseModel):
         )
         self.prebuild_payouts(bpem=bpem)
         self.prebuild_pop_financial(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             thl_lm=thl_lm,
             ds=ds,
             client=client,
@@ -682,7 +691,7 @@ class Business(BaseModel):
             enriched_session = es(ds=ds)
 
         self.prebuild_enriched_session_parquet(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             client=client,
             ds=ds,
             mnt_gr_api=mnt_gr_api,
@@ -695,7 +704,7 @@ class Business(BaseModel):
             enriched_wall = ew(ds=ds)
 
         self.prebuild_enriched_wall_parquet(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             client=client,
             ds=ds,
             mnt_gr_api=mnt_gr_api,
diff --git a/generalresearch/models/gr/team.py b/generalresearch/models/gr/team.py
index b1553e2..aa62c5a 100644
--- a/generalresearch/models/gr/team.py
+++ b/generalresearch/models/gr/team.py
@@ -142,13 +142,13 @@ class Team(BaseModel):
 
     def prebuild_enriched_session_parquet(
         self,
-        thl_pg_config: PostgresConfig,
+        product_manager: ProductManager,
         ds: GRLDatasets,
         client: Client,
         mnt_gr_api: Path,
         enriched_session: EnrichedSessionMerge | None = None,
     ) -> None:
-        self.prefetch_products(thl_pg_config=thl_pg_config)
+        self.prefetch_products(product_manager=product_manager)
 
         if enriched_session is None:
             from generalresearch.incite.defaults import (
@@ -185,13 +185,13 @@ class Team(BaseModel):
 
     def prebuild_enriched_wall_parquet(
         self,
-        thl_pg_config: PostgresConfig,
+        product_manager: ProductManager,
         ds: GRLDatasets,
         client: Client,
         mnt_gr_api: Path,
         enriched_wall: EnrichedWallMerge | None = None,
     ) -> None:
-        self.prefetch_products(thl_pg_config=thl_pg_config)
+        self.prefetch_products(product_manager=product_manager)
 
         if enriched_wall is None:
             from generalresearch.incite.defaults import (
@@ -259,7 +259,10 @@ class Team(BaseModel):
 
     def set_cache(
         self,
-        pg_config: PostgresConfig,
+        product_manager: ProductManager,
+        gr_user_manager: GRUserManager,
+        gr_business_manager: BusinessManager,
+        gr_membership_manager: MembershipManager,
         thl_web_rr: PostgresConfig,
         redis_config: RedisConfig,
         client: Client,
@@ -268,10 +271,10 @@ class Team(BaseModel):
         enriched_session: EnrichedSessionMerge | None = None,
         enriched_wall: EnrichedWallMerge | None = None,
     ) -> None:
-        self.prefetch_products(thl_pg_config=thl_web_rr)
-        self.prefetch_gr_users(pg_config=pg_config, redis_config=redis_config)
-        self.prefetch_businesses(pg_config=pg_config, redis_config=redis_config)
-        self.prefetch_memberships(pg_config=pg_config)
+        self.prefetch_products(product_manager=product_manager)
+        self.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        self.prefetch_businesses(business_manager=gr_business_manager)
+        self.prefetch_memberships(membership_manager=gr_membership_manager)
 
         rc = redis_config.create_redis_client()
         mapping = self.model_dump(mode="json")
@@ -288,7 +291,7 @@ class Team(BaseModel):
             enriched_session = es(ds=ds)
 
         self.prebuild_enriched_session_parquet(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             client=client,
             ds=ds,
             mnt_gr_api=mnt_gr_api,
@@ -301,7 +304,7 @@ class Team(BaseModel):
             enriched_wall = ew(ds=ds)
 
         self.prebuild_enriched_wall_parquet(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             client=client,
             ds=ds,
             mnt_gr_api=mnt_gr_api,
diff --git a/generalresearch/thl_django/app/test_settings.py b/generalresearch/thl_django/app/test_settings.py
index c9a1955..f3d23af 100644
--- a/generalresearch/thl_django/app/test_settings.py
+++ b/generalresearch/thl_django/app/test_settings.py
@@ -1,7 +1,7 @@
 DATABASES = {
     "default": {
         "ENGINE": "django.db.backends.postgresql",
-        "NAME": 'unittest-2026-09-03-7aa1e5',
+        "NAME": 'unittest-2026-09-03-728bcf',
         "USER": 'jenkins',
         "PASSWORD": '123456789',
         "HOST": 'unittest-postgresql.fmt2.grl.internal',
diff --git a/test_utils/managers/conftest.py b/test_utils/managers/conftest.py
index ed771c7..ff088c2 100644
--- a/test_utils/managers/conftest.py
+++ b/test_utils/managers/conftest.py
@@ -14,15 +14,6 @@ from generalresearch.managers.thl.user_streak import (
 from generalresearch.models.definitions import Source
 
 if TYPE_CHECKING:
-    from generalresearch.managers.gr.business import (
-        BusinessAddressManager,
-        BusinessBankAccountManager,
-        BusinessManager,
-    )
-    from generalresearch.managers.gr.team import (
-        MembershipManager,
-        TeamManager,
-    )
     from generalresearch.managers.spectrum.survey import SpectrumSurveyManager
     from generalresearch.managers.thl.buyer import BuyerManager
     from generalresearch.managers.thl.ipinfo import (
@@ -35,6 +26,7 @@ if TYPE_CHECKING:
         IPRecordManager,
         UserIpHistoryManager,
     )
+    from generalresearch.models.thl.user import User
     from generalresearch.models.thl.wallet.cashout_method import CashoutMethod
     from generalresearch.pg_helper import PostgresConfig
     from generalresearch.redis_helper import RedisConfig
@@ -100,7 +92,7 @@ def user_iphistory_manager(
 
 
 @pytest.fixture(scope="function")
-def user_iphistory_manager_clear_cache(user_iphistory_manager, user):
+def user_iphistory_manager_clear_cache(user_iphistory_manager, user: User):
     # On successive py-test/jenkins runs, the cache may contain
     #   the previous run's info (keyed under the same user_id)
     user_iphistory_manager.delete_user_ip_history_cache(user_id=user.user_id)
@@ -205,69 +197,6 @@ def spectrum_survey_manager(spectrum_rw: SqlHelper) -> SpectrumSurveyManager:
     return SpectrumSurveyManager(sql_helper=spectrum_rw)
 
 
-# === GR ===
-@pytest.fixture(scope="session")
-def business_manager(
-    gr_db: PostgresConfig, gr_redis_config: RedisConfig
-) -> BusinessManager:
-    from generalresearch.redis_helper import RedisConfig
-
-    assert gr_db.dsn.path
-    assert "/unittest-" in gr_db.dsn.path
-    assert isinstance(gr_redis_config, RedisConfig)
-
-    from generalresearch.managers.gr.business import BusinessManager
-
-    return BusinessManager(
-        pg_config=gr_db,
-        redis_config=gr_redis_config,
-    )
-
-
-@pytest.fixture(scope="session")
-def business_address_manager(gr_db: PostgresConfig) -> BusinessAddressManager:
-    assert gr_db.dsn.path
-    assert "/unittest-" in gr_db.dsn.path
-
-    from generalresearch.managers.gr.business import BusinessAddressManager
-
-    return BusinessAddressManager(pg_config=gr_db)
-
-
-@pytest.fixture(scope="session")
-def business_bank_account_manager(
-    gr_db: PostgresConfig,
-) -> BusinessBankAccountManager:
-    assert gr_db.dsn.path
-    assert "/unittest-" in gr_db.dsn.path
-
-    from generalresearch.managers.gr.business import (
-        BusinessBankAccountManager,
-    )
-
-    return BusinessBankAccountManager(pg_config=gr_db)
-
-
-@pytest.fixture(scope="session")
-def team_manager(gr_db: PostgresConfig, gr_redis_config: RedisConfig) -> TeamManager:
-    assert gr_db.dsn.path
-    assert "/unittest-" in gr_db.dsn.path
-
-    from generalresearch.managers.gr.team import TeamManager
-
-    return TeamManager(pg_config=gr_db, redis_config=gr_redis_config)
-
-
-@pytest.fixture(scope="session")
-def membership_manager(gr_db: PostgresConfig) -> MembershipManager:
-    assert gr_db.dsn.path
-    assert "/unittest-" in gr_db.dsn.path
-
-    from generalresearch.managers.gr.team import MembershipManager
-
-    return MembershipManager(pg_config=gr_db)
-
-
 @pytest.fixture(scope="session")
 def delete_buyers_surveys(
     thl_web_rw: PostgresConfig, buyer_manager: BuyerManager
diff --git a/test_utils/managers/thl/conftest.py b/test_utils/managers/thl/conftest.py
index 6e19bef..18a31e2 100644
--- a/test_utils/managers/thl/conftest.py
+++ b/test_utils/managers/thl/conftest.py
@@ -184,7 +184,10 @@ def product_manager(thl_web_rw: PostgresConfig) -> ProductManager:
 
 @pytest.fixture(scope="session")
 def user_manager(
-    settings: GRLBaseSettings, thl_web_rw: PostgresConfig, thl_web_rr: PostgresConfig
+    settings: GRLBaseSettings,
+    thl_web_rw: PostgresConfig,
+    thl_web_rr: PostgresConfig,
+    thl_redis_config: RedisConfig,
 ) -> UserManager:
     assert thl_web_rw.dsn
     assert thl_web_rw.dsn.path
@@ -193,16 +196,22 @@ def user_manager(
     assert "/unittest-" in thl_web_rw.dsn.path
     assert "/unittest-" in thl_web_rr.dsn.path
 
+    from generalresearch.managers.thl.user_manager.rate_limit import UserManagerLimiter
     from generalresearch.managers.thl.user_manager.user_manager import (
         UserManager,
     )
 
-    return UserManager(
+    um = UserManager(
         pg_config=thl_web_rw,
         pg_config_rr=thl_web_rr,
         redis=settings.redis,
     )
 
+    # rc = thl_redis_config.create_redis_client()
+    um.user_manager_limiter = UserManagerLimiter(redis=thl_redis_config.dsn)
+
+    return um
+
 
 @pytest.fixture(scope="session")
 def mysql_user_manager(thl_web_rw: PostgresConfig) -> MysqlUserManager:
diff --git a/test_utils/models/thl/conftest.py b/test_utils/models/thl/conftest.py
index badd87c..5826f0d 100644
--- a/test_utils/models/thl/conftest.py
+++ b/test_utils/models/thl/conftest.py
@@ -39,6 +39,7 @@ if TYPE_CHECKING:
     from generalresearch.managers.thl.userhealth import AuditLogManager, IPRecordManager
     from generalresearch.managers.thl.wall import WallManager
     from generalresearch.models.definitions import DeviceType
+    from generalresearch.models.gr.business import Business
     from generalresearch.models.gr.team import Team
     from generalresearch.models.legacy.bucket import Bucket
     from generalresearch.models.thl.ipinfo import IPGeoname, IPInformation
@@ -154,8 +155,7 @@ def product_factory(product_manager: ProductManager) -> Callable[..., Product]:
     def _inner(
         save: bool = True,
         team: Team | None = None,
-        # business: Business | None = None,
-        # commission_pct: Decimal = Decimal("0.05"),
+        business: Business | None = None,
         product_id: UUIDStr | None = None,
         business_id: UUIDStr | None = None,
         name: str | None = None,
@@ -171,8 +171,12 @@ def product_factory(product_manager: ProductManager) -> Callable[..., Product]:
         user_health_config: UserHealthConfig | None = None,
     ) -> Product:
         """To be used in tests, where we don't care about certain fields"""
+
         product_id = product_id if product_id else uuid4().hex
+
         team_id = team.uuid if team else uuid4().hex
+        business_id = business.uuid if business else uuid4().hex
+
         name = name if name else f"name-{product_id[:12]}"
         redirect_url = redirect_url if redirect_url else "https://www.example.com/"
 
diff --git a/tests/models/gr/test_base.py b/tests/models/gr/test_base.py
index fba0960..56603bf 100644
--- a/tests/models/gr/test_base.py
+++ b/tests/models/gr/test_base.py
@@ -41,10 +41,15 @@ class TestGRPostgresDjangoCreation:
         assert isinstance(dsn, PostgresDsn)
 
     def test_django_tables(self, gr_db: PostgresConfig):
+        """
+        WARNING: This will always be the thl_django tables in addition
+        to the GR tables due to the way our fixtures are loaded.
+        """
+
         res = gr_db.execute_sql_query(query="""
             SELECT COUNT(*)
             FROM information_schema.tables
             WHERE table_schema = 'public';
         """)
         assert len(res) == 1
-        assert res[0]["count"] == 10
+        assert res[0]["count"] == 65
diff --git a/tests/models/gr/test_business.py b/tests/models/gr/test_business.py
index 57f31f3..4e0b4e1 100644
--- a/tests/models/gr/test_business.py
+++ b/tests/models/gr/test_business.py
@@ -194,7 +194,7 @@ class TestBusiness:
             bpem=business_payout_event_manager,
         )
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -283,12 +283,13 @@ class TestBusiness:
         thl_web_rr: PostgresConfig,
         ledger_manager: LedgerManager,
         pop_ledger_merge: PopLedgerMerge,
+        product_manager: ProductManager,
     ):
         assert gr_business.balance is None
 
         with pytest.raises(expected_exception=AssertionError) as cm:
             gr_business.prebuild_balance(
-                thl_pg_config=thl_web_rr,
+                product_manager=product_manager,
                 lm=ledger_manager,
                 ds=mnt_filepath,
                 client=client_no_amm,
@@ -409,8 +410,6 @@ class TestBusiness:
         )
 
         gr_business.prebuild_payouts(
-            thl_pg_config=thl_web_rr,
-            thl_lm=thl_ledger_manager,
             bpem=business_payout_event_manager,
         )
 
@@ -495,6 +494,7 @@ class TestBusinessBalance:
         create_main_accounts: Callable[..., None],
         client_no_amm: DaskClient,
         ledger_collection,
+        product_manager: ProductManager,
         pop_ledger_merge: PopLedgerMerge,
         delete_df_collection: Callable[..., None],
     ):
@@ -522,7 +522,7 @@ class TestBusinessBalance:
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -549,6 +549,7 @@ class TestBusinessBalance:
         user_factory: Callable[..., User],
         mnt_filepath: GRLDatasets,
         ledger_manager: LedgerManager,
+        product_manager: ProductManager,
         start: datetime,
         thl_web_rr: PostgresConfig,
         session_with_tx_factory: Callable[..., Session],
@@ -582,7 +583,7 @@ class TestBusinessBalance:
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -631,6 +632,7 @@ class TestBusinessBalance:
         gr_business: Business,
         product_factory: Callable[..., Product],
         user_factory: Callable[..., User],
+        product_manager: ProductManager,
         mnt_filepath: GRLDatasets,
         bp_payout_factory: Callable[..., BrokerageProductPayoutEvent],
         thl_ledger_manager: ThlLedgerManager,
@@ -687,7 +689,7 @@ class TestBusinessBalance:
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -714,6 +716,7 @@ class TestBusinessBalance:
         payout_event_manager: PayoutEventManager,
         session_with_tx_factory: Callable[..., Session],
         delete_ledger_db: Callable[..., None],
+        product_manager: ProductManager,
         create_main_accounts: Callable[..., None],
         ledger_collection,
         task_adj_collection,
@@ -799,7 +802,7 @@ class TestBusinessBalance:
         assert df.shape == (20, 28)
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -846,6 +849,7 @@ class TestBusinessBalance:
         start: datetime,
         bp_payout_factory: Callable[..., BrokerageProductPayoutEvent],
         payout_event_manager,
+        product_manager: ProductManager,
         adj_to_fail_with_tx_factory: Callable[..., None],
         thl_web_rr: PostgresConfig,
         ledger_manager: LedgerManager,
@@ -903,7 +907,7 @@ class TestBusinessBalance:
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -958,6 +962,7 @@ class TestBusinessBalance:
         bp_payout_factory: Callable[..., BrokerageProductPayoutEvent],
         thl_ledger_manager: ThlLedgerManager,
         ledger_manager: LedgerManager,
+        product_manager: ProductManager,
         start: datetime,
         thl_web_rr: PostgresConfig,
         payout_event_manager,
@@ -1065,7 +1070,7 @@ class TestBusinessBalance:
         assert df.shape == (20, 28)
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1073,7 +1078,7 @@ class TestBusinessBalance:
         )
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1083,7 +1088,7 @@ class TestBusinessBalance:
         day1_bal = gr_business.balance
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1093,7 +1098,7 @@ class TestBusinessBalance:
         day2_bal = gr_business.balance
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1103,7 +1108,7 @@ class TestBusinessBalance:
         day3_bal = gr_business.balance
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1113,7 +1118,7 @@ class TestBusinessBalance:
         day4_bal = gr_business.balance
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1123,7 +1128,7 @@ class TestBusinessBalance:
         day5_bal = gr_business.balance
 
         gr_business.prebuild_balance(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             lm=ledger_manager,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -1196,8 +1201,10 @@ class TestBusinessMethods:
         ledger_manager: LedgerManager,
         thl_ledger_manager: ThlLedgerManager,
         business_payout_event_manager,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
+        product_manager: ProductManager,
         product_factory: Callable[..., Product],
-        team: Team,
+        gr_team: Team,
         session_with_tx_factory: Callable[..., Session],
         user_factory: Callable[..., User],
         ledger_collection,
@@ -1211,7 +1218,7 @@ class TestBusinessMethods:
         client = gr_redis_config.create_redis_client()
         assert client.get(name=gr_business.cache_key) is None
 
-        p1 = product_factory(team=team, business=gr_business)
+        p1 = product_factory(team=gr_team, business=gr_business)
         u1 = user_factory(product=p1)
 
         # Business needs tx & incite to build balance
@@ -1223,7 +1230,9 @@ class TestBusinessMethods:
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
         gr_business.set_cache(
-            pg_config=gr_db,
+            product_manager=product_manager,
+            business_bank_account_manager=gr_business_bank_account_manager,
+            pg_config=thl_web_rr,
             thl_web_rr=thl_web_rr,
             redis_config=gr_redis_config,
             client=client_no_amm,
@@ -1260,6 +1269,8 @@ class TestBusinessMethods:
         ledger_manager: LedgerManager,
         thl_ledger_manager: ThlLedgerManager,
         business_payout_event_manager,
+        product_manager: ProductManager,
+        gr_business_bank_account_manager: BusinessBankAccountManager,
         user_factory: Callable[..., User],
         delete_ledger_db: Callable[..., None],
         create_main_accounts: Callable[..., None],
@@ -1286,6 +1297,8 @@ class TestBusinessMethods:
         pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
 
         gr_business.set_cache(
+            product_manager=product_manager,
+            business_bank_account_manager=gr_business_bank_account_manager,
             pg_config=gr_db,
             thl_web_rr=thl_web_rr,
             redis_config=gr_redis_config,
@@ -1351,6 +1364,7 @@ class TestBusinessMethods:
         enriched_session_merge,
         client_no_amm: DaskClient,
         wall_collection: WallDFCollection,
+        product_manager: ProductManager,
         session_collection: SessionDFCollection,
         thl_web_rr: PostgresConfig,
         user_factory: Callable[..., User],
@@ -1389,7 +1403,7 @@ class TestBusinessMethods:
         )
 
         gr_business.prebuild_enriched_session_parquet(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             mnt_gr_api=mnt_gr_api_dir,
@@ -1409,6 +1423,7 @@ class TestBusinessMethods:
         enriched_wall_merge,
         client_no_amm: DaskClient,
         wall_collection: WallDFCollection,
+        product_manager: ProductManager,
         session_collection: SessionDFCollection,
         thl_web_rr: PostgresConfig,
         user_factory: Callable[..., User],
@@ -1447,7 +1462,7 @@ class TestBusinessMethods:
         )
 
         gr_business.prebuild_enriched_wall_parquet(
-            thl_pg_config=thl_web_rr,
+            product_manager=product_manager,
             ds=mnt_filepath,
             client=client_no_amm,
             mnt_gr_api=mnt_gr_api_dir,
diff --git a/tests/models/gr/test_team.py b/tests/models/gr/test_team.py
index aa2de45..a94d53f 100644
--- a/tests/models/gr/test_team.py
+++ b/tests/models/gr/test_team.py
@@ -29,7 +29,10 @@ if TYPE_CHECKING:
     from generalresearch.incite.mergers.foundations.enriched_wall import (
         EnrichedWallMerge,
     )
+    from generalresearch.managers.gr.authentication import GRUserManager
+    from generalresearch.managers.gr.business import BusinessManager
     from generalresearch.managers.gr.team import MembershipManager, TeamManager
+    from generalresearch.managers.thl.product import ProductManager
     from generalresearch.models.gr.authentication import GRUser
     from generalresearch.models.gr.team import Membership
     from generalresearch.models.thl.session import Session
@@ -40,118 +43,118 @@ if TYPE_CHECKING:
 
 class TestTeam:
 
-    def test_init(self, team: Team):
+    def test_init(self, gr_team: Team):
 
-        assert isinstance(team, Team)
-        assert isinstance(team.id, int)
-        assert isinstance(team.uuid, str)
+        assert isinstance(gr_team, Team)
+        assert isinstance(gr_team.id, int)
+        assert isinstance(gr_team.uuid, str)
 
-    def test_memberships_none(self, team: Team, gr_db: PostgresConfig):
-        assert team.memberships is None
+    def test_memberships_none(
+        self, gr_team: Team, gr_membership_manager: MembershipManager
+    ):
+        assert gr_team.memberships is None
 
-        team.prefetch_memberships(pg_config=gr_db)
-        assert isinstance(team.memberships, list)
-        assert len(team.memberships) == 0
+        gr_team.prefetch_memberships(membership_manager=gr_membership_manager)
+        assert isinstance(gr_team.memberships, list)
+        assert len(gr_team.memberships) == 0
 
     def test_memberships(
         self,
-        team: Team,
+        gr_team: Team,
         gr_user: GRUser,
         gr_user_factory: Callable[..., GRUser],
-        membership_manager: MembershipManager,
-        gr_db: PostgresConfig,
+        gr_membership_manager: MembershipManager,
     ):
-        assert team.memberships is None
+        assert gr_team.memberships is None
 
-        team.prefetch_memberships(pg_config=gr_db)
-        assert isinstance(team.memberships, list)
-        assert len(team.memberships) == 1
-        assert team.memberships[0].user_id == gr_user.id
+        gr_team.prefetch_memberships(membership_manager=gr_membership_manager)
+        assert isinstance(gr_team.memberships, list)
+        assert len(gr_team.memberships) == 1
+        assert gr_team.memberships[0].user_id == gr_user.id
 
         # Create another new Membership
-        membership_manager.create(team=team, gr_user=gr_user_factory())
-        assert len(team.memberships) == 1
-        team.prefetch_memberships(pg_config=gr_db)
-        assert len(team.memberships) == 2
+        gr_membership_manager.create(team=gr_team, gr_user=gr_user_factory())
+        assert len(gr_team.memberships) == 1
+        gr_team.prefetch_memberships(membership_manager=gr_membership_manager)
+        assert len(gr_team.memberships) == 2
 
     def test_gr_users(
         self,
-        team: Team,
+        gr_team: Team,
         gr_user_factory: Callable[..., GRUser],
         membership_manager: MembershipManager,
-        gr_db: PostgresConfig,
-        gr_redis_config: RedisConfig,
+        gr_user_manager: GRUserManager,
     ):
-        assert team.gr_users is None
+        assert gr_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) == 0
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert isinstance(gr_team.gr_users, list)
+        assert len(gr_team.gr_users) == 0
 
         # Create a new Membership
-        membership_manager.create(team=team, gr_user=gr_user_factory())
-        assert len(team.gr_users) == 0
-        team.prefetch_gr_users(pg_config=gr_db, redis_config=gr_redis_config)
-        assert len(team.gr_users) == 1
+        membership_manager.create(team=gr_team, gr_user=gr_user_factory())
+        assert len(gr_team.gr_users) == 0
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert len(gr_team.gr_users) == 1
 
         # Create another Membership
-        membership_manager.create(team=team, gr_user=gr_user_factory())
-        assert len(team.gr_users) == 1
-        team.prefetch_gr_users(pg_config=gr_db, redis_config=gr_redis_config)
-        assert len(team.gr_users) == 2
+        membership_manager.create(team=gr_team, gr_user=gr_user_factory())
+        assert len(gr_team.gr_users) == 1
+        gr_team.prefetch_gr_users(gr_user_manager=gr_user_manager)
+        assert len(gr_team.gr_users) == 2
 
     def test_businesses(
         self,
-        team: Team,
+        gr_team: Team,
         business: Business,
         team_manager: TeamManager,
-        gr_db: PostgresConfig,
-        gr_redis_config: RedisConfig,
+        gr_business_manager: BusinessManager,
     ):
 
-        assert team.businesses is None
+        assert gr_team.businesses is None
 
-        team.prefetch_businesses(pg_config=gr_db, redis_config=gr_redis_config)
-        assert isinstance(team.businesses, list)
-        assert len(team.businesses) == 0
+        gr_team.prefetch_businesses(business_manager=gr_business_manager)
+        assert isinstance(gr_team.businesses, list)
+        assert len(gr_team.businesses) == 0
 
-        team_manager.add_business(team=team, business=business)
-        assert len(team.businesses) == 0
-        team.prefetch_businesses(pg_config=gr_db, redis_config=gr_redis_config)
-        assert len(team.businesses) == 1
-        assert isinstance(team.businesses[0], Business)
-        assert team.businesses[0].uuid == business.uuid
+        team_manager.add_business(team=gr_team, business=business)
+        assert len(gr_team.businesses) == 0
+        gr_team.prefetch_businesses(business_manager=gr_business_manager)
+        assert len(gr_team.businesses) == 1
+        assert isinstance(gr_team.businesses[0], Business)
+        assert gr_team.businesses[0].uuid == business.uuid
 
     def test_products(
         self,
-        team: Team,
+        gr_team: Team,
         product_factory: Callable[..., Product],
         thl_web_rr: PostgresConfig,
+        product_manager: ProductManager,
     ):
 
-        assert team.products is None
+        assert gr_team.products is None
 
-        team.prefetch_products(thl_pg_config=thl_web_rr)
-        assert isinstance(team.products, list)
-        assert len(team.products) == 0
+        gr_team.prefetch_products(product_manager=product_manager)
+        assert isinstance(gr_team.products, list)
+        assert len(gr_team.products) == 0
 
-        product_factory(team=team)
-        assert len(team.products) == 0
-        team.prefetch_products(thl_pg_config=thl_web_rr)
-        assert len(team.products) == 1
-        assert isinstance(team.products[0], Product)
+        product_factory(team=gr_team)
+        assert len(gr_team.products) == 0
+        gr_team.prefetch_products(product_manager=product_manager)
+        assert len(gr_team.products) == 1
+        assert isinstance(gr_team.products[0], Product)
 
 
 class TestTeamMethods:
 
-    def test_cache_key(self, team: Team):
-        assert isinstance(team.cache_key, str)
-        assert ":" in team.cache_key
-        assert str(team.uuid) in team.cache_key
+    def test_cache_key(self, gr_team: Team):
+        assert isinstance(gr_team.cache_key, str)
+        assert ":" in gr_team.cache_key
+        assert str(gr_team.uuid) in gr_team.cache_key
 
     def test_set_cache(
         self,
-        team: Team,
+        gr_team: Team,
         gr_db: PostgresConfig,
         thl_web_rr: PostgresConfig,
         gr_redis_config: RedisConfig,
@@ -162,9 +165,9 @@ class TestTeamMethods:
         enriched_session_merge: EnrichedSessionMerge,
     ):
         client = gr_redis_config.create_redis_client()
-        assert client.get(name=team.cache_key) is None
+        assert client.get(name=gr_team.cache_key) is None
 
-        team.set_cache(
+        gr_team.set_cache(
             pg_config=gr_db,
             thl_web_rr=thl_web_rr,
             redis_config=gr_redis_config,
@@ -175,7 +178,7 @@ class TestTeamMethods:
             enriched_session=enriched_session_merge,
         )
 
-        assert client.hgetall(name=team.cache_key) is not None
+        assert client.hgetall(name=gr_team.cache_key) is not None
 
     def test_set_cache_team(
         self,
@@ -183,7 +186,7 @@ class TestTeamMethods:
         gr_db: PostgresConfig,
         thl_web_rr: PostgresConfig,
         product_factory: Callable[..., Product],
-        team: Team,
+        gr_team: Team,
         membership_factory: Callable[..., Membership],
         gr_redis_config: RedisConfig,
         mnt_filepath: GRLDatasets,
@@ -193,10 +196,10 @@ class TestTeamMethods:
     ):
         from generalresearch.models.gr.team import Team
 
-        p1 = product_factory(team=team)
-        membership_factory(team=team, gr_user=gr_user)
+        p1 = product_factory(team=gr_team)
+        membership_factory(team=gr_team, gr_user=gr_user)
 
-        team.set_cache(
+        gr_team.set_cache(
             pg_config=gr_db,
             thl_web_rr=thl_web_rr,
             redis_config=gr_redis_config,
@@ -208,7 +211,7 @@ class TestTeamMethods:
         )
 
         team2 = Team.from_redis(
-            uuid=team.uuid,
+            uuid=gr_team.uuid,
             fields=["id", "memberships", "gr_users", "businesses", "products"],
             gr_redis_config=gr_redis_config,
         )
@@ -216,7 +219,7 @@ class TestTeamMethods:
         assert isinstance(team2, Team)
         assert isinstance(team2.products, list)
         assert isinstance(team2.gr_users, list)
-        assert team.model_dump_json() == team2.model_dump_json()
+        assert gr_team.model_dump_json() == team2.model_dump_json()
         assert p1.uuid in [p.uuid for p in team2.products]
         assert len(team2.gr_users) == 1
         assert gr_user.id in [gru.id for gru in team2.gr_users]
@@ -235,14 +238,14 @@ class TestTeamMethods:
         delete_df_collection: Callable[..., None],
         mnt_filepath: GRLDatasets,
         mnt_gr_api_dir: Path,
-        team: Team,
+        gr_team: Team,
     ):
 
         delete_df_collection(coll=wall_collection)
         delete_df_collection(coll=session_collection)
 
-        p1 = product_factory(team=team)
-        p2 = product_factory(team=team)
+        p1 = product_factory(team=gr_team)
+        p2 = product_factory(team=gr_team)
 
         for p in [p1, p2]:
             u = user_factory(product=p)
@@ -263,7 +266,7 @@ class TestTeamMethods:
             pg_config=thl_web_rr,
         )
 
-        team.prebuild_enriched_session_parquet(
+        gr_team.prebuild_enriched_session_parquet(
             thl_pg_config=thl_web_rr,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -273,7 +276,7 @@ class TestTeamMethods:
 
         # Now try to read from path
         df = pd.read_parquet(
-            os.path.join(mnt_gr_api_dir, "pop_session", f"{team.file_key}.parquet")
+            os.path.join(mnt_gr_api_dir, "pop_session", f"{gr_team.file_key}.parquet")
         )
         assert isinstance(df, pd.DataFrame)
 
@@ -291,14 +294,14 @@ class TestTeamMethods:
         delete_df_collection: Callable[..., None],
         mnt_filepath: GRLDatasets,
         mnt_gr_api_dir: Path,
-        team: Team,
+        gr_team: Team,
     ):
 
         delete_df_collection(coll=wall_collection)
         delete_df_collection(coll=session_collection)
 
-        p1 = product_factory(team=team)
-        p2 = product_factory(team=team)
+        p1 = product_factory(team=gr_team)
+        p2 = product_factory(team=gr_team)
 
         for p in [p1, p2]:
             u = user_factory(product=p)
@@ -319,7 +322,7 @@ class TestTeamMethods:
             pg_config=thl_web_rr,
         )
 
-        team.prebuild_enriched_wall_parquet(
+        gr_team.prebuild_enriched_wall_parquet(
             thl_pg_config=thl_web_rr,
             ds=mnt_filepath,
             client=client_no_amm,
@@ -329,6 +332,6 @@ class TestTeamMethods:
 
         # Now try to read from path
         df = pd.read_parquet(
-            os.path.join(mnt_gr_api_dir, "pop_event", f"{team.file_key}.parquet")
+            os.path.join(mnt_gr_api_dir, "pop_event", f"{gr_team.file_key}.parquet")
         )
         assert isinstance(df, pd.DataFrame)