dev_agent
02d537b303
CI / ci (push) Successful in 8m35s
Co-authored-by: dev_agent <dev_agent@cubecraftlabs.com>
329 lines
13 KiB
Go
329 lines
13 KiB
Go
package scheduler_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/db"
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/household"
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify"
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/notify/notifytest"
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/scheduler"
|
|
"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/store"
|
|
)
|
|
|
|
// The tests in this file run plan's day_of_reminder schedules on the fake
|
|
// clock against the real plan service and notification outbox. The plan of
|
|
// the week of Monday Oct 12 (w42) has poolNames Monday to Sunday: Beef
|
|
// Chili on Monday, Pot Roast on Tuesday. The household's dinner time is the
|
|
// seeded 17:30 and its reminder time the seeded 16:30, in Chicago.
|
|
|
|
// w42 is the Monday of 2026-W42.
|
|
var w42 = mustLocalDate("2026-10-12")
|
|
|
|
// planWeek drafts the plan of the week starting weekStart and waits for it.
|
|
func (p *planEnv) planWeek(weekStart store.LocalDate) {
|
|
p.e.t.Helper()
|
|
p.reply(weekStart)
|
|
if _, err := p.svc.StartDraft(context.Background(), weekStart, false); err != nil {
|
|
p.e.t.Fatal(err)
|
|
}
|
|
if jobs := p.e.drafts(); jobs[len(jobs)-1] != succeeded {
|
|
p.e.t.Fatalf("draft of %s = %+v, want succeeded", weekStart, jobs)
|
|
}
|
|
}
|
|
|
|
// crockPot makes the dinner name a crock-pot dinner of minutes.
|
|
func (p *planEnv) crockPot(name string, minutes int) {
|
|
p.e.t.Helper()
|
|
if _, err := p.e.st.Writer.Exec(`UPDATE dinners SET method = 'crockpot', minutes_total = ? WHERE id = ?`, minutes, p.ids[name]); err != nil {
|
|
p.e.t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// reminders returns the day_of_reminder notifications stored, oldest
|
|
// first. The seeded preference sends day_of_reminder to push only, so there
|
|
// is one row per event.
|
|
func (e *env) reminders() []notifytest.Row {
|
|
e.t.Helper()
|
|
rows := notifytest.Rows(e.t, e.st, notify.DayOfReminder)
|
|
for _, r := range rows {
|
|
if r.Channel != notify.ChannelPush {
|
|
e.t.Fatalf("day_of_reminder row %+v, want push only", r)
|
|
}
|
|
}
|
|
return rows
|
|
}
|
|
|
|
// reminderKeys returns the keys of e.reminders().
|
|
func (e *env) reminderKeys() []string {
|
|
e.t.Helper()
|
|
var keys []string
|
|
for _, r := range e.reminders() {
|
|
keys = append(keys, r.Key)
|
|
}
|
|
return keys
|
|
}
|
|
|
|
// wantReminder fails unless the reminder keyed key was stored with title,
|
|
// body and the link to the dinner name.
|
|
func (p *planEnv) wantReminder(key, title, body, name string) {
|
|
p.e.t.Helper()
|
|
for _, r := range p.e.reminders() {
|
|
if r.Key != key {
|
|
continue
|
|
}
|
|
week := household.WeekStart(mustLocalDate(key[len(key)-len("YYYY-MM-DD"):]))
|
|
want := notify.Payload{Event: notify.DayOfReminder, Title: title, Body: body, URL: "/dinner/" + p.ids[name], Tag: key, Week: week.String()}
|
|
if r.Payload != want {
|
|
p.e.t.Errorf("reminder %s = %+v, want %+v", key, r.Payload, want)
|
|
}
|
|
return
|
|
}
|
|
p.e.t.Errorf("no reminder %s", key)
|
|
}
|
|
|
|
// TestDayOfReminderNormalNight: a night whose dinner is not a crock-pot
|
|
// dinner gets exactly the daily reminder, at reminder_time 16:30, keyed
|
|
// day_of_reminder:YYYY-MM-DD and linking to the dinner.
|
|
func TestDayOfReminderNormalNight(t *testing.T) {
|
|
e := newEnv(t)
|
|
p := e.plans(e.pool())
|
|
p.planWeek(w42)
|
|
|
|
// Monday 08:00: the catch-up of Sunday 16:30 finds no plan for W41.
|
|
r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
|
|
r.runUntil(at(2026, 10, 12, 16, 29))
|
|
wantKeys(t, "before 16:30", e.reminderKeys(), nil)
|
|
|
|
r.runUntil(at(2026, 10, 12, 16, 30))
|
|
wantKeys(t, "at 16:30", e.reminderKeys(), []string{"day_of_reminder:2026-10-12"})
|
|
p.wantReminder("day_of_reminder:2026-10-12", "Tonight: Beef Chili · Recipe →", "", "Beef Chili")
|
|
|
|
r.runUntil(at(2026, 10, 13, 23, 59))
|
|
wantKeys(t, "Tuesday", e.reminderKeys(), []string{"day_of_reminder:2026-10-12", "day_of_reminder:2026-10-13"})
|
|
p.wantReminder("day_of_reminder:2026-10-13", "Tonight: Pot Roast · Recipe →", "", "Pot Roast")
|
|
wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "2026-10-13"})
|
|
}
|
|
|
|
// TestDayOfReminderCrockPotNight: a crock-pot night whose start_by is
|
|
// earlier than reminder_time gets the start reminder at start_by minus 15
|
|
// minutes, keyed day_of_reminder:start:YYYY-MM-DD, and the daily reminder
|
|
// at reminder_time. A crock-pot night whose start_by is not earlier than
|
|
// reminder_time gets only the daily one.
|
|
func TestDayOfReminderCrockPotNight(t *testing.T) {
|
|
e := newEnv(t)
|
|
p := e.plans(e.pool())
|
|
p.crockPot("Beef Chili", 480) // Monday: start by 09:30
|
|
p.crockPot("Pot Roast", 30) // Tuesday: start by 17:00, after 16:30
|
|
p.planWeek(w42)
|
|
|
|
r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
|
|
r.runUntil(at(2026, 10, 12, 9, 14))
|
|
wantKeys(t, "before 09:15", e.reminderKeys(), nil)
|
|
|
|
r.runUntil(at(2026, 10, 12, 9, 15))
|
|
wantKeys(t, "at 09:15", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
|
|
p.wantReminder("day_of_reminder:start:2026-10-12", "Start the crock pot by 9:30 am", "Beef Chili", "Beef Chili")
|
|
|
|
r.runUntil(at(2026, 10, 12, 16, 29))
|
|
wantKeys(t, "before 16:30", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
|
|
r.runUntil(at(2026, 10, 12, 16, 30))
|
|
wantKeys(t, "at 16:30", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12"})
|
|
p.wantReminder("day_of_reminder:2026-10-12", "Tonight: Beef Chili · Recipe →", "", "Beef Chili")
|
|
|
|
r.runUntil(at(2026, 10, 13, 23, 59))
|
|
wantKeys(t, "Tuesday", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12", "day_of_reminder:2026-10-13"})
|
|
wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "2026-10-13", "start:2026-10-12"})
|
|
}
|
|
|
|
// TestDayOfReminderEmptyNight: with no plan for tonight's week, here none
|
|
// at all and then only next week's, nothing is emitted and nothing fails;
|
|
// next week's crock-pot Monday is reminded on its own day.
|
|
func TestDayOfReminderEmptyNight(t *testing.T) {
|
|
e := newEnv(t)
|
|
p := e.plans(e.pool())
|
|
|
|
r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
|
|
r.runUntil(at(2026, 10, 13, 23, 59))
|
|
wantKeys(t, "with no plan", e.reminderKeys(), nil)
|
|
|
|
p.crockPot("Beef Chili", 480)
|
|
p.planWeek(w43)
|
|
r.runUntil(at(2026, 10, 18, 23, 59))
|
|
wantKeys(t, "with only next week's plan", e.reminderKeys(), nil)
|
|
wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder),
|
|
[]string{"2026-10-11", "2026-10-12", "2026-10-13", "2026-10-14", "2026-10-15", "2026-10-16", "2026-10-17", "2026-10-18"})
|
|
if logs := p.logs.String(); !strings.Contains(logs, "day-of reminder not sent: the week has no plan") || strings.Contains(logs, "level=ERROR") {
|
|
t.Errorf("logs = %s, want the empty nights logged and no error", logs)
|
|
}
|
|
|
|
r.runUntil(at(2026, 10, 19, 9, 15))
|
|
wantKeys(t, "next Monday", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-19"})
|
|
p.wantReminder("day_of_reminder:start:2026-10-19", "Start the crock pot by 9:30 am", "Beef Chili", "Beef Chili")
|
|
}
|
|
|
|
// TestDayOfReminderFollowsReminderTimeWithoutRestart: a reminder_time
|
|
// change takes effect in the running scheduler. Moved from 16:30 to 18:00,
|
|
// the daily reminder fires at 18:00, not 16:30, and a crock-pot start_by
|
|
// of 17:00, now earlier than reminder_time, gets its start reminder at
|
|
// 16:45.
|
|
func TestDayOfReminderFollowsReminderTimeWithoutRestart(t *testing.T) {
|
|
e := newEnv(t)
|
|
p := e.plans(e.pool())
|
|
p.crockPot("Beef Chili", 30) // start by 17:00
|
|
p.planWeek(w42)
|
|
|
|
r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
|
|
e.update(household.SettingsPatch{ReminderTime: ptr("18:00")})
|
|
r.changed()
|
|
r.runUntil(at(2026, 10, 12, 16, 44))
|
|
wantKeys(t, "before 16:45", e.reminderKeys(), nil)
|
|
r.runUntil(at(2026, 10, 12, 16, 45))
|
|
wantKeys(t, "at 16:45", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
|
|
p.wantReminder("day_of_reminder:start:2026-10-12", "Start the crock pot by 5:00 pm", "Beef Chili", "Beef Chili")
|
|
r.runUntil(at(2026, 10, 12, 17, 59))
|
|
wantKeys(t, "before 18:00", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
|
|
r.runUntil(at(2026, 10, 12, 18, 0))
|
|
wantKeys(t, "at 18:00", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12"})
|
|
}
|
|
|
|
// TestDayOfReminderNoDuplicateAfterRestart: restarts after each reminder
|
|
// of a crock-pot night, within the catch-up window, emit neither again:
|
|
// each period is already claimed.
|
|
func TestDayOfReminderNoDuplicateAfterRestart(t *testing.T) {
|
|
e := newEnv(t)
|
|
ids := e.pool()
|
|
p := e.plans(ids)
|
|
p.crockPot("Beef Chili", 480)
|
|
p.planWeek(w42)
|
|
|
|
r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
|
|
r.runUntil(at(2026, 10, 12, 9, 15))
|
|
r.stop()
|
|
p.stop()
|
|
|
|
p2 := e.plans(ids)
|
|
r2 := e.start(at(2026, 10, 12, 9, 20), p2.svc.ReminderSchedules()...)
|
|
wantKeys(t, "after the first restart", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
|
|
r2.runUntil(at(2026, 10, 12, 16, 30))
|
|
r2.stop()
|
|
p2.stop()
|
|
|
|
p3 := e.plans(ids)
|
|
r3 := e.start(at(2026, 10, 12, 16, 40), p3.svc.ReminderSchedules()...)
|
|
r3.runUntil(at(2026, 10, 13, 9, 0))
|
|
wantKeys(t, "after the second restart", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12"})
|
|
wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "start:2026-10-12"})
|
|
}
|
|
|
|
// TestDailyAtLookupFailureIsRetried: a DailyAt rule fires at the instant
|
|
// its lookup gives, its period keyed by the schedule's Key and the date;
|
|
// a lookup that fails fires nothing and is looked up again after
|
|
// ClaimRetry, then fires its period once.
|
|
func TestDailyAtLookupFailureIsRetried(t *testing.T) {
|
|
e := newEnv(t)
|
|
var rec recorder
|
|
var mu sync.Mutex
|
|
failing := false
|
|
at915 := func(ctx context.Context, d store.LocalDate) (time.Time, bool, error) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
if failing {
|
|
return time.Time{}, false, errors.New("database down")
|
|
}
|
|
y, m, day := d.Date()
|
|
return at(y, m, day, 9, 15), true, nil
|
|
}
|
|
sch := scheduler.Schedule{
|
|
Name: scheduler.DayOfReminder,
|
|
Key: "start",
|
|
Rule: func(household.Settings) scheduler.Rule { return scheduler.DailyAt(at915) },
|
|
Run: rec.run,
|
|
}
|
|
|
|
r := e.start(at(2026, 10, 12, 8, 0), sch)
|
|
wantKeys(t, "catch-up", rec.keys(), []string{"start:2026-10-11"})
|
|
mu.Lock()
|
|
failing = true
|
|
mu.Unlock()
|
|
r.runUntil(at(2026, 10, 12, 9, 16))
|
|
wantKeys(t, "while the lookup fails", rec.keys(), []string{"start:2026-10-11"})
|
|
|
|
mu.Lock()
|
|
failing = false
|
|
mu.Unlock()
|
|
r.runUntil(at(2026, 10, 12, 9, 17))
|
|
wantKeys(t, "after the lookup recovers", rec.keys(), []string{"start:2026-10-11", "start:2026-10-12"})
|
|
if p := rec.periods()[1]; !p.FireAt.Equal(at(2026, 10, 12, 9, 15)) || p.Date.String() != "2026-10-12" {
|
|
t.Errorf("period = %+v, want fired at 09:15 for 2026-10-12", p)
|
|
}
|
|
r.runUntil(at(2026, 10, 13, 12, 0))
|
|
wantKeys(t, "next day", rec.keys(), []string{"start:2026-10-11", "start:2026-10-12", "start:2026-10-13"})
|
|
wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), rec.keys())
|
|
}
|
|
|
|
// questLog stores name as a Quest-log dinner, a crock-pot dinner of
|
|
// minutes, and returns its id. It is not a Regular.
|
|
func (p *planEnv) questLog(name string, minutes int) string {
|
|
p.e.t.Helper()
|
|
now := store.Now().String()
|
|
d, err := db.New(p.e.st.Writer).CreateDinner(context.Background(), db.CreateDinnerParams{
|
|
ID: store.NewID(),
|
|
Name: name,
|
|
NormalizedName: harness.Normalize(name),
|
|
Status: "quest_log",
|
|
Origin: "side_quest",
|
|
GroundingStatus: "manual",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
})
|
|
if err != nil {
|
|
p.e.t.Fatal(err)
|
|
}
|
|
p.ids[name] = d.ID
|
|
p.crockPot(name, minutes)
|
|
return d.ID
|
|
}
|
|
|
|
// TestStartReminderAfterSwapFiresOnTime: swapping a crock-pot dinner in
|
|
// for tonight wakes the scheduler, so its start reminder fires at start_by
|
|
// minus 15 minutes, 09:15, and not at the next hourly check, 10:00. At
|
|
// 09:00 tonight is Beef Chili, not a crock-pot dinner, and the scheduler's
|
|
// next timer is 10:00; at 09:01 the household swaps in an eight-hour
|
|
// crock-pot Quest-log dinner, start by 09:30. Each reminder fires once.
|
|
func TestStartReminderAfterSwapFiresOnTime(t *testing.T) {
|
|
e := newEnv(t)
|
|
p := e.wakingPlans(e.pool())
|
|
stew := p.questLog("Crock Pot Stew", 480) // start by 09:30
|
|
p.planWeek(w42)
|
|
|
|
r := e.start(at(2026, 10, 12, 8, 0), p.svc.ReminderSchedules()...)
|
|
r.runUntil(at(2026, 10, 12, 9, 0))
|
|
if next, _ := r.clock.nextDeadline(); !next.Equal(at(2026, 10, 12, 10, 0)) {
|
|
t.Fatalf("next wake at 09:00 = %s, want the hourly 10:00", next)
|
|
}
|
|
|
|
r.runUntil(at(2026, 10, 12, 9, 1))
|
|
if _, err := p.svc.Swap(context.Background(), w42, "2026-10-12", stew); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.changed()
|
|
r.runUntil(at(2026, 10, 12, 9, 14))
|
|
wantKeys(t, "before 09:15", e.reminderKeys(), nil)
|
|
|
|
r.runUntil(at(2026, 10, 12, 9, 15))
|
|
wantKeys(t, "at 09:15", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12"})
|
|
p.wantReminder("day_of_reminder:start:2026-10-12", "Start the crock pot by 9:30 am", "Crock Pot Stew", "Crock Pot Stew")
|
|
|
|
r.runUntil(at(2026, 10, 13, 23, 59))
|
|
wantKeys(t, "Tuesday", e.reminderKeys(), []string{"day_of_reminder:start:2026-10-12", "day_of_reminder:2026-10-12", "day_of_reminder:2026-10-13"})
|
|
p.wantReminder("day_of_reminder:2026-10-12", "Tonight: Crock Pot Stew · Recipe →", "", "Crock Pot Stew")
|
|
wantKeys(t, "schedule_runs", e.claimed(scheduler.DayOfReminder), []string{"2026-10-11", "2026-10-12", "2026-10-13", "start:2026-10-12"})
|
|
}
|