Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
188 lines
7.1 KiB
Go
188 lines
7.1 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ecdh"
|
|
"crypto/rand"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
webpush "github.com/SherClockHolmes/webpush-go"
|
|
"github.com/google/uuid"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"pageswiki/internal/store"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
type pushHTTPFixture func(*http.Request) (*http.Response, error)
|
|
|
|
func (f pushHTTPFixture) Do(r *http.Request) (*http.Response, error) { return f(r) }
|
|
|
|
func TestNotificationPushEncryptedDeliveryResponses(t *testing.T) {
|
|
s, _, domain, owner := taskFixture(t)
|
|
sub := storedBrowserPush{Subscription: testPushSubscription(t), Origin: "https://wiki.example"}
|
|
d := &store.NotificationPushDelivery{Notification: uuid.NewString(), Domain: domain, Owner: owner}
|
|
for _, code := range []int{201, 400, 404, 410, 429, 500} {
|
|
client := pushHTTPFixture(func(r *http.Request) (*http.Response, error) {
|
|
if r.Method != "POST" || r.URL.String() != sub.Endpoint || r.Header.Get("TTL") != "300" || r.Header.Get("Content-Encoding") != "aes128gcm" || !strings.HasPrefix(r.Header.Get("Authorization"), "vapid ") {
|
|
t.Fatal("invalid Web Push request")
|
|
}
|
|
body, e := io.ReadAll(r.Body)
|
|
if e != nil || strings.Contains(string(body), d.Notification) || strings.Contains(string(body), owner) {
|
|
t.Fatal("plaintext notification payload", e)
|
|
}
|
|
return &http.Response{StatusCode: code, Body: io.NopCloser(strings.NewReader(""))}, nil
|
|
})
|
|
success, retry, expired := s.sendNotificationPush(context.Background(), d, sub, client)
|
|
if success != (code == 201) || retry != (code == 429 || code == 500) || expired != (code == 404 || code == 410) {
|
|
t.Fatalf("delivery status %d: %v %v %v", code, success, retry, expired)
|
|
}
|
|
}
|
|
}
|
|
|
|
func testPushSubscription(t *testing.T) webpush.Subscription {
|
|
t.Helper()
|
|
key, err := ecdh.P256().GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return webpush.Subscription{Endpoint: "https://fcm.googleapis.com/fcm/send/test-fixture", Keys: webpush.Keys{Auth: base64.RawURLEncoding.EncodeToString(make([]byte, 16)), P256dh: base64.RawURLEncoding.EncodeToString(key.PublicKey().Bytes())}}
|
|
}
|
|
func TestNotificationPushEndpointsAndPrivacy(t *testing.T) {
|
|
s, token, domain, owner := taskFixture(t)
|
|
s.mux.HandleFunc("/_/api/v1/notifications/", s.handleNotificationsAPI)
|
|
call := func(method, token string, input any) *httptest.ResponseRecorder {
|
|
b, _ := json.Marshal(input)
|
|
r := httptest.NewRequest(method, "http://localhost/_/api/v1/notifications/push", strings.NewReader(string(b)))
|
|
r.Header.Set("Content-Type", "application/json")
|
|
if token != "" {
|
|
r.Header.Set("Authorization", "Bearer "+token)
|
|
}
|
|
w := httptest.NewRecorder()
|
|
s.withAuthorization(s.mux).ServeHTTP(w, r)
|
|
return w
|
|
}
|
|
if w := call("GET", "", nil); w.Code != 401 {
|
|
t.Fatalf("anonymous %d", w.Code)
|
|
}
|
|
w := call("GET", token, nil)
|
|
if w.Code != 200 || strings.Contains(w.Body.String(), "private") || !strings.Contains(w.Header().Get("Cache-Control"), "no-store") {
|
|
t.Fatalf("keys: %d %s", w.Code, w.Body)
|
|
}
|
|
sub := testPushSubscription(t)
|
|
if w = call("POST", token, browserPushInput{Subscription: sub, Focused: true}); w.Code != 200 {
|
|
t.Fatalf("subscribe %d %s", w.Code, w.Body)
|
|
}
|
|
var raw string
|
|
if err := s.store.DB.QueryRow(`SELECT session_hash FROM notification_push_subscriptions WHERE owner_uuid=? AND domain_uuid=?`, owner, domain).Scan(&raw); err != nil || raw == token || raw == "" {
|
|
t.Fatalf("token storage %v", err)
|
|
}
|
|
if w = call("DELETE", token, browserPushInput{Subscription: sub}); w.Code != 200 {
|
|
t.Fatalf("unsubscribe %d", w.Code)
|
|
}
|
|
for _, endpoint := range []string{"http://fcm.googleapis.com/test", "https://localhost/test", "https://127.0.0.1/test", "https://fcm.googleapis.com.evil.test/test", "https://fcm.googleapis.com:444/test", "https://user@fcm.googleapis.com/test", "https://fcm.googleapis.com/test#fragment"} {
|
|
copy := sub
|
|
copy.Endpoint = endpoint
|
|
if validPushSubscription(copy) {
|
|
t.Errorf("unsafe endpoint accepted: %s", endpoint)
|
|
}
|
|
}
|
|
sub.Keys.P256dh = "bad"
|
|
if validPushSubscription(sub) {
|
|
t.Fatal("bad curve accepted")
|
|
}
|
|
}
|
|
|
|
func TestNotificationPushQueueAtomicityRevocationAndFocus(t *testing.T) {
|
|
s, token, domain, owner := taskFixture(t)
|
|
ctx := context.Background()
|
|
sub := testPushSubscription(t)
|
|
raw, _ := json.Marshal(storedBrowserPush{Subscription: sub, Origin: "https://wiki.example"})
|
|
if err := s.store.SaveNotificationPush(ctx, domain, owner, token, sub.Endpoint, string(raw), true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
makeNotification := func(rollback bool) store.Notification {
|
|
t.Helper()
|
|
tx, e := s.store.DB.Begin()
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
n, _, e := s.store.CreateNotificationTx(tx, store.Notification{DomainUUID: domain, RecipientUUID: owner, EventUUID: uuid.NewString(), Kind: "task.due", Message: "private fixture"})
|
|
if e != nil {
|
|
tx.Rollback()
|
|
t.Fatal(e)
|
|
}
|
|
if rollback {
|
|
tx.Rollback()
|
|
} else if e = tx.Commit(); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
return n
|
|
}
|
|
makeNotification(true)
|
|
if d, e := s.store.ClaimNotificationPush(ctx); e != nil || d != nil {
|
|
t.Fatalf("rollback queued: %+v %v", d, e)
|
|
}
|
|
n := makeNotification(false)
|
|
d, e := s.store.ClaimNotificationPush(ctx)
|
|
if e != nil || d == nil || !d.Focused || d.Notification != n.UUID {
|
|
t.Fatalf("claim: %+v %v", d, e)
|
|
}
|
|
if second, e := s.store.ClaimNotificationPush(ctx); e != nil || second != nil {
|
|
t.Fatal("lease failed", e)
|
|
}
|
|
if e = s.store.DeferFocusedNotificationPush(ctx, d); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.store.AcknowledgeNotificationPush(ctx, domain, "wrong owner", sub.Endpoint, []string{n.UUID}); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
var count int
|
|
s.store.DB.QueryRow(`SELECT COUNT(*) FROM notification_push_queue`).Scan(&count)
|
|
if count != 1 {
|
|
t.Fatal("cross-owner acknowledgement")
|
|
}
|
|
if e = s.store.AcknowledgeNotificationPush(ctx, domain, owner, sub.Endpoint, []string{n.UUID}); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.store.SaveNotificationPush(ctx, domain, owner, token, sub.Endpoint, string(raw), false); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
makeNotification(false)
|
|
d, e = s.store.ClaimNotificationPush(ctx)
|
|
if e != nil || d == nil || d.Focused || d.Subscription == "" {
|
|
t.Fatalf("background claim: %+v %v", d, e)
|
|
}
|
|
if e = s.store.FinishNotificationPush(ctx, d, true, false); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if retry, e := s.store.ClaimNotificationPush(ctx); e != nil || retry != nil {
|
|
t.Fatal("retry not backed off", e)
|
|
}
|
|
if _, e = s.store.DB.Exec(`UPDATE notification_push_queue SET next_at_ms=0`); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.store.RevokeAuthSession(token); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
d, e = s.store.ClaimNotificationPush(ctx)
|
|
if e != nil || d == nil || d.Subscription != "" {
|
|
t.Fatalf("revoked session delivery: %+v %v", d, e)
|
|
}
|
|
if e = s.store.FinishNotificationPush(ctx, d, false, false); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if e = s.store.EnsureNotificationPushEvent(); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
s.store.DB.Exec(`UPDATE event_definitions SET enabled=0,interval_seconds=120 WHERE uuid='builtin.notification.push'`)
|
|
s.store.EnsureNotificationPushEvent()
|
|
var enabled, interval int
|
|
s.store.DB.QueryRow(`SELECT enabled,interval_seconds FROM event_definitions WHERE uuid='builtin.notification.push'`).Scan(&enabled, &interval)
|
|
if enabled != 0 || interval != 120 {
|
|
t.Fatal("operator scheduler settings overwritten")
|
|
}
|
|
}
|