Fail deliveries on archive errors; validate expiry at creation (#43)

Two review findings on the database archiving target:

- An archive error now records the attempt as failed with the
  error string and marks the delivery failed, instead of logging
  the error and reporting success. A target that could not do its
  one job must not claim it did.
- The archive expiry is now actually configurable: the add-target
  form gains an expiry field for database targets, and the value
  is validated at creation time via the new
  delivery.ValidateArchiveExpiry (empty, "never", or a positive
  Go duration), rejecting bad values with a 400 at the only place
  a human can fix them, mirroring how Slack target URLs are
  validated at creation.

Test updates: a forced archive failure asserts a failed delivery
with a recorded error and no archive file; config builder tests
cover empty/never/duration and rejection paths; the two engine
tests that exercise the database target now build engines with a
real webhook DB manager since archiving is no longer a no-op; the
reopen-debounce test uses a wider window so parallel test load
cannot make two rapid writes straddle it.

internal/delivery/target_database_test.go

@@ -83,30 +83,14 @@ func TestDeliverDatabase_ArchivesEvent(t *testing.T) {
 
 	webhookDB := testWebhookDB(t)
 	event := seedEvent(t, webhookDB, `{"archived":true}`)
-
-	dlv := seedDelivery(
-		t, webhookDB, event.ID, uuid.New().String(),
-		database.DeliveryStatusPending,
-	)
-
-	d := &database.Delivery{
-		EventID:  event.ID,
-		TargetID: dlv.TargetID,
-		Status:   database.DeliveryStatusPending,
-		Event:    event,
-		Target: database.Target{
-			Name: "test-db",
-			Type: database.TargetTypeDatabase,
-		},
-	}
-	d.ID = dlv.ID
+	d := seedDatabaseTargetDelivery(t, webhookDB, event, "")
 
 	e.ExportDeliverDatabase(webhookDB, d)
 
 	var updated database.Delivery
 
 	require.NoError(t, webhookDB.First(
-		&updated, "id = ?", dlv.ID,
+		&updated, "id = ?", d.ID,
 	).Error)
 	assert.Equal(t,
 		database.DeliveryStatusDelivered, updated.Status,
@@ -202,9 +186,11 @@ func TestArchiveWriter_RecreatesAfterRemoval(
 func TestArchiveWriter_ReopenDebounce(t *testing.T) {
 	t.Parallel()
 
+	// A generous debounce keeps the two rapid writes inside
+	// the window even on a heavily loaded test machine.
 	path := filepath.Join(t.TempDir(), "archive-wh.db")
 	w := delivery.NewExportArchiveWriter(
-		path, archiveTestLogger(), 20*time.Millisecond,
+		path, archiveTestLogger(), 2*time.Second,
 	)
 
 	require.NoError(t, w.Write(
@@ -218,7 +204,7 @@ func TestArchiveWriter_ReopenDebounce(t *testing.T) {
 	// initial open — no extra close/reopen.
 	assert.Equal(t, 1, w.Reopens())
 
-	time.Sleep(30 * time.Millisecond)
+	time.Sleep(2100 * time.Millisecond)
 
 	require.NoError(t, w.Write(
 		delivery.ExportArchivedEvent{EventID: "c"}, 0,
@@ -290,3 +276,116 @@ func TestParseArchiveExpiry(t *testing.T) {
 	)
 	require.Error(t, err)
 }
+
+// seedDatabaseTargetDelivery seeds a pending delivery for a
+// database target with the given config JSON and returns the
+// in-memory delivery the target handler is invoked with.
+func seedDatabaseTargetDelivery(
+	t *testing.T,
+	webhookDB *gorm.DB,
+	event database.Event,
+	config string,
+) *database.Delivery {
+	t.Helper()
+
+	dlv := seedDelivery(
+		t, webhookDB, event.ID, uuid.New().String(),
+		database.DeliveryStatusPending,
+	)
+
+	d := &database.Delivery{
+		EventID:  event.ID,
+		TargetID: dlv.TargetID,
+		Status:   database.DeliveryStatusPending,
+		Event:    event,
+		Target: database.Target{
+			Name:   "test-db",
+			Type:   database.TargetTypeDatabase,
+			Config: config,
+		},
+	}
+	d.ID = dlv.ID
+
+	return d
+}
+
+// TestDeliverDatabase_ArchiveFailureFailsDelivery verifies that
+// an archive error (here: an unparseable expiry in the target
+// config) fails the delivery loudly: the attempt is recorded as
+// failed with the error and the delivery is marked failed, not
+// delivered.
+func TestDeliverDatabase_ArchiveFailureFailsDelivery(
+	t *testing.T,
+) {
+	t.Parallel()
+
+	dataDir := t.TempDir()
+
+	e := delivery.NewTestEngineWithDB(
+		nil, database.NewTestWebhookDBManager(dataDir),
+		archiveTestLogger(),
+		&http.Client{Timeout: 5 * time.Second},
+		1,
+	)
+
+	webhookDB := testWebhookDB(t)
+	event := seedEvent(t, webhookDB, `{"archived":false}`)
+	d := seedDatabaseTargetDelivery(
+		t, webhookDB, event, `{"expiry":"nonsense"}`,
+	)
+
+	e.ExportDeliverDatabase(webhookDB, d)
+
+	var updated database.Delivery
+
+	require.NoError(t, webhookDB.First(
+		&updated, "id = ?", d.ID,
+	).Error)
+	assert.Equal(t,
+		database.DeliveryStatusFailed, updated.Status,
+		"archive failure must mark the delivery failed",
+	)
+
+	var results []database.DeliveryResult
+
+	require.NoError(t, webhookDB.Where(
+		"delivery_id = ?", d.ID,
+	).Find(&results).Error)
+	require.Len(t, results, 1)
+	assert.False(t,
+		results[0].Success,
+		"the attempt must be recorded as failed",
+	)
+	assert.Contains(t,
+		results[0].Error, "nonsense",
+		"the archive error must be recorded on the attempt",
+	)
+
+	assert.NoFileExists(t,
+		filepath.Join(
+			dataDir,
+			fmt.Sprintf("archive-%s.db", event.WebhookID),
+		),
+		"no archive file should exist for a failed config",
+	)
+}
+
+func TestValidateArchiveExpiry(t *testing.T) {
+	t.Parallel()
+
+	valid := []string{"", "never", "1h", "720h", "30m"}
+	for _, in := range valid {
+		require.NoError(t,
+			delivery.ValidateArchiveExpiry(in),
+			"expiry %q should be accepted", in,
+		)
+	}
+
+	invalid := []string{"nonsense", "7d", "-5h", "0s", "0"}
+	for _, in := range invalid {
+		require.Error(t,
+			delivery.ValidateArchiveExpiry(in),
+			"expiry %q should be rejected", in,
+		)
+	}
+}