Files
summercms/modules/lighthouse/example_test.go

346 lines
11 KiB
Go

package lighthouse_test
import (
"context"
"encoding/json"
"fmt"
"net/http"
"slices"
"strconv"
"strings"
"testing"
"time"
"git.golem15.com/golem15/summercms/modules/backpack"
"git.golem15.com/golem15/summercms/modules/compass"
"git.golem15.com/golem15/summercms/modules/lagoon"
"git.golem15.com/golem15/summercms/modules/lighthouse"
_ "git.golem15.com/golem15/summercms/modules/lighthouse/centrifugo"
"git.golem15.com/golem15/summercms/modules/pact"
"git.golem15.com/golem15/summercms/modules/surf"
"gorm.io/gorm"
)
// newApp returns an app whose config selects a realtime driver.
func newApp(settings map[string]any) (*backpack.App, error) {
cfg, err := compass.Open(compass.Options{Dir: "config", Env: "development", Environ: []string{}})
if err != nil {
return nil, err
}
for k, v := range settings {
if err := cfg.Set(k, v); err != nil {
return nil, err
}
}
return backpack.New(cfg), nil
}
// isMember stands in for the application's own membership query.
func isMember(ctx context.Context, userID uint, blogID int64) bool {
return userID == 42 && blogID == 7
}
func ExampleRegistry_Register() {
app, err := newApp(map[string]any{"realtime.driver": "memory"})
if err != nil {
fmt.Println(err)
return
}
svc, err := lighthouse.From(app)
if err != nil {
fmt.Println(err)
return
}
// blog:{entity}:{id} channels are open to members of the blog only. The
// authorizer runs on every subscribe; nothing is cached.
err = svc.Registry().Register("blog", lighthouse.AuthorizerFunc(
func(ctx context.Context, userID uint, channel string) lighthouse.Result {
if isMember(ctx, userID, lighthouse.ChannelID(channel)) {
return lighthouse.Allowed(nil)
}
return lighthouse.Denied("not a member of the blog")
}))
if err != nil {
fmt.Println(err)
return
}
for _, sub := range []struct {
user uint
channel string
}{{42, "blog:7"}, {42, "blog:8"}, {42, "presence:blog:7"}, {42, "shop:7"}} {
ns, presence := lighthouse.ParseChannel(sub.channel)
auth, ok := svc.Registry().Get(ns)
if !ok {
fmt.Println(sub.channel, "no authorizer")
continue
}
res := auth.Authorize(context.Background(), sub.user, sub.channel)
fmt.Printf("%d %s namespace=%s presence=%v allowed=%v reason=%q\n", sub.user, sub.channel, ns, presence, res.Allowed, res.Reason())
}
fmt.Println(lighthouse.ChannelID("blog:12abc"), lighthouse.FormatChannels("acme", []string{"Blog:7"}))
// Output:
// 42 blog:7 namespace=blog presence=false allowed=true reason=""
// 42 blog:8 namespace=blog presence=false allowed=false reason="not a member of the blog"
// 42 presence:blog:7 namespace=blog presence=true allowed=false reason="not a member of the blog"
// shop:7 no authorizer
// 12 [acme:blog:7]
}
// Post is the acme.blog post model. It knows nothing about realtime.
type Post struct {
ID uint `gorm:"column:id;primaryKey"`
BlogID uint `gorm:"column:blog_id"`
Title string `gorm:"column:title"`
}
func (Post) TableName() string { return "acme_blog_posts" }
// bindPosts registers the broadcast contract of Post from the plugin's Boot.
func bindPosts(svc *lighthouse.Service) error {
// docs:start bind
return lighthouse.Bind[Post](svc, lighthouse.Binding[Post]{
Alias: "blog.post",
Channels: func(ctx context.Context, tx *gorm.DB, p *Post) ([]string, error) {
return []string{"blog:" + strconv.FormatUint(uint64(p.BlogID), 10)}, nil
},
})
// docs:end bind
}
// publishPost creates a post; its broadcast is published after commit.
func publishPost(ctx context.Context, db *gorm.DB, fail bool) error {
// docs:start write
return lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
if err := tx.Create(&Post{BlogID: 7, Title: "Hello"}).Error; err != nil {
return err
}
// The broadcast job is now queued in this transaction. It is
// published only if the transaction commits.
if fail {
return fmt.Errorf("rolled back")
}
return nil
})
// docs:end write
}
// importPosts writes many posts and publishes one summary event.
func importPosts(ctx context.Context, svc *lighthouse.Service, db *gorm.DB, titles []string) error {
// docs:start bulk
return lighthouse.WithoutBroadcasting[Post](ctx, func(ctx context.Context) error {
return lagoon.Transaction(ctx, db, func(ctx context.Context, tx *gorm.DB) error {
for _, title := range titles {
if err := tx.Create(&Post{BlogID: 7, Title: title}).Error; err != nil {
return err
}
}
return svc.Emit(ctx, tx, lighthouse.Broadcast{
Channels: []string{"blog:7"},
Event: "blog.posts_imported",
Payload: struct {
Count int `json:"count"`
}{len(titles)},
})
})
})
// docs:end bulk
}
// waitFor waits until the memory driver has recorded n publications.
func waitFor(t *testing.T, mem *lighthouse.MemoryDriver, n int) []lighthouse.Publication {
t.Helper()
deadline := time.Now().Add(10 * time.Second)
for len(mem.Publications()) < n {
if time.Now().After(deadline) {
t.Fatalf("got %d publications, want %d", len(mem.Publications()), n)
}
time.Sleep(20 * time.Millisecond)
}
time.Sleep(300 * time.Millisecond) // catch extra publications
pubs := mem.Publications()
if len(pubs) != n {
t.Fatalf("got %d publications, want exactly %d: %+v", len(pubs), n, pubs)
}
return pubs
}
// TestDocsBroadcast runs the bind, write and bulk regions of the Realtime
// page on the package's Postgres harness with a job worker.
func TestDocsBroadcast(t *testing.T) {
_, svc, db := lighthouse.DocsEnv(t)
if err := db.Exec(`CREATE TABLE acme_blog_posts (id SERIAL PRIMARY KEY, blog_id INTEGER NOT NULL, title TEXT NOT NULL)`).Error; err != nil {
t.Fatal(err)
}
if err := bindPosts(svc); err != nil {
t.Fatal(err)
}
mem, ok := svc.Driver().(*lighthouse.MemoryDriver)
if !ok {
t.Fatalf("driver is %T", svc.Driver())
}
ctx := t.Context()
if err := publishPost(ctx, db, true); err == nil {
t.Fatal("rolled-back publish succeeded")
}
if err := publishPost(ctx, db, false); err != nil {
t.Fatal(err)
}
pubs := waitFor(t, mem, 1)
if pubs[0].Event != "created.blog.post" || len(pubs[0].Channels) != 1 || pubs[0].Channels[0] != "blog:7" {
t.Fatalf("publication = %+v", pubs[0])
}
if err := importPosts(ctx, svc, db, []string{"A", "B", "C"}); err != nil {
t.Fatal(err)
}
pubs = waitFor(t, mem, 2)
if pubs[1].Event != "blog.posts_imported" || string(pubs[1].Payload) != `{"count":3}` {
t.Fatalf("summary = %+v %s", pubs[1], pubs[1].Payload)
}
}
// RoomsPlugin is the acme.rooms plugin: room:{id} channels for members.
type RoomsPlugin struct {
realtime *lighthouse.Service
}
// lookupAcmeUser stands in for the application's own user model.
func lookupAcmeUser(ctx context.Context, id uint) (lighthouse.User, bool, error) {
if id != 42 {
return lighthouse.User{}, false, nil
}
name := "Ada"
return lighthouse.User{ID: id, Name: &name}, true, nil
}
// isRoomMember stands in for the application's own membership query.
func isRoomMember(ctx context.Context, userID uint, roomID int64) bool {
return userID == 42 && roomID == 7
}
// Boot builds the realtime service, installs the user lookup and registers
// the room authorizer.
func (p *RoomsPlugin) Boot(app *backpack.App) error {
svc, err := lighthouse.From(app)
if err != nil {
return err
}
p.realtime = svc
svc.SetUserLookup(func(ctx context.Context, id uint) (lighthouse.User, bool, error) {
return lookupAcmeUser(ctx, id) // the application's own user model
})
// Allow room:{id} to members only; re-checked on every subscribe.
return svc.Registry().Register("room", lighthouse.AuthorizerFunc(
func(ctx context.Context, userID uint, channel string) lighthouse.Result {
if isRoomMember(ctx, userID, lighthouse.ChannelID(channel)) {
return lighthouse.Allowed(nil)
}
return lighthouse.Denied("not a room member")
}))
}
// Routes mounts the driver's routes once.
func (p *RoomsPlugin) Routes(r pact.Router) error {
return lighthouse.Mount(r, p.realtime.Driver(), lighthouse.Surfaces{
UserAuth: surf.Use("jwt.auth"),
ServerToServer: surf.Use(),
Middleware: surf.Use("throttle:acme-realtime"),
})
}
// routeRecorder is a pact.Router that records each route with its
// middleware, standing in for surf's router.
type routeRecorder struct {
prefix string
middleware []string
lines *[]string
}
func (r routeRecorder) group(prefix string, mw []string, raw bool, fn func(pact.Router)) {
if raw {
mw = append([]string{"raw"}, mw...)
}
fn(routeRecorder{strings.TrimSuffix(r.prefix+prefix, "/"), append(slices.Clone(r.middleware), mw...), r.lines})
}
func (r routeRecorder) add(method, path string, mw []string) {
*r.lines = append(*r.lines, method+" "+r.prefix+path+" "+strings.Join(append(slices.Clone(r.middleware), mw...), ","))
}
func (r routeRecorder) Group(p string, mw []string, fn func(pact.Router)) { r.group(p, mw, false, fn) }
func (r routeRecorder) GroupRaw(p string, mw []string, fn func(pact.Router)) {
r.group(p, mw, true, fn)
}
func (r routeRecorder) Get(p string, _ http.HandlerFunc, mw ...string) { r.add("GET", p, mw) }
func (r routeRecorder) Post(p string, _ http.HandlerFunc, mw ...string) { r.add("POST", p, mw) }
func (r routeRecorder) Put(p string, _ http.HandlerFunc, mw ...string) { r.add("PUT", p, mw) }
func (r routeRecorder) Patch(p string, _ http.HandlerFunc, mw ...string) { r.add("PATCH", p, mw) }
func (r routeRecorder) Delete(p string, _ http.HandlerFunc, mw ...string) { r.add("DELETE", p, mw) }
func (routeRecorder) Where(string, string) {}
func (routeRecorder) WhereIn(string, ...string) {}
// TestDocsRoomsPlugin boots the README's plugin on the centrifugo driver,
// checks its user lookup and room authorizer, and mounts its routes.
func TestDocsRoomsPlugin(t *testing.T) {
app, err := newApp(map[string]any{"realtime.driver": "centrifugo", "realtime.centrifugo.token_secret": "docs-secret"})
if err != nil {
t.Fatal(err)
}
p := &RoomsPlugin{}
if err := p.Boot(app); err != nil {
t.Fatal(err)
}
ctx := t.Context()
if u, ok, err := p.realtime.User(ctx, 42); err != nil || !ok || u.Name == nil || *u.Name != "Ada" {
t.Fatalf("User(42) = %+v, %v, %v", u, ok, err)
}
room, ok := p.realtime.Registry().Get("room")
if !ok {
t.Fatal("no room authorizer")
}
if !room.Authorize(ctx, 42, "room:7").Allowed || room.Authorize(ctx, 42, "room:8").Reason() != "not a room member" {
t.Fatal("room authorizer does not follow membership")
}
var lines []string
if err := p.Routes(routeRecorder{lines: &lines}); err != nil {
t.Fatal(err)
}
want := []string{
"GET /api/realtime/token jwt.auth,throttle:acme-realtime",
"POST /api/realtime/subscribe raw,throttle:acme-realtime",
}
if !slices.Equal(lines, want) {
t.Fatalf("routes = %q, want %q", lines, want)
}
}
func ExampleMemoryDriver() {
app, err := newApp(map[string]any{"realtime.driver": "memory"})
if err != nil {
fmt.Println(err)
return
}
svc, err := lighthouse.From(app)
if err != nil {
fmt.Println(err)
return
}
// Code under test publishes; here the example calls the driver itself.
ctx := context.Background()
_ = svc.Driver().Publish(ctx, "blog:7", "blog.post_updated", json.RawMessage(`{"id":1}`))
_ = svc.Driver().Broadcast(ctx, []string{"blog:7", "blog:8"}, "blog.posts_imported", json.RawMessage(`{"count":3}`))
// docs:start publications
mem := svc.Driver().(*lighthouse.MemoryDriver)
for _, pub := range mem.Publications() {
fmt.Println(pub.Method, pub.Channels, pub.Event)
}
// docs:end publications
// Output:
// publish [blog:7] blog.post_updated
// broadcast [blog:7 blog:8] blog.posts_imported
}