diff options
Diffstat (limited to 'internal/handlers/widget_test.go')
| -rw-r--r-- | internal/handlers/widget_test.go | 110 |
1 files changed, 89 insertions, 21 deletions
diff --git a/internal/handlers/widget_test.go b/internal/handlers/widget_test.go index 749af3a..2bb92bc 100644 --- a/internal/handlers/widget_test.go +++ b/internal/handlers/widget_test.go @@ -123,7 +123,7 @@ func TestTimelineItemToWidgetItem_Task(t *testing.T) { Source: "doot", Type: models.TimelineItemTypeTask, Time: now, - IsAllDay: true, + IsAllDay: true, // dated task: doot due dates are always midnight-anchored URL: "https://example.com/task/abc", } @@ -138,8 +138,13 @@ func TestTimelineItemToWidgetItem_Task(t *testing.T) { if !wi.Completable { t.Error("doot task should be completable") } - if wi.Start != nil { - t.Error("all-day item should have nil Start") + // A dated task (Undated defaults false) must get Start populated even + // though IsAllDay is true -- see the 2026-08-10 fix in + // TimelineItemToWidgetItem's doc comment. Only genuinely undated tasks + // (Undated: true, see TestTimelineItemToWidgetItem_AllDayTask_KeepsFloatingBehavior) + // keep nil Start. + if wi.Start == nil { + t.Error("dated task should have Start populated, not nil") } } @@ -235,12 +240,13 @@ func TestTimelineItemToWidgetItem_MultiDayAllDayEvent_ForwardsEnd(t *testing.T) } } -// TestTimelineItemToWidgetItem_AllDayTask_KeepsFloatingBehavior proves the -// same fix does NOT change behavior for undated doot/gtask tasks, which are -// also flagged IsAllDay as a "no specific time" fallback (see -// TimelineItem.ComputeDaySection) but are a different concept from a real -// all-day calendar event -- they must keep the existing nil-Start -// "floating" treatment so the hourly-slot packer still places them. +// TestTimelineItemToWidgetItem_AllDayTask_KeepsFloatingBehavior proves a +// genuinely undated doot/gtask task (Undated: true, matching how +// timeline_logic.go's nativeUndated/gtask-no-due-date branches actually +// construct it) keeps the existing nil-Start "floating" treatment so the +// hourly-slot packer still places them -- unlike a dated-but-midnight- +// anchored task, which now gets Start populated (see +// TestTimelineItemToWidgetItem_DootTaskGetsDueDate). func TestTimelineItemToWidgetItem_AllDayTask_KeepsFloatingBehavior(t *testing.T) { item := models.TimelineItem{ ID: "undated-task", @@ -249,12 +255,13 @@ func TestTimelineItemToWidgetItem_AllDayTask_KeepsFloatingBehavior(t *testing.T) Type: models.TimelineItemTypeTask, Time: time.Now(), IsAllDay: true, + Undated: true, } wi := TimelineItemToWidgetItem(item) if wi.Start != nil { - t.Error("an undated task (IsAllDay as a fallback, not a real all-day event) should still have nil Start") + t.Error("a genuinely undated task should still have nil Start") } } @@ -300,12 +307,17 @@ func TestTimelineItemToWidgetItem_NotOverdueByDefault(t *testing.T) { // TestTimelineItemToWidgetItem_DootTaskGetsDueDate proves the 2026-07-12 // clickable-reschedule fix: a doot task's raw due date must reach the -// client via a NEW field (DueDate) that is independent of Start/IsAllDay -- -// Start is deliberately left nil for doot tasks (see -// TestTimelineItemToWidgetItem_AllDayTask_KeepsFloatingBehavior) so the -// client's floating-task SlotPacker can position it, and that must keep -// working unchanged. Before this fix there was no way for the Android -// detail popup to know a doot task's current due date at all. +// client via DueDate, independent of Start, so the Android detail popup can +// display/reschedule it. +// +// Start assertion updated 2026-08-10: this used to assert Start stayed +// nil "so the client's floating-task SlotPacker can position it" -- that +// was the bug. A dated task (Undated: false, the default -- this item +// isn't undated, it has a real due date) dumped into the same undated/ +// floating pool as genuinely dateless tasks, which has zero day-awareness +// on the Android client (DootWidget.kt's `floating` list), so a task due +// tomorrow rendered as if due today. Start must now be populated so the +// client's existing day-bucketing (keyed off Start) actually runs for it. func TestTimelineItemToWidgetItem_DootTaskGetsDueDate(t *testing.T) { due := time.Date(2026, 7, 15, 0, 0, 0, 0, time.Local) item := models.TimelineItem{ @@ -314,7 +326,7 @@ func TestTimelineItemToWidgetItem_DootTaskGetsDueDate(t *testing.T) { Source: "doot", Type: models.TimelineItemTypeTask, Time: due, - IsAllDay: true, + IsAllDay: true, // doot due dates are always midnight-anchored, dated or not } wi := TimelineItemToWidgetItem(item) @@ -325,10 +337,63 @@ func TestTimelineItemToWidgetItem_DootTaskGetsDueDate(t *testing.T) { if !wi.DueDate.Equal(due) { t.Errorf("DueDate = %v, want %v", *wi.DueDate, due) } - // Start must stay nil -- this is the pre-existing floating-task - // behavior and this feature must not change it. + if wi.Start == nil { + t.Fatal("expected Start to be set for a dated task, so Android can day-bucket it correctly") + } + if !wi.Start.Equal(due) { + t.Errorf("Start = %v, want %v", *wi.Start, due) + } +} + +// TestTimelineItemToWidgetItem_DatedGTaskGetsStart proves the same fix for +// Google Tasks, which have the identical always-midnight-anchored due date +// quirk (see reference_google_tasks_due_date_utc_quirk) -- a dated gtask +// (Undated: false) must also get Start populated, not just doot tasks. +func TestTimelineItemToWidgetItem_DatedGTaskGetsStart(t *testing.T) { + due := time.Date(2026, 7, 15, 0, 0, 0, 0, time.Local) + item := models.TimelineItem{ + ID: "gtask-1", + Title: "Renew passport", + Source: "gtasks", + Type: models.TimelineItemTypeGTask, + Time: due, + IsAllDay: true, + } + + wi := TimelineItemToWidgetItem(item) + + if wi.Start == nil { + t.Fatal("expected Start to be set for a dated gtask") + } + if !wi.Start.Equal(due) { + t.Errorf("Start = %v, want %v", *wi.Start, due) + } +} + +// TestTimelineItemToWidgetItem_UndatedTaskWithPlaceholderTime_NilDueDate +// proves the 2026-08-10 companion fix: nativeUndated tasks construct their +// TimelineItem with Time=now (a layout placeholder, not a real due date -- +// see timeline_logic.go), not a zero Time. DueDate must guard on Undated, +// not just !Time.IsZero(), or an undated task's detail popup would show a +// fabricated "due" date of whatever moment the request happened to run. +func TestTimelineItemToWidgetItem_UndatedTaskWithPlaceholderTime_NilDueDate(t *testing.T) { + item := models.TimelineItem{ + ID: "doot-undated-2", + Title: "Someday task", + Source: "doot", + Type: models.TimelineItemTypeTask, + Time: time.Now(), // the real placeholder value nativeUndated actually uses + IsAllDay: true, + Undated: true, + } + + wi := TimelineItemToWidgetItem(item) + + if wi.DueDate != nil { + t.Error("expected DueDate to be nil for an undated task, even though Time is non-zero") + } if wi.Start != nil { - t.Error("Start must remain nil for a doot task -- DueDate is a separate field, not a replacement") + t.Error("expected Start to be nil for an undated task") } } @@ -340,9 +405,12 @@ func TestTimelineItemToWidgetItem_UndatedDootTask_NilDueDate(t *testing.T) { Type: models.TimelineItemTypeTask, Time: time.Now(), IsAllDay: true, + Undated: true, } // Zero Time simulates the "no real due date" case at the field level; - // TimelineItemToWidgetItem's DueDate logic must guard on !Time.IsZero(). + // TimelineItemToWidgetItem's DueDate logic must guard on !Time.IsZero() + // (see TestTimelineItemToWidgetItem_UndatedTaskWithPlaceholderTime_NilDueDate + // for the realistic non-zero-placeholder-Time case). item.Time = time.Time{} wi := TimelineItemToWidgetItem(item) |