clawbot
b9ec91c0f7
check / check (push) In progress
The UI gave one thing several names. The `database` type is now Archive in the type list, on its badge and on the edit page, and its settings read "Archive expiry" and "Archive rotation" everywhere. The retry field is "Delivery attempts", with help text, errors and the target list saying it counts every attempt; a stored 0 shows as one attempt. The target list uses one capitalisation. The navbar says "Sign out", the sign-in page "Sign in", and the resubmit notice "webhook" instead of "source". The README follows. Stored values, their meaning, routes and form field names are unchanged. Model: opus-5-5
452 lines
13 KiB
Go
452 lines
13 KiB
Go
package handlers_test
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"sneak.berlin/go/webhooker/internal/database"
|
|
"sneak.berlin/go/webhooker/internal/delivery"
|
|
"sneak.berlin/go/webhooker/internal/handlers"
|
|
"sneak.berlin/go/webhooker/internal/session"
|
|
)
|
|
|
|
// Template data keys the page templates read. The handlers package has
|
|
// its own unexported constants for these; this is the external test
|
|
// package, so it needs its own.
|
|
const (
|
|
dataKeyWebhook = "Webhook"
|
|
dataKeyError = "Error"
|
|
dataKeyEvents = "Events"
|
|
)
|
|
|
|
// testWebhookID is the identifier given to the webhook under test on
|
|
// pages that render one.
|
|
const testWebhookID = "wh-1"
|
|
|
|
// renderPage renders a page template through the real template set as
|
|
// an authenticated user and returns the resulting HTML.
|
|
func renderPage(
|
|
t *testing.T,
|
|
h *handlers.Handlers,
|
|
sess *session.Session,
|
|
page string,
|
|
data map[string]any,
|
|
) string {
|
|
t.Helper()
|
|
|
|
cookies := authenticatedCookies(t, sess, "test-user-id", "testuser")
|
|
|
|
req := httptest.NewRequestWithContext(
|
|
context.Background(), http.MethodGet, "/", nil,
|
|
)
|
|
for _, c := range cookies {
|
|
req.AddCookie(c)
|
|
}
|
|
|
|
w := httptest.NewRecorder()
|
|
h.RenderTemplateForTest(w, req, page, data)
|
|
|
|
return w.Body.String()
|
|
}
|
|
|
|
// TestNavbarUsesWebhookTerminology pins the user-visible navigation
|
|
// label to "Webhooks" and its link to the webhook list at /hooks.
|
|
func TestNavbarUsesWebhookTerminology(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
// One item, so the list body renders too: it calls
|
|
// WebhookListItem.RetentionLabel, promoted from the embedded
|
|
// Webhook and therefore a pointer method. An empty list would
|
|
// skip that call and hide a template error behind the
|
|
// navigation assertions below.
|
|
item := handlers.WebhookListItem{}
|
|
item.Name = "wh"
|
|
item.ID = testWebhookID
|
|
item.RetentionDays = 14
|
|
|
|
body := renderPage(t, h, sess, "sources_list.html", map[string]any{
|
|
"Webhooks": []handlers.WebhookListItem{item},
|
|
})
|
|
|
|
assert.Contains(t, body, "Retention: 14 days")
|
|
assert.Contains(t, body, `class="btn-secondary">Webhooks</a>`)
|
|
assert.Contains(
|
|
t, body, `class="btn-secondary w-full">Webhooks</a>`,
|
|
)
|
|
assert.Contains(
|
|
t, body,
|
|
`<h1 class="text-2xl font-medium text-gray-900">Webhooks</h1>`,
|
|
)
|
|
assert.NotContains(
|
|
t, body, ">Sources<",
|
|
"no user-visible element may still be labelled Sources",
|
|
)
|
|
assert.Contains(t, body, `href="/hooks"`)
|
|
}
|
|
|
|
// TestEditPageUsesWebhookTerminology pins the edit page's heading and
|
|
// its back link to the webhook page at /hook/{id}.
|
|
func TestEditPageUsesWebhookTerminology(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
// The webhook goes in as a pointer because source_edit.html calls
|
|
// Webhook.RetentionLabel, a pointer method: a map element is not
|
|
// addressable, so a value here renders an error instead of the
|
|
// page.
|
|
webhook := &database.Webhook{Name: "wh", RetentionDays: 14}
|
|
webhook.ID = testWebhookID
|
|
|
|
body := renderPage(t, h, sess, "source_edit.html", map[string]any{
|
|
dataKeyWebhook: webhook,
|
|
dataKeyError: "",
|
|
})
|
|
|
|
assert.Contains(t, body, "Edit Webhook")
|
|
assert.NotContains(t, body, ">Sources<")
|
|
assert.Contains(t, body, `href="/hook/wh-1"`)
|
|
}
|
|
|
|
// TestEventLogPageIsCalledFullEventLog pins the one name the event log
|
|
// page at /hook/{id}/events goes by: both links to it on the webhook
|
|
// page, and its own heading, read "Full Event Log".
|
|
func TestEventLogPageIsCalledFullEventLog(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
// A pointer, as in the handlers: source_detail.html calls
|
|
// Webhook.RetentionLabel, a pointer method. The webhook page only
|
|
// ranges over its lists, and a list left out renders as empty, so
|
|
// its lists are left out. The event log also counts its events, so
|
|
// it gets an empty list.
|
|
webhook := &database.Webhook{Name: "wh", RetentionDays: 14}
|
|
webhook.ID = testWebhookID
|
|
|
|
detailBody := renderPage(
|
|
t, h, sess, "source_detail.html", map[string]any{
|
|
dataKeyWebhook: webhook,
|
|
},
|
|
)
|
|
|
|
assert.Contains(
|
|
t, detailBody,
|
|
`<a href="/hook/wh-1/events" class="btn-secondary">Full Event Log</a>`,
|
|
"the button at the top of the webhook page",
|
|
)
|
|
assert.Contains(
|
|
t, detailBody,
|
|
`<a href="/hook/wh-1/events" class="btn-small">Full Event Log</a>`,
|
|
"the link under recent events",
|
|
)
|
|
|
|
logBody := renderPage(t, h, sess, "source_logs.html", map[string]any{
|
|
dataKeyWebhook: webhook,
|
|
dataKeyEvents: []handlers.EventLogView{},
|
|
"TotalEvents": int64(0),
|
|
})
|
|
|
|
assert.Contains(
|
|
t, logBody,
|
|
`<h1 class="text-2xl font-medium text-gray-900">Full Event Log</h1>`,
|
|
)
|
|
}
|
|
|
|
// TestCreateFormRetentionCopyMatchesBehaviour pins the create form's
|
|
// retention copy to what the code does: the reaper permanently deletes
|
|
// events past the cutoff, an empty field falls back to
|
|
// DefaultRetentionDays, and 0 is rewritten to the retain-forever
|
|
// sentinel by Webhook.BeforeSave.
|
|
func TestCreateFormRetentionCopyMatchesBehaviour(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
body := renderPage(t, h, sess, "sources_new.html", map[string]any{
|
|
"DefaultRetentionDays": database.DefaultRetentionDays,
|
|
dataKeyError: "",
|
|
})
|
|
|
|
assert.Contains(
|
|
t, body,
|
|
"permanently deletes events older than this",
|
|
"the form must say retention is enforced by deletion",
|
|
)
|
|
assert.Contains(t, body, "Enter 0 to retain events forever")
|
|
assert.Contains(
|
|
t, body,
|
|
"leave blank to use the default of "+
|
|
strconv.Itoa(database.DefaultRetentionDays)+" days",
|
|
"blank means the default, not forever",
|
|
)
|
|
}
|
|
|
|
// TestEditFormRetentionCopyMatchesBehaviour pins the edit form's
|
|
// retention copy, including that it states the stored policy via
|
|
// RetentionLabel and that an empty field leaves that policy unchanged
|
|
// rather than meaning forever.
|
|
func TestEditFormRetentionCopyMatchesBehaviour(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
finite := &database.Webhook{Name: "wh", RetentionDays: 14}
|
|
finite.ID = testWebhookID
|
|
|
|
body := renderPage(t, h, sess, "source_edit.html", map[string]any{
|
|
dataKeyWebhook: finite,
|
|
dataKeyError: "",
|
|
})
|
|
|
|
assert.Contains(t, body, "Currently 14 days.")
|
|
assert.Contains(
|
|
t, body,
|
|
"permanently deletes events older than this",
|
|
)
|
|
assert.Contains(t, body, "Enter 0 to retain events forever")
|
|
assert.Contains(
|
|
t, body,
|
|
"leave blank to keep the current setting",
|
|
"blank means unchanged, not forever",
|
|
)
|
|
|
|
forever := &database.Webhook{
|
|
Name: "wh",
|
|
RetentionDays: database.RetentionForeverDays,
|
|
}
|
|
forever.ID = "wh-2"
|
|
|
|
foreverBody := renderPage(
|
|
t, h, sess, "source_edit.html", map[string]any{
|
|
dataKeyWebhook: forever,
|
|
dataKeyError: "",
|
|
},
|
|
)
|
|
|
|
assert.Contains(
|
|
t, foreverBody, "Currently forever.",
|
|
"a retain-forever webhook must not read as a day count",
|
|
)
|
|
assert.Contains(
|
|
t, foreverBody,
|
|
"No events are deleted while retention is set to forever",
|
|
)
|
|
assert.NotContains(
|
|
t, foreverBody,
|
|
"permanently deletes events older than this",
|
|
"the reaper skips retain-forever webhooks, so the form "+
|
|
"must not claim it deletes their events",
|
|
)
|
|
}
|
|
|
|
// TestEntrypointCopyButtonIsProgressiveEnhancement proves the copy
|
|
// affordance degrades: the button ships with the hidden attribute, so a
|
|
// browser that never runs app.js shows no dead control, and the URL is
|
|
// rendered as ordinary selectable text either way.
|
|
func TestEntrypointCopyButtonIsProgressiveEnhancement(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
entrypoint := database.Entrypoint{Path: "abc123"}
|
|
entrypoint.ID = "ep-1"
|
|
|
|
// The webhook goes in as a pointer because source_detail.html
|
|
// calls Webhook.RetentionLabel, a pointer method: a map element
|
|
// is not addressable, so a value here aborts execution partway
|
|
// down the page, after the copy button has already been flushed
|
|
// to the response.
|
|
webhook := &database.Webhook{Name: "wh", RetentionDays: 14}
|
|
webhook.ID = testWebhookID
|
|
webhook.CreatedAt = time.Date(
|
|
2026, time.January, 2, 3, 4, 5, 0, time.UTC,
|
|
)
|
|
|
|
body := renderPage(t, h, sess, "source_detail.html", map[string]any{
|
|
dataKeyWebhook: webhook,
|
|
// The handler passes projected views, never raw rows — a
|
|
// target carries its stored credential — so the test data
|
|
// has that same shape.
|
|
"Entrypoints": handlers.NewEntrypointViews(
|
|
[]database.Entrypoint{entrypoint},
|
|
),
|
|
"Targets": delivery.NewTargetViews(nil),
|
|
dataKeyEvents: []database.Event{},
|
|
"BaseURL": "https://hooks.example.com",
|
|
})
|
|
|
|
assert.Contains(
|
|
t, body,
|
|
`<code id="entrypoint-url-ep-1"`,
|
|
)
|
|
assert.Contains(t, body, "https://hooks.example.com/h/abc123")
|
|
assert.Contains(
|
|
t, body,
|
|
`<button type="button" hidden data-copy-target="entrypoint-url-ep-1"`,
|
|
"the copy control must be a button, start hidden and be "+
|
|
"revealed by script",
|
|
)
|
|
|
|
// renderTemplate streams to the ResponseWriter, so an abort
|
|
// midway still leaves everything above it in the body. This pins
|
|
// content from the last line of the template, which is below the
|
|
// assertions above: without it, a page that renders the copy
|
|
// button and then 500s passes.
|
|
assert.Contains(
|
|
t, body, "Retention: 14 days",
|
|
"the page must render to completion, not abort partway",
|
|
)
|
|
}
|
|
|
|
// maxRetriesHelp is the wording both target forms must carry. The
|
|
// delivery core makes max_retries attempts in total, not that many
|
|
// retries on top of a first try (a fresh delivery starts at attempt 1
|
|
// and target_http gives up once the attempt number reaches
|
|
// max_retries), and 0 is special-cased to a single fire-and-forget
|
|
// attempt with no circuit breaker.
|
|
const maxRetriesHelp = "How many times each delivery is attempted in " +
|
|
"all, the first attempt included. 0 means a single attempt with no " +
|
|
"retries and no circuit breaker."
|
|
|
|
// TestTargetFormMaxRetriesCopyMatchesBehaviour pins the max_retries
|
|
// label, "Delivery attempts", and help text on both the create form
|
|
// (the add-target form on the webhook detail page) and the edit form,
|
|
// so the copy cannot drift back to calling the number a retry count.
|
|
func TestTargetFormMaxRetriesCopyMatchesBehaviour(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
webhook := &database.Webhook{Name: "wh", RetentionDays: 14}
|
|
webhook.ID = testWebhookID
|
|
|
|
entrypoint := database.Entrypoint{Path: "abc123"}
|
|
entrypoint.ID = "ep-1"
|
|
|
|
createBody := renderPage(
|
|
t, h, sess, "source_detail.html", map[string]any{
|
|
dataKeyWebhook: webhook,
|
|
"Entrypoints": handlers.NewEntrypointViews(
|
|
[]database.Entrypoint{entrypoint},
|
|
),
|
|
"Targets": delivery.NewTargetViews(nil),
|
|
dataKeyEvents: []database.Event{},
|
|
"BaseURL": "https://hooks.example.com",
|
|
},
|
|
)
|
|
|
|
assert.Contains(t, createBody, "Delivery attempts:</label>")
|
|
assert.Contains(
|
|
t, createBody, maxRetriesHelp,
|
|
"the add-target form must explain max_retries as total attempts",
|
|
)
|
|
|
|
// A slack target exercises the same max_retries field while needing
|
|
// only a URL from the edit template, so the test data stays
|
|
// minimal. The Target and TargetForm keys mirror the field names
|
|
// the template reads off the handler's values.
|
|
editBody := renderPage(
|
|
t, h, sess, "target_edit.html", map[string]any{
|
|
dataKeyWebhook: webhook,
|
|
"Target": map[string]any{
|
|
"ID": "tg-1",
|
|
"Name": "t",
|
|
"Type": "slack",
|
|
"Active": true,
|
|
},
|
|
"TargetForm": map[string]any{
|
|
"URL": "https://hooks.slack.com/services/x",
|
|
"MaxRetries": "3",
|
|
},
|
|
dataKeyError: "",
|
|
},
|
|
)
|
|
|
|
assert.Contains(t, editBody, `class="label">Delivery attempts</label>`)
|
|
assert.Contains(
|
|
t, editBody, maxRetriesHelp,
|
|
"the target edit form must explain max_retries as total attempts",
|
|
)
|
|
}
|
|
|
|
// TestCreateFormCallsTheDatabaseTargetAnArchive pins the names the new
|
|
// webhook page gives the database target its Archive checkbox creates,
|
|
// and that target's settings, to the ones the target forms use.
|
|
func TestCreateFormCallsTheDatabaseTargetAnArchive(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var h *handlers.Handlers
|
|
|
|
var sess *session.Session
|
|
|
|
app := newTestApp(t, &h, &sess)
|
|
app.RequireStart()
|
|
|
|
t.Cleanup(app.RequireStop)
|
|
|
|
body := renderPage(t, h, sess, "sources_new.html", map[string]any{
|
|
dataKeyError: "",
|
|
})
|
|
|
|
assert.Contains(t, body, "created with an archive target")
|
|
assert.Contains(t, body, `class="label">Archive expiry</label>`)
|
|
assert.Contains(t, body, `class="label">Archive rotation</label>`)
|
|
}
|