Initial commitv3.3.4

61 files changed, 11837 insertions, 0 deletions

diff --git a/tests/models/__init__.py b/tests/models/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/__init__.py
diff --git a/tests/models/admin/__init__.py b/tests/models/admin/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/admin/__init__.py
diff --git a/tests/models/admin/test_report_request.py b/tests/models/admin/test_report_request.py
new file mode 100644
index 0000000..cf4c405
--- /dev/null
+++ b/tests/models/admin/test_report_request.py
@@ -0,0 +1,163 @@
+from datetime import timezone, datetime
+
+import pandas as pd
+import pytest
+from pydantic import ValidationError
+
+
+class TestReportRequest:
+    def test_base(self, utc_60days_ago):
+        from generalresearch.models.admin.request import (
+            ReportRequest,
+            ReportType,
+        )
+
+        rr = ReportRequest()
+
+        assert isinstance(rr.start, datetime), "rr.start incorrect type"
+        assert isinstance(rr.start_floor, datetime), "rr.start_floor incorrect type"
+
+        assert rr.report_type == ReportType.POP_SESSION
+        assert rr.start != rr.start_floor, "rr.start != rr.start_floor"
+        assert rr.start_floor.tzinfo == timezone.utc, "rr.start_floor.tzinfo not utc"
+
+        rr1 = ReportRequest.model_validate(
+            {
+                "start": datetime(
+                    year=datetime.now().year,
+                    month=1,
+                    day=1,
+                    hour=0,
+                    minute=30,
+                    second=25,
+                    microsecond=35,
+                    tzinfo=timezone.utc,
+                ),
+                "interval": "1h",
+            }
+        )
+
+        assert isinstance(rr1.start, datetime), "rr1.start incorrect type"
+        assert isinstance(rr1.start_floor, datetime), "rr1.start_floor incorrect type"
+
+        rr2 = ReportRequest.model_validate(
+            {
+                "start": datetime(
+                    year=datetime.now().year,
+                    month=1,
+                    day=1,
+                    hour=6,
+                    minute=30,
+                    second=25,
+                    microsecond=35,
+                    tzinfo=timezone.utc,
+                ),
+                "interval": "1d",
+            }
+        )
+
+        assert isinstance(rr2.start, datetime), "rr2.start incorrect type"
+        assert isinstance(rr2.start_floor, datetime), "rr2.start_floor incorrect type"
+
+        assert rr1.start != rr2.start, "rr1.start != rr2.start"
+        assert rr1.start_floor == rr2.start_floor, "rr1.start_floor == rr2.start_floor"
+
+        # datetime.datetime(2025, 7, 9, 0, 0, tzinfo=datetime.timezone.utc)
+        # datetime.datetime(2025, 7, 9, 0, 0, tzinfo=datetime.timezone.utc)
+
+        #  datetime.datetime(2025, 7, 9, 0, 0, tzinfo=datetime.timezone.utc) =
+        #  ReportRequest(report_type=<ReportType.POP_SESSION: 'pop_session'>,
+        #  index0='started', index1='product_id',
+        #  start=datetime.datetime(2025, 7, 9, 0, 46, 23, 145756, tzinfo=datetime.timezone.utc),
+        #  end=datetime.datetime(2025, 9, 7, 0, 46, 23, 149195, tzinfo=datetime.timezone.utc),
+        #  interval='1h', include_open_bucket=True,
+        #  start_floor=datetime.datetime(2025, 7, 9, 0, 0, tzinfo=datetime.timezone.utc)).start_floor
+
+        #  datetime.datetime(2025, 7, 9, 0, 0, tzinfo=datetime.timezone.utc) =
+        #  ReportRequest(report_type=<ReportType.POP_SESSION: 'pop_session'>,
+        #  index0='started', index1='product_id',
+        #  start=datetime.datetime(2025, 7, 9, 0, 46, 23, 145756, tzinfo=datetime.timezone.utc),
+        #  end=datetime.datetime(2025, 9, 7, 0, 46, 23, 149267, tzinfo=datetime.timezone.utc),
+        #  interval='1d', include_open_bucket=True,
+        #  start_floor=datetime.datetime(2025, 7, 9, 0, 0, tzinfo=datetime.timezone.utc)).start_floor
+
+    def test_start_end_range(self, utc_90days_ago, utc_30days_ago):
+        from generalresearch.models.admin.request import ReportRequest
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            ReportRequest.model_validate(
+                {"start": utc_30days_ago, "end": utc_90days_ago}
+            )
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            ReportRequest.model_validate(
+                {
+                    "start": datetime(year=1990, month=1, day=1),
+                    "end": datetime(year=1950, month=1, day=1),
+                }
+            )
+
+    def test_start_end_range_tz(self):
+        from generalresearch.models.admin.request import ReportRequest
+        from zoneinfo import ZoneInfo
+
+        pacific_tz = ZoneInfo("America/Los_Angeles")
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            ReportRequest.model_validate(
+                {
+                    "start": datetime(year=2000, month=1, day=1, tzinfo=pacific_tz),
+                    "end": datetime(year=2000, month=6, day=1, tzinfo=pacific_tz),
+                }
+            )
+
+    def test_start_floor_naive(self):
+        from generalresearch.models.admin.request import ReportRequest
+
+        rr = ReportRequest()
+
+        assert rr.start_floor_naive.tzinfo is None
+
+    def test_end_naive(self):
+        from generalresearch.models.admin.request import ReportRequest
+
+        rr = ReportRequest()
+
+        assert rr.end_naive.tzinfo is None
+
+    def test_pd_interval(self):
+        from generalresearch.models.admin.request import ReportRequest
+
+        rr = ReportRequest()
+
+        assert isinstance(rr.pd_interval, pd.Interval)
+
+    def test_interval_timedelta(self):
+        from generalresearch.models.admin.request import ReportRequest
+
+        rr = ReportRequest()
+
+        assert isinstance(rr.interval_timedelta, pd.Timedelta)
+
+    def test_buckets(self):
+        from generalresearch.models.admin.request import ReportRequest
+
+        rr = ReportRequest()
+
+        assert isinstance(rr.buckets(), pd.DatetimeIndex)
+
+    def test_bucket_ranges(self):
+        from generalresearch.models.admin.request import ReportRequest
+
+        rr = ReportRequest()
+        assert isinstance(rr.bucket_ranges(), list)
+
+        rr = ReportRequest.model_validate(
+            {
+                "interval": "1d",
+                "start": datetime(year=2000, month=1, day=1, tzinfo=timezone.utc),
+                "end": datetime(year=2000, month=1, day=10, tzinfo=timezone.utc),
+            }
+        )
+
+        assert len(rr.bucket_ranges()) == 10
diff --git a/tests/models/custom_types/__init__.py b/tests/models/custom_types/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/custom_types/__init__.py
diff --git a/tests/models/custom_types/test_aware_datetime.py b/tests/models/custom_types/test_aware_datetime.py
new file mode 100644
index 0000000..a23413c
--- /dev/null
+++ b/tests/models/custom_types/test_aware_datetime.py
@@ -0,0 +1,82 @@
+import logging
+from datetime import datetime, timezone
+from typing import Optional
+
+import pytest
+import pytz
+from pydantic import BaseModel, ValidationError, Field
+
+from generalresearch.models.custom_types import AwareDatetimeISO
+
+logger = logging.getLogger()
+
+
+class AwareDatetimeISOModel(BaseModel):
+    dt_optional: Optional[AwareDatetimeISO] = Field(default=None)
+    dt: AwareDatetimeISO
+
+
+class TestAwareDatetimeISO:
+    def test_str(self):
+        dt = "2023-10-10T01:01:01.0Z"
+        t = AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+        AwareDatetimeISOModel.model_validate_json(t.model_dump_json())
+
+        t = AwareDatetimeISOModel(dt=dt, dt_optional=None)
+        AwareDatetimeISOModel.model_validate_json(t.model_dump_json())
+
+    def test_dt(self):
+        dt = datetime(2023, 10, 10, 1, 1, 1, tzinfo=timezone.utc)
+        t = AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+        AwareDatetimeISOModel.model_validate_json(t.model_dump_json())
+
+        t = AwareDatetimeISOModel(dt=dt, dt_optional=None)
+        AwareDatetimeISOModel.model_validate_json(t.model_dump_json())
+
+        dt = datetime(2023, 10, 10, 1, 1, 1, microsecond=123, tzinfo=timezone.utc)
+        t = AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+        AwareDatetimeISOModel.model_validate_json(t.model_dump_json())
+
+        t = AwareDatetimeISOModel(dt=dt, dt_optional=None)
+        AwareDatetimeISOModel.model_validate_json(t.model_dump_json())
+
+    def test_no_tz(self):
+        dt = datetime(2023, 10, 10, 1, 1, 1)
+
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=dt, dt_optional=None)
+
+        dt = "2023-10-10T01:01:01.0"
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=dt, dt_optional=None)
+
+    def test_non_utc_tz(self):
+        dt = datetime(
+            year=2023,
+            month=10,
+            day=10,
+            hour=1,
+            second=1,
+            minute=1,
+            tzinfo=pytz.timezone("US/Central"),
+        )
+
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+
+    def test_invalid_format(self):
+        dt = "2023-10-10T01:01:01Z"
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+
+        dt = "2023-10-10T01:01:01"
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+        dt = "2023-10-10"
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=dt, dt_optional=dt)
+
+    def test_required(self):
+        dt = "2023-10-10T01:01:01.0Z"
+        with pytest.raises(expected_exception=ValidationError):
+            AwareDatetimeISOModel(dt=None, dt_optional=dt)
diff --git a/tests/models/custom_types/test_dsn.py b/tests/models/custom_types/test_dsn.py
new file mode 100644
index 0000000..b37f2c4
--- /dev/null
+++ b/tests/models/custom_types/test_dsn.py
@@ -0,0 +1,112 @@
+from typing import Optional
+from uuid import uuid4
+
+import pytest
+from pydantic import BaseModel, ValidationError, Field
+from pydantic import MySQLDsn
+from pydantic_core import Url
+
+from generalresearch.models.custom_types import DaskDsn, SentryDsn
+
+
+# --- Test Pydantic Models ---
+
+
+class SettingsModel(BaseModel):
+    dask: Optional["DaskDsn"] = Field(default=None)
+    sentry: Optional["SentryDsn"] = Field(default=None)
+    db: Optional["MySQLDsn"] = Field(default=None)
+
+
+# --- Pytest themselves ---
+
+
+class TestDaskDsn:
+
+    def test_base(self):
+        from dask.distributed import Client
+
+        m = SettingsModel(dask="tcp://dask-scheduler.internal")
+
+        assert m.dask.scheme == "tcp"
+        assert m.dask.host == "dask-scheduler.internal"
+        assert m.dask.port == 8786
+
+        with pytest.raises(expected_exception=TypeError) as cm:
+            Client(m.dask)
+        assert "Scheduler address must be a string or a Cluster instance" in str(
+            cm.value
+        )
+
+        # todo: this requires vpn connection. maybe do this part with a localhost dsn
+        # client = Client(str(m.dask))
+        # self.assertIsInstance(client, Client)
+
+    def test_str(self):
+        m = SettingsModel(dask="tcp://dask-scheduler.internal")
+        assert isinstance(m.dask, Url)
+        assert "tcp://dask-scheduler.internal:8786" == str(m.dask)
+
+    def test_auth(self):
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(dask="tcp://test:password@dask-scheduler.internal")
+        assert "User & Password are not supported" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(dask="tcp://test:@dask-scheduler.internal")
+        assert "User & Password are not supported" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(dask="tcp://:password@dask-scheduler.internal")
+        assert "User & Password are not supported" in str(cm.value)
+
+    def test_invalid_schema(self):
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(dask="dask-scheduler.internal")
+        assert "relative URL without a base" in str(cm.value)
+
+        # I look forward to the day we use infiniband interfaces
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(dask="ucx://dask-scheduler.internal")
+        assert "URL scheme should be 'tcp'" in str(cm.value)
+
+    def test_port(self):
+        m = SettingsModel(dask="tcp://dask-scheduler.internal")
+        assert m.dask.port == 8786
+
+
+class TestSentryDsn:
+    def test_base(self):
+        m = SettingsModel(
+            sentry=f"https://{uuid4().hex}@12345.ingest.us.sentry.io/9876543"
+        )
+
+        assert m.sentry.scheme == "https"
+        assert m.sentry.host == "12345.ingest.us.sentry.io"
+        assert m.sentry.port == 443
+
+    def test_str(self):
+        test_url: str = f"https://{uuid4().hex}@12345.ingest.us.sentry.io/9876543"
+        m = SettingsModel(sentry=test_url)
+        assert isinstance(m.sentry, Url)
+        assert test_url == str(m.sentry)
+
+    def test_auth(self):
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(
+                sentry="https://0123456789abc:password@12345.ingest.us.sentry.io/9876543"
+            )
+        assert "Sentry password is not supported" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(sentry="https://test:@12345.ingest.us.sentry.io/9876543")
+        assert "Sentry user key seems bad" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            SettingsModel(sentry="https://:password@12345.ingest.us.sentry.io/9876543")
+        assert "Sentry URL requires a user key" in str(cm.value)
+
+    def test_port(self):
+        test_url: str = f"https://{uuid4().hex}@12345.ingest.us.sentry.io/9876543"
+        m = SettingsModel(sentry=test_url)
+        assert m.sentry.port == 443
diff --git a/tests/models/custom_types/test_therest.py b/tests/models/custom_types/test_therest.py
new file mode 100644
index 0000000..13e9bae
--- /dev/null
+++ b/tests/models/custom_types/test_therest.py
@@ -0,0 +1,42 @@
+import json
+from uuid import UUID
+
+import pytest
+from pydantic import TypeAdapter, ValidationError
+
+
+class TestAll:
+
+    def test_comma_sep_str(self):
+        from generalresearch.models.custom_types import AlphaNumStrSet
+
+        t = TypeAdapter(AlphaNumStrSet)
+        assert {"a", "b", "c"} == t.validate_python(["a", "b", "c"])
+        assert '"a,b,c"' == t.dump_json({"c", "b", "a"}).decode()
+        assert '""' == t.dump_json(set()).decode()
+        assert {"a", "b", "c"} == t.validate_json('"c,b,a"')
+        assert set() == t.validate_json('""')
+
+        with pytest.raises(ValidationError):
+            t.validate_python({"", "b", "a"})
+
+        with pytest.raises(ValidationError):
+            t.validate_python({""})
+
+        with pytest.raises(ValidationError):
+            t.validate_json('",b,a"')
+
+    def test_UUIDStrCoerce(self):
+        from generalresearch.models.custom_types import UUIDStrCoerce
+
+        t = TypeAdapter(UUIDStrCoerce)
+        uuid_str = "18e70590176e49c693b07682f3c112be"
+        assert uuid_str == t.validate_python("18e70590-176e-49c6-93b0-7682f3c112be")
+        assert uuid_str == t.validate_python(
+            UUID("18e70590-176e-49c6-93b0-7682f3c112be")
+        )
+        assert (
+            json.dumps(uuid_str)
+            == t.dump_json("18e70590176e49c693b07682f3c112be").decode()
+        )
+        assert uuid_str == t.validate_json('"18e70590-176e-49c6-93b0-7682f3c112be"')
diff --git a/tests/models/custom_types/test_uuid_str.py b/tests/models/custom_types/test_uuid_str.py
new file mode 100644
index 0000000..91af9ae
--- /dev/null
+++ b/tests/models/custom_types/test_uuid_str.py
@@ -0,0 +1,51 @@
+from typing import Optional
+from uuid import uuid4
+
+import pytest
+from pydantic import BaseModel, ValidationError, Field
+
+from generalresearch.models.custom_types import UUIDStr
+
+
+class UUIDStrModel(BaseModel):
+    uuid_optional: Optional[UUIDStr] = Field(default_factory=lambda: uuid4().hex)
+    uuid: UUIDStr
+
+
+class TestUUIDStr:
+    def test_str(self):
+        v = "58889cd67f9f4c699b25437112dce638"
+
+        t = UUIDStrModel(uuid=v, uuid_optional=v)
+        UUIDStrModel.model_validate_json(t.model_dump_json())
+
+        t = UUIDStrModel(uuid=v, uuid_optional=None)
+        t2 = UUIDStrModel.model_validate_json(t.model_dump_json())
+
+        assert t2.uuid_optional is None
+        assert t2.uuid == v
+
+    def test_uuid(self):
+        v = uuid4()
+
+        with pytest.raises(ValidationError) as cm:
+            UUIDStrModel(uuid=v, uuid_optional=None)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(ValidationError) as cm:
+            UUIDStrModel(uuid="58889cd67f9f4c699b25437112dce638", uuid_optional=v)
+        assert "Input should be a valid string" in str(cm.value)
+
+    def test_invalid_format(self):
+        v = "x"
+        with pytest.raises(ValidationError):
+            UUIDStrModel(uuid=v, uuid_optional=None)
+
+        with pytest.raises(ValidationError):
+            UUIDStrModel(uuid="58889cd67f9f4c699b25437112dce638", uuid_optional=v)
+
+    def test_required(self):
+        v = "58889cd67f9f4c699b25437112dce638"
+
+        with pytest.raises(ValidationError):
+            UUIDStrModel(uuid=None, uuid_optional=v)
diff --git a/tests/models/dynata/__init__.py b/tests/models/dynata/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/dynata/__init__.py
diff --git a/tests/models/dynata/test_eligbility.py b/tests/models/dynata/test_eligbility.py
new file mode 100644
index 0000000..23437f5
--- /dev/null
+++ b/tests/models/dynata/test_eligbility.py
@@ -0,0 +1,324 @@
+from datetime import datetime, timezone
+
+
+class TestEligibility:
+
+    def test_evaluate_task_criteria(self):
+        from generalresearch.models.dynata.survey import (
+            DynataQuotaGroup,
+            DynataFilterGroup,
+            DynataSurvey,
+            DynataRequirements,
+        )
+
+        filters = [[["a", "b"], ["c", "d"]], [["e"], ["f"]]]
+        filters = [DynataFilterGroup.model_validate(f) for f in filters]
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": True,
+            "d": False,
+            "e": True,
+            "f": True,
+        }
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [{"count": 100, "condition_hashes": [], "status": "OPEN"}]
+            )
+        ]
+        task = DynataSurvey.model_validate(
+            {
+                "survey_id": "1",
+                "filters": filters,
+                "quotas": quotas,
+                "allowed_devices": set("1"),
+                "calculation_type": "COMPLETES",
+                "client_id": "",
+                "country_iso": "us",
+                "language_iso": "eng",
+                "group_id": "g1",
+                "project_id": "p1",
+                "status": "OPEN",
+                "project_exclusions": set(),
+                "created": datetime.now(tz=timezone.utc),
+                "category_exclusions": set(),
+                "category_ids": set(),
+                "cpi": 1,
+                "days_in_field": 0,
+                "expected_count": 0,
+                "order_number": "",
+                "live_link": "",
+                "bid_ir": 0.5,
+                "bid_loi": 500,
+                "requirements": DynataRequirements(),
+            }
+        )
+        assert task.determine_eligibility(criteria_evaluation)
+
+        # task status
+        task.status = "CLOSED"
+        assert not task.determine_eligibility(criteria_evaluation)
+        task.status = "OPEN"
+
+        # one quota with no space left (count = 0)
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [{"count": 0, "condition_hashes": [], "status": "OPEN"}]
+            )
+        ]
+        task.quotas = quotas
+        assert not task.determine_eligibility(criteria_evaluation)
+
+        # we pass 'a' and 'b'
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [{"count": 100, "condition_hashes": ["a", "b"], "status": "OPEN"}]
+            )
+        ]
+        task.quotas = quotas
+        assert task.determine_eligibility(criteria_evaluation)
+
+        # make 'f' false, we still pass the 2nd filtergroup b/c 'e' is True
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": True,
+            "d": False,
+            "e": True,
+            "f": False,
+        }
+        assert task.determine_eligibility(criteria_evaluation)
+
+        # make 'e' false, we don't pass the 2nd filtergroup
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": True,
+            "d": False,
+            "e": False,
+            "f": False,
+        }
+        assert not task.determine_eligibility(criteria_evaluation)
+
+        # We fail quota 'c','d', but we pass 'a','b', so we pass the first quota group
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": True,
+            "d": False,
+            "e": True,
+            "f": True,
+        }
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [
+                    {"count": 100, "condition_hashes": ["a", "b"], "status": "OPEN"},
+                    {"count": 100, "condition_hashes": ["c", "d"], "status": "CLOSED"},
+                ]
+            )
+        ]
+        task.quotas = quotas
+        assert task.determine_eligibility(criteria_evaluation)
+
+        # we pass the first qg, but then fall into a full 2nd qg
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [
+                    {"count": 100, "condition_hashes": ["a", "b"], "status": "OPEN"},
+                    {"count": 100, "condition_hashes": ["c", "d"], "status": "CLOSED"},
+                ]
+            ),
+            DynataQuotaGroup.model_validate(
+                [{"count": 100, "condition_hashes": ["f"], "status": "CLOSED"}]
+            ),
+        ]
+        task.quotas = quotas
+        assert not task.determine_eligibility(criteria_evaluation)
+
+    def test_soft_pair(self):
+        from generalresearch.models.dynata.survey import (
+            DynataQuotaGroup,
+            DynataFilterGroup,
+            DynataSurvey,
+            DynataRequirements,
+        )
+
+        filters = [[["a", "b"], ["c", "d"]], [["e"], ["f"]]]
+        filters = [DynataFilterGroup.model_validate(f) for f in filters]
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": True,
+            "d": False,
+            "e": True,
+            "f": True,
+        }
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [{"count": 100, "condition_hashes": [], "status": "OPEN"}]
+            )
+        ]
+        task = DynataSurvey.model_validate(
+            {
+                "survey_id": "1",
+                "filters": filters,
+                "quotas": quotas,
+                "allowed_devices": set("1"),
+                "calculation_type": "COMPLETES",
+                "client_id": "",
+                "country_iso": "us",
+                "language_iso": "eng",
+                "group_id": "g1",
+                "project_id": "p1",
+                "status": "OPEN",
+                "project_exclusions": set(),
+                "created": datetime.now(tz=timezone.utc),
+                "category_exclusions": set(),
+                "category_ids": set(),
+                "cpi": 1,
+                "days_in_field": 0,
+                "expected_count": 0,
+                "order_number": "",
+                "live_link": "",
+                "bid_ir": 0.5,
+                "bid_loi": 500,
+                "requirements": DynataRequirements(),
+            }
+        )
+        assert task.passes_filters(criteria_evaluation)
+        passes, condition_hashes = task.passes_filters_soft(criteria_evaluation)
+        assert passes
+
+        # make 'e' & 'f' None, we don't pass the 2nd filtergroup
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": True,
+            "d": False,
+            "e": None,
+            "f": None,
+        }
+        assert not task.passes_filters(criteria_evaluation)
+        passes, conditional_hashes = task.passes_filters_soft(criteria_evaluation)
+        assert passes is None
+        assert {"e", "f"} == conditional_hashes
+
+        # 1st filtergroup unknown
+        criteria_evaluation = {
+            "a": True,
+            "b": None,
+            "c": None,
+            "d": None,
+            "e": None,
+            "f": None,
+        }
+        assert not task.passes_filters(criteria_evaluation)
+        passes, conditional_hashes = task.passes_filters_soft(criteria_evaluation)
+        assert passes is None
+        assert {"b", "c", "d", "e", "f"} == conditional_hashes
+
+        # 1st filtergroup unknown, 2nd cell False
+        criteria_evaluation = {
+            "a": True,
+            "b": None,
+            "c": None,
+            "d": False,
+            "e": None,
+            "f": None,
+        }
+        assert not task.passes_filters(criteria_evaluation)
+        passes, conditional_hashes = task.passes_filters_soft(criteria_evaluation)
+        assert passes is None
+        assert {"b", "e", "f"} == conditional_hashes
+
+        # we pass the first qg, unknown 2nd
+        criteria_evaluation = {
+            "a": True,
+            "b": True,
+            "c": None,
+            "d": False,
+            "e": None,
+            "f": None,
+        }
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [
+                    {"count": 100, "condition_hashes": ["a", "b"], "status": "OPEN"},
+                    {"count": 100, "condition_hashes": ["c", "d"], "status": "CLOSED"},
+                ]
+            ),
+            DynataQuotaGroup.model_validate(
+                [{"count": 100, "condition_hashes": ["f"], "status": "OPEN"}]
+            ),
+        ]
+        task.quotas = quotas
+        passes, conditional_hashes = task.passes_quotas_soft(criteria_evaluation)
+        assert passes is None
+        assert {"f"} == conditional_hashes
+
+        # both quota groups unknown
+        criteria_evaluation = {
+            "a": True,
+            "b": None,
+            "c": None,
+            "d": False,
+            "e": None,
+            "g": None,
+        }
+        quotas = [
+            DynataQuotaGroup.model_validate(
+                [
+                    {"count": 100, "condition_hashes": ["a", "b"], "status": "OPEN"},
+                    {"count": 100, "condition_hashes": ["c", "d"], "status": "CLOSED"},
+                ]
+            ),
+            DynataQuotaGroup.model_validate(
+                [{"count": 100, "condition_hashes": ["g"], "status": "OPEN"}]
+            ),
+        ]
+        task.quotas = quotas
+        passes, conditional_hashes = task.passes_quotas_soft(criteria_evaluation)
+        assert passes is None
+        assert {"b", "g"} == conditional_hashes
+
+        passes, conditional_hashes = task.determine_eligibility_soft(
+            criteria_evaluation
+        )
+        assert passes is None
+        assert {"b", "e", "f", "g"} == conditional_hashes
+
+    # def x(self):
+    #     # ----
+    #     c1 = DynataCondition(question_id='gender', values=['male'], value_type=ConditionValueType.LIST)  # 718f759
+    #     c2 = DynataCondition(question_id='age', values=['18-24'], value_type=ConditionValueType.RANGE)  # 7a7b290
+    #     obj1 = DynataFilterObject(cells=[c1.criterion_hash, c2.criterion_hash])
+    #
+    #     c3 = DynataCondition(question_id='gender', values=['female'], value_type=ConditionValueType.LIST)  # 38fa4e1
+    #     c4 = DynataCondition(question_id='age', values=['35-45'], value_type=ConditionValueType.RANGE)  # e4f06fa
+    #     obj2 = DynataFilterObject(cells=[c3.criterion_hash, c4.criterion_hash])
+    #
+    #     grp1 = DynataFilterGroup(objects=[obj1, obj2])
+    #
+    #     # -----
+    #     c5 = DynataCondition(question_id='ethnicity', values=['white'], value_type=ConditionValueType.LIST)  # eb9b9a4
+    #     obj3 = DynataFilterObject(cells=[c5.criterion_hash])
+    #
+    #     c6 = DynataCondition(question_id='ethnicity', values=['black'], value_type=ConditionValueType.LIST)  # 039fe2d
+    #     obj4 = DynataFilterObject(cells=[c6.criterion_hash])
+    #
+    #     grp2 = DynataFilterGroup(objects=[obj3, obj4])
+    #     # -----
+    #     q1 = DynataQuota(count=5, status=DynataStatus.OPEN,
+    #                      condition_hashes=[c1.criterion_hash, c2.criterion_hash])
+    #     q2 = DynataQuota(count=10, status=DynataStatus.CLOSED,
+    #                      condition_hashes=[c3.criterion_hash, c4.criterion_hash])
+    #     qg1 = DynataQuotaGroup(cells=[q1, q2])
+    #     # ----
+    #
+    #     s = DynataSurvey(survey_id='123', status=DynataStatus.OPEN, country_iso='us',
+    #                      language_iso='eng', group_id='123', client_id='123', project_id='12',
+    #                      filters=[grp1, grp2],
+    #                      quotas=[qg1])
+    #     ce = {'718f759': True, '7a7b290': True, 'eb9b9a4': True}
+    #     s.passes_filters(ce)
+    #     s.passes_quotas(ce)
diff --git a/tests/models/dynata/test_survey.py b/tests/models/dynata/test_survey.py
new file mode 100644
index 0000000..ad953a3
--- /dev/null
+++ b/tests/models/dynata/test_survey.py
@@ -0,0 +1,164 @@
+class TestDynataCondition:
+
+    def test_condition_create(self):
+        from generalresearch.models.dynata.survey import DynataCondition
+
+        cell = {
+            "tag": "90606986-5508-461b-a821-216e9a72f1a0",
+            "attribute_id": 120,
+            "negate": False,
+            "kind": "VALUE",
+            "value": "45398",
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"120": {"45398"}})
+        assert not c.evaluate_criterion({"120": {"11111"}})
+
+        cell = {
+            "tag": "aa7169c0-cb34-499a-aadd-31e0013df8fd",
+            "attribute_id": 231302,
+            "negate": False,
+            "operator": "OR",
+            "kind": "LIST",
+            "list": ["514802", "514804", "514808", "514810"],
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"231302": {"514804", "123445"}})
+        assert not c.evaluate_criterion({"231302": {"123445"}})
+
+        cell = {
+            "tag": "aa7169c0-cb34-499a-aadd-31e0013df8fd",
+            "attribute_id": 231302,
+            "negate": False,
+            "operator": "AND",
+            "kind": "LIST",
+            "list": ["514802", "514804"],
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"231302": {"514802", "514804"}})
+        assert not c.evaluate_criterion({"231302": {"514802"}})
+
+        cell = {
+            "tag": "75a36c67-0328-4c1b-a4dd-67d34688ff68",
+            "attribute_id": 80,
+            "negate": False,
+            "kind": "RANGE",
+            "range": {"from": 18, "to": 99},
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"80": {"20"}})
+        assert not c.evaluate_criterion({"80": {"120"}})
+
+        cell = {
+            "tag": "dd64b622-ed10-4a3b-e1h8-a4e63b59vha2",
+            "attribute_id": 83,
+            "negate": False,
+            "kind": "INEFFABLE",
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"83": {"20"}})
+
+        cell = {
+            "tag": "kei35kkjj-d00k-52kj-b3j4-a4jinx9832",
+            "attribute_id": 8,
+            "negate": False,
+            "kind": "ANSWERED",
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"8": {"20"}})
+        assert not c.evaluate_criterion({"81": {"20"}})
+
+    def test_condition_range(self):
+        from generalresearch.models.dynata.survey import DynataCondition
+
+        cell = {
+            "tag": "75a36c67-0328-4c1b-a4dd-67d34688ff68",
+            "attribute_id": 80,
+            "negate": False,
+            "kind": "RANGE",
+            "range": {"from": 18, "to": None},
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"80": {"20"}})
+
+    def test_recontact(self):
+        from generalresearch.models.dynata.survey import DynataCondition
+
+        cell = {
+            "tag": "d559212d-7984-4239-89c2-06c29588d79e",
+            "attribute_id": 238384,
+            "negate": False,
+            "operator": "OR",
+            "kind": "INVITE_COLLECTIONS",
+            "invite_collections": ["621041", "621042"],
+        }
+        c = DynataCondition.from_api(cell)
+        assert c.evaluate_criterion({"80": {"20"}}, user_groups={"621041", "a"})
+
+
+class TestDynataSurvey:
+    pass
+
+    # def test_survey_eligibility(self):
+    #     d = {'survey_id': 29333264, 'survey_name': '#29333264', 'survey_status': 22,
+    #          'field_end_date': datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc),
+    #          'category': 'Exciting New', 'category_code': 232,
+    #          'crtd_on': datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc),
+    #          'mod_on': datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc),
+    #          'soft_launch': False, 'click_balancing': 0, 'price_type': 1, 'pii': False,
+    #          'buyer_message': '', 'buyer_id': 4726, 'incl_excl': 0,
+    #          'cpi': Decimal('1.20000'), 'last_complete_date': None, 'project_last_complete_date': None,
+    #          'quotas': [], 'qualifications': [],
+    #          'country_iso': 'fr', 'language_iso': 'fre', 'overall_ir': 0.4, 'overall_loi': 600,
+    #          'last_block_ir': None, 'last_block_loi': None, 'survey_exclusions': set(), 'exclusion_period': 0}
+    #     s = DynataSurvey.from_api(d)
+    #     s.qualifications = ['a', 'b', 'c']
+    #     s.quotas = [
+    #         SpectrumQuota(remaining_count=10, condition_hashes=['a', 'b']),
+    #         SpectrumQuota(remaining_count=0, condition_hashes=['d']),
+    #         SpectrumQuota(remaining_count=10, condition_hashes=['e'])
+    #     ]
+    #
+    #     self.assertTrue(s.passes_qualifications({'a': True, 'b': True, 'c': True}))
+    #     self.assertFalse(s.passes_qualifications({'a': True, 'b': True, 'c': False}))
+    #
+    #     # we do NOT match a full quota, so we pass
+    #     self.assertTrue(s.passes_quotas({'a': True, 'b': True, 'd': False}))
+    #     # We dont pass any
+    #     self.assertFalse(s.passes_quotas({}))
+    #     # we only pass a full quota
+    #     self.assertFalse(s.passes_quotas({'d': True}))
+    #     # we only dont pass a full quota, but we haven't passed any open
+    #     self.assertFalse(s.passes_quotas({'d': False}))
+    #     # we pass a quota, but also pass a full quota, so fail
+    #     self.assertFalse(s.passes_quotas({'e': True, 'd': True}))
+    #     # we pass a quota, but are unknown in a full quota, so fail
+    #     self.assertFalse(s.passes_quotas({'e': True}))
+    #
+    #     # # Soft Pair
+    #     self.assertEqual((True, set()), s.passes_qualifications_soft({'a': True, 'b': True, 'c': True}))
+    #     self.assertEqual((False, set()), s.passes_qualifications_soft({'a': True, 'b': True, 'c': False}))
+    #     self.assertEqual((None, set('c')), s.passes_qualifications_soft({'a': True, 'b': True, 'c': None}))
+    #
+    #     # we do NOT match a full quota, so we pass
+    #     self.assertEqual((True, set()), s.passes_quotas_soft({'a': True, 'b': True, 'd': False}))
+    #     # We dont pass any
+    #     self.assertEqual((None, {'a', 'b', 'd', 'e'}), s.passes_quotas_soft({}))
+    #     # we only pass a full quota
+    #     self.assertEqual((False, set()), s.passes_quotas_soft({'d': True}))
+    #     # we only dont pass a full quota, but we haven't passed any open
+    #     self.assertEqual((None, {'a', 'b', 'e'}), s.passes_quotas_soft({'d': False}))
+    #     # we pass a quota, but also pass a full quota, so fail
+    #     self.assertEqual((False, set()), s.passes_quotas_soft({'e': True, 'd': True}))
+    #     # we pass a quota, but are unknown in a full quota, so fail
+    #     self.assertEqual((None, {'d'}), s.passes_quotas_soft({'e': True}))
+    #
+    #     self.assertEqual(True, s.determine_eligibility({'a': True, 'b': True, 'c': True, 'd': False}))
+    #     self.assertEqual(False, s.determine_eligibility({'a': True, 'b': True, 'c': False, 'd': False}))
+    #     self.assertEqual(False, s.determine_eligibility({'a': True, 'b': True, 'c': None, 'd': False}))
+    #     self.assertEqual((True, set()), s.determine_eligibility_soft({'a': True, 'b': True, 'c': True, 'd': False}))
+    #     self.assertEqual((False, set()), s.determine_eligibility_soft({'a': True, 'b': True, 'c': False, 'd': False}))
+    #     self.assertEqual((None, set('c')), s.determine_eligibility_soft({'a': True, 'b': True, 'c': None,
+    #     'd': False}))
+    #     self.assertEqual((None, {'c', 'd'}), s.determine_eligibility_soft({'a': True, 'b': True, 'c': None,
+    #     'd': None}))
diff --git a/tests/models/gr/__init__.py b/tests/models/gr/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/gr/__init__.py
diff --git a/tests/models/gr/test_authentication.py b/tests/models/gr/test_authentication.py
new file mode 100644
index 0000000..e906d8c
--- /dev/null
+++ b/tests/models/gr/test_authentication.py
@@ -0,0 +1,313 @@
+import binascii
+import json
+import os
+from datetime import datetime, timezone
+from random import randint
+from uuid import uuid4
+
+import pytest
+
+SSO_ISSUER = ""
+
+
+class TestGRUser:
+
+    def test_init(self, gr_user):
+        from generalresearch.models.gr.authentication import GRUser
+
+        assert isinstance(gr_user, GRUser)
+        assert not gr_user.is_superuser
+
+        assert gr_user.teams is None
+        assert gr_user.businesses is None
+        assert gr_user.products is None
+
+    @pytest.mark.skip(reason="TODO")
+    def test_businesses(self):
+        pass
+
+    def test_teams(self, gr_user, membership, gr_db, gr_redis_config):
+        from generalresearch.models.gr.team import Team
+
+        assert gr_user.teams is None
+
+        gr_user.prefetch_teams(pg_config=gr_db, redis_config=gr_redis_config)
+
+        assert isinstance(gr_user.teams, list)
+        assert len(gr_user.teams) == 1
+        assert isinstance(gr_user.teams[0], Team)
+
+    def test_prefetch_team_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_products(
+        self,
+        gr_user,
+        product_factory,
+        team,
+        membership,
+        gr_db,
+        thl_web_rr,
+        gr_redis_config,
+    ):
+        from generalresearch.models.thl.product import Product
+
+        assert gr_user.products is None
+
+        # Create a new Team membership, and then create a Product that
+        #    is  part of that team
+        membership.prefetch_team(pg_config=gr_db, redis_config=gr_redis_config)
+        p: Product = product_factory(team=team)
+        assert p.id_int
+        assert team.uuid == membership.team.uuid
+        assert p.team_id == team.uuid
+        assert p.team_uuid == membership.team.uuid
+        assert gr_user.id == membership.user_id
+
+        gr_user.prefetch_products(
+            pg_config=gr_db,
+            thl_pg_config=thl_web_rr,
+            redis_config=gr_redis_config,
+        )
+        assert isinstance(gr_user.products, list)
+        assert len(gr_user.products) == 1
+        assert isinstance(gr_user.products[0], Product)
+
+
+class TestGRUserMethods:
+
+    def test_cache_key(self, gr_user, gr_redis):
+        assert isinstance(gr_user.cache_key, str)
+        assert ":" in gr_user.cache_key
+        assert str(gr_user.id) in gr_user.cache_key
+
+    def test_to_redis(
+        self,
+        gr_user,
+        gr_redis,
+        team,
+        business,
+        product_factory,
+        membership_factory,
+    ):
+        product_factory(team=team, business=business)
+        membership_factory(team=team, gr_user=gr_user)
+
+        res = gr_user.to_redis()
+        assert isinstance(res, str)
+
+        from generalresearch.models.gr.authentication import GRUser
+
+        instance = GRUser.from_redis(res)
+        assert isinstance(instance, GRUser)
+
+    def test_set_cache(
+        self,
+        gr_user,
+        gr_user_token,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        gr_redis_config,
+    ):
+        assert gr_redis.get(name=gr_user.cache_key) is None
+        assert gr_redis.get(name=f"{gr_user.cache_key}:team_uuids") is None
+        assert gr_redis.get(name=f"{gr_user.cache_key}:business_uuids") is None
+        assert gr_redis.get(name=f"{gr_user.cache_key}:product_uuids") is None
+
+        gr_user.set_cache(
+            pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
+        )
+
+        assert gr_redis.get(name=gr_user.cache_key) is not None
+        assert gr_redis.get(name=f"{gr_user.cache_key}:team_uuids") is not None
+        assert gr_redis.get(name=f"{gr_user.cache_key}:business_uuids") is not None
+        assert gr_redis.get(name=f"{gr_user.cache_key}:product_uuids") is not None
+
+    def test_set_cache_gr_user(
+        self,
+        gr_user,
+        gr_user_token,
+        gr_redis,
+        gr_redis_config,
+        gr_db,
+        thl_web_rr,
+        product_factory,
+        team,
+        membership_factory,
+        thl_redis_config,
+    ):
+        from generalresearch.models.gr.authentication import GRUser
+
+        p1 = product_factory(team=team)
+        membership_factory(team=team, gr_user=gr_user)
+
+        gr_user.set_cache(
+            pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
+        )
+
+        res: str = gr_redis.get(name=gr_user.cache_key)
+        gru2 = GRUser.from_redis(res)
+
+        assert gr_user.model_dump_json(
+            exclude={"businesses", "teams", "products"}
+        ) == gru2.model_dump_json(exclude={"businesses", "teams", "products"})
+
+        gru2.prefetch_products(
+            pg_config=gr_db,
+            thl_pg_config=thl_web_rr,
+            redis_config=thl_redis_config,
+        )
+        assert gru2.product_uuids == [p1.uuid]
+
+    def test_set_cache_team_uuids(
+        self,
+        gr_user,
+        membership,
+        gr_user_token,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        product_factory,
+        team,
+        gr_redis_config,
+    ):
+        product_factory(team=team)
+
+        gr_user.set_cache(
+            pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
+        )
+        res = json.loads(gr_redis.get(name=f"{gr_user.cache_key}:team_uuids"))
+        assert len(res) == 1
+        assert gr_user.team_uuids == res
+
+    @pytest.mark.skip
+    def test_set_cache_business_uuids(
+        self,
+        gr_user,
+        membership,
+        gr_user_token,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        product_factory,
+        business,
+        team,
+        gr_redis_config,
+    ):
+        product_factory(team=team, business=business)
+
+        gr_user.set_cache(
+            pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
+        )
+        res = json.loads(gr_redis.get(name=f"{gr_user.cache_key}:business_uuids"))
+        assert len(res) == 1
+        assert gr_user.business_uuids == res
+
+    def test_set_cache_product_uuids(
+        self,
+        gr_user,
+        membership,
+        gr_user_token,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        product_factory,
+        team,
+        gr_redis_config,
+    ):
+        product_factory(team=team)
+
+        gr_user.set_cache(
+            pg_config=gr_db, thl_web_rr=thl_web_rr, redis_config=gr_redis_config
+        )
+        res = json.loads(gr_redis.get(name=f"{gr_user.cache_key}:product_uuids"))
+        assert len(res) == 1
+        assert gr_user.product_uuids == res
+
+
+class TestGRToken:
+
+    @pytest.fixture
+    def gr_token(self, gr_user):
+        from generalresearch.models.gr.authentication import GRToken
+
+        now = datetime.now(tz=timezone.utc)
+        token = binascii.hexlify(os.urandom(20)).decode()
+
+        gr_token = GRToken(key=token, created=now, user_id=gr_user.id)
+
+        return gr_token
+
+    def test_init(self, gr_token):
+        from generalresearch.models.gr.authentication import GRToken
+
+        assert isinstance(gr_token, GRToken)
+        assert gr_token.created
+
+    def test_user(self, gr_token, gr_db, gr_redis_config):
+        from generalresearch.models.gr.authentication import GRUser
+
+        assert gr_token.user is None
+
+        gr_token.prefetch_user(pg_config=gr_db, redis_config=gr_redis_config)
+
+        assert isinstance(gr_token.user, GRUser)
+
+    def test_auth_header(self, gr_token):
+        assert isinstance(gr_token.auth_header, dict)
+
+
+class TestClaims:
+
+    def test_init(self):
+        from generalresearch.models.gr.authentication import Claims
+
+        d = {
+            "iss": SSO_ISSUER,
+            "sub": f"{uuid4().hex}{uuid4().hex}",
+            "aud": uuid4().hex,
+            "exp": randint(a=1_500_000_000, b=2_000_000_000),
+            "iat": randint(a=1_500_000_000, b=2_000_000_000),
+            "auth_time": randint(a=1_500_000_000, b=2_000_000_000),
+            "acr": "goauthentik.io/providers/oauth2/default",
+            "amr": ["pwd", "mfa"],
+            "sid": f"{uuid4().hex}{uuid4().hex}",
+            "email": "max@g-r-l.com",
+            "email_verified": True,
+            "name": "Max Nanis",
+            "given_name": "Max Nanis",
+            "preferred_username": "nanis",
+            "nickname": "nanis",
+            "groups": [
+                "authentik Admins",
+                "Developers",
+                "Systems Admin",
+                "Customer Support",
+                "admin",
+            ],
+            "azp": uuid4().hex,
+            "uid": uuid4().hex,
+        }
+        instance = Claims.model_validate(d)
+
+        assert isinstance(instance, Claims)
diff --git a/tests/models/gr/test_business.py b/tests/models/gr/test_business.py
new file mode 100644
index 0000000..9a7718d
--- /dev/null
+++ b/tests/models/gr/test_business.py
@@ -0,0 +1,1432 @@
+import os
+from datetime import datetime, timedelta, timezone
+from decimal import Decimal
+from typing import Optional
+from uuid import uuid4
+
+import pandas as pd
+import pytest
+
+# noinspection PyUnresolvedReferences
+from distributed.utils_test import (
+    gen_cluster,
+    client_no_amm,
+    loop,
+    loop_in_thread,
+    cleanup,
+    cluster_fixture,
+    client,
+)
+from pytest import approx
+
+from generalresearch.currency import USDCent
+from generalresearch.models.thl.finance import (
+    ProductBalances,
+    BusinessBalances,
+)
+
+# from test_utils.incite.conftest import mnt_filepath
+from test_utils.managers.conftest import (
+    business_bank_account_manager,
+    lm,
+    thl_lm,
+)
+
+
+class TestBusinessBankAccount:
+
+    def test_init(self, business, business_bank_account_manager):
+        from generalresearch.models.gr.business import (
+            BusinessBankAccount,
+            TransferMethod,
+        )
+
+        instance = business_bank_account_manager.create(
+            business_id=business.id,
+            uuid=uuid4().hex,
+            transfer_method=TransferMethod.ACH,
+        )
+        assert isinstance(instance, BusinessBankAccount)
+
+    def test_business(self, business_bank_account, business, gr_db, gr_redis_config):
+        from generalresearch.models.gr.business import Business
+
+        assert business_bank_account.business is None
+
+        business_bank_account.prefetch_business(
+            pg_config=gr_db, redis_config=gr_redis_config
+        )
+        assert isinstance(business_bank_account.business, Business)
+        assert business_bank_account.business.uuid == business.uuid
+
+
+class TestBusinessAddress:
+
+    def test_init(self, business_address):
+        from generalresearch.models.gr.business import BusinessAddress
+
+        assert isinstance(business_address, BusinessAddress)
+
+
+class TestBusinessContact:
+
+    def test_init(self):
+        from generalresearch.models.gr.business import BusinessContact
+
+        bc = BusinessContact(name="abc", email="test@abc.com")
+        assert isinstance(bc, BusinessContact)
+
+
+class TestBusiness:
+    @pytest.fixture
+    def start(self) -> "datetime":
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+
+    @pytest.fixture
+    def offset(self) -> str:
+        return "30d"
+
+    @pytest.fixture
+    def duration(self) -> Optional["timedelta"]:
+        return None
+
+    def test_init(self, business):
+        from generalresearch.models.gr.business import Business
+
+        assert isinstance(business, Business)
+        assert isinstance(business.id, int)
+        assert isinstance(business.uuid, str)
+
+    def test_str_and_repr(
+        self,
+        business,
+        product_factory,
+        thl_web_rr,
+        lm,
+        thl_lm,
+        business_payout_event_manager,
+        bp_payout_factory,
+        start,
+        user_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        client_no_amm,
+        ledger_collection,
+        mnt_filepath,
+        create_main_accounts,
+    ):
+        create_main_accounts()
+        p1 = product_factory(business=business)
+        u1 = user_factory(product=p1)
+        p2 = product_factory(business=business)
+        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        thl_lm.get_account_or_create_bp_wallet(product=p2)
+
+        res1 = repr(business)
+
+        assert business.uuid in res1
+        assert "<Business: " in res1
+
+        res2 = str(business)
+
+        assert business.uuid in res2
+        assert "Name:" in res2
+        assert "Not Loaded" in res2
+
+        business.prefetch_products(thl_pg_config=thl_web_rr)
+        business.prefetch_bp_accounts(lm=lm, thl_pg_config=thl_web_rr)
+        res3 = str(business)
+        assert "Products: 2" in res3
+        assert "Ledger Accounts: 2" in res3
+
+        # -- need some tx to make these interesting
+        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=5),
+        )
+        bp_payout_factory(
+            product=p1,
+            amount=USDCent(50),
+            created=start + timedelta(days=4),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.prebuild_payouts(
+            thl_pg_config=thl_web_rr,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+        )
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+        res4 = str(business)
+        assert "Payouts: 1" in res4
+        assert "Available Balance: 141" in res4
+
+    def test_addresses(self, business, business_address, gr_db):
+        from generalresearch.models.gr.business import BusinessAddress
+
+        assert business.addresses is None
+
+        business.prefetch_addresses(pg_config=gr_db)
+        assert isinstance(business.addresses, list)
+        assert len(business.addresses) == 1
+        assert isinstance(business.addresses[0], BusinessAddress)
+
+    def test_teams(self, business, team, team_manager, gr_db):
+        assert business.teams is None
+
+        business.prefetch_teams(pg_config=gr_db)
+        assert isinstance(business.teams, list)
+        assert len(business.teams) == 0
+
+        team_manager.add_business(team=team, business=business)
+        assert len(business.teams) == 0
+        business.prefetch_teams(pg_config=gr_db)
+        assert len(business.teams) == 1
+
+    def test_products(self, business, product_factory, thl_web_rr):
+        from generalresearch.models.thl.product import Product
+
+        p1 = product_factory(business=business)
+        assert business.products is None
+
+        business.prefetch_products(thl_pg_config=thl_web_rr)
+        assert isinstance(business.products, list)
+        assert len(business.products) == 1
+        assert isinstance(business.products[0], Product)
+
+        assert business.products[0].uuid == p1.uuid
+
+        # Add two more, but list is still one until we prefetch
+        p2 = product_factory(business=business)
+        p3 = product_factory(business=business)
+        assert len(business.products) == 1
+
+        business.prefetch_products(thl_pg_config=thl_web_rr)
+        assert len(business.products) == 3
+
+    def test_bank_accounts(self, business, business_bank_account, gr_db):
+        assert business.products is None
+
+        # It's an empty list after prefetch
+        business.prefetch_bank_accounts(pg_config=gr_db)
+        assert isinstance(business.bank_accounts, list)
+        assert len(business.bank_accounts) == 1
+
+    def test_balance(
+        self,
+        business,
+        mnt_filepath,
+        client_no_amm,
+        thl_web_rr,
+        lm,
+        pop_ledger_merge,
+    ):
+        assert business.balance is None
+
+        with pytest.raises(expected_exception=AssertionError) as cm:
+            business.prebuild_balance(
+                thl_pg_config=thl_web_rr,
+                lm=lm,
+                ds=mnt_filepath,
+                client=client_no_amm,
+                pop_ledger=pop_ledger_merge,
+            )
+        assert "Cannot build Business Balance" in str(cm.value)
+        assert business.balance is None
+
+        # TODO: Add parquet building so that this doesn't fail and we can
+        #    properly assign a business.balance
+
+    def test_payouts_no_accounts(
+        self,
+        business,
+        product_factory,
+        thl_web_rr,
+        thl_lm,
+        business_payout_event_manager,
+    ):
+        assert business.payouts is None
+
+        with pytest.raises(expected_exception=AssertionError) as cm:
+            business.prebuild_payouts(
+                thl_pg_config=thl_web_rr,
+                thl_lm=thl_lm,
+                bpem=business_payout_event_manager,
+            )
+        assert "Must provide product_uuids" in str(cm.value)
+
+        p = product_factory(business=business)
+        thl_lm.get_account_or_create_bp_wallet(product=p)
+
+        business.prebuild_payouts(
+            thl_pg_config=thl_web_rr,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+        )
+        assert isinstance(business.payouts, list)
+        assert len(business.payouts) == 0
+
+    def test_payouts(
+        self,
+        business,
+        product_factory,
+        bp_payout_factory,
+        thl_lm,
+        thl_web_rr,
+        business_payout_event_manager,
+        create_main_accounts,
+    ):
+        create_main_accounts()
+        p = product_factory(business=business)
+        thl_lm.get_account_or_create_bp_wallet(product=p)
+        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+
+        bp_payout_factory(
+            product=p, amount=USDCent(123), skip_wallet_balance_check=True
+        )
+
+        business.prebuild_payouts(
+            thl_pg_config=thl_web_rr,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+        )
+        assert len(business.payouts) == 1
+        assert sum([p.amount for p in business.payouts]) == 123
+
+        # Add another!
+        bp_payout_factory(
+            product=p,
+            amount=USDCent(123),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        business.prebuild_payouts(
+            thl_pg_config=thl_web_rr,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+        )
+        assert len(business.payouts) == 1
+        assert len(business.payouts[0].bp_payouts) == 2
+        assert sum([p.amount for p in business.payouts]) == 246
+
+    def test_payouts_totals(
+        self,
+        business,
+        product_factory,
+        bp_payout_factory,
+        thl_lm,
+        thl_web_rr,
+        business_payout_event_manager,
+        create_main_accounts,
+    ):
+        from generalresearch.models.thl.product import Product
+
+        create_main_accounts()
+
+        p1: Product = product_factory(business=business)
+        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        business_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+
+        bp_payout_factory(
+            product=p1,
+            amount=USDCent(1),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        bp_payout_factory(
+            product=p1,
+            amount=USDCent(25),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        bp_payout_factory(
+            product=p1,
+            amount=USDCent(50),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        business.prebuild_payouts(
+            thl_pg_config=thl_web_rr,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+        )
+
+        assert len(business.payouts) == 1
+        assert len(business.payouts[0].bp_payouts) == 3
+        assert business.payouts_total == USDCent(76)
+        assert business.payouts_total_str == "$0.76"
+
+    def test_pop_financial(
+        self,
+        business,
+        thl_web_rr,
+        lm,
+        mnt_filepath,
+        client_no_amm,
+        pop_ledger_merge,
+    ):
+        assert business.pop_financial is None
+        business.prebuild_pop_financial(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+        assert business.pop_financial == []
+
+    def test_bp_accounts(self, business, lm, thl_web_rr, product_factory, thl_lm):
+        assert business.bp_accounts is None
+        business.prefetch_bp_accounts(lm=lm, thl_pg_config=thl_web_rr)
+        assert business.bp_accounts == []
+
+        from generalresearch.models.thl.product import Product
+
+        p1: Product = product_factory(business=business)
+        thl_lm.get_account_or_create_bp_wallet(product=p1)
+
+        business.prefetch_bp_accounts(lm=lm, thl_pg_config=thl_web_rr)
+        assert len(business.bp_accounts) == 1
+
+
+class TestBusinessBalance:
+
+    @pytest.fixture
+    def start(self) -> "datetime":
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+
+    @pytest.fixture
+    def offset(self) -> str:
+        return "30d"
+
+    @pytest.fixture
+    def duration(self) -> Optional["timedelta"]:
+        return None
+
+    @pytest.mark.skip
+    def test_product_ordering(self):
+        # Assert that the order of business.balance.product_balances is always
+        #   consistent and in the same order based off product.created ASC
+        pass
+
+    def test_single_product(
+        self,
+        business,
+        product_factory,
+        user_factory,
+        mnt_filepath,
+        bp_payout_factory,
+        thl_lm,
+        lm,
+        duration,
+        offset,
+        start,
+        thl_web_rr,
+        payout_event_manager,
+        session_with_tx_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        delete_df_collection,
+    ):
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.product import Product
+        from generalresearch.models.thl.user import User
+
+        p1: Product = product_factory(business=business)
+        u1: User = user_factory(product=p1)
+        u2: User = user_factory(product=p1)
+
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+
+        session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal("1.25"),
+            started=start + timedelta(days=2),
+        )
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+        assert isinstance(business.balance, BusinessBalances)
+        assert business.balance.payout == 190
+        assert business.balance.adjustment == 0
+        assert business.balance.net == 190
+        assert business.balance.retainer == 47
+        assert business.balance.available_balance == 143
+
+        assert len(business.balance.product_balances) == 1
+        pb = business.balance.product_balances[0]
+        assert isinstance(pb, ProductBalances)
+        assert pb.balance == business.balance.balance
+        assert pb.available_balance == business.balance.available_balance
+        assert pb.adjustment_percent == 0.0
+
+    def test_multi_product(
+        self,
+        business,
+        product_factory,
+        user_factory,
+        mnt_filepath,
+        bp_payout_factory,
+        thl_lm,
+        lm,
+        duration,
+        offset,
+        start,
+        thl_web_rr,
+        payout_event_manager,
+        session_with_tx_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        delete_df_collection,
+    ):
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product_factory(business=business))
+        u2: User = user_factory(product=product_factory(business=business))
+
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+
+        session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal("1.25"),
+            started=start + timedelta(days=2),
+        )
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+        assert isinstance(business.balance, BusinessBalances)
+        assert business.balance.payout == 190
+        assert business.balance.balance == 190
+        assert business.balance.adjustment == 0
+        assert business.balance.net == 190
+        assert business.balance.retainer == 46
+        assert business.balance.available_balance == 144
+
+        assert len(business.balance.product_balances) == 2
+
+        pb1 = business.balance.product_balances[0]
+        pb2 = business.balance.product_balances[1]
+        assert isinstance(pb1, ProductBalances)
+        assert pb1.product_id == u1.product_id
+        assert isinstance(pb2, ProductBalances)
+        assert pb2.product_id == u2.product_id
+
+        for pb in [pb1, pb2]:
+            assert pb.balance != business.balance.balance
+            assert pb.available_balance != business.balance.available_balance
+            assert pb.adjustment_percent == 0.0
+
+        assert pb1.product_id in [u1.product_id, u2.product_id]
+        assert pb1.payout == 71
+        assert pb1.adjustment == 0
+        assert pb1.expense == 0
+        assert pb1.net == 71
+        assert pb1.retainer == 17
+        assert pb1.available_balance == 54
+
+        assert pb2.product_id in [u1.product_id, u2.product_id]
+        assert pb2.payout == 119
+        assert pb2.adjustment == 0
+        assert pb2.expense == 0
+        assert pb2.net == 119
+        assert pb2.retainer == 29
+        assert pb2.available_balance == 90
+
+    def test_multi_product_multi_payout(
+        self,
+        business,
+        product_factory,
+        user_factory,
+        mnt_filepath,
+        bp_payout_factory,
+        thl_lm,
+        lm,
+        duration,
+        offset,
+        start,
+        thl_web_rr,
+        payout_event_manager,
+        session_with_tx_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        delete_df_collection,
+    ):
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product_factory(business=business))
+        u2: User = user_factory(product=product_factory(business=business))
+
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+
+        session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal("1.25"),
+            started=start + timedelta(days=2),
+        )
+
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+
+        bp_payout_factory(
+            product=u1.product,
+            amount=USDCent(5),
+            created=start + timedelta(days=4),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        bp_payout_factory(
+            product=u2.product,
+            amount=USDCent(50),
+            created=start + timedelta(days=4),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+
+        assert business.balance.payout == 190
+        assert business.balance.net == 190
+
+        assert business.balance.balance == 135
+
+    def test_multi_product_multi_payout_adjustment(
+        self,
+        business,
+        product_factory,
+        user_factory,
+        mnt_filepath,
+        bp_payout_factory,
+        thl_lm,
+        lm,
+        duration,
+        offset,
+        start,
+        thl_web_rr,
+        payout_event_manager,
+        session_with_tx_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        client_no_amm,
+        ledger_collection,
+        task_adj_collection,
+        pop_ledger_merge,
+        wall_manager,
+        session_manager,
+        adj_to_fail_with_tx_factory,
+        delete_df_collection,
+    ):
+        """
+        - Product 1 $2.50 Complete
+        - Product 2 $2.50 Complete
+        - $2.50 Payout on Product 1
+        - $0.50 Payout on Product 2
+        - Product 3 $2.50 Complete
+        - Complete -> Failure $2.50 Adjustment on Product 1
+        ====
+        - Net: $7.50 * .95 = $7.125
+            - $2.50 = $2.375 = $2.38
+            - $2.50 = $2.375 = $2.38
+            - $2.50 = $2.375 = $2.38
+            ====
+                             - $7.14
+        - Balance: $2
+        """
+
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+        delete_df_collection(coll=task_adj_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product_factory(business=business))
+        u2: User = user_factory(product=product_factory(business=business))
+        u3: User = user_factory(product=product_factory(business=business))
+
+        s1 = session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=1),
+        )
+
+        session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=2),
+        )
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+
+        bp_payout_factory(
+            product=u1.product,
+            amount=USDCent(250),
+            created=start + timedelta(days=3),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        bp_payout_factory(
+            product=u2.product,
+            amount=USDCent(50),
+            created=start + timedelta(days=4),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        adj_to_fail_with_tx_factory(session=s1, created=start + timedelta(days=5))
+
+        session_with_tx_factory(
+            user=u3,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=6),
+        )
+
+        # Build and prepare the Business with the db transactions now in place
+
+        # This isn't needed for Business Balance... but good to also check
+        # task_adj_collection.initial_load(client=None, sync=True)
+        # These are the only two that are needed for Business Balance
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        df = client_no_amm.compute(ledger_collection.ddf(), sync=True)
+        assert df.shape == (24, 24)
+
+        df = client_no_amm.compute(pop_ledger_merge.ddf(), sync=True)
+        assert df.shape == (20, 28)
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+
+        assert business.balance.payout == 714
+        assert business.balance.adjustment == -238
+
+        assert business.balance.product_balances[0].adjustment == -238
+        assert business.balance.product_balances[1].adjustment == 0
+        assert business.balance.product_balances[2].adjustment == 0
+
+        assert business.balance.expense == 0
+        assert business.balance.net == 714 - 238
+        assert business.balance.balance == business.balance.payout - (250 + 50 + 238)
+
+        predicted_retainer = sum(
+            [
+                pb.balance * 0.25
+                for pb in business.balance.product_balances
+                if pb.balance > 0
+            ]
+        )
+        assert business.balance.retainer == approx(predicted_retainer, rel=0.01)
+
+    def test_neg_balance_cache(
+        self,
+        product,
+        mnt_filepath,
+        thl_lm,
+        client_no_amm,
+        thl_redis_config,
+        brokerage_product_payout_event_manager,
+        delete_ledger_db,
+        create_main_accounts,
+        delete_df_collection,
+        ledger_collection,
+        business,
+        user_factory,
+        product_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        start,
+        bp_payout_factory,
+        payout_event_manager,
+        adj_to_fail_with_tx_factory,
+        thl_web_rr,
+        lm,
+    ):
+        """Test having a Business with two products.. one that lost money
+        and one that gained money. Ensure that the Business balance
+        reflects that to compensate for the Product in the negative.
+        """
+        # Now let's load it up and actually test some things
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.product import Product
+        from generalresearch.models.thl.user import User
+
+        p1: Product = product_factory(business=business)
+        p2: Product = product_factory(business=business)
+        u1: User = user_factory(product=p1)
+        u2: User = user_factory(product=p2)
+        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        thl_lm.get_account_or_create_bp_wallet(product=p2)
+
+        # Product 1: Complete, Payout, Recon..
+        s1 = session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        bp_payout_factory(
+            product=u1.product,
+            amount=USDCent(71),
+            ext_ref_id=uuid4().hex,
+            created=start + timedelta(days=1, minutes=1),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+        adj_to_fail_with_tx_factory(
+            session=s1,
+            created=start + timedelta(days=1, minutes=2),
+        )
+
+        # Product 2: Complete, Complete.
+        s2 = session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1, minutes=3),
+        )
+        s3 = session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1, minutes=4),
+        )
+
+        # Finally, process everything:
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+
+        # Check Product 1
+        pb1 = business.balance.product_balances[0]
+        assert pb1.product_id == p1.uuid
+        assert pb1.payout == 71
+        assert pb1.adjustment == -71
+        assert pb1.net == 0
+        assert pb1.balance == 71 - (71 * 2)
+        assert pb1.retainer == 0
+        assert pb1.available_balance == 0
+
+        # Check Product 2
+        pb2 = business.balance.product_balances[1]
+        assert pb2.product_id == p2.uuid
+        assert pb2.payout == 71 * 2
+        assert pb2.adjustment == 0
+        assert pb2.net == 71 * 2
+        assert pb2.balance == (71 * 2)
+        assert pb2.retainer == pytest.approx((71 * 2) * 0.25, rel=1)
+        assert pb2.available_balance == 107
+
+        # Check Business
+        bb1 = business.balance
+        assert bb1.payout == (71 * 3)  # Raw total of completes
+        assert bb1.adjustment == -71  # 1 Complete >> Failure
+        assert bb1.expense == 0
+        assert bb1.net == (71 * 3) - 71  # How much the Business actually earned
+        assert (
+            bb1.balance == (71 * 3) - 71 - 71
+        )  # 3 completes, but 1 payout and 1 recon leaves only one complete
+        # worth of activity on the account
+        assert bb1.retainer == pytest.approx((71 * 2) * 0.25, rel=1)
+        assert bb1.available_balance_usd_str == "$0.36"
+
+        # Confirm that the debt from the pb1 in the red is covered when
+        #    calculating the Business balance by the profit of pb2
+        assert pb2.available_balance + pb1.balance == bb1.available_balance
+
+    def test_multi_product_multi_payout_adjustment_at_timestamp(
+        self,
+        business,
+        product_factory,
+        user_factory,
+        mnt_filepath,
+        bp_payout_factory,
+        thl_lm,
+        lm,
+        duration,
+        offset,
+        start,
+        thl_web_rr,
+        payout_event_manager,
+        session_with_tx_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        client_no_amm,
+        ledger_collection,
+        task_adj_collection,
+        pop_ledger_merge,
+        wall_manager,
+        session_manager,
+        adj_to_fail_with_tx_factory,
+        delete_df_collection,
+    ):
+        """
+            This test measures a complex Business situation, but then makes
+            various assertions based off the query which uses an at_timestamp.
+
+            The goal here is a feature that allows us to look back and see
+            what the balance was of an account at any specific point in time.
+
+        - Day 1: Product 1 $2.50 Complete
+            - Total Payout: $2.38
+            - Smart Retainer: $0.59
+            - Available Balance: $1.79
+        - Day 2: Product 2 $2.50 Complete
+            - Total Payout: $4.76
+            - Smart Retainer: $1.18
+            - Available Balance: $3.58
+        - Day 3: $2.50 Payout on Product 1
+            - Total Payout: $4.76
+            - Smart Retainer: $0.59
+            - Available Balance: $1.67
+        - Day 4: $0.50 Payout on Product 2
+            - Total Payout: $4.76
+            - Smart Retainer: $0.47
+            - Available Balance: $1.29
+        - Day 5: Product 3 $2.50 Complete
+            - Total Payout: $7.14
+            - Smart Retainer: $1.06
+            - Available Balance: $3.08
+        - Day 6: Complete -> Failure $2.50 Adjustment on Product 1
+            - Total Payout: $7.18
+            - Smart Retainer: $1.06
+            - Available Balance: $0.70
+        """
+
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+        delete_df_collection(coll=task_adj_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product_factory(business=business))
+        u2: User = user_factory(product=product_factory(business=business))
+        u3: User = user_factory(product=product_factory(business=business))
+
+        s1 = session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=1),
+        )
+
+        session_with_tx_factory(
+            user=u2,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=2),
+        )
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+
+        bp_payout_factory(
+            product=u1.product,
+            amount=USDCent(250),
+            created=start + timedelta(days=3),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        bp_payout_factory(
+            product=u2.product,
+            amount=USDCent(50),
+            created=start + timedelta(days=4),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        session_with_tx_factory(
+            user=u3,
+            wall_req_cpi=Decimal("2.50"),
+            started=start + timedelta(days=5),
+        )
+
+        adj_to_fail_with_tx_factory(session=s1, created=start + timedelta(days=6))
+
+        # Build and prepare the Business with the db transactions now in place
+
+        # This isn't needed for Business Balance... but good to also check
+        # task_adj_collection.initial_load(client=None, sync=True)
+        # These are the only two that are needed for Business Balance
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        df = client_no_amm.compute(ledger_collection.ddf(), sync=True)
+        assert df.shape == (24, 24)
+
+        df = client_no_amm.compute(pop_ledger_merge.ddf(), sync=True)
+        assert df.shape == (20, 28)
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+            at_timestamp=start + timedelta(days=1, hours=1),
+        )
+        day1_bal = business.balance
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+            at_timestamp=start + timedelta(days=2, hours=1),
+        )
+        day2_bal = business.balance
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+            at_timestamp=start + timedelta(days=3, hours=1),
+        )
+        day3_bal = business.balance
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+            at_timestamp=start + timedelta(days=4, hours=1),
+        )
+        day4_bal = business.balance
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+            at_timestamp=start + timedelta(days=5, hours=1),
+        )
+        day5_bal = business.balance
+
+        business.prebuild_balance(
+            thl_pg_config=thl_web_rr,
+            lm=lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+            at_timestamp=start + timedelta(days=6, hours=1),
+        )
+        day6_bal = business.balance
+
+        assert day1_bal.payout == 238
+        assert day1_bal.retainer == 59
+        assert day1_bal.available_balance == 179
+
+        assert day2_bal.payout == 476
+        assert day2_bal.retainer == 118
+        assert day2_bal.available_balance == 358
+
+        assert day3_bal.payout == 476
+        assert day3_bal.retainer == 59
+        assert day3_bal.available_balance == 167
+
+        assert day4_bal.payout == 476
+        assert day4_bal.retainer == 47
+        assert day4_bal.available_balance == 129
+
+        assert day5_bal.payout == 714
+        assert day5_bal.retainer == 106
+        assert day5_bal.available_balance == 308
+
+        assert day6_bal.payout == 714
+        assert day6_bal.retainer == 106
+        assert day6_bal.available_balance == 70
+
+
+class TestBusinessMethods:
+
+    @pytest.fixture(scope="function")
+    def start(self, utc_90days_ago) -> "datetime":
+        s = utc_90days_ago.replace(microsecond=0)
+        return s
+
+    @pytest.fixture(scope="function")
+    def offset(self) -> str:
+        return "15d"
+
+    @pytest.fixture(scope="function")
+    def duration(
+        self,
+    ) -> Optional["timedelta"]:
+        return None
+
+    def test_cache_key(self, business, gr_redis):
+        assert isinstance(business.cache_key, str)
+        assert ":" in business.cache_key
+        assert str(business.uuid) in business.cache_key
+
+    def test_set_cache(
+        self,
+        business,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        client_no_amm,
+        mnt_filepath,
+        lm,
+        thl_lm,
+        business_payout_event_manager,
+        product_factory,
+        membership_factory,
+        team,
+        session_with_tx_factory,
+        user_factory,
+        ledger_collection,
+        pop_ledger_merge,
+        utc_60days_ago,
+        delete_ledger_db,
+        create_main_accounts,
+        gr_redis_config,
+        mnt_gr_api_dir,
+    ):
+        assert gr_redis.get(name=business.cache_key) is None
+
+        p1 = product_factory(team=team, business=business)
+        u1 = user_factory(product=p1)
+
+        # Business needs tx & incite to build balance
+        delete_ledger_db()
+        create_main_accounts()
+        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        session_with_tx_factory(user=u1, started=utc_60days_ago)
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.set_cache(
+            pg_config=gr_db,
+            thl_web_rr=thl_web_rr,
+            redis_config=gr_redis_config,
+            client=client_no_amm,
+            ds=mnt_filepath,
+            lm=lm,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+            pop_ledger=pop_ledger_merge,
+            mnt_gr_api=mnt_gr_api_dir,
+        )
+
+        assert gr_redis.hgetall(name=business.cache_key) is not None
+        from generalresearch.models.gr.business import Business
+
+        # We're going to pull only a specific year, but make sure that
+        # it's being assigned to the field regardless
+        year = datetime.now(tz=timezone.utc).year
+        res = Business.from_redis(
+            uuid=business.uuid,
+            fields=[f"pop_financial:{year}"],
+            gr_redis_config=gr_redis_config,
+        )
+        assert len(res.pop_financial) > 0
+
+    def test_set_cache_business(
+        self,
+        gr_user,
+        business,
+        gr_user_token,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        product_factory,
+        team,
+        membership_factory,
+        client_no_amm,
+        mnt_filepath,
+        lm,
+        thl_lm,
+        business_payout_event_manager,
+        user_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        session_with_tx_factory,
+        ledger_collection,
+        team_manager,
+        pop_ledger_merge,
+        gr_redis_config,
+        utc_60days_ago,
+        mnt_gr_api_dir,
+    ):
+        from generalresearch.models.gr.business import Business
+
+        p1 = product_factory(team=team, business=business)
+        u1 = user_factory(product=p1)
+        team_manager.add_business(team=team, business=business)
+
+        # Business needs tx & incite to build balance
+        delete_ledger_db()
+        create_main_accounts()
+        thl_lm.get_account_or_create_bp_wallet(product=p1)
+        session_with_tx_factory(user=u1, started=utc_60days_ago)
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        business.set_cache(
+            pg_config=gr_db,
+            thl_web_rr=thl_web_rr,
+            redis_config=gr_redis_config,
+            client=client_no_amm,
+            ds=mnt_filepath,
+            lm=lm,
+            thl_lm=thl_lm,
+            bpem=business_payout_event_manager,
+            pop_ledger=pop_ledger_merge,
+            mnt_gr_api=mnt_gr_api_dir,
+        )
+
+        # keys: List = Business.required_fields() + ["products", "bp_accounts"]
+        business2 = Business.from_redis(
+            uuid=business.uuid,
+            fields=[
+                "id",
+                "tax_number",
+                "contact",
+                "addresses",
+                "teams",
+                "products",
+                "bank_accounts",
+                "balance",
+                "payouts_total_str",
+                "payouts_total",
+                "payouts",
+                "pop_financial",
+                "bp_accounts",
+            ],
+            gr_redis_config=gr_redis_config,
+        )
+
+        assert business.model_dump_json() == business2.model_dump_json()
+        assert p1.uuid in [p.uuid for p in business2.products]
+        assert len(business2.teams) == 1
+        assert team.uuid in [t.uuid for t in business2.teams]
+
+        assert business2.balance.payout == 48
+        assert business2.balance.balance == 48
+        assert business2.balance.net == 48
+        assert business2.balance.retainer == 12
+        assert business2.balance.available_balance == 36
+        assert len(business2.balance.product_balances) == 1
+
+        assert len(business2.payouts) == 0
+
+        assert len(business2.bp_accounts) == 1
+        assert len(business2.bp_accounts) == len(business2.product_uuids)
+
+        assert len(business2.pop_financial) == 1
+        assert business2.pop_financial[0].payout == business2.balance.payout
+        assert business2.pop_financial[0].net == business2.balance.net
+
+    def test_prebuild_enriched_session_parquet(
+        self,
+        event_report_request,
+        enriched_session_merge,
+        client_no_amm,
+        wall_collection,
+        session_collection,
+        thl_web_rr,
+        session_report_request,
+        user_factory,
+        start,
+        session_factory,
+        product_factory,
+        delete_df_collection,
+        business,
+        mnt_filepath,
+        mnt_gr_api_dir,
+    ):
+
+        delete_df_collection(coll=wall_collection)
+        delete_df_collection(coll=session_collection)
+
+        p1 = product_factory(business=business)
+        p2 = product_factory(business=business)
+
+        for p in [p1, p2]:
+            u = user_factory(product=p)
+            for i in range(50):
+                s = session_factory(
+                    user=u,
+                    wall_count=1,
+                    wall_req_cpi=Decimal("1.00"),
+                    started=start + timedelta(minutes=i, seconds=1),
+                )
+        wall_collection.initial_load(client=None, sync=True)
+        session_collection.initial_load(client=None, sync=True)
+
+        enriched_session_merge.build(
+            client=client_no_amm,
+            session_coll=session_collection,
+            wall_coll=wall_collection,
+            pg_config=thl_web_rr,
+        )
+
+        business.prebuild_enriched_session_parquet(
+            thl_pg_config=thl_web_rr,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            mnt_gr_api=mnt_gr_api_dir,
+            enriched_session=enriched_session_merge,
+        )
+
+        # Now try to read from path
+        df = pd.read_parquet(
+            os.path.join(mnt_gr_api_dir, "pop_session", f"{business.file_key}.parquet")
+        )
+        assert isinstance(df, pd.DataFrame)
+
+    def test_prebuild_enriched_wall_parquet(
+        self,
+        event_report_request,
+        enriched_session_merge,
+        enriched_wall_merge,
+        client_no_amm,
+        wall_collection,
+        session_collection,
+        thl_web_rr,
+        session_report_request,
+        user_factory,
+        start,
+        session_factory,
+        product_factory,
+        delete_df_collection,
+        business,
+        mnt_filepath,
+        mnt_gr_api_dir,
+    ):
+
+        delete_df_collection(coll=wall_collection)
+        delete_df_collection(coll=session_collection)
+
+        p1 = product_factory(business=business)
+        p2 = product_factory(business=business)
+
+        for p in [p1, p2]:
+            u = user_factory(product=p)
+            for i in range(50):
+                s = session_factory(
+                    user=u,
+                    wall_count=1,
+                    wall_req_cpi=Decimal("1.00"),
+                    started=start + timedelta(minutes=i, seconds=1),
+                )
+        wall_collection.initial_load(client=None, sync=True)
+        session_collection.initial_load(client=None, sync=True)
+
+        enriched_wall_merge.build(
+            client=client_no_amm,
+            session_coll=session_collection,
+            wall_coll=wall_collection,
+            pg_config=thl_web_rr,
+        )
+
+        business.prebuild_enriched_wall_parquet(
+            thl_pg_config=thl_web_rr,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            mnt_gr_api=mnt_gr_api_dir,
+            enriched_wall=enriched_wall_merge,
+        )
+
+        # Now try to read from path
+        df = pd.read_parquet(
+            os.path.join(mnt_gr_api_dir, "pop_event", f"{business.file_key}.parquet")
+        )
+        assert isinstance(df, pd.DataFrame)
diff --git a/tests/models/gr/test_team.py b/tests/models/gr/test_team.py
new file mode 100644
index 0000000..d728bbe
--- /dev/null
+++ b/tests/models/gr/test_team.py
@@ -0,0 +1,296 @@
+import os
+from datetime import timedelta
+from decimal import Decimal
+
+import pandas as pd
+
+
+class TestTeam:
+
+    def test_init(self, team):
+        from generalresearch.models.gr.team import Team
+
+        assert isinstance(team, Team)
+        assert isinstance(team.id, int)
+        assert isinstance(team.uuid, str)
+
+    def test_memberships_none(self, team, gr_user_factory, gr_db):
+        assert team.memberships is None
+
+        team.prefetch_memberships(pg_config=gr_db)
+        assert isinstance(team.memberships, list)
+        assert len(team.memberships) == 0
+
+    def test_memberships(
+        self,
+        team,
+        membership,
+        gr_user,
+        gr_user_factory,
+        membership_factory,
+        membership_manager,
+        gr_db,
+    ):
+        assert 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
+
+        # 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
+
+    def test_gr_users(
+        self, team, gr_user_factory, membership_manager, gr_db, gr_redis_config
+    ):
+        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) == 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
+
+        # 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
+
+    def test_businesses(self, team, business, team_manager, gr_db, gr_redis_config):
+        from generalresearch.models.gr.business import Business
+
+        assert 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
+
+        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
+
+    def test_products(self, team, product_factory, thl_web_rr):
+        from generalresearch.models.thl.product import Product
+
+        assert team.products is None
+
+        team.prefetch_products(thl_pg_config=thl_web_rr)
+        assert isinstance(team.products, list)
+        assert len(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)
+
+
+class TestTeamMethods:
+
+    def test_cache_key(self, team, gr_redis):
+        assert isinstance(team.cache_key, str)
+        assert ":" in team.cache_key
+        assert str(team.uuid) in team.cache_key
+
+    def test_set_cache(
+        self,
+        team,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        gr_redis_config,
+        client_no_amm,
+        mnt_filepath,
+        mnt_gr_api_dir,
+        enriched_wall_merge,
+        enriched_session_merge,
+    ):
+        assert gr_redis.get(name=team.cache_key) is None
+
+        team.set_cache(
+            pg_config=gr_db,
+            thl_web_rr=thl_web_rr,
+            redis_config=gr_redis_config,
+            client=client_no_amm,
+            ds=mnt_filepath,
+            mnt_gr_api=mnt_gr_api_dir,
+            enriched_wall=enriched_wall_merge,
+            enriched_session=enriched_session_merge,
+        )
+
+        assert gr_redis.hgetall(name=team.cache_key) is not None
+
+    def test_set_cache_team(
+        self,
+        gr_user,
+        gr_user_token,
+        gr_redis,
+        gr_db,
+        thl_web_rr,
+        product_factory,
+        team,
+        membership_factory,
+        gr_redis_config,
+        client_no_amm,
+        mnt_filepath,
+        mnt_gr_api_dir,
+        enriched_wall_merge,
+        enriched_session_merge,
+    ):
+        from generalresearch.models.gr.team import Team
+
+        p1 = product_factory(team=team)
+        membership_factory(team=team, gr_user=gr_user)
+
+        team.set_cache(
+            pg_config=gr_db,
+            thl_web_rr=thl_web_rr,
+            redis_config=gr_redis_config,
+            client=client_no_amm,
+            ds=mnt_filepath,
+            mnt_gr_api=mnt_gr_api_dir,
+            enriched_wall=enriched_wall_merge,
+            enriched_session=enriched_session_merge,
+        )
+
+        team2 = Team.from_redis(
+            uuid=team.uuid,
+            fields=["id", "memberships", "gr_users", "businesses", "products"],
+            gr_redis_config=gr_redis_config,
+        )
+
+        assert 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]
+
+    def test_prebuild_enriched_session_parquet(
+        self,
+        event_report_request,
+        enriched_session_merge,
+        client_no_amm,
+        wall_collection,
+        session_collection,
+        thl_web_rr,
+        session_report_request,
+        user_factory,
+        start,
+        session_factory,
+        product_factory,
+        delete_df_collection,
+        business,
+        mnt_filepath,
+        mnt_gr_api_dir,
+        team,
+    ):
+
+        delete_df_collection(coll=wall_collection)
+        delete_df_collection(coll=session_collection)
+
+        p1 = product_factory(team=team)
+        p2 = product_factory(team=team)
+
+        for p in [p1, p2]:
+            u = user_factory(product=p)
+            for i in range(50):
+                s = session_factory(
+                    user=u,
+                    wall_count=1,
+                    wall_req_cpi=Decimal("1.00"),
+                    started=start + timedelta(minutes=i, seconds=1),
+                )
+        wall_collection.initial_load(client=None, sync=True)
+        session_collection.initial_load(client=None, sync=True)
+
+        enriched_session_merge.build(
+            client=client_no_amm,
+            session_coll=session_collection,
+            wall_coll=wall_collection,
+            pg_config=thl_web_rr,
+        )
+
+        team.prebuild_enriched_session_parquet(
+            thl_pg_config=thl_web_rr,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            mnt_gr_api=mnt_gr_api_dir,
+            enriched_session=enriched_session_merge,
+        )
+
+        # Now try to read from path
+        df = pd.read_parquet(
+            os.path.join(mnt_gr_api_dir, "pop_session", f"{team.file_key}.parquet")
+        )
+        assert isinstance(df, pd.DataFrame)
+
+    def test_prebuild_enriched_wall_parquet(
+        self,
+        event_report_request,
+        enriched_session_merge,
+        enriched_wall_merge,
+        client_no_amm,
+        wall_collection,
+        session_collection,
+        thl_web_rr,
+        session_report_request,
+        user_factory,
+        start,
+        session_factory,
+        product_factory,
+        delete_df_collection,
+        business,
+        mnt_filepath,
+        mnt_gr_api_dir,
+        team,
+    ):
+
+        delete_df_collection(coll=wall_collection)
+        delete_df_collection(coll=session_collection)
+
+        p1 = product_factory(team=team)
+        p2 = product_factory(team=team)
+
+        for p in [p1, p2]:
+            u = user_factory(product=p)
+            for i in range(50):
+                s = session_factory(
+                    user=u,
+                    wall_count=1,
+                    wall_req_cpi=Decimal("1.00"),
+                    started=start + timedelta(minutes=i, seconds=1),
+                )
+        wall_collection.initial_load(client=None, sync=True)
+        session_collection.initial_load(client=None, sync=True)
+
+        enriched_wall_merge.build(
+            client=client_no_amm,
+            session_coll=session_collection,
+            wall_coll=wall_collection,
+            pg_config=thl_web_rr,
+        )
+
+        team.prebuild_enriched_wall_parquet(
+            thl_pg_config=thl_web_rr,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            mnt_gr_api=mnt_gr_api_dir,
+            enriched_wall=enriched_wall_merge,
+        )
+
+        # Now try to read from path
+        df = pd.read_parquet(
+            os.path.join(mnt_gr_api_dir, "pop_event", f"{team.file_key}.parquet")
+        )
+        assert isinstance(df, pd.DataFrame)
diff --git a/tests/models/innovate/__init__.py b/tests/models/innovate/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/innovate/__init__.py
diff --git a/tests/models/innovate/test_question.py b/tests/models/innovate/test_question.py
new file mode 100644
index 0000000..330f919
--- /dev/null
+++ b/tests/models/innovate/test_question.py
@@ -0,0 +1,85 @@
+from generalresearch.models import Source
+from generalresearch.models.innovate.question import (
+    InnovateQuestion,
+    InnovateQuestionType,
+    InnovateQuestionOption,
+)
+from generalresearch.models.thl.profiling.upk_question import (
+    UpkQuestionSelectorTE,
+    UpkQuestion,
+    UpkQuestionSelectorMC,
+    UpkQuestionType,
+    UpkQuestionChoice,
+)
+
+
+class TestInnovateQuestion:
+
+    def test_text_entry(self):
+
+        q = InnovateQuestion(
+            question_id="3",
+            country_iso="us",
+            language_iso="eng",
+            question_key="ZIPCODES",
+            question_text="postal code",
+            question_type=InnovateQuestionType.TEXT_ENTRY,
+            tags=None,
+            options=None,
+            is_live=True,
+            category_id=None,
+        )
+        assert Source.INNOVATE == q.source
+        assert "i:zipcodes" == q.external_id
+        assert "zipcodes" == q.internal_id
+        assert ("zipcodes", "us", "eng") == q._key
+
+        upk = q.to_upk_question()
+        expected_upk = UpkQuestion(
+            ext_question_id="i:zipcodes",
+            type=UpkQuestionType.TEXT_ENTRY,
+            country_iso="us",
+            language_iso="eng",
+            text="postal code",
+            selector=UpkQuestionSelectorTE.SINGLE_LINE,
+            choices=None,
+        )
+        assert expected_upk == upk
+
+    def test_mc(self):
+
+        text = "Have you purchased or received any of the following in past 18 months?"
+        q = InnovateQuestion(
+            question_key="dynamic_profiling-_1_14715",
+            country_iso="us",
+            language_iso="eng",
+            question_id="14715",
+            question_text=text,
+            question_type=InnovateQuestionType.MULTI_SELECT,
+            tags="Dynamic Profiling- 1",
+            options=[
+                InnovateQuestionOption(id="1", text="aaa", order=0),
+                InnovateQuestionOption(id="2", text="bbb", order=1),
+            ],
+            is_live=True,
+            category_id=None,
+        )
+        assert "i:dynamic_profiling-_1_14715" == q.external_id
+        assert "dynamic_profiling-_1_14715" == q.internal_id
+        assert ("dynamic_profiling-_1_14715", "us", "eng") == q._key
+        assert 2 == q.num_options
+
+        upk = q.to_upk_question()
+        expected_upk = UpkQuestion(
+            ext_question_id="i:dynamic_profiling-_1_14715",
+            type=UpkQuestionType.MULTIPLE_CHOICE,
+            country_iso="us",
+            language_iso="eng",
+            text=text,
+            selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+            choices=[
+                UpkQuestionChoice(id="1", text="aaa", order=0),
+                UpkQuestionChoice(id="2", text="bbb", order=1),
+            ],
+        )
+        assert expected_upk == upk
diff --git a/tests/models/legacy/__init__.py b/tests/models/legacy/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/legacy/__init__.py
diff --git a/tests/models/legacy/data.py b/tests/models/legacy/data.py
new file mode 100644
index 0000000..20f3231
--- /dev/null
+++ b/tests/models/legacy/data.py
@@ -0,0 +1,265 @@
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/45b7228a7/?bpuid=379fb74f-05b2-42dc-b283
+# -47e1c8678b04&duration=1200&format=json&country_iso=us
+RESPONSE_45b7228a7 = (
+    '{"info": {"success": true}, "offerwall": {"availability_count": 9, "buckets": [{"category": [{"adwords_id": '
+    'null, "adwords_label": null, "id": "c82cf98c578a43218334544ab376b00e", "label": "Social Research", "p": 1.0}], '
+    '"description": "", "duration": {"max": 719, "min": 72, "q1": 144, "q2": 621, "q3": 650}, '
+    '"id": "5503c471d95645dd947080704d3760b3", "name": "", "payout": {"max": 132, "min": 68, "q1": 113, "q2": 124, '
+    '"q3": 128}, "quality_score": 1.0, "uri": '
+    '"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=5503c471d95645dd947080704d3760b3&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=16fa868", "x": 0, "y": 0}, '
+    '{"category": [{"adwords_id": null, "adwords_label": null, "id": "c82cf98c578a43218334544ab376b00e", '
+    '"label": "Social Research", "p": 0.6666666666666666}, {"adwords_id": "5000", "adwords_label": "World '
+    'Localities", "id": "cd3f9374ba5d4e5692ee5691320ecc8b", "label": "World Localities", "p": 0.16666666666666666}, '
+    '{"adwords_id": "14", "adwords_label": "People & Society", "id": "c8642a1b86d9460cbe8f7e8ae6e56ee4", '
+    '"label": "People & Society", "p": 0.16666666666666666}], "description": "", "duration": {"max": 1180, '
+    '"min": 144, "q1": 457, "q2": 621, "q3": 1103}, "id": "56f437aa5da443748872390a5cbf6103", "name": "", "payout": {'
+    '"max": 113, "min": 24, "q1": 40, "q2": 68, "q3": 68}, "quality_score": 0.17667012, '
+    '"uri": "https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=56f437aa5da443748872390a5cbf6103&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=16fa868", "x": 1, "y": 0}, '
+    '{"category": [{"adwords_id": null, "adwords_label": null, "id": "c82cf98c578a43218334544ab376b00e", '
+    '"label": "Social Research", "p": 0.6666666666666666}, {"adwords_id": "5000", "adwords_label": "World '
+    'Localities", "id": "cd3f9374ba5d4e5692ee5691320ecc8b", "label": "World Localities", "p": 0.16666666666666666}, '
+    '{"adwords_id": "14", "adwords_label": "People & Society", "id": "c8642a1b86d9460cbe8f7e8ae6e56ee4", '
+    '"label": "People & Society", "p": 0.16666666666666666}], "description": "", "duration": {"max": 1180, '
+    '"min": 144, "q1": 457, "q2": 1103, "q3": 1128}, "id": "a5b8403e4a4a4ed1a21ef9b3a721ab02", "name": "", '
+    '"payout": {"max": 68, "min": 14, "q1": 24, "q2": 40, "q3": 68}, "quality_score": 0.01, '
+    '"uri": "https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=a5b8403e4a4a4ed1a21ef9b3a721ab02&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=16fa868", "x": 2, "y": 0}], '
+    '"id": "2fba2999baf0423cad0c49eceea4eb33", "payout_format": "${payout/100:.2f}"}}'
+)
+
+RESPONSE_b145b803 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":10,"buckets":[{"category":[{"adwords_id":null,'
+    '"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research","p":1.0}],"contents":[{'
+    '"id":"b9d6fdb95ae2402dbb8e8673be382f04","id_code":"m:b9d6fdb95ae2402dbb8e8673be382f04","loi":954,"payout":166,'
+    '"source":"m"},{"id":"x94r9bg","id_code":"o:x94r9bg","loi":71,"payout":132,"source":"o"},{"id":"ejqjbv4",'
+    '"id_code":"o:ejqjbv4","loi":650,"payout":128,"source":"o"},{"id":"yxqdnb9","id_code":"o:yxqdnb9","loi":624,'
+    '"payout":113,"source":"o"},{"id":"vyjrv0v","id_code":"o:vyjrv0v","loi":719,"payout":124,"source":"o"}],'
+    '"currency":"USD","description":"","duration":{"max":954,"min":72,"q1":625,"q2":650,"q3":719},'
+    '"id":"c190231a7d494012a2f641a89a85e6a6","name":"","payout":{"max":166,"min":113,"q1":124,"q2":128,"q3":132},'
+    '"quality_score":1.0,"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120'
+    '/?i=c190231a7d494012a2f641a89a85e6a6&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=9dbbf8c","x":0,"y":0},'
+    '{"category":[{"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social '
+    'Research","p":0.5},{"adwords_id":"5000","adwords_label":"World Localities",'
+    '"id":"cd3f9374ba5d4e5692ee5691320ecc8b","label":"World Localities","p":0.25},{"adwords_id":"14",'
+    '"adwords_label":"People & Society","id":"c8642a1b86d9460cbe8f7e8ae6e56ee4","label":"People & Society",'
+    '"p":0.25}],"contents":[{"id":"ejqa3kw","id_code":"o:ejqa3kw","loi":143,"payout":68,"source":"o"},'
+    '{"id":"g6xkrbm","id_code":"o:g6xkrbm","loi":536,"payout":68,"source":"o"},{"id":"yr5od0g","id_code":"o:yr5od0g",'
+    '"loi":457,"payout":68,"source":"o"}],"currency":"USD","description":"","duration":{"max":537,"min":144,"q1":301,'
+    '"q2":457,"q3":497},"id":"ee12be565f744ef2b194703f3d32f8cd","name":"","payout":{"max":68,"min":68,"q1":68,'
+    '"q2":68,"q3":68},"quality_score":0.01,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=ee12be565f744ef2b194703f3d32f8cd&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=9dbbf8c","x":1,"y":0},'
+    '{"category":[{"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social '
+    'Research","p":1.0}],"contents":[{"id":"a019660a8bc0411dba19a3e5c5df5b6c",'
+    '"id_code":"m:a019660a8bc0411dba19a3e5c5df5b6c","loi":1180,"payout":24,"source":"m"},{"id":"ejqa3kw",'
+    '"id_code":"o:ejqa3kw","loi":143,"payout":68,"source":"o"},{"id":"8c54725047cc4e0590665a034d37e7f5",'
+    '"id_code":"m:8c54725047cc4e0590665a034d37e7f5","loi":1128,"payout":14,"source":"m"}],"currency":"USD",'
+    '"description":"","duration":{"max":1180,"min":144,"q1":636,"q2":1128,"q3":1154},'
+    '"id":"dc2551eb48d84b329fdcb5b2bd60ed71","name":"","payout":{"max":68,"min":14,"q1":19,"q2":24,"q3":46},'
+    '"quality_score":0.06662835156312356,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=dc2551eb48d84b329fdcb5b2bd60ed71&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=9dbbf8c","x":2,"y":0}],'
+    '"id":"7cb9eb4c1a5b41a38cfebd13c9c338cb"}}'
+)
+
+# This is a blocked user. Otherwise, the format is identical to RESPONSE_b145b803
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/1e5f0af8/?bpuid=00051c62-a872-4832-a008
+# -c37ec51d33d3&duration=1200&format=json&country_iso=us
+RESPONSE_d48cce47 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":0,"buckets":[],'
+    '"id":"168680387a7f4c8c9cc8e7ab63f502ff","payout_format":"${payout/100:.2f}"}}'
+)
+
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/1e5f0af8/?bpuid=379fb74f-05b2-42dc-b283
+# -47e1c8678b04&duration=1200&format=json&country_iso=us
+RESPONSE_1e5f0af8 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":9,"buckets":[{"category":[{"adwords_id":null,'
+    '"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research","p":1.0}],"contents":[{'
+    '"id":"x94r9bg","id_code":"o:x94r9bg","loi":71,"payout":132,"source":"o"},{"id":"yxqdnb9","id_code":"o:yxqdnb9",'
+    '"loi":604,"payout":113,"source":"o"},{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":473,"payout":128,"source":"o"},'
+    '{"id":"vyjrv0v","id_code":"o:vyjrv0v","loi":719,"payout":124,"source":"o"}],"currency":"USD","description":"",'
+    '"duration":{"max":719,"min":72,"q1":373,"q2":539,"q3":633},"id":"2a4a897a76464af2b85703b72a125da0",'
+    '"is_recontact":false,"name":"","payout":{"max":132,"min":113,"q1":121,"q2":126,"q3":129},"quality_score":1.0,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=2a4a897a76464af2b85703b72a125da0&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=82fe142","x":0,"y":0},'
+    '{"category":[{"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social '
+    'Research","p":0.5},{"adwords_id":"5000","adwords_label":"World Localities",'
+    '"id":"cd3f9374ba5d4e5692ee5691320ecc8b","label":"World Localities","p":0.25},{"adwords_id":"14",'
+    '"adwords_label":"People & Society","id":"c8642a1b86d9460cbe8f7e8ae6e56ee4","label":"People & Society",'
+    '"p":0.25}],"contents":[{"id":"775ed98f65604dac91b3a60814438829","id_code":"m:775ed98f65604dac91b3a60814438829",'
+    '"loi":1121,"payout":32,"source":"m"},{"id":"ejqa3kw","id_code":"o:ejqa3kw","loi":143,"payout":68,"source":"o"},'
+    '{"id":"yr5od0g","id_code":"o:yr5od0g","loi":457,"payout":68,"source":"o"}],"currency":"USD","description":"",'
+    '"duration":{"max":1121,"min":144,"q1":301,"q2":457,"q3":789},"id":"0aa83eb711c042e28bb9284e604398ac",'
+    '"is_recontact":false,"name":"","payout":{"max":68,"min":32,"q1":50,"q2":68,"q3":68},"quality_score":0.01,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=0aa83eb711c042e28bb9284e604398ac&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=82fe142","x":1,"y":0},'
+    '{"category":[{"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social '
+    'Research","p":1.0}],"contents":[{"id":"775ed98f65604dac91b3a60814438829",'
+    '"id_code":"m:775ed98f65604dac91b3a60814438829","loi":1121,"payout":32,"source":"m"},'
+    '{"id":"8c54725047cc4e0590665a034d37e7f5","id_code":"m:8c54725047cc4e0590665a034d37e7f5","loi":1128,"payout":14,'
+    '"source":"m"},{"id":"a019660a8bc0411dba19a3e5c5df5b6c","id_code":"m:a019660a8bc0411dba19a3e5c5df5b6c",'
+    '"loi":1180,"payout":24,"source":"m"}],"currency":"USD","description":"","duration":{"max":1180,"min":1121,'
+    '"q1":1125,"q2":1128,"q3":1154},"id":"d3a87b2bb6cf4428a55916bdf65e775e","is_recontact":false,"name":"",'
+    '"payout":{"max":32,"min":14,"q1":19,"q2":24,"q3":28},"quality_score":0.0825688889614345,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=d3a87b2bb6cf4428a55916bdf65e775e&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=82fe142","x":2,"y":0}],'
+    '"id":"391a54bbe84c4dbfa50b40841201a606"}}'
+)
+
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/5fl8bpv5/?bpuid=379fb74f-05b2-42dc-b283
+# -47e1c8678b04&duration=1200&format=json&country_iso=us
+RESPONSE_5fl8bpv5 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":9,"buckets":[{'
+    '"id":"a1097b20f2ae472a9a9ad2987ba3bf95",'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=a1097b20f2ae472a9a9ad2987ba3bf95&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e7baf5e"}],'
+    '"id":"fddaa544d7ff428a8ccccd0667fdc249","payout_format":"${payout/100:.2f}"}}'
+)
+
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/37d1da64/?bpuid=379fb74f-05b2-42dc-b283
+# -47e1c8678b04&duration=1200&format=json&country_iso=us
+RESPONSE_37d1da64 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":18,"buckets":[{"category":[{"adwords_id":null,'
+    '"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research","p":1.0}],"contents":[{'
+    '"id":"0qvwx4z","id_code":"o:0qvwx4z","loi":700,"payout":106,"source":"o"},{"id":"x94r9bg","id_code":"o:x94r9bg",'
+    '"loi":72,"payout":132,"source":"o"},{"id":"yxqdnb9","id_code":"o:yxqdnb9","loi":605,"payout":113,"source":"o"},'
+    '{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":474,"payout":128,"source":"o"}],"eligibility":"conditional",'
+    '"id":"2cfc47e8d8c4417cb1f499dbf7e9afb8","loi":700,"missing_questions":["7ca8b59f4c864f80a1a7c7287adfc637"],'
+    '"payout":106,"uri":null},{"category":[{"adwords_id":null,"adwords_label":null,'
+    '"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research","p":1.0}],"contents":[{"id":"yxqdnb9",'
+    '"id_code":"o:yxqdnb9","loi":605,"payout":113,"source":"o"},{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,'
+    '"payout":132,"source":"o"},{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":474,"payout":128,"source":"o"}],'
+    '"eligibility":"unconditional","id":"8964a87ebbe9433cae0ddce1b34a637a","loi":605,"payout":113,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=8964a87ebbe9433cae0ddce1b34a637a&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=ec8aa9a"},{"category":[{'
+    '"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research",'
+    '"p":1.0}],"contents":[{"id":"a019660a8bc0411dba19a3e5c5df5b6c","id_code":"m:a019660a8bc0411dba19a3e5c5df5b6c",'
+    '"loi":1180,"payout":24,"source":"m"},{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},'
+    '{"id":"yxqdnb9","id_code":"o:yxqdnb9","loi":605,"payout":113,"source":"o"},'
+    '{"id":"775ed98f65604dac91b3a60814438829","id_code":"m:775ed98f65604dac91b3a60814438829","loi":1121,"payout":32,'
+    '"source":"m"},{"id":"ejqa3kw","id_code":"o:ejqa3kw","loi":144,"payout":68,"source":"o"},{"id":"ejqjbv4",'
+    '"id_code":"o:ejqjbv4","loi":474,"payout":128,"source":"o"},{"id":"yr5od0g","id_code":"o:yr5od0g","loi":457,'
+    '"payout":68,"source":"o"},{"id":"vyjrv0v","id_code":"o:vyjrv0v","loi":719,"payout":124,"source":"o"}],'
+    '"eligibility":"unconditional","id":"ba98df6041344e818f02873534ae09a3","loi":1180,"payout":24,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=ba98df6041344e818f02873534ae09a3&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=ec8aa9a"},{"category":[{'
+    '"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research",'
+    '"p":1.0}],"contents":[{"id":"775ed98f65604dac91b3a60814438829","id_code":"m:775ed98f65604dac91b3a60814438829",'
+    '"loi":1121,"payout":32,"source":"m"},{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},'
+    '{"id":"yxqdnb9","id_code":"o:yxqdnb9","loi":605,"payout":113,"source":"o"},{"id":"ejqa3kw",'
+    '"id_code":"o:ejqa3kw","loi":144,"payout":68,"source":"o"},{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":474,'
+    '"payout":128,"source":"o"},{"id":"yr5od0g","id_code":"o:yr5od0g","loi":457,"payout":68,"source":"o"},'
+    '{"id":"vyjrv0v","id_code":"o:vyjrv0v","loi":719,"payout":124,"source":"o"}],"eligibility":"unconditional",'
+    '"id":"6456abe0f2584be8a30d9e0e93bef496","loi":1121,"payout":32,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=6456abe0f2584be8a30d9e0e93bef496&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=ec8aa9a"},{"category":[{'
+    '"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research",'
+    '"p":1.0}],"contents":[{"id":"ejqa3kw","id_code":"o:ejqa3kw","loi":144,"payout":68,"source":"o"},{"id":"x94r9bg",'
+    '"id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,'
+    '"payout":132,"source":"o"}],"eligibility":"unconditional","id":"e0a0fb27bf174040be7971795a967ce5","loi":144,'
+    '"payout":68,"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=e0a0fb27bf174040be7971795a967ce5&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=ec8aa9a"},{"category":[{'
+    '"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research",'
+    '"p":1.0}],"contents":[{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":474,"payout":128,"source":"o"},'
+    '{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},{"id":"x94r9bg","id_code":"o:x94r9bg",'
+    '"loi":72,"payout":132,"source":"o"}],"eligibility":"unconditional","id":"99e3f8cfd367411b822cf11c3b54b558",'
+    '"loi":474,"payout":128,"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709'
+    "/00ff1d9b71b94bf4b20d22cd56774120/?i=99e3f8cfd367411b822cf11c3b54b558&b=379fb74f-05b2-42dc-b283-47e1c8678b04"
+    '&66482fb=ec8aa9a"},{"category":[{"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e",'
+    '"label":"Social Research","p":1.0}],"contents":[{"id":"8c54725047cc4e0590665a034d37e7f5",'
+    '"id_code":"m:8c54725047cc4e0590665a034d37e7f5","loi":1128,"payout":14,"source":"m"},{"id":"x94r9bg",'
+    '"id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},{"id":"yxqdnb9","id_code":"o:yxqdnb9","loi":605,'
+    '"payout":113,"source":"o"},{"id":"775ed98f65604dac91b3a60814438829",'
+    '"id_code":"m:775ed98f65604dac91b3a60814438829","loi":1121,"payout":32,"source":"m"},{"id":"ejqa3kw",'
+    '"id_code":"o:ejqa3kw","loi":144,"payout":68,"source":"o"},{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":474,'
+    '"payout":128,"source":"o"},{"id":"yr5od0g","id_code":"o:yr5od0g","loi":457,"payout":68,"source":"o"},'
+    '{"id":"vyjrv0v","id_code":"o:vyjrv0v","loi":719,"payout":124,"source":"o"}],"eligibility":"unconditional",'
+    '"id":"db7bc77afbb6443e8f35e9f06764fd06","loi":1128,"payout":14,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=db7bc77afbb6443e8f35e9f06764fd06&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=ec8aa9a"},{"category":[{'
+    '"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research",'
+    '"p":0.5},{"adwords_id":"5000","adwords_label":"World Localities","id":"cd3f9374ba5d4e5692ee5691320ecc8b",'
+    '"label":"World Localities","p":0.25},{"adwords_id":"14","adwords_label":"People & Society",'
+    '"id":"c8642a1b86d9460cbe8f7e8ae6e56ee4","label":"People & Society","p":0.25}],"contents":[{"id":"yr5od0g",'
+    '"id_code":"o:yr5od0g","loi":457,"payout":68,"source":"o"},{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,'
+    '"payout":132,"source":"o"},{"id":"ejqa3kw","id_code":"o:ejqa3kw","loi":144,"payout":68,"source":"o"}],'
+    '"eligibility":"unconditional","id":"d5af3c782a354d6a8616e47531eb15e7","loi":457,"payout":68,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=d5af3c782a354d6a8616e47531eb15e7&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=ec8aa9a"},{"category":[{'
+    '"adwords_id":null,"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research",'
+    '"p":1.0}],"contents":[{"id":"vyjrv0v","id_code":"o:vyjrv0v","loi":719,"payout":124,"source":"o"},'
+    '{"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},{"id":"ejqjbv4","id_code":"o:ejqjbv4",'
+    '"loi":474,"payout":128,"source":"o"}],"eligibility":"unconditional","id":"ceafb146bb7042889b85630a44338a75",'
+    '"loi":719,"payout":124,"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709'
+    "/00ff1d9b71b94bf4b20d22cd56774120/?i=ceafb146bb7042889b85630a44338a75&b=379fb74f-05b2-42dc-b283-47e1c8678b04"
+    '&66482fb=ec8aa9a"}],"id":"37ed0858e0f64329812e2070fb658eb3","question_info":{'
+    '"7ca8b59f4c864f80a1a7c7287adfc637":{"choices":[{"choice_id":"0","choice_text":"Single, never married",'
+    '"order":0},{"choice_id":"1","choice_text":"Living with a Partner","order":1},{"choice_id":"2",'
+    '"choice_text":"Civil Union / Domestic Partnership","order":2},{"choice_id":"3","choice_text":"Married",'
+    '"order":3},{"choice_id":"4","choice_text":"Separated","order":4},{"choice_id":"5","choice_text":"Divorced",'
+    '"order":5},{"choice_id":"6","choice_text":"Widowed","order":6}],"country_iso":"us","language_iso":"eng",'
+    '"question_id":"7ca8b59f4c864f80a1a7c7287adfc637","question_text":"What is your relationship status?",'
+    '"question_type":"MC","selector":"SA"}}}}'
+)
+
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/5fa23085/?bpuid=379fb74f-05b2-42dc-b283
+# -47e1c8678b04&duration=1200&format=json&country_iso=us
+RESPONSE_5fa23085 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":7,"buckets":[{"category":[{"adwords_id":null,'
+    '"adwords_label":null,"id":"c82cf98c578a43218334544ab376b00e","label":"Social Research","p":0.6666666666666666},'
+    '{"adwords_id":"5000","adwords_label":"World Localities","id":"cd3f9374ba5d4e5692ee5691320ecc8b","label":"World '
+    'Localities","p":0.16666666666666666},{"adwords_id":"14","adwords_label":"People & Society",'
+    '"id":"c8642a1b86d9460cbe8f7e8ae6e56ee4","label":"People & Society","p":0.16666666666666666}],"contents":[{'
+    '"id":"x94r9bg","id_code":"o:x94r9bg","loi":72,"payout":132,"source":"o"},{"id":"yxqdnb9","id_code":"o:yxqdnb9",'
+    '"loi":605,"payout":113,"source":"o"},{"id":"ejqjbv4","id_code":"o:ejqjbv4","loi":640,"payout":128,"source":"o"},'
+    '{"id":"yr5od0g","id_code":"o:yr5od0g","loi":457,"payout":68,"source":"o"},{"id":"vyjrv0v","id_code":"o:vyjrv0v",'
+    '"loi":719,"payout":124,"source":"o"}],"duration":{"max":719,"min":72,"q1":457,"q2":605,"q3":640},'
+    '"id":"30049c28363b4f689c84fbacf1cc57e2","payout":{"max":132,"min":68,"q1":113,"q2":124,"q3":128},'
+    '"source":"pollfish","uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120'
+    '/?i=30049c28363b4f689c84fbacf1cc57e2&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e3c1af1"}],'
+    '"id":"1c33756fd7ca49fa84ee48e42145e68c"}}'
+)
+
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/1705e4f8/?bpuid=379fb74f-05b2-42dc-b283
+# -47e1c8678b04&duration=1200&format=json&country_iso=us
+RESPONSE_1705e4f8 = (
+    '{"info":{"success":true},"offerwall":{"availability_count":7,"buckets":[{"currency":"USD","duration":719,'
+    '"id":"d06abd6ac75b453a93d0e85e4e391c00","min_payout":124,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=d06abd6ac75b453a93d0e85e4e391c00&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":705,"id":"bcf5ca85a4044e9abed163f72039c7d1","min_payout":123,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=bcf5ca85a4044e9abed163f72039c7d1&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":679,"id":"b85034bd59e04a64ac1be7686a4c906d","min_payout":121,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=b85034bd59e04a64ac1be7686a4c906d&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":1180,"id":"324cf03b9ba24ef19284683bf9b62afb","min_payout":24,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=324cf03b9ba24ef19284683bf9b62afb&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":1062,"id":"6bbbef3157c346009e677e556ecea7e7","min_payout":17,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=6bbbef3157c346009e677e556ecea7e7&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":1128,"id":"bc12ba86b5024cf5b8ade997415190f7","min_payout":14,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=bc12ba86b5024cf5b8ade997415190f7&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":1126,"id":"e574e715dcc744dbacf84a8426a0cd37","min_payout":10,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=e574e715dcc744dbacf84a8426a0cd37&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":1302,"id":"a6f562e3371347d19d281d40b3ca317d","min_payout":10,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=a6f562e3371347d19d281d40b3ca317d&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"},{"currency":"USD",'
+    '"duration":953,"id":"462c8e1fbdad475792a360097c8e740f","min_payout":4,'
+    '"uri":"https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i'
+    '=462c8e1fbdad475792a360097c8e740f&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=e09baa2"}],'
+    '"id":"7f5158dc25174ada89f54e2b26a61b20"}}'
+)
+
+# Blocked user
+# https://fsb.generalresearch.com/00ff1d9b71b94bf4b20d22cd56774120/offerwall/0af0f7ec/?bpuid=00051c62-a872-4832-a008
+# -c37ec51d33d3&duration=1200&format=json&country_iso=us
+RESPONSE_0af0f7ec = (
+    '{"info":{"success":true},"offerwall":{"availability_count":0,"buckets":[],'
+    '"id":"34e71f4ccdec47b3b0991f5cfda60238","payout_format":"${payout/100:.2f}"}}'
+)
diff --git a/tests/models/legacy/test_offerwall_parse_response.py b/tests/models/legacy/test_offerwall_parse_response.py
new file mode 100644
index 0000000..7fb5315
--- /dev/null
+++ b/tests/models/legacy/test_offerwall_parse_response.py
@@ -0,0 +1,186 @@
+import json
+
+from generalresearch.models import Source
+from generalresearch.models.legacy.bucket import (
+    TopNPlusBucket,
+    SurveyEligibilityCriterion,
+    DurationSummary,
+    PayoutSummary,
+    BucketTask,
+)
+
+
+class TestOfferwallTopNAndStarwall:
+    def test_45b7228a7(self):
+        from generalresearch.models.legacy.offerwall import (
+            TopNOfferWall,
+            TopNOfferWallResponse,
+            StarwallOfferWallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_45b7228a7,
+        )
+
+        res = json.loads(RESPONSE_45b7228a7)
+        assert TopNOfferWallResponse.model_validate(res)
+        offerwall = TopNOfferWall.model_validate(res["offerwall"])
+        assert offerwall
+        offerwall.censor()
+        # Format is identical to starwall
+        assert StarwallOfferWallResponse.model_validate(res)
+
+    def test_b145b803(self):
+        from generalresearch.models.legacy.offerwall import (
+            TopNPlusOfferWallResponse,
+            StarwallPlusOfferWallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_b145b803,
+        )
+
+        res = json.loads(RESPONSE_b145b803)
+        assert TopNPlusOfferWallResponse.model_validate(res)
+        assert StarwallPlusOfferWallResponse.model_validate(res)
+
+    def test_d48cce47(self):
+        from generalresearch.models.legacy.offerwall import (
+            TopNPlusBlockOfferWallResponse,
+            StarwallPlusBlockOfferWallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_b145b803,
+            RESPONSE_d48cce47,
+        )
+
+        res = json.loads(RESPONSE_d48cce47)  # this is a blocked user's response
+        assert TopNPlusBlockOfferWallResponse.model_validate(res)
+        assert StarwallPlusBlockOfferWallResponse.model_validate(res)
+        # otherwise it is identical to the plus's response
+        res = json.loads(RESPONSE_b145b803)
+        assert TopNPlusBlockOfferWallResponse.model_validate(res)
+        assert StarwallPlusBlockOfferWallResponse.model_validate(res)
+
+    def test_1e5f0af8(self):
+        from generalresearch.models.legacy.offerwall import (
+            TopNPlusBlockRecontactOfferWallResponse,
+            StarwallPlusBlockRecontactOfferWallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_d48cce47,
+            RESPONSE_1e5f0af8,
+        )
+
+        res = json.loads(RESPONSE_1e5f0af8)
+        assert TopNPlusBlockRecontactOfferWallResponse.model_validate(res)
+        assert StarwallPlusBlockRecontactOfferWallResponse.model_validate(res)
+
+        res = json.loads(RESPONSE_d48cce47)  # this is a blocked user's response
+        assert TopNPlusBlockRecontactOfferWallResponse.model_validate(res)
+        assert StarwallPlusBlockRecontactOfferWallResponse.model_validate(res)
+
+    def test_eligibility_criteria(self):
+        b = TopNPlusBucket(
+            id="c82cf98c578a43218334544ab376b00e",
+            contents=[
+                BucketTask(
+                    id="12345",
+                    payout=10,
+                    source=Source.TESTING,
+                    id_code="t:12345",
+                    loi=120,
+                )
+            ],
+            duration=DurationSummary(max=1, min=1, q1=1, q2=1, q3=1),
+            quality_score=1,
+            payout=PayoutSummary(max=1, min=1, q1=1, q2=1, q3=1),
+            uri="https://task.generalresearch.com/api/v1/52d3f63b2709/00ff1d9b71b94bf4b20d22cd56774120/?i=2a4a897a76464af2b85703b72a125da0&b=379fb74f-05b2-42dc-b283-47e1c8678b04&66482fb=82fe142",
+            eligibility_criteria=(
+                SurveyEligibilityCriterion(
+                    question_id="71a367fb71b243dc89f0012e0ec91749",
+                    question_text="what is something",
+                    qualifying_answer=("1",),
+                    qualifying_answer_label=("abc",),
+                    property_code="t:123",
+                ),
+                SurveyEligibilityCriterion(
+                    question_id="81a367fb71b243dc89f0012e0ec91749",
+                    question_text="what is something 2",
+                    qualifying_answer=("2",),
+                    qualifying_answer_label=("ddd",),
+                    property_code="t:124",
+                ),
+            ),
+        )
+        assert b.eligibility_criteria[0].rank == 0
+        assert b.eligibility_criteria[1].rank == 1
+        print(b.model_dump_json())
+        b.censor()
+        print(b.model_dump_json())
+
+
+class TestOfferwallSingle:
+    def test_5fl8bpv5(self):
+        from generalresearch.models.legacy.offerwall import (
+            SingleEntryOfferWallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_5fl8bpv5,
+        )
+
+        res = json.loads(RESPONSE_5fl8bpv5)
+        assert SingleEntryOfferWallResponse.model_validate(res)
+
+
+class TestOfferwallSoftPair:
+    def test_37d1da64(self):
+        from generalresearch.models.legacy.offerwall import (
+            SoftPairOfferwallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_37d1da64,
+        )
+
+        res = json.loads(RESPONSE_37d1da64)
+        assert SoftPairOfferwallResponse.model_validate(res)
+
+
+class TestMarketplace:
+    def test_5fa23085(self):
+        from generalresearch.models.legacy.offerwall import (
+            MarketplaceOfferwallResponse,
+        )
+
+        from tests.models.legacy.data import (
+            RESPONSE_5fa23085,
+        )
+
+        res = json.loads(RESPONSE_5fa23085)
+        assert MarketplaceOfferwallResponse.model_validate(res)
+
+
+class TestTimebucks:
+    def test_1705e4f8(self):
+        from generalresearch.models.legacy.offerwall import (
+            TimeBucksOfferwallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_1705e4f8,
+        )
+
+        res = json.loads(RESPONSE_1705e4f8)
+        assert TimeBucksOfferwallResponse.model_validate(res)
+
+    def test_0af0f7ec(self):
+        from generalresearch.models.legacy.offerwall import (
+            TimeBucksBlockOfferwallResponse,
+        )
+        from tests.models.legacy.data import (
+            RESPONSE_1705e4f8,
+            RESPONSE_0af0f7ec,
+        )
+
+        res = json.loads(RESPONSE_0af0f7ec)
+        assert TimeBucksBlockOfferwallResponse.model_validate(res)
+
+        res = json.loads(RESPONSE_1705e4f8)
+        assert TimeBucksBlockOfferwallResponse.model_validate(res)
diff --git a/tests/models/legacy/test_profiling_questions.py b/tests/models/legacy/test_profiling_questions.py
new file mode 100644
index 0000000..1afaa6b
--- /dev/null
+++ b/tests/models/legacy/test_profiling_questions.py
@@ -0,0 +1,81 @@
+class TestUpkQuestionResponse:
+
+    def test_init(self):
+        from generalresearch.models.legacy.questions import UpkQuestionResponse
+
+        s = (
+            '{"status": "success", "count": 7, "questions": [{"selector": "SL", "validation": {"patterns": [{'
+            '"message": "Must input a value between 13 and 120", "pattern": "^(1[01][0-9]|120|1[3-9]|[2-9]['
+            '0-9])$"}]}, "country_iso": "us", "question_id": "c5a4ef644c374f8994ecb3226b84263e", "language_iso": '
+            '"eng", "configuration": {"max_length": 3, "type": "TE"}, "question_text": "What is your age (in '
+            'years)?", "question_type": "TE", "task_score": 20.28987136651298, "task_count": 21131, "p": 1.0}, '
+            '{"choices": [{"order": 0, "choice_id": "0", "choice_text": "Male"}, {"order": 1, "choice_id": "1", '
+            '"choice_text": "Female"}, {"order": 2, "choice_id": "2", "choice_text": "Other"}], "selector": "SA", '
+            '"country_iso": "us", "question_id": "5d6d9f3c03bb40bf9d0a24f306387d7c", "language_iso": "eng", '
+            '"question_text": "What is your gender?", "question_type": "MC", "task_score": 16.598347505339095, '
+            '"task_count": 4842, "p": 0.8180607558081178}, {"choices": [{"order": 0, "choice_id": "ara", '
+            '"choice_text": "Arabic"}, {"order": 1, "choice_id": "zho", "choice_text": "Chinese - Mandarin"}, '
+            '{"order": 2, "choice_id": "dut", "choice_text": "Dutch"}, {"order": 3, "choice_id": "eng", '
+            '"choice_text": "English"}, {"order": 4, "choice_id": "fre", "choice_text": "French"}, {"order": 5, '
+            '"choice_id": "ger", "choice_text": "German"}, {"order": 6, "choice_id": "hat", "choice_text": "Haitian '
+            'Creole"}, {"order": 7, "choice_id": "hin", "choice_text": "Hindi"}, {"order": 8, "choice_id": "ind", '
+            '"choice_text": "Indonesian"}, {"order": 9, "choice_id": "ita", "choice_text": "Italian"}, {"order": 10, '
+            '"choice_id": "jpn", "choice_text": "Japanese"}, {"order": 11, "choice_id": "kor", "choice_text": '
+            '"Korean"}, {"order": 12, "choice_id": "may", "choice_text": "Malay"}, {"order": 13, "choice_id": "pol", '
+            '"choice_text": "Polish"}, {"order": 14, "choice_id": "por", "choice_text": "Portuguese"}, {"order": 15, '
+            '"choice_id": "pan", "choice_text": "Punjabi"}, {"order": 16, "choice_id": "rus", "choice_text": '
+            '"Russian"}, {"order": 17, "choice_id": "spa", "choice_text": "Spanish"}, {"order": 18, "choice_id": '
+            '"tgl", "choice_text": "Tagalog/Filipino"}, {"order": 19, "choice_id": "tur", "choice_text": "Turkish"}, '
+            '{"order": 20, "choice_id": "vie", "choice_text": "Vietnamese"}, {"order": 21, "choice_id": "zul", '
+            '"choice_text": "Zulu"}, {"order": 22, "choice_id": "xxx", "choice_text": "Other"}], "selector": "MA", '
+            '"country_iso": "us", "question_id": "f15663d012244d5fa43f5784f7bd1898", "language_iso": "eng", '
+            '"question_text": "Which language(s) do you speak fluently at home? (Select all that apply)", '
+            '"question_type": "MC", "task_score": 15.835933296975051, "task_count": 147, "p": 0.780484657143325}, '
+            '{"selector": "SL", "validation": {"patterns": [{"message": "Must enter a valid zip code: XXXXX", '
+            '"pattern": "^[0-9]{5}$"}]}, "country_iso": "us", "question_id": "543de254e9ca4d9faded4377edab82a9", '
+            '"language_iso": "eng", "configuration": {"max_length": 5, "min_length": 5, "type": "TE"}, '
+            '"question_text": "What is your zip code?", "question_type": "TE", "task_score": 3.9114103408096685, '
+            '"task_count": 4116, "p": 0.19277649769949645}, {"selector": "SL", "validation": {"patterns": [{'
+            '"message": "Must input digits only (range between 1 and 999999)", "pattern": "^[0-9]{1,6}$"}]}, '
+            '"country_iso": "us", "question_id": "9ffacedc92584215912062a9d75338fa", "language_iso": "eng", '
+            '"configuration": {"max_length": 6, "type": "TE"}, "question_text": "What is your current annual '
+            'household income before taxes (in USD)?", "question_type": "TE", "task_score": 2.4630414657197686, '
+            '"task_count": 3267, "p": 0.12139266046727369}, {"choices": [{"order": 0, "choice_id": "0", '
+            '"choice_text": "Employed full-time"}, {"order": 1, "choice_id": "1", "choice_text": "Employed '
+            'part-time"}, {"order": 2, "choice_id": "2", "choice_text": "Self-employed full-time"}, {"order": 3, '
+            '"choice_id": "3", "choice_text": "Self-employed part-time"}, {"order": 4, "choice_id": "4", '
+            '"choice_text": "Active military"}, {"order": 5, "choice_id": "5", "choice_text": "Inactive '
+            'military/Veteran"}, {"order": 6, "choice_id": "6", "choice_text": "Temporarily unemployed"}, '
+            '{"order": 7, "choice_id": "7", "choice_text": "Full-time homemaker"}, {"order": 8, "choice_id": "8", '
+            '"choice_text": "Retired"}, {"order": 9, "choice_id": "9", "choice_text": "Student"}, {"order": 10, '
+            '"choice_id": "10", "choice_text": "Disabled"}], "selector": "SA", "country_iso": "us", "question_id": '
+            '"b546d26651f040c9a6900ffb126e7d69", "language_iso": "eng", "question_text": "What is your current '
+            'employment status?", "question_type": "MC", "task_score": 1.6940674222375414, "task_count": 1134, '
+            '"p": 0.0834932559027201}, {"choices": [{"order": 0, "choice_id": "0", "choice_text": "No"}, '
+            '{"order": 1, "choice_id": "1", "choice_text": "Yes, Mexican"}, {"order": 2, "choice_id": "2", '
+            '"choice_text": "Yes, Puerto Rican"}, {"order": 3, "choice_id": "3", "choice_text": "Yes, Cuban"}, '
+            '{"order": 4, "choice_id": "4", "choice_text": "Yes, Salvadoran"}, {"order": 5, "choice_id": "5", '
+            '"choice_text": "Yes, Dominican"}, {"order": 6, "choice_id": "6", "choice_text": "Yes, Guatemalan"}, '
+            '{"order": 7, "choice_id": "7", "choice_text": "Yes, Colombian"}, {"order": 8, "choice_id": "8", '
+            '"choice_text": "Yes, Honduran"}, {"order": 9, "choice_id": "9", "choice_text": "Yes, Ecuadorian"}, '
+            '{"order": 10, "choice_id": "10", "choice_text": "Yes, Argentinian"}, {"order": 11, "choice_id": "11", '
+            '"choice_text": "Yes, Peruvian"}, {"order": 12, "choice_id": "12", "choice_text": "Yes, Nicaraguan"}, '
+            '{"order": 13, "choice_id": "13", "choice_text": "Yes, Spaniard"}, {"order": 14, "choice_id": "14", '
+            '"choice_text": "Yes, Venezuelan"}, {"order": 15, "choice_id": "15", "choice_text": "Yes, Panamanian"}, '
+            '{"order": 16, "choice_id": "16", "choice_text": "Yes, Other"}], "selector": "SA", "country_iso": "us", '
+            '"question_id": "7d452b8069c24a1aacbccbf767910345", "language_iso": "eng", "question_text": "Are you of '
+            'Hispanic, Latino, or Spanish origin?", "question_type": "MC", "task_score": 1.6342156553005878, '
+            '"task_count": 2516, "p": 0.08054342118687588}], "special_questions": [{"selector": "HIDDEN", '
+            '"country_iso": "xx", "question_id": "1d1e2e8380ac474b87fb4e4c569b48df", "language_iso": "xxx", '
+            '"question_type": "HIDDEN"}, {"selector": "HIDDEN", "country_iso": "xx", "question_id": '
+            '"2fbedb2b9f7647b09ff5e52fa119cc5e", "language_iso": "xxx", "question_type": "HIDDEN"}, {"selector": '
+            '"HIDDEN", "country_iso": "xx", "question_id": "4030c52371b04e80b64e058d9c5b82e9", "language_iso": '
+            '"xxx", "question_type": "HIDDEN"}, {"selector": "HIDDEN", "country_iso": "xx", "question_id": '
+            '"a91cb1dea814480dba12d9b7b48696dd", "language_iso": "xxx", "question_type": "HIDDEN"}, {"selector": '
+            '"HIDDEN", "task_count": 40.0, "task_score": 0.45961204566189584, "country_iso": "us", "question_id": '
+            '"59f39a785f154752b6435c260cbce3c6", "language_iso": "eng", "question_text": "Core-Based Statistical '
+            'Area (2020)", "question_type": "HIDDEN"}], "consent_questions": []}'
+        )
+        instance = UpkQuestionResponse.model_validate_json(s)
+
+        assert isinstance(instance, UpkQuestionResponse)
diff --git a/tests/models/legacy/test_user_question_answer_in.py b/tests/models/legacy/test_user_question_answer_in.py
new file mode 100644
index 0000000..253c46e
--- /dev/null
+++ b/tests/models/legacy/test_user_question_answer_in.py
@@ -0,0 +1,304 @@
+import json
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+
+
+class TestUserQuestionAnswers:
+    """This is for the GRS POST submission that may contain multiple
+    Question+Answer(s) combinations for a single GRS Survey. It is
+    responsible for making sure the same question isn't submitted
+    more than once per submission, and other "list validation"
+    checks that aren't possible on an individual level.
+    """
+
+    def test_json_init(
+        self,
+        product_manager,
+        user_manager,
+        session_manager,
+        wall_manager,
+        user_factory,
+        product,
+        session_factory,
+        utc_hour_ago,
+    ):
+        from generalresearch.models.thl.session import Session, Wall
+        from generalresearch.models.thl.user import User
+        from generalresearch.models import Source
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswers,
+        )
+
+        u: User = user_factory(product=product)
+
+        s1: Session = session_factory(
+            user=u,
+            wall_count=1,
+            started=utc_hour_ago,
+            wall_req_cpi=Decimal("0.00"),
+            wall_source=Source.GRS,
+        )
+        assert isinstance(s1, Session)
+        w1 = s1.wall_events[0]
+        assert isinstance(w1, Wall)
+
+        instance = UserQuestionAnswers.model_validate_json(
+            json.dumps(
+                {
+                    "product_id": product.uuid,
+                    "product_user_id": u.product_user_id,
+                    "session_id": w1.uuid,
+                    "answers": [
+                        {"question_id": uuid4().hex, "answer": ["a", "b"]},
+                        {"question_id": uuid4().hex, "answer": ["a", "b"]},
+                    ],
+                }
+            )
+        )
+        assert isinstance(instance, UserQuestionAnswers)
+
+    def test_simple_validation_errors(
+        self, product_manager, user_manager, session_manager, wall_manager
+    ):
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswers,
+        )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                    "session_id": uuid4().hex,
+                    "answers": [{"question_id": uuid4().hex, "answer": ["a", "b"]}],
+                }
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_id": uuid4().hex,
+                    "session_id": uuid4().hex,
+                    "answers": [{"question_id": uuid4().hex, "answer": ["a", "b"]}],
+                }
+            )
+
+        # user is validated only if a session_id is passed
+        UserQuestionAnswers.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                "answers": [{"question_id": uuid4().hex, "answer": ["a", "b"]}],
+            }
+        )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_id": uuid4().hex,
+                    "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                    "session_id": uuid4().hex,
+                }
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_id": uuid4().hex,
+                    "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                    "session_id": uuid4().hex,
+                    "answers": [],
+                }
+            )
+
+        with pytest.raises(ValueError):
+            answers = [
+                {"question_id": uuid4().hex, "answer": ["a"]} for i in range(101)
+            ]
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_id": uuid4().hex,
+                    "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                    "session_id": uuid4().hex,
+                    "answers": answers,
+                }
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_id": uuid4().hex,
+                    "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                    "session_id": uuid4().hex,
+                    "answers": "aaa",
+                }
+            )
+
+    def test_no_duplicate_questions(self):
+        # TODO: depending on if or how many of these types of errors actually
+        #   occur, we could get fancy and just drop one of them. I don't
+        #   think this is worth exploring yet unless we see if it's a problem.
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswers,
+        )
+
+        consistent_qid = uuid4().hex
+        with pytest.raises(ValueError) as cm:
+            UserQuestionAnswers.model_validate(
+                {
+                    "product_id": uuid4().hex,
+                    "product_user_id": f"test-user-{uuid4().hex[:6]}",
+                    "session_id": uuid4().hex,
+                    "answers": [
+                        {"question_id": consistent_qid, "answer": ["aaa"]},
+                        {"question_id": consistent_qid, "answer": ["bbb"]},
+                    ],
+                }
+            )
+
+        assert "Don't provide answers to duplicate questions" in str(cm.value)
+
+    def test_allow_answer_failures_silent(
+        self,
+        product_manager,
+        user_manager,
+        session_manager,
+        wall_manager,
+        product,
+        user_factory,
+        utc_hour_ago,
+        session_factory,
+    ):
+        """
+        There are many instances where suppliers may be submitting answers
+        manually, and they're just totally broken. We want to silently remove
+        that one QuestionAnswerIn without "loosing" any of the other
+        QuestionAnswerIn items that they provided.
+        """
+        from generalresearch.models.thl.session import Session, Wall
+        from generalresearch.models.thl.user import User
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswers,
+        )
+
+        u: User = user_factory(product=product)
+
+        s1: Session = session_factory(user=u, wall_count=1, started=utc_hour_ago)
+        assert isinstance(s1, Session)
+        w1 = s1.wall_events[0]
+        assert isinstance(w1, Wall)
+
+        data = {
+            "product_id": product.uuid,
+            "product_user_id": u.product_user_id,
+            "session_id": w1.uuid,
+            "answers": [
+                {"question_id": uuid4().hex, "answer": ["aaa"]},
+                {"question_id": f"broken-{uuid4().hex[:6]}", "answer": ["bbb"]},
+            ],
+        }
+        # load via .model_validate()
+        instance = UserQuestionAnswers.model_validate(data)
+        assert isinstance(instance, UserQuestionAnswers)
+
+        # One of the QuestionAnswerIn items was invalid, so it was dropped
+        assert 1 == len(instance.answers)
+
+        # Confirm that this also works via model_validate_json
+        json_data = json.dumps(data)
+        instance = UserQuestionAnswers.model_validate_json(json_data)
+        assert isinstance(instance, UserQuestionAnswers)
+
+        # One of the QuestionAnswerIn items was invalid, so it was dropped
+        assert 1 == len(instance.answers)
+
+        assert instance.user is None
+        instance.prefetch_user(um=user_manager)
+        assert isinstance(instance.user, User)
+
+
+class TestUserQuestionAnswerIn:
+    """This is for the individual Question+Answer(s) that may come back from
+    a GRS POST.
+    """
+
+    def test_simple_validation_errors(self):
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswerIn,
+        )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": f"test-{uuid4().hex[:6]}", "answer": ["123"]}
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate({"answer": ["123"]})
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": [123]}
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": [""]}
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": ["  "]}
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": ["a" * 5_001]}
+            )
+
+        with pytest.raises(ValueError):
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": []}
+            )
+
+    def test_only_single_answers(self):
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswerIn,
+        )
+
+        for qid in {
+            "2fbedb2b9f7647b09ff5e52fa119cc5e",
+            "4030c52371b04e80b64e058d9c5b82e9",
+            "a91cb1dea814480dba12d9b7b48696dd",
+            "1d1e2e8380ac474b87fb4e4c569b48df",
+        }:
+            # This is the UserAgent question which only allows a single answer
+            with pytest.raises(ValueError) as cm:
+                UserQuestionAnswerIn.model_validate(
+                    {"question_id": qid, "answer": ["a", "b"]}
+                )
+
+            assert "Too many answer values provided" in str(cm.value)
+
+    def test_answer_item_limit(self):
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswerIn,
+        )
+
+        answer = [uuid4().hex[:6] for i in range(11)]
+        with pytest.raises(ValueError) as cm:
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": answer}
+            )
+        assert "List should have at most 10 items after validation" in str(cm.value)
+
+    def test_disallow_duplicate_answer_values(self):
+        from generalresearch.models.legacy.questions import (
+            UserQuestionAnswerIn,
+        )
+
+        answer = ["aaa" for i in range(5)]
+        with pytest.raises(ValueError) as cm:
+            UserQuestionAnswerIn.model_validate(
+                {"question_id": uuid4().hex, "answer": answer}
+            )
diff --git a/tests/models/morning/__init__.py b/tests/models/morning/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/morning/__init__.py
diff --git a/tests/models/morning/test.py b/tests/models/morning/test.py
new file mode 100644
index 0000000..cf4982d
--- /dev/null
+++ b/tests/models/morning/test.py
@@ -0,0 +1,199 @@
+from datetime import datetime, timezone
+
+from generalresearch.models.morning.question import MorningQuestion
+
+bid = {
+    "buyer_account_id": "ab180f06-aa2b-4b8b-9b87-1031bfe8b16b",
+    "buyer_id": "5f3b4daa-6ff0-4826-a551-9d4572ea1c84",
+    "country_id": "us",
+    "end_date": "2024-07-19T09:01:13.520243Z",
+    "exclusions": [
+        {"group_id": "66070689-5198-5782-b388-33daa74f3269", "lockout_period": 28}
+    ],
+    "id": "5324c2ac-eca8-4ed0-8b0e-042ba3aa2a85",
+    "language_ids": ["en"],
+    "name": "Ad-Hoc Survey",
+    "published_at": "2024-06-19T09:01:13.520243Z",
+    "quotas": [
+        {
+            "cost_per_interview": 154,
+            "id": "b8ade883-a83d-4d8e-9ef7-953f4b692bd8",
+            "qualifications": [
+                {
+                    "id": "age",
+                    "response_ids": [
+                        "18",
+                        "19",
+                        "20",
+                        "21",
+                        "22",
+                        "23",
+                        "24",
+                        "25",
+                        "26",
+                        "27",
+                        "28",
+                        "29",
+                        "30",
+                        "31",
+                        "32",
+                        "33",
+                        "34",
+                    ],
+                },
+                {"id": "gender", "response_ids": ["1"]},
+                {"id": "hispanic", "response_ids": ["1"]},
+            ],
+            "statistics": {
+                "length_of_interview": 1353,
+                "median_length_of_interview": 1353,
+                "num_available": 3,
+                "num_completes": 7,
+                "num_failures": 0,
+                "num_in_progress": 4,
+                "num_over_quotas": 0,
+                "num_qualified": 27,
+                "num_quality_terminations": 14,
+                "num_timeouts": 1,
+                "qualified_conversion": 30,
+            },
+        }
+    ],
+    "state": "active",
+    "statistics": {
+        "earnings_per_click": 26,
+        "estimated_length_of_interview": 1140,
+        "incidence_rate": 77,
+        "length_of_interview": 1198,
+        "median_length_of_interview": 1198,
+        "num_available": 70,
+        "num_completes": 360,
+        "num_entrants": 1467,
+        "num_failures": 0,
+        "num_in_progress": 48,
+        "num_over_quotas": 10,
+        "num_qualified": 1121,
+        "num_quality_terminations": 584,
+        "num_screenouts": 380,
+        "num_timeouts": 85,
+        "qualified_conversion": 34,
+        "system_conversion": 25,
+    },
+    "supplier_exclusive": False,
+    "survey_type": "ad_hoc",
+    "timeout": 21600,
+    "topic_id": "general",
+}
+
+bid = {
+    "_experimental_single_use_qualifications": [
+        {
+            "id": "electric_car_test",
+            "name": "Electric Car Test",
+            "text": "What kind of vehicle do you drive?",
+            "language_ids": ["en"],
+            "responses": [{"id": "1", "text": "electric"}, {"id": "2", "text": "gas"}],
+            "type": "multiple_choice",
+        }
+    ],
+    "buyer_account_id": "0b6f207c-96e1-4dce-b032-566a815ad263",
+    "buyer_id": "9020f6f3-db41-470a-a5d7-c04fa2da9156",
+    "closed_at": "2022-01-01T00:00:00Z",
+    "country_id": "us",
+    "end_date": "2022-01-01T00:00:00Z",
+    "exclusions": [
+        {"group_id": "0bbae805-5a80-42e3-8d5f-cb056a0f825d", "lockout_period": 7}
+    ],
+    "id": "000f09a3-bc25-4adc-a443-a9975800e7ac",
+    "language_ids": ["en", "es"],
+    "name": "My Example Survey",
+    "published_at": "2021-12-30T00:00:00Z",
+    "quotas": [
+        {
+            "_experimental_single_use_qualifications": [
+                {"id": "electric_car_test", "response_ids": ["1"]}
+            ],
+            "cost_per_interview": 100,
+            "id": "6a7d0190-e6ad-4a59-9945-7ba460517f2b",
+            "qualifications": [
+                {"id": "gender", "response_ids": ["1"]},
+                {"id": "age", "response_ids": ["18", "19", "20", "21"]},
+            ],
+            "statistics": {
+                "length_of_interview": 600,
+                "median_length_of_interview": 600,
+                "num_available": 500,
+                "num_completes": 100,
+                "num_failures": 0,
+                "num_in_progress": 0,
+                "num_over_quotas": 0,
+                "num_qualified": 100,
+                "num_quality_terminations": 0,
+                "num_timeouts": 0,
+                "qualified_conversion": 100,
+            },
+        }
+    ],
+    "state": "active",
+    "statistics": {
+        "earnings_per_click": 50,
+        "estimated_length_of_interview": 720,
+        "incidence_rate": 100,
+        "length_of_interview": 600,
+        "median_length_of_interview": 600,
+        "num_available": 500,
+        "num_completes": 100,
+        "num_entrants": 100,
+        "num_failures": 0,
+        "num_in_progress": 0,
+        "num_over_quotas": 0,
+        "num_qualified": 100,
+        "num_quality_terminations": 0,
+        "num_screenouts": 0,
+        "num_timeouts": 0,
+        "qualified_conversion": 100,
+        "system_conversion": 100,
+    },
+    "supplier_exclusive": False,
+    "survey_type": "ad_hoc",
+    "timeout": 3600,
+    "topic_id": "general",
+}
+
+# what gets run in MorningAPI._format_bid
+bid["language_isos"] = ("eng",)
+bid["country_iso"] = "us"
+bid["end_date"] = datetime(2024, 7, 19, 9, 1, 13, 520243, tzinfo=timezone.utc)
+bid["published_at"] = datetime(2024, 6, 19, 9, 1, 13, 520243, tzinfo=timezone.utc)
+bid.update(bid["statistics"])
+bid["qualified_conversion"] /= 100
+bid["system_conversion"] /= 100
+for quota in bid["quotas"]:
+    quota.update(quota["statistics"])
+    quota["qualified_conversion"] /= 100
+    quota["cost_per_interview"] /= 100
+if "_experimental_single_use_qualifications" in bid:
+    bid["experimental_single_use_qualifications"] = [
+        MorningQuestion.from_api(q, bid["country_iso"], "eng")
+        for q in bid["_experimental_single_use_qualifications"]
+    ]
+
+
+class TestMorningBid:
+
+    def test_model_validate(self):
+        from generalresearch.models.morning.survey import MorningBid
+
+        s = MorningBid.model_validate(bid)
+        d = s.model_dump(mode="json")
+        d = s.to_mysql()
+
+    def test_manager(self):
+        # todo: credentials n stuff
+        pass
+        # sql_helper = SqlHelper(host="localhost", user="root", password="", db="300large-morning")
+        # m = MorningSurveyManager(sql_helper=sql_helper)
+        # s = MorningBid.model_validate(bid)
+        # m.create(s)
+        # res = m.get_survey_library()[0]
+        # MorningBid.model_validate(res)
diff --git a/tests/models/precision/__init__.py b/tests/models/precision/__init__.py
new file mode 100644
index 0000000..8006fa3
--- /dev/null
+++ b/tests/models/precision/__init__.py
@@ -0,0 +1,115 @@
+survey_json = {
+    "cpi": "1.44",
+    "country_isos": "ca",
+    "language_isos": "eng",
+    "country_iso": "ca",
+    "language_iso": "eng",
+    "buyer_id": "7047",
+    "bid_loi": 1200,
+    "bid_ir": 0.45,
+    "source": "e",
+    "used_question_ids": ["age", "country_iso", "gender", "gender_1"],
+    "survey_id": "0000",
+    "group_id": "633473",
+    "status": "open",
+    "name": "beauty survey",
+    "survey_guid": "c7f375c5077d4c6c8209ff0b539d7183",
+    "category_id": "-1",
+    "global_conversion": None,
+    "desired_count": 96,
+    "achieved_count": 0,
+    "allowed_devices": "1,2,3",
+    "entry_link": "https://www.opinionetwork.com/survey/entry.aspx?mid=[%MID%]&project=633473&key=%%key%%",
+    "excluded_surveys": "470358,633286",
+    "quotas": [
+        {
+            "name": "25-34,Male,Quebec",
+            "id": "2324110",
+            "guid": "23b5760d24994bc08de451b3e62e77c7",
+            "status": "open",
+            "desired_count": 48,
+            "achieved_count": 0,
+            "termination_count": 0,
+            "overquota_count": 0,
+            "condition_hashes": ["b41e1a3", "bc89ee8", "4124366", "9f32c61"],
+        },
+        {
+            "name": "25-34,Female,Quebec",
+            "id": "2324111",
+            "guid": "0706f1a88d7e4f11ad847c03012e68d2",
+            "status": "open",
+            "desired_count": 48,
+            "achieved_count": 0,
+            "termination_count": 4,
+            "overquota_count": 0,
+            "condition_hashes": ["b41e1a3", "0cdc304", "500af2c", "9f32c61"],
+        },
+    ],
+    "conditions": {
+        "b41e1a3": {
+            "logical_operator": "OR",
+            "value_type": 1,
+            "negate": False,
+            "question_id": "country_iso",
+            "values": ["ca"],
+            "criterion_hash": "b41e1a3",
+            "value_len": 1,
+            "sizeof": 2,
+        },
+        "bc89ee8": {
+            "logical_operator": "OR",
+            "value_type": 1,
+            "negate": False,
+            "question_id": "gender",
+            "values": ["male"],
+            "criterion_hash": "bc89ee8",
+            "value_len": 1,
+            "sizeof": 4,
+        },
+        "4124366": {
+            "logical_operator": "OR",
+            "value_type": 1,
+            "negate": False,
+            "question_id": "gender_1",
+            "values": ["male"],
+            "criterion_hash": "4124366",
+            "value_len": 1,
+            "sizeof": 4,
+        },
+        "9f32c61": {
+            "logical_operator": "OR",
+            "value_type": 1,
+            "negate": False,
+            "question_id": "age",
+            "values": ["25", "26", "27", "28", "29", "30", "31", "32", "33", "34"],
+            "criterion_hash": "9f32c61",
+            "value_len": 10,
+            "sizeof": 20,
+        },
+        "0cdc304": {
+            "logical_operator": "OR",
+            "value_type": 1,
+            "negate": False,
+            "question_id": "gender",
+            "values": ["female"],
+            "criterion_hash": "0cdc304",
+            "value_len": 1,
+            "sizeof": 6,
+        },
+        "500af2c": {
+            "logical_operator": "OR",
+            "value_type": 1,
+            "negate": False,
+            "question_id": "gender_1",
+            "values": ["female"],
+            "criterion_hash": "500af2c",
+            "value_len": 1,
+            "sizeof": 6,
+        },
+    },
+    "expected_end_date": "2024-06-28T10:40:33.000000Z",
+    "created": None,
+    "updated": None,
+    "is_live": True,
+    "all_hashes": ["0cdc304", "b41e1a3", "9f32c61", "bc89ee8", "4124366", "500af2c"],
+}
diff --git a/tests/models/precision/test_survey.py b/tests/models/precision/test_survey.py
new file mode 100644
index 0000000..ff2d6d1
--- /dev/null
+++ b/tests/models/precision/test_survey.py
@@ -0,0 +1,88 @@
+class TestPrecisionQuota:
+
+    def test_quota_passes(self):
+        from generalresearch.models.precision.survey import PrecisionSurvey
+        from tests.models.precision import survey_json
+
+        s = PrecisionSurvey.model_validate(survey_json)
+        q = s.quotas[0]
+        ce = {k: True for k in ["b41e1a3", "bc89ee8", "4124366", "9f32c61"]}
+        assert q.matches(ce)
+
+        ce["b41e1a3"] = False
+        assert not q.matches(ce)
+
+        ce.pop("b41e1a3")
+        assert not q.matches(ce)
+        assert not q.matches({})
+
+    def test_quota_passes_closed(self):
+        from generalresearch.models.precision import PrecisionStatus
+        from generalresearch.models.precision.survey import PrecisionSurvey
+        from tests.models.precision import survey_json
+
+        s = PrecisionSurvey.model_validate(survey_json)
+        q = s.quotas[0]
+        q.status = PrecisionStatus.CLOSED
+        ce = {k: True for k in ["b41e1a3", "bc89ee8", "4124366", "9f32c61"]}
+        # We still match, but the quota is not open
+        assert q.matches(ce)
+        assert not q.is_open
+
+
+class TestPrecisionSurvey:
+
+    def test_passes(self):
+        from generalresearch.models.precision.survey import PrecisionSurvey
+        from tests.models.precision import survey_json
+
+        s = PrecisionSurvey.model_validate(survey_json)
+        ce = {k: True for k in ["b41e1a3", "bc89ee8", "4124366", "9f32c61"]}
+        assert s.determine_eligibility(ce)
+
+    def test_elig_closed_quota(self):
+        from generalresearch.models.precision import PrecisionStatus
+        from generalresearch.models.precision.survey import PrecisionSurvey
+        from tests.models.precision import survey_json
+
+        s = PrecisionSurvey.model_validate(survey_json)
+        ce = {k: True for k in ["b41e1a3", "bc89ee8", "4124366", "9f32c61"]}
+        q = s.quotas[0]
+        q.status = PrecisionStatus.CLOSED
+        # We match a closed quota
+        assert not s.determine_eligibility(ce)
+
+        s.quotas[0].status = PrecisionStatus.OPEN
+        s.quotas[1].status = PrecisionStatus.CLOSED
+        # Now me match an open quota and dont match the closed quota, so we should be eligible
+        assert s.determine_eligibility(ce)
+
+    def test_passes_sp(self):
+        from generalresearch.models.precision import PrecisionStatus
+        from generalresearch.models.precision.survey import PrecisionSurvey
+        from tests.models.precision import survey_json
+
+        s = PrecisionSurvey.model_validate(survey_json)
+        ce = {k: True for k in ["b41e1a3", "bc89ee8", "4124366", "9f32c61"]}
+        passes, hashes = s.determine_eligibility_soft(ce)
+
+        # We don't know if we match the 2nd quota, but it is open so it doesn't matter
+        assert passes
+        assert (True, []) == s.quotas[0].matches_soft(ce)
+        assert (None, ["0cdc304", "500af2c"]) == s.quotas[1].matches_soft(ce)
+
+        # Now don't know if we match either
+        ce.pop("9f32c61")  # age
+        passes, hashes = s.determine_eligibility_soft(ce)
+        assert passes is None
+        assert {"500af2c", "9f32c61", "0cdc304"} == hashes
+
+        ce["9f32c61"] = False
+        ce["0cdc304"] = False
+        # We know we don't match either
+        assert (False, set()) == s.determine_eligibility_soft(ce)
+
+        # We pass 1st quota, 2nd is unknown but closed, so we don't know for sure we pass
+        ce = {k: True for k in ["b41e1a3", "bc89ee8", "4124366", "9f32c61"]}
+        s.quotas[1].status = PrecisionStatus.CLOSED
+        assert (None, {"0cdc304", "500af2c"}) == s.determine_eligibility_soft(ce)
diff --git a/tests/models/precision/test_survey_manager.py b/tests/models/precision/test_survey_manager.py
new file mode 100644
index 0000000..8532ab0
--- /dev/null
+++ b/tests/models/precision/test_survey_manager.py
@@ -0,0 +1,63 @@
+# from decimal import Decimal
+#
+# from datetime import timezone, datetime
+# from pymysql import IntegrityError
+# from generalresearch.models.precision.survey import PrecisionSurvey
+# from tests.models.precision import survey_json
+
+
+# def delete_survey(survey_id: str):
+#     db_name = sql_helper.db
+#     # TODO: what is the precision specific db name...
+#
+#     sql_helper.execute_sql_query(
+#         query="""
+#         DELETE FROM `300large-precision`.precision_survey
+#         WHERE survey_id = %s
+#         """,
+#         params=[survey_id], commit=True)
+#     sql_helper.execute_sql_query("""
+#     DELETE FROM `300large-precision`.precision_survey_country WHERE survey_id = %s
+#     """, [survey_id], commit=True)
+#     sql_helper.execute_sql_query("""
+#     DELETE FROM `300large-precision`.precision_survey_language WHERE survey_id = %s
+#     """, [survey_id], commit=True)
+#
+#
+# class TestPrecisionSurvey:
+#     def test_survey_create(self):
+#         now = datetime.now(tz=timezone.utc)
+#         s = PrecisionSurvey.model_validate(survey_json)
+#         self.assertEqual(s.survey_id, '0000')
+#         delete_survey(s.survey_id)
+#
+#         sm.create(s)
+#
+#         surveys = sm.get_survey_library(updated_since=now)
+#         self.assertEqual(len(surveys), 1)
+#         self.assertEqual('0000', surveys[0].survey_id)
+#         self.assertTrue(s.is_unchanged(surveys[0]))
+#
+#         with self.assertRaises(IntegrityError) as context:
+#             sm.create(s)
+#
+#     def test_survey_update(self):
+#         # There's extra complexity here with the country/lang join tables
+#         now = datetime.now(tz=timezone.utc)
+#         s = PrecisionSurvey.model_validate(survey_json)
+#         self.assertEqual(s.survey_id, '0000')
+#         delete_survey(s.survey_id)
+#         sm.create(s)
+#         s.cpi = Decimal('0.50')
+#         # started out at only 'ca' and 'eng'
+#         s.country_isos = ['us']
+#         s.country_iso = 'us'
+#         s.language_isos = ['eng', 'spa']
+#         s.language_iso = 'eng'
+#         sm.update([s])
+#         surveys = sm.get_survey_library(updated_since=now)
+#         self.assertEqual(len(surveys), 1)
+#         s2 = surveys[0]
+#         self.assertEqual('0000', s2.survey_id)
+#         self.assertEqual(Decimal('0.50'), s2.cpi)
+#         self.assertTrue(s.is_unchanged(s2))
diff --git a/tests/models/prodege/__init__.py b/tests/models/prodege/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/prodege/__init__.py
diff --git a/tests/models/prodege/test_survey_participation.py b/tests/models/prodege/test_survey_participation.py
new file mode 100644
index 0000000..b85cc91
--- /dev/null
+++ b/tests/models/prodege/test_survey_participation.py
@@ -0,0 +1,120 @@
+from datetime import timezone, datetime, timedelta
+
+
+class TestProdegeParticipation:
+
+    def test_exclude(self):
+        from generalresearch.models.prodege import ProdegePastParticipationType
+        from generalresearch.models.prodege.survey import (
+            ProdegePastParticipation,
+            ProdegeUserPastParticipation,
+        )
+
+        now = datetime.now(tz=timezone.utc)
+        pp = ProdegePastParticipation.from_api(
+            {
+                "participation_project_ids": [152677146, 152803285],
+                "filter_type": "exclude",
+                "in_past_days": 7,
+                "participation_types": ["complete"],
+            }
+        )
+        # User has no history, so is eligible
+        assert pp.is_eligible([])
+
+        # user abandoned. its a click, not complete, so he's eligible
+        upps = [
+            ProdegeUserPastParticipation(
+                started=now - timedelta(hours=69), survey_id="152677146"
+            )
+        ]
+        assert pp.is_eligible(upps)
+
+        # user completes. ineligible
+        upps = [
+            ProdegeUserPastParticipation(
+                started=now - timedelta(hours=69),
+                survey_id="152677146",
+                ext_status_code_1="1",
+            )
+        ]
+        assert not pp.is_eligible(upps)
+
+        # user completed. but too long ago
+        upps = [
+            ProdegeUserPastParticipation(
+                started=now - timedelta(days=100),
+                survey_id="152677146",
+                ext_status_code_1="1",
+            )
+        ]
+        assert pp.is_eligible(upps)
+
+        # remove day filter, should be ineligble again
+        pp = ProdegePastParticipation.from_api(
+            {
+                "participation_project_ids": [152677146, 152803285],
+                "filter_type": "exclude",
+                "in_past_days": 0,
+                "participation_types": ["complete"],
+            }
+        )
+        assert not pp.is_eligible(upps)
+
+        # I almost forgot this.... a "complete" IS ALSO A "click"!!!
+        pp = ProdegePastParticipation.from_api(
+            {
+                "participation_project_ids": [152677146, 152803285],
+                "filter_type": "exclude",
+                "in_past_days": 0,
+                "participation_types": ["click"],
+            }
+        )
+        upps = [
+            ProdegeUserPastParticipation(
+                started=now - timedelta(hours=69),
+                survey_id="152677146",
+                ext_status_code_1="1",
+            )
+        ]
+        assert {
+            ProdegePastParticipationType.COMPLETE,
+            ProdegePastParticipationType.CLICK,
+        } == upps[0].participation_types
+        assert not pp.is_eligible(upps)
+
+    def test_include(self):
+        from generalresearch.models.prodege.survey import (
+            ProdegePastParticipation,
+            ProdegeUserPastParticipation,
+        )
+
+        now = datetime.now(tz=timezone.utc)
+        pp = ProdegePastParticipation.from_api(
+            {
+                "participation_project_ids": [152677146, 152803285],
+                "filter_type": "include",
+                "in_past_days": 7,
+                "participation_types": ["complete"],
+            }
+        )
+        # User has no history, so is IN-eligible
+        assert not pp.is_eligible([])
+
+        # user abandoned. its a click, not complete, so he's INeligible
+        upps = [
+            ProdegeUserPastParticipation(
+                started=now - timedelta(hours=69), survey_id="152677146"
+            )
+        ]
+        assert not pp.is_eligible(upps)
+
+        # user completes, eligible
+        upps = [
+            ProdegeUserPastParticipation(
+                started=now - timedelta(hours=69),
+                survey_id="152677146",
+                ext_status_code_1="1",
+            )
+        ]
+        assert pp.is_eligible(upps)
diff --git a/tests/models/spectrum/__init__.py b/tests/models/spectrum/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/spectrum/__init__.py
diff --git a/tests/models/spectrum/test_question.py b/tests/models/spectrum/test_question.py
new file mode 100644
index 0000000..ba118d7
--- /dev/null
+++ b/tests/models/spectrum/test_question.py
@@ -0,0 +1,216 @@
+from datetime import datetime, timezone
+
+from generalresearch.models import Source
+from generalresearch.models.spectrum.question import (
+    SpectrumQuestionOption,
+    SpectrumQuestion,
+    SpectrumQuestionType,
+    SpectrumQuestionClass,
+)
+from generalresearch.models.thl.profiling.upk_question import (
+    UpkQuestion,
+    UpkQuestionSelectorMC,
+    UpkQuestionType,
+    UpkQuestionChoice,
+)
+
+
+class TestSpectrumQuestion:
+
+    def test_parse_from_api_1(self):
+
+        example_1 = {
+            "qualification_code": 213,
+            "text": "My household earns approximately $%%213%% per year",
+            "cat": None,
+            "desc": "Income",
+            "type": 5,
+            "class": 1,
+            "condition_codes": [],
+            "format": {"min": 0, "max": 999999, "regex": "/^([0-9]{1,6})$/i"},
+            "crtd_on": 1502869927688,
+            "mod_on": 1706557247467,
+        }
+        q = SpectrumQuestion.from_api(example_1, "us", "eng")
+
+        expected_q = SpectrumQuestion(
+            question_id="213",
+            country_iso="us",
+            language_iso="eng",
+            question_name="Income",
+            question_text="My household earns approximately $___ per year",
+            question_type=SpectrumQuestionType.TEXT_ENTRY,
+            tags=None,
+            options=None,
+            class_num=SpectrumQuestionClass.CORE,
+            created=datetime(2017, 8, 16, 7, 52, 7, 688000, tzinfo=timezone.utc),
+            is_live=True,
+            source=Source.SPECTRUM,
+            category_id=None,
+        )
+        assert "My household earns approximately $___ per year" == q.question_text
+        assert "213" == q.question_id
+        assert expected_q == q
+        q.to_upk_question()
+        assert "s:213" == q.external_id
+
+    def test_parse_from_api_2(self):
+
+        example_2 = {
+            "qualification_code": 211,
+            "text": "I'm a %%211%%",
+            "cat": None,
+            "desc": "Gender",
+            "type": 1,
+            "class": 1,
+            "condition_codes": [
+                {"id": "111", "text": "Male"},
+                {"id": "112", "text": "Female"},
+            ],
+            "format": {"min": None, "max": None, "regex": ""},
+            "crtd_on": 1502869927688,
+            "mod_on": 1706557249817,
+        }
+        q = SpectrumQuestion.from_api(example_2, "us", "eng")
+        expected_q = SpectrumQuestion(
+            question_id="211",
+            country_iso="us",
+            language_iso="eng",
+            question_name="Gender",
+            question_text="I'm a",
+            question_type=SpectrumQuestionType.SINGLE_SELECT,
+            tags=None,
+            options=[
+                SpectrumQuestionOption(id="111", text="Male", order=0),
+                SpectrumQuestionOption(id="112", text="Female", order=1),
+            ],
+            class_num=SpectrumQuestionClass.CORE,
+            created=datetime(2017, 8, 16, 7, 52, 7, 688000, tzinfo=timezone.utc),
+            is_live=True,
+            source=Source.SPECTRUM,
+            category_id=None,
+        )
+        assert expected_q == q
+        q.to_upk_question()
+
+    def test_parse_from_api_3(self):
+
+        example_3 = {
+            "qualification_code": 220,
+            "text": "My child is a %%230%% %%221%% old %%220%%",
+            "cat": None,
+            "desc": "Child Dependent",
+            "type": 6,
+            "class": 4,
+            "condition_codes": [
+                {"id": "111", "text": "Boy"},
+                {"id": "112", "text": "Girl"},
+            ],
+            "format": {"min": None, "max": None, "regex": ""},
+            "crtd_on": 1502869927688,
+            "mod_on": 1706556781278,
+        }
+        q = SpectrumQuestion.from_api(example_3, "us", "eng")
+        # This fails because the text has variables from other questions in it
+        assert q is None
+
+    def test_parse_from_api_4(self):
+
+        example_4 = {
+            "qualification_code": 1039,
+            "text": "Do you suffer from any of the following ailments or medical conditions? (Select all that apply) "
+            " %%1039%%",
+            "cat": "Ailments, Illness",
+            "desc": "Standard Ailments",
+            "type": 3,
+            "class": 2,
+            "condition_codes": [
+                {"id": "111", "text": "Allergies (Food, Nut, Skin)"},
+                {"id": "999", "text": "None of the above"},
+                {"id": "130", "text": "Other"},
+                {
+                    "id": "129",
+                    "text": "Women's Health Conditions (Reproductive Issues)",
+                },
+            ],
+            "format": {"min": None, "max": None, "regex": ""},
+            "crtd_on": 1502869927688,
+            "mod_on": 1706557241693,
+        }
+        q = SpectrumQuestion.from_api(example_4, "us", "eng")
+        expected_q = SpectrumQuestion(
+            question_id="1039",
+            country_iso="us",
+            language_iso="eng",
+            question_name="Standard Ailments",
+            question_text="Do you suffer from any of the following ailments or medical conditions? (Select all that "
+            "apply)",
+            question_type=SpectrumQuestionType.MULTI_SELECT,
+            tags="Ailments, Illness",
+            options=[
+                SpectrumQuestionOption(
+                    id="111", text="Allergies (Food, Nut, Skin)", order=0
+                ),
+                SpectrumQuestionOption(
+                    id="129",
+                    text="Women's Health Conditions (Reproductive Issues)",
+                    order=1,
+                ),
+                SpectrumQuestionOption(id="130", text="Other", order=2),
+                SpectrumQuestionOption(id="999", text="None of the above", order=3),
+            ],
+            class_num=SpectrumQuestionClass.EXTENDED,
+            created=datetime(2017, 8, 16, 7, 52, 7, 688000, tzinfo=timezone.utc),
+            is_live=True,
+            source=Source.SPECTRUM,
+            category_id=None,
+        )
+        assert expected_q == q
+
+        # todo: we should have something that infers that if the choice text is "None of the above",
+        #   then the choice is exclusive
+        u = UpkQuestion(
+            id=None,
+            ext_question_id="s:1039",
+            type=UpkQuestionType.MULTIPLE_CHOICE,
+            selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+            country_iso="us",
+            language_iso="eng",
+            text="Do you suffer from any of the following ailments or medical conditions? (Select all "
+            "that apply)",
+            choices=[
+                UpkQuestionChoice(
+                    id="111",
+                    text="Allergies (Food, Nut, Skin)",
+                    order=0,
+                    group=None,
+                    exclusive=False,
+                    importance=None,
+                ),
+                UpkQuestionChoice(
+                    id="129",
+                    text="Women's Health Conditions (Reproductive Issues)",
+                    order=1,
+                    group=None,
+                    exclusive=False,
+                    importance=None,
+                ),
+                UpkQuestionChoice(
+                    id="130",
+                    text="Other",
+                    order=2,
+                    group=None,
+                    exclusive=False,
+                    importance=None,
+                ),
+                UpkQuestionChoice(
+                    id="999",
+                    text="None of the above",
+                    order=3,
+                    group=None,
+                    exclusive=False,
+                    importance=None,
+                ),
+            ],
+        )
+        assert u == q.to_upk_question()
diff --git a/tests/models/spectrum/test_survey.py b/tests/models/spectrum/test_survey.py
new file mode 100644
index 0000000..65dec60
--- /dev/null
+++ b/tests/models/spectrum/test_survey.py
@@ -0,0 +1,413 @@
+from datetime import timezone, datetime
+from decimal import Decimal
+
+
+class TestSpectrumCondition:
+
+    def test_condition_create(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.spectrum.survey import (
+            SpectrumCondition,
+        )
+        from generalresearch.models.thl.survey.condition import ConditionValueType
+
+        c = SpectrumCondition.from_api(
+            {
+                "qualification_code": 212,
+                "range_sets": [
+                    {"units": 311, "to": 28, "from": 25},
+                    {"units": 311, "to": 42, "from": 40},
+                ],
+            }
+        )
+        assert (
+            SpectrumCondition(
+                question_id="212",
+                values=["25-28", "40-42"],
+                value_type=ConditionValueType.RANGE,
+                negate=False,
+                logical_operator=LogicalOperator.OR,
+            )
+            == c
+        )
+
+        # These equal each other b/c age ranges get automatically converted
+        assert (
+            SpectrumCondition(
+                question_id="212",
+                values=["25", "26", "27", "28", "40", "41", "42"],
+                value_type=ConditionValueType.LIST,
+                negate=False,
+                logical_operator=LogicalOperator.OR,
+            )
+            == c
+        )
+
+        c = SpectrumCondition.from_api(
+            {
+                "condition_codes": ["111", "117", "112", "113", "118"],
+                "qualification_code": 1202,
+            }
+        )
+        assert (
+            SpectrumCondition(
+                question_id="1202",
+                values=["111", "112", "113", "117", "118"],
+                value_type=ConditionValueType.LIST,
+                negate=False,
+                logical_operator=LogicalOperator.OR,
+            )
+            == c
+        )
+
+
+class TestSpectrumQuota:
+
+    def test_quota_create(self):
+        from generalresearch.models.spectrum.survey import (
+            SpectrumCondition,
+            SpectrumQuota,
+        )
+
+        d = {
+            "quota_id": "a846b545-4449-4d76-93a2-f8ebdf6e711e",
+            "quantities": {"currently_open": 57, "remaining": 57, "achieved": 0},
+            "criteria": [{"qualification_code": 211, "condition_codes": ["111"]}],
+            "crtd_on": 1716227282077,
+            "mod_on": 1716227284146,
+            "last_complete_date": None,
+        }
+        criteria = [SpectrumCondition.from_api(q) for q in d["criteria"]]
+        d["condition_hashes"] = [x.criterion_hash for x in criteria]
+        q = SpectrumQuota.from_api(d)
+        assert SpectrumQuota(remaining_count=57, condition_hashes=["c23c0b9"]) == q
+        assert q.is_open
+
+    def test_quota_passes(self):
+        from generalresearch.models.spectrum.survey import (
+            SpectrumQuota,
+        )
+
+        q = SpectrumQuota(remaining_count=57, condition_hashes=["a"])
+        assert q.passes({"a": True})
+        assert not q.passes({"a": False})
+        assert not q.passes({})
+
+        # We have to match all
+        q = SpectrumQuota(remaining_count=57, condition_hashes=["a", "b", "c"])
+        assert not q.passes({"a": True, "b": False})
+        assert q.passes({"a": True, "b": True, "c": True})
+
+        # Quota must be open, even if we match
+        q = SpectrumQuota(remaining_count=0, condition_hashes=["a"])
+        assert not q.passes({"a": True})
+
+    def test_quota_passes_soft(self):
+        from generalresearch.models.spectrum.survey import (
+            SpectrumQuota,
+        )
+
+        q = SpectrumQuota(remaining_count=57, condition_hashes=["a", "b", "c"])
+        # Pass if we match all
+        assert (True, set()) == q.matches_soft({"a": True, "b": True, "c": True})
+        # Fail if we don't match any
+        assert (False, set()) == q.matches_soft({"a": True, "b": False, "c": None})
+        # Unknown if any are unknown AND we don't fail any
+        assert (None, {"c", "b"}) == q.matches_soft({"a": True, "b": None, "c": None})
+        assert (None, {"a", "c", "b"}) == q.matches_soft(
+            {"a": None, "b": None, "c": None}
+        )
+        assert (False, set()) == q.matches_soft({"a": None, "b": False, "c": None})
+
+
+class TestSpectrumSurvey:
+    def test_survey_create(self):
+        from generalresearch.models import (
+            LogicalOperator,
+            Source,
+            TaskCalculationType,
+        )
+        from generalresearch.models.spectrum import SpectrumStatus
+        from generalresearch.models.spectrum.survey import (
+            SpectrumCondition,
+            SpectrumQuota,
+            SpectrumSurvey,
+        )
+        from generalresearch.models.thl.survey.condition import ConditionValueType
+
+        # Note: d is the raw response after calling SpectrumAPI.preprocess_survey() on it!
+        d = {
+            "survey_id": 29333264,
+            "survey_name": "Exciting New Survey #29333264",
+            "survey_status": 22,
+            "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc),
+            "category": "Exciting New",
+            "category_code": 232,
+            "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc),
+            "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc),
+            "soft_launch": False,
+            "click_balancing": 0,
+            "price_type": 1,
+            "pii": False,
+            "buyer_message": "",
+            "buyer_id": 4726,
+            "incl_excl": 0,
+            "cpi": Decimal("1.20000"),
+            "last_complete_date": None,
+            "project_last_complete_date": None,
+            "survey_performance": {
+                "overall": {"ir": 40, "loi": 10},
+                "last_block": {"ir": None, "loi": None},
+            },
+            "supplier_completes": {
+                "needed": 495,
+                "achieved": 0,
+                "remaining": 495,
+                "guaranteed_allocation": 0,
+                "guaranteed_allocation_remaining": 0,
+            },
+            "pds": {"enabled": False, "buyer_name": None},
+            "quotas": [
+                {
+                    "quota_id": "c2bc961e-4f26-4223-b409-ebe9165cfdf5",
+                    "quantities": {
+                        "currently_open": 491,
+                        "remaining": 495,
+                        "achieved": 0,
+                    },
+                    "criteria": [
+                        {
+                            "qualification_code": 212,
+                            "range_sets": [{"units": 311, "to": 64, "from": 18}],
+                        }
+                    ],
+                    "crtd_on": 1716227293496,
+                    "mod_on": 1716229289847,
+                    "last_complete_date": None,
+                }
+            ],
+            "qualifications": [
+                {
+                    "range_sets": [{"units": 311, "to": 64, "from": 18}],
+                    "qualification_code": 212,
+                }
+            ],
+            "country_iso": "fr",
+            "language_iso": "fre",
+            "bid_ir": 0.4,
+            "bid_loi": 600,
+            "last_block_ir": None,
+            "last_block_loi": None,
+            "survey_exclusions": set(),
+            "exclusion_period": 0,
+        }
+        s = SpectrumSurvey.from_api(d)
+        expected_survey = SpectrumSurvey(
+            cpi=Decimal("1.20000"),
+            country_isos=["fr"],
+            language_isos=["fre"],
+            buyer_id="4726",
+            source=Source.SPECTRUM,
+            used_question_ids={"212"},
+            survey_id="29333264",
+            survey_name="Exciting New Survey #29333264",
+            status=SpectrumStatus.LIVE,
+            field_end_date=datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc),
+            category_code="232",
+            calculation_type=TaskCalculationType.COMPLETES,
+            requires_pii=False,
+            survey_exclusions=set(),
+            exclusion_period=0,
+            bid_ir=0.40,
+            bid_loi=600,
+            last_block_loi=None,
+            last_block_ir=None,
+            overall_loi=None,
+            overall_ir=None,
+            project_last_complete_date=None,
+            country_iso="fr",
+            language_iso="fre",
+            include_psids=None,
+            exclude_psids=None,
+            qualifications=["77f493d"],
+            quotas=[SpectrumQuota(remaining_count=491, condition_hashes=["77f493d"])],
+            conditions={
+                "77f493d": SpectrumCondition(
+                    logical_operator=LogicalOperator.OR,
+                    value_type=ConditionValueType.RANGE,
+                    negate=False,
+                    question_id="212",
+                    values=["18-64"],
+                )
+            },
+            created_api=datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc),
+            modified_api=datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc),
+            updated=None,
+        )
+        assert expected_survey.model_dump_json() == s.model_dump_json()
+
+    def test_survey_properties(self):
+        from generalresearch.models.spectrum.survey import (
+            SpectrumSurvey,
+        )
+
+        d = {
+            "survey_id": 29333264,
+            "survey_name": "#29333264",
+            "survey_status": 22,
+            "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc),
+            "category": "Exciting New",
+            "category_code": 232,
+            "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc),
+            "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc),
+            "soft_launch": False,
+            "click_balancing": 0,
+            "price_type": 1,
+            "pii": False,
+            "buyer_message": "",
+            "buyer_id": 4726,
+            "incl_excl": 0,
+            "cpi": Decimal("1.20000"),
+            "last_complete_date": None,
+            "project_last_complete_date": None,
+            "quotas": [
+                {
+                    "quota_id": "c2bc961e-4f26-4223-b409-ebe9165cfdf5",
+                    "quantities": {
+                        "currently_open": 491,
+                        "remaining": 495,
+                        "achieved": 0,
+                    },
+                    "criteria": [
+                        {
+                            "qualification_code": 214,
+                            "range_sets": [{"units": 311, "to": 64, "from": 18}],
+                        }
+                    ],
+                }
+            ],
+            "qualifications": [
+                {
+                    "range_sets": [{"units": 311, "to": 64, "from": 18}],
+                    "qualification_code": 212,
+                },
+                {"condition_codes": ["111", "117", "112"], "qualification_code": 1202},
+            ],
+            "country_iso": "fr",
+            "language_iso": "fre",
+            "overall_ir": 0.4,
+            "overall_loi": 600,
+            "last_block_ir": None,
+            "last_block_loi": None,
+            "survey_exclusions": set(),
+            "exclusion_period": 0,
+        }
+        s = SpectrumSurvey.from_api(d)
+        assert {"212", "1202", "214"} == s.used_question_ids
+        assert s.is_live
+        assert s.is_open
+        assert {"38cea5e", "83955ef", "77f493d"} == s.all_hashes
+
+    def test_survey_eligibility(self):
+        from generalresearch.models.spectrum.survey import (
+            SpectrumQuota,
+            SpectrumSurvey,
+        )
+
+        d = {
+            "survey_id": 29333264,
+            "survey_name": "#29333264",
+            "survey_status": 22,
+            "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc),
+            "category": "Exciting New",
+            "category_code": 232,
+            "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc),
+            "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc),
+            "soft_launch": False,
+            "click_balancing": 0,
+            "price_type": 1,
+            "pii": False,
+            "buyer_message": "",
+            "buyer_id": 4726,
+            "incl_excl": 0,
+            "cpi": Decimal("1.20000"),
+            "last_complete_date": None,
+            "project_last_complete_date": None,
+            "quotas": [],
+            "qualifications": [],
+            "country_iso": "fr",
+            "language_iso": "fre",
+            "overall_ir": 0.4,
+            "overall_loi": 600,
+            "last_block_ir": None,
+            "last_block_loi": None,
+            "survey_exclusions": set(),
+            "exclusion_period": 0,
+        }
+        s = SpectrumSurvey.from_api(d)
+        s.qualifications = ["a", "b", "c"]
+        s.quotas = [
+            SpectrumQuota(remaining_count=10, condition_hashes=["a", "b"]),
+            SpectrumQuota(remaining_count=0, condition_hashes=["d"]),
+            SpectrumQuota(remaining_count=10, condition_hashes=["e"]),
+        ]
+
+        assert s.passes_qualifications({"a": True, "b": True, "c": True})
+        assert not s.passes_qualifications({"a": True, "b": True, "c": False})
+
+        # we do NOT match a full quota, so we pass
+        assert s.passes_quotas({"a": True, "b": True, "d": False})
+        # We dont pass any
+        assert not s.passes_quotas({})
+        # we only pass a full quota
+        assert not s.passes_quotas({"d": True})
+        # we only dont pass a full quota, but we haven't passed any open
+        assert not s.passes_quotas({"d": False})
+        # we pass a quota, but also pass a full quota, so fail
+        assert not s.passes_quotas({"e": True, "d": True})
+        # we pass a quota, but are unknown in a full quota, so fail
+        assert not s.passes_quotas({"e": True})
+
+        # # Soft Pair
+        assert (True, set()) == s.passes_qualifications_soft(
+            {"a": True, "b": True, "c": True}
+        )
+        assert (False, set()) == s.passes_qualifications_soft(
+            {"a": True, "b": True, "c": False}
+        )
+        assert (None, set("c")) == s.passes_qualifications_soft(
+            {"a": True, "b": True, "c": None}
+        )
+
+        # we do NOT match a full quota, so we pass
+        assert (True, set()) == s.passes_quotas_soft({"a": True, "b": True, "d": False})
+        # We dont pass any
+        assert (None, {"a", "b", "d", "e"}) == s.passes_quotas_soft({})
+        # we only pass a full quota
+        assert (False, set()) == s.passes_quotas_soft({"d": True})
+        # we only dont pass a full quota, but we haven't passed any open
+        assert (None, {"a", "b", "e"}) == s.passes_quotas_soft({"d": False})
+        # we pass a quota, but also pass a full quota, so fail
+        assert (False, set()) == s.passes_quotas_soft({"e": True, "d": True})
+        # we pass a quota, but are unknown in a full quota, so fail
+        assert (None, {"d"}) == s.passes_quotas_soft({"e": True})
+
+        assert s.determine_eligibility({"a": True, "b": True, "c": True, "d": False})
+        assert not s.determine_eligibility(
+            {"a": True, "b": True, "c": False, "d": False}
+        )
+        assert not s.determine_eligibility(
+            {"a": True, "b": True, "c": None, "d": False}
+        )
+        assert (True, set()) == s.determine_eligibility_soft(
+            {"a": True, "b": True, "c": True, "d": False}
+        )
+        assert (False, set()) == s.determine_eligibility_soft(
+            {"a": True, "b": True, "c": False, "d": False}
+        )
+        assert (None, set("c")) == s.determine_eligibility_soft(
+            {"a": True, "b": True, "c": None, "d": False}
+        )
+        assert (None, {"c", "d"}) == s.determine_eligibility_soft(
+            {"a": True, "b": True, "c": None, "d": None}
+        )
diff --git a/tests/models/spectrum/test_survey_manager.py b/tests/models/spectrum/test_survey_manager.py
new file mode 100644
index 0000000..582093c
--- /dev/null
+++ b/tests/models/spectrum/test_survey_manager.py
@@ -0,0 +1,130 @@
+import copy
+import logging
+from datetime import timezone, datetime
+from decimal import Decimal
+
+from pymysql import IntegrityError
+
+
+logger = logging.getLogger()
+
+example_survey_api_response = {
+    "survey_id": 29333264,
+    "survey_name": "#29333264",
+    "survey_status": 22,
+    "field_end_date": datetime(2024, 5, 23, 18, 18, 31, tzinfo=timezone.utc),
+    "category": "Exciting New",
+    "category_code": 232,
+    "crtd_on": datetime(2024, 5, 20, 17, 48, 13, tzinfo=timezone.utc),
+    "mod_on": datetime(2024, 5, 20, 18, 18, 31, tzinfo=timezone.utc),
+    "soft_launch": False,
+    "click_balancing": 0,
+    "price_type": 1,
+    "pii": False,
+    "buyer_message": "",
+    "buyer_id": 4726,
+    "incl_excl": 0,
+    "cpi": Decimal("1.20"),
+    "last_complete_date": None,
+    "project_last_complete_date": None,
+    "quotas": [
+        {
+            "quota_id": "c2bc961e-4f26-4223-b409-ebe9165cfdf5",
+            "quantities": {"currently_open": 491, "remaining": 495, "achieved": 0},
+            "criteria": [
+                {
+                    "qualification_code": 214,
+                    "range_sets": [{"units": 311, "to": 64, "from": 18}],
+                }
+            ],
+        }
+    ],
+    "qualifications": [
+        {
+            "range_sets": [{"units": 311, "to": 64, "from": 18}],
+            "qualification_code": 212,
+        },
+        {"condition_codes": ["111", "117", "112"], "qualification_code": 1202},
+    ],
+    "country_iso": "fr",
+    "language_iso": "fre",
+    "bid_ir": 0.4,
+    "bid_loi": 600,
+    "overall_ir": None,
+    "overall_loi": None,
+    "last_block_ir": None,
+    "last_block_loi": None,
+    "survey_exclusions": set(),
+    "exclusion_period": 0,
+}
+
+
+class TestSpectrumSurvey:
+
+    def test_survey_create(self, settings, spectrum_manager, spectrum_rw):
+        from generalresearch.models.spectrum.survey import SpectrumSurvey
+
+        assert settings.debug, "CRITICAL: Do not run this on production."
+
+        now = datetime.now(tz=timezone.utc)
+        spectrum_rw.execute_sql_query(
+            query=f"""
+                DELETE FROM `{spectrum_rw.db}`.spectrum_survey
+                WHERE survey_id = '29333264'""",
+            commit=True,
+        )
+
+        d = example_survey_api_response.copy()
+        s = SpectrumSurvey.from_api(d)
+        spectrum_manager.create(s)
+
+        surveys = spectrum_manager.get_survey_library(updated_since=now)
+        assert len(surveys) == 1
+        assert "29333264" == surveys[0].survey_id
+        assert s.is_unchanged(surveys[0])
+
+        try:
+            spectrum_manager.create(s)
+        except IntegrityError as e:
+            print(e.args)
+
+    def test_survey_update(self, settings, spectrum_manager, spectrum_rw):
+        from generalresearch.models.spectrum.survey import SpectrumSurvey
+
+        assert settings.debug, "CRITICAL: Do not run this on production."
+
+        now = datetime.now(tz=timezone.utc)
+        spectrum_rw.execute_sql_query(
+            query=f"""
+                DELETE FROM `{spectrum_rw.db}`.spectrum_survey
+                WHERE survey_id = '29333264'
+            """,
+            commit=True,
+        )
+        d = copy.deepcopy(example_survey_api_response)
+        s = SpectrumSurvey.from_api(d)
+        print(s)
+
+        spectrum_manager.create(s)
+        s.cpi = Decimal("0.50")
+        spectrum_manager.update([s])
+        surveys = spectrum_manager.get_survey_library(updated_since=now)
+        assert len(surveys) == 1
+        assert "29333264" == surveys[0].survey_id
+        assert Decimal("0.50") == surveys[0].cpi
+        assert s.is_unchanged(surveys[0])
+
+        #  --- Updating bid/overall/last block
+        assert 600 == s.bid_loi
+        assert s.overall_loi is None
+        assert s.last_block_loi is None
+
+        # now the last block is set
+        s.bid_loi = None
+        s.overall_loi = 1000
+        s.last_block_loi = 1000
+        spectrum_manager.update([s])
+        surveys = spectrum_manager.get_survey_library(updated_since=now)
+        assert 600 == surveys[0].bid_loi
+        assert 1000 == surveys[0].overall_loi
+        assert 1000 == surveys[0].last_block_loi
diff --git a/tests/models/test_currency.py b/tests/models/test_currency.py
new file mode 100644
index 0000000..40cff88
--- /dev/null
+++ b/tests/models/test_currency.py
@@ -0,0 +1,410 @@
+"""These were taken from the wxet project's first use of this idea. Not all
+functionality is the same, but pasting here so the tests are in the
+correct spot...
+"""
+
+from decimal import Decimal
+from random import randint
+
+import pytest
+
+
+class TestUSDCentModel:
+
+    def test_construct_int(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val = randint(0, 999_999)
+            instance = USDCent(int_val)
+            assert int_val == instance
+
+    def test_construct_float(self):
+        from generalresearch.currency import USDCent
+
+        with pytest.warns(expected_warning=Warning) as record:
+            float_val: float = 10.6789
+            instance = USDCent(float_val)
+
+        assert len(record) == 1
+        assert "USDCent init with a float. Rounding behavior may be unexpected" in str(
+            record[0].message
+        )
+        assert instance == USDCent(10)
+        assert instance == 10
+
+    def test_construct_decimal(self):
+        from generalresearch.currency import USDCent
+
+        with pytest.warns(expected_warning=Warning) as record:
+            decimal_val: Decimal = Decimal("10.0")
+            instance = USDCent(decimal_val)
+
+        assert len(record) == 1
+        assert (
+            "USDCent init with a Decimal. Rounding behavior may be unexpected"
+            in str(record[0].message)
+        )
+
+        assert instance == USDCent(10)
+        assert instance == 10
+
+        # Now with rounding
+        with pytest.warns(Warning) as record:
+            decimal_val: Decimal = Decimal("10.6789")
+            instance = USDCent(decimal_val)
+
+        assert len(record) == 1
+        assert (
+            "USDCent init with a Decimal. Rounding behavior may be unexpected"
+            in str(record[0].message)
+        )
+
+        assert instance == USDCent(10)
+        assert instance == 10
+
+    def test_construct_negative(self):
+        from generalresearch.currency import USDCent
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            USDCent(-1)
+        assert "USDCent not be less than zero" in str(cm.value)
+
+    def test_operation_add(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val1 = randint(0, 999_999)
+            int_val2 = randint(0, 999_999)
+
+            instance1 = USDCent(int_val1)
+            instance2 = USDCent(int_val2)
+
+            assert int_val1 + int_val2 == instance1 + instance2
+
+    def test_operation_subtract(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val1 = randint(500_000, 999_999)
+            int_val2 = randint(0, 499_999)
+
+            instance1 = USDCent(int_val1)
+            instance2 = USDCent(int_val2)
+
+            assert int_val1 - int_val2 == instance1 - instance2
+
+    def test_operation_subtract_to_neg(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val = randint(0, 999_999)
+            instance = USDCent(int_val)
+
+            with pytest.raises(expected_exception=ValueError) as cm:
+                instance - USDCent(1_000_000)
+
+            assert "USDCent not be less than zero" in str(cm.value)
+
+    def test_operation_multiply(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val1 = randint(0, 999_999)
+            int_val2 = randint(0, 999_999)
+
+            instance1 = USDCent(int_val1)
+            instance2 = USDCent(int_val2)
+
+            assert int_val1 * int_val2 == instance1 * instance2
+
+    def test_operation_div(self):
+        from generalresearch.currency import USDCent
+
+        with pytest.raises(ValueError) as cm:
+            USDCent(10) / 2
+        assert "Division not allowed for USDCent" in str(cm.value)
+
+    def test_operation_result_type(self):
+        from generalresearch.currency import USDCent
+
+        int_val = randint(1, 999_999)
+        instance = USDCent(int_val)
+
+        res_add = instance + USDCent(1)
+        assert isinstance(res_add, USDCent)
+
+        res_sub = instance - USDCent(1)
+        assert isinstance(res_sub, USDCent)
+
+        res_multipy = instance * USDCent(2)
+        assert isinstance(res_multipy, USDCent)
+
+    def test_operation_partner_add(self):
+        from generalresearch.currency import USDCent
+
+        int_val = randint(1, 999_999)
+        instance = USDCent(int_val)
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + 0.10
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + Decimal(".10")
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + "9.9"
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + True
+
+    def test_abs(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val = abs(randint(0, 999_999))
+            instance = abs(USDCent(int_val))
+
+            assert int_val == instance
+
+    def test_str(self):
+        from generalresearch.currency import USDCent
+
+        for i in range(100):
+            int_val = randint(0, 999_999)
+            instance = USDCent(int_val)
+
+            assert str(int_val) == str(instance)
+
+    def test_operation_result_type_unsupported(self):
+        """There is no correct answer here, but we at least want to make sure
+        that a USDCent is returned
+        """
+        from generalresearch.currency import USDCent
+
+        res = USDCent(10) // 1.2
+        assert not isinstance(res, USDCent)
+        assert isinstance(res, float)
+
+        res = USDCent(10) % 1
+        assert not isinstance(res, USDCent)
+        assert isinstance(res, int)
+
+        res = pow(USDCent(10), 2)
+        assert not isinstance(res, USDCent)
+        assert isinstance(res, int)
+
+        res = pow(USDCent(10), USDCent(2))
+        assert not isinstance(res, USDCent)
+        assert isinstance(res, int)
+
+        res = float(USDCent(10))
+        assert not isinstance(res, USDCent)
+        assert isinstance(res, float)
+
+
+class TestUSDMillModel:
+
+    def test_construct_int(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val = randint(0, 999_999)
+            instance = USDMill(int_val)
+            assert int_val == instance
+
+    def test_construct_float(self):
+        from generalresearch.currency import USDMill
+
+        with pytest.warns(expected_warning=Warning) as record:
+            float_val: float = 10.6789
+            instance = USDMill(float_val)
+
+        assert len(record) == 1
+        assert "USDMill init with a float. Rounding behavior may be unexpected" in str(
+            record[0].message
+        )
+        assert instance == USDMill(10)
+        assert instance == 10
+
+    def test_construct_decimal(self):
+        from generalresearch.currency import USDMill
+
+        with pytest.warns(expected_warning=Warning) as record:
+            decimal_val: Decimal = Decimal("10.0")
+            instance = USDMill(decimal_val)
+
+        assert len(record) == 1
+        assert (
+            "USDMill init with a Decimal. Rounding behavior may be unexpected"
+            in str(record[0].message)
+        )
+
+        assert instance == USDMill(10)
+        assert instance == 10
+
+        # Now with rounding
+        with pytest.warns(expected_warning=Warning) as record:
+            decimal_val: Decimal = Decimal("10.6789")
+            instance = USDMill(decimal_val)
+
+        assert len(record) == 1
+        assert (
+            "USDMill init with a Decimal. Rounding behavior may be unexpected"
+            in str(record[0].message)
+        )
+
+        assert instance == USDMill(10)
+        assert instance == 10
+
+    def test_construct_negative(self):
+        from generalresearch.currency import USDMill
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            USDMill(-1)
+        assert "USDMill not be less than zero" in str(cm.value)
+
+    def test_operation_add(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val1 = randint(0, 999_999)
+            int_val2 = randint(0, 999_999)
+
+            instance1 = USDMill(int_val1)
+            instance2 = USDMill(int_val2)
+
+            assert int_val1 + int_val2 == instance1 + instance2
+
+    def test_operation_subtract(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val1 = randint(500_000, 999_999)
+            int_val2 = randint(0, 499_999)
+
+            instance1 = USDMill(int_val1)
+            instance2 = USDMill(int_val2)
+
+            assert int_val1 - int_val2 == instance1 - instance2
+
+    def test_operation_subtract_to_neg(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val = randint(0, 999_999)
+            instance = USDMill(int_val)
+
+            with pytest.raises(expected_exception=ValueError) as cm:
+                instance - USDMill(1_000_000)
+
+            assert "USDMill not be less than zero" in str(cm.value)
+
+    def test_operation_multiply(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val1 = randint(0, 999_999)
+            int_val2 = randint(0, 999_999)
+
+            instance1 = USDMill(int_val1)
+            instance2 = USDMill(int_val2)
+
+            assert int_val1 * int_val2 == instance1 * instance2
+
+    def test_operation_div(self):
+        from generalresearch.currency import USDMill
+
+        with pytest.raises(ValueError) as cm:
+            USDMill(10) / 2
+        assert "Division not allowed for USDMill" in str(cm.value)
+
+    def test_operation_result_type(self):
+        from generalresearch.currency import USDMill
+
+        int_val = randint(1, 999_999)
+        instance = USDMill(int_val)
+
+        res_add = instance + USDMill(1)
+        assert isinstance(res_add, USDMill)
+
+        res_sub = instance - USDMill(1)
+        assert isinstance(res_sub, USDMill)
+
+        res_multipy = instance * USDMill(2)
+        assert isinstance(res_multipy, USDMill)
+
+    def test_operation_partner_add(self):
+        from generalresearch.currency import USDMill
+
+        int_val = randint(1, 999_999)
+        instance = USDMill(int_val)
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + 0.10
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + Decimal(".10")
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + "9.9"
+
+        with pytest.raises(expected_exception=AssertionError):
+            instance + True
+
+    def test_abs(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val = abs(randint(0, 999_999))
+            instance = abs(USDMill(int_val))
+
+            assert int_val == instance
+
+    def test_str(self):
+        from generalresearch.currency import USDMill
+
+        for i in range(100):
+            int_val = randint(0, 999_999)
+            instance = USDMill(int_val)
+
+            assert str(int_val) == str(instance)
+
+    def test_operation_result_type_unsupported(self):
+        """There is no correct answer here, but we at least want to make sure
+        that a USDMill is returned
+        """
+        from generalresearch.currency import USDCent, USDMill
+
+        res = USDMill(10) // 1.2
+        assert not isinstance(res, USDMill)
+        assert isinstance(res, float)
+
+        res = USDMill(10) % 1
+        assert not isinstance(res, USDMill)
+        assert isinstance(res, int)
+
+        res = pow(USDMill(10), 2)
+        assert not isinstance(res, USDMill)
+        assert isinstance(res, int)
+
+        res = pow(USDMill(10), USDMill(2))
+        assert not isinstance(res, USDCent)
+        assert isinstance(res, int)
+
+        res = float(USDMill(10))
+        assert not isinstance(res, USDMill)
+        assert isinstance(res, float)
+
+
+class TestNegativeFormatting:
+
+    def test_pos(self):
+        from generalresearch.currency import format_usd_cent
+
+        assert "-$987.65" == format_usd_cent(-98765)
+
+    def test_neg(self):
+        from generalresearch.currency import format_usd_cent
+
+        assert "-$123.45" == format_usd_cent(-12345)
diff --git a/tests/models/test_device.py b/tests/models/test_device.py
new file mode 100644
index 0000000..480e0c0
--- /dev/null
+++ b/tests/models/test_device.py
@@ -0,0 +1,27 @@
+import pytest
+
+iphone_ua_string = (
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 5_1 like Mac OS X) AppleWebKit/534.46 (KHTML, like Gecko) "
+    "Version/5.1 Mobile/9B179 Safari/7534.48.3"
+)
+ipad_ua_string = (
+    "Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, "
+    "like Gecko) Version/4.0.4 Mobile/7B314 Safari/531.21.10"
+)
+windows_ie_ua_string = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"
+chromebook_ua_string = (
+    "Mozilla/5.0 (X11; CrOS i686 0.12.433) AppleWebKit/534.30 (KHTML, like Gecko) "
+    "Chrome/12.0.742.77 Safari/534.30"
+)
+
+
+class TestDeviceUA:
+    def test_device_ua(self):
+        from generalresearch.models import DeviceType
+        from generalresearch.models.device import parse_device_from_useragent
+
+        assert parse_device_from_useragent(iphone_ua_string) == DeviceType.MOBILE
+        assert parse_device_from_useragent(ipad_ua_string) == DeviceType.TABLET
+        assert parse_device_from_useragent(windows_ie_ua_string) == DeviceType.DESKTOP
+        assert parse_device_from_useragent(chromebook_ua_string) == DeviceType.DESKTOP
+        assert parse_device_from_useragent("greg bot") == DeviceType.UNKNOWN
diff --git a/tests/models/test_finance.py b/tests/models/test_finance.py
new file mode 100644
index 0000000..888bf49
--- /dev/null
+++ b/tests/models/test_finance.py
@@ -0,0 +1,929 @@
+from datetime import timezone, timedelta
+from itertools import product as iter_product
+from random import randint
+from uuid import uuid4
+
+import pandas as pd
+import pytest
+
+# noinspection PyUnresolvedReferences
+from distributed.utils_test import (
+    gen_cluster,
+    client_no_amm,
+    loop,
+    loop_in_thread,
+    cleanup,
+    cluster_fixture,
+    client,
+)
+from faker import Faker
+
+from generalresearch.incite.schemas.mergers.pop_ledger import (
+    numerical_col_names,
+)
+from generalresearch.models.thl.finance import (
+    POPFinancial,
+    ProductBalances,
+    BusinessBalances,
+)
+from test_utils.conftest import delete_df_collection
+from test_utils.incite.collections.conftest import ledger_collection
+from test_utils.incite.mergers.conftest import pop_ledger_merge
+from test_utils.managers.ledger.conftest import (
+    create_main_accounts,
+    session_with_tx_factory,
+)
+
+fake = Faker()
+
+
+class TestProductBalanceInitialize:
+
+    def test_unknown_fields(self):
+        with pytest.raises(expected_exception=ValueError):
+            ProductBalances.model_validate(
+                {
+                    "bp_payment.DEBIT": 1,
+                }
+            )
+
+    def test_payout(self):
+        val = randint(1, 1_000)
+        instance = ProductBalances.model_validate({"bp_payment.CREDIT": val})
+        assert instance.payout == val
+
+    def test_adjustment(self):
+        instance = ProductBalances.model_validate(
+            {"bp_adjustment.CREDIT": 90, "bp_adjustment.DEBIT": 147}
+        )
+
+        assert -57 == instance.adjustment
+
+    def test_plug(self):
+        instance = ProductBalances.model_validate(
+            {
+                "bp_adjustment.CREDIT": 1000,
+                "bp_adjustment.DEBIT": 200,
+                "plug.DEBIT": 50,
+            }
+        )
+        assert 750 == instance.adjustment
+
+        instance = ProductBalances.model_validate(
+            {
+                "bp_payment.CREDIT": 789,
+                "bp_adjustment.CREDIT": 23,
+                "bp_adjustment.DEBIT": 101,
+                "plug.DEBIT": 17,
+            }
+        )
+        assert 694 == instance.net
+        assert 694 == instance.balance
+
+    def test_expense(self):
+        instance = ProductBalances.model_validate(
+            {"user_bonus.CREDIT": 0, "user_bonus.DEBIT": 999}
+        )
+
+        assert -999 == instance.expense
+
+    def test_payment(self):
+        instance = ProductBalances.model_validate(
+            {"bp_payout.CREDIT": 1, "bp_payout.DEBIT": 100}
+        )
+
+        assert 99 == instance.payment
+
+    def test_balance(self):
+        instance = ProductBalances.model_validate(
+            {
+                # Payouts from surveys: 1000
+                "bp_payment.CREDIT": 1000,
+                # Adjustments: -200
+                "bp_adjustment.CREDIT": 100,
+                "bp_adjustment.DEBIT": 300,
+                # Expense: -50
+                "user_bonus.CREDIT": 0,
+                "user_bonus.DEBIT": 50,
+                # Prior supplier Payouts = 99
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 100,
+            }
+        )
+
+        # Supplier payments aren't considered in the net
+        assert 750 == instance.net
+
+        # Confirm any Supplier payments are taken out of their balance
+        assert 651 == instance.balance
+
+    def test_retainer(self):
+        instance = ProductBalances.model_validate(
+            {
+                "bp_payment.CREDIT": 1000,
+            }
+        )
+
+        assert 1000 == instance.balance
+        assert 250 == instance.retainer
+
+        instance = ProductBalances.model_validate(
+            {
+                "bp_payment.CREDIT": 1000,
+                # 1001 worth of adjustments, making it negative
+                "bp_adjustment.DEBIT": 1001,
+            }
+        )
+
+        assert -1 == instance.balance
+        assert 0 == instance.retainer
+
+    def test_available_balance(self):
+        instance = ProductBalances.model_validate(
+            {
+                "bp_payment.CREDIT": 1000,
+            }
+        )
+
+        assert 750 == instance.available_balance
+
+        instance = ProductBalances.model_validate(
+            {
+                # Payouts from surveys: $188.37
+                "bp_payment.CREDIT": 18_837,
+                # Adjustments: -$7.53 + $.17
+                "bp_adjustment.CREDIT": 17,
+                "bp_adjustment.DEBIT": 753,
+                # $.15 of those marketplace Failure >> Completes were never
+                #   actually paid out, so plug those positive adjustments
+                "plug.DEBIT": 15,
+                # Expense: -$27.45
+                "user_bonus.CREDIT": 0,
+                "user_bonus.DEBIT": 2_745,
+                # Prior supplier Payouts = $100
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 10_001,
+            }
+        )
+
+        assert 18837 == instance.payout
+        assert -751 == instance.adjustment
+        assert 15341 == instance.net
+
+        # Confirm any Supplier payments are taken out of their balance
+        assert 5341 == instance.balance
+        assert 1335 == instance.retainer
+        assert 4006 == instance.available_balance
+
+    def test_json_schema(self):
+        instance = ProductBalances.model_validate(
+            {
+                # Payouts from surveys: 1000
+                "bp_payment.CREDIT": 1000,
+                # Adjustments: -200
+                "bp_adjustment.CREDIT": 100,
+                "bp_adjustment.DEBIT": 300,
+                # $.80 of those marketplace Failure >> Completes were never
+                #   actually paid out, so plug those positive adjustments
+                "plug.DEBIT": 80,
+                # Expense: -50
+                "user_bonus.CREDIT": 0,
+                "user_bonus.DEBIT": 50,
+                # Prior supplier Payouts = 99
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 100,
+            }
+        )
+
+        assert isinstance(instance.model_json_schema(), dict)
+        openapi_fields = list(instance.model_json_schema()["properties"].keys())
+
+        # Ensure the SkipJsonSchema is working..
+        assert "mp_payment_credit" not in openapi_fields
+        assert "mp_payment_debit" not in openapi_fields
+        assert "mp_adjustment_credit" not in openapi_fields
+        assert "mp_adjustment_debit" not in openapi_fields
+        assert "bp_payment_debit" not in openapi_fields
+        assert "plug_credit" not in openapi_fields
+        assert "plug_debit" not in openapi_fields
+
+        # Confirm the @property computed fields show up in openapi. I don't
+        #   know how to do that yet... so this is check to confirm they're
+        #   known computed fields for now
+        computed_fields = list(instance.model_computed_fields.keys())
+        assert "payout" in computed_fields
+        assert "adjustment" in computed_fields
+        assert "expense" in computed_fields
+        assert "payment" in computed_fields
+        assert "net" in computed_fields
+        assert "balance" in computed_fields
+        assert "retainer" in computed_fields
+        assert "available_balance" in computed_fields
+
+    def test_repr(self):
+        instance = ProductBalances.model_validate(
+            {
+                # Payouts from surveys: 1000
+                "bp_payment.CREDIT": 1000,
+                # Adjustments: -200
+                "bp_adjustment.CREDIT": 100,
+                "bp_adjustment.DEBIT": 300,
+                # $.80 of those marketplace Failure >> Completes were never
+                #   actually paid out, so plug those positive adjustments
+                "plug.DEBIT": 80,
+                # Expense: -50
+                "user_bonus.CREDIT": 0,
+                "user_bonus.DEBIT": 50,
+                # Prior supplier Payouts = 99
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 100,
+            }
+        )
+
+        assert "Total Adjustment: -$2.80" in str(instance)
+
+
+class TestBusinessBalanceInitialize:
+
+    def test_validate_product_ids(self):
+        instance1 = ProductBalances.model_validate(
+            {"bp_payment.CREDIT": 500, "bp_adjustment.DEBIT": 40}
+        )
+
+        instance2 = ProductBalances.model_validate(
+            {"bp_payment.CREDIT": 500, "bp_adjustment.DEBIT": 40}
+        )
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            BusinessBalances.model_validate(
+                {"product_balances": [instance1, instance2]}
+            )
+        assert "'product_id' must be set for BusinessBalance children" in str(cm.value)
+
+        # Confirm that once you add them, it successfully initializes
+        instance1.product_id = uuid4().hex
+        instance2.product_id = uuid4().hex
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert isinstance(instance, BusinessBalances)
+
+    def test_payout(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.DEBIT": 40,
+            }
+        )
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.DEBIT": 40,
+            }
+        )
+
+        # Confirm the base payouts are as expected.
+        assert instance1.payout == 500
+        assert instance2.payout == 500
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.payout == 1_000
+
+    def test_adjustment(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+            }
+        )
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+            }
+        )
+
+        # Confirm the base adjustment are as expected.
+        assert instance1.adjustment == -30
+        assert instance2.adjustment == -30
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.adjustment == -60
+
+    def test_expense(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+            }
+        )
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+            }
+        )
+
+        # Confirm the base adjustment are as expected.
+        assert instance1.expense == -4
+        assert instance2.expense == -4
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.expense == -8
+
+    def test_net(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+            }
+        )
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+            }
+        )
+
+        # Confirm the simple net
+        assert instance1.net == 466
+        assert instance2.net == 466
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.net == 466 * 2
+
+    def test_payment(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 10_001,
+            }
+        )
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 500,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 40,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 10_001,
+            }
+        )
+        assert instance1.payment == 10_000
+        assert instance2.payment == 10_000
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.payment == 20_000
+
+    def test_balance(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 50_000,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 500,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 10_001,
+            }
+        )
+        assert instance1.balance == 39_506
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 40_000,
+                "bp_adjustment.CREDIT": 2_000,
+                "bp_adjustment.DEBIT": 400,
+                "plug.DEBIT": 983,
+                "user_bonus.DEBIT": 392,
+                "user_bonus.CREDIT": 0,
+                "bp_payout.CREDIT": 0,
+                "bp_payout.DEBIT": 8_000,
+            }
+        )
+        assert instance2.balance == 32_225
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.balance == 39_506 + 32_225
+
+    def test_retainer(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 50_000,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 500,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 10_001,
+            }
+        )
+        assert instance1.balance == 39_506
+        assert instance1.retainer == 9_876
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 40_000,
+                "bp_adjustment.CREDIT": 2_000,
+                "bp_adjustment.DEBIT": 400,
+                "plug.DEBIT": 983,
+                "user_bonus.DEBIT": 392,
+                "user_bonus.CREDIT": 0,
+                "bp_payout.CREDIT": 0,
+                "bp_payout.DEBIT": 8_000,
+            }
+        )
+        assert instance2.balance == 32_225
+        assert instance2.retainer == 8_056
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.retainer == 9_876 + 8_056
+
+    def test_available_balance(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 50_000,
+                "bp_adjustment.CREDIT": 20,
+                "bp_adjustment.DEBIT": 500,
+                "plug.DEBIT": 10,
+                "user_bonus.DEBIT": 5,
+                "user_bonus.CREDIT": 1,
+                "bp_payout.CREDIT": 1,
+                "bp_payout.DEBIT": 10_001,
+            }
+        )
+        assert instance1.balance == 39_506
+        assert instance1.retainer == 9_876
+        assert instance1.available_balance == 39_506 - 9_876
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 40_000,
+                "bp_adjustment.CREDIT": 2_000,
+                "bp_adjustment.DEBIT": 400,
+                "plug.DEBIT": 983,
+                "user_bonus.DEBIT": 392,
+                "user_bonus.CREDIT": 0,
+                "bp_payout.CREDIT": 0,
+                "bp_payout.DEBIT": 8_000,
+            }
+        )
+        assert instance2.balance == 32_225
+        assert instance2.retainer == 8_056
+        assert instance2.available_balance == 32_225 - 8_056
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert instance.retainer == 9_876 + 8_056
+        assert instance.available_balance == instance.balance - (9_876 + 8_056)
+
+    def test_negative_net(self):
+        instance1 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 50_000,
+                "bp_adjustment.DEBIT": 50_001,
+                "bp_payout.DEBIT": 4_999,
+            }
+        )
+        assert 50_000 == instance1.payout
+        assert -50_001 == instance1.adjustment
+        assert 4_999 == instance1.payment
+
+        assert -1 == instance1.net
+        assert -5_000 == instance1.balance
+        assert 0 == instance1.available_balance
+
+        instance2 = ProductBalances.model_validate(
+            {
+                "product_id": uuid4().hex,
+                "bp_payment.CREDIT": 50_000,
+                "bp_adjustment.DEBIT": 10_000,
+                "bp_payout.DEBIT": 10_000,
+            }
+        )
+        assert 50_000 == instance2.payout
+        assert -10_000 == instance2.adjustment
+        assert 10_000 == instance2.payment
+
+        assert 40_000 == instance2.net
+        assert 30_000 == instance2.balance
+        assert 22_500 == instance2.available_balance
+
+        # Now confirm that they're correct in the BusinessBalance
+        instance = BusinessBalances.model_validate(
+            {"product_balances": [instance1, instance2]}
+        )
+        assert 100_000 == instance.payout
+        assert -60_001 == instance.adjustment
+        assert 14_999 == instance.payment
+
+        assert 39_999 == instance.net
+        assert 25_000 == instance.balance
+
+        # Compare the retainers together. We can't just calculate the retainer
+        # on the Business.balance because it'll be "masked" by any Products
+        # that have a negative balance and actually reduce the Business's
+        # retainer as a whole. Therefore, we need to sum together each of the
+        # retainers from the child Products
+        assert 0 == instance1.retainer
+        assert 7_500 == instance2.retainer
+        assert 6_250 == instance.balance * 0.25
+        assert 6_250 != instance.retainer
+        assert 7_500 == instance.retainer
+        assert 25_000 - 7_500 == instance.available_balance
+
+    def test_str(self):
+        instance = BusinessBalances.model_validate(
+            {
+                "product_balances": [
+                    ProductBalances.model_validate(
+                        {
+                            "product_id": uuid4().hex,
+                            "bp_payment.CREDIT": 50_000,
+                            "bp_adjustment.DEBIT": 50_001,
+                            "bp_payout.DEBIT": 4_999,
+                        }
+                    ),
+                    ProductBalances.model_validate(
+                        {
+                            "product_id": uuid4().hex,
+                            "bp_payment.CREDIT": 50_000,
+                            "bp_adjustment.DEBIT": 10_000,
+                            "bp_payout.DEBIT": 10_000,
+                        }
+                    ),
+                ]
+            }
+        )
+
+        assert "Products: 2" in str(instance)
+        assert "Total Adjustment: -$600.01" in str(instance)
+        assert "Available Balance: $175.00" in str(instance)
+
+    def test_from_json(self):
+        s = '{"product_balances":[{"product_id":"7485124190274248bc14132755c8fc3b","bp_payment_credit":1184,"adjustment_credit":0,"adjustment_debit":0,"supplier_credit":0,"supplier_debit":0,"user_bonus_credit":0,"user_bonus_debit":0,"payout":1184,"adjustment":0,"expense":0,"net":1184,"payment":0,"balance":1184,"retainer":296,"available_balance":888,"adjustment_percent":0.0}],"payout":1184,"adjustment":0,"expense":0,"net":1184,"payment":0,"balance":1184,"retainer":296,"available_balance":888,"adjustment_percent":0.0}'
+        instance = BusinessBalances.model_validate_json(s)
+
+        assert instance.payout == 1184
+        assert instance.available_balance == 888
+        assert instance.retainer == 296
+        assert len(instance.product_balances) == 1
+        assert instance.adjustment_percent == 0.0
+        assert instance.expense == 0
+
+        p = instance.product_balances[0]
+        assert p.payout == 1184
+        assert p.available_balance == 888
+        assert p.retainer == 296
+
+
+@pytest.mark.parametrize(
+    argnames="offset, duration",
+    argvalues=list(
+        iter_product(
+            ["12h", "2D"],
+            [timedelta(days=2), timedelta(days=5)],
+        )
+    ),
+)
+class TestProductFinanceData:
+
+    def test_base(
+        self,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        mnt_filepath,
+        session_with_tx_factory,
+        product,
+        user_factory,
+        start,
+        duration,
+        delete_df_collection,
+        thl_lm,
+        create_main_accounts,
+    ):
+        from generalresearch.models.thl.user import User
+
+        # -- Build & Setup
+        # assert ledger_collection.start is None
+        # assert ledger_collection.offset is None
+        u: User = user_factory(product=product, created=ledger_collection.start)
+
+        for item in ledger_collection.items:
+
+            for s_idx in range(3):
+                rand_item_time = fake.date_time_between(
+                    start_date=item.start,
+                    end_date=item.finish,
+                    tzinfo=timezone.utc,
+                )
+                session_with_tx_factory(started=rand_item_time, user=u)
+
+            item.initial_load(overwrite=True)
+
+        # Confirm any of the items are archived
+        assert ledger_collection.progress.has_archive.eq(True).all()
+
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+        # assert pop_ledger_merge.progress.has_archive.eq(True).all()
+
+        item_finishes = [i.finish for i in ledger_collection.items]
+        item_finishes.sort(reverse=True)
+        last_item_finish = item_finishes[0]
+
+        # --
+        account = thl_lm.get_account_or_create_bp_wallet(product=u.product)
+
+        ddf = pop_ledger_merge.ddf(
+            force_rr_latest=False,
+            include_partial=True,
+            columns=numerical_col_names + ["time_idx", "account_id"],
+            filters=[
+                ("account_id", "==", account.uuid),
+                ("time_idx", ">=", start),
+                ("time_idx", "<", start + duration),
+            ],
+        )
+
+        df: pd.DataFrame = client_no_amm.compute(collections=ddf, sync=True)
+
+        assert isinstance(df, pd.DataFrame)
+        assert not df.empty
+
+        # --
+
+        df = df.groupby([pd.Grouper(key="time_idx", freq="D"), "account_id"]).sum()
+        res = POPFinancial.list_from_pandas(df, accounts=[account])
+
+        assert isinstance(res, list)
+        assert isinstance(res[0], POPFinancial)
+
+        # On this, we can assert all products are the same, and that there are
+        # no overlapping time intervals
+        assert 1 == len(set(list([i.product_id for i in res])))
+        assert len(res) == len(set(list([i.time for i in res])))
+
+
+@pytest.mark.parametrize(
+    argnames="offset, duration",
+    argvalues=list(
+        iter_product(
+            ["12h", "2D"],
+            [timedelta(days=2), timedelta(days=5)],
+        )
+    ),
+)
+class TestPOPFinancialData:
+
+    def test_base(
+        self,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        mnt_filepath,
+        user_factory,
+        product,
+        start,
+        duration,
+        create_main_accounts,
+        session_with_tx_factory,
+        session_manager,
+        thl_lm,
+        delete_df_collection,
+        delete_ledger_db,
+    ):
+        # -- Build & Setup
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+        # assert ledger_collection.start is None
+        # assert ledger_collection.offset is None
+
+        users = []
+        for idx in range(5):
+            u = user_factory(product=product)
+
+            for item in ledger_collection.items:
+                rand_item_time = fake.date_time_between(
+                    start_date=item.start,
+                    end_date=item.finish,
+                    tzinfo=timezone.utc,
+                )
+
+                session_with_tx_factory(started=rand_item_time, user=u)
+                item.initial_load(overwrite=True)
+
+            users.append(u)
+
+        # Confirm any of the items are archived
+        assert ledger_collection.progress.has_archive.eq(True).all()
+
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+        # assert pop_ledger_merge.progress.has_archive.eq(True).all()
+
+        item_finishes = [i.finish for i in ledger_collection.items]
+        item_finishes.sort(reverse=True)
+        last_item_finish = item_finishes[0]
+
+        accounts = []
+        for user in users:
+            account = thl_lm.get_account_or_create_bp_wallet(product=u.product)
+            accounts.append(account)
+        account_ids = [a.uuid for a in accounts]
+
+        # --
+
+        ddf = pop_ledger_merge.ddf(
+            force_rr_latest=False,
+            include_partial=True,
+            columns=numerical_col_names + ["time_idx", "account_id"],
+            filters=[
+                ("account_id", "in", account_ids),
+                ("time_idx", ">=", start),
+                ("time_idx", "<", last_item_finish),
+            ],
+        )
+        df: pd.DataFrame = client_no_amm.compute(collections=ddf, sync=True)
+
+        df = df.groupby([pd.Grouper(key="time_idx", freq="D"), "account_id"]).sum()
+        res = POPFinancial.list_from_pandas(df, accounts=accounts)
+
+        assert isinstance(res, list)
+        for i in res:
+            assert isinstance(i, POPFinancial)
+
+            # This does not return the AccountID, it's the Product ID
+            assert i.product_id in [u.product_id for u in users]
+
+        # 1 Product, multiple Users
+        assert len(users) == len(accounts)
+
+        # We group on days, and duration is a parameter to parametrize
+        assert isinstance(duration, timedelta)
+
+        # -- Teardown
+        delete_df_collection(ledger_collection)
+
+
+@pytest.mark.parametrize(
+    argnames="offset, duration",
+    argvalues=list(
+        iter_product(
+            ["12h", "1D"],
+            [timedelta(days=2), timedelta(days=3)],
+        )
+    ),
+)
+class TestBusinessBalanceData:
+    def test_from_pandas(
+        self,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        user_factory,
+        product,
+        create_main_accounts,
+        session_factory,
+        thl_lm,
+        session_manager,
+        start,
+        thl_web_rr,
+        duration,
+        delete_df_collection,
+        delete_ledger_db,
+        session_with_tx_factory,
+        offset,
+        rm_ledger_collection,
+    ):
+        from generalresearch.models.thl.user import User
+        from generalresearch.models.thl.ledger import LedgerAccount
+
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+        rm_ledger_collection()
+
+        for idx in range(5):
+            u: User = user_factory(product=product, created=ledger_collection.start)
+
+            for item in ledger_collection.items:
+                item_time = fake.date_time_between(
+                    start_date=item.start,
+                    end_date=item.finish,
+                    tzinfo=timezone.utc,
+                )
+                session_with_tx_factory(started=item_time, user=u)
+                item.initial_load(overwrite=True)
+
+        # Confirm any of the items are archived
+        assert ledger_collection.progress.has_archive.eq(True).all()
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+        # assert pop_ledger_merge.progress.has_archive.eq(True).all()
+
+        account: LedgerAccount = thl_lm.get_account_or_create_bp_wallet(product=product)
+
+        ddf = pop_ledger_merge.ddf(
+            force_rr_latest=False,
+            include_partial=True,
+            columns=numerical_col_names + ["account_id"],
+            filters=[("account_id", "in", [account.uuid])],
+        )
+        ddf = ddf.groupby("account_id").sum()
+        df: pd.DataFrame = client_no_amm.compute(collections=ddf, sync=True)
+
+        assert isinstance(df, pd.DataFrame)
+
+        instance = BusinessBalances.from_pandas(
+            input_data=df, accounts=[account], thl_pg_config=thl_web_rr
+        )
+        balance: int = thl_lm.get_account_balance(account=account)
+
+        assert instance.balance == balance
+        assert instance.net == balance
+        assert instance.payout == balance
+
+        assert instance.payment == 0
+        assert instance.adjustment == 0
+        assert instance.adjustment_percent == 0.0
+
+        assert instance.expense == 0
+
+        # Cleanup
+        delete_ledger_db()
+        delete_df_collection(coll=ledger_collection)
diff --git a/tests/models/thl/__init__.py b/tests/models/thl/__init__.py
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/tests/models/thl/__init__.py
@@ -0,0 +1 @@
+
diff --git a/tests/models/thl/question/__init__.py b/tests/models/thl/question/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/thl/question/__init__.py
diff --git a/tests/models/thl/question/test_question_info.py b/tests/models/thl/question/test_question_info.py
new file mode 100644
index 0000000..945ee7a
--- /dev/null
+++ b/tests/models/thl/question/test_question_info.py
@@ -0,0 +1,146 @@
+from generalresearch.models.thl.profiling.upk_property import (
+    UpkProperty,
+    ProfilingInfo,
+)
+
+
+class TestQuestionInfo:
+
+    def test_init(self):
+
+        s = (
+            '[{"property_label": "hispanic", "cardinality": "*", "prop_type": "i", "country_iso": "us", '
+            '"property_id": "05170ae296ab49178a075cab2a2073a6", "item_id": "7911ec1468b146ee870951f8ae9cbac1", '
+            '"item_label": "panamanian", "gold_standard": 1, "options": [{"id": "c358c11e72c74fa2880358f1d4be85ab", '
+            '"label": "not_hispanic"}, {"id": "b1d6c475770849bc8e0200054975dc9c", "label": "yes_hispanic"}, '
+            '{"id": "bd1eb44495d84b029e107c188003c2bd", "label": "other_hispanic"}, '
+            '{"id": "f290ad5e75bf4f4ea94dc847f57c1bd3", "label": "mexican"}, '
+            '{"id": "49f50f2801bd415ea353063bfc02d252", "label": "puerto_rican"}, '
+            '{"id": "dcbe005e522f4b10928773926601f8bf", "label": "cuban"}, '
+            '{"id": "467ef8ddb7ac4edb88ba9ef817cbb7e9", "label": "salvadoran"}, '
+            '{"id": "3c98e7250707403cba2f4dc7b877c963", "label": "dominican"}, '
+            '{"id": "981ee77f6d6742609825ef54fea824a8", "label": "guatemalan"}, '
+            '{"id": "81c8057b809245a7ae1b8a867ea6c91e", "label": "colombian"}, '
+            '{"id": "513656d5f9e249fa955c3b527d483b93", "label": "honduran"}, '
+            '{"id": "afc8cddd0c7b4581bea24ccd64db3446", "label": "ecuadorian"}, '
+            '{"id": "61f34b36e80747a89d85e1eb17536f84", "label": "argentinian"}, '
+            '{"id": "5330cfa681d44aa8ade3a6d0ea198e44", "label": "peruvian"}, '
+            '{"id": "e7bceaffd76e486596205d8545019448", "label": "nicaraguan"}, '
+            '{"id": "b7bbb2ebf8424714962e6c4f43275985", "label": "spanish"}, '
+            '{"id": "8bf539785e7a487892a2f97e52b1932d", "label": "venezuelan"}, '
+            '{"id": "7911ec1468b146ee870951f8ae9cbac1", "label": "panamanian"}], "category": [{"id": '
+            '"4fd8381d5a1c4409ab007ca254ced084", "label": "Demographic", "path": "/Demographic", '
+            '"adwords_vertical_id": null}]}, {"property_label": "ethnic_group", "cardinality": "*", "prop_type": '
+            '"i", "country_iso": "us", "property_id": "15070958225d4132b7f6674fcfc979f6", "item_id": '
+            '"64b7114cf08143949e3bcc3d00a5d8a0", "item_label": "other_ethnicity", "gold_standard": 1, "options": [{'
+            '"id": "a72e97f4055e4014a22bee4632cbf573", "label": "caucasians"}, '
+            '{"id": "4760353bc0654e46a928ba697b102735", "label": "black_or_african_american"}, '
+            '{"id": "20ff0a2969fa4656bbda5c3e0874e63b", "label": "asian"}, '
+            '{"id": "107e0a79e6b94b74926c44e70faf3793", "label": "native_hawaiian_or_other_pacific_islander"}, '
+            '{"id": "900fa12691d5458c8665bf468f1c98c1", "label": "native_americans"}, '
+            '{"id": "64b7114cf08143949e3bcc3d00a5d8a0", "label": "other_ethnicity"}], "category": [{"id": '
+            '"4fd8381d5a1c4409ab007ca254ced084", "label": "Demographic", "path": "/Demographic", '
+            '"adwords_vertical_id": null}]}, {"property_label": "educational_attainment", "cardinality": "?", '
+            '"prop_type": "i", "country_iso": "us", "property_id": "2637783d4b2b4075b93e2a156e16e1d8", "item_id": '
+            '"934e7b81d6744a1baa31bbc51f0965d5", "item_label": "other_education", "gold_standard": 1, "options": [{'
+            '"id": "df35ef9e474b4bf9af520aa86630202d", "label": "3rd_grade_completion"}, '
+            '{"id": "83763370a1064bd5ba76d1b68c4b8a23", "label": "8th_grade_completion"}, '
+            '{"id": "f0c25a0670c340bc9250099dcce50957", "label": "not_high_school_graduate"}, '
+            '{"id": "02ff74c872bd458983a83847e1a9f8fd", "label": "high_school_completion"}, '
+            '{"id": "ba8beb807d56441f8fea9b490ed7561c", "label": "vocational_program_completion"}, '
+            '{"id": "65373a5f348a410c923e079ddbb58e9b", "label": "some_college_completion"}, '
+            '{"id": "2d15d96df85d4cc7b6f58911fdc8d5e2", "label": "associate_academic_degree_completion"}, '
+            '{"id": "497b1fedec464151b063cd5367643ffa", "label": "bachelors_degree_completion"}, '
+            '{"id": "295133068ac84424ae75e973dc9f2a78", "label": "some_graduate_completion"}, '
+            '{"id": "e64f874faeff4062a5aa72ac483b4b9f", "label": "masters_degree_completion"}, '
+            '{"id": "cbaec19a636d476385fb8e7842b044f5", "label": "doctorate_degree_completion"}, '
+            '{"id": "934e7b81d6744a1baa31bbc51f0965d5", "label": "other_education"}], "category": [{"id": '
+            '"4fd8381d5a1c4409ab007ca254ced084", "label": "Demographic", "path": "/Demographic", '
+            '"adwords_vertical_id": null}]}, {"property_label": "household_spoken_language", "cardinality": "*", '
+            '"prop_type": "i", "country_iso": "us", "property_id": "5a844571073d482a96853a0594859a51", "item_id": '
+            '"62b39c1de141422896ad4ab3c4318209", "item_label": "dut", "gold_standard": 1, "options": [{"id": '
+            '"f65cd57b79d14f0f8460761ce41ec173", "label": "ara"}, {"id": "6d49de1f8f394216821310abd29392d9", '
+            '"label": "zho"}, {"id": "be6dc23c2bf34c3f81e96ddace22800d", "label": "eng"}, '
+            '{"id": "ddc81f28752d47a3b1c1f3b8b01a9b07", "label": "fre"}, {"id": "2dbb67b29bd34e0eb630b1b8385542ca", '
+            '"label": "ger"}, {"id": "a747f96952fc4b9d97edeeee5120091b", "label": "hat"}, '
+            '{"id": "7144b04a3219433baac86273677551fa", "label": "hin"}, {"id": "e07ff3e82c7149eaab7ea2b39ee6a6dc", '
+            '"label": "ita"}, {"id": "b681eff81975432ebfb9f5cc22dedaa3", "label": "jpn"}, '
+            '{"id": "5cb20440a8f64c9ca62fb49c1e80cdef", "label": "kor"}, {"id": "171c4b77d4204bc6ac0c2b81e38a10ff", '
+            '"label": "pan"}, {"id": "8c3ec18e6b6c4a55a00dd6052e8e84fb", "label": "pol"}, '
+            '{"id": "3ce074d81d384dd5b96f1fb48f87bf01", "label": "por"}, {"id": "6138dc951990458fa88a666f6ddd907b", '
+            '"label": "rus"}, {"id": "e66e5ecc07df4ebaa546e0b436f034bd", "label": "spa"}, '
+            '{"id": "5a981b3d2f0d402a96dd2d0392ec2fcb", "label": "tgl"}, {"id": "b446251bd211403487806c4d0a904981", '
+            '"label": "vie"}, {"id": "92fb3ee337374e2db875fb23f52eed46", "label": "xxx"}, '
+            '{"id": "8b1f590f12f24cc1924d7bdcbe82081e", "label": "ind"}, {"id": "bf3f4be556a34ff4b836420149fd2037", '
+            '"label": "tur"}, {"id": "87ca815c43ba4e7f98cbca98821aa508", "label": "zul"}, '
+            '{"id": "0adbf915a7a64d67a87bb3ce5d39ca54", "label": "may"}, {"id": "62b39c1de141422896ad4ab3c4318209", '
+            '"label": "dut"}], "category": [{"id": "4fd8381d5a1c4409ab007ca254ced084", "label": "Demographic", '
+            '"path": "/Demographic", "adwords_vertical_id": null}]}, {"property_label": "gender", "cardinality": '
+            '"?", "prop_type": "i", "country_iso": "us", "property_id": "73175402104741549f21de2071556cd7", '
+            '"item_id": "093593e316344cd3a0ac73669fca8048", "item_label": "other_gender", "gold_standard": 1, '
+            '"options": [{"id": "b9fc5ea07f3a4252a792fd4a49e7b52b", "label": "male"}, '
+            '{"id": "9fdb8e5e18474a0b84a0262c21e17b56", "label": "female"}, '
+            '{"id": "093593e316344cd3a0ac73669fca8048", "label": "other_gender"}], "category": [{"id": '
+            '"4fd8381d5a1c4409ab007ca254ced084", "label": "Demographic", "path": "/Demographic", '
+            '"adwords_vertical_id": null}]}, {"property_label": "age_in_years", "cardinality": "?", "prop_type": '
+            '"n", "country_iso": "us", "property_id": "94f7379437874076b345d76642d4ce6d", "item_id": null, '
+            '"item_label": null, "gold_standard": 1, "category": [{"id": "4fd8381d5a1c4409ab007ca254ced084", '
+            '"label": "Demographic", "path": "/Demographic", "adwords_vertical_id": null}]}, {"property_label": '
+            '"children_age_gender", "cardinality": "*", "prop_type": "i", "country_iso": "us", "property_id": '
+            '"e926142fcea94b9cbbe13dc7891e1e7f", "item_id": "b7b8074e95334b008e8958ccb0a204f1", "item_label": '
+            '"female_18", "gold_standard": 1, "options": [{"id": "16a6448ec24c48d4993d78ebee33f9b4", '
+            '"label": "male_under_1"}, {"id": "809c04cb2e3b4a3bbd8077ab62cdc220", "label": "female_under_1"}, '
+            '{"id": "295e05bb6a0843bc998890b24c99841e", "label": "no_children"}, '
+            '{"id": "142cb948d98c4ae8b0ef2ef10978e023", "label": "male_0"}, '
+            '{"id": "5a5c1b0e9abc48a98b3bc5f817d6e9d0", "label": "male_1"}, '
+            '{"id": "286b1a9afb884bdfb676dbb855479d1e", "label": "male_2"}, '
+            '{"id": "942ca3cda699453093df8cbabb890607", "label": "male_3"}, '
+            '{"id": "995818d432f643ec8dd17e0809b24b56", "label": "male_4"}, '
+            '{"id": "f38f8b57f25f4cdea0f270297a1e7a5c", "label": "male_5"}, '
+            '{"id": "975df709e6d140d1a470db35023c432d", "label": "male_6"}, '
+            '{"id": "f60bd89bbe0f4e92b90bccbc500467c2", "label": "male_7"}, '
+            '{"id": "6714ceb3ed5042c0b605f00b06814207", "label": "male_8"}, '
+            '{"id": "c03c2f8271d443cf9df380e84b4dea4c", "label": "male_9"}, '
+            '{"id": "11690ee0f5a54cb794f7ddd010d74fa2", "label": "male_10"}, '
+            '{"id": "17bef9a9d14b4197b2c5609fa94b0642", "label": "male_11"}, '
+            '{"id": "e79c8338fe28454f89ccc78daf6f409a", "label": "male_12"}, '
+            '{"id": "3a4f87acb3fa41f4ae08dfe2858238c1", "label": "male_13"}, '
+            '{"id": "36ffb79d8b7840a7a8cb8d63bbc8df59", "label": "male_14"}, '
+            '{"id": "1401a508f9664347aee927f6ec5b0a40", "label": "male_15"}, '
+            '{"id": "6e0943c5ec4a4f75869eb195e3eafa50", "label": "male_16"}, '
+            '{"id": "47d4b27b7b5242758a9fff13d3d324cf", "label": "male_17"}, '
+            '{"id": "9ce886459dd44c9395eb77e1386ab181", "label": "female_0"}, '
+            '{"id": "6499ccbf990d4be5b686aec1c7353fd8", "label": "female_1"}, '
+            '{"id": "d85ceaa39f6d492abfc8da49acfd14f2", "label": "female_2"}, '
+            '{"id": "18edb45c138e451d8cb428aefbb80f9c", "label": "female_3"}, '
+            '{"id": "bac6f006ed9f4ccf85f48e91e99fdfd1", "label": "female_4"}, '
+            '{"id": "5a6a1a8ad00c4ce8be52dcb267b034ff", "label": "female_5"}, '
+            '{"id": "6bff0acbf6364c94ad89507bcd5f4f45", "label": "female_6"}, '
+            '{"id": "d0d56a0a6b6f4516a366a2ce139b4411", "label": "female_7"}, '
+            '{"id": "bda6028468044b659843e2bef4db2175", "label": "female_8"}, '
+            '{"id": "dbb6d50325464032b456357b1a6e5e9c", "label": "female_9"}, '
+            '{"id": "b87a93d7dc1348edac5e771684d63fb8", "label": "female_10"}, '
+            '{"id": "11449d0d98f14e27ba47de40b18921d7", "label": "female_11"}, '
+            '{"id": "16156501e97b4263962cbbb743840292", "label": "female_12"}, '
+            '{"id": "04ee971c89a345cc8141a45bce96050c", "label": "female_13"}, '
+            '{"id": "e818d310bfbc4faba4355e5d2ed49d4f", "label": "female_14"}, '
+            '{"id": "440d25e078924ba0973163153c417ed6", "label": "female_15"}, '
+            '{"id": "78ff804cc9b441c5a524bd91e3d1f8bf", "label": "female_16"}, '
+            '{"id": "4b04d804d7d84786b2b1c22e4ed440f5", "label": "female_17"}, '
+            '{"id": "28bc848cd3ff44c3893c76bfc9bc0c4e", "label": "male_18"}, '
+            '{"id": "b7b8074e95334b008e8958ccb0a204f1", "label": "female_18"}], "category": [{"id": '
+            '"e18ba6e9d51e482cbb19acf2e6f505ce", "label": "Parenting", "path": "/People & Society/Family & '
+            'Relationships/Family/Parenting", "adwords_vertical_id": "58"}]}, {"property_label": "home_postal_code", '
+            '"cardinality": "?", "prop_type": "x", "country_iso": "us", "property_id": '
+            '"f3b32ebe78014fbeb1ed6ff77d6338bf", "item_id": null, "item_label": null, "gold_standard": 1, '
+            '"category": [{"id": "4fd8381d5a1c4409ab007ca254ced084", "label": "Demographic", "path": "/Demographic", '
+            '"adwords_vertical_id": null}]}, {"property_label": "household_income", "cardinality": "?", "prop_type": '
+            '"n", "country_iso": "us", "property_id": "ff5b1d4501d5478f98de8c90ef996ac1", "item_id": null, '
+            '"item_label": null, "gold_standard": 1, "category": [{"id": "4fd8381d5a1c4409ab007ca254ced084", '
+            '"label": "Demographic", "path": "/Demographic", "adwords_vertical_id": null}]}]'
+        )
+        instance_list = ProfilingInfo.validate_json(s)
+
+        assert isinstance(instance_list, list)
+        for i in instance_list:
+            assert isinstance(i, UpkProperty)
diff --git a/tests/models/thl/question/test_user_info.py b/tests/models/thl/question/test_user_info.py
new file mode 100644
index 0000000..0bbbc78
--- /dev/null
+++ b/tests/models/thl/question/test_user_info.py
@@ -0,0 +1,32 @@
+from generalresearch.models.thl.profiling.user_info import UserInfo
+
+
+class TestUserInfo:
+
+    def test_init(self):
+
+        s = (
+            '{"user_profile_knowledge": [], "marketplace_profile_knowledge": [{"source": "d", "question_id": '
+            '"1", "answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "pr", '
+            '"question_id": "3", "answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": '
+            '"h", "question_id": "60", "answer": ["58"], "created": "2023-11-07T16:41:05.234096Z"}, '
+            '{"source": "c", "question_id": "43", "answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, '
+            '{"source": "s", "question_id": "211", "answer": ["111"], "created": '
+            '"2023-11-07T16:41:05.234096Z"}, {"source": "s", "question_id": "1843", "answer": ["111"], '
+            '"created": "2023-11-07T16:41:05.234096Z"}, {"source": "h", "question_id": "13959", "answer": ['
+            '"244155"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "c", "question_id": "33092", '
+            '"answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "c", "question_id": "gender", '
+            '"answer": ["10682"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "e", "question_id": '
+            '"gender", "answer": ["male"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "f", '
+            '"question_id": "gender", "answer": ["male"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": '
+            '"i", "question_id": "gender", "answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, '
+            '{"source": "c", "question_id": "137510", "answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, '
+            '{"source": "m", "question_id": "gender", "answer": ["1"], "created": '
+            '"2023-11-07T16:41:05.234096Z"}, {"source": "o", "question_id": "gender", "answer": ["male"], '
+            '"created": "2023-11-07T16:41:05.234096Z"}, {"source": "c", "question_id": "gender_plus", "answer": ['
+            '"7657644"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "i", "question_id": '
+            '"gender_plus", "answer": ["1"], "created": "2023-11-07T16:41:05.234096Z"}, {"source": "c", '
+            '"question_id": "income_level", "answer": ["9071"], "created": "2023-11-07T16:41:05.234096Z"}]}'
+        )
+        instance = UserInfo.model_validate_json(s)
+        assert isinstance(instance, UserInfo)
diff --git a/tests/models/thl/test_adjustments.py b/tests/models/thl/test_adjustments.py
new file mode 100644
index 0000000..15d01d0
--- /dev/null
+++ b/tests/models/thl/test_adjustments.py
@@ -0,0 +1,688 @@
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+
+import pytest
+
+from generalresearch.models import Source
+from generalresearch.models.thl.session import (
+    Wall,
+    Status,
+    StatusCode1,
+    WallAdjustedStatus,
+    SessionAdjustedStatus,
+)
+
+started1 = datetime(2023, 1, 1, tzinfo=timezone.utc)
+started2 = datetime(2023, 1, 1, 0, 10, 0, tzinfo=timezone.utc)
+finished1 = started1 + timedelta(minutes=10)
+finished2 = started2 + timedelta(minutes=10)
+
+adj_ts = datetime(2023, 2, 2, tzinfo=timezone.utc)
+adj_ts2 = datetime(2023, 2, 3, tzinfo=timezone.utc)
+adj_ts3 = datetime(2023, 2, 4, tzinfo=timezone.utc)
+
+
+class TestProductAdjustments:
+
+    @pytest.mark.parametrize("payout", [".6", "1", "1.8", "2", "500.0000"])
+    def test_determine_bp_payment_no_rounding(self, product_factory, payout):
+        p1 = product_factory(commission_pct=Decimal("0.05"))
+        res = p1.determine_bp_payment(thl_net=Decimal(payout))
+        assert isinstance(res, Decimal)
+        assert res == Decimal(payout) * Decimal("0.95")
+
+    @pytest.mark.parametrize("payout", [".01", ".05", ".5"])
+    def test_determine_bp_payment_rounding(self, product_factory, payout):
+        p1 = product_factory(commission_pct=Decimal("0.05"))
+        res = p1.determine_bp_payment(thl_net=Decimal(payout))
+        assert isinstance(res, Decimal)
+        assert res != Decimal(payout) * Decimal("0.95")
+
+
+class TestSessionAdjustments:
+
+    def test_status_complete(self, session_factory, user):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpi=Decimal(1),
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        # Confirm only the last Wall Event is a complete
+        assert not s1.wall_events[0].status == Status.COMPLETE
+        assert s1.wall_events[1].status == Status.COMPLETE
+
+        # Confirm the Session is marked as finished and the simple brokerage
+        #   payout calculation is correct.
+        status, status_code_1 = s1.determine_session_status()
+        assert status == Status.COMPLETE
+        assert status_code_1 == StatusCode1.COMPLETE
+
+
+class TestAdjustments:
+
+    def test_finish_with_status(self, session_factory, user, session_manager):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpi=Decimal(1),
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        status, status_code_1 = s1.determine_session_status()
+        payout = user.product.determine_bp_payment(Decimal(1))
+        session_manager.finish_with_status(
+            session=s1,
+            status=status,
+            status_code_1=status_code_1,
+            payout=payout,
+            finished=finished2,
+        )
+
+        assert Decimal("0.95") == payout
+
+    def test_never_adjusted(self, session_factory, user, session_manager):
+        s1 = session_factory(
+            user=user,
+            wall_count=5,
+            wall_req_cpi=Decimal(1),
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            payout=Decimal("0.95"),
+            finished=finished2,
+        )
+
+        # Confirm walls and Session are never adjusted in anyway
+        for w in s1.wall_events:
+            w: Wall
+            assert w.adjusted_status is None
+            assert w.adjusted_timestamp is None
+            assert w.adjusted_cpi is None
+
+        assert s1.adjusted_status is None
+        assert s1.adjusted_payout is None
+        assert s1.adjusted_timestamp is None
+
+    def test_adjustment_wall_values(
+        self, session_factory, user, session_manager, wall_manager
+    ):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=5,
+            wall_req_cpi=Decimal(1),
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            payout=Decimal("0.95"),
+            finished=finished2,
+        )
+
+        # Change the last wall event to a Failure
+        w: Wall = s1.wall_events[-1]
+        wall_manager.adjust_status(
+            wall=w,
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_timestamp=adj_ts,
+        )
+
+        # Original Session and Wall status is still the same, but the Adjusted
+        #   values have changed
+        assert s1.status == Status.COMPLETE
+        assert s1.adjusted_status is None
+        assert s1.adjusted_timestamp is None
+        assert s1.adjusted_payout is None
+        assert s1.adjusted_user_payout is None
+
+        assert w.status == Status.COMPLETE
+        assert w.status_code_1 == StatusCode1.COMPLETE
+        assert w.adjusted_status == WallAdjustedStatus.ADJUSTED_TO_FAIL
+        assert w.adjusted_cpi == Decimal(0)
+        assert w.adjusted_timestamp == adj_ts
+
+        # Because the Product doesn't have the Wallet mode enabled, the
+        #   user_payout fields should always be None
+        assert not user.product.user_wallet_config.enabled
+        assert s1.adjusted_user_payout is None
+
+    def test_adjustment_session_values(
+        self, wall_manager, session_manager, session_factory, user
+    ):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpi=Decimal(1),
+            wall_source=Source.DYNATA,
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            payout=Decimal("0.95"),
+            finished=finished2,
+        )
+
+        # Change the last wall event to a Failure
+        wall_manager.adjust_status(
+            wall=s1.wall_events[-1],
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_timestamp=adj_ts,
+        )
+
+        # Refresh the Session with the new Wall Adjustment considerations,
+        session_manager.adjust_status(session=s1)
+        assert s1.status == Status.COMPLETE  # Original status should remain
+        assert s1.adjusted_status == SessionAdjustedStatus.ADJUSTED_TO_FAIL
+        assert s1.adjusted_payout == Decimal(0)
+        assert s1.adjusted_timestamp == adj_ts
+
+        # Because the Product doesn't have the Wallet mode enabled, the
+        #   user_payout fields should always be None
+        assert not user.product.user_wallet_config.enabled
+        assert s1.adjusted_user_payout is None
+
+    def test_double_adjustment_session_values(
+        self, wall_manager, session_manager, session_factory, user
+    ):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpi=Decimal(1),
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            payout=Decimal("0.95"),
+            finished=finished2,
+        )
+
+        # Change the last wall event to a Failure
+        w: Wall = s1.wall_events[-1]
+        wall_manager.adjust_status(
+            wall=w,
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_timestamp=adj_ts,
+        )
+
+        # Refresh the Session with the new Wall Adjustment considerations,
+        session_manager.adjust_status(session=s1)
+
+        # Let's take that back again! Buyers love to do this.
+        # So now we're going to "un-reconcile" the last Wall Event which has
+        # already gone from a Complete >> Failure
+        wall_manager.adjust_status(
+            wall=w, adjusted_status=None, adjusted_timestamp=adj_ts2
+        )
+        assert w.adjusted_status is None
+        assert w.adjusted_cpi is None
+        assert w.adjusted_timestamp == adj_ts2
+
+        # Once the wall was unreconciled, "refresh" the Session again
+        assert s1.adjusted_status is not None
+        session_manager.adjust_status(session=s1)
+        assert s1.adjusted_status is None
+        assert s1.adjusted_payout is None
+        assert s1.adjusted_timestamp == adj_ts2
+        assert s1.adjusted_user_payout is None
+
+    def test_double_adjustment_sm_vs_db_values(
+        self, wall_manager, session_manager, session_factory, user
+    ):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpi=Decimal(1),
+            wall_source=Source.DYNATA,
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            payout=Decimal("0.95"),
+            finished=finished2,
+        )
+
+        # Change the last wall event to a Failure
+        wall_manager.adjust_status(
+            wall=s1.wall_events[-1],
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_timestamp=adj_ts,
+        )
+
+        # Refresh the Session with the new Wall Adjustment considerations,
+        session_manager.adjust_status(session=s1)
+
+        # Let's take that back again! Buyers love to do this.
+        # So now we're going to "un-reconcile" the last Wall Event which has
+        # already gone from a Complete >> Failure
+        # Once the wall was unreconciled, "refresh" the Session again
+        wall_manager.adjust_status(
+            wall=s1.wall_events[-1], adjusted_status=None, adjusted_timestamp=adj_ts2
+        )
+        session_manager.adjust_status(session=s1)
+
+        # Confirm that the sessions wall attributes are still aligned with
+        # what comes back directly from the database
+        db_wall_events = wall_manager.get_wall_events(session_id=s1.id)
+        for idx in range(len(s1.wall_events)):
+            w_sm: Wall = s1.wall_events[idx]
+            w_db: Wall = db_wall_events[idx]
+
+            assert w_sm.uuid == w_db.uuid
+            assert w_sm.session_id == w_db.session_id
+            assert w_sm.status == w_db.status
+            assert w_sm.status_code_1 == w_db.status_code_1
+            assert w_sm.status_code_2 == w_db.status_code_2
+
+            assert w_sm.elapsed == w_db.elapsed
+
+            # Decimal("1.000000") vs Decimal(1) - based on mysql or postgres
+            assert pytest.approx(w_sm.cpi) == w_db.cpi
+            assert pytest.approx(w_sm.req_cpi) == w_db.req_cpi
+
+            assert w_sm.model_dump_json(
+                exclude={"cpi", "req_cpi"}
+            ) == w_db.model_dump_json(exclude={"cpi", "req_cpi"})
+
+    def test_double_adjustment_double_completes(
+        self, wall_manager, session_manager, session_factory, user
+    ):
+        # Completed Session with 2 wall events
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpi=Decimal(2),
+            wall_source=Source.DYNATA,
+            final_status=Status.COMPLETE,
+            started=started1,
+        )
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            payout=Decimal("0.95"),
+            finished=finished2,
+        )
+
+        # Change the last wall event to a Failure
+        wall_manager.adjust_status(
+            wall=s1.wall_events[-1],
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_timestamp=adj_ts,
+        )
+
+        # Refresh the Session with the new Wall Adjustment considerations,
+        session_manager.adjust_status(session=s1)
+
+        # Let's take that back again! Buyers love to do this.
+        # So now we're going to "un-reconcile" the last Wall Event which has
+        # already gone from a Complete >> Failure
+        # Once the wall was unreconciled, "refresh" the Session again
+        wall_manager.adjust_status(
+            wall=s1.wall_events[-1], adjusted_status=None, adjusted_timestamp=adj_ts2
+        )
+        session_manager.adjust_status(session=s1)
+
+        # Reassign them - we already validated they're equal in previous
+        #    tests so this is safe to do.
+        s1.wall_events = wall_manager.get_wall_events(session_id=s1.id)
+
+        # The First Wall event was originally a Failure, now let's also set
+        # that as a complete, so now both Wall Events will b a
+        # complete (Fail >> Adj to Complete, Complete >> Adj to Fail >> Adj to Complete)
+        w1: Wall = s1.wall_events[0]
+        assert w1.status == Status.FAIL
+        assert w1.adjusted_status is None
+        assert w1.adjusted_cpi is None
+        assert w1.adjusted_timestamp is None
+
+        wall_manager.adjust_status(
+            wall=w1,
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_COMPLETE,
+            adjusted_timestamp=adj_ts3,
+        )
+
+        assert w1.status == Status.FAIL  # original status doesn't change
+        assert w1.adjusted_status == WallAdjustedStatus.ADJUSTED_TO_COMPLETE
+        assert w1.adjusted_cpi == w1.cpi
+        assert w1.adjusted_timestamp == adj_ts3
+
+        session_manager.adjust_status(s1)
+        assert SessionAdjustedStatus.PAYOUT_ADJUSTMENT == s1.adjusted_status
+        assert Decimal("3.80") == s1.adjusted_payout
+        assert s1.adjusted_user_payout is None
+        assert adj_ts3 == s1.adjusted_timestamp
+
+    def test_complete_to_fail(
+        self, session_factory, user, session_manager, wall_manager, utc_hour_ago
+    ):
+        s1 = session_factory(
+            user=user,
+            wall_count=1,
+            wall_req_cpi=Decimal("1"),
+            final_status=Status.COMPLETE,
+            started=utc_hour_ago,
+        )
+
+        status, status_code_1 = s1.determine_session_status()
+        assert status == Status.COMPLETE
+
+        thl_net = Decimal(sum(w.cpi for w in s1.wall_events if w.is_visible_complete()))
+        payout = user.product.determine_bp_payment(thl_net=thl_net)
+
+        session_manager.finish_with_status(
+            session=s1,
+            status=status,
+            status_code_1=status_code_1,
+            finished=utc_hour_ago + timedelta(minutes=10),
+            payout=payout,
+            user_payout=None,
+        )
+
+        w1 = s1.wall_events[0]
+        w1.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_cpi=0,
+            adjusted_timestamp=adj_ts,
+        )
+        assert w1.adjusted_status == WallAdjustedStatus.ADJUSTED_TO_FAIL
+        assert w1.adjusted_cpi == Decimal(0)
+
+        new_status, new_payout, new_user_payout = s1.determine_new_status_and_payouts()
+        assert Status.FAIL == new_status
+        assert Decimal(0) == new_payout
+
+        assert not user.product.user_wallet_config.enabled
+        assert new_user_payout is None
+
+        s1.adjust_status()
+        assert SessionAdjustedStatus.ADJUSTED_TO_FAIL == s1.adjusted_status
+        assert Decimal(0) == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        assert s1.adjusted_user_payout is None
+
+        # cpi adjustment
+        w1.update(
+            adjusted_status=WallAdjustedStatus.CPI_ADJUSTMENT,
+            adjusted_cpi=Decimal("0.69"),
+            adjusted_timestamp=adj_ts,
+        )
+        assert WallAdjustedStatus.CPI_ADJUSTMENT == w1.adjusted_status
+        assert Decimal("0.69") == w1.adjusted_cpi
+        new_status, new_payout, new_user_payout = s1.determine_new_status_and_payouts()
+        assert Status.COMPLETE == new_status
+        assert Decimal("0.66") == new_payout
+
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.33") == new_user_payout
+        assert new_user_payout is None
+
+        s1.adjust_status()
+        assert SessionAdjustedStatus.PAYOUT_ADJUSTMENT == s1.adjusted_status
+        assert Decimal("0.66") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.33") == s1.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+
+        # adjust cpi again
+        wall_manager.adjust_status(
+            wall=w1,
+            adjusted_status=WallAdjustedStatus.CPI_ADJUSTMENT,
+            adjusted_cpi=Decimal("0.50"),
+            adjusted_timestamp=adj_ts,
+        )
+        assert WallAdjustedStatus.CPI_ADJUSTMENT == w1.adjusted_status
+        assert Decimal("0.50") == w1.adjusted_cpi
+        new_status, new_payout, new_user_payout = s1.determine_new_status_and_payouts()
+        assert Status.COMPLETE == new_status
+        assert Decimal("0.48") == new_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.24") == new_user_payout
+        assert new_user_payout is None
+
+        s1.adjust_status()
+        assert SessionAdjustedStatus.PAYOUT_ADJUSTMENT == s1.adjusted_status
+        assert Decimal("0.48") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.24") == s1.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+
+    def test_complete_to_fail_to_complete(self, user, session_factory, utc_hour_ago):
+        # Setup: Complete, then adjust it to fail
+        s1 = session_factory(
+            user=user,
+            wall_count=1,
+            wall_req_cpi=Decimal("1"),
+            final_status=Status.COMPLETE,
+            started=utc_hour_ago,
+        )
+        w1 = s1.wall_events[0]
+
+        status, status_code_1 = s1.determine_session_status()
+        thl_net, commission_amount, bp_pay, user_pay = s1.determine_payments()
+        s1.update(
+            **{
+                "status": status,
+                "status_code_1": status_code_1,
+                "finished": utc_hour_ago + timedelta(minutes=10),
+                "payout": bp_pay,
+                "user_payout": user_pay,
+            }
+        )
+        w1.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_cpi=0,
+            adjusted_timestamp=adj_ts,
+        )
+        s1.adjust_status()
+
+        # Test: Adjust back to complete
+        w1.update(
+            adjusted_status=None,
+            adjusted_cpi=None,
+            adjusted_timestamp=adj_ts,
+        )
+        assert w1.adjusted_status is None
+        assert w1.adjusted_cpi is None
+        assert adj_ts == w1.adjusted_timestamp
+
+        new_status, new_payout, new_user_payout = s1.determine_new_status_and_payouts()
+        assert Status.COMPLETE == new_status
+        assert Decimal("0.95") == new_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.48") == new_user_payout
+        assert new_user_payout is None
+
+        s1.adjust_status()
+        assert s1.adjusted_status is None
+        assert s1.adjusted_payout is None
+        assert s1.adjusted_user_payout is None
+
+    def test_complete_to_fail_to_complete_adj(
+        self, user, session_factory, utc_hour_ago
+    ):
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpis=[Decimal(1), Decimal(2)],
+            final_status=Status.COMPLETE,
+            started=utc_hour_ago,
+        )
+
+        w1 = s1.wall_events[0]
+        w2 = s1.wall_events[1]
+
+        status, status_code_1 = s1.determine_session_status()
+        thl_net = Decimal(sum(w.cpi for w in s1.wall_events if w.is_visible_complete()))
+        payout = user.product.determine_bp_payment(thl_net=thl_net)
+        s1.update(
+            **{
+                "status": status,
+                "status_code_1": status_code_1,
+                "finished": utc_hour_ago + timedelta(minutes=25),
+                "payout": payout,
+                "user_payout": None,
+            }
+        )
+
+        # Test. Adjust first fail to complete. Now we have 2 completes.
+        w1.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_COMPLETE,
+            adjusted_cpi=w1.cpi,
+            adjusted_timestamp=adj_ts,
+        )
+        s1.adjust_status()
+        assert SessionAdjustedStatus.PAYOUT_ADJUSTMENT == s1.adjusted_status
+        assert Decimal("2.85") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("1.42") == s1.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+
+        # Now we have [Fail, Complete ($2)] -> [Complete ($1), Fail]
+        w2.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_cpi=0,
+            adjusted_timestamp=adj_ts2,
+        )
+        s1.adjust_status()
+        assert SessionAdjustedStatus.PAYOUT_ADJUSTMENT == s1.adjusted_status
+        assert Decimal("0.95") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.48") == s1.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+
+    def test_complete_to_fail_to_complete_adj1(
+        self, user, session_factory, utc_hour_ago
+    ):
+        # Same as test_complete_to_fail_to_complete_adj but in opposite order
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpis=[Decimal(1), Decimal(2)],
+            final_status=Status.COMPLETE,
+            started=utc_hour_ago,
+        )
+
+        w1 = s1.wall_events[0]
+        w2 = s1.wall_events[1]
+
+        status, status_code_1 = s1.determine_session_status()
+        thl_net = Decimal(sum(w.cpi for w in s1.wall_events if w.is_visible_complete()))
+        payout = user.product.determine_bp_payment(thl_net)
+        s1.update(
+            **{
+                "status": status,
+                "status_code_1": status_code_1,
+                "finished": utc_hour_ago + timedelta(minutes=25),
+                "payout": payout,
+                "user_payout": None,
+            }
+        )
+
+        # Test. Adjust complete to fail. Now we have 2 fails.
+        w2.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_FAIL,
+            adjusted_cpi=0,
+            adjusted_timestamp=adj_ts,
+        )
+        s1.adjust_status()
+        assert SessionAdjustedStatus.ADJUSTED_TO_FAIL == s1.adjusted_status
+        assert Decimal(0) == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal(0) == s.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+        # Now we have [Fail, Complete ($2)] -> [Complete ($1), Fail]
+        w1.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_COMPLETE,
+            adjusted_cpi=w1.cpi,
+            adjusted_timestamp=adj_ts2,
+        )
+        s1.adjust_status()
+        assert SessionAdjustedStatus.PAYOUT_ADJUSTMENT == s1.adjusted_status
+        assert Decimal("0.95") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.48") == s.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+
+    def test_fail_to_complete_to_fail(self, user, session_factory, utc_hour_ago):
+        # End with an abandon
+        s1 = session_factory(
+            user=user,
+            wall_count=2,
+            wall_req_cpis=[Decimal(1), Decimal(2)],
+            final_status=Status.ABANDON,
+            started=utc_hour_ago,
+        )
+
+        w1 = s1.wall_events[0]
+        w2 = s1.wall_events[1]
+
+        # abandon adjust to complete
+        w2.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_COMPLETE,
+            adjusted_cpi=w2.cpi,
+            adjusted_timestamp=adj_ts,
+        )
+        assert WallAdjustedStatus.ADJUSTED_TO_COMPLETE == w2.adjusted_status
+        s1.adjust_status()
+        assert SessionAdjustedStatus.ADJUSTED_TO_COMPLETE == s1.adjusted_status
+        assert Decimal("1.90") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.95") == s1.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
+
+        # back to fail
+        w2.update(
+            adjusted_status=None,
+            adjusted_cpi=None,
+            adjusted_timestamp=adj_ts,
+        )
+        assert w2.adjusted_status is None
+        s1.adjust_status()
+        assert s1.adjusted_status is None
+        assert s1.adjusted_payout is None
+        assert s1.adjusted_user_payout is None
+
+        # other is now complete
+        w1.update(
+            adjusted_status=WallAdjustedStatus.ADJUSTED_TO_COMPLETE,
+            adjusted_cpi=w1.cpi,
+            adjusted_timestamp=adj_ts,
+        )
+        assert WallAdjustedStatus.ADJUSTED_TO_COMPLETE == w1.adjusted_status
+        s1.adjust_status()
+        assert SessionAdjustedStatus.ADJUSTED_TO_COMPLETE == s1.adjusted_status
+        assert Decimal("0.95") == s1.adjusted_payout
+        assert not user.product.user_wallet_config.enabled
+        # assert Decimal("0.48") == s1.adjusted_user_payout
+        assert s1.adjusted_user_payout is None
diff --git a/tests/models/thl/test_bucket.py b/tests/models/thl/test_bucket.py
new file mode 100644
index 0000000..0aa5843
--- /dev/null
+++ b/tests/models/thl/test_bucket.py
@@ -0,0 +1,201 @@
+from datetime import timedelta
+from decimal import Decimal
+
+import pytest
+from pydantic import ValidationError
+
+
+class TestBucket:
+
+    def test_raises_payout(self):
+        from generalresearch.models.legacy.bucket import Bucket
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(user_payout_min=123)
+        assert "Must pass a Decimal" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(user_payout_min=Decimal(1 / 3))
+        assert "Must have 2 or fewer decimal places" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(user_payout_min=Decimal(10000))
+        assert "should be less than 1000" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(user_payout_min=Decimal(1), user_payout_max=Decimal("0.01"))
+        assert "user_payout_min should be <= user_payout_max" in str(e.value)
+
+    def test_raises_loi(self):
+        from generalresearch.models.legacy.bucket import Bucket
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(loi_min=123)
+        assert "Input should be a valid timedelta" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(loi_min=timedelta(seconds=9999))
+        assert "should be less than 90 minutes" in str(e.value)
+
+        with pytest.raises(ValidationError) as e:
+            Bucket(loi_min=timedelta(seconds=0))
+        assert "should be greater than 0" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(loi_min=timedelta(seconds=10), loi_max=timedelta(seconds=9))
+        assert "loi_min should be <= loi_max" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(
+                loi_min=timedelta(seconds=10),
+                loi_max=timedelta(seconds=90),
+                loi_q1=timedelta(seconds=20),
+            )
+        assert "loi_q1, q2, and q3 should all be set" in str(e.value)
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Bucket(
+                loi_min=timedelta(seconds=10),
+                loi_max=timedelta(seconds=90),
+                loi_q1=timedelta(seconds=200),
+                loi_q2=timedelta(seconds=20),
+                loi_q3=timedelta(seconds=12),
+            )
+        assert "loi_q1 should be <= loi_q2" in str(e.value)
+
+    def test_parse_1(self):
+        from generalresearch.models.legacy.bucket import Bucket
+
+        b1 = Bucket.parse_from_offerwall({"payout": {"min": 123}})
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=None,
+            loi_min=None,
+            loi_max=None,
+        )
+        assert b_exp == b1
+
+        b2 = Bucket.parse_from_offerwall({"payout": {"min": 123, "max": 230}})
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=Decimal("2.30"),
+            loi_min=None,
+            loi_max=None,
+        )
+        assert b_exp == b2
+
+        b3 = Bucket.parse_from_offerwall(
+            {"payout": {"min": 123, "max": 230}, "duration": {"min": 600, "max": 1800}}
+        )
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=Decimal("2.30"),
+            loi_min=timedelta(seconds=600),
+            loi_max=timedelta(seconds=1800),
+        )
+        assert b_exp == b3
+
+        b4 = Bucket.parse_from_offerwall(
+            {
+                "payout": {"max": 80, "min": 28, "q1": 43, "q2": 43, "q3": 56},
+                "duration": {"max": 1172, "min": 266, "q1": 746, "q2": 918, "q3": 1002},
+            }
+        )
+        b_exp = Bucket(
+            user_payout_min=Decimal("0.28"),
+            user_payout_max=Decimal("0.80"),
+            user_payout_q1=Decimal("0.43"),
+            user_payout_q2=Decimal("0.43"),
+            user_payout_q3=Decimal("0.56"),
+            loi_min=timedelta(seconds=266),
+            loi_max=timedelta(seconds=1172),
+            loi_q1=timedelta(seconds=746),
+            loi_q2=timedelta(seconds=918),
+            loi_q3=timedelta(seconds=1002),
+        )
+        assert b_exp == b4
+
+    def test_parse_2(self):
+        from generalresearch.models.legacy.bucket import Bucket
+
+        b1 = Bucket.parse_from_offerwall({"min_payout": 123})
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=None,
+            loi_min=None,
+            loi_max=None,
+        )
+        assert b_exp == b1
+
+        b2 = Bucket.parse_from_offerwall({"min_payout": 123, "max_payout": 230})
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=Decimal("2.30"),
+            loi_min=None,
+            loi_max=None,
+        )
+        assert b_exp == b2
+
+        b3 = Bucket.parse_from_offerwall(
+            {
+                "min_payout": 123,
+                "max_payout": 230,
+                "min_duration": 600,
+                "max_duration": 1800,
+            }
+        )
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=Decimal("2.30"),
+            loi_min=timedelta(seconds=600),
+            loi_max=timedelta(seconds=1800),
+        )
+        assert b_exp, b3
+
+        b4 = Bucket.parse_from_offerwall(
+            {
+                "min_payout": 28,
+                "max_payout": 99,
+                "min_duration": 205,
+                "max_duration": 1113,
+                "q1_payout": 43,
+                "q2_payout": 43,
+                "q3_payout": 46,
+                "q1_duration": 561,
+                "q2_duration": 891,
+                "q3_duration": 918,
+            }
+        )
+        b_exp = Bucket(
+            user_payout_min=Decimal("0.28"),
+            user_payout_max=Decimal("0.99"),
+            user_payout_q1=Decimal("0.43"),
+            user_payout_q2=Decimal("0.43"),
+            user_payout_q3=Decimal("0.46"),
+            loi_min=timedelta(seconds=205),
+            loi_max=timedelta(seconds=1113),
+            loi_q1=timedelta(seconds=561),
+            loi_q2=timedelta(seconds=891),
+            loi_q3=timedelta(seconds=918),
+        )
+        assert b_exp == b4
+
+    def test_parse_3(self):
+        from generalresearch.models.legacy.bucket import Bucket
+
+        b1 = Bucket.parse_from_offerwall({"payout": 123})
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=None,
+            loi_min=None,
+            loi_max=None,
+        )
+        assert b_exp == b1
+
+        b2 = Bucket.parse_from_offerwall({"payout": 123, "duration": 1800})
+        b_exp = Bucket(
+            user_payout_min=Decimal("1.23"),
+            user_payout_max=None,
+            loi_min=None,
+            loi_max=timedelta(seconds=1800),
+        )
+        assert b_exp == b2
diff --git a/tests/models/thl/test_buyer.py b/tests/models/thl/test_buyer.py
new file mode 100644
index 0000000..eebb828
--- /dev/null
+++ b/tests/models/thl/test_buyer.py
@@ -0,0 +1,23 @@
+from generalresearch.models import Source
+from generalresearch.models.thl.survey.buyer import BuyerCountryStat
+
+
+def test_buyer_country_stat():
+    bcs = BuyerCountryStat(
+        country_iso="us",
+        source=Source.TESTING,
+        code="123",
+        task_count=100,
+        conversion_alpha=40,
+        conversion_beta=190,
+        dropoff_alpha=20,
+        dropoff_beta=50,
+        long_fail_rate=1,
+        loi_excess_ratio=1,
+        user_report_coeff=1,
+        recon_likelihood=0.05,
+    )
+    assert bcs.score
+    print(bcs.score)
+    print(bcs.conversion_p20)
+    print(bcs.dropoff_p60)
diff --git a/tests/models/thl/test_contest/__init__.py b/tests/models/thl/test_contest/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/models/thl/test_contest/__init__.py
diff --git a/tests/models/thl/test_contest/test_contest.py b/tests/models/thl/test_contest/test_contest.py
new file mode 100644
index 0000000..d53eee5
--- /dev/null
+++ b/tests/models/thl/test_contest/test_contest.py
@@ -0,0 +1,23 @@
+import pytest
+from generalresearch.models.thl.user import User
+
+
+class TestContest:
+    """In many of the Contest related tests, we often want a consistent
+    Product throughout, and multiple different users that may be
+    involved in the Contest... so redefine the product fixture along with
+    some users in here that are scoped="class" so they stay around for
+    each of the test functions
+    """
+
+    @pytest.fixture(scope="function")
+    def user_1(self, user_factory, product) -> User:
+        return user_factory(product=product)
+
+    @pytest.fixture(scope="function")
+    def user_2(self, user_factory, product) -> User:
+        return user_factory(product=product)
+
+    @pytest.fixture(scope="function")
+    def user_3(self, user_factory, product) -> User:
+        return user_factory(product=product)
diff --git a/tests/models/thl/test_contest/test_leaderboard_contest.py b/tests/models/thl/test_contest/test_leaderboard_contest.py
new file mode 100644
index 0000000..98f3215
--- /dev/null
+++ b/tests/models/thl/test_contest/test_leaderboard_contest.py
@@ -0,0 +1,213 @@
+from datetime import timezone
+from uuid import uuid4
+
+import pytest
+
+from generalresearch.currency import USDCent
+from generalresearch.managers.leaderboard.manager import LeaderboardManager
+from generalresearch.models.thl.contest import ContestPrize
+from generalresearch.models.thl.contest.definitions import (
+    ContestType,
+    ContestPrizeKind,
+)
+from generalresearch.models.thl.contest.leaderboard import (
+    LeaderboardContest,
+)
+from generalresearch.models.thl.contest.utils import (
+    distribute_leaderboard_prizes,
+)
+from generalresearch.models.thl.leaderboard import LeaderboardRow
+from tests.models.thl.test_contest.test_contest import TestContest
+
+
+class TestLeaderboardContest(TestContest):
+
+    @pytest.fixture
+    def leaderboard_contest(
+        self, product, thl_redis, user_manager
+    ) -> "LeaderboardContest":
+        board_key = f"leaderboard:{product.uuid}:us:weekly:2025-05-26:complete_count"
+
+        c = LeaderboardContest(
+            uuid=uuid4().hex,
+            product_id=product.uuid,
+            contest_type=ContestType.LEADERBOARD,
+            leaderboard_key=board_key,
+            name="$15 1st place, $10 2nd, $5 3rd place US weekly",
+            prizes=[
+                ContestPrize(
+                    name="$15 Cash",
+                    estimated_cash_value=USDCent(15_00),
+                    cash_amount=USDCent(15_00),
+                    kind=ContestPrizeKind.CASH,
+                    leaderboard_rank=1,
+                ),
+                ContestPrize(
+                    name="$10 Cash",
+                    estimated_cash_value=USDCent(10_00),
+                    cash_amount=USDCent(10_00),
+                    kind=ContestPrizeKind.CASH,
+                    leaderboard_rank=2,
+                ),
+                ContestPrize(
+                    name="$5 Cash",
+                    estimated_cash_value=USDCent(5_00),
+                    cash_amount=USDCent(5_00),
+                    kind=ContestPrizeKind.CASH,
+                    leaderboard_rank=3,
+                ),
+            ],
+        )
+        c._redis_client = thl_redis
+        c._user_manager = user_manager
+        return c
+
+    def test_init(self, leaderboard_contest, thl_redis, user_1, user_2):
+        model = leaderboard_contest.leaderboard_model
+        assert leaderboard_contest.end_condition.ends_at is not None
+
+        lbm = LeaderboardManager(
+            redis_client=thl_redis,
+            board_code=model.board_code,
+            country_iso=model.country_iso,
+            freq=model.freq,
+            product_id=leaderboard_contest.product_id,
+            within_time=model.period_start_local,
+        )
+
+        lbm.hit_complete_count(product_user_id=user_1.product_user_id)
+        lbm.hit_complete_count(product_user_id=user_2.product_user_id)
+        lbm.hit_complete_count(product_user_id=user_2.product_user_id)
+
+        lb = leaderboard_contest.get_leaderboard()
+        print(lb)
+
+    def test_win(self, leaderboard_contest, thl_redis, user_1, user_2, user_3):
+        model = leaderboard_contest.leaderboard_model
+        lbm = LeaderboardManager(
+            redis_client=thl_redis,
+            board_code=model.board_code,
+            country_iso=model.country_iso,
+            freq=model.freq,
+            product_id=leaderboard_contest.product_id,
+            within_time=model.period_start_local.astimezone(tz=timezone.utc),
+        )
+
+        lbm.hit_complete_count(product_user_id=user_1.product_user_id)
+        lbm.hit_complete_count(product_user_id=user_1.product_user_id)
+
+        lbm.hit_complete_count(product_user_id=user_2.product_user_id)
+
+        lbm.hit_complete_count(product_user_id=user_3.product_user_id)
+
+        leaderboard_contest.end_contest()
+        assert len(leaderboard_contest.all_winners) == 3
+
+        # Prizes are $15, $10, $5. user 2 and 3 ties for 2nd place, so they split (10 + 5)
+        assert leaderboard_contest.all_winners[0].awarded_cash_amount == USDCent(15_00)
+        assert (
+            leaderboard_contest.all_winners[0].user.product_user_id
+            == user_1.product_user_id
+        )
+        assert leaderboard_contest.all_winners[0].prize == leaderboard_contest.prizes[0]
+        assert leaderboard_contest.all_winners[1].awarded_cash_amount == USDCent(
+            15_00 / 2
+        )
+        assert leaderboard_contest.all_winners[2].awarded_cash_amount == USDCent(
+            15_00 / 2
+        )
+
+
+class TestLeaderboardContestPrizes:
+
+    def test_distribute_prizes_1(self):
+        prizes = [USDCent(15_00)]
+        leaderboard_rows = [
+            LeaderboardRow(bpuid="a", value=20, rank=1),
+            LeaderboardRow(bpuid="b", value=10, rank=2),
+        ]
+        result = distribute_leaderboard_prizes(prizes, leaderboard_rows)
+
+        # a gets first prize, b gets nothing.
+        assert result == {
+            "a": USDCent(15_00),
+        }
+
+    def test_distribute_prizes_2(self):
+        prizes = [USDCent(15_00), USDCent(10_00)]
+        leaderboard_rows = [
+            LeaderboardRow(bpuid="a", value=20, rank=1),
+            LeaderboardRow(bpuid="b", value=10, rank=2),
+        ]
+        result = distribute_leaderboard_prizes(prizes, leaderboard_rows)
+
+        # a gets first prize, b gets 2nd prize
+        assert result == {
+            "a": USDCent(15_00),
+            "b": USDCent(10_00),
+        }
+
+    def test_distribute_prizes_3(self):
+        prizes = [USDCent(15_00), USDCent(10_00)]
+        leaderboard_rows = [
+            LeaderboardRow(bpuid="a", value=20, rank=1),
+        ]
+        result = distribute_leaderboard_prizes(prizes, leaderboard_rows)
+
+        # A gets first prize, no-one gets $10
+        assert result == {
+            "a": USDCent(15_00),
+        }
+
+    def test_distribute_prizes_4(self):
+        prizes = [USDCent(15_00)]
+        leaderboard_rows = [
+            LeaderboardRow(bpuid="a", value=20, rank=1),
+            LeaderboardRow(bpuid="b", value=20, rank=1),
+            LeaderboardRow(bpuid="c", value=20, rank=1),
+            LeaderboardRow(bpuid="d", value=20, rank=1),
+        ]
+        result = distribute_leaderboard_prizes(prizes, leaderboard_rows)
+
+        # 4-way tie for the $15 prize; it gets split
+        assert result == {
+            "a": USDCent(3_75),
+            "b": USDCent(3_75),
+            "c": USDCent(3_75),
+            "d": USDCent(3_75),
+        }
+
+    def test_distribute_prizes_5(self):
+        prizes = [USDCent(15_00), USDCent(10_00)]
+        leaderboard_rows = [
+            LeaderboardRow(bpuid="a", value=20, rank=1),
+            LeaderboardRow(bpuid="b", value=20, rank=1),
+            LeaderboardRow(bpuid="c", value=10, rank=3),
+        ]
+        result = distribute_leaderboard_prizes(prizes, leaderboard_rows)
+
+        # 2-way tie for the $15 prize; the top two prizes get split. Rank 3
+        # and below get nothing
+        assert result == {
+            "a": USDCent(12_50),
+            "b": USDCent(12_50),
+        }
+
+    def test_distribute_prizes_6(self):
+        prizes = [USDCent(15_00), USDCent(10_00), USDCent(5_00)]
+        leaderboard_rows = [
+            LeaderboardRow(bpuid="a", value=20, rank=1),
+            LeaderboardRow(bpuid="b", value=10, rank=2),
+            LeaderboardRow(bpuid="c", value=10, rank=2),
+            LeaderboardRow(bpuid="d", value=10, rank=2),
+        ]
+        result = distribute_leaderboard_prizes(prizes, leaderboard_rows)
+
+        # A gets first prize, 3 way tie for 2nd rank: they split the 2nd and
+        #   3rd place prizes (10 + 5)/3
+        assert result == {
+            "a": USDCent(15_00),
+            "b": USDCent(5_00),
+            "c": USDCent(5_00),
+            "d": USDCent(5_00),
+        }
diff --git a/tests/models/thl/test_contest/test_raffle_contest.py b/tests/models/thl/test_contest/test_raffle_contest.py
new file mode 100644
index 0000000..e1c0a15
--- /dev/null
+++ b/tests/models/thl/test_contest/test_raffle_contest.py
@@ -0,0 +1,300 @@
+from collections import Counter
+from uuid import uuid4
+
+import pytest
+from pytest import approx
+
+from generalresearch.currency import USDCent
+from generalresearch.models.thl.contest import (
+    ContestPrize,
+    ContestEndCondition,
+)
+from generalresearch.models.thl.contest.contest_entry import ContestEntry
+from generalresearch.models.thl.contest.definitions import (
+    ContestEntryType,
+    ContestPrizeKind,
+    ContestType,
+    ContestStatus,
+    ContestEndReason,
+)
+from generalresearch.models.thl.contest.raffle import RaffleContest
+
+from tests.models.thl.test_contest.test_contest import TestContest
+
+
+class TestRaffleContest(TestContest):
+
+    @pytest.fixture(scope="function")
+    def raffle_contest(self, product) -> RaffleContest:
+        return RaffleContest(
+            product_id=product.uuid,
+            name=f"Raffle Contest {uuid4().hex}",
+            contest_type=ContestType.RAFFLE,
+            entry_type=ContestEntryType.CASH,
+            prizes=[
+                ContestPrize(
+                    name="iPod 64GB White",
+                    kind=ContestPrizeKind.PHYSICAL,
+                    estimated_cash_value=USDCent(100_00),
+                )
+            ],
+            end_condition=ContestEndCondition(target_entry_amount=100),
+        )
+
+    @pytest.fixture(scope="function")
+    def ended_raffle_contest(self, raffle_contest, utc_now) -> RaffleContest:
+        # Fake ending the contest
+        raffle_contest = raffle_contest.model_copy()
+        raffle_contest.update(
+            status=ContestStatus.COMPLETED,
+            ended_at=utc_now,
+            end_reason=ContestEndReason.ENDS_AT,
+        )
+        return raffle_contest
+
+
+class TestRaffleContestUserView(TestRaffleContest):
+
+    def test_user_view(self, raffle_contest, user):
+        from generalresearch.models.thl.contest.raffle import RaffleUserView
+
+        data = {
+            "current_amount": USDCent(1_00),
+            "product_user_id": user.product_user_id,
+            "user_amount": USDCent(1),
+            "user_amount_today": USDCent(1),
+        }
+        r = RaffleUserView.model_validate(raffle_contest.model_dump() | data)
+        res = r.model_dump(mode="json")
+
+        assert res["product_user_id"] == user.product_user_id
+        assert res["user_amount_today"] == 1
+        assert res["current_win_probability"] == approx(0.01, rel=0.000001)
+        assert res["projected_win_probability"] == approx(0.01, rel=0.000001)
+
+        # Now change the amount
+        r.current_amount = USDCent(1_01)
+        res = r.model_dump(mode="json")
+        assert res["current_win_probability"] == approx(0.0099, rel=0.001)
+        assert res["projected_win_probability"] == approx(0.0099, rel=0.001)
+
+    def test_win_pct(self, raffle_contest, user):
+        from generalresearch.models.thl.contest.raffle import RaffleUserView
+
+        data = {
+            "current_amount": USDCent(10),
+            "product_user_id": user.product_user_id,
+            "user_amount": USDCent(1),
+            "user_amount_today": USDCent(1),
+        }
+        r = RaffleUserView.model_validate(raffle_contest.model_dump() | data)
+        r.prizes = [
+            ContestPrize(
+                name="iPod 64GB White",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+            ContestPrize(
+                name="iPod 64GB White",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+        ]
+        # Raffle has 10 entries, user has 1 entry.
+        # There are 2 prizes.
+        assert r.current_win_probability == approx(expected=0.2, rel=0.01)
+        # He can only possibly win 1 prize
+        assert r.current_prize_count_probability[1] == approx(expected=0.2, rel=0.01)
+        # He has a 0 prob of winning 2 prizes
+        assert r.current_prize_count_probability[2] == 0
+        # Contest end when there are 100 entries, so 1/100 * 2 prizes
+        assert r.projected_win_probability == approx(expected=0.02, rel=0.01)
+
+        # Change to user having 2 entries (out of 10)
+        # Still with 2 prizes
+        r.user_amount = USDCent(2)
+        assert r.current_win_probability == approx(expected=0.3777, rel=0.01)
+        # 2/10 chance of winning 1st, 8/9 change of not winning 2nd, plus the
+        #   same in the other order
+        p = (2 / 10) * (8 / 9) * 2  # 0.355555
+        assert r.current_prize_count_probability[1] == approx(p, rel=0.01)
+        p = (2 / 10) * (1 / 9)  # 0.02222
+        assert r.current_prize_count_probability[2] == approx(p, rel=0.01)
+
+
+class TestRaffleContestWinners(TestRaffleContest):
+
+    def test_winners_1_prize(self, ended_raffle_contest, user_1, user_2, user_3):
+        ended_raffle_contest.entries = [
+            ContestEntry(
+                user=user_1,
+                amount=USDCent(1),
+                entry_type=ContestEntryType.CASH,
+            ),
+            ContestEntry(
+                user=user_2,
+                amount=USDCent(2),
+                entry_type=ContestEntryType.CASH,
+            ),
+            ContestEntry(
+                user=user_3,
+                amount=USDCent(3),
+                entry_type=ContestEntryType.CASH,
+            ),
+        ]
+
+        # There is 1 prize. If we select a winner 1000 times, we'd expect user 1
+        #   to win ~ 1/6th of the time, user 2 ~2/6th and 3 3/6th.
+        winners = ended_raffle_contest.select_winners()
+        assert len(winners) == 1
+
+        c = Counter(
+            [
+                ended_raffle_contest.select_winners()[0].user.user_id
+                for _ in range(10000)
+            ]
+        )
+        assert c[user_1.user_id] == approx(
+            10000 * 1 / 6, rel=0.1
+        )  # 10% relative tolerance
+        assert c[user_2.user_id] == approx(10000 * 2 / 6, rel=0.1)
+        assert c[user_3.user_id] == approx(10000 * 3 / 6, rel=0.1)
+
+    def test_winners_2_prizes(self, ended_raffle_contest, user_1, user_2, user_3):
+        ended_raffle_contest.prizes.append(
+            ContestPrize(
+                name="iPod 64GB Black",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            )
+        )
+        ended_raffle_contest.entries = [
+            ContestEntry(
+                user=user_3,
+                amount=USDCent(1),
+                entry_type=ContestEntryType.CASH,
+            ),
+            ContestEntry(
+                user=user_1,
+                amount=USDCent(9999999),
+                entry_type=ContestEntryType.CASH,
+            ),
+            ContestEntry(
+                user=user_2,
+                amount=USDCent(1),
+                entry_type=ContestEntryType.CASH,
+            ),
+        ]
+        # In this scenario, user 1 should win both prizes
+        winners = ended_raffle_contest.select_winners()
+        assert len(winners) == 2
+        # Two different prizes
+        assert len({w.prize.name for w in winners}) == 2
+        # Same user
+        assert all(w.user.user_id == user_1.user_id for w in winners)
+
+    def test_winners_2_prizes_1_entry(self, ended_raffle_contest, user_3):
+        ended_raffle_contest.prizes = [
+            ContestPrize(
+                name="iPod 64GB White",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+            ContestPrize(
+                name="iPod 64GB Black",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+        ]
+        ended_raffle_contest.entries = [
+            ContestEntry(
+                user=user_3,
+                amount=USDCent(1),
+                entry_type=ContestEntryType.CASH,
+            ),
+        ]
+
+        # One prize goes unclaimed
+        winners = ended_raffle_contest.select_winners()
+        assert len(winners) == 1
+
+    def test_winners_2_prizes_1_entry_2_pennies(self, ended_raffle_contest, user_3):
+        ended_raffle_contest.prizes = [
+            ContestPrize(
+                name="iPod 64GB White",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+            ContestPrize(
+                name="iPod 64GB Black",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+        ]
+        ended_raffle_contest.entries = [
+            ContestEntry(
+                user=user_3,
+                amount=USDCent(2),
+                entry_type=ContestEntryType.CASH,
+            ),
+        ]
+        # User wins both prizes
+        winners = ended_raffle_contest.select_winners()
+        assert len(winners) == 2
+
+    def test_winners_3_prizes_3_entries(
+        self, ended_raffle_contest, product, user_1, user_2, user_3
+    ):
+        ended_raffle_contest.prizes = [
+            ContestPrize(
+                name="iPod 64GB White",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+            ContestPrize(
+                name="iPod 64GB Black",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+            ContestPrize(
+                name="iPod 64GB Red",
+                kind=ContestPrizeKind.PHYSICAL,
+                estimated_cash_value=USDCent(100_00),
+            ),
+        ]
+        ended_raffle_contest.entries = [
+            ContestEntry(
+                user=user_1,
+                amount=USDCent(1),
+                entry_type=ContestEntryType.CASH,
+            ),
+            ContestEntry(
+                user=user_2,
+                amount=USDCent(2),
+                entry_type=ContestEntryType.CASH,
+            ),
+            ContestEntry(
+                user=user_3,
+                amount=USDCent(3),
+                entry_type=ContestEntryType.CASH,
+            ),
+        ]
+
+        winners = ended_raffle_contest.select_winners()
+        assert len(winners) == 3
+
+        winners = [ended_raffle_contest.select_winners() for _ in range(10000)]
+
+        # There's 3 winners, the 1st should follow the same percentages
+        c = Counter([w[0].user.user_id for w in winners])
+
+        assert c[user_1.user_id] == approx(10000 * 1 / 6, rel=0.1)
+        assert c[user_2.user_id] == approx(10000 * 2 / 6, rel=0.1)
+        assert c[user_3.user_id] == approx(10000 * 3 / 6, rel=0.1)
+
+        # Assume the 1st user won
+        ended_raffle_contest.entries.pop(0)
+        winners = [ended_raffle_contest.select_winners() for _ in range(10000)]
+        c = Counter([w[0].user.user_id for w in winners])
+        assert c[user_2.user_id] == approx(10000 * 2 / 5, rel=0.1)
+        assert c[user_3.user_id] == approx(10000 * 3 / 5, rel=0.1)
diff --git a/tests/models/thl/test_ledger.py b/tests/models/thl/test_ledger.py
new file mode 100644
index 0000000..d706357
--- /dev/null
+++ b/tests/models/thl/test_ledger.py
@@ -0,0 +1,130 @@
+from datetime import datetime, timezone
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+from pydantic import ValidationError
+
+from generalresearch.models.thl.ledger import LedgerAccount, Direction, AccountType
+from generalresearch.models.thl.ledger import LedgerTransaction, LedgerEntry
+
+
+class TestLedgerTransaction:
+
+    def test_create(self):
+        # Can create with nothing ...
+        t = LedgerTransaction()
+        assert [] == t.entries
+        assert {} == t.metadata
+        t = LedgerTransaction(
+            created=datetime.now(tz=timezone.utc),
+            metadata={"a": "b", "user": "1234"},
+            ext_description="foo",
+        )
+
+    def test_ledger_entry(self):
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            LedgerEntry(
+                direction=Direction.CREDIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=0,
+            )
+        assert "Input should be greater than 0" in str(cm.value)
+
+        with pytest.raises(ValidationError) as cm:
+            LedgerEntry(
+                direction=Direction.CREDIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=2**65,
+            )
+        assert "Input should be less than 9223372036854775807" in str(cm.value)
+
+        with pytest.raises(ValidationError) as cm:
+            LedgerEntry(
+                direction=Direction.CREDIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=Decimal("1"),
+            )
+        assert "Input should be a valid integer" in str(cm.value)
+
+        with pytest.raises(ValidationError) as cm:
+            LedgerEntry(
+                direction=Direction.CREDIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=1.2,
+            )
+        assert "Input should be a valid integer" in str(cm.value)
+
+    def test_entries(self):
+        entries = [
+            LedgerEntry(
+                direction=Direction.CREDIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=100,
+            ),
+            LedgerEntry(
+                direction=Direction.DEBIT,
+                account_uuid="5927621462814f9893be807db850a31b",
+                amount=100,
+            ),
+        ]
+        LedgerTransaction(entries=entries)
+
+    def test_raises_entries(self):
+        entries = [
+            LedgerEntry(
+                direction=Direction.DEBIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=100,
+            ),
+            LedgerEntry(
+                direction=Direction.DEBIT,
+                account_uuid="5927621462814f9893be807db850a31b",
+                amount=100,
+            ),
+        ]
+        with pytest.raises(ValidationError) as e:
+            LedgerTransaction(entries=entries)
+        assert "ledger entries must balance" in str(e.value)
+
+        entries = [
+            LedgerEntry(
+                direction=Direction.DEBIT,
+                account_uuid="3f3735eaed264c2a9f8a114934afa121",
+                amount=100,
+            ),
+            LedgerEntry(
+                direction=Direction.CREDIT,
+                account_uuid="5927621462814f9893be807db850a31b",
+                amount=101,
+            ),
+        ]
+        with pytest.raises(ValidationError) as cm:
+            LedgerTransaction(entries=entries)
+        assert "ledger entries must balance" in str(cm.value)
+
+
+class TestLedgerAccount:
+
+    def test_initialization(self):
+        u = uuid4().hex
+        name = f"test-{u[:8]}"
+
+        with pytest.raises(ValidationError) as cm:
+            LedgerAccount(
+                display_name=name,
+                qualified_name="bad bunny",
+                normal_balance=Direction.DEBIT,
+                account_type=AccountType.BP_WALLET,
+            )
+        assert "qualified name should start with" in str(cm.value)
+
+        with pytest.raises(ValidationError) as cm:
+            LedgerAccount(
+                display_name=name,
+                qualified_name="fish sticks:bp_wallet",
+                normal_balance=Direction.DEBIT,
+                account_type=AccountType.BP_WALLET,
+                currency="fish sticks",
+            )
+        assert "Invalid UUID" in str(cm.value)
diff --git a/tests/models/thl/test_marketplace_condition.py b/tests/models/thl/test_marketplace_condition.py
new file mode 100644
index 0000000..217616d
--- /dev/null
+++ b/tests/models/thl/test_marketplace_condition.py
@@ -0,0 +1,382 @@
+import pytest
+from pydantic import ValidationError
+
+
+class TestMarketplaceCondition:
+
+    def test_list_or(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"a2"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a2"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a3"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas) is None
+
+    def test_list_or_negate(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"a2"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a2"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a3"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas) is None
+
+    def test_list_and(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"a1", "a2"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a2"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert c.evaluate_criterion(user_qas)
+        user_qas = {"q1": {"a1"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a3"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=False,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert c.evaluate_criterion(user_qas) is None
+
+    def test_list_and_negate(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"a1", "a2"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a2"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a3"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=True,
+            value_type=ConditionValueType.LIST,
+            values=["a1", "a2", "a3"],
+            logical_operator=LogicalOperator.AND,
+        )
+        assert c.evaluate_criterion(user_qas) is None
+
+    def test_ranges(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"2", "50"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4", "10-20"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["10-20"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4", "10-20"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas) is None
+        # --- negate
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4", "10-20"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.RANGE,
+            values=["10-20"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        # --- AND
+        with pytest.raises(expected_exception=ValidationError):
+            c = MarketplaceCondition(
+                question_id="q1",
+                negate=False,
+                value_type=ConditionValueType.RANGE,
+                values=["1-4", "10-20"],
+                logical_operator=LogicalOperator.AND,
+            )
+
+    def test_ranges_to_list(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"2", "50"}}
+        MarketplaceCondition._CONVERT_LIST_TO_RANGE = ["q1"]
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4", "10-12", "3-5"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        assert ConditionValueType.LIST == c.value_type
+        assert ["1", "10", "11", "12", "2", "3", "4", "5"] == c.values
+
+    def test_ranges_infinity(self):
+        from generalresearch.models import LogicalOperator
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"2", "50"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4", "10-inf"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion(user_qas)
+        user_qas = {"q1": {"5", "50"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["1-4", "60-inf"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion(user_qas)
+
+        # need to test negative infinity!
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["inf-40"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert c.evaluate_criterion({"q1": {"5", "50"}})
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.RANGE,
+            values=["inf-40"],
+            logical_operator=LogicalOperator.OR,
+        )
+        assert not c.evaluate_criterion({"q1": {"50"}})
+
+    def test_answered(self):
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_qas = {"q1": {"a2"}}
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=False,
+            value_type=ConditionValueType.ANSWERED,
+            values=[],
+        )
+        assert c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=False,
+            value_type=ConditionValueType.ANSWERED,
+            values=[],
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q1",
+            negate=True,
+            value_type=ConditionValueType.ANSWERED,
+            values=[],
+        )
+        assert not c.evaluate_criterion(user_qas)
+        c = MarketplaceCondition(
+            question_id="q2",
+            negate=True,
+            value_type=ConditionValueType.ANSWERED,
+            values=[],
+        )
+        assert c.evaluate_criterion(user_qas)
+
+    def test_invite(self):
+        from generalresearch.models.thl.survey.condition import (
+            MarketplaceCondition,
+            ConditionValueType,
+        )
+
+        user_groups = {"g1", "g2", "g3"}
+        c = MarketplaceCondition(
+            question_id=None,
+            negate=False,
+            value_type=ConditionValueType.RECONTACT,
+            values=["g1", "g4"],
+        )
+        assert c.evaluate_criterion(user_qas=dict(), user_groups=user_groups)
+        c = MarketplaceCondition(
+            question_id=None,
+            negate=False,
+            value_type=ConditionValueType.RECONTACT,
+            values=["g4"],
+        )
+        assert not c.evaluate_criterion(user_qas=dict(), user_groups=user_groups)
+
+        c = MarketplaceCondition(
+            question_id=None,
+            negate=True,
+            value_type=ConditionValueType.RECONTACT,
+            values=["g1", "g4"],
+        )
+        assert not c.evaluate_criterion(user_qas=dict(), user_groups=user_groups)
+        c = MarketplaceCondition(
+            question_id=None,
+            negate=True,
+            value_type=ConditionValueType.RECONTACT,
+            values=["g4"],
+        )
+        assert c.evaluate_criterion(user_qas=dict(), user_groups=user_groups)
diff --git a/tests/models/thl/test_payout.py b/tests/models/thl/test_payout.py
new file mode 100644
index 0000000..3a51328
--- /dev/null
+++ b/tests/models/thl/test_payout.py
@@ -0,0 +1,10 @@
+class TestBusinessPayoutEvent:
+
+    def test_validate(self):
+        from generalresearch.models.gr.business import Business
+
+        instance = Business.model_validate_json(
+            json_data='{"id":123,"uuid":"947f6ba5250d442b9a66cde9ee33605a","name":"Example » Demo","kind":"c","tax_number":null,"contact":null,"addresses":[],"teams":[{"id":53,"uuid":"8e4197dcaefe4f1f831a02b212e6b44a","name":"Example » Demo","memberships":null,"gr_users":null,"businesses":null,"products":null}],"products":[{"id":"fc23e741b5004581b30e6478363525df","id_int":1234,"name":"Example","enabled":true,"payments_enabled":true,"created":"2025-04-14T13:25:37.279403Z","team_id":"9e4197dcaefe4f1f831a02b212e6b44a","business_id":"857f6ba6160d442b9a66cde9ee33605a","tags":[],"commission_pct":"0.050000","redirect_url":"https://pam-api-us.reppublika.com/v2/public/4970ef00-0ef7-11f0-9962-05cb6323c84c/grl/status","harmonizer_domain":"https://talk.generalresearch.com/","sources_config":{"user_defined":[{"name":"w","active":false,"banned_countries":[],"allow_mobile_ip":true,"supplier_id":null,"allow_pii_only_buyers":false,"allow_unhashed_buyers":false,"withhold_profiling":false,"pass_unconditional_eligible_unknowns":true,"address":null,"allow_vpn":null,"distribute_harmonizer_active":null}]},"session_config":{"max_session_len":600,"max_session_hard_retry":5,"min_payout":"0.14"},"payout_config":{"payout_format":null,"payout_transformation":null},"user_wallet_config":{"enabled":false,"amt":false,"supported_payout_types":["CASH_IN_MAIL","PAYPAL","TANGO"],"min_cashout":null},"user_create_config":{"min_hourly_create_limit":0,"max_hourly_create_limit":null},"offerwall_config":{},"profiling_config":{"enabled":true,"grs_enabled":true,"n_questions":null,"max_questions":10,"avg_question_count":5.0,"task_injection_freq_mult":1.0,"non_us_mult":2.0,"hidden_questions_expiration_hours":168},"user_health_config":{"banned_countries":[],"allow_ban_iphist":true},"yield_man_config":{},"balance":null,"payouts_total_str":null,"payouts_total":null,"payouts":null,"user_wallet":{"enabled":false,"amt":false,"supported_payout_types":["CASH_IN_MAIL","PAYPAL","TANGO"],"min_cashout":null}}],"bank_accounts":[],"balance":{"product_balances":[{"product_id":"fc14e741b5004581b30e6478363414df","last_event":null,"bp_payment_credit":780251,"adjustment_credit":4678,"adjustment_debit":26446,"supplier_credit":0,"supplier_debit":451513,"user_bonus_credit":0,"user_bonus_debit":0,"issued_payment":0,"payout":780251,"payout_usd_str":"$7,802.51","adjustment":-21768,"expense":0,"net":758483,"payment":451513,"payment_usd_str":"$4,515.13","balance":306970,"retainer":76742,"retainer_usd_str":"$767.42","available_balance":230228,"available_balance_usd_str":"$2,302.28","recoup":0,"recoup_usd_str":"$0.00","adjustment_percent":0.027898714644390074}],"payout":780251,"payout_usd_str":"$7,802.51","adjustment":-21768,"expense":0,"net":758483,"net_usd_str":"$7,584.83","payment":451513,"payment_usd_str":"$4,515.13","balance":306970,"balance_usd_str":"$3,069.70","retainer":76742,"retainer_usd_str":"$767.42","available_balance":230228,"available_balance_usd_str":"$2,302.28","adjustment_percent":0.027898714644390074,"recoup":0,"recoup_usd_str":"$0.00"},"payouts_total_str":"$4,515.13","payouts_total":451513,"payouts":[{"bp_payouts":[{"uuid":"40cf2c3c341e4f9d985be4bca43e6116","debit_account_uuid":"3a058056da85493f9b7cdfe375aad0e0","cashout_method_uuid":"602113e330cf43ae85c07d94b5100291","created":"2025-08-02T09:18:20.433329Z","amount":345735,"status":"COMPLETE","ext_ref_id":null,"payout_type":"ACH","request_data":{},"order_data":null,"product_id":"fc14e741b5004581b30e6478363414df","method":"ACH","amount_usd":345735,"amount_usd_str":"$3,457.35"}],"amount":345735,"amount_usd_str":"$3,457.35","created":"2025-08-02T09:18:20.433329Z","line_items":1,"ext_ref_id":null},{"bp_payouts":[{"uuid":"63ce1787087248978919015c8fcd5ab9","debit_account_uuid":"3a058056da85493f9b7cdfe375aad0e0","cashout_method_uuid":"602113e330cf43ae85c07d94b5100291","created":"2025-06-10T22:16:18.765668Z","amount":105778,"status":"COMPLETE","ext_ref_id":"11175997868","payout_type":"ACH","request_data":{},"order_data":null,"product_id":"fc14e741b5004581b30e6478363414df","method":"ACH","amount_usd":105778,"amount_usd_str":"$1,057.78"}],"amount":105778,"amount_usd_str":"$1,057.78","created":"2025-06-10T22:16:18.765668Z","line_items":1,"ext_ref_id":"11175997868"}]}'
+        )
+
+        assert isinstance(instance, Business)
diff --git a/tests/models/thl/test_payout_format.py b/tests/models/thl/test_payout_format.py
new file mode 100644
index 0000000..dc91f39
--- /dev/null
+++ b/tests/models/thl/test_payout_format.py
@@ -0,0 +1,46 @@
+import pytest
+from pydantic import BaseModel
+
+from generalresearch.models.thl.payout_format import (
+    PayoutFormatType,
+    PayoutFormatField,
+    format_payout_format,
+)
+
+
+class PayoutFormatTestClass(BaseModel):
+    payout_format: PayoutFormatType = PayoutFormatField
+
+
+class TestPayoutFormat:
+    def test_payout_format_cls(self):
+        # valid
+        PayoutFormatTestClass(payout_format="{payout*10:,.0f} Points")
+        PayoutFormatTestClass(payout_format="{payout:.0f}")
+        PayoutFormatTestClass(payout_format="${payout/100:.2f}")
+
+        # invalid
+        with pytest.raises(expected_exception=Exception) as e:
+            PayoutFormatTestClass(payout_format="{payout10:,.0f} Points")
+
+        with pytest.raises(expected_exception=Exception) as e:
+            PayoutFormatTestClass(payout_format="payout:,.0f} Points")
+
+        with pytest.raises(expected_exception=Exception):
+            PayoutFormatTestClass(payout_format="payout")
+
+        with pytest.raises(expected_exception=Exception):
+            PayoutFormatTestClass(payout_format="{payout;import sys:.0f}")
+
+    def test_payout_format(self):
+        assert "1,230 Points" == format_payout_format(
+            payout_format="{payout*10:,.0f} Points", payout_int=123
+        )
+
+        assert "123" == format_payout_format(
+            payout_format="{payout:.0f}", payout_int=123
+        )
+
+        assert "$1.23" == format_payout_format(
+            payout_format="${payout/100:.2f}", payout_int=123
+        )
diff --git a/tests/models/thl/test_product.py b/tests/models/thl/test_product.py
new file mode 100644
index 0000000..52f60c2
--- /dev/null
+++ b/tests/models/thl/test_product.py
@@ -0,0 +1,1130 @@
+import os
+import shutil
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+from typing import Optional
+from uuid import uuid4
+
+import pytest
+from pydantic import ValidationError
+
+from generalresearch.currency import USDCent
+from generalresearch.models import Source
+from generalresearch.models.thl.product import (
+    Product,
+    PayoutConfig,
+    PayoutTransformation,
+    ProfilingConfig,
+    SourcesConfig,
+    IntegrationMode,
+    SupplyConfig,
+    SourceConfig,
+    SupplyPolicy,
+)
+
+
+class TestProduct:
+
+    def test_init(self):
+        # By default, just a Pydantic instance doesn't have an id_int
+        instance = Product.model_validate(
+            dict(
+                id="968a9acc79b74b6fb49542d82516d284",
+                name="test-968a9acc",
+                redirect_url="https://www.google.com/hey",
+            )
+        )
+        assert instance.id_int is None
+
+        res = instance.model_dump_json()
+        # We're not excluding anything here, only in the "*Out" variants
+        assert "id_int" in res
+
+    def test_init_db(self, product_manager):
+        # By default, just a Pydantic instance doesn't have an id_int
+        instance = product_manager.create_dummy()
+        assert isinstance(instance.id_int, int)
+
+        res = instance.model_dump_json()
+
+        # we json skip & exclude
+        res = instance.model_dump()
+
+    def test_redirect_url(self):
+        p = Product.model_validate(
+            dict(
+                id="968a9acc79b74b6fb49542d82516d284",
+                created="2023-09-21T22:13:09.274672Z",
+                commission_pct=Decimal("0.05"),
+                enabled=True,
+                sources=[{"name": "d", "active": True}],
+                name="test-968a9acc",
+                max_session_len=600,
+                team_id="8b5e94afd8a246bf8556ad9986486baa",
+                redirect_url="https://www.google.com/hey",
+            )
+        )
+
+        with pytest.raises(expected_exception=ValidationError):
+            p.redirect_url = ""
+
+        with pytest.raises(expected_exception=ValidationError):
+            p.redirect_url = None
+
+        with pytest.raises(expected_exception=ValidationError):
+            p.redirect_url = "http://www.example.com/test/?a=1&b=2"
+
+        with pytest.raises(expected_exception=ValidationError):
+            p.redirect_url = "http://www.example.com/test/?a=1&b=2&tsid="
+
+        p.redirect_url = "https://www.example.com/test/?a=1&b=2"
+        c = p.generate_bp_redirect(tsid="c6ab6ba1e75b44e2bf5aab00fc68e3b7")
+        assert (
+            c
+            == "https://www.example.com/test/?a=1&b=2&tsid=c6ab6ba1e75b44e2bf5aab00fc68e3b7"
+        )
+
+    def test_harmonizer_domain(self):
+        p = Product(
+            id="968a9acc79b74b6fb49542d82516d284",
+            created="2023-09-21T22:13:09.274672Z",
+            commission_pct=Decimal("0.05"),
+            enabled=True,
+            name="test-968a9acc",
+            team_id="8b5e94afd8a246bf8556ad9986486baa",
+            harmonizer_domain="profile.generalresearch.com",
+            redirect_url="https://www.google.com/hey",
+        )
+        assert p.harmonizer_domain == "https://profile.generalresearch.com/"
+        p.harmonizer_domain = "https://profile.generalresearch.com/"
+        p.harmonizer_domain = "https://profile.generalresearch.com"
+        assert p.harmonizer_domain == "https://profile.generalresearch.com/"
+        with pytest.raises(expected_exception=Exception):
+            p.harmonizer_domain = ""
+        with pytest.raises(expected_exception=Exception):
+            p.harmonizer_domain = None
+        with pytest.raises(expected_exception=Exception):
+            # no https
+            p.harmonizer_domain = "http://profile.generalresearch.com"
+        with pytest.raises(expected_exception=Exception):
+            # "/a" at the end
+            p.harmonizer_domain = "https://profile.generalresearch.com/a"
+
+    def test_payout_xform(self):
+        p = Product(
+            id="968a9acc79b74b6fb49542d82516d284",
+            created="2023-09-21T22:13:09.274672Z",
+            commission_pct=Decimal("0.05"),
+            enabled=True,
+            name="test-968a9acc",
+            team_id="8b5e94afd8a246bf8556ad9986486baa",
+            harmonizer_domain="profile.generalresearch.com",
+            redirect_url="https://www.google.com/hey",
+        )
+
+        p.payout_config.payout_transformation = PayoutTransformation.model_validate(
+            {
+                "f": "payout_transformation_percent",
+                "kwargs": {"pct": "0.5", "min_payout": "0.10"},
+            }
+        )
+
+        assert (
+            "payout_transformation_percent" == p.payout_config.payout_transformation.f
+        )
+        assert 0.5 == p.payout_config.payout_transformation.kwargs.pct
+        assert (
+            Decimal("0.10") == p.payout_config.payout_transformation.kwargs.min_payout
+        )
+        assert p.payout_config.payout_transformation.kwargs.max_payout is None
+
+        # This calls get_payout_transformation_func
+        # 50% of $1.00
+        assert Decimal("0.50") == p.calculate_user_payment(Decimal(1))
+        # with a min
+        assert Decimal("0.10") == p.calculate_user_payment(Decimal("0.15"))
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            p.payout_config.payout_transformation = PayoutTransformation.model_validate(
+                {"f": "payout_transformation_percent", "kwargs": {}}
+            )
+        assert "1 validation error for PayoutTransformation\nkwargs.pct" in str(
+            cm.value
+        )
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            p.payout_config.payout_transformation = PayoutTransformation.model_validate(
+                {"f": "payout_transformation_percent"}
+            )
+
+        assert "1 validation error for PayoutTransformation\nkwargs" in str(cm.value)
+
+        with pytest.warns(expected_warning=Warning) as w:
+            p.payout_config.payout_transformation = PayoutTransformation.model_validate(
+                {
+                    "f": "payout_transformation_percent",
+                    "kwargs": {"pct": 1, "min_payout": "0.5"},
+                }
+            )
+        assert "Are you sure you want to pay respondents >95% of CPI?" in "".join(
+            [str(i.message) for i in w]
+        )
+
+        p.payout_config = PayoutConfig()
+        assert p.calculate_user_payment(Decimal("0.15")) is None
+
+    def test_payout_xform_amt(self):
+        p = Product(
+            id="968a9acc79b74b6fb49542d82516d284",
+            created="2023-09-21T22:13:09.274672Z",
+            commission_pct=Decimal("0.05"),
+            enabled=True,
+            name="test-968a9acc",
+            team_id="8b5e94afd8a246bf8556ad9986486baa",
+            harmonizer_domain="profile.generalresearch.com",
+            redirect_url="https://www.google.com/hey",
+        )
+
+        p.payout_config.payout_transformation = PayoutTransformation.model_validate(
+            {
+                "f": "payout_transformation_amt",
+            }
+        )
+
+        assert "payout_transformation_amt" == p.payout_config.payout_transformation.f
+
+        # This calls get_payout_transformation_func
+        # 95% of $1.00
+        assert p.calculate_user_payment(Decimal(1)) == Decimal("0.95")
+        assert p.calculate_user_payment(Decimal("1.05")) == Decimal("1.00")
+
+        assert p.calculate_user_payment(
+            Decimal("0.10"), user_wallet_balance=Decimal(0)
+        ) == Decimal("0.07")
+        assert p.calculate_user_payment(
+            Decimal("1.05"), user_wallet_balance=Decimal(0)
+        ) == Decimal("0.97")
+        assert p.calculate_user_payment(
+            Decimal(".05"), user_wallet_balance=Decimal(1)
+        ) == Decimal("0.02")
+        # final balance will be <0, so pay the full amount
+        assert p.calculate_user_payment(
+            Decimal(".50"), user_wallet_balance=Decimal(-1)
+        ) == p.calculate_user_payment(Decimal("0.50"))
+        # final balance will be >0, so do the 7c rounding
+        assert p.calculate_user_payment(
+            Decimal(".50"), user_wallet_balance=Decimal("-0.10")
+        ) == (
+            p.calculate_user_payment(Decimal(".40"), user_wallet_balance=Decimal(0))
+            - Decimal("-0.10")
+        )
+
+    def test_payout_xform_none(self):
+        p = Product(
+            id="968a9acc79b74b6fb49542d82516d284",
+            created="2023-09-21T22:13:09.274672Z",
+            commission_pct=Decimal("0.05"),
+            enabled=True,
+            name="test-968a9acc",
+            team_id="8b5e94afd8a246bf8556ad9986486baa",
+            harmonizer_domain="profile.generalresearch.com",
+            redirect_url="https://www.google.com/hey",
+            payout_config=PayoutConfig(payout_format=None, payout_transformation=None),
+        )
+        assert p.format_payout_format(Decimal("1.00")) is None
+
+        pt = PayoutTransformation.model_validate(
+            {"kwargs": {"pct": 0.5}, "f": "payout_transformation_percent"}
+        )
+        p.payout_config = PayoutConfig(
+            payout_format="{payout*10:,.0f} Points", payout_transformation=pt
+        )
+        assert p.format_payout_format(Decimal("1.00")) == "1,000 Points"
+
+    def test_profiling(self):
+        p = Product(
+            id="968a9acc79b74b6fb49542d82516d284",
+            created="2023-09-21T22:13:09.274672Z",
+            commission_pct=Decimal("0.05"),
+            enabled=True,
+            name="test-968a9acc",
+            team_id="8b5e94afd8a246bf8556ad9986486baa",
+            harmonizer_domain="profile.generalresearch.com",
+            redirect_url="https://www.google.com/hey",
+        )
+        assert p.profiling_config.enabled is True
+
+        p.profiling_config = ProfilingConfig(max_questions=1)
+        assert p.profiling_config.max_questions == 1
+
+    def test_bp_account(self, product, thl_lm):
+        assert product.bp_account is None
+
+        product.prefetch_bp_account(thl_lm=thl_lm)
+
+        from generalresearch.models.thl.ledger import LedgerAccount
+
+        assert isinstance(product.bp_account, LedgerAccount)
+
+
+class TestGlobalProduct:
+    # We have one product ID that is special; we call it the Global
+    # Product ID and in prod the. This product stores a bunch of extra
+    # things in the SourcesConfig
+
+    def test_init_and_props(self):
+        instance = Product(
+            name="Global Config",
+            redirect_url="https://www.example.com",
+            sources_config=SupplyConfig(
+                policies=[
+                    # This is the config for Dynata that any BP is allowed to use
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        integration_mode=IntegrationMode.PLATFORM,
+                    ),
+                    # Spectrum that is using OUR credentials, that anyone is allowed to use.
+                    #   Same as the dynata config above, just that the dynata supplier_id is
+                    #   inferred by the dynata-grpc; it's not required to be set.
+                    SupplyPolicy(
+                        address=["https://spectrum.internal:50051"],
+                        active=True,
+                        name=Source.SPECTRUM,
+                        supplier_id="example-supplier-id",
+                        # implicit Scope = GLOBAL
+                        # default integration_mode=IntegrationMode.PLATFORM,
+                    ),
+                    # A spectrum config with a different supplier_id, but
+                    #   it is OUR supplier, and we are paid for the completes. Only a certain BP
+                    #   can use this config.
+                    SupplyPolicy(
+                        address=["https://spectrum.internal:50051"],
+                        active=True,
+                        name=Source.SPECTRUM,
+                        supplier_id="example-supplier-id",
+                        team_ids=["d42194c2dfe44d7c9bec98123bc4a6c0"],
+                        # implicit Scope = TEAM
+                        # default integration_mode=IntegrationMode.PLATFORM,
+                    ),
+                    # The supplier ID is associated with THEIR
+                    #   credentials, and we do not get paid for this activity.
+                    SupplyPolicy(
+                        address=["https://cint.internal:50051"],
+                        active=True,
+                        name=Source.CINT,
+                        supplier_id="example-supplier-id",
+                        product_ids=["db8918b3e87d4444b60241d0d3a54caa"],
+                        integration_mode=IntegrationMode.PASS_THROUGH,
+                    ),
+                    # We could have another global cint integration available
+                    # to anyone also, or we could have another like above
+                    SupplyPolicy(
+                        address=["https://cint.internal:50051"],
+                        active=True,
+                        name=Source.CINT,
+                        supplier_id="example-supplier-id",
+                        team_ids=["b163972a59584de881e5eab01ad10309"],
+                        integration_mode=IntegrationMode.PASS_THROUGH,
+                    ),
+                ]
+            ),
+        )
+
+        assert Product.model_validate_json(instance.model_dump_json()) == instance
+
+        s = instance.sources_config
+        # Cint should NOT have a global config
+        assert set(s.global_scoped_policies_dict.keys()) == {
+            Source.DYNATA,
+            Source.SPECTRUM,
+        }
+
+        # The spectrum global config is the one that isn't scoped to a
+        # specific supplier
+        assert (
+            s.global_scoped_policies_dict[Source.SPECTRUM].supplier_id
+            == "grl-supplier-id"
+        )
+
+        assert set(s.team_scoped_policies_dict.keys()) == {
+            "b163972a59584de881e5eab01ad10309",
+            "d42194c2dfe44d7c9bec98123bc4a6c0",
+        }
+        # This team has one team-scoped config, and it's for spectrum
+        assert s.team_scoped_policies_dict[
+            "d42194c2dfe44d7c9bec98123bc4a6c0"
+        ].keys() == {Source.SPECTRUM}
+
+        # For a random product/team, it'll just have the globally-scoped config
+        random_product = uuid4().hex
+        random_team = uuid4().hex
+        res = instance.sources_config.get_policies_for(
+            product_id=random_product, team_id=random_team
+        )
+        assert res == s.global_scoped_policies_dict
+
+        # It'll have the global config plus cint, and it should use the PRODUCT
+        #  scoped config, not the TEAM scoped!
+        res = instance.sources_config.get_policies_for(
+            product_id="db8918b3e87d4444b60241d0d3a54caa",
+            team_id="b163972a59584de881e5eab01ad10309",
+        )
+        assert set(res.keys()) == {
+            Source.DYNATA,
+            Source.SPECTRUM,
+            Source.CINT,
+        }
+        assert res[Source.CINT].supplier_id == "example-supplier-id"
+
+    def test_source_vs_supply_validate(self):
+        # sources_config can be a SupplyConfig or SourcesConfig.
+        # make sure they get model_validated correctly
+        gp = Product(
+            name="Global Config",
+            redirect_url="https://www.example.com",
+            sources_config=SupplyConfig(
+                policies=[
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        integration_mode=IntegrationMode.PLATFORM,
+                    )
+                ]
+            ),
+        )
+        bp = Product(
+            name="test product config",
+            redirect_url="https://www.example.com",
+            sources_config=SourcesConfig(
+                user_defined=[
+                    SourceConfig(
+                        active=False,
+                        name=Source.DYNATA,
+                    )
+                ]
+            ),
+        )
+        assert Product.model_validate_json(gp.model_dump_json()) == gp
+        assert Product.model_validate_json(bp.model_dump_json()) == bp
+
+    def test_validations(self):
+        with pytest.raises(
+            ValidationError, match="Can only have one GLOBAL policy per Source"
+        ):
+            SupplyConfig(
+                policies=[
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        integration_mode=IntegrationMode.PLATFORM,
+                    ),
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        integration_mode=IntegrationMode.PASS_THROUGH,
+                    ),
+                ]
+            )
+        with pytest.raises(
+            ValidationError,
+            match="Can only have one PRODUCT policy per Source per BP",
+        ):
+            SupplyConfig(
+                policies=[
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        product_ids=["7e417dec1c8a406e8554099b46e518ca"],
+                        integration_mode=IntegrationMode.PLATFORM,
+                    ),
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        product_ids=["7e417dec1c8a406e8554099b46e518ca"],
+                        integration_mode=IntegrationMode.PASS_THROUGH,
+                    ),
+                ]
+            )
+        with pytest.raises(
+            ValidationError,
+            match="Can only have one TEAM policy per Source per Team",
+        ):
+            SupplyConfig(
+                policies=[
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        team_ids=["7e417dec1c8a406e8554099b46e518ca"],
+                        integration_mode=IntegrationMode.PLATFORM,
+                    ),
+                    SupplyPolicy(
+                        address=["https://dynata.internal:50051"],
+                        active=True,
+                        name=Source.DYNATA,
+                        team_ids=["7e417dec1c8a406e8554099b46e518ca"],
+                        integration_mode=IntegrationMode.PASS_THROUGH,
+                    ),
+                ]
+            )
+
+
+class TestGlobalProductConfigFor:
+    def test_no_user_defined(self):
+        sc = SupplyConfig(
+            policies=[
+                SupplyPolicy(
+                    address=["https://dynata.internal:50051"],
+                    active=True,
+                    name=Source.DYNATA,
+                )
+            ]
+        )
+        product = Product(
+            name="Test Product Config",
+            redirect_url="https://www.example.com",
+            sources_config=SourcesConfig(),
+        )
+        res = sc.get_config_for_product(product=product)
+        assert len(res.policies) == 1
+
+    def test_user_defined_merge(self):
+        sc = SupplyConfig(
+            policies=[
+                SupplyPolicy(
+                    address=["https://dynata.internal:50051"],
+                    banned_countries=["mx"],
+                    active=True,
+                    name=Source.DYNATA,
+                ),
+                SupplyPolicy(
+                    address=["https://dynata.internal:50051"],
+                    banned_countries=["ca"],
+                    active=True,
+                    name=Source.DYNATA,
+                    team_ids=[uuid4().hex],
+                ),
+            ]
+        )
+        product = Product(
+            name="Test Product Config",
+            redirect_url="https://www.example.com",
+            sources_config=SourcesConfig(
+                user_defined=[
+                    SourceConfig(
+                        name=Source.DYNATA,
+                        active=False,
+                        banned_countries=["us"],
+                    )
+                ]
+            ),
+        )
+        res = sc.get_config_for_product(product=product)
+        assert len(res.policies) == 1
+        assert not res.policies[0].active
+        assert res.policies[0].banned_countries == ["mx", "us"]
+
+    def test_no_eligible(self):
+        sc = SupplyConfig(
+            policies=[
+                SupplyPolicy(
+                    address=["https://dynata.internal:50051"],
+                    active=True,
+                    name=Source.DYNATA,
+                    team_ids=["7e417dec1c8a406e8554099b46e518ca"],
+                    integration_mode=IntegrationMode.PLATFORM,
+                )
+            ]
+        )
+        product = Product(
+            name="Test Product Config",
+            redirect_url="https://www.example.com",
+            sources_config=SourcesConfig(),
+        )
+        res = sc.get_config_for_product(product=product)
+        assert len(res.policies) == 0
+
+
+class TestProductFinancials:
+
+    @pytest.fixture
+    def start(self) -> "datetime":
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+
+    @pytest.fixture
+    def offset(self) -> str:
+        return "30d"
+
+    @pytest.fixture
+    def duration(self) -> Optional["timedelta"]:
+        return None
+
+    def test_balance(
+        self,
+        business,
+        product_factory,
+        user_factory,
+        mnt_filepath,
+        bp_payout_factory,
+        thl_lm,
+        lm,
+        duration,
+        offset,
+        thl_redis_config,
+        start,
+        thl_web_rr,
+        brokerage_product_payout_event_manager,
+        session_with_tx_factory,
+        delete_ledger_db,
+        create_main_accounts,
+        client_no_amm,
+        ledger_collection,
+        pop_ledger_merge,
+        delete_df_collection,
+    ):
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.product import Product
+        from generalresearch.models.thl.user import User
+        from generalresearch.models.thl.finance import ProductBalances
+        from generalresearch.currency import USDCent
+
+        p1: Product = product_factory(business=business)
+        u1: User = user_factory(product=p1)
+        bp_wallet = thl_lm.get_account_or_create_bp_wallet(product=p1)
+        thl_lm.get_account_or_create_user_wallet(user=u1)
+        brokerage_product_payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+
+        assert len(thl_lm.get_tx_filtered_by_account(account_uuid=bp_wallet.uuid)) == 0
+
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".50"),
+            started=start + timedelta(days=1),
+        )
+        assert thl_lm.get_account_balance(account=bp_wallet) == 48
+        assert len(thl_lm.get_tx_filtered_by_account(account_uuid=bp_wallet.uuid)) == 1
+
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal("1.00"),
+            started=start + timedelta(days=2),
+        )
+        assert thl_lm.get_account_balance(account=bp_wallet) == 143
+        assert len(thl_lm.get_tx_filtered_by_account(account_uuid=bp_wallet.uuid)) == 2
+
+        with pytest.raises(expected_exception=AssertionError) as cm:
+            p1.prebuild_balance(
+                thl_lm=thl_lm,
+                ds=mnt_filepath,
+                client=client_no_amm,
+            )
+        assert "Cannot build Product Balance" in str(cm.value)
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        p1.prebuild_balance(
+            thl_lm=thl_lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+        )
+        assert isinstance(p1.balance, ProductBalances)
+        assert p1.balance.payout == 143
+        assert p1.balance.adjustment == 0
+        assert p1.balance.expense == 0
+        assert p1.balance.net == 143
+        assert p1.balance.balance == 143
+        assert p1.balance.retainer == 35
+        assert p1.balance.available_balance == 108
+
+        p1.prebuild_payouts(
+            thl_lm=thl_lm,
+            bp_pem=brokerage_product_payout_event_manager,
+        )
+        assert p1.payouts is not None
+        assert len(p1.payouts) == 0
+        assert p1.payouts_total == 0
+        assert p1.payouts_total_str == "$0.00"
+
+        # -- Now pay them out...
+
+        bp_payout_factory(
+            product=p1,
+            amount=USDCent(50),
+            created=start + timedelta(days=3),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+        assert len(thl_lm.get_tx_filtered_by_account(account_uuid=bp_wallet.uuid)) == 3
+
+        # RM the entire directories
+        shutil.rmtree(ledger_collection.archive_path)
+        os.makedirs(ledger_collection.archive_path, exist_ok=True)
+        shutil.rmtree(pop_ledger_merge.archive_path)
+        os.makedirs(pop_ledger_merge.archive_path, exist_ok=True)
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        p1.prebuild_balance(
+            thl_lm=thl_lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+        )
+        assert isinstance(p1.balance, ProductBalances)
+        assert p1.balance.payout == 143
+        assert p1.balance.adjustment == 0
+        assert p1.balance.expense == 0
+        assert p1.balance.net == 143
+        assert p1.balance.balance == 93
+        assert p1.balance.retainer == 23
+        assert p1.balance.available_balance == 70
+
+        p1.prebuild_payouts(
+            thl_lm=thl_lm,
+            bp_pem=brokerage_product_payout_event_manager,
+        )
+        assert p1.payouts is not None
+        assert len(p1.payouts) == 1
+        assert p1.payouts_total == 50
+        assert p1.payouts_total_str == "$0.50"
+
+        # -- Now pay ou another!.
+
+        bp_payout_factory(
+            product=p1,
+            amount=USDCent(5),
+            created=start + timedelta(days=4),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+        assert len(thl_lm.get_tx_filtered_by_account(account_uuid=bp_wallet.uuid)) == 4
+
+        # RM the entire directories
+        shutil.rmtree(ledger_collection.archive_path)
+        os.makedirs(ledger_collection.archive_path, exist_ok=True)
+        shutil.rmtree(pop_ledger_merge.archive_path)
+        os.makedirs(pop_ledger_merge.archive_path, exist_ok=True)
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        p1.prebuild_balance(
+            thl_lm=thl_lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+        )
+        assert isinstance(p1.balance, ProductBalances)
+        assert p1.balance.payout == 143
+        assert p1.balance.adjustment == 0
+        assert p1.balance.expense == 0
+        assert p1.balance.net == 143
+        assert p1.balance.balance == 88
+        assert p1.balance.retainer == 22
+        assert p1.balance.available_balance == 66
+
+        p1.prebuild_payouts(
+            thl_lm=thl_lm,
+            bp_pem=brokerage_product_payout_event_manager,
+        )
+        assert p1.payouts is not None
+        assert len(p1.payouts) == 2
+        assert p1.payouts_total == 55
+        assert p1.payouts_total_str == "$0.55"
+
+
+class TestProductBalance:
+
+    @pytest.fixture
+    def start(self) -> "datetime":
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+
+    @pytest.fixture
+    def offset(self) -> str:
+        return "30d"
+
+    @pytest.fixture
+    def duration(self) -> Optional["timedelta"]:
+        return None
+
+    def test_inconsistent(
+        self,
+        product,
+        mnt_filepath,
+        thl_lm,
+        client_no_amm,
+        thl_redis_config,
+        brokerage_product_payout_event_manager,
+        delete_ledger_db,
+        create_main_accounts,
+        delete_df_collection,
+        ledger_collection,
+        business,
+        user_factory,
+        product_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        start,
+        bp_payout_factory,
+        payout_event_manager,
+    ):
+        # Now let's load it up and actually test some things
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product)
+
+        # 1. Complete and Build Parquets 1st time
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        # 2. Payout and build Parquets 2nd time
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        bp_payout_factory(
+            product=product,
+            amount=USDCent(71),
+            ext_ref_id=uuid4().hex,
+            created=start + timedelta(days=1, minutes=1),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        with pytest.raises(expected_exception=AssertionError) as cm:
+            product.prebuild_balance(
+                thl_lm=thl_lm, ds=mnt_filepath, client=client_no_amm
+            )
+        assert "Sql and Parquet Balance inconsistent" in str(cm)
+
+    def test_not_inconsistent(
+        self,
+        product,
+        mnt_filepath,
+        thl_lm,
+        client_no_amm,
+        thl_redis_config,
+        brokerage_product_payout_event_manager,
+        delete_ledger_db,
+        create_main_accounts,
+        delete_df_collection,
+        ledger_collection,
+        business,
+        user_factory,
+        product_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        start,
+        bp_payout_factory,
+        payout_event_manager,
+    ):
+        # This is very similar to the test_complete_payout_pq_inconsistent
+        #   test, however this time we're only going to assign the payout
+        #   in real time, and not in the past. This means that even if we
+        #   build the parquet files multiple times, they will include the
+        #   payout.
+
+        # Now let's load it up and actually test some things
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product)
+
+        # 1. Complete and Build Parquets 1st time
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        # 2. Payout and build Parquets 2nd time but this payout is "now"
+        #    so it hasn't already been archived
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        bp_payout_factory(
+            product=product,
+            amount=USDCent(71),
+            ext_ref_id=uuid4().hex,
+            created=datetime.now(tz=timezone.utc),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        # We just want to call this to confirm it doesn't raise.
+        product.prebuild_balance(thl_lm=thl_lm, ds=mnt_filepath, client=client_no_amm)
+
+
+class TestProductPOPFinancial:
+
+    @pytest.fixture
+    def start(self) -> "datetime":
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+
+    @pytest.fixture
+    def offset(self) -> str:
+        return "30d"
+
+    @pytest.fixture
+    def duration(self) -> Optional["timedelta"]:
+        return None
+
+    def test_base(
+        self,
+        product,
+        mnt_filepath,
+        thl_lm,
+        client_no_amm,
+        thl_redis_config,
+        brokerage_product_payout_event_manager,
+        delete_ledger_db,
+        create_main_accounts,
+        delete_df_collection,
+        ledger_collection,
+        business,
+        user_factory,
+        product_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        start,
+        bp_payout_factory,
+        payout_event_manager,
+    ):
+        # This is very similar to the test_complete_payout_pq_inconsistent
+        #   test, however this time we're only going to assign the payout
+        #   in real time, and not in the past. This means that even if we
+        #   build the parquet files multiple times, they will include the
+        #   payout.
+
+        # Now let's load it up and actually test some things
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product)
+
+        # 1. Complete and Build Parquets 1st time
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        # --- test ---
+        assert product.pop_financial is None
+        product.prebuild_pop_financial(
+            thl_lm=thl_lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            pop_ledger=pop_ledger_merge,
+        )
+
+        from generalresearch.models.thl.finance import POPFinancial
+
+        assert isinstance(product.pop_financial, list)
+        assert isinstance(product.pop_financial[0], POPFinancial)
+        pf1: POPFinancial = product.pop_financial[0]
+        assert isinstance(pf1.time, datetime)
+        assert pf1.payout == 71
+        assert pf1.net == 71
+        assert pf1.adjustment == 0
+        for adj in pf1.adjustment_types:
+            assert adj.amount == 0
+
+
+class TestProductCache:
+
+    @pytest.fixture
+    def start(self) -> "datetime":
+        return datetime(year=2018, month=3, day=14, hour=0, tzinfo=timezone.utc)
+
+    @pytest.fixture
+    def offset(self) -> str:
+        return "30d"
+
+    @pytest.fixture
+    def duration(self) -> Optional["timedelta"]:
+        return None
+
+    def test_basic(
+        self,
+        product,
+        mnt_filepath,
+        thl_lm,
+        client_no_amm,
+        thl_redis_config,
+        brokerage_product_payout_event_manager,
+        delete_ledger_db,
+        create_main_accounts,
+        delete_df_collection,
+        ledger_collection,
+        business,
+        user_factory,
+        product_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        start,
+    ):
+        # Now let's load it up and actually test some things
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        # Confirm the default / null behavior
+        rc = thl_redis_config.create_redis_client()
+        res: Optional[str] = rc.get(product.cache_key)
+        assert res is None
+        with pytest.raises(expected_exception=AssertionError):
+            product.set_cache(
+                thl_lm=thl_lm,
+                ds=mnt_filepath,
+                client=client_no_amm,
+                bp_pem=brokerage_product_payout_event_manager,
+                redis_config=thl_redis_config,
+            )
+
+        from generalresearch.models.thl.product import Product
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product)
+
+        session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        # Now try again with everything in place
+        product.set_cache(
+            thl_lm=thl_lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            bp_pem=brokerage_product_payout_event_manager,
+            redis_config=thl_redis_config,
+        )
+
+        # Fetch from cache and assert the instance loaded from redis
+        res: Optional[str] = rc.get(product.cache_key)
+        assert isinstance(res, str)
+        from generalresearch.models.thl.ledger import LedgerAccount
+
+        assert isinstance(product.bp_account, LedgerAccount)
+
+        p1: Product = Product.model_validate_json(res)
+        assert p1.balance.product_id == product.uuid
+        assert p1.balance.payout_usd_str == "$0.71"
+        assert p1.balance.retainer_usd_str == "$0.17"
+        assert p1.balance.available_balance_usd_str == "$0.54"
+
+    def test_neg_balance_cache(
+        self,
+        product,
+        mnt_filepath,
+        thl_lm,
+        client_no_amm,
+        thl_redis_config,
+        brokerage_product_payout_event_manager,
+        delete_ledger_db,
+        create_main_accounts,
+        delete_df_collection,
+        ledger_collection,
+        business,
+        user_factory,
+        product_factory,
+        session_with_tx_factory,
+        pop_ledger_merge,
+        start,
+        bp_payout_factory,
+        payout_event_manager,
+        adj_to_fail_with_tx_factory,
+    ):
+        # Now let's load it up and actually test some things
+        delete_ledger_db()
+        create_main_accounts()
+        delete_df_collection(coll=ledger_collection)
+
+        from generalresearch.models.thl.product import Product
+        from generalresearch.models.thl.user import User
+
+        u1: User = user_factory(product=product)
+
+        # 1. Complete
+        s1 = session_with_tx_factory(
+            user=u1,
+            wall_req_cpi=Decimal(".75"),
+            started=start + timedelta(days=1),
+        )
+
+        # 2. Payout
+        payout_event_manager.set_account_lookup_table(thl_lm=thl_lm)
+        bp_payout_factory(
+            product=product,
+            amount=USDCent(71),
+            ext_ref_id=uuid4().hex,
+            created=start + timedelta(days=1, minutes=1),
+            skip_wallet_balance_check=True,
+            skip_one_per_day_check=True,
+        )
+
+        # 3. Recon
+        adj_to_fail_with_tx_factory(
+            session=s1,
+            created=start + timedelta(days=1, minutes=1),
+        )
+
+        # Finally, process everything:
+        ledger_collection.initial_load(client=None, sync=True)
+        pop_ledger_merge.build(client=client_no_amm, ledger_coll=ledger_collection)
+
+        product.set_cache(
+            thl_lm=thl_lm,
+            ds=mnt_filepath,
+            client=client_no_amm,
+            bp_pem=brokerage_product_payout_event_manager,
+            redis_config=thl_redis_config,
+        )
+
+        # Fetch from cache and assert the instance loaded from redis
+        rc = thl_redis_config.create_redis_client()
+        res: Optional[str] = rc.get(product.cache_key)
+        assert isinstance(res, str)
+
+        p1: Product = Product.model_validate_json(res)
+        assert p1.balance.product_id == product.uuid
+        assert p1.balance.payout_usd_str == "$0.71"
+        assert p1.balance.adjustment == -71
+        assert p1.balance.expense == 0
+        assert p1.balance.net == 0
+        assert p1.balance.balance == -71
+        assert p1.balance.retainer_usd_str == "$0.00"
+        assert p1.balance.available_balance_usd_str == "$0.00"
diff --git a/tests/models/thl/test_product_userwalletconfig.py b/tests/models/thl/test_product_userwalletconfig.py
new file mode 100644
index 0000000..4583c46
--- /dev/null
+++ b/tests/models/thl/test_product_userwalletconfig.py
@@ -0,0 +1,56 @@
+from itertools import groupby
+from random import shuffle as rshuffle
+
+from generalresearch.models.thl.product import (
+    UserWalletConfig,
+)
+
+from generalresearch.models.thl.wallet import PayoutType
+
+
+def all_equal(iterable):
+    g = groupby(iterable)
+    return next(g, True) and not next(g, False)
+
+
+class TestProductUserWalletConfig:
+
+    def test_init(self):
+        instance = UserWalletConfig()
+
+        assert isinstance(instance, UserWalletConfig)
+
+        # Check the defaults
+        assert not instance.enabled
+        assert not instance.amt
+
+        assert isinstance(instance.supported_payout_types, set)
+        assert len(instance.supported_payout_types) == 3
+
+        assert instance.min_cashout is None
+
+    def test_model_dump(self):
+        instance = UserWalletConfig()
+
+        # If we use the defaults, the supported_payout_types are always
+        #   in the same order because they're the same
+        assert isinstance(instance.model_dump_json(), str)
+        res = []
+        for idx in range(100):
+            res.append(instance.model_dump_json())
+        assert all_equal(res)
+
+    def test_model_dump_payout_types(self):
+        res = []
+        for idx in range(100):
+
+            # Generate a random order of PayoutTypes each time
+            payout_types = [e for e in PayoutType]
+            rshuffle(payout_types)
+            instance = UserWalletConfig.model_validate(
+                {"supported_payout_types": payout_types}
+            )
+
+            res.append(instance.model_dump_json())
+
+        assert all_equal(res)
diff --git a/tests/models/thl/test_soft_pair.py b/tests/models/thl/test_soft_pair.py
new file mode 100644
index 0000000..bac0e8d
--- /dev/null
+++ b/tests/models/thl/test_soft_pair.py
@@ -0,0 +1,24 @@
+from generalresearch.models import Source
+from generalresearch.models.thl.soft_pair import SoftPairResult, SoftPairResultType
+
+
+def test_model():
+    from generalresearch.models.dynata.survey import (
+        DynataCondition,
+        ConditionValueType,
+    )
+
+    c1 = DynataCondition(
+        question_id="1", value_type=ConditionValueType.LIST, values=["a", "b"]
+    )
+    c2 = DynataCondition(
+        question_id="2", value_type=ConditionValueType.LIST, values=["c", "d"]
+    )
+    sr = SoftPairResult(
+        pair_type=SoftPairResultType.CONDITIONAL,
+        source=Source.DYNATA,
+        survey_id="xxx",
+        conditions={c1, c2},
+    )
+    assert sr.grpc_string == "xxx:1;2"
+    assert sr.survey_sid == "d:xxx"
diff --git a/tests/models/thl/test_upkquestion.py b/tests/models/thl/test_upkquestion.py
new file mode 100644
index 0000000..e67427e
--- /dev/null
+++ b/tests/models/thl/test_upkquestion.py
@@ -0,0 +1,414 @@
+import pytest
+from pydantic import ValidationError
+
+
+class TestUpkQuestion:
+
+    def test_importance(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UPKImportance,
+        )
+
+        ui = UPKImportance(task_score=1, task_count=None)
+        ui = UPKImportance(task_score=0)
+        with pytest.raises(ValidationError) as e:
+            UPKImportance(task_score=-1)
+        assert "Input should be greater than or equal to 0" in str(e.value)
+
+    def test_pattern(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            PatternValidation,
+        )
+
+        s = PatternValidation(message="hi", pattern="x")
+        with pytest.raises(ValidationError) as e:
+            s.message = "sfd"
+        assert "Instance is frozen" in str(e.value)
+
+    def test_mc(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestionChoice,
+            UpkQuestionSelectorMC,
+            UpkQuestionType,
+            UpkQuestion,
+            UpkQuestionConfigurationMC,
+        )
+
+        q = UpkQuestion(
+            id="601377a0d4c74529afc6293a8e5c3b5e",
+            country_iso="us",
+            language_iso="eng",
+            type=UpkQuestionType.MULTIPLE_CHOICE,
+            selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+            text="whats up",
+            choices=[
+                UpkQuestionChoice(id="1", text="sky", order=1),
+                UpkQuestionChoice(id="2", text="moon", order=2),
+            ],
+            configuration=UpkQuestionConfigurationMC(max_select=2),
+        )
+        assert q == UpkQuestion.model_validate(q.model_dump(mode="json"))
+
+        q = UpkQuestion(
+            country_iso="us",
+            language_iso="eng",
+            type=UpkQuestionType.MULTIPLE_CHOICE,
+            selector=UpkQuestionSelectorMC.SINGLE_ANSWER,
+            text="yes or no",
+            choices=[
+                UpkQuestionChoice(id="1", text="yes", order=1),
+                UpkQuestionChoice(id="2", text="no", order=2),
+            ],
+            configuration=UpkQuestionConfigurationMC(max_select=1),
+        )
+        assert q == UpkQuestion.model_validate(q.model_dump(mode="json"))
+
+        q = UpkQuestion(
+            country_iso="us",
+            language_iso="eng",
+            type=UpkQuestionType.MULTIPLE_CHOICE,
+            selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+            text="yes or no",
+            choices=[
+                UpkQuestionChoice(id="1", text="yes", order=1),
+                UpkQuestionChoice(id="2", text="no", order=2),
+            ],
+        )
+        assert q == UpkQuestion.model_validate(q.model_dump(mode="json"))
+
+        with pytest.raises(ValidationError) as e:
+            q = UpkQuestion(
+                country_iso="us",
+                language_iso="eng",
+                type=UpkQuestionType.MULTIPLE_CHOICE,
+                selector=UpkQuestionSelectorMC.SINGLE_ANSWER,
+                text="yes or no",
+                choices=[
+                    UpkQuestionChoice(id="1", text="yes", order=1),
+                    UpkQuestionChoice(id="2", text="no", order=2),
+                ],
+                configuration=UpkQuestionConfigurationMC(max_select=2),
+            )
+        assert "max_select must be 1 if the selector is SA" in str(e.value)
+
+        with pytest.raises(ValidationError) as e:
+            q = UpkQuestion(
+                country_iso="us",
+                language_iso="eng",
+                type=UpkQuestionType.MULTIPLE_CHOICE,
+                selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+                text="yes or no",
+                choices=[
+                    UpkQuestionChoice(id="1", text="yes", order=1),
+                    UpkQuestionChoice(id="2", text="no", order=2),
+                ],
+                configuration=UpkQuestionConfigurationMC(max_select=4),
+            )
+        assert "max_select must be >= len(choices)" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            q = UpkQuestion(
+                country_iso="us",
+                language_iso="eng",
+                type=UpkQuestionType.MULTIPLE_CHOICE,
+                selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+                text="yes or no",
+                choices=[
+                    UpkQuestionChoice(id="1", text="yes", order=1),
+                    UpkQuestionChoice(id="2", text="no", order=2),
+                ],
+                configuration=UpkQuestionConfigurationMC(max_length=2),
+            )
+        assert "Extra inputs are not permitted" in str(e.value)
+
+    def test_te(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestionType,
+            UpkQuestion,
+            UpkQuestionSelectorTE,
+            UpkQuestionValidation,
+            PatternValidation,
+            UpkQuestionConfigurationTE,
+        )
+
+        q = UpkQuestion(
+            id="601377a0d4c74529afc6293a8e5c3b5e",
+            country_iso="us",
+            language_iso="eng",
+            type=UpkQuestionType.TEXT_ENTRY,
+            selector=UpkQuestionSelectorTE.MULTI_LINE,
+            text="whats up",
+            choices=[],
+            configuration=UpkQuestionConfigurationTE(max_length=2),
+            validation=UpkQuestionValidation(
+                patterns=[PatternValidation(pattern=".", message="x")]
+            ),
+        )
+        assert q == UpkQuestion.model_validate(q.model_dump(mode="json"))
+        assert q.choices is None
+
+    def test_deserialization(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestion,
+        )
+
+        q = UpkQuestion.model_validate(
+            {
+                "id": "601377a0d4c74529afc6293a8e5c3b5e",
+                "ext_question_id": "m:2342",
+                "country_iso": "us",
+                "language_iso": "eng",
+                "text": "whats up",
+                "choices": [
+                    {"id": "1", "text": "yes", "order": 1},
+                    {"id": "2", "text": "no", "order": 2},
+                ],
+                "importance": None,
+                "type": "MC",
+                "selector": "SA",
+                "configuration": None,
+            }
+        )
+        assert q == UpkQuestion.model_validate(q.model_dump(mode="json"))
+
+        q = UpkQuestion.model_validate(
+            {
+                "id": "601377a0d4c74529afc6293a8e5c3b5e",
+                "ext_question_id": "m:2342",
+                "country_iso": "us",
+                "language_iso": "eng",
+                "text": "whats up",
+                "choices": [
+                    {"id": "1", "text": "yes", "order": 1},
+                    {"id": "2", "text": "no", "order": 2},
+                ],
+                "importance": None,
+                "question_type": "MC",
+                "selector": "MA",
+                "configuration": {"max_select": 2},
+            }
+        )
+        assert q == UpkQuestion.model_validate(q.model_dump(mode="json"))
+
+    def test_from_morning(self):
+        from generalresearch.models.morning.question import (
+            MorningQuestion,
+            MorningQuestionType,
+        )
+
+        q = MorningQuestion(
+            **{
+                "id": "gender",
+                "country_iso": "us",
+                "language_iso": "eng",
+                "name": "Gender",
+                "text": "What is your gender?",
+                "type": "s",
+                "options": [
+                    {"id": "1", "text": "yes", "order": 1},
+                    {"id": "2", "text": "no", "order": 2},
+                ],
+            }
+        )
+        q.to_upk_question()
+        q = MorningQuestion(
+            country_iso="us",
+            language_iso="eng",
+            type=MorningQuestionType.text_entry,
+            text="how old r u",
+            id="a",
+            name="age",
+        )
+        q.to_upk_question()
+
+    def test_order(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestionChoice,
+            UpkQuestionSelectorMC,
+            UpkQuestionType,
+            UpkQuestion,
+            order_exclusive_options,
+        )
+
+        q = UpkQuestion(
+            country_iso="us",
+            language_iso="eng",
+            type=UpkQuestionType.MULTIPLE_CHOICE,
+            selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+            text="yes, no, or NA?",
+            choices=[
+                UpkQuestionChoice(id="1", text="NA", order=0),
+                UpkQuestionChoice(id="2", text="no", order=1),
+                UpkQuestionChoice(id="3", text="yes", order=2),
+            ],
+        )
+        order_exclusive_options(q)
+        assert (
+            UpkQuestion(
+                country_iso="us",
+                language_iso="eng",
+                type=UpkQuestionType.MULTIPLE_CHOICE,
+                selector=UpkQuestionSelectorMC.MULTIPLE_ANSWER,
+                text="yes, no, or NA?",
+                choices=[
+                    UpkQuestionChoice(id="2", text="no", order=0),
+                    UpkQuestionChoice(id="3", text="yes", order=1),
+                    UpkQuestionChoice(id="1", text="NA", order=2, exclusive=True),
+                ],
+            )
+            == q
+        )
+
+
+class TestUpkQuestionValidateAnswer:
+    def test_validate_answer_SA(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestion,
+        )
+
+        question = UpkQuestion.model_validate(
+            {
+                "choices": [
+                    {"order": 0, "choice_id": "0", "choice_text": "Male"},
+                    {"order": 1, "choice_id": "1", "choice_text": "Female"},
+                    {"order": 2, "choice_id": "2", "choice_text": "Other"},
+                ],
+                "selector": "SA",
+                "country_iso": "us",
+                "question_id": "5d6d9f3c03bb40bf9d0a24f306387d7c",
+                "language_iso": "eng",
+                "question_text": "What is your gender?",
+                "question_type": "MC",
+            }
+        )
+        answer = ("0",)
+        assert question.validate_question_answer(answer)[0] is True
+        answer = ("3",)
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Invalid Options Selected",
+        )
+        answer = ("0", "0")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Multiple of the same answer submitted",
+        )
+        answer = ("0", "1")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Single Answer MC question with >1 selected " "answers",
+        )
+
+    def test_validate_answer_MA(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestion,
+        )
+
+        question = UpkQuestion.model_validate(
+            {
+                "choices": [
+                    {
+                        "order": 0,
+                        "choice_id": "none",
+                        "exclusive": True,
+                        "choice_text": "None of the above",
+                    },
+                    {
+                        "order": 1,
+                        "choice_id": "female_under_1",
+                        "choice_text": "Female under age 1",
+                    },
+                    {
+                        "order": 2,
+                        "choice_id": "male_under_1",
+                        "choice_text": "Male under age 1",
+                    },
+                    {
+                        "order": 3,
+                        "choice_id": "female_1",
+                        "choice_text": "Female age 1",
+                    },
+                    {"order": 4, "choice_id": "male_1", "choice_text": "Male age 1"},
+                    {
+                        "order": 5,
+                        "choice_id": "female_2",
+                        "choice_text": "Female age 2",
+                    },
+                ],
+                # I removed a bunch of choices fyi
+                "selector": "MA",
+                "country_iso": "us",
+                "question_id": "3b65220db85f442ca16bb0f1c0e3a456",
+                "language_iso": "eng",
+                "question_text": "Please indicate the age and gender of your child or children:",
+                "question_type": "MC",
+            }
+        )
+        answer = ("none",)
+        assert question.validate_question_answer(answer)[0] is True
+        answer = ("male_1",)
+        assert question.validate_question_answer(answer)[0] is True
+        answer = ("male_1", "female_1")
+        assert question.validate_question_answer(answer)[0] is True
+        answer = ("xxx",)
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Invalid Options Selected",
+        )
+        answer = ("male_1", "male_1")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Multiple of the same answer submitted",
+        )
+        answer = ("male_1", "xxx")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Invalid Options Selected",
+        )
+        answer = ("male_1", "none")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Invalid exclusive selection",
+        )
+
+    def test_validate_answer_TE(self):
+        from generalresearch.models.thl.profiling.upk_question import (
+            UpkQuestion,
+        )
+
+        question = UpkQuestion.model_validate(
+            {
+                "selector": "SL",
+                "validation": {
+                    "patterns": [
+                        {
+                            "message": "Must enter a valid zip code: XXXXX",
+                            "pattern": "^[0-9]{5}$",
+                        }
+                    ]
+                },
+                "country_iso": "us",
+                "question_id": "543de254e9ca4d9faded4377edab82a9",
+                "language_iso": "eng",
+                "configuration": {"max_length": 5, "min_length": 5},
+                "question_text": "What is your zip code?",
+                "question_type": "TE",
+            }
+        )
+        answer = ("33143",)
+        assert question.validate_question_answer(answer)[0] is True
+        answer = ("33143", "33143")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Multiple of the same answer submitted",
+        )
+        answer = ("33143", "12345")
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Only one answer allowed",
+        )
+        answer = ("111",)
+        assert question.validate_question_answer(answer) == (
+            False,
+            "Must enter a valid zip code: XXXXX",
+        )
diff --git a/tests/models/thl/test_user.py b/tests/models/thl/test_user.py
new file mode 100644
index 0000000..4f10861
--- /dev/null
+++ b/tests/models/thl/test_user.py
@@ -0,0 +1,688 @@
+import json
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+from random import randint, choice as rand_choice
+from uuid import uuid4
+
+import pytest
+from pydantic import ValidationError
+
+
+class TestUserUserID:
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        val = randint(1, 2**30)
+        user = User(user_id=val)
+        assert user.user_id == val
+
+    def test_type(self):
+        from generalresearch.models.thl.user import User
+
+        # It will cast str to int
+        assert User(user_id="1").user_id == 1
+
+        # It will cast float to int
+        assert User(user_id=1.0).user_id == 1
+
+        # It will cast Decimal to int
+        assert User(user_id=Decimal("1.0")).user_id == 1
+
+        # pydantic Validation error is a ValueError, let's check both..
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=Decimal("1.00000001"))
+        assert "1 validation error for User" in str(cm.value)
+        assert "user_id" in str(cm.value)
+        assert "Input should be a valid integer," in str(cm.value)
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            User(user_id=Decimal("1.00000001"))
+        assert "1 validation error for User" in str(cm.value)
+        assert "user_id" in str(cm.value)
+        assert "Input should be a valid integer," in str(cm.value)
+
+    def test_zero(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            User(user_id=0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be greater than 0" in str(cm.value)
+
+    def test_negative(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            User(user_id=-1)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be greater than 0" in str(cm.value)
+
+    def test_too_big(self):
+        from generalresearch.models.thl.user import User
+
+        val = 2**31
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            User(user_id=val)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be less than 2147483648" in str(cm.value)
+
+    def test_identifiable(self):
+        from generalresearch.models.thl.user import User
+
+        val = randint(1, 2**30)
+        user = User(user_id=val)
+        assert user.is_identifiable
+
+
+class TestUserProductID:
+    user_id = randint(1, 2**30)
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        product_id = uuid4().hex
+
+        user = User(user_id=self.user_id, product_id=product_id)
+        assert user.user_id == self.user_id
+        assert user.product_id == product_id
+
+    def test_type(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=0.0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=Decimal("0"))
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+    def test_empty(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id="")
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at least 32 characters" in str(cm.value)
+
+    def test_invalid_len(self):
+        from generalresearch.models.thl.user import User
+
+        # Valid uuid4s are 32 char long
+        product_id = uuid4().hex[:31]
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=product_id)
+        assert "1 validation error for User", str(cm.value)
+        assert "String should have at least 32 characters", str(cm.value)
+
+        product_id = uuid4().hex * 2
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, product_id=product_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at most 32 characters" in str(cm.value)
+
+        product_id = uuid4().hex
+        product_id *= 2
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=product_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at most 32 characters" in str(cm.value)
+
+    def test_invalid_uuid(self):
+        from generalresearch.models.thl.user import User
+
+        # Modify the UUID to break it
+        product_id = uuid4().hex[:31] + "x"
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=product_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Invalid UUID" in str(cm.value)
+
+    def test_invalid_hex_form(self):
+        from generalresearch.models.thl.user import User
+
+        # Sure not in hex form, but it'll get caught for being the
+        # wrong length before anything else
+        product_id = str(uuid4())  # '1a93447e-c77b-4cfa-b58e-ed4777d57110'
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_id=product_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at most 32 characters" in str(cm.value)
+
+    def test_identifiable(self):
+        """Can't create a User with only a product_id because it also
+        needs to the product_user_id"""
+        from generalresearch.models.thl.user import User
+
+        product_id = uuid4().hex
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(product_id=product_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Value error, User is not identifiable" in str(cm.value)
+
+
+class TestUserProductUserID:
+    user_id = randint(1, 2**30)
+
+    def randomword(self, length: int = 50):
+        # Raw so nothing is escaped to add additional backslashes
+        _bpuid_allowed = r"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!#$%&()*+,-.:;<=>?@[]^_{|}~"
+        return "".join(rand_choice(_bpuid_allowed) for i in range(length))
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        product_user_id = uuid4().hex[:12]
+        user = User(user_id=self.user_id, product_user_id=product_user_id)
+
+        assert user.user_id == self.user_id
+        assert user.product_user_id == product_user_id
+
+    def test_type(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=0.0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=Decimal("0"))
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+    def test_empty(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id="")
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at least 3 characters" in str(cm.value)
+
+    def test_invalid_len(self):
+        from generalresearch.models.thl.user import User
+
+        product_user_id = self.randomword(251)
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at most 128 characters" in str(cm.value)
+
+        product_user_id = self.randomword(2)
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at least 3 characters" in str(cm.value)
+
+    def test_invalid_chars_space(self):
+        from generalresearch.models.thl.user import User
+
+        product_user_id = f"{self.randomword(50)} {self.randomword(50)}"
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String cannot contain spaces" in str(cm.value)
+
+    def test_invalid_chars_slash(self):
+        from generalresearch.models.thl.user import User
+
+        product_user_id = f"{self.randomword(50)}\{self.randomword(50)}"
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String cannot contain backslash" in str(cm.value)
+
+        product_user_id = f"{self.randomword(50)}/{self.randomword(50)}"
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String cannot contain slash" in str(cm.value)
+
+    def test_invalid_chars_backtick(self):
+        """Yes I could keep doing these specific character checks. However,
+        I wanted a test that made sure the regex was hit. I do not know
+        how we want to provide with the level of specific String checks
+        we do in here for specific error messages."""
+        from generalresearch.models.thl.user import User
+
+        product_user_id = f"{self.randomword(50)}`{self.randomword(50)}"
+        with pytest.raises(expected_exception=ValueError) as cm:
+            User(user_id=self.user_id, product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String is not valid regex" in str(cm.value)
+
+    def test_unique_from_product_id(self):
+        # We removed this filter b/c these users already exist. the manager checks for this
+        # though and we can't create new users like this
+        pass
+        # product_id = uuid4().hex
+        #
+        # with pytest.raises(ValueError) as cm:
+        #     User(product_id=product_id, product_user_id=product_id)
+        # assert "1 validation error for User", str(cm.exception))
+        # assert "product_user_id must not equal the product_id", str(cm.exception))
+
+    def test_identifiable(self):
+        """Can't create a User with only a product_user_id because it also
+        needs to the product_id"""
+        from generalresearch.models.thl.user import User
+
+        product_user_id = uuid4().hex
+        with pytest.raises(ValueError) as cm:
+            User(product_user_id=product_user_id)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Value error, User is not identifiable" in str(cm.value)
+
+
+class TestUserUUID:
+    user_id = randint(1, 2**30)
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        uuid_pk = uuid4().hex
+
+        user = User(user_id=self.user_id, uuid=uuid_pk)
+        assert user.user_id == self.user_id
+        assert user.uuid == uuid_pk
+
+    def test_type(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=0.0)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=Decimal("0"))
+        assert "1 validation error for User", str(cm.value)
+        assert "Input should be a valid string" in str(cm.value)
+
+    def test_empty(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid="")
+        assert "1 validation error for User", str(cm.value)
+        assert "String should have at least 32 characters", str(cm.value)
+
+    def test_invalid_len(self):
+        from generalresearch.models.thl.user import User
+
+        # Valid uuid4s are 32 char long
+        uuid_pk = uuid4().hex[:31]
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=uuid_pk)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at least 32 characters" in str(cm.value)
+
+        # Valid uuid4s are 32 char long
+        uuid_pk = uuid4().hex
+        uuid_pk *= 2
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=uuid_pk)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at most 32 characters" in str(cm.value)
+
+    def test_invalid_uuid(self):
+        from generalresearch.models.thl.user import User
+
+        # Modify the UUID to break it
+        uuid_pk = uuid4().hex[:31] + "x"
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=uuid_pk)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Invalid UUID" in str(cm.value)
+
+    def test_invalid_hex_form(self):
+        from generalresearch.models.thl.user import User
+
+        # Sure not in hex form, but it'll get caught for being the
+        # wrong length before anything else
+        uuid_pk = str(uuid4())  # '1a93447e-c77b-4cfa-b58e-ed4777d57110'
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=uuid_pk)
+        assert "1 validation error for User" in str(cm.value)
+        assert "String should have at most 32 characters" in str(cm.value)
+
+        uuid_pk = str(uuid4())[:32]  # '1a93447e-c77b-4cfa-b58e-ed4777d57110'
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, uuid=uuid_pk)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Invalid UUID" in str(cm.value)
+
+    def test_identifiable(self):
+        from generalresearch.models.thl.user import User
+
+        user_uuid = uuid4().hex
+        user = User(uuid=user_uuid)
+        assert user.is_identifiable
+
+
+class TestUserCreated:
+    user_id = randint(1, 2**30)
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        user = User(user_id=self.user_id)
+        dt = datetime.now(tz=timezone.utc)
+        user.created = dt
+
+        assert user.created == dt
+
+    def test_tz_naive_throws_init(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, created=datetime.now(tz=None))
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should have timezone info" in str(cm.value)
+
+    def test_tz_naive_throws_setter(self):
+        from generalresearch.models.thl.user import User
+
+        user = User(user_id=self.user_id)
+        with pytest.raises(ValueError) as cm:
+            user.created = datetime.now(tz=None)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should have timezone info" in str(cm.value)
+
+    def test_tz_utc(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(
+                user_id=self.user_id,
+                created=datetime.now(tz=timezone(-timedelta(hours=8))),
+            )
+        assert "1 validation error for User" in str(cm.value)
+        assert "Timezone is not UTC" in str(cm.value)
+
+    def test_not_in_future(self):
+        from generalresearch.models.thl.user import User
+
+        the_future = datetime.now(tz=timezone.utc) + timedelta(minutes=1)
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, created=the_future)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input is in the future" in str(cm.value)
+
+    def test_after_anno_domini(self):
+        from generalresearch.models.thl.user import User
+
+        before_ad = datetime(
+            year=2015, month=1, day=1, tzinfo=timezone.utc
+        ) + timedelta(minutes=1)
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, created=before_ad)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input is before Anno Domini" in str(cm.value)
+
+
+class TestUserLastSeen:
+    user_id = randint(1, 2**30)
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        user = User(user_id=self.user_id)
+        dt = datetime.now(tz=timezone.utc)
+        user.last_seen = dt
+
+        assert user.last_seen == dt
+
+    def test_tz_naive_throws_init(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, last_seen=datetime.now(tz=None))
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should have timezone info" in str(cm.value)
+
+    def test_tz_naive_throws_setter(self):
+        from generalresearch.models.thl.user import User
+
+        user = User(user_id=self.user_id)
+        with pytest.raises(ValueError) as cm:
+            user.last_seen = datetime.now(tz=None)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should have timezone info" in str(cm.value)
+
+    def test_tz_utc(self):
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(
+                user_id=self.user_id,
+                last_seen=datetime.now(tz=timezone(-timedelta(hours=8))),
+            )
+        assert "1 validation error for User" in str(cm.value)
+        assert "Timezone is not UTC" in str(cm.value)
+
+    def test_not_in_future(self):
+        from generalresearch.models.thl.user import User
+
+        the_future = datetime.now(tz=timezone.utc) + timedelta(minutes=1)
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, last_seen=the_future)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input is in the future" in str(cm.value)
+
+    def test_after_anno_domini(self):
+        from generalresearch.models.thl.user import User
+
+        before_ad = datetime(
+            year=2015, month=1, day=1, tzinfo=timezone.utc
+        ) + timedelta(minutes=1)
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, last_seen=before_ad)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input is before Anno Domini" in str(cm.value)
+
+
+class TestUserBlocked:
+    user_id = randint(1, 2**30)
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        user = User(user_id=self.user_id, blocked=True)
+        assert user.blocked
+
+    def test_str_casting(self):
+        """We don't want any of these to work, and that's why
+        we set strict=True on the column"""
+        from generalresearch.models.thl.user import User
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, blocked="true")
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid boolean" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, blocked="True")
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid boolean" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, blocked="1")
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid boolean" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, blocked="yes")
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid boolean" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, blocked="no")
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid boolean" in str(cm.value)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, blocked=uuid4().hex)
+        assert "1 validation error for User" in str(cm.value)
+        assert "Input should be a valid boolean" in str(cm.value)
+
+
+class TestUserTiming:
+    user_id = randint(1, 2**30)
+
+    def test_valid(self):
+        from generalresearch.models.thl.user import User
+
+        created = datetime.now(tz=timezone.utc) - timedelta(minutes=60)
+        last_seen = datetime.now(tz=timezone.utc) - timedelta(minutes=59)
+
+        user = User(user_id=self.user_id, created=created, last_seen=last_seen)
+        assert user.created == created
+        assert user.last_seen == last_seen
+
+    def test_created_first(self):
+        from generalresearch.models.thl.user import User
+
+        created = datetime.now(tz=timezone.utc) - timedelta(minutes=60)
+        last_seen = datetime.now(tz=timezone.utc) - timedelta(minutes=59)
+
+        with pytest.raises(ValueError) as cm:
+            User(user_id=self.user_id, created=last_seen, last_seen=created)
+        assert "1 validation error for User" in str(cm.value)
+        assert "User created time invalid" in str(cm.value)
+
+
+class TestUserModelVerification:
+    """Tests that may be dependent on more than 1 attribute"""
+
+    def test_identifiable(self):
+        from generalresearch.models.thl.user import User
+
+        product_id = uuid4().hex
+        product_user_id = uuid4().hex
+        user = User(product_id=product_id, product_user_id=product_user_id)
+        assert user.is_identifiable
+
+    def test_valid_helper(self):
+        from generalresearch.models.thl.user import User
+
+        user_bool = User.is_valid_ubp(
+            product_id=uuid4().hex, product_user_id=uuid4().hex
+        )
+        assert user_bool
+
+        user_bool = User.is_valid_ubp(product_id=uuid4().hex, product_user_id=" - - - ")
+        assert not user_bool
+
+
+class TestUserSerialization:
+
+    def test_basic_json(self):
+        from generalresearch.models.thl.user import User
+
+        product_id = uuid4().hex
+        product_user_id = uuid4().hex
+
+        user = User(
+            product_id=product_id,
+            product_user_id=product_user_id,
+            created=datetime.now(tz=timezone.utc),
+            blocked=False,
+        )
+
+        d = json.loads(user.to_json())
+        assert d.get("product_id") == product_id
+        assert d.get("product_user_id") == product_user_id
+        assert not d.get("blocked")
+
+        assert d.get("product") is None
+        assert d.get("created").endswith("Z")
+
+    def test_basic_dict(self):
+        from generalresearch.models.thl.user import User
+
+        product_id = uuid4().hex
+        product_user_id = uuid4().hex
+
+        user = User(
+            product_id=product_id,
+            product_user_id=product_user_id,
+            created=datetime.now(tz=timezone.utc),
+            blocked=False,
+        )
+
+        d = user.to_dict()
+        assert d.get("product_id") == product_id
+        assert d.get("product_user_id") == product_user_id
+        assert not d.get("blocked")
+
+        assert d.get("product") is None
+        assert d.get("created").tzinfo == timezone.utc
+
+    def test_from_json(self):
+        from generalresearch.models.thl.user import User
+
+        product_id = uuid4().hex
+        product_user_id = uuid4().hex
+
+        user = User(
+            product_id=product_id,
+            product_user_id=product_user_id,
+            created=datetime.now(tz=timezone.utc),
+            blocked=False,
+        )
+
+        u = User.model_validate_json(user.to_json())
+        assert u.product_id == product_id
+        assert u.product is None
+        assert u.created.tzinfo == timezone.utc
+
+
+class TestUserMethods:
+
+    def test_audit_log(self, user, audit_log_manager):
+        assert user.audit_log is None
+        user.prefetch_audit_log(audit_log_manager=audit_log_manager)
+        assert user.audit_log == []
+
+        audit_log_manager.create_dummy(user_id=user.user_id)
+        user.prefetch_audit_log(audit_log_manager=audit_log_manager)
+        assert len(user.audit_log) == 1
+
+    def test_transactions(
+        self, user_factory, thl_lm, session_with_tx_factory, product_user_wallet_yes
+    ):
+        u1 = user_factory(product=product_user_wallet_yes)
+
+        assert u1.transactions is None
+        u1.prefetch_transactions(thl_lm=thl_lm)
+        assert u1.transactions == []
+
+        session_with_tx_factory(user=u1)
+
+        u1.prefetch_transactions(thl_lm=thl_lm)
+        assert len(u1.transactions) == 1
+
+    @pytest.mark.skip(reason="TODO")
+    def test_location_history(self, user):
+        assert user.location_history is None
diff --git a/tests/models/thl/test_user_iphistory.py b/tests/models/thl/test_user_iphistory.py
new file mode 100644
index 0000000..46018e0
--- /dev/null
+++ b/tests/models/thl/test_user_iphistory.py
@@ -0,0 +1,45 @@
+from datetime import timezone, datetime, timedelta
+
+from generalresearch.models.thl.user_iphistory import (
+    UserIPHistory,
+    UserIPRecord,
+)
+
+
+def test_collapse_ip_records():
+    # This does not exist in a db, so we do not need fixtures/ real user ids, whatever
+    now = datetime.now(tz=timezone.utc) - timedelta(days=1)
+    # Gets stored most recent first. This is reversed, but the validator will order it
+    records = [
+        UserIPRecord(ip="1.2.3.5", created=now + timedelta(minutes=1)),
+        UserIPRecord(
+            ip="1e5c:de49:165a:6aa0:4f89:1433:9af7:aaaa",
+            created=now + timedelta(minutes=2),
+        ),
+        UserIPRecord(
+            ip="1e5c:de49:165a:6aa0:4f89:1433:9af7:bbbb",
+            created=now + timedelta(minutes=3),
+        ),
+        UserIPRecord(ip="1.2.3.5", created=now + timedelta(minutes=4)),
+        UserIPRecord(
+            ip="1e5c:de49:165a:6aa0:4f89:1433:9af7:cccc",
+            created=now + timedelta(minutes=5),
+        ),
+        UserIPRecord(
+            ip="6666:de49:165a:6aa0:4f89:1433:9af7:aaaa",
+            created=now + timedelta(minutes=6),
+        ),
+        UserIPRecord(ip="1.2.3.6", created=now + timedelta(minutes=7)),
+    ]
+    iph = UserIPHistory(user_id=1, ips=records)
+    res = iph.collapse_ip_records()
+
+    # We should be left with one of the 1.2.3.5 ipv4s,
+    #   and only the 1e5c::cccc and the 6666 ipv6 addresses
+    assert len(res) == 4
+    assert [x.ip for x in res] == [
+        "1.2.3.6",
+        "6666:de49:165a:6aa0:4f89:1433:9af7:aaaa",
+        "1e5c:de49:165a:6aa0:4f89:1433:9af7:cccc",
+        "1.2.3.5",
+    ]
diff --git a/tests/models/thl/test_user_metadata.py b/tests/models/thl/test_user_metadata.py
new file mode 100644
index 0000000..3d851dc
--- /dev/null
+++ b/tests/models/thl/test_user_metadata.py
@@ -0,0 +1,46 @@
+import pytest
+
+from generalresearch.models import MAX_INT32
+from generalresearch.models.thl.user_profile import UserMetadata
+
+
+class TestUserMetadata:
+
+    def test_default(self):
+        # You can initialize it with nothing
+        um = UserMetadata()
+        assert um.email_address is None
+        assert um.email_sha1 is None
+
+    def test_user_id(self):
+        # This does NOT validate that the user_id exists. When we attempt a db operation,
+        #   at that point it will fail b/c of the foreign key constraint.
+        UserMetadata(user_id=MAX_INT32 - 1)
+
+        with pytest.raises(expected_exception=ValueError) as cm:
+            UserMetadata(user_id=MAX_INT32)
+        assert "Input should be less than 2147483648" in str(cm.value)
+
+    def test_email(self):
+        um = UserMetadata(email_address="e58375d80f5f4a958138004aae44c7ca@example.com")
+        assert (
+            um.email_sha256
+            == "fd219d8b972b3d82e70dc83284027acc7b4a6de66c42261c1684e3f05b545bc0"
+        )
+        assert um.email_sha1 == "a82578f02b0eed28addeb81317417cf239ede1c3"
+        assert um.email_md5 == "9073a7a3c21cfd6160d1899fb736cd1c"
+
+        # You cannot set the hashes directly
+        with pytest.raises(expected_exception=AttributeError) as cm:
+            um.email_md5 = "x" * 32
+        # assert "can't set attribute 'email_md5'" in str(cm.value)
+        assert "property 'email_md5' of 'UserMetadata' object has no setter" in str(
+            cm.value
+        )
+
+        # assert it hasn't changed anything
+        assert um.email_md5 == "9073a7a3c21cfd6160d1899fb736cd1c"
+
+        # If you update the email, all the hashes change
+        um.email_address = "greg@example.com"
+        assert um.email_md5 != "9073a7a3c21cfd6160d1899fb736cd1c"
diff --git a/tests/models/thl/test_user_streak.py b/tests/models/thl/test_user_streak.py
new file mode 100644
index 0000000..72efd05
--- /dev/null
+++ b/tests/models/thl/test_user_streak.py
@@ -0,0 +1,96 @@
+from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
+
+import pytest
+from pydantic import ValidationError
+
+from generalresearch.models.thl.user_streak import (
+    UserStreak,
+    StreakPeriod,
+    StreakFulfillment,
+    StreakState,
+)
+
+
+def test_user_streak_empty_fail():
+    us = UserStreak(
+        period=StreakPeriod.DAY,
+        fulfillment=StreakFulfillment.COMPLETE,
+        country_iso="us",
+        user_id=1,
+        last_fulfilled_period_start=None,
+        current_streak=0,
+        longest_streak=0,
+        state=StreakState.BROKEN,
+    )
+    assert us.time_remaining_in_period is None
+
+    with pytest.raises(
+        ValidationError, match="StreakState.BROKEN but current_streak not 0"
+    ):
+        UserStreak(
+            period=StreakPeriod.DAY,
+            fulfillment=StreakFulfillment.COMPLETE,
+            country_iso="us",
+            user_id=1,
+            last_fulfilled_period_start=None,
+            current_streak=1,
+            longest_streak=0,
+            state=StreakState.BROKEN,
+        )
+
+    with pytest.raises(
+        ValidationError, match="Current streak can't be longer than longest streak"
+    ):
+        UserStreak(
+            period=StreakPeriod.DAY,
+            fulfillment=StreakFulfillment.COMPLETE,
+            country_iso="us",
+            user_id=1,
+            last_fulfilled_period_start=None,
+            current_streak=1,
+            longest_streak=0,
+            state=StreakState.ACTIVE,
+        )
+
+
+def test_user_streak_remaining():
+    us = UserStreak(
+        period=StreakPeriod.DAY,
+        fulfillment=StreakFulfillment.COMPLETE,
+        country_iso="us",
+        user_id=1,
+        last_fulfilled_period_start=None,
+        current_streak=1,
+        longest_streak=1,
+        state=StreakState.AT_RISK,
+    )
+    now = datetime.now(tz=ZoneInfo("America/New_York"))
+    end_of_today = now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(
+        days=1
+    )
+    print(f"{now.isoformat()=}, {end_of_today.isoformat()=}")
+    expected = (end_of_today - now).total_seconds()
+    assert us.time_remaining_in_period.total_seconds() == pytest.approx(expected, abs=1)
+
+
+def test_user_streak_remaining_month():
+    us = UserStreak(
+        period=StreakPeriod.MONTH,
+        fulfillment=StreakFulfillment.COMPLETE,
+        country_iso="us",
+        user_id=1,
+        last_fulfilled_period_start=None,
+        current_streak=1,
+        longest_streak=1,
+        state=StreakState.AT_RISK,
+    )
+    now = datetime.now(tz=ZoneInfo("America/New_York"))
+    end_of_month = (
+        now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+        + timedelta(days=32)
+    ).replace(day=1)
+    print(f"{now.isoformat()=}, {end_of_month.isoformat()=}")
+    expected = (end_of_month - now).total_seconds()
+    assert us.time_remaining_in_period.total_seconds() == pytest.approx(expected, abs=1)
+    print(us.time_remaining_in_period)
diff --git a/tests/models/thl/test_wall.py b/tests/models/thl/test_wall.py
new file mode 100644
index 0000000..057aad2
--- /dev/null
+++ b/tests/models/thl/test_wall.py
@@ -0,0 +1,207 @@
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+from uuid import uuid4
+
+import pytest
+from pydantic import ValidationError
+
+from generalresearch.models import Source
+from generalresearch.models.thl.definitions import (
+    Status,
+    StatusCode1,
+    WallStatusCode2,
+)
+from generalresearch.models.thl.session import Wall
+
+
+class TestWall:
+
+    def test_wall_json(self):
+        w = Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            ext_status_code_1="1.0",
+            status=Status.FAIL,
+            status_code_1=StatusCode1.BUYER_FAIL,
+            started=datetime(2023, 1, 1, 0, 0, 1, tzinfo=timezone.utc),
+            finished=datetime(2023, 1, 1, 0, 10, 1, tzinfo=timezone.utc),
+        )
+        s = w.to_json()
+        w2 = Wall.from_json(s)
+        assert w == w2
+
+    def test_status_status_code_agreement(self):
+        # should not raise anything
+        Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            status=Status.FAIL,
+            status_code_1=StatusCode1.BUYER_FAIL,
+            started=datetime.now(timezone.utc),
+            finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+        )
+        Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            status=Status.FAIL,
+            status_code_1=StatusCode1.MARKETPLACE_FAIL,
+            status_code_2=WallStatusCode2.COMPLETE_TOO_FAST,
+            started=datetime.now(timezone.utc),
+            finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+        )
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Wall(
+                user_id=1,
+                source=Source.DYNATA,
+                req_survey_id="xxx",
+                req_cpi=Decimal(1),
+                session_id=1,
+                survey_id="yyy",
+                status=Status.FAIL,
+                status_code_1=StatusCode1.GRS_ABANDON,
+                started=datetime.now(timezone.utc),
+                finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+            )
+        assert "If status is f, status_code_1 should be in" in str(e.value)
+
+        with pytest.raises(expected_exception=ValidationError) as cm:
+            Wall(
+                user_id=1,
+                source=Source.DYNATA,
+                req_survey_id="xxx",
+                req_cpi=Decimal(1),
+                session_id=1,
+                survey_id="yyy",
+                status=Status.FAIL,
+                status_code_1=StatusCode1.GRS_ABANDON,
+                status_code_2=WallStatusCode2.COMPLETE_TOO_FAST,
+                started=datetime.now(timezone.utc),
+                finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+            )
+        assert "If status is f, status_code_1 should be in" in str(e.value)
+
+    def test_status_code_1_2_agreement(self):
+        # should not raise anything
+        Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            status=Status.FAIL,
+            status_code_1=StatusCode1.MARKETPLACE_FAIL,
+            status_code_2=WallStatusCode2.COMPLETE_TOO_FAST,
+            started=datetime.now(timezone.utc),
+            finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+        )
+        Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            status=Status.FAIL,
+            status_code_1=StatusCode1.BUYER_FAIL,
+            status_code_2=None,
+            started=datetime.now(timezone.utc),
+            finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+        )
+        Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            status_code_2=None,
+            started=datetime.now(timezone.utc),
+            finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+        )
+
+        with pytest.raises(expected_exception=ValidationError) as e:
+            Wall(
+                user_id=1,
+                source=Source.DYNATA,
+                req_survey_id="xxx",
+                req_cpi=Decimal(1),
+                session_id=1,
+                survey_id="yyy",
+                status=Status.FAIL,
+                status_code_1=StatusCode1.BUYER_FAIL,
+                status_code_2=WallStatusCode2.COMPLETE_TOO_FAST,
+                started=datetime.now(timezone.utc),
+                finished=datetime.now(timezone.utc) + timedelta(seconds=1),
+            )
+            assert "If status_code_1 is 1, status_code_2 should be in" in str(e.value)
+
+    def test_annotate_status_code(self):
+        w = Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+        )
+        w.annotate_status_codes("1.0")
+        assert Status.COMPLETE == w.status
+        assert StatusCode1.COMPLETE == w.status_code_1
+        assert w.status_code_2 is None
+        assert "1.0" == w.ext_status_code_1
+        assert w.ext_status_code_2 is None
+
+    def test_buyer_too_long(self):
+        buyer_id = uuid4().hex
+        w = Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            buyer_id=buyer_id,
+        )
+        assert buyer_id == w.buyer_id
+
+        w = Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            buyer_id=None,
+        )
+        assert w.buyer_id is None
+
+        w = Wall(
+            user_id=1,
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            survey_id="yyy",
+            buyer_id=buyer_id + "abc123",
+        )
+        assert buyer_id == w.buyer_id
+
+    @pytest.mark.skip(reason="TODO")
+    def test_more_stuff(self):
+        # todo: .update, test status logic
+        pass
diff --git a/tests/models/thl/test_wall_session.py b/tests/models/thl/test_wall_session.py
new file mode 100644
index 0000000..ab140e9
--- /dev/null
+++ b/tests/models/thl/test_wall_session.py
@@ -0,0 +1,326 @@
+from datetime import datetime, timezone, timedelta
+from decimal import Decimal
+
+import pytest
+
+from generalresearch.models import Source
+from generalresearch.models.thl.definitions import Status, StatusCode1
+from generalresearch.models.thl.session import Session, Wall
+from generalresearch.models.thl.user import User
+
+
+class TestWallSession:
+
+    def test_session_with_no_wall_events(self):
+        started = datetime(2023, 1, 1, tzinfo=timezone.utc)
+        s = Session(user=User(user_id=1), started=started)
+        assert s.status is None
+        assert s.status_code_1 is None
+
+        # todo: this needs to be set explicitly, not this way
+        # # If I have no wall events, it's a fail
+        # s.determine_session_status()
+        # assert s.status == Status.FAIL
+        # assert s.status_code_1 == StatusCode1.SESSION_START_FAIL
+
+    def test_session_timeout_with_only_grs(self):
+        started = datetime(2023, 1, 1, tzinfo=timezone.utc)
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            user_id=1,
+            source=Source.GRS,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+        )
+        s.append_wall_event(w)
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+        assert Status.TIMEOUT == s.status
+        assert StatusCode1.GRS_ABANDON == s.status_code_1
+
+    def test_session_with_only_grs_fail(self):
+        # todo: this needs to be set explicitly, not this way
+        pass
+        # started = datetime(2023, 1, 1, tzinfo=timezone.utc)
+        # s = Session(user=User(user_id=1), started=started)
+        # w = Wall(user_id=1, source=Source.GRS, req_survey_id='xxx',
+        #          req_cpi=Decimal(1), session_id=1)
+        # s.append_wall_event(w)
+        # w.finish(status=Status.FAIL, status_code_1=StatusCode1.PS_FAIL)
+        # s.determine_session_status()
+        # assert s.status == Status.FAIL
+        # assert s.status_code_1 == StatusCode1.GRS_FAIL
+
+    def test_session_with_only_grs_complete(self):
+        started = datetime(year=2023, month=1, day=1, tzinfo=timezone.utc)
+
+        # A Session is started
+        s = Session(user=User(user_id=1), started=started)
+
+        # The User goes into a GRS survey, and completes it
+        # @gstupp - should a GRS be allowed with a req_cpi > 0?
+        w = Wall(
+            user_id=1,
+            source=Source.GRS,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+        )
+        s.append_wall_event(w)
+        w.finish(status=Status.COMPLETE, status_code_1=StatusCode1.COMPLETE)
+
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+
+        assert s.status == Status.FAIL
+
+        # @gstupp changed this behavior on 11/2023 (51471b6ae671f21212a8b1fad60b508181cbb8ca)
+        #   I don't know which is preferred or the consequences of each. However,
+        #   now it's a SESSION_CONTINUE_FAIL instead of a SESSION_START_FAIL so
+        #   change this so the test passes
+        # self.assertEqual(s.status_code_1, StatusCode1.SESSION_START_FAIL)
+        assert s.status_code_1 == StatusCode1.SESSION_CONTINUE_FAIL
+
+    @pytest.mark.skip(reason="TODO")
+    def test_session_with_only_non_grs_complete(self):
+        # todo: this needs to be set explicitly, not this way
+        pass
+        # # This fails... until payout stuff is done
+        # started = datetime(2023, 1, 1, tzinfo=timezone.utc)
+        # s = Session(user=User(user_id=1), started=started)
+        # w = Wall(source=Source.DYNATA, req_survey_id='xxx', req_cpi=Decimal('1.00001'),
+        #          session_id=1, user_id=1)
+        # s.append_wall_event(w)
+        # w.finish(status=Status.COMPLETE, status_code_1=StatusCode1.COMPLETE)
+        # s.determine_session_status()
+        # assert s.status == Status.COMPLETE
+        # assert s.status_code_1 is None
+
+    def test_session_with_only_non_grs_fail(self):
+        started = datetime(year=2023, month=1, day=1, tzinfo=timezone.utc)
+
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal("1.00001"),
+            session_id=1,
+            user_id=1,
+        )
+
+        s.append_wall_event(w)
+        w.finish(status=Status.FAIL, status_code_1=StatusCode1.BUYER_FAIL)
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+
+        assert s.status == Status.FAIL
+        assert s.status_code_1 == StatusCode1.BUYER_FAIL
+        assert s.payout is None
+
+    def test_session_with_only_non_grs_timeout(self):
+        started = datetime(year=2023, month=1, day=1, tzinfo=timezone.utc)
+
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal("1.00001"),
+            session_id=1,
+            user_id=1,
+        )
+
+        s.append_wall_event(w)
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+
+        assert s.status == Status.TIMEOUT
+        assert s.status_code_1 == StatusCode1.BUYER_ABANDON
+        assert s.payout is None
+
+    def test_session_with_grs_and_external(self):
+        started = datetime(year=2023, month=1, day=1, tzinfo=timezone.utc)
+
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            source=Source.GRS,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            user_id=1,
+            started=started,
+        )
+
+        s.append_wall_event(w)
+        w.finish(
+            status=Status.COMPLETE,
+            status_code_1=StatusCode1.COMPLETE,
+            finished=started + timedelta(minutes=10),
+        )
+
+        w = Wall(
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal("1.00001"),
+            session_id=1,
+            user_id=1,
+        )
+        s.append_wall_event(w)
+        w.finish(
+            status=Status.ABANDON,
+            finished=datetime.now(tz=timezone.utc) + timedelta(minutes=10),
+            status_code_1=StatusCode1.BUYER_ABANDON,
+        )
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+
+        assert s.status == Status.ABANDON
+        assert s.status_code_1 == StatusCode1.BUYER_ABANDON
+        assert s.payout is None
+
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            source=Source.GRS,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            user_id=1,
+        )
+        s.append_wall_event(w)
+        w.finish(status=Status.COMPLETE, status_code_1=StatusCode1.COMPLETE)
+        w = Wall(
+            source=Source.DYNATA,
+            req_survey_id="xxx",
+            req_cpi=Decimal("1.00001"),
+            session_id=1,
+            user_id=1,
+        )
+        s.append_wall_event(w)
+        w.finish(status=Status.FAIL, status_code_1=StatusCode1.PS_DUPLICATE)
+
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+
+        assert s.status == Status.FAIL
+        assert s.status_code_1 == StatusCode1.PS_DUPLICATE
+        assert s.payout is None
+
+    def test_session_marketplace_fail(self):
+        started = datetime(2023, 1, 1, tzinfo=timezone.utc)
+
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            source=Source.CINT,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            user_id=1,
+            started=started,
+        )
+        s.append_wall_event(w)
+        w.finish(
+            status=Status.FAIL,
+            status_code_1=StatusCode1.MARKETPLACE_FAIL,
+            finished=started + timedelta(minutes=10),
+        )
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+        assert Status.FAIL == s.status
+        assert StatusCode1.SESSION_CONTINUE_QUALITY_FAIL == s.status_code_1
+
+    def test_session_unknown(self):
+        started = datetime(2023, 1, 1, tzinfo=timezone.utc)
+
+        s = Session(user=User(user_id=1), started=started)
+        w = Wall(
+            source=Source.CINT,
+            req_survey_id="xxx",
+            req_cpi=Decimal(1),
+            session_id=1,
+            user_id=1,
+            started=started,
+        )
+        s.append_wall_event(w)
+        w.finish(
+            status=Status.FAIL,
+            status_code_1=StatusCode1.UNKNOWN,
+            finished=started + timedelta(minutes=10),
+        )
+        status, status_code_1 = s.determine_session_status()
+        s.update(status=status, status_code_1=status_code_1)
+        assert Status.FAIL == s.status
+        assert StatusCode1.BUYER_FAIL == s.status_code_1
+
+
+# class TestWallSessionPayout:
+#     product_id = uuid4().hex
+#
+#     def test_session_payout_with_only_non_grs_complete(self):
+#         sql_helper = self.make_sql_helper()
+#         user = User(user_id=1, product_id=self.product_id)
+#         s = Session(user=user, started=datetime(2023, 1, 1, tzinfo=timezone.utc))
+#         w = Wall(source=Source.DYNATA, req_survey_id='xxx', req_cpi=Decimal('1.00001'))
+#         s.append_wall_event(w)
+#         w.handle_callback(status=Status.COMPLETE)
+#         s.determine_session_status()
+#         s.determine_payout(sql_helper=sql_helper)
+#         assert s.status == Status.COMPLETE
+#         assert s.status_code_1 is None
+#         # we're assuming here the commission on this BP is 8.5% and doesn't get changed by someone!
+#         assert s.payout == Decimal('0.88')
+#
+#     def test_session_payout(self):
+#         sql_helper = self.make_sql_helper()
+#         user = User(user_id=1, product_id=self.product_id)
+#         s = Session(user=user, started=datetime(2023, 1, 1, tzinfo=timezone.utc))
+#         w = Wall(source=Source.GRS, req_survey_id='xxx', req_cpi=1)
+#         s.append_wall_event(w)
+#         w.handle_callback(status=Status.COMPLETE)
+#         w = Wall(source=Source.DYNATA, req_survey_id='xxx', req_cpi=Decimal('1.00001'))
+#         s.append_wall_event(w)
+#         w.handle_callback(status=Status.COMPLETE)
+#         s.determine_session_status()
+#         s.determine_payout(commission_pct=Decimal('0.05'))
+#         assert s.status == Status.COMPLETE
+#         assert s.status_code_1 is None
+#         assert s.payout == Decimal('0.93')
+
+
+# def test_get_from_uuid_vendor_wall(self):
+#     sql_helper = self.make_sql_helper()
+#     sql_helper.get_or_create("auth_user", "id", {"id": 1}, {
+#         "id": 1, "password": "1",
+#         "last_login": None, "is_superuser": 0,
+#         "username": "a", "first_name": "a",
+#         "last_name": "a", "email": "a",
+#         "is_staff": 0, "is_active": 1,
+#         "date_joined": "2023-10-13 14:03:20.000000"})
+#     sql_helper.get_or_create("vendor_wallsession", "id", {"id": 324}, {"id": 324})
+#     sql_helper.create("vendor_wall", {
+#         "id": "7b3e380babc840b79abf0030d408bbd9",
+#         "status": "c",
+#         "started": "2023-10-10 00:51:13.415444",
+#         "finished": "2023-10-10 01:08:00.676947",
+#         "req_loi": 1200,
+#         "req_cpi": 0.63,
+#         "req_survey_id": "8070750",
+#         "survey_id": "8070750",
+#         "cpi": 0.63,
+#         "user_id": 1,
+#         "report_notes": None,
+#         "report_status": None,
+#         "status_code": "1",
+#         "req_survey_hashed_opp": None,
+#         "session_id": 324,
+#         "source": "i",
+#         "ubp_id": None
+#     })
+#     Wall
+#     w = Wall.get_from_uuid_vendor_wall('7b3e380babc840b79abf0030d408bbd9', sql_helper=sql_helper,
+#                                        session_id=1)
+#     assert w.status == Status.COMPLETE
+#     assert w.source == Source.INNOVATE
+#     assert w.uuid == '7b3e380babc840b79abf0030d408bbd9'
+#     assert w.cpi == Decimal('0.63')
+#     assert w.survey_id == '8070750'
+#     assert w.user_id == 1