moving create_dummy to conftest files, fastapi to requirements for Typing, more RuffHEADmaster

6 files changed, 324 insertions, 0 deletions

diff --git a/test_utils/managers/gr/__init__.py b/test_utils/managers/gr/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test_utils/managers/gr/__init__.py
diff --git a/test_utils/managers/gr/conftest.py b/test_utils/managers/gr/conftest.py
new file mode 100644
index 0000000..3e3a4ad
--- /dev/null
+++ b/test_utils/managers/gr/conftest.py
@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from typing import Callable
+from uuid import uuid4
+
+import pytest
+from pydantic import PositiveInt
+from pydantic_extra_types.phone_numbers import PhoneNumber
+
+from generalresearch.managers.gr.authentication import GRUserManager
+from generalresearch.managers.gr.business import (
+    BusinessAddressManager,
+    BusinessBankAccountManager,
+    BusinessManager,
+)
+from generalresearch.managers.gr.team import TeamManager
+from generalresearch.models.custom_types import UUIDStr
+from generalresearch.models.gr.authentication import GRUser
+from generalresearch.models.gr.business import (
+    Business,
+    BusinessAddress,
+    BusinessBankAccount,
+    BusinessType,
+    TransferMethod,
+)
+from generalresearch.models.gr.team import Team
+
+
+@pytest.fixture
+def gr_user_factory(gr_um: GRUserManager) -> Callable[..., GRUser]:
+
+    def _inner(
+        sub: str | None = None,
+        is_superuser: bool = False,
+    ) -> GRUser:
+        sub = sub or f"{uuid4().hex}-{uuid4().hex}"
+
+        return gr_um.create(
+            sub=sub,
+            is_superuser=is_superuser,
+        )
+
+    return _inner
+
+
+@pytest.fixture
+def gr_business_bank_account_factory(
+    gr_bbam: BusinessBankAccountManager,
+) -> Callable[..., BusinessBankAccount]:
+
+    def _inner(
+        business_id: PositiveInt,
+        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],
+        )
+
+    return _inner
+
+
+@pytest.fixture
+def gr_business_address_factory(
+    gr_bam: BusinessAddressManager,
+) -> Callable[..., BusinessAddress]:
+
+    def _inner(
+        business_id: PositiveInt,
+        uuid: UUIDStr | None = None,
+        line_1: str | None = None,
+        line_2: str | None = None,
+        city: str | None = None,
+        state: str | None = None,
+        postal_code: str | None = None,
+        phone_number: PhoneNumber | None = None,
+        country: str | None = None,
+    ):
+        uuid = uuid or uuid4().hex
+        line_1 = line_1 or "abc"
+        line_2 = line_2 or "bczx"
+        city = city or "Downingtown"
+        state = state or "CA"
+        postal_code = postal_code or "94041"
+        phone_number = None
+        country = country or "US"
+
+        return gr_bam.create(
+            business_id=business_id,
+            uuid=uuid,
+            line_1=line_1,
+            line_2=line_2,
+            city=city,
+            state=state,
+            postal_code=postal_code,
+            phone_number=phone_number,
+            country=country,
+        )
+
+    return _inner
+
+
+@pytest.fixture
+def gr_business_factory(
+    gr_bm: BusinessManager,
+) -> Callable[..., Business]:
+
+    def _inner(
+        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
+
+        uuid = uuid or uuid4().hex
+        name = name or "< Unknown >"
+        tax_number = tax_number or str(randint(1, 999_999_999))
+
+        return gr_bm.create(
+            uuid=uuid, name=name, team=team, kind=kind, tax_number=tax_number
+        )
+
+    return _inner
+
+
+@pytest.fixture
+def gr_team(
+    gr_tm: TeamManager,
+) -> Callable[..., Team]:
+
+    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)
+
+    return _inner
diff --git a/test_utils/managers/grliq/__init__.py b/test_utils/managers/grliq/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test_utils/managers/grliq/__init__.py
diff --git a/test_utils/managers/grliq/conftest.py b/test_utils/managers/grliq/conftest.py
new file mode 100644
index 0000000..525d8c8
--- /dev/null
+++ b/test_utils/managers/grliq/conftest.py
@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Callable
+from uuid import uuid4
+
+import pytest
+
+from generalresearch.grliq.managers import DUMMY_GRLIQ_DATA
+from generalresearch.grliq.managers.forensic_data import GrlIqDataManager
+from generalresearch.grliq.models.forensic_data import GrlIqData
+
+
+@pytest.fixture
+def grliq_data_factory(grliq_dm: GrlIqDataManager) -> Callable[..., GrlIqData]:
+
+    def _inner(
+        is_attempt_allowed: bool = True,
+        product_id: str | None = None,
+        product_user_id: str | None = None,
+        uuid: str | None = None,
+        mid: str | None = None,
+        created_at: datetime | None = None,
+    ) -> GrlIqData:
+        """
+        Creates a dummy record in the db with a GrlIqData (data), GrlIqCheckerResults (result_data),
+            and GrlIqForensicCategoryResult (category_results)
+        :param is_attempt_allowed: Whether the attempt is allowed.
+        :param product_id: product_id of user
+        :param product_user_id:  product_user_id of user
+        :param uuid: uuid for the grliq data record
+        :param mid: the thl_session:uuid / mid for the attempt.
+        :return:
+        """
+        import copy
+
+        res: GrlIqData = copy.deepcopy(DUMMY_GRLIQ_DATA[int(is_attempt_allowed)])
+
+        product_id = product_id or uuid4().hex
+        product_user_id = product_user_id or uuid4().hex
+        uuid = uuid or uuid4().hex
+        mid = mid or uuid4().hex
+        created_at = created_at or datetime.now(tz=timezone.utc)
+
+        res["data"].product_id = product_id
+        res["data"].product_user_id = product_user_id
+        res["data"].uuid = uuid
+        res["data"].mid = mid
+        res["data"].created_at = created_at
+        res["result_data"].uuid = uuid
+        res["category_result"].uuid = uuid
+
+        return grliq_dm.create(
+            iq_data=res["data"],
+            result_data=res["result_data"],
+            category_result=res["category_result"],
+            fraud_score=res["category_result"].fraud_score,
+            is_attempt_allowed=res["category_result"].is_attempt_allowed(),
+        )
+
+    return _inner
diff --git a/test_utils/managers/thl/__init__.py b/test_utils/managers/thl/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test_utils/managers/thl/__init__.py
diff --git a/test_utils/managers/thl/conftest.py b/test_utils/managers/thl/conftest.py
new file mode 100644
index 0000000..76e4226
--- /dev/null
+++ b/test_utils/managers/thl/conftest.py
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from random import randint
+from typing import Callable
+
+import faker
+from pydantic import PositiveInt
+
+from generalresearch.managers.thl.ipinfo import IPGeonameManager, IPInformationManager
+from generalresearch.models.custom_types import IPvAnyAddressStr
+from generalresearch.models.thl.ipinfo import IPGeoname, IPInformation, UserType
+
+fake = faker.Faker()
+
+
+def ipgeoname_factory(ipgeoname_manager: IPGeonameManager) -> Callable[..., IPGeoname]:
+
+    def _inner(
+        geoname_id: PositiveInt | None = None,
+        continent_code: str | None = None,
+        continent_name: str | None = None,
+        country_iso: str | None = None,
+        country_name: str | None = None,
+        subdivision_1_iso: str | None = None,
+        subdivision_1_name: str | None = None,
+        subdivision_2_iso: str | None = None,
+        subdivision_2_name: str | None = None,
+        city_name: str | None = None,
+        metro_code: int | None = None,
+        time_zone: str | None = None,
+        is_in_european_union: bool | None = None,
+    ) -> IPGeoname:
+
+        return ipgeoname_manager.create(
+            geoname_id=geoname_id or randint(1, 999_999_999),
+            continent_code=continent_code or "na",
+            continent_name=continent_name or "North America",
+            country_iso=country_iso or "us",
+            country_name=country_name or "United States",
+            subdivision_1_iso=subdivision_1_iso or "fl",
+            subdivision_1_name=subdivision_1_name or "Florida",
+            subdivision_2_iso=subdivision_2_iso,
+            subdivision_2_name=subdivision_2_name,
+            city_name=city_name,
+            metro_code=metro_code,
+            time_zone=time_zone,
+            is_in_european_union=is_in_european_union,
+        )
+
+    return _inner
+
+
+def ipinformation_factory(
+    ipinformation_manager: IPInformationManager,
+) -> Callable[..., IPInformation]:
+
+    def _inner(
+        ip: IPvAnyAddressStr | None = None,
+        geoname_id: PositiveInt | None = None,
+        country_iso: str | None = None,
+        registered_country_iso: str | None = None,
+        is_anonymous: bool | None = None,
+        is_anonymous_vpn: bool | None = None,
+        is_hosting_provider: bool | None = None,
+        is_public_proxy: bool | None = None,
+        is_tor_exit_node: bool | None = None,
+        is_residential_proxy: bool | None = None,
+        autonomous_system_number: PositiveInt | None = None,
+        autonomous_system_organization: str | None = None,
+        domain: str | None = None,
+        isp: str | None = None,
+        mobile_country_code: str | None = None,
+        mobile_network_code: str | None = None,
+        network: str | None = None,
+        organization: str | None = None,
+        static_ip_score: float | None = None,
+        user_type: UserType | None = None,
+        postal_code: str | None = None,
+        latitude: Decimal | None = None,
+        longitude: Decimal | None = None,
+        accuracy_radius: int | None = None,
+    ) -> IPInformation:
+
+        return ipinformation_manager.create(
+            ip=ip or fake.ipv4_public(),
+            geoname_id=geoname_id,
+            country_iso=country_iso or fake.country_code(),
+            registered_country_iso=registered_country_iso,
+            is_anonymous=is_anonymous,
+            is_anonymous_vpn=is_anonymous_vpn,
+            is_hosting_provider=is_hosting_provider,
+            is_public_proxy=is_public_proxy,
+            is_tor_exit_node=is_tor_exit_node,
+            is_residential_proxy=is_residential_proxy,
+            autonomous_system_number=autonomous_system_number,
+            autonomous_system_organization=autonomous_system_organization,
+            domain=domain,
+            isp=isp,
+            mobile_country_code=mobile_country_code,
+            mobile_network_code=mobile_network_code,
+            network=network,
+            organization=organization,
+            static_ip_score=static_ip_score,
+            user_type=user_type,
+            postal_code=postal_code,
+            latitude=latitude,
+            longitude=longitude,
+            accuracy_radius=accuracy_radius,
+        )
+
+    return _inner