Bring in pipeline, auth, deploy and docs from the boilerplate
roledesk is built on the boilerplate from here on: pipeline 2.0 (queue and scheduler), auth (one password, sessions, passkeys), the deploy kit and its docs, plus the coupling and packaging tests. Downstream copies, unedited. Refreshed from boilerplate/d56949f7d0f6c0bfe5745478e09007bfad67ae87 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
1f436104f3
commit
9d666d0937
76 files changed
+15235
No files matched your search
@@ -0,0 +1,701 @@
|
||||
"""The scheduler: the five wordings, the table, the firing, and the routes.
|
||||
|
||||
python -m pytest pipeline/tests/test_schedule.py -q
|
||||
|
||||
Three things here are worth knowing before changing anything.
|
||||
|
||||
The daylight-saving tests are the reason `next_after` takes a zone at all, and
|
||||
they are written around a real transition rather than a synthetic one, because
|
||||
the bug they guard is precisely that `+ timedelta(days=1)` looks correct.
|
||||
|
||||
The firing tests call `JobQueue._fire_due` directly. It is a private, and that
|
||||
is deliberate: driving it through `start()` would mean asserting on a loop that
|
||||
ticks on a clock, and a test that sleeps to make a scheduler fire is a test
|
||||
that fails on a busy machine. One test does start a real queue, to prove the
|
||||
tick is wired into the loop at all.
|
||||
|
||||
`SCHEDULES` is a module-level registry, like `JOBS`, so anything here that
|
||||
declares into it does so through the `declared` fixture, which puts it back.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from pathlib import Path
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
|
||||
|
||||
from pipeline import NULL, JobQueue, Jobs, RunContext, job
|
||||
from pipeline.schedule import SCHEDULES, BadCadence, Cadence, declare
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
COPENHAGEN = ZoneInfo("Europe/Copenhagen")
|
||||
|
||||
|
||||
@job("s_tick", "A scheduled tick")
|
||||
def s_tick(config, store, *, context: RunContext = NULL, note: str = "") -> dict:
|
||||
store.append(note)
|
||||
return {"note": note}
|
||||
|
||||
|
||||
@job("s_solo", "One at a time", solo=True)
|
||||
def s_solo(config, store, *, context: RunContext = NULL) -> dict:
|
||||
return {}
|
||||
|
||||
|
||||
@job("s_needs", "Needing a payload")
|
||||
def s_needs(config, store, *, context: RunContext = NULL, target: str) -> dict:
|
||||
return {"target": target}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def jobs():
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
yield Jobs(Path(tmp) / "s.db")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def queue(jobs):
|
||||
"""A queue that is never started: the tests below fire it by hand.
|
||||
|
||||
`tz="UTC"` so a cadence's next run is the same number wherever this runs.
|
||||
"""
|
||||
return JobQueue(jobs, {}, [], tz="UTC")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def declared():
|
||||
"""Borrow the declaration registry and give it back.
|
||||
|
||||
`SCHEDULES` is global, like `JOBS`, and a test that left something in it
|
||||
would give every later test in the session a schedule it never asked for.
|
||||
"""
|
||||
saved = dict(SCHEDULES)
|
||||
SCHEDULES.clear()
|
||||
yield SCHEDULES
|
||||
SCHEDULES.clear()
|
||||
SCHEDULES.update(saved)
|
||||
|
||||
|
||||
def ago(seconds: float) -> str:
|
||||
return (datetime.now(UTC) - timedelta(seconds=seconds)).isoformat()
|
||||
|
||||
|
||||
# ------------------------------------------------------------ the grammar
|
||||
|
||||
WORDINGS = [
|
||||
("every 15m", "every 15m"),
|
||||
("every 6h", "every 6h"),
|
||||
("every 2d", "every 2d"),
|
||||
("daily at 06:00", "daily at 06:00"),
|
||||
("weekly mon 07:00", "weekly mon 07:00"),
|
||||
# Written how people write them, stored how the table stores them.
|
||||
("weekly monday 07:00", "weekly mon 07:00"),
|
||||
("Weekly Sunday 23:59", "weekly sun 23:59"),
|
||||
("EVERY 15 M", "every 15m"),
|
||||
(" daily at 6:05 ", "daily at 06:05"),
|
||||
("every 1d", "every 1d"),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("typed,canonical", WORDINGS)
|
||||
def test_every_wording_parses_and_comes_back_canonical(typed, canonical):
|
||||
"""Five forms, one spelling each.
|
||||
|
||||
The round trip is the point: the table stores `str(cadence)`, so two
|
||||
people writing the same schedule two ways end up with one row that reads
|
||||
the same to both of them.
|
||||
"""
|
||||
cadence = Cadence.parse(typed)
|
||||
assert str(cadence) == canonical
|
||||
assert str(Cadence.parse(canonical)) == canonical
|
||||
assert Cadence.parse(typed) == Cadence.parse(canonical)
|
||||
|
||||
|
||||
def test_the_units_are_what_they_say():
|
||||
assert Cadence.parse("every 15m").seconds == 900
|
||||
assert Cadence.parse("every 6h").seconds == 6 * 3600
|
||||
assert Cadence.parse("every 2d").seconds == 2 * 86400
|
||||
# A clock cadence has no fixed length, and says so rather than guessing.
|
||||
assert Cadence.parse("daily at 06:00").seconds == 0
|
||||
|
||||
|
||||
@pytest.mark.parametrize("wording", [
|
||||
"sometimes", "", "cron 0 6 * * *", "every 15", "every m", "every 0h",
|
||||
"every 15s", "daily 06:00", "daily at 25:00", "daily at 06:60",
|
||||
"weekly 07:00", "weekly funday 07:00", "every 15m please",
|
||||
])
|
||||
def test_a_wording_outside_the_five_is_refused_with_all_five(wording):
|
||||
"""And the refusal is the sentence a person is shown.
|
||||
|
||||
It goes out of the API as `{"detail": ...}` and into a toast, so it has to
|
||||
say what to type instead rather than merely that this was wrong.
|
||||
"""
|
||||
with pytest.raises(ValueError) as refused:
|
||||
Cadence.parse(wording)
|
||||
said = str(refused.value)
|
||||
assert isinstance(refused.value, BadCadence)
|
||||
for form in ("every 15m", "every 6h", "every 2d",
|
||||
"daily at 06:00", "weekly mon 07:00"):
|
||||
assert form in said
|
||||
|
||||
|
||||
# ------------------------------------------------------------- next_after
|
||||
|
||||
def test_next_after_is_strictly_after():
|
||||
"""A schedule fired at its own time must not find itself due again on the
|
||||
same instant, which would be one firing per tick for ever."""
|
||||
at_six = datetime(2025, 6, 1, 6, 0, tzinfo=COPENHAGEN)
|
||||
when = Cadence.parse("daily at 06:00").next_after(at_six, COPENHAGEN)
|
||||
assert when.astimezone(COPENHAGEN) == at_six + timedelta(days=1)
|
||||
|
||||
|
||||
def test_next_after_always_comes_back_in_utc():
|
||||
"""Because it is written straight into the table, where every other time
|
||||
is UTC and the column is compared as text."""
|
||||
when = Cadence.parse("daily at 06:00").next_after(
|
||||
datetime(2025, 6, 1, 12, 0, tzinfo=COPENHAGEN), COPENHAGEN)
|
||||
assert when.tzinfo is UTC
|
||||
assert when.isoformat().endswith("+00:00")
|
||||
|
||||
|
||||
def test_weekly_lands_on_the_day_it_names():
|
||||
monday = Cadence.parse("weekly mon 07:00")
|
||||
# A Wednesday: the next Monday is five days away, not tomorrow.
|
||||
from_wed = monday.next_after(datetime(2025, 6, 4, 9, 0, tzinfo=COPENHAGEN),
|
||||
COPENHAGEN).astimezone(COPENHAGEN)
|
||||
assert from_wed.weekday() == 0 and (from_wed.hour, from_wed.minute) == (7, 0)
|
||||
assert from_wed.date() == datetime(2025, 6, 9).date()
|
||||
# Monday morning before seven: today, not next week.
|
||||
from_mon = monday.next_after(datetime(2025, 6, 9, 6, 0, tzinfo=COPENHAGEN),
|
||||
COPENHAGEN).astimezone(COPENHAGEN)
|
||||
assert from_mon.date() == datetime(2025, 6, 9).date()
|
||||
|
||||
|
||||
def test_daily_keeps_its_wall_clock_across_both_dst_changes():
|
||||
"""06:00 is 06:00 on both sides, which is the whole reason for the zone.
|
||||
|
||||
Spring forward is a 23-hour day and autumn back is a 25-hour one, so the
|
||||
real elapsed time between two runs is not 24 hours — and it must not be,
|
||||
because what the wording promised is a time of day.
|
||||
"""
|
||||
daily = Cadence.parse("daily at 06:00")
|
||||
|
||||
# Europe/Copenhagen, 2025: forward on 30 March, back on 26 October.
|
||||
forward = daily.next_after(
|
||||
datetime(2025, 3, 29, 6, 30, tzinfo=COPENHAGEN), COPENHAGEN)
|
||||
local = forward.astimezone(COPENHAGEN)
|
||||
assert (local.hour, local.minute) == (6, 0)
|
||||
assert local.date() == datetime(2025, 3, 30).date()
|
||||
# 05:30Z to 04:00Z: 22h30m of real time for a 23h30m step of the clock.
|
||||
assert forward - datetime(2025, 3, 29, 6, 30, tzinfo=COPENHAGEN) \
|
||||
== timedelta(hours=22, minutes=30)
|
||||
|
||||
back = daily.next_after(
|
||||
datetime(2025, 10, 25, 6, 30, tzinfo=COPENHAGEN), COPENHAGEN)
|
||||
local = back.astimezone(COPENHAGEN)
|
||||
assert (local.hour, local.minute) == (6, 0)
|
||||
assert local.date() == datetime(2025, 10, 26).date()
|
||||
assert back - datetime(2025, 10, 25, 6, 30, tzinfo=COPENHAGEN) \
|
||||
== timedelta(hours=24, minutes=30)
|
||||
|
||||
|
||||
def test_weekly_keeps_its_wall_clock_across_a_dst_change():
|
||||
when = Cadence.parse("weekly sun 07:00").next_after(
|
||||
datetime(2025, 3, 26, 9, 0, tzinfo=COPENHAGEN), COPENHAGEN)
|
||||
local = when.astimezone(COPENHAGEN)
|
||||
assert local.date() == datetime(2025, 3, 30).date() # the change itself
|
||||
assert (local.hour, local.minute) == (7, 0)
|
||||
|
||||
|
||||
def test_an_interval_is_elapsed_time_and_ignores_the_change():
|
||||
"""The other half of the promise, and the reason both wordings exist.
|
||||
|
||||
`every 24h` across a spring-forward is 24 real hours and therefore lands
|
||||
an hour later on the clock. A person who wanted 06:00 wrote `daily`.
|
||||
"""
|
||||
start = datetime(2025, 3, 29, 6, 30, tzinfo=COPENHAGEN)
|
||||
when = Cadence.parse("every 24h").next_after(start, COPENHAGEN)
|
||||
assert when - start == timedelta(hours=24)
|
||||
assert when.astimezone(COPENHAGEN).hour == 7
|
||||
|
||||
|
||||
def test_a_naive_moment_is_read_as_utc():
|
||||
"""Rather than raising. Every stamp in the table is UTC, so a caller that
|
||||
lost the tzinfo on the way is very nearly certainly holding one."""
|
||||
naive = datetime(2025, 6, 1, 12, 0)
|
||||
assert Cadence.parse("every 1h").next_after(naive) \
|
||||
== datetime(2025, 6, 1, 13, 0, tzinfo=UTC)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- the table
|
||||
|
||||
def test_the_table_holds_a_schedule_through_its_life(jobs):
|
||||
row = jobs.add_schedule("nightly", "s_tick", "daily at 06:00",
|
||||
payload={"note": "hello"}, label="A nightly tick",
|
||||
next_run="2030-01-01T06:00:00+00:00")
|
||||
assert row is not None
|
||||
assert (row.name, row.kind, row.cadence) == ("nightly", "s_tick", "daily at 06:00")
|
||||
assert row.payload == {"note": "hello"} and row.enabled is True
|
||||
assert row.last_job_id == 0 and row.last_run == "" and row.last_state == ""
|
||||
|
||||
assert [s.name for s in jobs.schedules()] == ["nightly"]
|
||||
assert jobs.schedule(row.id) == row
|
||||
|
||||
edited = jobs.update_schedule(row.id, cadence="every 15m", enabled=False,
|
||||
payload={"note": "other"})
|
||||
assert edited.cadence == "every 15m" and edited.enabled is False
|
||||
assert edited.payload == {"note": "other"}
|
||||
# Untouched columns stay as they were.
|
||||
assert edited.name == "nightly" and edited.label == "A nightly tick"
|
||||
|
||||
assert jobs.delete_schedule(row.id) is True
|
||||
assert jobs.delete_schedule(row.id) is False # two tabs; not an error
|
||||
assert jobs.schedules() == []
|
||||
|
||||
|
||||
def test_a_name_is_taken_once(jobs):
|
||||
assert jobs.add_schedule("one", "s_tick", "every 15m") is not None
|
||||
assert jobs.add_schedule("one", "s_tick", "every 6h", only_if_new=True) is None
|
||||
assert jobs.schedules()[0].cadence == "every 15m"
|
||||
|
||||
|
||||
def test_schedules_carry_the_state_of_their_last_job(jobs):
|
||||
row = jobs.add_schedule("one", "s_tick", "every 15m")
|
||||
queued = jobs.enqueue("s_tick")
|
||||
jobs.mark_fired(row.id, queued.id, "2030-01-01T00:00:00+00:00")
|
||||
assert jobs.schedules()[0].last_state == "queued"
|
||||
jobs.claim({"cpu": 1})
|
||||
jobs.finish(queued.id, "failed", error="no")
|
||||
assert jobs.schedules()[0].last_state == "failed"
|
||||
# And the time it fired, which is not the time it is next due.
|
||||
listed = jobs.schedules()[0]
|
||||
assert listed.last_run and listed.next_run == "2030-01-01T00:00:00+00:00"
|
||||
|
||||
|
||||
def test_due_schedules_passes_over_what_is_off_or_not_yet(jobs):
|
||||
jobs.add_schedule("due", "s_tick", "every 15m", next_run=ago(60))
|
||||
jobs.add_schedule("off", "s_tick", "every 15m", next_run=ago(60), enabled=False)
|
||||
jobs.add_schedule("later", "s_tick", "every 15m",
|
||||
next_run="2099-01-01T00:00:00+00:00")
|
||||
jobs.add_schedule("never", "s_tick", "every 15m") # no time at all
|
||||
due = jobs.due_schedules(datetime.now(UTC).isoformat())
|
||||
assert [s.name for s in due] == ["due"]
|
||||
|
||||
|
||||
# --------------------------------------------------------------- the firing
|
||||
|
||||
def test_the_tick_fires_a_due_row_and_moves_it_on(queue, jobs):
|
||||
row = jobs.add_schedule("regular", "s_tick", "every 15m",
|
||||
payload={"note": "scheduled"}, next_run=ago(30))
|
||||
queue._fire_due()
|
||||
|
||||
queued = jobs.snapshot().queued
|
||||
assert [j.kind for j in queued] == ["s_tick"]
|
||||
assert queued[0].payload == {"note": "scheduled"}
|
||||
|
||||
after = jobs.schedule(row.id)
|
||||
assert after.last_job_id == queued[0].id
|
||||
assert after.last_run
|
||||
# Fifteen minutes from now, not from the moment it was due.
|
||||
assert after.next_run > datetime.now(UTC).isoformat()
|
||||
assert after.next_run < (datetime.now(UTC) + timedelta(minutes=16)).isoformat()
|
||||
|
||||
|
||||
def test_a_schedule_does_not_pile_up_behind_its_own_job(queue, jobs):
|
||||
"""The job from the last firing is still queued, so this one is skipped.
|
||||
|
||||
Skipped and *moved on*, not left due: a schedule whose job takes longer
|
||||
than its cadence would otherwise fire on every tick for as long as the job
|
||||
ran, and the queue would fill with copies of work already under way.
|
||||
"""
|
||||
row = jobs.add_schedule("regular", "s_tick", "every 15m", next_run=ago(30))
|
||||
queue._fire_due()
|
||||
first = jobs.schedule(row.id).last_job_id
|
||||
|
||||
jobs.update_schedule(row.id, next_run=ago(1)) # due again
|
||||
queue._fire_due()
|
||||
|
||||
assert len(jobs.snapshot().queued) == 1
|
||||
again = jobs.schedule(row.id)
|
||||
assert again.last_job_id == first # nothing new was queued
|
||||
assert again.next_run > datetime.now(UTC).isoformat()
|
||||
|
||||
|
||||
def test_a_solo_kind_already_underway_holds_its_schedule_back(queue, jobs):
|
||||
"""The other way a schedule collides: not with itself, with somebody else.
|
||||
|
||||
A button, a second schedule or a cascade started one, and `enqueue` would
|
||||
hand that job back — so the schedule would record work it did not ask for
|
||||
as its own firing.
|
||||
"""
|
||||
pressed = jobs.enqueue("s_solo", dedup_key="s_solo")
|
||||
row = jobs.add_schedule("solo", "s_solo", "every 15m", next_run=ago(30))
|
||||
queue._fire_due()
|
||||
after = jobs.schedule(row.id)
|
||||
assert after.last_job_id == 0 # it never fired
|
||||
assert after.next_run > datetime.now(UTC).isoformat()
|
||||
assert [j.id for j in jobs.snapshot().queued] == [pressed.id]
|
||||
|
||||
|
||||
def test_downtime_is_caught_up_once_and_not_once_per_slot(queue, jobs):
|
||||
"""Three days off an hourly schedule is one job, not seventy-two.
|
||||
|
||||
The row carries one `next_run`, and a firing sets it from *now* rather
|
||||
than stepping through what was missed — so there is nowhere for a backlog
|
||||
to accumulate even in principle.
|
||||
"""
|
||||
row = jobs.add_schedule("hourly", "s_tick", "every 1h", next_run=ago(3 * 86400))
|
||||
queue._fire_due()
|
||||
assert len(jobs.snapshot().queued) == 1
|
||||
after = jobs.schedule(row.id)
|
||||
assert after.next_run > datetime.now(UTC).isoformat()
|
||||
assert after.next_run < (datetime.now(UTC) + timedelta(minutes=61)).isoformat()
|
||||
|
||||
|
||||
def test_an_unknown_kind_never_fires_and_keeps_its_place(queue, jobs):
|
||||
"""A handler that went away in a deploy. The row stays exactly as it is —
|
||||
time included — so reinstalling the plugin runs it rather than starting
|
||||
another cadence from scratch."""
|
||||
row = jobs.add_schedule("gone", "s_vanished", "every 15m", next_run=ago(30))
|
||||
queue._fire_due()
|
||||
assert jobs.snapshot().queued == []
|
||||
assert jobs.schedule(row.id).next_run == row.next_run
|
||||
queue._fire_due() # and it says so once
|
||||
assert queue._said_about == {(row.id, "kind")}
|
||||
|
||||
|
||||
def test_a_cadence_the_table_cannot_parse_never_fires(queue, jobs):
|
||||
"""Only reachable by editing the file by hand, since every route parses
|
||||
first. It must not take the tick down with it."""
|
||||
jobs.add_schedule("bent", "s_tick", "every 15m", next_run=ago(30))
|
||||
jobs._write("UPDATE schedules SET cadence='sometimes'")
|
||||
queue._fire_due()
|
||||
assert jobs.snapshot().queued == []
|
||||
assert jobs.schedules()[0].cadence == "sometimes" # left to be fixed
|
||||
|
||||
|
||||
def test_a_disabled_row_is_not_fired(queue, jobs):
|
||||
jobs.add_schedule("off", "s_tick", "every 15m", next_run=ago(30), enabled=False)
|
||||
queue._fire_due()
|
||||
assert jobs.snapshot().queued == []
|
||||
|
||||
|
||||
def test_run_now_fires_without_moving_the_next_run(queue, jobs):
|
||||
row = jobs.add_schedule("nightly", "s_tick", "daily at 06:00",
|
||||
next_run="2099-01-01T06:00:00+00:00")
|
||||
started = queue.run_schedule(row.id)
|
||||
assert started is not None and started.kind == "s_tick"
|
||||
after = jobs.schedule(row.id)
|
||||
assert after.next_run == "2099-01-01T06:00:00+00:00"
|
||||
# But it did just run, and that is the job it queued — so the next tick
|
||||
# will not start a second one while this is still going.
|
||||
assert after.last_job_id == started.id and after.last_run
|
||||
|
||||
|
||||
# ------------------------------------------------------------ reconciliation
|
||||
|
||||
def test_declared_defaults_get_a_row_on_start(declared, jobs):
|
||||
declare("nightly tick", "s_tick", "daily at 06:00", {"note": "declared"},
|
||||
label="A tick, nightly")
|
||||
JobQueue(jobs, {}, [], tz="UTC")._reconcile_schedules()
|
||||
row = jobs.schedules()[0]
|
||||
assert (row.name, row.kind, row.cadence) == ("nightly tick", "s_tick",
|
||||
"daily at 06:00")
|
||||
assert row.payload == {"note": "declared"} and row.label == "A tick, nightly"
|
||||
assert row.next_run # and it knows when it is next
|
||||
|
||||
|
||||
def test_reconciliation_keeps_what_the_user_edited(declared, jobs):
|
||||
"""The whole of what a declaration means: a starting point, not a setting.
|
||||
|
||||
Switching a default off, or slowing it down, has to survive the next
|
||||
deploy — otherwise the only way to be rid of one is to edit the code and
|
||||
redeploy, which is not a thing the person running the app can do.
|
||||
"""
|
||||
declare("nightly tick", "s_tick", "daily at 06:00")
|
||||
queue = JobQueue(jobs, {}, [], tz="UTC")
|
||||
queue._reconcile_schedules()
|
||||
row = jobs.schedules()[0]
|
||||
jobs.update_schedule(row.id, cadence="every 2d", enabled=False,
|
||||
payload={"note": "mine"})
|
||||
|
||||
queue._reconcile_schedules() # a restart
|
||||
|
||||
again = jobs.schedules()[0]
|
||||
assert again.id == row.id
|
||||
assert again.cadence == "every 2d"
|
||||
assert again.enabled is False
|
||||
assert again.payload == {"note": "mine"}
|
||||
|
||||
|
||||
def test_a_declaration_that_goes_away_leaves_its_row(declared, jobs):
|
||||
"""Nothing here deletes. A deploy that silently forgot a schedule somebody
|
||||
was relying on is the failure this avoids; an orphan says `unknown kind`
|
||||
and waits to be deleted deliberately."""
|
||||
declare("nightly tick", "s_tick", "daily at 06:00")
|
||||
queue = JobQueue(jobs, {}, [], tz="UTC")
|
||||
queue._reconcile_schedules()
|
||||
declared.clear()
|
||||
queue._reconcile_schedules()
|
||||
assert [s.name for s in jobs.schedules()] == ["nightly tick"]
|
||||
|
||||
|
||||
def test_declaring_one_name_twice_differently_is_refused(declared):
|
||||
declare("nightly", "s_tick", "daily at 06:00")
|
||||
declare("nightly", "s_tick", "daily at 06:00") # the same: fine
|
||||
with pytest.raises(ValueError) as refused:
|
||||
declare("nightly", "s_tick", "daily at 07:00")
|
||||
assert "nightly" in str(refused.value)
|
||||
|
||||
|
||||
def test_a_declared_cadence_is_parsed_where_it_is_written(declared):
|
||||
"""At import, with a traceback pointing at the line — rather than at 06:00
|
||||
in a log nobody is reading."""
|
||||
with pytest.raises(ValueError):
|
||||
declare("bad", "s_tick", "every so often")
|
||||
assert "bad" not in declared
|
||||
|
||||
|
||||
# ------------------------------------------------------------- a real queue
|
||||
|
||||
def test_a_started_queue_fires_what_is_overdue(jobs, declared):
|
||||
"""The one test that drives the loop rather than the method.
|
||||
|
||||
Everything above proves the firing decides correctly; this proves it is
|
||||
wired into `start()` at all, which is the wire nobody notices is missing
|
||||
until a schedule silently stops running.
|
||||
"""
|
||||
ran: list[str] = []
|
||||
jobs.add_schedule("regular", "s_tick", "every 15m",
|
||||
payload={"note": "from the loop"}, next_run=ago(30))
|
||||
queue = JobQueue(jobs, {}, ran, tz="UTC", workers={"cpu": 1})
|
||||
assert queue.drain(timeout=10) is True
|
||||
assert ran == ["from the loop"]
|
||||
assert jobs.schedules()[0].last_state == "done"
|
||||
|
||||
|
||||
def test_a_queue_with_schedules_off_fires_nothing(jobs, declared):
|
||||
ran: list[str] = []
|
||||
jobs.add_schedule("regular", "s_tick", "every 15m", next_run=ago(30))
|
||||
queue = JobQueue(jobs, {}, ran, tz="UTC", schedules=False)
|
||||
assert queue.drain(timeout=10) is True
|
||||
assert ran == []
|
||||
assert jobs.schedules()[0].last_job_id == 0
|
||||
|
||||
|
||||
def test_an_unknown_timezone_is_a_warning_and_not_a_refusal(jobs, caplog):
|
||||
"""A mistyped zone must not be the reason a worker will not start."""
|
||||
queue = JobQueue(jobs, {}, [], tz="Mars/Olympus_Mons")
|
||||
assert queue.zone is not None
|
||||
assert Cadence.parse("daily at 06:00").next_after(datetime.now(UTC), queue.zone)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ the web
|
||||
|
||||
@pytest.fixture
|
||||
def client(jobs, declared):
|
||||
pytest.importorskip("fastapi")
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
from pipeline.web import connect
|
||||
|
||||
app = FastAPI()
|
||||
connect(app, jobs, {}, [], tz="UTC", schedules=False)
|
||||
with TestClient(app) as client:
|
||||
yield client
|
||||
|
||||
|
||||
def test_the_element_is_served(client):
|
||||
answer = client.get("/_jobs/schedules.js")
|
||||
assert answer.status_code == 200
|
||||
assert "javascript" in answer.headers["content-type"]
|
||||
assert "desk-schedules" in answer.text
|
||||
|
||||
|
||||
def test_adding_listing_editing_and_deleting(client):
|
||||
added = client.post("/api/schedules", json={
|
||||
"kind": "s_tick", "cadence": "weekly monday 07:00",
|
||||
"payload": {"note": "over http"}})
|
||||
assert added.status_code == 201
|
||||
row = added.json()
|
||||
# Named after its kind, since none was given, and stored canonically.
|
||||
assert row["name"] == "s_tick" and row["cadence"] == "weekly mon 07:00"
|
||||
assert row["next_run"] and row["unknown"] is False
|
||||
|
||||
assert [s["id"] for s in client.get("/api/schedules").json()] == [row["id"]]
|
||||
|
||||
off = client.patch(f"/api/schedules/{row['id']}", json={"enabled": False})
|
||||
assert off.status_code == 200 and off.json()["enabled"] is False
|
||||
# And only that: a PATCH of one field does not resubmit the rest.
|
||||
assert off.json()["cadence"] == "weekly mon 07:00"
|
||||
assert off.json()["payload"] == {"note": "over http"}
|
||||
|
||||
faster = client.patch(f"/api/schedules/{row['id']}", json={"cadence": "every 15m"})
|
||||
assert faster.json()["cadence"] == "every 15m"
|
||||
# A new cadence moves the time with it, rather than leaving the old one.
|
||||
assert faster.json()["next_run"] != row["next_run"]
|
||||
|
||||
gone = client.delete(f"/api/schedules/{row['id']}")
|
||||
assert gone.status_code == 200 and gone.json() == {"deleted": True}
|
||||
assert client.delete(f"/api/schedules/{row['id']}").json() == {"deleted": False}
|
||||
|
||||
|
||||
def test_a_second_schedule_of_one_kind_is_named_by_counting(client):
|
||||
first = client.post("/api/schedules",
|
||||
json={"kind": "s_tick", "cadence": "every 15m"}).json()
|
||||
second = client.post("/api/schedules",
|
||||
json={"kind": "s_tick", "cadence": "every 6h"}).json()
|
||||
assert (first["name"], second["name"]) == ("s_tick", "s_tick 2")
|
||||
|
||||
|
||||
def test_a_name_somebody_typed_is_refused_rather_than_altered(client):
|
||||
client.post("/api/schedules",
|
||||
json={"name": "nightly", "kind": "s_tick", "cadence": "every 15m"})
|
||||
clash = client.post("/api/schedules",
|
||||
json={"name": "nightly", "kind": "s_tick", "cadence": "every 6h"})
|
||||
assert clash.status_code == 409
|
||||
assert "nightly" in clash.json()["detail"]
|
||||
|
||||
|
||||
def test_an_unregistered_kind_is_a_404_naming_what_there_is(client):
|
||||
refused = client.post("/api/schedules",
|
||||
json={"kind": "s_nonesuch", "cadence": "every 15m"})
|
||||
assert refused.status_code == 404
|
||||
detail = refused.json()["detail"]
|
||||
assert "s_nonesuch" in detail and "s_tick" in detail
|
||||
|
||||
|
||||
def test_a_payload_missing_what_the_handler_needs_is_a_422_naming_it(client):
|
||||
refused = client.post("/api/schedules",
|
||||
json={"kind": "s_needs", "cadence": "every 15m"})
|
||||
assert refused.status_code == 422
|
||||
assert "target" in refused.json()["detail"]
|
||||
# And with it, the same request is fine.
|
||||
assert client.post("/api/schedules", json={
|
||||
"kind": "s_needs", "cadence": "every 15m",
|
||||
"payload": {"target": "somewhere"}}).status_code == 201
|
||||
|
||||
|
||||
def test_a_bad_cadence_is_a_422_listing_the_accepted_wordings(client):
|
||||
refused = client.post("/api/schedules",
|
||||
json={"kind": "s_tick", "cadence": "sometimes"})
|
||||
assert refused.status_code == 422
|
||||
detail = refused.json()["detail"]
|
||||
assert isinstance(detail, str)
|
||||
for form in ("every 15m", "every 6h", "every 2d",
|
||||
"daily at 06:00", "weekly mon 07:00"):
|
||||
assert form in detail
|
||||
|
||||
|
||||
def test_an_edit_is_validated_the_same_way(client):
|
||||
row = client.post("/api/schedules",
|
||||
json={"kind": "s_tick", "cadence": "every 15m"}).json()
|
||||
assert client.patch(f"/api/schedules/{row['id']}",
|
||||
json={"cadence": "now and then"}).status_code == 422
|
||||
assert client.patch(f"/api/schedules/{row['id']}",
|
||||
json={"kind": "s_needs"}).status_code == 422
|
||||
assert client.patch("/api/schedules/9999",
|
||||
json={"enabled": False}).status_code == 404
|
||||
|
||||
|
||||
def test_run_now_queues_the_job(client, jobs):
|
||||
row = client.post("/api/schedules",
|
||||
json={"kind": "s_tick", "cadence": "daily at 06:00"}).json()
|
||||
started = client.post(f"/api/schedules/{row['id']}/run")
|
||||
assert started.status_code == 202
|
||||
assert started.json()["kind"] == "s_tick"
|
||||
after = client.get("/api/schedules").json()[0]
|
||||
assert after["last_job_id"] == started.json()["id"]
|
||||
assert after["next_run"] == row["next_run"]
|
||||
assert client.post("/api/schedules/9999/run").status_code == 404
|
||||
|
||||
|
||||
def test_a_row_whose_handler_went_away_is_flagged_not_hidden(client, jobs):
|
||||
jobs.add_schedule("orphan", "s_vanished", "every 15m")
|
||||
row = next(s for s in client.get("/api/schedules").json()
|
||||
if s["name"] == "orphan")
|
||||
assert row["unknown"] is True
|
||||
# Listed and deletable, which is the whole of what can be done about it.
|
||||
assert client.delete(f"/api/schedules/{row['id']}").json() == {"deleted": True}
|
||||
|
||||
|
||||
def test_the_socket_pushes_the_schedule_list_on_every_change(client):
|
||||
"""So a row edited in one tab redraws in the others without polling.
|
||||
|
||||
The opening message is the *job* list — the socket is shared — which is
|
||||
why `<desk-schedules>` reads `/api/schedules` once on connect and follows
|
||||
this afterwards.
|
||||
"""
|
||||
with client.websocket_connect("/ws/jobs") as socket:
|
||||
assert socket.receive_json()["type"] == "jobs"
|
||||
added = client.post("/api/schedules",
|
||||
json={"kind": "s_tick", "cadence": "every 15m"}).json()
|
||||
pushed = _next_of(socket, "schedules")
|
||||
assert [s["id"] for s in pushed["schedules"]] == [added["id"]]
|
||||
assert pushed["schedules"][0]["cadence"] == "every 15m"
|
||||
|
||||
client.patch(f"/api/schedules/{added['id']}", json={"cadence": "every 6h"})
|
||||
assert _next_of(socket, "schedules")["schedules"][0]["cadence"] == "every 6h"
|
||||
|
||||
client.delete(f"/api/schedules/{added['id']}")
|
||||
assert _next_of(socket, "schedules")["schedules"] == []
|
||||
|
||||
|
||||
def _next_of(socket, type_: str, tries: int = 12) -> dict:
|
||||
"""The next message of one type, stepping over the job pushes between."""
|
||||
for _ in range(tries):
|
||||
message = socket.receive_json()
|
||||
if message["type"] == type_:
|
||||
return message
|
||||
raise AssertionError(f"no {type_} message arrived")
|
||||
|
||||
|
||||
# --------------------------------------------------------------- the worker
|
||||
|
||||
def _worker(db: Path, marks: Path, *extra: str) -> subprocess.CompletedProcess:
|
||||
argv = [sys.executable, "-m", "pipeline.worker", "--db", str(db),
|
||||
"--bootstrap", "pipeline.tests.scheduled_handlers:marking",
|
||||
"--bootstrap-arg", str(marks), "--until-idle", *extra]
|
||||
return subprocess.run(argv, env=dict(os.environ, PYTHONPATH=str(ROOT)),
|
||||
cwd=ROOT, capture_output=True, timeout=120)
|
||||
|
||||
|
||||
def test_the_standalone_worker_fires_schedules(tmp_path):
|
||||
"""A machine running only `python -m pipeline.worker` still gets its 06:00
|
||||
job, which is what makes it a complete replacement for the web app's
|
||||
worker rather than half of one."""
|
||||
db, marks = tmp_path / "w.db", tmp_path / "marks"
|
||||
marks.mkdir()
|
||||
jobs = Jobs(db)
|
||||
jobs.add_schedule("marker", "sw_mark", "every 1h", next_run=ago(60))
|
||||
|
||||
done = _worker(db, marks)
|
||||
assert done.returncode == 0, done.stdout.decode("utf-8", "replace")
|
||||
assert (marks / "fired").exists()
|
||||
assert jobs.schedules()[0].last_job_id
|
||||
|
||||
|
||||
def test_no_schedules_turns_it_off_for_a_second_worker(tmp_path):
|
||||
"""One scheduler per file, as many workers as you like: the pile-up guard
|
||||
reads `last_job_id`, which neither of two simultaneous firings has written
|
||||
yet when the other looks."""
|
||||
db, marks = tmp_path / "w.db", tmp_path / "marks"
|
||||
marks.mkdir()
|
||||
jobs = Jobs(db)
|
||||
jobs.add_schedule("marker", "sw_mark", "every 1h", next_run=ago(60))
|
||||
|
||||
done = _worker(db, marks, "--no-schedules")
|
||||
assert done.returncode == 0, done.stdout.decode("utf-8", "replace")
|
||||
assert not (marks / "fired").exists()
|
||||
assert jobs.schedules()[0].last_job_id == 0
|
||||
# Not even the declared default was reconciled: nothing about schedules
|
||||
# happens in a worker that was told not to do them.
|
||||
assert [s.name for s in jobs.schedules()] == ["marker"]
|
||||
Reference in new issue
Block a user