Name each database target's archive for its webhook and target (closes #376)

Each database target now writes its own archive file, archive-WEBHOOKNAME-TARGETNAME-TARGETID.db, named by delivery.ArchiveFileName, in place of one archive per webhook keyed on its UUID. Renaming a webhook or a target renames its archive files (with any -wal and -shm) before the new name is saved, never over an existing file, and moves every one back if a rename or the save fails. The webhook edit, the target edit and target creation share one lock so no two interleave. Deleting a webhook or target leaves its files on disk. Nothing looks for the old archive-WEBHOOKID.db files. The README gives the naming and the recovery steps.

Model: opus-5-5

internal/handlers/handlers_test.go

@@ -3,6 +3,7 @@ package handlers_test
 import (
 	"context"
 	"errors"
+	"fmt"
 	"html/template"
 	"net/http"
 	"net/http/httptest"
@@ -52,23 +53,103 @@ func (n *recordingNotifier) Tasks() []delivery.Task {
 	return out
 }
 
-// recordingEvictor is a delivery.WebhookEvictor that records
-// the webhook ids it was asked to evict, so a test can prove
-// that a deletion path reached the delivery engine.
-type recordingEvictor struct {
-	mu      sync.Mutex
-	evicted []string
+// recordingArchives is a delivery.Archives that records what it
+// was asked to do, so a test can prove that a deletion or rename
+// path reached the delivery engine. After FailRenames, every
+// rename of that target fails with the given error. After
+// BlockNextRename, the next rename is recorded and then waits.
+type recordingArchives struct {
+	mu             sync.Mutex
+	evicted        []string
+	evictedTargets []string
+	renames        []archiveRename
+	renameErrs     map[string]error
+	entered        chan struct{}
+	release        chan struct{}
 }
 
-func (r *recordingEvictor) EvictWebhook(webhookID string) {
+// errInjectedRename is the failure a test hands FailRenames.
+var errInjectedRename = errors.New("injected rename failure")
+
+// errNameTaken is what the delivery engine returns when a file
+// already has an archive's new name, here archive-taken.db.
+var errNameTaken = fmt.Errorf(
+	"%w: archive-taken.db", delivery.ErrArchiveNameTaken,
+)
+
+// archiveRename is one recorded Rename call.
+type archiveRename struct {
+	TargetID    string
+	WebhookName string
+	TargetName  string
+}
+
+func (r *recordingArchives) EvictWebhook(webhookID string) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
 	r.evicted = append(r.evicted, webhookID)
 }
 
+func (r *recordingArchives) EvictTarget(targetID string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	r.evictedTargets = append(r.evictedTargets, targetID)
+}
+
+func (r *recordingArchives) Rename(
+	targetID, webhookName, targetName string,
+) error {
+	r.mu.Lock()
+
+	r.renames = append(r.renames, archiveRename{
+		TargetID:    targetID,
+		WebhookName: webhookName,
+		TargetName:  targetName,
+	})
+	err := r.renameErrs[targetID]
+	entered, release := r.entered, r.release
+	r.entered, r.release = nil, nil
+
+	r.mu.Unlock()
+
+	if entered != nil {
+		close(entered)
+		<-release
+	}
+
+	return err
+}
+
+// BlockNextRename makes the next rename, once recorded, wait until
+// the returned release is called. The returned channel is closed
+// when that rename starts waiting.
+func (r *recordingArchives) BlockNextRename() (<-chan struct{}, func()) {
+	entered := make(chan struct{})
+	release := make(chan struct{})
+
+	r.mu.Lock()
+	r.entered, r.release = entered, release
+	r.mu.Unlock()
+
+	return entered, func() { close(release) }
+}
+
+// FailRenames makes every later rename of targetID fail with err.
+func (r *recordingArchives) FailRenames(targetID string, err error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if r.renameErrs == nil {
+		r.renameErrs = map[string]error{}
+	}
+
+	r.renameErrs[targetID] = err
+}
+
 // Evicted returns a copy of the recorded webhook ids.
-func (r *recordingEvictor) Evicted() []string {
+func (r *recordingArchives) Evicted() []string {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
@@ -78,6 +159,28 @@ func (r *recordingEvictor) Evicted() []string {
 	return out
 }
 
+// EvictedTargets returns a copy of the recorded target ids.
+func (r *recordingArchives) EvictedTargets() []string {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	out := make([]string, len(r.evictedTargets))
+	copy(out, r.evictedTargets)
+
+	return out
+}
+
+// Renames returns a copy of the recorded renames.
+func (r *recordingArchives) Renames() []archiveRename {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	out := make([]archiveRename, len(r.renames))
+	copy(out, r.renames)
+
+	return out
+}
+
 func newTestApp(
 	t *testing.T,
 	targets ...any,
@@ -117,10 +220,10 @@ func newTestAppWithConfig(
 			func(n *recordingNotifier) delivery.Notifier {
 				return n
 			},
-			func() *recordingEvictor {
-				return &recordingEvictor{}
+			func() *recordingArchives {
+				return &recordingArchives{}
 			},
-			func(r *recordingEvictor) delivery.WebhookEvictor {
+			func(r *recordingArchives) delivery.Archives {
 				return r
 			},
 			metrics.NewRegistry,