feat: swap improvements

This commit is contained in:
jfmcarreira committed 2026-10-06 12:48:46 +01:00
1 parent c3d4a325a0
commit 0dac4b24bc
15 files changed
+1484 -139

No files matched your search

+692 -6
View File
@@ -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
+1 -1
View File
@@ -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
View File
@@ -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