383 lines
13 KiB
Python
383 lines
13 KiB
Python
# tests/repositories/test_member.py
|
||
import datetime as dt
|
||
from typing import List
|
||
|
||
import pytest
|
||
|
||
from backend.models import Member as MemberModel, ScheduleStatus
|
||
from backend.repositories import MemberRepository
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# Helper: a few sample members we can reuse across tests
|
||
# ----------------------------------------------------------------------
|
||
@pytest.fixture
|
||
def sample_members() -> List[MemberModel]:
|
||
"""Return a list of MemberModel objects (not yet persisted)."""
|
||
return [
|
||
MemberModel(
|
||
MemberId=-1,
|
||
FirstName="Alice",
|
||
LastName="Anderson",
|
||
Email="alice@example.com",
|
||
PhoneNumber="555‑1111",
|
||
ClassificationId=1,
|
||
Notes=None,
|
||
IsActive=1,
|
||
LastScheduledAt=None,
|
||
LastAcceptedAt=None,
|
||
LastDeclinedAt=None,
|
||
DeclineStreak=0,
|
||
),
|
||
MemberModel(
|
||
MemberId=-1,
|
||
FirstName="Bob",
|
||
LastName="Baker",
|
||
Email="bob@example.com",
|
||
PhoneNumber="555‑2222",
|
||
ClassificationId=2,
|
||
Notes="VIP",
|
||
IsActive=1,
|
||
LastScheduledAt=dt.datetime(2025, 8, 20, 10, 0, 0),
|
||
LastAcceptedAt=dt.datetime(2025, 8, 19, 9, 30, 0),
|
||
LastDeclinedAt=None,
|
||
DeclineStreak=0,
|
||
),
|
||
MemberModel(
|
||
MemberId=-1,
|
||
FirstName="Carol",
|
||
LastName="Carter",
|
||
Email=None,
|
||
PhoneNumber=None,
|
||
ClassificationId=1,
|
||
Notes=None,
|
||
IsActive=0, # inactive – useful for filter tests
|
||
LastScheduledAt=None,
|
||
LastAcceptedAt=None,
|
||
LastDeclinedAt=None,
|
||
DeclineStreak=0,
|
||
),
|
||
]
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# Fixture to wipe the Members table (used by tests that need a clean slate)
|
||
# ----------------------------------------------------------------------
|
||
@pytest.fixture
|
||
def clean_members(member_repo: MemberRepository):
|
||
"""
|
||
Delete *all* rows from the Members table **and** any rows that
|
||
reference it (ServiceAvailability). The service‑availability tests
|
||
rely on the seeded Alice/Bob rows, so we only invoke this fixture
|
||
in the member‑repo tests that need isolation.
|
||
"""
|
||
# 1️⃣ Remove dependent rows first – otherwise the FK constraint blocks us.
|
||
member_repo.db.execute(
|
||
f"DELETE FROM ServiceAvailability"
|
||
) # commit happens inside `execute`
|
||
|
||
# 2️⃣ Now we can safely delete the members themselves.
|
||
member_repo.db.execute(
|
||
f"DELETE FROM {member_repo._TABLE}"
|
||
)
|
||
member_repo.db._conn.commit()
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# Helper to build a MemberModel with explicit timestamps.
|
||
# ----------------------------------------------------------------------
|
||
def make_member(
|
||
repo: MemberRepository,
|
||
first_name: str,
|
||
last_name: str,
|
||
*,
|
||
classification_id: int = 1,
|
||
is_active: int = 1,
|
||
accepted_at: str | None = None,
|
||
scheduled_at: str | None = None,
|
||
declined_at: str | None = None,
|
||
decline_streak: int = 0,
|
||
) -> MemberModel:
|
||
"""Insert a member and then manually set the optional timestamp columns."""
|
||
m = repo.create(
|
||
first_name=first_name,
|
||
last_name=last_name,
|
||
email=None,
|
||
phone_number=None,
|
||
classification_id=classification_id,
|
||
notes=None,
|
||
is_active=is_active,
|
||
)
|
||
# Directly update the row so we can control the timestamps without
|
||
# invoking the repository’s higher‑level helpers (which would reset
|
||
# other fields).
|
||
sql = f"""
|
||
UPDATE {repo._TABLE}
|
||
SET
|
||
LastAcceptedAt = ?,
|
||
LastScheduledAt = ?,
|
||
LastDeclinedAt = ?,
|
||
DeclineStreak = ?
|
||
WHERE {repo._PK} = ?
|
||
"""
|
||
repo.db.execute(
|
||
sql,
|
||
(
|
||
accepted_at,
|
||
scheduled_at,
|
||
declined_at,
|
||
decline_streak,
|
||
m.MemberId,
|
||
),
|
||
)
|
||
# Refresh the model from the DB so the attributes reflect the changes.
|
||
return repo.get_by_id(m.MemberId) # type: ignore[return-value]
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# 1️⃣ Basic CRUD – create & get_by_id
|
||
# ----------------------------------------------------------------------
|
||
def test_create_and_get_by_id(member_repo: MemberRepository):
|
||
member = member_repo.create(
|
||
first_name="Diana",
|
||
last_name="Doe",
|
||
email="diana@example.com",
|
||
phone_number="555‑3333",
|
||
classification_id=3,
|
||
notes="New recruit",
|
||
is_active=1,
|
||
)
|
||
|
||
# Primary key should be a positive integer (AUTOINCREMENT starts at 1)
|
||
assert isinstance(member.MemberId, int) and member.MemberId > 0
|
||
|
||
# Retrieve the same row
|
||
fetched = member_repo.get_by_id(member.MemberId)
|
||
assert fetched is not None
|
||
assert fetched.FirstName == "Diana"
|
||
assert fetched.LastName == "Doe"
|
||
assert fetched.Email == "diana@example.com"
|
||
assert fetched.ClassificationId == 3
|
||
assert fetched.IsActive == 1
|
||
assert fetched.Notes == "New recruit"
|
||
|
||
|
||
def test_get_by_id_returns_none_when_missing(member_repo: MemberRepository):
|
||
"""A PK that does not exist must return ``None`` (no exception)."""
|
||
assert member_repo.get_by_id(9999) is None
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# 2️⃣ list_all – bulk insertion + retrieval
|
||
# ----------------------------------------------------------------------
|
||
def test_list_all(
|
||
member_repo: MemberRepository,
|
||
sample_members: List[MemberModel],
|
||
clean_members, # ensure we start from an empty table
|
||
):
|
||
for m in sample_members:
|
||
member_repo.create(
|
||
first_name=m.FirstName,
|
||
last_name=m.LastName,
|
||
email=m.Email,
|
||
phone_number=m.PhoneNumber,
|
||
classification_id=m.ClassificationId,
|
||
notes=m.Notes,
|
||
is_active=m.IsActive,
|
||
)
|
||
|
||
all_members = member_repo.list_all()
|
||
# Because we cleared the table first, we expect exactly the three we added.
|
||
assert len(all_members) == 3
|
||
|
||
# Spot‑check that each name appears
|
||
names = {(m.FirstName, m.LastName) for m in all_members}
|
||
assert ("Alice", "Anderson") in names
|
||
assert ("Bob", "Baker") in names
|
||
assert ("Carol", "Carter") in names
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# 3️⃣ get_by_classification_ids – filter by classification list
|
||
# ----------------------------------------------------------------------
|
||
def test_get_by_classification_ids(
|
||
member_repo: MemberRepository,
|
||
sample_members: List[MemberModel],
|
||
clean_members,
|
||
):
|
||
for m in sample_members:
|
||
member_repo.create(
|
||
first_name=m.FirstName,
|
||
last_name=m.LastName,
|
||
email=m.Email,
|
||
phone_number=m.PhoneNumber,
|
||
classification_id=m.ClassificationId,
|
||
notes=m.Notes,
|
||
is_active=m.IsActive,
|
||
)
|
||
|
||
# Classification 1 → Alice + Carol (2 rows)
|
||
result = member_repo.get_by_classification_ids([1])
|
||
assert len(result) == 2
|
||
assert {r.FirstName for r in result} == {"Alice", "Carol"}
|
||
|
||
# Classification 2 → only Bob
|
||
result = member_repo.get_by_classification_ids([2])
|
||
assert len(result) == 1
|
||
assert result[0].FirstName == "Bob"
|
||
|
||
# Both classifications → all three
|
||
result = member_repo.get_by_classification_ids([1, 2])
|
||
assert len(result) == 3
|
||
|
||
|
||
def test_candidate_queue_obeys_boost_and_timestamp_sorting(
|
||
member_repo: MemberRepository,
|
||
):
|
||
"""
|
||
Verify that ``candidate_queue`` respects:
|
||
|
||
1️⃣ The boost clause (low ``DeclineStreak`` + recent ``LastDeclinedAt``).
|
||
2️⃣ ``LastAcceptedAt`` ASC (oldest first, ``NULL`` → far‑past).
|
||
3️⃣ ``LastScheduledAt`` ASC (same handling).
|
||
|
||
The default boost window is 2 days (172 800 seconds).
|
||
|
||
Additional rule (as stated in the doc‑string):
|
||
*Members whose ``LastAcceptedAt`` is NULL should appear **before** members
|
||
that have a non‑NULL acceptance date.*
|
||
"""
|
||
# --------------------------------------------------------------
|
||
# 0️⃣ Remove any ServiceAvailability rows that reference the seeded
|
||
# members, then delete the seeded members themselves.
|
||
# --------------------------------------------------------------
|
||
member_repo.db.execute("DELETE FROM ServiceAvailability")
|
||
member_repo.db.execute(
|
||
f"DELETE FROM {member_repo._TABLE} WHERE MemberId IN (1, 2)"
|
||
)
|
||
member_repo.db._conn.commit()
|
||
|
||
# --------------------------------------------------------------
|
||
# 1️⃣ Build a diverse set of members.
|
||
# --------------------------------------------------------------
|
||
# ── A – active, no timestamps (baseline, NULL acceptance)
|
||
a = make_member(member_repo, "Alice", "Anderson")
|
||
|
||
# ── B – active, accepted yesterday (non‑NULL acceptance)
|
||
yesterday = (dt.datetime.utcnow() - dt.timedelta(days=1)).strftime(
|
||
"%Y-%m-%d %H:%M:%S"
|
||
)
|
||
b = make_member(
|
||
member_repo,
|
||
"Bob",
|
||
"Baker",
|
||
accepted_at=yesterday,
|
||
)
|
||
|
||
# ── C – active, declined **today** with a low streak (boost candidate)
|
||
today_iso = dt.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
|
||
c = make_member(
|
||
member_repo,
|
||
"Carol",
|
||
"Clark",
|
||
declined_at=today_iso,
|
||
decline_streak=1, # < 2 → qualifies for boost
|
||
)
|
||
|
||
# ── D – active, declined **3 days ago** (outside the 2‑day boost window,
|
||
# still NULL acceptance)
|
||
three_days_ago = (dt.datetime.utcnow() - dt.timedelta(days=3)).strftime(
|
||
"%Y-%m-%d %H:%M:%S"
|
||
)
|
||
d = make_member(
|
||
member_repo,
|
||
"Dave",
|
||
"Davis",
|
||
declined_at=three_days_ago,
|
||
decline_streak=1,
|
||
)
|
||
|
||
# ── E – **inactive** member – should never appear when only_active=True.
|
||
e = make_member(
|
||
member_repo,
|
||
"Eve",
|
||
"Evans",
|
||
is_active=0,
|
||
)
|
||
|
||
# --------------------------------------------------------------
|
||
# 2️⃣ Pull the queue (default: only_active=True, boost_seconds=2 days)
|
||
# --------------------------------------------------------------
|
||
q = member_repo.candidate_queue(classification_ids=[1])
|
||
|
||
# --------------------------------------------------------------
|
||
# 3️⃣ Expected order (explain each step):
|
||
# --------------------------------------------------------------
|
||
# • Boosted members first → Carol (recent decline, streak < 2)
|
||
# • Then all members whose ``LastAcceptedAt`` is NULL,
|
||
# ordered by ``LastScheduledAt`` (both are NULL, so fallback to PK order):
|
||
# → Alice, then Dave
|
||
# • Finally members with a non‑NULL acceptance date → Bob
|
||
# • Eve is inactive → omitted.
|
||
expected_first_names = ["Carol", "Alice", "Dave", "Bob"]
|
||
assert [m.FirstName for m in q] == expected_first_names
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# 5️⃣ touch_last_scheduled – updates the timestamp column
|
||
# ----------------------------------------------------------------------
|
||
def test_touch_last_scheduled_updates_timestamp(member_repo: MemberRepository):
|
||
member = member_repo.create(
|
||
first_name="Eve",
|
||
last_name="Evans",
|
||
email=None,
|
||
phone_number=None,
|
||
classification_id=4,
|
||
notes=None,
|
||
is_active=1,
|
||
)
|
||
assert member.LastScheduledAt is None
|
||
|
||
# Call the helper – it should set LastScheduledAt to the current UTC time.
|
||
member_repo.touch_last_scheduled(member.MemberId)
|
||
|
||
refreshed = member_repo.get_by_id(member.MemberId)
|
||
assert refreshed is not None
|
||
assert refreshed.LastScheduledAt is not None
|
||
|
||
# SQLite stores timestamps as ISO‑8601 strings; parsing should succeed.
|
||
dt.datetime.fromisoformat(refreshed.LastScheduledAt)
|
||
|
||
|
||
# ----------------------------------------------------------------------
|
||
# 6️⃣ set_last_declined – records decline date and increments streak
|
||
# ----------------------------------------------------------------------
|
||
def test_set_last_declined_resets_streak_and_records_date(member_repo: MemberRepository):
|
||
member = member_repo.create(
|
||
first_name="Frank",
|
||
last_name="Foster",
|
||
email=None,
|
||
phone_number=None,
|
||
classification_id=4,
|
||
notes=None,
|
||
is_active=1,
|
||
)
|
||
# Initial state
|
||
assert member.DeclineStreak == 0
|
||
assert member.LastDeclinedAt is None
|
||
|
||
# Simulate a decline today.
|
||
today_iso = dt.date.today().isoformat()
|
||
member_repo.set_last_declined(member.MemberId, today_iso)
|
||
|
||
refreshed = member_repo.get_by_id(member.MemberId)
|
||
assert refreshed.DeclineStreak == 1
|
||
assert refreshed.LastDeclinedAt == today_iso
|
||
|
||
# Simulate a second decline tomorrow – streak should increase again.
|
||
tomorrow_iso = (dt.date.today() + dt.timedelta(days=1)).isoformat()
|
||
member_repo.set_last_declined(member.MemberId, tomorrow_iso)
|
||
|
||
refreshed2 = member_repo.get_by_id(member.MemberId)
|
||
assert refreshed2.DeclineStreak == 2
|
||
assert refreshed2.LastDeclinedAt == tomorrow_iso |