Files
sm-user-plugin/blacklist_sweep_test.go
Jakub Zych bc5f4f7260 fix(quick-261119-kj8): sweep the JWT blacklist from a scheduled user:jwt-blacklist-sweep command
Boot started a ticker goroutine inside lagoon.OnDatabase that nothing
stopped, so every booting process (serve, each console command, each test
boot) leaked one and swept the blacklist once per process. The sweep is
now the console command user:jwt-blacklist-sweep, which the conga
scheduler runs on the job worker every
golem15.user.jwt.blacklist_sweep_interval (default 10m, 0 for none), once
per period across instances. An interval the scheduler cannot run
(unparsable, negative, under 1s, not dividing 24h) now fails boot.
2026-11-19 15:06:29 +01:00

284 lines
8.9 KiB
Go

package user
import (
"bytes"
"context"
"encoding/base64"
"errors"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
"git.golem15.com/golem15/summercms/modules/backpack"
"git.golem15.com/golem15/summercms/modules/bonfire"
"git.golem15.com/golem15/summercms/modules/bouncer"
"git.golem15.com/golem15/summercms/modules/compass"
"git.golem15.com/golem15/summercms/modules/pact"
"gorm.io/gorm"
)
const (
sweepCommand = "user:jwt-blacklist-sweep"
sweepIntervalKey = "golem15.user.jwt.blacklist_sweep_interval"
)
// badSweepIntervals are values the scheduler cannot run, so Boot rejects them.
var badSweepIntervals = []string{"soon", "3", "-1m", "500ms", "7m", "48h"}
// fakeBlacklist is a bouncer.BlacklistStore that records the Sweep calls.
type fakeBlacklist struct {
mu sync.Mutex
sweeps []time.Time
sweepErr error
}
func (f *fakeBlacklist) Add(context.Context, string, time.Time, time.Time) error { return nil }
func (f *fakeBlacklist) IsBlacklisted(context.Context, string) (bool, error) {
return false, nil
}
func (f *fakeBlacklist) Sweep(_ context.Context, now time.Time) error {
f.mu.Lock()
defer f.mu.Unlock()
f.sweeps = append(f.sweeps, now)
return f.sweepErr
}
func (f *fakeBlacklist) calls() []time.Time {
f.mu.Lock()
defer f.mu.Unlock()
return append([]time.Time(nil), f.sweeps...)
}
// TestBlacklistSweepSchedule schedules user:jwt-blacklist-sweep every 10m
// by default, before Register (nil app) too, at a custom interval, not at
// all for 0 or a bad value, and every scheduled command is a registered
// command.
func TestBlacklistSweepSchedule(t *testing.T) {
want := pact.ScheduledCommand{Command: sweepCommand, Cadence: pact.Every(10 * time.Minute)}
app := bareApp(t)
for name, p := range map[string]*Plugin{"unset": {app: app}, "nil app": {}} {
s := p.Schedule()
if len(s) != 1 || s[0].Command != want.Command || s[0].Cadence != want.Cadence || len(s[0].Args) != 0 {
t.Fatalf("%s: schedule = %+v", name, s)
}
}
names := map[string]bool{}
for _, c := range (&Plugin{app: app}).Commands() {
names[c.Name] = true
}
for _, s := range (&Plugin{app: app}).Schedule() {
if !names[s.Command] {
t.Fatalf("scheduled %s is not registered: %v", s.Command, names)
}
}
for value, every := range map[string]time.Duration{"1h": time.Hour, "30s": 30 * time.Second} {
app := bareApp(t)
if err := app.Config.Set(sweepIntervalKey, value); err != nil {
t.Fatal(err)
}
s := (&Plugin{app: app}).Schedule()
if len(s) != 1 || s[0].Command != sweepCommand || s[0].Cadence != pact.Every(every) {
t.Fatalf("%s: schedule = %+v", value, s)
}
}
for _, off := range []string{"0", "0s"} {
app := bareApp(t)
if err := app.Config.Set(sweepIntervalKey, off); err != nil {
t.Fatal(err)
}
if s := (&Plugin{app: app}).Schedule(); len(s) != 0 {
t.Fatalf("%s: schedule = %+v, want none", off, s)
}
}
if s := (&Plugin{app: envApp(t, "SUMMER_GOLEM15__USER__JWT__BLACKLIST_SWEEP_INTERVAL=0")}).Schedule(); len(s) != 0 {
t.Fatalf("SUMMER_ 0: schedule = %+v, want none", s)
}
for _, bad := range badSweepIntervals {
app := bareApp(t)
if err := app.Config.Set(sweepIntervalKey, bad); err != nil {
t.Fatal(err)
}
if s := (&Plugin{app: app}).Schedule(); s != nil {
t.Fatalf("%s: schedule = %+v, want nil", bad, s)
}
}
}
// envApp is a bare application whose config also reads environ.
func envApp(t *testing.T, environ ...string) *backpack.App {
t.Helper()
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "app.yaml"), []byte("name: user-env\n"), 0o644); err != nil {
t.Fatal(err)
}
cfg, err := compass.Open(compass.Options{Dir: dir, Environ: append([]string{"SUMMER_ENV=development"}, environ...)})
if err != nil {
t.Fatal(err)
}
return backpack.New(cfg)
}
// TestBlacklistSweepBoot fails Boot on an interval the scheduler cannot run,
// naming the key, and accepts 10m, 0 and an unset key.
func TestBlacklistSweepBoot(t *testing.T) {
withSecret := func(t *testing.T) *backpack.App {
app := bareApp(t)
if err := app.Config.Set("golem15.user.jwt.secret", "blacklist-sweep-boot-secret"); err != nil {
t.Fatal(err)
}
return app
}
for _, bad := range badSweepIntervals {
app := withSecret(t)
if err := app.Config.Set(sweepIntervalKey, bad); err != nil {
t.Fatal(err)
}
if err := (&Plugin{}).Boot(app); err == nil || !strings.Contains(err.Error(), sweepIntervalKey) {
t.Fatalf("Boot with %q: %v", bad, err)
}
}
for _, good := range []string{"10m", "0", ""} {
app := withSecret(t)
if good != "" {
if err := app.Config.Set(sweepIntervalKey, good); err != nil {
t.Fatal(err)
}
}
if err := (&Plugin{}).Boot(app); err != nil && strings.Contains(err.Error(), sweepIntervalKey) {
t.Fatalf("Boot with %q: %v", good, err)
}
}
}
// TestJWTBlacklistSweepCommand runs the command over a published store: one
// Sweep with the current time and the result line; a failing store is an
// error and no result line; a nil app is an error.
func TestJWTBlacklistSweepCommand(t *testing.T) {
run := func(t *testing.T, p *Plugin) (string, error) {
t.Helper()
cmd := commandNamed(t, p.Commands(), sweepCommand)
var buf bytes.Buffer
err := cmd.Run(context.Background(), emailArg{}, bonfire.NewOutput(nil, &buf, &buf))
return buf.String(), err
}
t.Run("published store", func(t *testing.T) {
app := bareApp(t)
fake := &fakeBlacklist{}
if err := app.Publish[bouncer.BlacklistStore](fake); err != nil {
t.Fatal(err)
}
before := time.Now()
out, err := run(t, &Plugin{app: app})
after := time.Now()
if err != nil {
t.Fatalf("run: %v (output %q)", err, out)
}
calls := fake.calls()
if len(calls) != 1 || calls[0].Before(before) || calls[0].After(after) {
t.Fatalf("sweeps = %v, want one between %v and %v", calls, before, after)
}
if !strings.Contains(out, "Deleted the expired JWT blacklist rows.") {
t.Fatalf("output = %q", out)
}
})
t.Run("failing store", func(t *testing.T) {
app := bareApp(t)
down := errors.New("blacklist down")
if err := app.Publish[bouncer.BlacklistStore](&fakeBlacklist{sweepErr: down}); err != nil {
t.Fatal(err)
}
out, err := run(t, &Plugin{app: app})
if !errors.Is(err, down) {
t.Fatalf("run error = %v, want it to wrap %v", err, down)
}
if strings.Contains(out, "Deleted") {
t.Fatalf("output after a failure = %q", out)
}
})
t.Run("nil app", func(t *testing.T) {
if _, err := run(t, &Plugin{}); err == nil {
t.Fatal("run with a nil app: no error")
}
})
}
// TestJWTBlacklistSweepPostgres runs user:jwt-blacklist-sweep against
// Postgres: through the store Boot published it deletes the expired row and
// keeps the one still valid; as a console command with no published
// database it opens one from database.dsn.
func TestJWTBlacklistSweepPostgres(t *testing.T) {
skipShortPostgres(t)
gdb, sqlDB := sessionDB(t)
insert := func(t *testing.T, jti string, at time.Time) {
t.Helper()
if err := gdb.Exec(`INSERT INTO jwt_blacklist (jti, expires_at, valid_until) VALUES (?, ?, ?)`, jti, at, at).Error; err != nil {
t.Fatal(err)
}
t.Cleanup(func() { gdb.Exec(`DELETE FROM jwt_blacklist WHERE jti = ?`, jti) })
}
count := func(t *testing.T, jti string) int64 {
t.Helper()
var n int64
if err := gdb.Raw(`SELECT COUNT(*) FROM jwt_blacklist WHERE jti = ?`, jti).Scan(&n).Error; err != nil {
t.Fatal(err)
}
return n
}
run := func(t *testing.T, p *Plugin) string {
t.Helper()
var buf bytes.Buffer
if err := commandNamed(t, p.Commands(), sweepCommand).Run(context.Background(), emailArg{}, bonfire.NewOutput(nil, &buf, &buf)); err != nil {
t.Fatalf("run: %v (output %q)", err, buf.String())
}
return buf.String()
}
t.Run("published store", func(t *testing.T) {
p := bootPlugin(t, newSessionApp(t, gdb, sqlDB), "0s")
insert(t, "sweep-me-published", time.Now().Add(-time.Minute))
insert(t, "sweep-keep-published", time.Now().Add(time.Hour))
out := run(t, p)
if count(t, "sweep-me-published") != 0 {
t.Fatal("the expired row was not deleted")
}
if count(t, "sweep-keep-published") != 1 {
t.Fatal("the unexpired row was deleted")
}
if !strings.Contains(out, "Deleted the expired JWT blacklist rows.") {
t.Fatalf("output = %q", out)
}
})
t.Run("database from config", func(t *testing.T) {
app := backpack.New(sessionConfig(t))
if err := app.Config.Set("database.dsn", sessionDSN); err != nil {
t.Fatal(err)
}
// Opening a database also loads the encryption keys from app.key.
if err := app.Config.Set("app.key", base64.StdEncoding.EncodeToString([]byte("0123456789abcdef0123456789abcdef"))); err != nil {
t.Fatal(err)
}
if _, ok := app.Lookup[*gorm.DB](); ok {
t.Fatal("setup: a database is published")
}
insert(t, "sweep-me-console", time.Now().Add(-time.Minute))
insert(t, "sweep-keep-console", time.Now().Add(time.Hour))
run(t, &Plugin{app: app})
if count(t, "sweep-me-console") != 0 {
t.Fatal("the expired row was not deleted")
}
if count(t, "sweep-keep-console") != 1 {
t.Fatal("the unexpired row was deleted")
}
})
}