4 files changed, 400 insertions, 0 deletions
diff --git a/tests/managers/gr/__init__.py b/tests/managers/gr/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/managers/gr/__init__.py
diff --git a/tests/managers/gr/test_authentication.py b/tests/managers/gr/test_authentication.py
new file mode 100644
index 0000000..53b6931
--- /dev/null
+++ b/tests/managers/gr/test_authentication.py
@@ -0,0 +1,125 @@
+import logging
+from random import randint
+from uuid import uuid4
+
+import pytest
+
+from generalresearch.models.gr.authentication import GRUser
+from test_utils.models.conftest import gr_user
+
+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
+
+        instance2 = gr_um.get_by_id(user.id)
+        assert user.model_dump_json() == instance2.model_dump_json()
+
+    def test_get_by_id(self, gr_user, gr_um):
+        with pytest.raises(expected_exception=ValueError) as cm:
+            gr_um.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)
+        assert instance.sub == gr_user.sub
+
+    def test_get_by_sub(self, gr_user, gr_um):
+        with pytest.raises(expected_exception=ValueError) as cm:
+            gr_um.get_by_sub(sub=uuid4().hex)
+        assert "GRUser not found" in str(cm.value)
+
+        instance = gr_um.get_by_sub(sub=gr_user.sub)
+        assert instance.id == gr_user.id
+
+    def test_get_by_sub_or_create(self, gr_user, gr_um):
+        sub = f"{uuid4().hex}-{uuid4().hex}"
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            gr_um.get_by_sub(sub=sub)
+        assert "GRUser not found" in str(cm.value)
+
+        instance = gr_um.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()
+        assert isinstance(res1, list)
+
+        gr_um.create_dummy()
+        res2 = gr_um.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)
+        assert isinstance(res, list)
+        assert res == []
+
+    def test_list_product_uuids(self, caplog, gr_user, gr_um, thl_web_rr):
+        with caplog.at_level(logging.WARNING):
+            gr_um.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
+
+        token = gr_tm.get_by_user_id(user_id=gr_user.id)
+        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
+
+        token = gr_tm.get_by_user_id(user_id=gr_user.id)
+        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
+
+        gr_tm.create(user_id=gr_user.id)
+
+        token: GRToken = gr_tm.get_by_user_id(user_id=gr_user.id)
+        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)
+
+        instance = gr_tm.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)
+        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
+
+        api_key = "..."
+        jwks = {
+            # ...
+        }
+
+        instance = gr_tm.get_by_key(
+            api_key=api_key,
+            jwks=jwks,
+            audience="...",
+            issuer=SSO_ISSUER,
+            gr_redis_config=gr_redis_config,
+        )
+
+        assert isinstance(instance, GRToken)
diff --git a/tests/managers/gr/test_business.py b/tests/managers/gr/test_business.py
new file mode 100644
index 0000000..7eb77f8
--- /dev/null
+++ b/tests/managers/gr/test_business.py
@@ -0,0 +1,150 @@
+from uuid import uuid4
+
+import pytest
+
+from test_utils.models.conftest import business
+
+
+class TestBusinessBankAccountManager:
+
+    def test_init(self, business_bank_account_manager, gr_db):
+        assert 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,
+        )
+
+        instance = business_bank_account_manager.create(
+            business_id=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(
+            business_id=instance.business_id
+        )
+        assert isinstance(res, list)
+        assert len(res) == 1
+        assert isinstance(res[0], BusinessBankAccount)
+        assert res[0].business_id == instance.business_id
+
+
+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)
+        assert isinstance(res, BusinessAddress)
+        assert isinstance(res.id, int)
+
+
+class TestBusinessManager:
+
+    def test_create(self, business_manager):
+        from generalresearch.models.gr.business import Business
+
+        instance = business_manager.create_dummy()
+        assert isinstance(instance, Business)
+        assert isinstance(instance.id, int)
+
+    def test_get_or_create(self, business_manager):
+        uuid_key = uuid4().hex
+
+        assert business_manager.get_by_uuid(business_uuid=uuid_key) is None
+
+        instance = business_manager.get_or_create(
+            uuid=uuid_key,
+            name=f"name-{uuid4().hex[:6]}",
+        )
+
+        res = business_manager.get_by_uuid(business_uuid=uuid_key)
+        assert res.id == instance.id
+
+    def test_get_all(self, business_manager):
+        res1 = business_manager.get_all()
+        assert isinstance(res1, list)
+
+        business_manager.create_dummy()
+        res2 = business_manager.get_all()
+        assert len(res1) == len(res2) - 1
+
+    @pytest.mark.skip(reason="TODO")
+    def test_get_by_team(self):
+        pass
+
+    def test_get_by_user_id(
+        self, business_manager, gr_user, team_manager, membership_manager
+    ):
+        res = 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)
+        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)
+        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)
+        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)
+        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)
+        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_id(self, business, business_manager):
+        instance = business_manager.get_by_id(business_id=business.id)
+        assert business.uuid == instance.uuid
+
+    def test_cache_key(self, business):
+        assert "business:" in business.cache_key
+
+    # def test_create_raise_on_duplicate(self):
+    #     b_uuid = uuid4().hex
+    #
+    #     # Make the first one
+    #     business = BusinessManager.create(
+    #         uuid=b_uuid,
+    #         name=f"test-{b_uuid[:6]}")
+    #     assert isinstance(business, Business)
+    #
+    #     # Try to make it again
+    #     with pytest.raises(expected_exception=psycopg.errors.UniqueViolation):
+    #         business = BusinessManager.create(
+    #             uuid=b_uuid,
+    #             name=f"test-{b_uuid[:6]}")
+    #
+    # def test_get_by_team(self, team):
+    #     for idx in range(5):
+    #         BusinessManager.create(name=f"Business Name #{uuid4().hex[:6]}", team=team)
+    #
+    #     res = BusinessManager.get_by_team(team_id=team.id)
+    #     assert isinstance(res, list)
+    #     assert 5 == len(res)
diff --git a/tests/managers/gr/test_team.py b/tests/managers/gr/test_team.py
new file mode 100644
index 0000000..9215da4
--- /dev/null
+++ b/tests/managers/gr/test_team.py
@@ -0,0 +1,125 @@
+from uuid import uuid4
+
+from test_utils.models.conftest import team
+
+
+class TestMembershipManager:
+
+    def test_init(self, membership_manager, gr_db):
+        assert 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_get_or_create(self, team_manager):
+        from generalresearch.models.gr.team import Team
+
+        new_uuid = uuid4().hex
+
+        team: Team = 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()
+        assert isinstance(res1, list)
+
+        team_manager.create_dummy()
+        res2 = team_manager.get_all()
+        assert len(res1) == len(res2) - 1
+
+    def test_create(self, team_manager):
+        from generalresearch.models.gr.team import Team
+
+        team: Team = team_manager.create_dummy()
+        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
+
+        user: GRUser = gr_um.create_dummy()
+
+        instance = team_manager.add_user(team=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]
+
+    def test_get_by_uuid(self, team_manager):
+        from generalresearch.models.gr.team import Team
+
+        team: Team = team_manager.create_dummy()
+
+        instance = team_manager.get_by_uuid(team_uuid=team.uuid)
+        assert team.id == instance.id
+
+    def test_get_by_id(self, team_manager):
+        from generalresearch.models.gr.team import Team
+
+        team: Team = team_manager.create_dummy()
+
+        instance = team_manager.get_by_id(team_id=team.id)
+        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)
+
+        res = 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
+
+    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,
+    ):
+        product_factory(team=team)
+        membership_factory(team=team, gr_user=gr_user)
+
+        gr_user.prefetch_teams(
+            pg_config=gr_db,
+            redis_config=gr_redis_config,
+        )
+
+        assert len(gr_user.teams) == 1
+
+    # def test_create_raise_on_duplicate(self):
+    #     t_uuid = uuid4().hex
+    #
+    #     # Make the first one
+    #     team = TeamManager.create(
+    #         uuid=t_uuid,
+    #         name=f"test-{t_uuid[:6]}")
+    #     assert isinstance(team, Team)
+    #
+    #     # Try to make it again
+    #     with pytest.raises(expected_exception=psycopg.errors.UniqueViolation):
+    #         TeamManager.create(
+    #             uuid=t_uuid,
+    #             name=f"test-{t_uuid[:6]}")
+    #