Deploy main eacf1e7 to prod

Replaces #559, which conflicted. Model: opus-5-5
2026-10-25 01:55:36 +00:00
parent 1647b43aa6
commit 537374e4cc
311 changed files with 35614 additions and 14120 deletions
@@ -1,8 +1,10 @@
 package handlers_test

 import (
+	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"

 	"github.com/stretchr/testify/assert"
@@ -10,7 +12,6 @@ import (
 	"gorm.io/gorm"
 	"gorm.io/gorm/clause"
 	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/delivery"
 	"sneak.berlin/go/webhooker/internal/handlers"
 	"sneak.berlin/go/webhooker/internal/session"
 )
@@ -21,9 +22,12 @@ const paramDeliveryID = "deliveryID"

 // replayTargetURL is a public destination, so a target configured with
 // it is one the SSRF guard would accept. Nothing in these tests
-// dispatches to it: the notifier is recorded, not run.
+// dispatches to it: the delivery engine is never started.
 const replayTargetURL = "http://93.184.216.34/hook"

+// replayEventQuery is the query string a seeded event arrived with.
+const replayEventQuery = "a=1&b=2"
+
 // seedFailedDelivery records an event, a terminally failed delivery of
 // it to the given target, and the attempt that failed.
 func seedFailedDelivery(
@@ -40,6 +44,7 @@ func seedFailedDelivery(
 		WebhookID:    webhookID,
 		EntrypointID: "entrypoint-" + webhookID,
 		Method:       http.MethodPost,
+		RawQuery:     replayEventQuery,
 		Headers:      `{"X-Test":["yes"]}`,
 		Body:         `{"replay":"me"}`,
 		ContentType:  contentTypeJSON,
@@ -138,7 +143,7 @@ func postReplay(
 	t.Helper()

 	req := postRequest(
-		"/source/"+webhookID+"/deliveries/"+
+		"/hook/"+webhookID+"/deliveries/"+
 			deliveryID+"/replay",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
@@ -157,14 +162,8 @@ func postReplay(

 // TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal is the
 // core requirement: replaying a failed delivery succeeds, appends a
-// new delivery, and leaves the original row and its recorded attempt
-// exactly as they were.
-//
-// It also pins the two things a replay would be wrong to get from the
-// original: the task carries the target's CURRENT configuration, which
-// this test changes between the failure and the replay, and it carries
-// the stored EVENT body rather than anything the failed attempt
-// received back.
+// new delivery marked as a replay, and leaves the original row and its
+// recorded attempt exactly as they were.
 func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(
 	t *testing.T,
 ) {
@@ -175,10 +174,9 @@ func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(
 		sess  *session.Session
 		db    *database.Database
 		dbMgr *database.WebhookDBManager
-		notif *recordingNotifier
 	)

-	app := newTestApp(t, &h, &sess, &db, &dbMgr, &notif)
+	app := newTestApp(t, &h, &sess, &db, &dbMgr)
 	app.RequireStart()

 	t.Cleanup(app.RequireStop)
@@ -186,7 +184,7 @@ func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(
 	wh := seedWebhook(t, db)
 	tgt := seedConfiguredTarget(
 		t, db, wh.ID, database.TargetTypeHTTP,
-		`{"url":"`+replayTargetURL+`"}`,
+		database.Target{URL: replayTargetURL},
 	)

 	event, original := seedFailedDelivery(
@@ -198,21 +196,12 @@ func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(

 	before := loadDelivery(t, webhookDB, original.ID)

-	// The operator fixes the destination, which is the whole reason
-	// to replay. The replay must use this, not the config the
-	// original delivery ran against.
-	const fixedConfig = `{"url":"http://93.184.216.34/fixed"}`
-
-	require.NoError(t, db.DB().Model(&database.Target{}).
-		Where("id = ?", tgt.ID).
-		Update("config", fixedConfig).Error)
-
 	w := postReplay(t, h, sess, wh.ID, original.ID)

 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=queued",
+		"/hook/"+wh.ID+"/events?notice=replay-queued",
 		w.Header().Get("Location"),
 	)

@@ -228,14 +217,9 @@ func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(
 	assert.Equal(
 		t, database.DeliveryStatusPending, replayed.Status,
 	)
+	assert.True(t, replayed.Replay)

 	assertDeliveryUntouched(t, webhookDB, before)
-
-	tasks := notif.Tasks()
-	require.Len(t, tasks, 1)
-	assertReplayTask(
-		t, tasks[0], wh.ID, event, tgt, replayed.ID, fixedConfig,
-	)
 	assertNoLeakedTarget(t, webhookDB)
 }

@@ -269,63 +253,62 @@ func assertDeliveryUntouched(
 	)
 }

-// assertReplayTask proves the task handed to the delivery engine is
-// the one the receiver would build for this event and this target, and
-// that it carries wantConfig — the target's configuration as it stands
-// now rather than as the original delivery ran against it.
-func assertReplayTask(
-	t *testing.T,
-	task delivery.Task,
-	webhookID string,
-	event *database.Event,
-	target *database.Target,
-	wantDeliveryID, wantConfig string,
-) {
-	t.Helper()
-
-	assert.Equal(t, wantDeliveryID, task.DeliveryID)
-	assert.Equal(t, event.ID, task.EventID)
-	assert.Equal(t, webhookID, task.WebhookID)
-	assert.Equal(t, event.EntrypointID, task.EntrypointID)
-	assert.Equal(t, target.ID, task.TargetID)
-	assert.Equal(t, target.Type, task.TargetType)
-	assert.JSONEq(
-		t, wantConfig, task.TargetConfig,
-		"replay must use the target's current configuration",
-	)
-	assert.Equal(t, event.Method, task.Method)
-	assert.Equal(t, event.Headers, task.Headers)
-	assert.Equal(t, event.ContentType, task.ContentType)
-	assert.Equal(t, 1, task.AttemptNum)
-	require.NotNil(t, task.Body)
-	assert.Equal(
-		t, event.Body, *task.Body,
-		"replay re-sends the stored event body",
-	)
-}
-
-// assertNoLeakedTarget proves the per-webhook database holds no target
-// rows. AutoMigrate creates the table there because Delivery declares
-// the relation, so it is a ROW that signals a leak: an association
-// write would have upserted the whole target, plaintext config and
-// all, into the event database. See
+// assertNoLeakedTarget proves the per-webhook database holds no
+// target: an association write would have upserted the whole target,
+// plaintext config and all, into the event database. See
 // https://git.eeqj.de/sneak/webhooker/issues/206.
 func assertNoLeakedTarget(t *testing.T, webhookDB *gorm.DB) {
 	t.Helper()

-	var leaked int64
-
-	require.NoError(t, webhookDB.Unscoped().
-		Model(&database.Target{}).Count(&leaked).Error)
-	assert.Zero(
-		t, leaked,
+	assert.False(
+		t, webhookDB.Migrator().HasTable(&database.Target{}),
 		"replay must not write the target into the event database",
 	)
 }

+// TestHandleDeliveryReplay_FailedStoreIsAnError proves a replay the
+// engine cannot store answers with the 500 error page and adds no
+// delivery.
+func TestHandleDeliveryReplay_FailedStoreIsAnError(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h     *handlers.Handlers
+		sess  *session.Session
+		db    *database.Database
+		dbMgr *database.WebhookDBManager
+	)
+
+	app := newTestApp(t, &h, &sess, &db, &dbMgr)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	wh := seedWebhook(t, db)
+	tgt := seedConfiguredTarget(
+		t, db, wh.ID, database.TargetTypeHTTP,
+		database.Target{URL: replayTargetURL},
+	)
+
+	event, original := seedFailedDelivery(t, dbMgr, wh.ID, tgt.ID)
+
+	// Without its target totals table the webhook's database refuses
+	// the totals write, which comes after the delivery row.
+	webhookDB, err := dbMgr.GetDB(wh.ID)
+	require.NoError(t, err)
+	require.NoError(t,
+		webhookDB.Migrator().DropTable(&database.TargetTotals{}))
+
+	w := postReplay(t, h, sess, wh.ID, original.ID)
+
+	assert.Equal(t, http.StatusInternalServerError, w.Code)
+	assert.Contains(t, w.Body.String(), "500 Internal Server Error")
+	assert.Len(t, listDeliveries(t, webhookDB, event.ID), 1)
+}
+
 // TestHandleDeliveryReplay_RefusesDeletedTarget proves the required
 // refusal: a target deleted since the delivery ran is reported as
-// deleted rather than erroring, and nothing is created or queued.
+// deleted rather than erroring, and nothing is created.
 func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	t.Parallel()

@@ -334,10 +317,9 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 		sess  *session.Session
 		db    *database.Database
 		dbMgr *database.WebhookDBManager
-		notif *recordingNotifier
 	)

-	app := newTestApp(t, &h, &sess, &db, &dbMgr, &notif)
+	app := newTestApp(t, &h, &sess, &db, &dbMgr)
 	app.RequireStart()

 	t.Cleanup(app.RequireStop)
@@ -345,7 +327,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	wh := seedWebhook(t, db)
 	tgt := seedConfiguredTarget(
 		t, db, wh.ID, database.TargetTypeHTTP,
-		`{"url":"`+replayTargetURL+`"}`,
+		database.Target{URL: replayTargetURL},
 	)

 	event, original := seedFailedDelivery(
@@ -362,7 +344,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=target-deleted",
+		"/hook/"+wh.ID+"/events?notice=replay-target-deleted",
 		w.Header().Get("Location"),
 	)

@@ -373,10 +355,6 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 		t, listDeliveries(t, webhookDB, event.ID), 1,
 		"a refused replay must create no delivery",
 	)
-	assert.Empty(
-		t, notif.Tasks(),
-		"a refused replay must queue nothing",
-	)

 	// The refusal is specific, which is why the target is looked up
 	// including soft-deleted rows: an id that never named a target
@@ -390,7 +368,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, missing.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=target-missing",
+		"/hook/"+wh.ID+"/events?notice=replay-target-missing",
 		missing.Header().Get("Location"),
 	)
 }
@@ -409,10 +387,9 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 		sess  *session.Session
 		db    *database.Database
 		dbMgr *database.WebhookDBManager
-		notif *recordingNotifier
 	)

-	app := newTestApp(t, &h, &sess, &db, &dbMgr, &notif)
+	app := newTestApp(t, &h, &sess, &db, &dbMgr)
 	app.RequireStart()

 	t.Cleanup(app.RequireStop)
@@ -420,7 +397,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	wh := seedWebhook(t, db)
 	tgt := seedConfiguredTarget(
 		t, db, wh.ID, database.TargetTypeHTTP,
-		`{"url":"`+replayTargetURL+`"}`,
+		database.Target{URL: replayTargetURL},
 	)

 	event, original := seedFailedDelivery(
@@ -431,7 +408,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, first.Code)
 	require.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=queued",
+		"/hook/"+wh.ID+"/events?notice=replay-queued",
 		first.Header().Get("Location"),
 	)

@@ -439,7 +416,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, second.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=in-flight",
+		"/hook/"+wh.ID+"/events?notice=replay-in-flight",
 		second.Header().Get("Location"),
 	)

@@ -450,10 +427,6 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 		t, listDeliveries(t, webhookDB, event.ID), 2,
 		"the refused second replay must add nothing",
 	)
-	assert.Len(
-		t, notif.Tasks(), 1,
-		"only the first replay reaches the delivery engine",
-	)

 	// A delivery the engine has not finished is not replayable
 	// either, which is the same rule seen from the other side.
@@ -465,11 +438,71 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, pending.Code)
 	assert.Equal(
 		t,
-		"/source/"+wh.ID+"/logs?replay=not-terminal",
+		"/hook/"+wh.ID+"/events?notice=replay-not-terminal",
 		pending.Header().Get("Location"),
 	)
 }

+// TestHandleDeliveryReplay_ReturnsToTheListItWasPressedIn proves a
+// Replay pressed in the Failed list carries that list in its form and
+// returns to it, and that a show value the event log does not know
+// returns to the full log.
+func TestHandleDeliveryReplay_ReturnsToTheListItWasPressedIn(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	var (
+		h     *handlers.Handlers
+		sess  *session.Session
+		db    *database.Database
+		dbMgr *database.WebhookDBManager
+	)
+
+	app := newTestApp(t, &h, &sess, &db, &dbMgr)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	wh := seedWebhook(t, db)
+	tgt := seedConfiguredTarget(
+		t, db, wh.ID, database.TargetTypeHTTP,
+		database.Target{URL: replayTargetURL},
+	)
+
+	_, original := seedFailedDelivery(t, dbMgr, wh.ID, tgt.ID)
+
+	assert.Contains(t, renderSourceLogsPageWithQuery(
+		t, h, sess, wh.ID, "?show=failed",
+	), `name="show" value="failed"`)
+
+	// The second replay is refused, as the first is still queued.
+	for _, tc := range []struct{ show, location string }{
+		{"failed", "/hook/" + wh.ID +
+			"/events?notice=replay-queued&show=failed"},
+		{"made-up", "/hook/" + wh.ID + "/events?notice=replay-in-flight"},
+	} {
+		req := postRequest(
+			"/hook/"+wh.ID+"/deliveries/"+original.ID+"/replay",
+			authenticatedCookies(
+				t, sess, deleteTestUserID, deleteTestUsername,
+			),
+			map[string]string{
+				paramSourceID:   wh.ID,
+				paramDeliveryID: original.ID,
+			},
+		)
+		req.Body = io.NopCloser(strings.NewReader("show=" + tc.show))
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+		w := httptest.NewRecorder()
+		h.HandleDeliveryReplay().ServeHTTP(w, req)
+
+		require.Equal(t, http.StatusSeeOther, w.Code, tc.show)
+		assert.Equal(t, tc.location, w.Header().Get("Location"), tc.show)
+	}
+}
+
 // TestHandleSourceLogs_RendersReplayControlAndBanner proves the action
 // reaches the page it belongs on: a finished delivery renders a POST
 // form carrying a CSRF token, and the outcome code a refusal redirects
@@ -492,7 +525,7 @@ func TestHandleSourceLogs_RendersReplayControlAndBanner(t *testing.T) {
 	wh := seedWebhook(t, db)
 	tgt := seedConfiguredTarget(
 		t, db, wh.ID, database.TargetTypeHTTP,
-		`{"url":"`+replayTargetURL+`"}`,
+		database.Target{URL: replayTargetURL},
 	)

 	_, original := seedFailedDelivery(t, dbMgr, wh.ID, tgt.ID)
@@ -501,7 +534,7 @@ func TestHandleSourceLogs_RendersReplayControlAndBanner(t *testing.T) {

 	assert.Contains(
 		t, body,
-		`action="/source/`+wh.ID+`/deliveries/`+
+		`action="/hook/`+wh.ID+`/deliveries/`+
 			original.ID+`/replay"`,
 	)
 	assert.Contains(t, body, `method="POST"`)
@@ -509,18 +542,77 @@ func TestHandleSourceLogs_RendersReplayControlAndBanner(t *testing.T) {
 	assert.Contains(t, body, ">Replay<")

 	refused := renderSourceLogsPageWithQuery(
-		t, h, sess, wh.ID, "?replay=target-deleted",
+		t, h, sess, wh.ID, "?notice=replay-target-deleted",
 	)

 	assert.Contains(t, refused, "alert-error")
-	assert.Contains(t, refused, "has been deleted")
+	assert.Contains(
+		t, refused,
+		"has been deleted. Use Resubmit to send the event "+
+			"to the webhook",
+	)

 	// An outcome code nobody issued renders no banner at all.
 	unknown := renderSourceLogsPageWithQuery(
-		t, h, sess, wh.ID, "?replay=made-up",
+		t, h, sess, wh.ID, "?notice=made-up",
 	)

 	assert.NotContains(t, unknown, "alert-error")
 	assert.NotContains(t, unknown, "alert-success")
 	assert.NotContains(t, unknown, "made-up")
 }
+
+// TestHandleDeliveryReplay_LabelsTheReplay proves a delivery created
+// by Replay is labelled as a replay in the event's summary line in the
+// event log, and in the list of the event's deliveries there and on
+// the event's page, while the delivery it repeats is not.
+func TestHandleDeliveryReplay_LabelsTheReplay(t *testing.T) {
+	t.Parallel()
+
+	var (
+		h     *handlers.Handlers
+		sess  *session.Session
+		db    *database.Database
+		dbMgr *database.WebhookDBManager
+	)
+
+	app := newTestApp(t, &h, &sess, &db, &dbMgr)
+	app.RequireStart()
+
+	t.Cleanup(app.RequireStop)
+
+	wh := seedWebhook(t, db)
+	tgt := seedConfiguredTarget(
+		t, db, wh.ID, database.TargetTypeHTTP,
+		database.Target{URL: replayTargetURL},
+	)
+
+	event, original := seedFailedDelivery(t, dbMgr, wh.ID, tgt.ID)
+
+	w := postReplay(t, h, sess, wh.ID, original.ID)
+	require.Equal(t, http.StatusSeeOther, w.Code)
+
+	eventLog := renderSourceLogsPage(t, h, sess, wh.ID)
+
+	assert.Contains(t, eventLog, tgt.Name+": failed")
+	assert.Contains(t, eventLog, tgt.Name+" (replay): pending")
+
+	w = serveEventPage(t, h, sess, wh.ID, event.ID)
+	require.Equal(t, http.StatusOK, w.Code)
+
+	// In each delivery list a row names the target, then the label if
+	// it is a replay, then its status: the replay is still pending, the
+	// original failed.
+	replayRow := tgt.Name + `</span> ` +
+		`<span class="text-xs text-gray-500">replay</span> ` +
+		`<span class="text-xs text-gray-400">pending</span>`
+	originalRow := tgt.Name + `</span> ` +
+		`<span class="text-xs text-red-600">failed</span>`
+
+	for _, page := range []string{eventLog, w.Body.String()} {
+		page = strings.Join(strings.Fields(page), " ")
+
+		assert.Contains(t, page, replayRow)
+		assert.Contains(t, page, originalRow)
+	}
+}