Give each event its own page and show bodies the same everywhere (closes #369)

Each row of the recent events on the webhook page links to the
event's own page, /hook/{id}/events/{eventID}, and expands to show its
body; only the newest starts expanded. The event's page shows its
details, its whole body and every delivery with its attempts.

One renderer, newBodyView with templates/event_body.html, shows a body
in all three places: whole up to 32 KiB, cut there in the lists with a
link to the event's page, JSON pretty-printed, a body of more than 200
lines or 32 KiB in a scrolling box, and a body that is not text left
out beside its download link. A resubmitted copy links to its
original's page.

Model: opus-5-5

internal/handlers/event_log_view_test.go

@@ -16,7 +16,7 @@ import (
 	"sneak.berlin/go/webhooker/internal/session"
 )
 
-// bodyCap is the number of body bytes the event log page is
+// bodyCap is the number of body bytes the lists of events are
 // allowed to render for one event.
 const bodyCap = handlers.MaxRenderedBodyBytesForTest
 
@@ -85,7 +85,7 @@ func seedAndProject(
 
 // TestHandleSourceLogs_BoundsOversizeBody proves the rendered
 // page is bounded by the cap rather than by the stored payload:
-// the body here is 64 times the cap, and the ingest path would
+// the body here is 16 times the cap, and the ingest path would
 // accept twice as much again.
 func TestHandleSourceLogs_BoundsOversizeBody(t *testing.T) {
 	t.Parallel()
@@ -123,7 +123,7 @@ func TestHandleSourceLogs_BoundsOversizeBody(t *testing.T) {
 	// The marker states the true stored size, not the cut one.
 	assert.Contains(
 		t, page,
-		"showing "+strconv.Itoa(bodyCap)+
+		"Showing the first "+strconv.Itoa(bodyCap)+
 			" of "+strconv.Itoa(storedBytes)+" bytes",
 	)
 }
@@ -152,34 +152,35 @@ func TestHandleSourceLogs_SmallBodyRendersWhole(t *testing.T) {
 	page := renderSourceLogsPage(t, h, sess, wh.ID)
 
 	assert.Contains(t, page, ""kept"")
-	assert.NotContains(t, page, "Body truncated for display")
+	assert.NotContains(t, page, "Showing the first")
 }
 
 // TestEventLogView_CutMidRune proves a multi-byte rune severed
 // by the byte-wise cut is dropped rather than surfaced as a
-// mojibake tail.
+// mojibake tail, which would also make the text look binary.
 func TestEventLogView_CutMidRune(t *testing.T) {
 	t.Parallel()
 
-	body := strings.Repeat(snowman, 4096)
+	body := strings.Repeat(snowman, bodyCap)
 	view := seedAndProject(t, body)
 
 	// bodyCap bytes hold bodyCap/3 whole snowmen and two bytes
 	// of the next one; those two are dropped.
 	whole := bodyCap / len(snowman)
 
-	assert.True(t, view.BodyTruncated)
-	assert.Equal(t, int64(len(body)), view.BodyBytes)
-	assert.Equal(t, strings.Repeat(snowman, whole), view.Body)
-	assert.True(t, utf8.ValidString(view.Body))
-	assert.LessOrEqual(t, len(view.Body), bodyCap)
+	assert.True(t, view.Body.Cut)
+	assert.False(t, view.Body.Binary)
+	assert.Equal(t, int64(len(body)), view.Body.Size)
+	assert.Equal(t, strings.Repeat(snowman, whole), view.Body.Text)
+	assert.True(t, utf8.ValidString(view.Body.Text))
+	assert.Equal(t, len(view.Body.Text), view.Body.ShownBytes)
+	assert.LessOrEqual(t, view.Body.ShownBytes, bodyCap)
 }
 
-// TestEventLogView_BinaryBodyLeftAsStored proves a binary
-// payload is passed through byte for byte. Its tail is invalid
-// UTF-8 however the cut falls, so repairing it would misreport
-// what the sender delivered.
-func TestEventLogView_BinaryBodyLeftAsStored(t *testing.T) {
+// TestEventLogView_BinaryBodyNotShown proves a body that is not
+// text is left out rather than shown as replacement characters,
+// whether it is cut or not.
+func TestEventLogView_BinaryBodyNotShown(t *testing.T) {
 	t.Parallel()
 
 	raw := make([]byte, bodyCap+808)
@@ -188,12 +189,21 @@ func TestEventLogView_BinaryBodyLeftAsStored(t *testing.T) {
 		raw[i] = 0x80 | byte(i%0x40)
 	}
 
-	view := seedAndProject(t, string(raw))
+	for name, body := range map[string][]byte{
+		"cut":   raw,
+		"whole": raw[:2048],
+		"NUL":   []byte("text\x00text"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
 
-	assert.True(t, view.BodyTruncated)
-	assert.Equal(t, int64(len(raw)), view.BodyBytes)
-	assert.Equal(t, string(raw[:bodyCap]), view.Body)
-	assert.False(t, utf8.ValidString(view.Body))
+			view := seedAndProject(t, string(body))
+
+			assert.True(t, view.Body.Binary)
+			assert.Empty(t, view.Body.Text)
+			assert.Equal(t, int64(len(body)), view.Body.Size)
+		})
+	}
 }
 
 // TestTrimPartialRune covers the distinction the cut repair