feat: swap improvements
This commit is contained in:
1 parent
c3d4a325a0
commit
0dac4b24bc
15 files changed
+1484
-139
No files matched your search
@@ -10,6 +10,7 @@ from sqlalchemy.pool import StaticPool
|
||||
from app.database import Base, get_db
|
||||
from app.main import app
|
||||
from app.models import Assignment, MonthlyPattern, NotificationLog, RotationMember, Schedule, SwapRequest, User
|
||||
from app.i18n import day_long, day_short
|
||||
from app.scheduling import ensure_month_assignments
|
||||
from app.security import hash_password
|
||||
|
||||
@@ -632,19 +633,53 @@ def test_new_generation_controls_require_admin_and_csrf(client, db, action):
|
||||
assert client.post(url, data={**data, "csrf_token": token}).status_code == 403
|
||||
|
||||
|
||||
def _open_request(db, schedule: Schedule, owner: User, target: User | None = None) -> SwapRequest:
|
||||
ensure_month_assignments(db, YEAR, MONTH)
|
||||
assignment = db.scalar(
|
||||
select(Assignment).where(
|
||||
def upcoming_of(db, schedule: Schedule, exclude: int | None = None) -> int:
|
||||
row = db.scalar(
|
||||
select(Assignment)
|
||||
.where(
|
||||
Assignment.schedule_id == schedule.id,
|
||||
Assignment.date > date.today(),
|
||||
).order_by(Assignment.date)
|
||||
Assignment.id != exclude if exclude else Assignment.id.is_not(None),
|
||||
)
|
||||
.order_by(Assignment.date)
|
||||
)
|
||||
assert row is not None
|
||||
return row.id
|
||||
|
||||
|
||||
def _open_request(
|
||||
db,
|
||||
schedule: Schedule,
|
||||
owner: User,
|
||||
target: User | None = None,
|
||||
*,
|
||||
two_sided: bool = True,
|
||||
) -> SwapRequest:
|
||||
"""An open request: `owner` gives a shift and, by default, gets another one back."""
|
||||
ensure_month_assignments(db, YEAR, MONTH)
|
||||
upcoming = list(
|
||||
db.scalars(
|
||||
select(Assignment)
|
||||
.where(Assignment.schedule_id == schedule.id, Assignment.date > date.today())
|
||||
.order_by(Assignment.date)
|
||||
).all()
|
||||
)
|
||||
assignment = upcoming[0]
|
||||
assignment.user_id = owner.id
|
||||
incoming = None
|
||||
partner = target
|
||||
if two_sided:
|
||||
for row in upcoming[1:]:
|
||||
if row.user_id is not None and (partner is None or row.user_id == partner.id):
|
||||
incoming = row
|
||||
break
|
||||
if incoming is not None and partner is None:
|
||||
partner = db.get(User, incoming.user_id)
|
||||
swap = SwapRequest(
|
||||
assignment_id=assignment.id,
|
||||
target_assignment_id=incoming.id if incoming is not None else None,
|
||||
requester_id=owner.id,
|
||||
target_user_id=target.id if target else None,
|
||||
target_user_id=partner.id if partner else None,
|
||||
status="open",
|
||||
)
|
||||
db.add(swap)
|
||||
@@ -657,6 +692,9 @@ def test_admin_completes_a_change_request_on_the_schedule_page(client, db):
|
||||
token = sign_in(client)
|
||||
rota_only = User(name="Rota Only", is_active=True, notify_email=True, email="rota@example.com")
|
||||
db.add(rota_only)
|
||||
db.flush()
|
||||
# Rota-only people work the schedule without signing in, so they are part of it.
|
||||
db.add(RotationMember(schedule_id=sat.id, user_id=rota_only.id, position=2))
|
||||
db.commit()
|
||||
swap = _open_request(db, sat, ana)
|
||||
|
||||
@@ -744,3 +782,651 @@ def test_admin_assignment_rejects_bad_input_and_protects_the_route(client, db):
|
||||
client.post("/login", data={"username": "member", "password": "member-password", "csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/").text).group(1)
|
||||
assert client.post(url, data={"csrf_token": token, "user_id": bruno.id}).status_code == 403
|
||||
|
||||
|
||||
def test_admin_can_open_a_change_request_for_someone_else(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
row = assignment_on(db, sat, date(YEAR, MONTH, 17))
|
||||
row.user_id = ana.id
|
||||
incoming = assignment_on(db, sat, date(YEAR, MONTH, 24))
|
||||
incoming.user_id = bruno.id
|
||||
db.commit()
|
||||
|
||||
rota = client.get(f"/?year={YEAR}&month={MONTH}").text
|
||||
assert 'href="/swaps/new?year=2026&month=10"' in rota # the rota only links to the form
|
||||
page = client.get(f"/swaps/new?year={YEAR}&month={MONTH}").text
|
||||
assert f'<option value="{row.id}">' in page
|
||||
assert f'<option value="{incoming.id}">' in page
|
||||
|
||||
created_response = client.post(
|
||||
"/swaps/new",
|
||||
data={
|
||||
"csrf_token": CSRF_RE.search(page).group(1),
|
||||
"assignment_id": row.id,
|
||||
"target_assignment_id": incoming.id,
|
||||
"message": "Ana não pode",
|
||||
},
|
||||
follow_redirects=True,
|
||||
)
|
||||
|
||||
created = db.scalar(select(SwapRequest).where(SwapRequest.assignment_id == row.id))
|
||||
assert created is not None, (created_response.status_code, created_response.text[-500:])
|
||||
assert created.requester_id == ana.id # the shift keeps its owner as the requester
|
||||
assert created.target_user_id == bruno.id # and the other one names its own owner
|
||||
assert created.target_assignment_id == incoming.id
|
||||
assert created.status == "open"
|
||||
notified = db.scalars(
|
||||
select(NotificationLog).where(NotificationLog.event_type == "swap_requested")
|
||||
).all()
|
||||
assert [log.user_id for log in notified] == [bruno.id]
|
||||
assert "Ana não pode" in notified[0].body
|
||||
|
||||
|
||||
def test_admin_cannot_open_a_request_for_an_unassigned_or_past_shift(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
row = assignment_on(db, sat, date(YEAR, MONTH, 17))
|
||||
row.user_id = None
|
||||
db.commit()
|
||||
page = client.get(f"/?year={YEAR}&month={MONTH}").text
|
||||
assert f'<option value="{row.id}">' not in page
|
||||
|
||||
response = client.post(
|
||||
"/swaps/new",
|
||||
data={
|
||||
"csrf_token": CSRF_RE.search(page).group(1),
|
||||
"assignment_id": row.id,
|
||||
"target_assignment_id": bruno.id,
|
||||
},
|
||||
)
|
||||
assert response.status_code == 403
|
||||
assert db.scalars(select(SwapRequest).where(SwapRequest.assignment_id == row.id)).all() == []
|
||||
|
||||
past = assignment_on(db, sat, date(YEAR, MONTH, 3)) # a Saturday before today
|
||||
past.user_id = ana.id
|
||||
db.commit()
|
||||
response = client.post(
|
||||
f"/assignments/{past.id}/swap",
|
||||
data={
|
||||
"csrf_token": CSRF_RE.search(client.get(f"/?year={YEAR}&month={MONTH}").text).group(1),
|
||||
"target_assignment_id": upcoming_of(db, sat),
|
||||
},
|
||||
)
|
||||
assert response.status_code == 400
|
||||
|
||||
|
||||
def test_a_member_still_cannot_open_a_request_for_someone_elses_shift(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
member = User(
|
||||
name="Member",
|
||||
username="member",
|
||||
password_hash=hash_password("member-password"),
|
||||
is_active=True,
|
||||
)
|
||||
db.add(member)
|
||||
db.commit()
|
||||
ensure_month_assignments(db, YEAR, MONTH)
|
||||
row = assignment_on(db, sat, date(YEAR, MONTH, 17))
|
||||
row.user_id = ana.id
|
||||
db.commit()
|
||||
token = CSRF_RE.search(client.get("/login").text).group(1)
|
||||
client.post("/login", data={"username": "member", "password": "member-password", "csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/").text).group(1)
|
||||
|
||||
page = client.get(f"/swaps/new?year={YEAR}&month={MONTH}").text
|
||||
assert f'<option value="{row.id}">' not in page
|
||||
assert client.post(
|
||||
"/swaps/new",
|
||||
data={
|
||||
"csrf_token": token,
|
||||
"assignment_id": row.id,
|
||||
"target_assignment_id": upcoming_of(db, sat),
|
||||
},
|
||||
).status_code == 403
|
||||
|
||||
|
||||
def test_admin_approves_an_open_request_by_choosing_the_person(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana)
|
||||
|
||||
page = client.get("/swaps").text
|
||||
assert "Aprovar e atribuir a…" in page
|
||||
rota = client.get(f"/?year={YEAR}&month={swap.assignment.date.month}").text
|
||||
assert f'action="/swaps/{swap.id}/approve"' in rota
|
||||
assert f'action="/swaps/{swap.id}/admin-reject"' in rota
|
||||
|
||||
client.post(
|
||||
f"/swaps/{swap.id}/approve",
|
||||
data={"csrf_token": token, "user_id": bruno.id},
|
||||
follow_redirects=False,
|
||||
)
|
||||
|
||||
db.refresh(swap)
|
||||
assert swap.status == "approved"
|
||||
assert swap.accepted_by_id == bruno.id
|
||||
assert db.get(Assignment, swap.assignment_id).user_id == bruno.id
|
||||
|
||||
|
||||
def test_approving_without_a_partner_still_needs_someone_to_give_it_to(client, db):
|
||||
"""Only a request without a named partner can be approved, and only with a choice."""
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, two_sided=False, target=None)
|
||||
db.refresh(swap)
|
||||
assert swap.target_user_id is None
|
||||
|
||||
assert client.post(
|
||||
f"/swaps/{swap.id}/approve", data={"csrf_token": token, "user_id": ""}
|
||||
).status_code == 400
|
||||
assert client.post(
|
||||
f"/swaps/{swap.id}/approve", data={"csrf_token": token, "user_id": ana.id}
|
||||
).status_code == 400
|
||||
db.refresh(swap)
|
||||
assert swap.status == "open"
|
||||
|
||||
client.post(
|
||||
f"/swaps/{swap.id}/approve", data={"csrf_token": token, "user_id": bruno.id},
|
||||
follow_redirects=False,
|
||||
)
|
||||
db.refresh(swap)
|
||||
assert swap.status == "approved"
|
||||
assert db.get(Assignment, swap.assignment_id).user_id == bruno.id
|
||||
|
||||
|
||||
def test_admin_confirms_the_person_who_already_accepted(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
db.execute(
|
||||
swap.__class__.__table__.update().where(swap.__class__.id == swap.id).values(
|
||||
status="pending_approval", accepted_by_id=bruno.id
|
||||
)
|
||||
)
|
||||
db.commit()
|
||||
db.refresh(swap)
|
||||
|
||||
client.post(f"/swaps/{swap.id}/approve", data={"csrf_token": token}, follow_redirects=False)
|
||||
|
||||
db.refresh(swap)
|
||||
assert swap.status == "approved"
|
||||
assert db.get(Assignment, swap.assignment_id).user_id == bruno.id
|
||||
|
||||
|
||||
def test_only_the_addressed_person_can_decline_the_request(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
outsider = User(
|
||||
name="Outsider",
|
||||
username="outsider",
|
||||
password_hash=hash_password("outsider-password"),
|
||||
is_active=True,
|
||||
)
|
||||
db.add(outsider)
|
||||
db.commit()
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
|
||||
token = CSRF_RE.search(client.get("/login").text).group(1)
|
||||
client.post("/login", data={"username": "outsider", "password": "outsider-password", "csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/swaps").text).group(1)
|
||||
|
||||
assert f'action="/swaps/{swap.id}/reject"' not in client.get("/swaps").text
|
||||
assert client.post(f"/swaps/{swap.id}/reject", data={"csrf_token": token}).status_code == 403
|
||||
|
||||
client.post("/logout", data={"csrf_token": token})
|
||||
bruno.username = "bruno"
|
||||
bruno.password_hash = hash_password("bruno-password")
|
||||
db.commit()
|
||||
token = CSRF_RE.search(client.get("/login").text).group(1)
|
||||
client.post("/login", data={"username": "bruno", "password": "bruno-password", "csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/swaps").text).group(1)
|
||||
|
||||
response = client.post(
|
||||
f"/swaps/{swap.id}/reject", data={"csrf_token": token}, follow_redirects=False
|
||||
)
|
||||
assert response.status_code == 303
|
||||
db.refresh(swap)
|
||||
assert swap.status == "rejected"
|
||||
notified = db.scalars(
|
||||
select(NotificationLog).where(NotificationLog.event_type == "swap_rejected")
|
||||
).all()
|
||||
assert [log.user_id for log in notified] == [ana.id]
|
||||
|
||||
|
||||
def test_a_declined_request_blocks_a_pending_one(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
db.execute(
|
||||
SwapRequest.__table__.update()
|
||||
.where(SwapRequest.id == swap.id)
|
||||
.values(status="pending_approval", accepted_by_id=bruno.id)
|
||||
)
|
||||
db.commit()
|
||||
db.refresh(swap)
|
||||
|
||||
token = sign_in(client)
|
||||
assert client.post(
|
||||
f"/swaps/{swap.id}/admin-reject", data={"csrf_token": token}, follow_redirects=False
|
||||
).status_code == 303
|
||||
db.refresh(swap)
|
||||
assert swap.status == "rejected"
|
||||
|
||||
|
||||
def test_a_requester_cannot_decline_their_own_request(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
swap = _open_request(db, sat, ana)
|
||||
token = sign_in(client)
|
||||
db.refresh(swap)
|
||||
# the admin is a different person, so sign in as the requester
|
||||
ana.username = "ana"
|
||||
ana.password_hash = hash_password("ana-password")
|
||||
db.commit()
|
||||
client.post("/logout", data={"csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/login").text).group(1)
|
||||
client.post("/login", data={"username": "ana", "password": "ana-password", "csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/swaps").text).group(1)
|
||||
|
||||
assert f'action="/swaps/{swap.id}/reject"' not in client.get("/swaps").text
|
||||
assert client.post(f"/swaps/{swap.id}/reject", data={"csrf_token": token}).status_code == 403
|
||||
|
||||
|
||||
def _shift_options(page: str) -> dict[int, str]:
|
||||
"""Every shift picker of the "Pedir troca" page, one per schedule block."""
|
||||
options: dict[int, str] = {}
|
||||
for block in re.findall(r'name="assignment_id".*?</select>', page, re.S):
|
||||
options.update(
|
||||
{
|
||||
int(value): label
|
||||
for value, label in re.findall(r'<option value="(\d+)">([^<]+)</option>', block)
|
||||
}
|
||||
)
|
||||
return options
|
||||
|
||||
|
||||
def test_the_swap_page_lists_the_shifts_and_the_people_of_each_schedule(client, db):
|
||||
_, sat, sun, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
ensure_month_assignments(db, YEAR, MONTH)
|
||||
future = [a for a in db.scalars(select(Assignment)).all() if a.date >= date.today() and a.user_id]
|
||||
|
||||
rota = client.get(f"/?year={YEAR}&month={MONTH}").text
|
||||
assert 'action="/swaps/new"' not in rota # the rota only shows who works each day
|
||||
assert f'href="/swaps/new?year={YEAR}&month={MONTH}"' in rota
|
||||
|
||||
page = client.get(f"/swaps/new?year={YEAR}&month={MONTH}").text
|
||||
listed = _shift_options(page)
|
||||
# Every future shift of the month an administrator may offer is listed once, with its date.
|
||||
assert set(listed) == {a.id for a in future}
|
||||
for assignment in future:
|
||||
assert listed[assignment.id] == day_short(assignment.date)
|
||||
|
||||
# Ana only appears in the Saturday block, Bruno in Saturday and Sunday.
|
||||
assert page.count("Ana") >= 1
|
||||
saturday = page.split("Almoço - Sábados")[1].split("</section>")[0]
|
||||
sunday = page.split("Almoço - Domingo")[1].split("</section>")[0]
|
||||
assert "Ana" in saturday and "Ana" not in sunday
|
||||
assert "Bruno" in sunday
|
||||
|
||||
# A member only gets their own shifts in the list.
|
||||
ana.username = "ana"
|
||||
ana.password_hash = hash_password("ana-password")
|
||||
db.commit()
|
||||
client.post("/logout", data={"csrf_token": token})
|
||||
token = CSRF_RE.search(client.get("/login").text).group(1)
|
||||
client.post("/login", data={"username": "ana", "password": "ana-password", "csrf_token": token})
|
||||
own = _shift_options(client.get(f"/swaps/new?year={YEAR}&month={MONTH}").text)
|
||||
assert own
|
||||
for assignment_id in own:
|
||||
assert db.get(Assignment, assignment_id).user_id == ana.id
|
||||
|
||||
|
||||
def test_a_swap_cannot_cross_schedules(client, db):
|
||||
night, sat, sun, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
ensure_month_assignments(db, YEAR, MONTH)
|
||||
saturday = assignment_on(db, sat, date(YEAR, MONTH, 17))
|
||||
saturday.user_id = ana.id
|
||||
bruno_shift = assignment_on(db, sat, date(YEAR, MONTH, 24))
|
||||
bruno_shift.user_id = bruno.id
|
||||
night_row = assignment_on(db, night, date(YEAR, MONTH, 18))
|
||||
night_row.user_id = ana.id
|
||||
db.commit()
|
||||
page = client.get(f"/swaps/new?year={YEAR}&month={MONTH}").text
|
||||
token_page = CSRF_RE.search(page).group(1)
|
||||
|
||||
# Bruno works the Saturday rotation but not the night schedule.
|
||||
response = client.post(
|
||||
"/swaps/new",
|
||||
data={
|
||||
"csrf_token": token_page,
|
||||
"assignment_id": saturday.id,
|
||||
"target_assignment_id": bruno_shift.id,
|
||||
},
|
||||
follow_redirects=False,
|
||||
)
|
||||
assert response.status_code == 303 # a valid Saturday swap
|
||||
|
||||
other = client.post(
|
||||
"/swaps/new",
|
||||
data={
|
||||
"csrf_token": token_page,
|
||||
"assignment_id": night_row.id,
|
||||
"target_assignment_id": bruno_shift.id,
|
||||
},
|
||||
)
|
||||
assert other.status_code == 400
|
||||
assert db.scalars(
|
||||
select(SwapRequest).where(SwapRequest.assignment_id == night_row.id)
|
||||
).all() == []
|
||||
|
||||
|
||||
def test_approving_a_swap_moves_both_shifts(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
given, wanted = swap.assignment_id, swap.target_assignment_id
|
||||
db.refresh(swap)
|
||||
assert db.get(Assignment, given).user_id == ana.id
|
||||
assert db.get(Assignment, wanted).user_id == bruno.id
|
||||
|
||||
client.post(f"/swaps/{swap.id}/approve", data={"csrf_token": token}, follow_redirects=False)
|
||||
|
||||
db.refresh(swap)
|
||||
assert swap.status == "approved"
|
||||
assert db.get(Assignment, given).user_id == bruno.id
|
||||
assert db.get(Assignment, given).source == "swap"
|
||||
assert db.get(Assignment, wanted).user_id == ana.id
|
||||
assert db.get(Assignment, wanted).source == "swap"
|
||||
notified = db.scalars(
|
||||
select(NotificationLog).where(NotificationLog.event_type == "swap_approved")
|
||||
).all()
|
||||
assert {log.user_id for log in notified} == {ana.id, bruno.id}
|
||||
|
||||
|
||||
def test_the_two_shifts_are_only_traded_if_both_are_still_owned(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
given, wanted = swap.assignment_id, swap.target_assignment_id
|
||||
# Someone else takes the shift the requester wanted in return.
|
||||
db.get(Assignment, wanted).user_id = ana.id
|
||||
db.commit()
|
||||
|
||||
response = client.post(f"/swaps/{swap.id}/approve", data={"csrf_token": token})
|
||||
|
||||
assert response.status_code == 409
|
||||
db.refresh(swap)
|
||||
assert swap.status == "cancelled"
|
||||
assert db.get(Assignment, given).user_id == ana.id
|
||||
assert db.get(Assignment, wanted).user_id == ana.id
|
||||
|
||||
|
||||
def test_creating_a_swap_needs_two_shifts_of_the_same_schedule(client, db):
|
||||
night, sat, sun, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
ensure_month_assignments(db, YEAR, MONTH)
|
||||
mine = assignment_on(db, sat, date(YEAR, MONTH, 17))
|
||||
mine.user_id = ana.id
|
||||
other_saturday = assignment_on(db, sat, date(YEAR, MONTH, 24))
|
||||
other_saturday.user_id = bruno.id
|
||||
night_shift = assignment_on(db, night, date(YEAR, MONTH, 19))
|
||||
night_shift.user_id = bruno.id
|
||||
db.commit()
|
||||
page = client.get(f"/swaps/new?year={YEAR}&month={MONTH}").text
|
||||
form = {"csrf_token": CSRF_RE.search(page).group(1), "assignment_id": mine.id}
|
||||
|
||||
def post(**extra):
|
||||
return client.post("/swaps/new", data={**form, **extra}, follow_redirects=False)
|
||||
|
||||
assert post(target_assignment_id=night_shift.id).status_code == 400 # another schedule
|
||||
assert post(target_assignment_id=mine.id).status_code == 400 # the same shift
|
||||
assert post().status_code == 422 # both shifts are required
|
||||
|
||||
created = post(target_assignment_id=other_saturday.id)
|
||||
assert created.status_code == 303, created.status_code
|
||||
swap = db.scalar(select(SwapRequest).where(SwapRequest.assignment_id == mine.id))
|
||||
assert (swap.requester_id, swap.target_user_id, swap.target_assignment_id) == (
|
||||
ana.id,
|
||||
bruno.id,
|
||||
other_saturday.id,
|
||||
)
|
||||
|
||||
# A shift can only be part of one open request at a time.
|
||||
again = client.post(
|
||||
"/swaps/new",
|
||||
data={**form, "target_assignment_id": other_saturday.id},
|
||||
follow_redirects=True,
|
||||
)
|
||||
assert "Já existe um pedido de troca ativo" in again.text
|
||||
assert len(db.scalars(select(SwapRequest).where(SwapRequest.assignment_id == mine.id)).all()) == 1
|
||||
assert client.post(
|
||||
"/swaps/new",
|
||||
data={**form, "assignment_id": other_saturday.id, "target_assignment_id": mine.id},
|
||||
follow_redirects=False,
|
||||
).status_code == 400
|
||||
|
||||
|
||||
def test_admin_assigns_someone_to_a_day_without_any_swap(client, db):
|
||||
night, sat, sun, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
target = date(YEAR, MONTH, 17) # a Saturday
|
||||
page = client.get(f"/admin/assign?on={target.isoformat()}").text
|
||||
assert "Atribuição por dia" in page
|
||||
assert f'name="on" value="{target.isoformat()}"' in page
|
||||
assert 'this.form.submit()' in page # picking a date applies it straight away
|
||||
assert "Ver dia" not in page
|
||||
assert f'href="/admin/assign?on={target.replace(day=16).isoformat()}"' in page
|
||||
assert day_long(target) in page
|
||||
night_row = assignment_on(db, night, target)
|
||||
lunch_row = assignment_on(db, sat, target)
|
||||
lunch_row.user_id = ana.id
|
||||
db.commit()
|
||||
|
||||
response = client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": lunch_row.id, "user_id": bruno.id},
|
||||
follow_redirects=True,
|
||||
)
|
||||
|
||||
assert "Bruno em sáb 17 out · Almoço - Sábados" in response.text
|
||||
db.refresh(lunch_row)
|
||||
assert lunch_row.user_id == bruno.id
|
||||
assert lunch_row.source == "manual"
|
||||
assert db.scalars(select(SwapRequest)).all() == [] # no change request involved
|
||||
notified = db.scalars(
|
||||
select(NotificationLog).where(NotificationLog.event_type == "assignment_updated")
|
||||
).all()
|
||||
assert [log.user_id for log in notified] == [bruno.id]
|
||||
assert db.get(Assignment, night_row.id).user_id in {None, ana.id, bruno.id}
|
||||
|
||||
|
||||
def test_assigning_on_the_day_page_replaces_the_person_and_notifies_both(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
row = assignment_on(db, sat, date(YEAR, MONTH, 17))
|
||||
row.user_id = ana.id
|
||||
db.commit()
|
||||
|
||||
client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": row.id, "user_id": bruno.id},
|
||||
follow_redirects=True,
|
||||
)
|
||||
|
||||
db.refresh(row)
|
||||
assert row.user_id == bruno.id
|
||||
notified = {
|
||||
(log.event_type, log.user_id)
|
||||
for log in db.scalars(select(NotificationLog)).all()
|
||||
}
|
||||
assert ("assignment_updated", bruno.id) in notified
|
||||
assert ("assignment_changed", ana.id) in notified
|
||||
|
||||
# Choosing the same person again is a no-op, and nobody can be left unassigned by accident.
|
||||
same = client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": row.id, "user_id": bruno.id},
|
||||
follow_redirects=True,
|
||||
)
|
||||
assert "Bruno já estava em sáb 17 out" in same.text
|
||||
cleared = client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": row.id, "user_id": ""},
|
||||
follow_redirects=True,
|
||||
)
|
||||
assert "sem atribuição" in cleared.text
|
||||
db.refresh(row)
|
||||
assert row.user_id is None
|
||||
assert row.source == "manual"
|
||||
|
||||
|
||||
def test_assigning_by_day_closes_an_open_request_and_protects_the_route(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
row = db.get(Assignment, swap.assignment_id)
|
||||
|
||||
client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": row.id, "user_id": bruno.id},
|
||||
follow_redirects=False,
|
||||
)
|
||||
|
||||
db.refresh(swap)
|
||||
assert swap.status == "cancelled"
|
||||
|
||||
client.post("/logout", data={"csrf_token": token})
|
||||
assert client.post(
|
||||
"/admin/assign", data={"assignment_id": row.id, "user_id": "", "csrf_token": token}
|
||||
).status_code == 401
|
||||
token = sign_in(client)
|
||||
assert client.post("/admin/assign", data={"csrf_token": "invalid", "assignment_id": row.id}).status_code == 400
|
||||
assert client.post(
|
||||
"/admin/assign", data={"csrf_token": token, "assignment_id": 9999, "user_id": ana.id}
|
||||
).status_code == 404
|
||||
inactive = User(name="Gone", is_active=False, notify_email=False)
|
||||
db.add(inactive)
|
||||
db.commit()
|
||||
assert client.post(
|
||||
"/admin/assign", data={"csrf_token": token, "assignment_id": row.id, "user_id": inactive.id}
|
||||
).status_code == 400
|
||||
assert client.get("/admin/assign?on=2026-10-45").status_code == 400
|
||||
assert client.get("/admin/assign?on=nao-e-uma-data").status_code == 400
|
||||
|
||||
def test_the_day_assign_page_is_reachable_from_the_schedules_hub(client, db):
|
||||
_, sat, _, _, _, _ = seed(db)
|
||||
sign_in(client)
|
||||
|
||||
hub = client.get("/admin/schedules").text
|
||||
assert '<a class="button primary" href="/admin/assign">Atribuir por dia</a>' in hub
|
||||
assert '<a href="/admin/assign">Atribuir dia</a>' not in client.get("/admin/users").text
|
||||
assert "Atribuição por dia" in client.get("/admin/assign").text
|
||||
|
||||
|
||||
def test_the_day_page_can_reset_a_shift_to_its_default_person(client, db):
|
||||
night, sat, sun, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
day = date(YEAR, MONTH, 17) # a Saturday
|
||||
lunch = assignment_on(db, sat, day)
|
||||
lunch.user_id = ana.id
|
||||
lunch.source = "manual"
|
||||
night_row = assignment_on(db, night, day)
|
||||
night_row.user_id = ana.id
|
||||
night_row.source = "manual"
|
||||
db.commit()
|
||||
db.add(MonthlyPattern(schedule_id=night.id, day_of_month=day.day, user_id=bruno.id))
|
||||
db.commit()
|
||||
|
||||
page = client.get(f"/admin/assign?on={day.isoformat()}").text
|
||||
assert "Automático → " in page
|
||||
|
||||
response = client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": lunch.id, "user_id": "auto"},
|
||||
follow_redirects=True,
|
||||
)
|
||||
assert "(automático)" in response.text
|
||||
db.refresh(lunch)
|
||||
assert lunch.source == "generated"
|
||||
assert lunch.user_id == bruno.id # the rotation picks Bruno for this date
|
||||
|
||||
client.post(
|
||||
"/admin/assign",
|
||||
data={"csrf_token": token, "assignment_id": night_row.id, "user_id": "auto"},
|
||||
follow_redirects=True,
|
||||
)
|
||||
db.refresh(night_row)
|
||||
assert night_row.source == "generated"
|
||||
assert night_row.user_id == bruno.id # the night pattern wins for the fixed schedule
|
||||
|
||||
|
||||
def test_admin_reverts_an_approved_swap(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
given, wanted = swap.assignment_id, swap.target_assignment_id
|
||||
client.post(f"/swaps/{swap.id}/approve", data={"csrf_token": token}, follow_redirects=False)
|
||||
db.refresh(swap)
|
||||
assert (db.get(Assignment, given).user_id, db.get(Assignment, wanted).user_id) == (bruno.id, ana.id)
|
||||
|
||||
page = client.get("/swaps").text
|
||||
assert f'action="/swaps/{swap.id}/revert"' in page
|
||||
response = client.post(
|
||||
f"/swaps/{swap.id}/revert", data={"csrf_token": token}, follow_redirects=True
|
||||
)
|
||||
|
||||
assert "Troca revertida" in response.text
|
||||
db.refresh(swap)
|
||||
assert swap.status == "reverted"
|
||||
for shift_id, person in ((given, ana), (wanted, bruno)):
|
||||
row = db.get(Assignment, shift_id)
|
||||
assert row.user_id == person.id
|
||||
assert row.source == "manual"
|
||||
assert "Revertida a troca" in (row.note or "")
|
||||
notified = db.scalars(
|
||||
select(NotificationLog).where(NotificationLog.event_type == "swap_reverted")
|
||||
).all()
|
||||
assert {log.user_id for log in notified} == {ana.id, bruno.id}
|
||||
assert "revertida" in client.get("/swaps").text
|
||||
|
||||
|
||||
def test_reverting_is_admin_only_and_only_when_it_still_applies(client, db):
|
||||
_, sat, _, ana, bruno, admin = seed(db)
|
||||
token = sign_in(client)
|
||||
swap = _open_request(db, sat, ana, target=bruno)
|
||||
given, wanted = swap.assignment_id, swap.target_assignment_id
|
||||
|
||||
# Still open: nothing to revert yet.
|
||||
assert client.post(f"/swaps/{swap.id}/revert", data={"csrf_token": token}).status_code == 400
|
||||
|
||||
client.post(f"/swaps/{swap.id}/approve", data={"csrf_token": token}, follow_redirects=False)
|
||||
db.refresh(swap)
|
||||
|
||||
# Somebody reassigned the shift after the swap: reverting would undo the wrong thing.
|
||||
db.get(Assignment, wanted).user_id = admin.id
|
||||
db.commit()
|
||||
assert client.post(f"/swaps/{swap.id}/revert", data={"csrf_token": token}).status_code == 409
|
||||
assert db.get(Assignment, given).user_id == bruno.id
|
||||
|
||||
# A member cannot revert, and a one-sided request has nothing to give back.
|
||||
client.post("/logout", data={"csrf_token": token})
|
||||
bruno.username = "bruno"
|
||||
bruno.password_hash = hash_password("bruno-password")
|
||||
db.commit()
|
||||
member_token = CSRF_RE.search(client.get("/login").text).group(1)
|
||||
client.post("/login", data={"username": "bruno", "password": "bruno-password", "csrf_token": member_token})
|
||||
member_token = CSRF_RE.search(client.get("/swaps").text).group(1)
|
||||
assert f'action="/swaps/{swap.id}/revert"' not in client.get("/swaps").text
|
||||
assert client.post(
|
||||
f"/swaps/{swap.id}/revert", data={"csrf_token": member_token}
|
||||
).status_code == 403
|
||||
|
||||
token = sign_in(client)
|
||||
assert client.post(f"/swaps/{swap.id}/revert", data={"csrf_token": "invalid"}).status_code == 400
|
||||
assert client.post("/swaps/9999/revert", data={"csrf_token": token}).status_code == 404
|
||||
legacy = _open_request(db, sat, ana, two_sided=False)
|
||||
client.post(f"/swaps/{legacy.id}/approve", data={"csrf_token": token, "user_id": bruno.id},
|
||||
follow_redirects=False)
|
||||
db.refresh(legacy)
|
||||
assert legacy.status == "approved"
|
||||
assert client.post(f"/swaps/{legacy.id}/revert", data={"csrf_token": token}).status_code == 404
|
||||
@@ -24,7 +24,7 @@ def test_migrations_produce_the_model_schema(tmp_path, monkeypatch):
|
||||
|
||||
with engine.connect() as connection:
|
||||
head = connection.execute(text("select version_num from alembic_version")).scalar_one()
|
||||
assert head == "bd2d4bb905b1"
|
||||
assert head == "57f552c46f7c"
|
||||
|
||||
|
||||
def test_seeded_schedule_names_are_renamed_without_touching_custom_names(tmp_path, monkeypatch):
|
||||
|
||||
+2
-1
@@ -245,7 +245,8 @@ def test_removing_a_person_clears_every_reference(client, db, admin):
|
||||
follow_redirects=True,
|
||||
)
|
||||
|
||||
assert "Rota Only foi removida(o)." in response.text
|
||||
assert "foi removida" not in response.text
|
||||
assert "Rota Only" not in response.text
|
||||
assert db.get(User, person.id) is None
|
||||
db.refresh(log)
|
||||
assert log.user_id is None
|
||||
|
||||
Reference in new issue
Block a user