Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

24.4 KB
Raw Blame
package controller

import (
	"context"
	"crypto/ecdh"
	"crypto/rand"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net"
	"net/http"
	"strings"
	"testing"
	"time"

	webpush "github.com/SherClockHolmes/webpush-go"
	timeutil "github.com/ente/museum/pkg/utils/time"
	"github.com/ente/museum/space/models"
	"github.com/ente/museum/space/repo"
	"github.com/stretchr/testify/require"
)

type recordedSpaceActivity struct {
	event        string
	actorUserID  int64
	actorSpaceID string
	actorSlug    string
	postID       int64
	postOwner    SpaceActivityActor
	commentID    string
	recipientIDs []int64
}

type recordingSpaceActivityNotifier struct {
	events chan recordedSpaceActivity
}

func newRecordingSpaceActivityNotifier() *recordingSpaceActivityNotifier {
	return &recordingSpaceActivityNotifier{events: make(chan recordedSpaceActivity, 8)}
}

func (n *recordingSpaceActivityNotifier) OnSpacePostCreated(actor SpaceActivityActor, postID int64) {
	n.events <- recordedSpaceActivity{
		event:        spaceActivityPostCreated,
		actorUserID:  actor.UserID,
		actorSpaceID: actor.SpaceID,
		actorSlug:    actor.Slug,
		postID:       postID,
	}
}

func (n *recordingSpaceActivityNotifier) OnSpacePostLiked(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityPostLiked, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) OnSpacePostReplied(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityPostReplied, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) OnSpaceMessageSent(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityMessageSent, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) OnSpacePokeSent(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityPokeSent, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) OnSpaceMessageLiked(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityMessageLiked, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) OnSpaceFriendAdded(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityFriendAdded, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) OnSpaceFriendRequested(actor SpaceActivityActor, recipientUserID int64) {
	n.record(spaceActivityFriendRequested, actor, recipientUserID)
}

func (n *recordingSpaceActivityNotifier) record(event string, actor SpaceActivityActor, recipientIDs ...int64) {
	n.events <- recordedSpaceActivity{
		event:        event,
		actorUserID:  actor.UserID,
		actorSpaceID: actor.SpaceID,
		actorSlug:    actor.Slug,
		recipientIDs: append([]int64(nil), recipientIDs...),
	}
}

func requireSpaceActivity(t *testing.T, notifier *recordingSpaceActivityNotifier) recordedSpaceActivity {
	t.Helper()
	select {
	case event := <-notifier.events:
		return event
	case <-time.After(time.Second):
		t.Fatal("timed out waiting for Space activity notification")
		return recordedSpaceActivity{}
	}
}

func requireNoSpaceActivity(t *testing.T, notifier *recordingSpaceActivityNotifier) {
	t.Helper()
	select {
	case event := <-notifier.events:
		t.Fatalf("unexpected Space activity notification: %+v", event)
	case <-time.After(100 * time.Millisecond):
	}
}

func TestSpaceWebPushCopyAndValidation(t *testing.T) {
	require.Equal(t, "@alice", spaceActivityActorLabel(" alice "))
	require.Equal(t, "A friend", spaceActivityActorLabel(" "))
	require.Equal(t, "/app/messages/space_id", conversationURL("space_id"))

	privateKey, err := ecdh.P256().GenerateKey(rand.Reader)
	require.NoError(t, err)
	p256dh := base64.RawURLEncoding.EncodeToString(privateKey.PublicKey().Bytes())
	auth := base64.RawURLEncoding.EncodeToString(make([]byte, 16))
	endpoint := "https://fcm.googleapis.com/wp/subscription"
	require.NoError(t, validateWebPushSubscription(endpoint, p256dh, auth))
	require.NoError(t, validateWebPushSubscription("https://updates.push.services.mozilla.com/wpush/v2/subscription", p256dh, auth))
	require.NoError(t, validateWebPushSubscription("https://web.push.apple.com/subscription", p256dh, auth))
	require.NoError(t, validateWebPushSubscription("https://db5.notify.windows.com/subscription", p256dh, auth))
	require.NoError(t, validateWebPushSubscription("https://jmt17.google.com/fcm/send/subscription", p256dh, auth))
	require.Error(t, validateWebPushSubscription("https://push.example/subscription", p256dh, auth))
	require.Error(t, validateWebPushSubscription("https://web.push.apple.com.attacker.example/subscription", p256dh, auth))
	require.Error(t, validateWebPushSubscription("https://fcm.googleapis.com:8443/wp/subscription", p256dh, auth))
	require.Error(t, validateWebPushSubscription("https://jmt17.google.com/other", p256dh, auth))
	require.Error(t, validateWebPushSubscription("http://fcm.googleapis.com/wp/subscription", p256dh, auth))
	require.Error(t, validateWebPushSubscription("https://[email protected]/wp/subscription", p256dh, auth))
	require.Error(t, validateWebPushSubscription(endpoint+"#fragment", p256dh, auth))
	require.Error(t, validateWebPushSubscription(endpoint, "invalid", auth))
	require.Error(t, validateWebPushSubscription(endpoint, p256dh, "invalid"))
}

func TestSpaceWebPushAddressMustBePublic(t *testing.T) {
	require.True(t, isPublicWebPushAddress(net.ParseIP("8.8.8.8")))
	require.True(t, isPublicWebPushAddress(net.ParseIP("2606:4700:4700::1111")))
	require.False(t, isPublicWebPushAddress(net.ParseIP("127.0.0.1")))
	require.False(t, isPublicWebPushAddress(net.ParseIP("10.0.0.1")))
	require.False(t, isPublicWebPushAddress(net.ParseIP("100.64.0.1")))
	require.False(t, isPublicWebPushAddress(net.ParseIP("192.0.2.1")))
	require.False(t, isPublicWebPushAddress(net.ParseIP("::1")))
	require.False(t, isPublicWebPushAddress(net.ParseIP("2001:db8::1")))
}

func TestSpaceWebPushConfigRequiresMatchingKeysAndBareSubscriber(t *testing.T) {
	privateKey, publicKey, err := webpush.GenerateVAPIDKeys()
	require.NoError(t, err)
	config := NewSpaceWebPushConfig(publicKey, privateKey, "[email protected]")
	require.NotNil(t, config)
	require.Equal(t, publicKey, config.publicKey)

	otherPrivateKey, _, err := webpush.GenerateVAPIDKeys()
	require.NoError(t, err)
	require.Nil(t, NewSpaceWebPushConfig(publicKey, otherPrivateKey, "[email protected]"))
	require.Nil(t, NewSpaceWebPushConfig(publicKey, privateKey, "mailto:[email protected]"))
	require.Nil(t, NewSpaceWebPushConfig("", "", ""))
}

func newSpaceWebPushTestConfig(t *testing.T) *SpaceWebPushConfig {
	t.Helper()
	privateKey, publicKey, err := webpush.GenerateVAPIDKeys()
	require.NoError(t, err)
	config := NewSpaceWebPushConfig(publicKey, privateKey, "[email protected]")
	require.NotNil(t, config)
	return config
}

func TestUnconfiguredSpaceWebPushSenderIsUnavailable(t *testing.T) {
	sender := NewSpaceWebPushSender(&repo.WebPushRepository{}, nil)
	require.False(t, sender.available())
	sender.OnSpacePostReplied(SpaceActivityActor{UserID: 1, SpaceID: "alice_space", Slug: "alice"}, 2)
}

func TestSpaceWebPushDeduplicatesSharedEndpointForAccount(t *testing.T) {
	subscriptions := deduplicateSpaceWebPushSubscriptions([]repo.SpaceWebPushSubscriptionRecord{
		{Endpoint: "https://push.example/shared", TargetID: "public", Public: true},
		{Endpoint: "https://push.example/shared", TargetID: "account"},
		{Endpoint: "https://push.example/other", TargetID: "other", Public: true},
	})
	require.Equal(t, []repo.SpaceWebPushSubscriptionRecord{
		{Endpoint: "https://push.example/shared", TargetID: "account"},
		{Endpoint: "https://push.example/other", TargetID: "other", Public: true},
	}, subscriptions)
}

func TestNewPostNotifiesWithNoAccountFriends(t *testing.T) {
	_, repos, _ := setupPostsControllerTest(t)
	notifier := newRecordingSpaceActivityNotifier()
	posts := NewModule(repos, nil, notifier, nil).Posts

	posts.notifyFriendsOfNewPost(SpaceActivityActor{UserID: 1, SpaceID: "space_id", Slug: "alice"}, 42)

	require.Equal(t, recordedSpaceActivity{
		event:        spaceActivityPostCreated,
		actorUserID:  1,
		actorSpaceID: "space_id",
		actorSlug:    "alice",
		postID:       42,
	}, requireSpaceActivity(t, notifier))
}

func TestPostLikeSendsActivityOnlyOnLikeTransition(t *testing.T) {
	_, repos, ctx := setupPostsControllerTest(t)
	notifier := newRecordingSpaceActivityNotifier()
	posts := NewModule(repos, nil, notifier, nil).Posts
	aliceID := insertSpaceControllerUser(t, repos, "[email protected]", "alice-public")
	bobID := insertSpaceControllerUser(t, repos, "[email protected]", "bob-public")
	aliceSpace, err := testCreateSpace(ctx, repos, aliceID, "alice_post_like_push", "alice-space-key", "alice-post-public", "alice-post-secret", "nonce", "alice-profile")
	require.NoError(t, err)
	bobSpace, err := testCreateSpace(ctx, repos, bobID, "bob_post_like_push", "bob-space-key", "bob-post-public", "bob-post-secret", "nonce", "bob-profile")
	require.NoError(t, err)
	require.NoError(t, testAddFriend(ctx, repos, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
	postID, err := testCreatePost(ctx, repos, aliceID, aliceSpace.SpaceID, "post-key", nil, aliceSpace.CurrentVersion, nil)
	require.NoError(t, err)

	_, err = posts.SetLike(ctx, bobSpace, postID, true)
	require.NoError(t, err)
	expected := recordedSpaceActivity{
		event:        spaceActivityPostLiked,
		actorUserID:  bobID,
		actorSpaceID: bobSpace.SpaceID,
		actorSlug:    bobSpace.SpaceSlug,
		recipientIDs: []int64{aliceID},
	}
	require.Equal(t, expected, requireSpaceActivity(t, notifier))

	_, err = posts.SetLike(ctx, bobSpace, postID, true)
	require.NoError(t, err)
	requireNoSpaceActivity(t, notifier)
	_, err = posts.SetLike(ctx, bobSpace, postID, false)
	require.NoError(t, err)
	requireNoSpaceActivity(t, notifier)
	_, err = posts.SetLike(ctx, bobSpace, postID, true)
	require.NoError(t, err)
	require.Equal(t, expected, requireSpaceActivity(t, notifier))
}

func TestMessageActivitiesAndLikeTransition(t *testing.T) {
	_, repos, ctx := setupMessagesControllerTest(t)
	notifier := newRecordingSpaceActivityNotifier()
	messages := NewModule(repos, nil, notifier, nil).Messages
	aliceID, aliceSpace := createMessageControllerUserAndSpace(t, repos, "alice-message-push", "alice-public")
	bobID, bobSpace := createMessageControllerUserAndSpace(t, repos, "bob-message-push", "bob-public")
	require.NoError(t, testAddFriend(ctx, repos, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
	request := models.CreateMessageRequest{
		MessageCipher:                spaceTestB64("cipher"),
		SenderEncryptedMessageKey:    spaceTestB64("sender-key"),
		RecipientEncryptedMessageKey: spaceTestB64("recipient-key"),
	}

	message, err := messages.Create(ctx, aliceSpace, bobSpace.SpaceID, request)
	require.NoError(t, err)
	require.Equal(t, recordedSpaceActivity{
		event:        spaceActivityMessageSent,
		actorUserID:  aliceID,
		actorSpaceID: aliceSpace.SpaceID,
		actorSlug:    aliceSpace.SpaceSlug,
		recipientIDs: []int64{bobID},
	}, requireSpaceActivity(t, notifier))

	pokeRequest := request
	pokeRequest.NotificationKind = spaceMessageNotificationKindPoke
	_, err = messages.Create(ctx, aliceSpace, bobSpace.SpaceID, pokeRequest)
	require.NoError(t, err)
	require.Equal(t, recordedSpaceActivity{
		event:        spaceActivityPokeSent,
		actorUserID:  aliceID,
		actorSpaceID: aliceSpace.SpaceID,
		actorSlug:    aliceSpace.SpaceSlug,
		recipientIDs: []int64{bobID},
	}, requireSpaceActivity(t, notifier))

	_, err = messages.SetLike(ctx, bobSpace, message.MessageID, true)
	require.NoError(t, err)
	expectedLike := recordedSpaceActivity{
		event:        spaceActivityMessageLiked,
		actorUserID:  bobID,
		actorSpaceID: bobSpace.SpaceID,
		actorSlug:    bobSpace.SpaceSlug,
		recipientIDs: []int64{aliceID},
	}
	require.Equal(t, expectedLike, requireSpaceActivity(t, notifier))
	_, err = messages.SetLike(ctx, bobSpace, message.MessageID, true)
	require.NoError(t, err)
	requireNoSpaceActivity(t, notifier)
	_, err = messages.SetLike(ctx, bobSpace, message.MessageID, false)
	require.NoError(t, err)
	requireNoSpaceActivity(t, notifier)

	postID, err := testCreatePost(ctx, repos, aliceID, aliceSpace.SpaceID, "post-key", nil, aliceSpace.CurrentVersion, nil)
	require.NoError(t, err)
	_, err = messages.ReplyToPost(ctx, bobSpace, postID, request)
	require.NoError(t, err)
	require.Equal(t, recordedSpaceActivity{
		event:        spaceActivityPostReplied,
		actorUserID:  bobID,
		actorSpaceID: bobSpace.SpaceID,
		actorSlug:    bobSpace.SpaceSlug,
		recipientIDs: []int64{aliceID},
	}, requireSpaceActivity(t, notifier))
}

func TestFriendActivitiesOnlyOnRelationshipTransitions(t *testing.T) {
	_, repos, ctx := setupFriendsControllerTest(t)
	notifier := newRecordingSpaceActivityNotifier()
	friends := NewModule(repos, nil, notifier, nil).Friends
	aliceID := insertSpaceControllerUser(t, repos, "[email protected]", "alice-public")
	bobID := insertSpaceControllerUser(t, repos, "[email protected]", "bob-public")
	aliceSpace, err := testCreateSpace(ctx, repos, aliceID, "alice_friend_push", "alice-space-key", "alice-public", "alice-secret", "nonce", "alice-profile")
	require.NoError(t, err)
	bobSpace, err := testCreateSpace(ctx, repos, bobID, "bob_friend_push", "bob-space-key", "bob-public", "bob-secret", "nonce", "bob-profile")
	require.NoError(t, err)
	request := models.AddFriendPayload{
		TargetSpaceID:                 aliceSpace.SpaceID,
		RequesterFriendSealedSpaceKey: base64.StdEncoding.EncodeToString([]byte("bob-requester-key")),
		RequesterKeyVersion:           bobSpace.CurrentVersion,
	}

	_, err = friends.Add(ctx, bobSpace, request)
	require.NoError(t, err)
	require.Equal(t, recordedSpaceActivity{
		event:        spaceActivityFriendRequested,
		actorUserID:  bobID,
		actorSpaceID: bobSpace.SpaceID,
		actorSlug:    bobSpace.SpaceSlug,
		recipientIDs: []int64{aliceID},
	}, requireSpaceActivity(t, notifier))
	_, err = friends.Add(ctx, bobSpace, request)
	require.NoError(t, err)
	requireNoSpaceActivity(t, notifier)

	requests, err := friends.ListRequests(ctx, aliceSpace)
	require.NoError(t, err)
	require.Len(t, requests, 1)
	_, err = friends.ConfirmRequest(ctx, aliceSpace, requests[0].RequestID, models.ConfirmFriendRequestPayload{
		TargetFriendSealedSpaceKey: base64.StdEncoding.EncodeToString([]byte("alice-target-key")),
		TargetKeyVersion:           aliceSpace.CurrentVersion,
	})
	require.NoError(t, err)
	require.Equal(t, recordedSpaceActivity{
		event:        spaceActivityFriendAdded,
		actorUserID:  aliceID,
		actorSpaceID: aliceSpace.SpaceID,
		actorSlug:    aliceSpace.SpaceSlug,
		recipientIDs: []int64{bobID},
	}, requireSpaceActivity(t, notifier))
}

func TestSpaceWebPushSenderUsesPokePayloadAndPrunesDeadEndpoint(t *testing.T) {
	_, repos, ctx := setupPostsControllerTest(t)
	recipientID := insertSpaceControllerUser(t, repos, "[email protected]", "recipient-public")
	sessionHash := []byte("space-push-session-hash")
	require.NoError(t, repos.Sessions.CreateBrowserSession(ctx, sessionHash, recipientID, "wrap-key", timeutil.NDaysFromNow(1)))
	_, err := repos.WebPush.UpsertAccountSubscription(ctx, sessionHash, "https://fcm.googleapis.com/wp/subscription", "p256dh", "auth")
	require.NoError(t, err)

	config := newSpaceWebPushTestConfig(t)

	originalSend := sendSpaceWebPush
	t.Cleanup(func() { sendSpaceWebPush = originalSend })
	var payload spaceWebPushPayload
	sendSpaceWebPush = func(_ context.Context, message []byte, subscription *webpush.Subscription, options *webpush.Options) (*http.Response, error) {
		require.Equal(t, "https://fcm.googleapis.com/wp/subscription", subscription.Endpoint)
		require.Equal(t, uint32(spaceWebPushRecordSize), options.RecordSize)
		require.Equal(t, spaceWebPushTTLSeconds, options.TTL)
		require.Equal(t, webpush.UrgencyNormal, options.Urgency)
		require.Equal(t, "[email protected]", options.Subscriber)
		require.NoError(t, json.Unmarshal(message, &payload))
		return &http.Response{StatusCode: http.StatusGone, Body: io.NopCloser(strings.NewReader(""))}, nil
	}

	sender := NewSpaceWebPushSender(repos.WebPush, config)
	sender.OnSpacePokeSent(SpaceActivityActor{UserID: 1, SpaceID: "alice_space", Slug: "alice"}, recipientID)
	require.Equal(t, spaceWebPushPayload{
		Title:  "Ente Space",
		Body:   "@alice poked you",
		Action: "Post a photo",
		URL:    "/app/post",
	}, payload)
	var count int
	require.NoError(t, repos.WebPush.DB.QueryRow(`SELECT COUNT(*) FROM space_web_push_subscriptions`).Scan(&count))
	require.Zero(t, count)
}

func TestPublicPostPushCarriesOnlyOpaqueLocalRouteTarget(t *testing.T) {
	config := newSpaceWebPushTestConfig(t)

	originalSend := sendSpaceWebPush
	t.Cleanup(func() { sendSpaceWebPush = originalSend })
	var payload spaceWebPushPayload
	sendSpaceWebPush = func(_ context.Context, message []byte, _ *webpush.Subscription, _ *webpush.Options) (*http.Response, error) {
		require.NoError(t, json.Unmarshal(message, &payload))
		return &http.Response{StatusCode: http.StatusCreated, Body: io.NopCloser(strings.NewReader(""))}, nil
	}

	sender := NewSpaceWebPushSender(nil, config)
	sender.send(
		SpaceActivityActor{UserID: 2, Slug: "alice"},
		"shared a new post",
		"Check it out",
		spaceActivityPostCreated,
		"/app",
		[]repo.SpaceWebPushSubscriptionRecord{{
			Endpoint: "https://fcm.googleapis.com/wp/public",
			P256dh:   "p256dh",
			Auth:     "auth",
			TargetID: "wpt_public_target",
			Public:   true,
		}},
	)
	require.Equal(t, spaceWebPushPayload{
		Title:    "Ente Space",
		Body:     "@alice shared a new post",
		Action:   "Check it out",
		TargetID: "wpt_public_target",
	}, payload)
}

func TestFriendAndDiscussionPushNotificationDestinations(t *testing.T) {
	_, repos, ctx := setupPostsControllerTest(t)
	recipientID := insertSpaceControllerUser(t, repos, "[email protected]", "recipient-public")
	sessionHash := []byte("friend-push-session")
	require.NoError(t, repos.Sessions.CreateBrowserSession(ctx, sessionHash, recipientID, "wrap-key", timeutil.NDaysFromNow(1)))
	_, err := repos.WebPush.UpsertAccountSubscription(ctx, sessionHash, "https://fcm.googleapis.com/wp/friend", "p256dh", "auth")
	require.NoError(t, err)
	originalSend := sendSpaceWebPush
	t.Cleanup(func() { sendSpaceWebPush = originalSend })
	var payload spaceWebPushPayload
	sendSpaceWebPush = func(_ context.Context, message []byte, _ *webpush.Subscription, _ *webpush.Options) (*http.Response, error) {
		require.NoError(t, json.Unmarshal(message, &payload))
		return &http.Response{StatusCode: http.StatusCreated, Body: io.NopCloser(strings.NewReader(""))}, nil
	}
	sender := NewSpaceWebPushSender(repos.WebPush, newSpaceWebPushTestConfig(t))
	actor := SpaceActivityActor{UserID: recipientID + 1, SpaceID: "alice-space", Slug: "alice"}
	sender.OnSpaceFriendRequested(actor, recipientID)
	require.Equal(t, spaceWebPushPayload{Title: "Ente Space", Body: "@alice sent you a friend request", Action: "Review request", URL: "/app/notifications"}, payload)
	sender.OnSpaceFriendAdded(actor, recipientID)
	require.Equal(t, spaceWebPushPayload{Title: "Ente Space", Body: "@alice accepted your friend request", Action: "Say hi", URL: "/app/messages/alice-space"}, payload)
	recipientOwner := SpaceActivityActor{UserID: recipientID, SpaceID: "post-owner", Slug: "recipient"}
	otherOwner := SpaceActivityActor{UserID: recipientID + 2, SpaceID: "post-owner", Slug: "bob"}
	for _, test := range []struct {
		name      string
		kind      string
		postOwner SpaceActivityActor
		body      string
	}{
		{"comment-on-your-post", "comment", recipientOwner, "@alice commented on your post"},
		{"comment-on-another-post", "comment", otherOwner, "@alice commented on @bob's post"},
		{"comment-on-own-post", "comment", actor, "@alice commented on their post"},
		{"reply-on-your-post", "comment_reply", recipientOwner, "@alice replied to your comment"},
		{"reply-on-another-post", "comment_reply", otherOwner, "@alice replied to your comment"},
		{"reply-on-own-post", "comment_reply", actor, "@alice replied to your comment"},
		{"reaction-on-your-post", "comment_reaction", recipientOwner, "@alice reacted to your comment"},
		{"reaction-on-another-post", "comment_reaction", otherOwner, "@alice reacted to your comment"},
		{"reaction-on-own-post", "comment_reaction", actor, "@alice reacted to your comment"},
	} {
		t.Run(test.name, func(t *testing.T) {
			payload = spaceWebPushPayload{}
			sender.OnSpaceComment(actor, []repo.CommentNotificationRecipient{{UserID: recipientID, Kind: test.kind}}, test.postOwner, 42, "comment/with space")
			require.Equal(t, spaceWebPushPayload{
				Title:  "Ente Space",
				Body:   test.body,
				Action: "View comments",
				URL:    "/app/posts/" + test.postOwner.SpaceID + "/42?comments=1&comment=comment%2Fwith+space",
			}, payload)
		})
	}
}

func TestSpaceWebPushSendRateAppliesOncePerActivity(t *testing.T) {
	config := newSpaceWebPushTestConfig(t)

	originalSend := sendSpaceWebPush
	t.Cleanup(func() { sendSpaceWebPush = originalSend })
	sent := make(chan struct{}, 51)
	sendSpaceWebPush = func(_ context.Context, _ []byte, _ *webpush.Subscription, _ *webpush.Options) (*http.Response, error) {
		sent <- struct{}{}
		return &http.Response{StatusCode: http.StatusCreated, Body: io.NopCloser(strings.NewReader(""))}, nil
	}

	subscriptions := make([]repo.SpaceWebPushSubscriptionRecord, 51)
	for index := range subscriptions {
		subscriptions[index] = repo.SpaceWebPushSubscriptionRecord{
			Endpoint: fmt.Sprintf("https://fcm.googleapis.com/wp/%d", index),
			P256dh:   "p256dh",
			Auth:     "auth",
		}
	}
	NewSpaceWebPushSender(nil, config).send(
		SpaceActivityActor{UserID: 3, Slug: "alice"},
		"shared a new post",
		"Check it out",
		spaceActivityPostCreated,
		"/app",
		subscriptions,
	)
	require.Equal(t, len(subscriptions), len(sent))
}

func TestCommentPushQuotaAppliesOnceAcrossRecipients(t *testing.T) {
	_, repos, ctx := setupPostsControllerTest(t)
	var recipients []repo.CommentNotificationRecipient
	var endpoints []string
	for i := range 10 {
		userID := insertSpaceControllerUser(t, repos, fmt.Sprintf("comment-push-%d@example.com", i), "public")
		sessionHash := []byte(fmt.Sprintf("comment-push-session-%d", i))
		require.NoError(t, repos.Sessions.CreateBrowserSession(ctx, sessionHash, userID, "wrap-key", timeutil.NDaysFromNow(1)))
		endpoint := fmt.Sprintf("https://fcm.googleapis.com/wp/comment-%d", i)
		_, err := repos.WebPush.UpsertAccountSubscription(ctx, sessionHash, endpoint, "p256dh", "auth")
		require.NoError(t, err)
		recipients = append(recipients, repo.CommentNotificationRecipient{UserID: userID, Kind: "comment"})
		endpoints = append(endpoints, endpoint)
	}
	recipients[0].Kind = "comment_reply"
	originalSend := sendSpaceWebPush
	t.Cleanup(func() { sendSpaceWebPush = originalSend })
	sent := make(chan string, len(recipients))
	sendSpaceWebPush = func(_ context.Context, _ []byte, subscription *webpush.Subscription, _ *webpush.Options) (*http.Response, error) {
		sent <- subscription.Endpoint
		return &http.Response{StatusCode: http.StatusCreated, Body: io.NopCloser(strings.NewReader(""))}, nil
	}
	actor := SpaceActivityActor{UserID: 100, SpaceID: "actor", Slug: "alice"}
	owner := SpaceActivityActor{UserID: recipients[1].UserID, SpaceID: "owner", Slug: "bob"}
	for _, priorActivities := range []int{0, 49} {
		t.Run(fmt.Sprintf("after-%d-activities", priorActivities), func(t *testing.T) {
			sender := NewSpaceWebPushSender(repos.WebPush, newSpaceWebPushTestConfig(t))
			sender.OnSpaceComment(actor, []repo.CommentNotificationRecipient{{UserID: actor.UserID, Kind: "comment"}}, owner, 42, "no-subscribers")
			for range priorActivities {
				sender.OnSpaceFriendAdded(actor, recipients[0].UserID)
				require.Len(t, sent, 1)
				<-sent
			}
			for i := range 50 - priorActivities {
				sender.OnSpaceComment(actor, recipients, owner, 42, fmt.Sprintf("comment-%d", i))
				require.Len(t, sent, len(recipients))
				var delivered []string
				for range recipients {
					delivered = append(delivered, <-sent)
				}
				require.ElementsMatch(t, endpoints, delivered)
			}
			sender.OnSpaceComment(actor, recipients, owner, 42, "over-limit")
			require.Empty(t, sent)
			sender.OnSpaceFriendAdded(actor, recipients[0].UserID)
			require.Empty(t, sent)
		})
	}
}

func (n *recordingSpaceActivityNotifier) OnSpaceComment(actor SpaceActivityActor, recipients []repo.CommentNotificationRecipient, postOwner SpaceActivityActor, postID int64, commentID string) {
	for _, recipient := range recipients {
		n.events <- recordedSpaceActivity{
			event:        recipient.Kind,
			actorUserID:  actor.UserID,
			actorSpaceID: actor.SpaceID,
			actorSlug:    actor.Slug,
			postID:       postID,
			postOwner:    postOwner,
			commentID:    commentID,
			recipientIDs: []int64{recipient.UserID},
		}
	}
}