π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package repo
import (
"bytes"
"context"
"crypto/sha256"
"database/sql"
"errors"
"sort"
"strconv"
"sync"
"testing"
"github.com/ente/museum/ente"
"github.com/ente/museum/internal/testutil"
timeutil "github.com/ente/museum/pkg/utils/time"
"github.com/stretchr/testify/require"
)
func newSpaceTestModule(t *testing.T) *Module {
t.Helper()
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() {
testutil.ResetTables(t, db)
})
return NewModule(db, nil)
}
type SpaceMessageConversationRecord struct {
Friend SpaceActorRecord
LatestActivity SpaceMessageConversationActivityRecord
UnreadActivities []SpaceMessageConversationActivityRecord
Unread bool
UnreadCount int64
NotificationUnread bool
SortCreatedAt int64
SortID string
}
func listTestConversations(ctx context.Context, module *Module, viewerSpaceID string, cursor string, limit int) ([]SpaceMessageConversationRecord, string, error) {
friends, err := module.Friends.ListFriendsForSpace(ctx, viewerSpaceID)
if err != nil {
return nil, "", err
}
friendSpaceIDs := make([]string, 0, len(friends))
for _, friend := range friends {
friendSpaceIDs = append(friendSpaceIDs, friend.Friend.SpaceID)
}
summaries, err := module.Messages.ListLatestChatSummaries(ctx, viewerSpaceID, friendSpaceIDs)
if err != nil {
return nil, "", err
}
conversations := make([]SpaceMessageConversationRecord, 0, len(friends))
for _, friend := range friends {
summary, ok := summaries[friend.Friend.SpaceID]
conversation := SpaceMessageConversationRecord{
Friend: friend.Friend,
}
if ok {
conversation.LatestActivity = summary.LatestActivity
conversation.UnreadActivities = summary.UnreadActivities
conversation.UnreadCount = countChatUnreadActivities(summary.UnreadActivities)
conversation.Unread = conversation.UnreadCount > 0
conversation.NotificationUnread = len(summary.UnreadActivities) > 0
} else {
conversation.LatestActivity = SpaceMessageConversationActivityRecord{
ID: "empty:" + friend.Friend.SpaceID,
Type: "empty",
CreatedAt: friend.CreatedAt,
}
}
conversation.SortCreatedAt = conversation.LatestActivity.CreatedAt
conversation.SortID = conversation.LatestActivity.ID
conversations = append(conversations, conversation)
}
sort.Slice(conversations, func(i, j int) bool {
if conversations[i].SortCreatedAt != conversations[j].SortCreatedAt {
return conversations[i].SortCreatedAt > conversations[j].SortCreatedAt
}
return conversations[i].SortID > conversations[j].SortID
})
if createdAt, id, ok := parseMessageCursor(cursor); ok {
filtered := conversations[:0]
for _, conversation := range conversations {
if conversation.SortCreatedAt < createdAt || (conversation.SortCreatedAt == createdAt && conversation.SortID < id) {
filtered = append(filtered, conversation)
}
}
conversations = filtered
}
limit = optionalInt(limit, 50)
if limit > 100 {
limit = 100
}
nextCursor := ""
if len(conversations) > limit {
last := conversations[limit-1]
nextCursor = strconv.FormatInt(last.SortCreatedAt, 10) + ":" + last.SortID
conversations = conversations[:limit]
}
return conversations, nextCursor, nil
}
func countChatUnreadActivities(activities []SpaceMessageConversationActivityRecord) int64 {
var count int64
for _, activity := range activities {
if activity.Type == "message" || activity.Type == "post_reply" {
count++
}
}
return count
}
func testSpaceBytes(value string) []byte {
return []byte(value)
}
func testCreateSpace(ctx context.Context, module *Module, ownerID int64, spaceSlug string, rootWrappedSpaceKey string, publicKey string, encryptedSecretKey string, _ string, encryptedProfile string) (*SpaceRecord, error) {
return module.Spaces.CreateSpace(ctx, ownerID, spaceSlug, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(publicKey), testSpaceBytes(encryptedSecretKey), testSpaceBytes(encryptedProfile), "")
}
func testUpdateProfile(ctx context.Context, module *Module, _ int64, spaceID string, keyVersion int, encryptedProfile string, avatar *ProfileAssetUpdate, cover *ProfileAssetUpdate, removeAvatar bool, removeCover bool) (*SpaceRecord, error) {
return module.Spaces.UpdateProfile(ctx, spaceID, keyVersion, testSpaceBytes(encryptedProfile), avatar, cover, removeAvatar, removeCover)
}
func testRotateKey(ctx context.Context, module *Module, _ int64, spaceID string, keyVersion int, rootWrappedSpaceKey string, wrappedPrevKey string, encryptedProfile string) (*SpaceRecord, error) {
return module.Spaces.RotateKey(ctx, spaceID, keyVersion, testSpaceBytes(rootWrappedSpaceKey), testSpaceBytes(wrappedPrevKey), testSpaceBytes(encryptedProfile), nil, nil)
}
func testAddFriend(ctx context.Context, module *Module, requesterID int64, requesterSpaceID string, targetSpaceID string, targetFriendSealedSpaceKey string, targetKeyVersion int, requesterFriendSealedSpaceKey string, requesterKeyVersion int) error {
request, _, _, err := module.Friends.CreateFriendRequest(ctx, requesterID, requesterSpaceID, targetSpaceID, testSpaceBytes(requesterFriendSealedSpaceKey), requesterKeyVersion)
if err != nil {
return err
}
_, _, err = module.Friends.ConfirmFriendRequest(ctx, targetSpaceID, request.RequestID, testSpaceBytes(targetFriendSealedSpaceKey), targetKeyVersion)
if err != nil {
return err
}
res, err := module.Messages.DB.ExecContext(ctx, `
DELETE FROM space_notifications
WHERE kind = 'friend_accepted'
AND (
(actor_space_id = $1 AND recipient_space_id = $2)
OR (actor_space_id = $2 AND recipient_space_id = $1)
)
`, requesterSpaceID, targetSpaceID)
if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
_, err = module.Read.DB.ExecContext(ctx, `
INSERT INTO space_notification_read_markers (viewer_space_id, friend_space_id, read_at)
VALUES ($1, $2, 1), ($2, $1, 1)
ON CONFLICT (viewer_space_id, friend_space_id) DO UPDATE
SET read_at = EXCLUDED.read_at
`, requesterSpaceID, targetSpaceID)
return err
}
func testSetPostLike(ctx context.Context, module *Module, postID int64, actorSpaceID string, like bool) error {
_, err := module.Posts.SetLikeWithCreated(ctx, postID, actorSpaceID, like)
return err
}
func testCreateFriendRequest(ctx context.Context, module *Module, requesterID int64, requesterSpaceID string, targetSpaceID string, requesterFriendSealedSpaceKey string, requesterKeyVersion int) (*SpaceFriendRequestRecord, bool, error) {
request, created, _, err := module.Friends.CreateFriendRequest(ctx, requesterID, requesterSpaceID, targetSpaceID, testSpaceBytes(requesterFriendSealedSpaceKey), requesterKeyVersion)
return request, created, err
}
func testConfirmFriendRequest(ctx context.Context, module *Module, _ int64, targetSpaceID string, requestID int64, targetFriendSealedSpaceKey string, targetKeyVersion int) (int64, bool, error) {
return module.Friends.ConfirmFriendRequest(ctx, targetSpaceID, requestID, testSpaceBytes(targetFriendSealedSpaceKey), targetKeyVersion)
}
func addTestSpaceFriends(t *testing.T, ctx context.Context, module *Module, space *SpaceRecord, prefix string, count int) {
t.Helper()
for i := 0; i < count; i++ {
suffix := strconv.Itoa(i)
friendID := insertSpaceUser(t, module, prefix+"-"+suffix+"@example.com", prefix+"-public-"+suffix)
friendSpace, err := testCreateSpace(ctx, module, friendID, prefix+"_"+suffix, "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
require.NoError(t, testUpsertShare(ctx, module, space.SpaceID, friendSpace.SpaceID, "friend-share", space.CurrentVersion))
require.NoError(t, testUpsertShare(ctx, module, friendSpace.SpaceID, space.SpaceID, "space-share", friendSpace.CurrentVersion))
}
}
func testUpsertShare(ctx context.Context, module *Module, spaceID string, friendSpaceID string, friendSealedSpaceKey string, keyVersion int) error {
return upsertFriendShare(ctx, module.Friends.DB, friendShareMutation{
SpaceID: spaceID,
FriendSpaceID: friendSpaceID,
FriendSealedSpaceKey: testSpaceBytes(friendSealedSpaceKey),
KeyVersion: keyVersion,
})
}
func testUpdateShare(ctx context.Context, module *Module, spaceID string, friendSpaceID string, friendSealedSpaceKey string, keyVersion int) error {
return module.Friends.UpdateShares(ctx, spaceID, []SpaceShareUpdateRecord{
{FriendSpaceID: friendSpaceID, FriendSealedSpaceKey: testSpaceBytes(friendSealedSpaceKey)},
}, keyVersion)
}
func deleteShareBySpaceAndFriend(ctx context.Context, module *Module, spaceID string, friendSpaceID string) error {
_, err := module.Friends.DB.ExecContext(ctx, `DELETE FROM space_friend_shares WHERE space_id = $1 AND friend_space_id = $2`, spaceID, friendSpaceID)
return err
}
func testCreatePost(ctx context.Context, module *Module, _ int64, spaceID string, encryptedPostKey string, captionCipher *string, keyVersion int, objects []SpacePostAssetRecord) (int64, error) {
var caption []byte
if captionCipher != nil {
caption = testSpaceBytes(*captionCipher)
}
postID, _, err := module.Posts.CreatePost(ctx, spaceID, testSpaceBytes(encryptedPostKey), caption, keyVersion, objects, "")
return postID, err
}
func TestCreateSpaceEnforcesOneSpacePerOwner(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
userID := insertSpaceUser(t, module, "[email protected]", "space-limit-public")
_, err := testCreateSpace(ctx, module, userID, "space_limit", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, err = testCreateSpace(ctx, module, userID, "another_space", "root", "public", "secret", "nonce", "profile")
require.ErrorIs(t, err, ErrSpaceOwnerLimitReached)
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM spaces WHERE owner_id = $1`, userID))
}
func TestCreateSpaceRejectsInvalidSlug(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
userID := insertSpaceUser(t, module, "[email protected]", "create-invalid-public")
_, err := testCreateSpace(ctx, module, userID, "ente", "root", "public", "secret", "nonce", "profile")
require.Error(t, err)
require.Contains(t, err.Error(), "spaceSlug is reserved")
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM spaces WHERE owner_id = $1`, userID))
}
func TestUpdateSlugRejectsInvalidSlug(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
userID := insertSpaceUser(t, module, "[email protected]", "update-invalid-public")
space, err := testCreateSpace(ctx, module, userID, "valid_slug", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, err = module.Spaces.UpdateSlug(ctx, space.SpaceID, "ente")
require.Error(t, err)
require.Contains(t, err.Error(), "spaceSlug is reserved")
unchanged, err := module.Spaces.GetSpaceByID(ctx, space.SpaceID)
require.NoError(t, err)
require.Equal(t, "valid_slug", unchanged.SpaceSlug)
}
func TestCreatePostEnforcesSpacePostLimit(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
userID := insertSpaceUser(t, module, "[email protected]", "post-limit-public")
space, err := testCreateSpace(ctx, module, userID, "post_limit", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, err = module.Posts.DB.ExecContext(ctx, `
INSERT INTO space_posts (space_id, encrypted_post_key, key_version)
SELECT $1, 'post-key', $2
FROM generate_series(1, $3)
`, space.SpaceID, space.CurrentVersion, MaxPostsPerSpace)
require.NoError(t, err)
_, postCount, err := module.Posts.CreatePost(ctx, space.SpaceID, testSpaceBytes("post-key"), nil, space.CurrentVersion, nil, "")
require.ErrorIs(t, err, ErrSpacePostLimitReached)
require.Equal(t, MaxPostsPerSpace, postCount)
_, err = module.Posts.DB.ExecContext(ctx, `
UPDATE space_posts
SET is_deleted = TRUE
WHERE post_id = (
SELECT MIN(post_id)
FROM space_posts
WHERE space_id = $1
)
`, space.SpaceID)
require.NoError(t, err)
postID, postCount, err := module.Posts.CreatePost(ctx, space.SpaceID, testSpaceBytes("post-key"), nil, space.CurrentVersion, nil, "")
require.NoError(t, err)
require.NotZero(t, postID)
require.Equal(t, MaxPostsPerSpace, postCount)
}
func TestCreateMessageEnforcesSenderLimit(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
aliceID := insertSpaceUser(t, module, "[email protected]", "message-limit-alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "message-limit-bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "message_limit_alice", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "message_limit_bob", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, err = module.Messages.DB.ExecContext(ctx, `
INSERT INTO space_messages (
message_id,
sender_space_id,
recipient_space_id,
kind,
message_cipher,
sender_encrypted_message_key,
recipient_encrypted_message_key
)
SELECT 'message-limit-' || value, $1, $2, 'regular', $3, $4, $5
FROM generate_series(1, $6) AS value
`, aliceSpace.SpaceID, bobSpace.SpaceID, testSpaceBytes("cipher"), testSpaceBytes("sender-key"), testSpaceBytes("recipient-key"), MaxActiveMessagesSentPerSpace)
require.NoError(t, err)
input := CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("cipher"),
SenderEncryptedMessageKey: testSpaceBytes("sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("recipient-key"),
}
_, err = module.Messages.CreateMessage(ctx, input)
require.ErrorIs(t, err, ErrSpaceMessageLimitReached)
input.SenderSpaceID = bobSpace.SpaceID
input.RecipientSpaceID = aliceSpace.SpaceID
_, err = module.Messages.CreateMessage(ctx, input)
require.NoError(t, err)
require.NoError(t, module.Messages.DeleteMessage(ctx, "message-limit-1", aliceSpace.SpaceID))
input.SenderSpaceID = aliceSpace.SpaceID
input.RecipientSpaceID = bobSpace.SpaceID
_, err = module.Messages.CreateMessage(ctx, input)
require.NoError(t, err)
}
func insertPendingFriendRequests(t *testing.T, module *Module, fixedSpaceID string, fixedSpaceIsRequester bool) (string, int64) {
t.Helper()
var peerSpaceID string
var firstRequestID int64
err := module.Friends.DB.QueryRow(`
WITH peers AS (
INSERT INTO users (encrypted_email, email_decryption_nonce, email_hash, creation_time)
SELECT convert_to('friend-request-limit-' || value || '@example.com', 'UTF8'), '\x00'::bytea,
'friend-request-limit-' || value || '@example.com', 1
FROM generate_series(1, $2) AS value
RETURNING user_id
), peer_spaces AS (
INSERT INTO spaces (space_id, owner_id, space_slug, root_wrapped_space_key,
public_key, encrypted_secret_key)
SELECT 'friend_request_limit_' || user_id, user_id,
'friend_request_limit_' || user_id, '\x00'::bytea, '\x00'::bytea, '\x00'::bytea
FROM peers
RETURNING space_id
), requests AS (
INSERT INTO space_friend_requests
(requester_space_id, target_space_id, requester_friend_sealed_space_key, requester_key_version)
SELECT CASE WHEN $3 THEN $1 ELSE space_id END,
CASE WHEN $3 THEN space_id ELSE $1 END,
'\x00'::bytea,
1
FROM peer_spaces
RETURNING request_id, requester_space_id, target_space_id
)
SELECT CASE WHEN $3 THEN target_space_id ELSE requester_space_id END, request_id
FROM requests
ORDER BY request_id
LIMIT 1
`, fixedSpaceID, MaxPendingFriendRequestsPerSpace, fixedSpaceIsRequester).Scan(&peerSpaceID, &firstRequestID)
require.NoError(t, err)
return peerSpaceID, firstRequestID
}
func insertIncomingFriendRequests(t *testing.T, module *Module, targetSpaceID string) int64 {
t.Helper()
_, firstRequestID := insertPendingFriendRequests(t, module, targetSpaceID, false)
return firstRequestID
}
func insertOutgoingFriendRequests(t *testing.T, module *Module, requesterSpaceID string) (string, int64) {
t.Helper()
return insertPendingFriendRequests(t, module, requesterSpaceID, true)
}
func TestCreateFriendRequestEnforcesTargetLimit(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
targetID := insertSpaceUser(t, module, "[email protected]", "request-limit-target-public")
targetSpace, err := testCreateSpace(ctx, module, targetID, "request_limit_target", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
firstRequestID := insertIncomingFriendRequests(t, module, targetSpace.SpaceID)
extraID := insertSpaceUser(t, module, "[email protected]", "request-limit-extra-public")
extraSpace, err := testCreateSpace(ctx, module, extraID, "request_limit_extra", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, _, err = testCreateFriendRequest(ctx, module, extraID, extraSpace.SpaceID, targetSpace.SpaceID, "share-key", extraSpace.CurrentVersion)
require.ErrorIs(t, err, ErrSpaceFriendRequestLimitReached)
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, targetSpace.SpaceID, firstRequestID))
_, created, err := testCreateFriendRequest(ctx, module, extraID, extraSpace.SpaceID, targetSpace.SpaceID, "share-key", extraSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
}
func TestCreateFriendRequestEnforcesSenderLimit(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
requesterID := insertSpaceUser(t, module, "[email protected]", "sender-limit-public")
requester, err := testCreateSpace(ctx, module, requesterID, "sender_limit", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
firstTargetSpaceID, firstRequestID := insertOutgoingFriendRequests(t, module, requester.SpaceID)
extraID := insertSpaceUser(t, module, "[email protected]", "sender-extra-public")
extra, err := testCreateSpace(ctx, module, extraID, "sender_extra", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, created, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, extra.SpaceID, "share-key", requester.CurrentVersion)
require.ErrorIs(t, err, ErrSpaceSentFriendRequestLimitReached)
require.False(t, created)
require.Equal(t, int64(MaxPendingFriendRequestsPerSpace), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1`, requester.SpaceID))
request, created, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, firstTargetSpaceID, "updated-share-key", requester.CurrentVersion)
require.NoError(t, err)
require.False(t, created)
require.Equal(t, firstRequestID, request.RequestID)
require.Equal(t, []byte("updated-share-key"), request.RequesterFriendSealedSpaceKey)
_, created, err = testCreateFriendRequest(ctx, module, extraID, extra.SpaceID, requester.SpaceID, "extra-share-key", extra.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
_, created, becameFriends, err := module.Friends.CreateFriendRequest(ctx, requesterID, requester.SpaceID, extra.SpaceID, []byte("share-key"), requester.CurrentVersion)
require.NoError(t, err)
require.False(t, created)
require.True(t, becameFriends)
require.Equal(t, int64(MaxPendingFriendRequestsPerSpace), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1`, requester.SpaceID))
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, requester.SpaceID, firstRequestID))
request, created, err = testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, firstTargetSpaceID, "share-key", requester.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
require.NotEqual(t, firstRequestID, request.RequestID)
_, becameFriends, err = module.Friends.ConfirmFriendRequest(ctx, firstTargetSpaceID, request.RequestID, []byte("target-share-key"), 1)
require.NoError(t, err)
require.True(t, becameFriends)
require.Equal(t, int64(MaxPendingFriendRequestsPerSpace-1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1`, requester.SpaceID))
}
func TestCreateFriendRequestsBeyondNine(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
requesterID := insertSpaceUser(t, module, "[email protected]", "requester-public")
requester, err := testCreateSpace(ctx, module, requesterID, "requester", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
addTestSpaceFriends(t, ctx, module, requester, "existing_friend", 12)
for i := 0; i < 12; i++ {
suffix := strconv.Itoa(i)
targetID := insertSpaceUser(t, module, "target-"+suffix+"@example.com", "target-public-"+suffix)
target, err := testCreateSpace(ctx, module, targetID, "target_"+suffix, "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
_, created, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, target.SpaceID, "share-key", requester.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
}
require.Equal(t, int64(12), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1`, requester.SpaceID))
}
func TestAcceptFriendRequestBeyondNine(t *testing.T) {
for _, operation := range []string{"confirm", "reciprocal"} {
t.Run(operation, func(t *testing.T) {
module := newSpaceTestModule(t)
ctx := context.Background()
requesterID := insertSpaceUser(t, module, "[email protected]", "requester-public")
targetID := insertSpaceUser(t, module, "[email protected]", "target-public")
requester, err := testCreateSpace(ctx, module, requesterID, "requester", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
target, err := testCreateSpace(ctx, module, targetID, "target", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
request, _, err := testCreateFriendRequest(ctx, module, requesterID, requester.SpaceID, target.SpaceID, "requester-share", requester.CurrentVersion)
require.NoError(t, err)
addTestSpaceFriends(t, ctx, module, requester, "requester_friend", 12)
addTestSpaceFriends(t, ctx, module, target, "target_friend", 12)
var becameFriends bool
if operation == "confirm" {
_, becameFriends, err = module.Friends.ConfirmFriendRequest(ctx, target.SpaceID, request.RequestID, []byte("target-share"), target.CurrentVersion)
} else {
_, _, becameFriends, err = module.Friends.CreateFriendRequest(ctx, targetID, target.SpaceID, requester.SpaceID, []byte("target-share"), target.CurrentVersion)
}
require.NoError(t, err)
require.True(t, becameFriends)
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE request_id = $1`, request.RequestID))
require.Equal(t, int64(13), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, requester.SpaceID))
require.Equal(t, int64(13), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1`, target.SpaceID))
})
}
}
func testUpdateCaption(ctx context.Context, module *Module, postID int64, _ int64, spaceID string, captionCipher *string) error {
var caption []byte
if captionCipher != nil {
caption = testSpaceBytes(*captionCipher)
}
return module.Posts.UpdateCaption(ctx, postID, spaceID, caption)
}
func insertSpaceUser(t *testing.T, module *Module, email string, publicKey string) int64 {
t.Helper()
userID := testutil.InsertUser(t, module.Spaces.DB, testutil.UserFixture{
Email: email,
CreationTime: timeutil.Microseconds(),
})
_, err := module.Spaces.DB.Exec(`
INSERT INTO key_attributes (
user_id, kek_salt, encrypted_key, key_decryption_nonce,
public_key, encrypted_secret_key, secret_key_decryption_nonce
) VALUES ($1, $2, $3, $4, $5, $6, $7)
`, userID, "salt", "encrypted-key", "nonce", publicKey, "encrypted-secret-key", "secret-nonce")
require.NoError(t, err)
return userID
}
func countSpaceRows(t *testing.T, module *Module, query string, args ...any) int64 {
t.Helper()
var count int64
err := module.Spaces.DB.QueryRow(query, args...).Scan(&count)
require.NoError(t, err)
return count
}
func TestGetBrowserSession(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
userID := insertSpaceUser(t, module, "[email protected]", "browser-session-public")
tokenHash := sha256.Sum256([]byte("browser-session-token"))
expiresAt := timeutil.NDaysFromNow(1)
err := module.Sessions.CreateBrowserSession(ctx, tokenHash[:], userID, "session-wrap-key", expiresAt)
require.NoError(t, err)
session, err := module.Sessions.GetBrowserSession(ctx, tokenHash[:])
require.NoError(t, err)
require.Equal(t, userID, session.UserID)
require.Equal(t, "session-wrap-key", session.SessionWrapKey)
require.Equal(t, expiresAt, session.ExpiresAt)
}
func TestGetBrowserSessionRejectsDeletedUser(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
userID := insertSpaceUser(t, module, "[email protected]", "deleted-browser-session-public")
tokenHash := sha256.Sum256([]byte("deleted-browser-session-token"))
require.NoError(t, module.Sessions.CreateBrowserSession(ctx, tokenHash[:], userID, "session-wrap-key", timeutil.NDaysFromNow(1)))
_, err := module.Sessions.DB.Exec(`UPDATE users SET encrypted_email = NULL WHERE user_id = $1`, userID)
require.NoError(t, err)
_, err = module.Sessions.GetBrowserSession(ctx, tokenHash[:])
require.ErrorIs(t, err, sql.ErrNoRows)
}
func TestExchangeBrowserSessionConsumesTokenOnce(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
userID := insertSpaceUser(t, module, "[email protected]", "browser-session-exchange-public")
authToken := "browser-session-exchange-token"
authTokenHash := sha256.Sum256([]byte(authToken))
_, err := module.Sessions.DB.Exec(`
INSERT INTO tokens (user_id, token, creation_time, app)
VALUES ($1, $2, $3, 'photos')
`, userID, authToken, timeutil.Microseconds())
require.NoError(t, err)
start := make(chan struct{})
errs := make(chan error, 2)
for _, tokenHash := range [][]byte{[]byte("first-space-token-hash"), []byte("second-space-token-hash")} {
go func(tokenHash []byte) {
<-start
errs <- module.Sessions.ExchangeBrowserSession(ctx, authTokenHash[:], tokenHash, userID, "session-wrap-key", timeutil.NDaysFromNow(1))
}(tokenHash)
}
close(start)
var created, rejected int
for range 2 {
err := <-errs
if err == nil {
created++
} else if errors.Is(err, ente.ErrAuthenticationRequired) {
rejected++
} else {
require.NoError(t, err)
}
}
require.Equal(t, 1, created)
require.Equal(t, 1, rejected)
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_browser_sessions WHERE user_id = $1`, userID))
}
func TestExchangeBrowserSessionKeepsTokenWhenSessionCreationFails(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
userID := insertSpaceUser(t, module, "[email protected]", "browser-session-rollback-public")
authToken := "browser-session-rollback-token"
authTokenHash := sha256.Sum256([]byte(authToken))
tokenHash := []byte("duplicate-space-token-hash")
_, err := module.Sessions.DB.Exec(`
INSERT INTO tokens (user_id, token, creation_time, app)
VALUES ($1, $2, $3, 'photos')
`, userID, authToken, timeutil.Microseconds())
require.NoError(t, err)
require.NoError(t, module.Sessions.CreateBrowserSession(ctx, tokenHash, userID, "existing-wrap-key", timeutil.NDaysFromNow(1)))
err = module.Sessions.ExchangeBrowserSession(ctx, authTokenHash[:], tokenHash, userID, "new-wrap-key", timeutil.NDaysFromNow(1))
require.Error(t, err)
var isDeleted bool
require.NoError(t, module.Sessions.DB.QueryRow(`SELECT is_deleted FROM tokens WHERE token_hash = $1`, authTokenHash[:]).Scan(&isDeleted))
require.False(t, isDeleted)
}
func TestSpaceAccountDeletionResetAccountDeletionAccess(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-reset-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-reset-public")
charlieID := insertSpaceUser(t, module, "[email protected]", "charlie-reset-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_reset_space", "alice-space-key", "alice-reset-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_reset_space", "bob-space-key", "bob-reset-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, module, charlieID, "charlie_reset_space", "charlie-space-key", "charlie-reset-public", "charlie-secret", "charlie-secret-nonce", "charlie-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
pendingRequest, created, err := testCreateFriendRequest(ctx, module, aliceID, aliceSpace.SpaceID, charlieSpace.SpaceID, "alice-charlie-share-key", aliceSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
aliceSession := []byte("alice-browser-token")
require.NoError(t, module.Sessions.CreateBrowserSession(ctx, aliceSession, aliceID, "session-wrap-key", timeutil.NDaysFromNow(1)))
_, err = module.WebPush.UpsertAccountSubscription(ctx, aliceSession, "https://push.example/alice-reset", "p256dh", "auth")
require.NoError(t, err)
postID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "alice-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
require.NoError(t, testSetPostLike(ctx, module, postID, bobSpace.SpaceID, true))
message, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("cipher"),
SenderEncryptedMessageKey: testSpaceBytes("sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("recipient-key"),
})
require.NoError(t, err)
require.NoError(t, module.Messages.SetLike(ctx, message.MessageID, aliceSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 1500, message.MessageID, aliceSpace.SpaceID)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, timeutil.Microseconds()))
require.NoError(t, module.ResetAccountDeletionAccess(ctx, aliceID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM spaces WHERE owner_id = $1`, aliceID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_posts WHERE space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_browser_sessions WHERE user_id = $1`, aliceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_web_push_subscriptions WHERE endpoint = $1`, "https://push.example/alice-reset"))
require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1 OR friend_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_requests WHERE requester_space_id = $1 OR target_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notification_read_markers WHERE viewer_space_id = $1 OR friend_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_post_likes WHERE post_id = $1`, postID))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages WHERE message_id = $1 AND recipient_liked_at IS NOT NULL`, message.MessageID))
_, _, err = testConfirmFriendRequest(ctx, module, charlieID, charlieSpace.SpaceID, pendingRequest.RequestID, "charlie-share-key", charlieSpace.CurrentVersion)
require.NoError(t, err)
require.Equal(t, int64(2), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE (space_id = $1 AND friend_space_id = $2) OR (space_id = $2 AND friend_space_id = $1)`, aliceSpace.SpaceID, charlieSpace.SpaceID))
}
func TestSpaceAccountDeletionDeleteUserData(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-delete-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-delete-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_delete_space", "alice-space-key", "alice-delete-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_delete_space", "bob-space-key", "bob-delete-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
_, err = module.Spaces.DB.Exec(`
INSERT INTO space_profile_assets (space_id, asset_type, object_id, bucket_id, size, key_version)
VALUES ($1, $2, $3, $4, 11, 1),
($1, $5, $6, $7, 22, 1)
`, aliceSpace.SpaceID, ProfileAssetTypeAvatar, "avatar", "hot", ProfileAssetTypeCover, "cover", "cold")
require.NoError(t, err)
postID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "alice-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
_, err = module.Posts.DB.Exec(`
INSERT INTO space_post_assets (post_id, object_key, bucket_id, size, position, metadata_cipher)
VALUES ($1, $2, $3, 33, 0, $4)
`, postID, "space/alice/post-asset", "hot", "metadata")
require.NoError(t, err)
require.NoError(t, module.Assets.AddTempObject(ctx, SpaceTempObjectRecord{
ObjectKey: "space/alice/staged-upload",
SpaceID: sql.NullString{String: aliceSpace.SpaceID, Valid: true},
Purpose: TempObjectPurposePost,
BucketID: "hot",
ExpectedSize: 44,
ExpiresAt: timeutil.NDaysFromNow(1),
}))
aliceSession := []byte("alice-delete-browser-token")
require.NoError(t, module.Sessions.CreateBrowserSession(ctx, aliceSession, aliceID, "session-wrap-key", timeutil.NDaysFromNow(1)))
_, err = module.WebPush.UpsertAccountSubscription(ctx, aliceSession, "https://push.example/alice-delete", "p256dh", "auth")
require.NoError(t, err)
link, err := module.Links.Create(
ctx,
aliceSpace.SpaceID,
bytes.Repeat([]byte{7}, 32),
bytes.Repeat([]byte{8}, 16),
67108864,
2,
aliceSpace.CurrentVersion,
[]byte("encrypted-space-key"),
[]byte("encrypted-access-key"),
)
require.NoError(t, err)
_, err = module.WebPush.UpsertLinkSubscription(ctx, link.LinkID, "https://push.example/alice-public-delete", "p256dh", "auth")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
message, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("cipher"),
SenderEncryptedMessageKey: testSpaceBytes("sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("recipient-key"),
})
require.NoError(t, err)
require.NoError(t, module.Messages.SetLike(ctx, message.MessageID, aliceSpace.SpaceID, true))
require.NoError(t, testSetPostLike(ctx, module, postID, bobSpace.SpaceID, true))
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, timeutil.Microseconds()))
require.NoError(t, module.DeleteUserData(ctx, aliceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM spaces WHERE owner_id = $1`, aliceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_posts WHERE space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_post_assets WHERE object_key = $1`, "space/alice/post-asset"))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_messages WHERE sender_space_id = $1 OR recipient_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_browser_sessions WHERE user_id = $1`, aliceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_web_push_subscriptions WHERE endpoint IN ($1, $2)`, "https://push.example/alice-delete", "https://push.example/alice-public-delete"))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_friend_shares WHERE space_id = $1 OR friend_space_id = $1`, aliceSpace.SpaceID))
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_notification_read_markers WHERE viewer_space_id = $1 OR friend_space_id = $1`, aliceSpace.SpaceID))
for _, objectKey := range []string{ProfileAssetObjectKey(aliceSpace.SpaceID, ProfileAssetTypeAvatar, "avatar"), ProfileAssetObjectKey(aliceSpace.SpaceID, ProfileAssetTypeCover, "cover"), "space/alice/post-asset", "space/alice/staged-upload"} {
require.Equal(t, int64(1), countSpaceRows(t, module, `
SELECT COUNT(*)
FROM space_temp_objects
WHERE object_key = $1
AND space_id IS NULL
AND cleanup_after >= now_utc_micro_seconds() + $2
`, objectKey, SpaceUploadURLExpiry.Microseconds()))
}
}
func TestSpaceMessagesThreadAndConversations(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_messages", "alice-space-key", "alice-messages-public", "alice-messages-secret", "alice-messages-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_messages", "bob-space-key", "bob-messages-public", "bob-messages-secret", "bob-messages-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
message, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("cipher"),
SenderEncryptedMessageKey: testSpaceBytes("sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("recipient-key"),
})
require.NoError(t, err)
require.Equal(t, "regular", message.Kind)
require.Equal(t, testSpaceBytes("sender-key"), message.EncryptedMessageKey)
require.False(t, message.Liked)
require.False(t, message.ViewerLiked)
require.NoError(t, module.Messages.SetLike(ctx, message.MessageID, aliceSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 1500, message.MessageID, aliceSpace.SpaceID)
likedMessage, err := module.Messages.GetMessage(ctx, message.MessageID, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, likedMessage.Liked)
require.True(t, likedMessage.ViewerLiked)
bobViewedMessage, err := module.Messages.GetMessage(ctx, message.MessageID, bobSpace.SpaceID)
require.NoError(t, err)
require.True(t, bobViewedMessage.Liked)
require.False(t, bobViewedMessage.ViewerLiked)
reply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("reply-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("reply-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("reply-recipient-key"),
ReplyMessageID: sql.NullString{String: message.MessageID, Valid: true},
})
require.NoError(t, err)
require.Equal(t, message.MessageID, reply.ReplyMessageID.String)
setMessageCreatedAt(t, module, 1000, message.MessageID)
setMessageCreatedAt(t, module, 2000, reply.MessageID)
aliceThread, nextCursor, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, aliceThread, 2)
require.Equal(t, reply.MessageID, aliceThread[0].MessageID)
require.Equal(t, message.MessageID, aliceThread[0].ReplyMessageID.String)
require.Equal(t, testSpaceBytes("recipient-key"), aliceThread[1].EncryptedMessageKey)
require.Equal(t, bobSpace.SpaceID, aliceThread[1].SenderSpaceID)
require.Equal(t, aliceSpace.SpaceID, aliceThread[1].RecipientSpaceID)
conversations, nextCursor, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, conversations, 1)
require.Equal(t, bobSpace.SpaceID, conversations[0].Friend.SpaceID)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.Equal(t, reply.MessageID, conversations[0].LatestActivity.MessageID.String)
require.NoError(t, module.Messages.DeleteMessage(ctx, message.MessageID, bobSpace.SpaceID))
deletedMessage, err := module.Messages.GetMessage(ctx, message.MessageID, bobSpace.SpaceID)
require.NoError(t, err)
require.True(t, deletedMessage.IsDeleted)
require.Empty(t, deletedMessage.MessageCipher)
require.Empty(t, deletedMessage.EncryptedMessageKey)
require.False(t, deletedMessage.Liked)
aliceThread, nextCursor, err = module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, aliceThread, 1)
require.Equal(t, reply.MessageID, aliceThread[0].MessageID)
require.Equal(t, message.MessageID, aliceThread[0].ReplyMessageID.String)
_, err = module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("cipher"),
SenderEncryptedMessageKey: testSpaceBytes("sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("recipient-key"),
ReplyPostID: sql.NullInt64{Int64: 1, Valid: true},
})
require.Error(t, err)
}
func TestSpaceConversationsUseProfileAssetAvatars(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-message-avatars-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-message-avatars-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_message_avatars", "alice-space-key", "alice-message-avatars-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_message_avatars", "bob-space-key", "bob-message-avatars-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
_, err = module.Spaces.DB.Exec(`
INSERT INTO space_profile_assets (space_id, asset_type, object_id, bucket_id, size, key_version)
VALUES ($1, $2, $3, $4, 101, 1),
($5, $2, $6, $4, 202, 1)
`, aliceSpace.SpaceID, ProfileAssetTypeAvatar, "alice-avatar-object-id", "b2-eu-cen", bobSpace.SpaceID, "bob-avatar-object-id")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
message, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("cipher"),
SenderEncryptedMessageKey: testSpaceBytes("sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 1000, message.MessageID)
thread, nextCursor, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, thread, 1)
require.Equal(t, bobSpace.SpaceID, thread[0].SenderSpaceID)
require.Equal(t, aliceSpace.SpaceID, thread[0].RecipientSpaceID)
conversations, nextCursor, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, conversations, 1)
require.Equal(t, "bob-avatar-object-id", conversations[0].Friend.AvatarObjectID.String)
require.EqualValues(t, 202, conversations[0].Friend.AvatarSize.Int64)
require.True(t, conversations[0].LatestActivity.MessageID.Valid)
}
func TestSpaceMessageConversationsUseLatestActivity(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-activity-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-activity-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_activity", "alice-space-key", "alice-activity-public", "alice-activity-secret", "alice-activity-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_activity", "bob-space-key", "bob-activity-public", "bob-activity-secret", "bob-activity-secret-nonce", "bob-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
conversations, nextCursor, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, conversations, 1)
require.Equal(t, bobSpace.SpaceID, conversations[0].Friend.SpaceID)
require.Equal(t, "empty", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].LatestActivity.MessageID.Valid)
require.False(t, conversations[0].Unread)
require.Zero(t, conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
bobMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("bob-message-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("bob-message-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("bob-message-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2000, bobMessage.MessageID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.Equal(t, bobMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
aliceMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("alice-message-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("alice-message-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("alice-message-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2500, aliceMessage.MessageID)
require.NoError(t, module.Messages.SetLike(ctx, aliceMessage.MessageID, bobSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 3000, aliceMessage.MessageID, bobSpace.SpaceID)
require.NoError(t, module.Messages.SetLike(ctx, bobMessage.MessageID, aliceSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 3500, bobMessage.MessageID, aliceSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.Outgoing)
require.Equal(t, bobMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, testSpaceBytes("bob-message-cipher"), conversations[0].LatestActivity.MessageCipher)
require.Equal(t, testSpaceBytes("bob-message-recipient-key"), conversations[0].LatestActivity.EncryptedMessageKey)
postID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
_, err = module.Posts.DB.Exec(`
INSERT INTO space_post_assets (post_id, object_key, bucket_id, metadata_cipher)
VALUES ($1, $2, $3, $4)
`, postID, "activity-post-object", "bucket", "metadata")
require.NoError(t, err)
require.NoError(t, testSetPostLike(ctx, module, postID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 4000, postID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.Equal(t, bobMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
postReply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("post-reply-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("post-reply-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("post-reply-recipient-key"),
ReplyPostID: sql.NullInt64{Int64: postID, Valid: true},
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 5000, postReply.MessageID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "post_reply", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.MessageID.Valid)
require.Equal(t, postReply.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, postID, conversations[0].LatestActivity.PostID.Int64)
replyOnlyPostID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "reply-only-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
replyOnly, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("reply-only-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("reply-only-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("reply-only-recipient-key"),
ReplyPostID: sql.NullInt64{Int64: replyOnlyPostID, Valid: true},
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 5500, replyOnly.MessageID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "post_reply", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.MessageID.Valid)
require.Equal(t, replyOnly.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, replyOnlyPostID, conversations[0].LatestActivity.PostID.Int64)
require.NoError(t, module.Posts.DeletePost(ctx, replyOnlyPostID, aliceSpace.SpaceID))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "post_reply", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.MessageID.Valid)
require.Equal(t, replyOnly.MessageID, conversations[0].LatestActivity.MessageID.String)
require.True(t, conversations[0].LatestActivity.PostID.Valid)
require.Equal(t, replyOnlyPostID, conversations[0].LatestActivity.PostID.Int64)
thread, _, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, replyOnly.MessageID, thread[0].MessageID)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(5500), latestActivityAt)
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
require.NoError(t, module.Friends.DeleteFriendship(ctx, bobSpace.SpaceID, aliceSpace.SpaceID))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, conversations)
}
func TestCurrentFriendsWithoutMessagesHaveNoActivity(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-empty-friend-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-empty-friend-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_empty_friend", "alice-space-key", "alice-empty-friend-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_empty_friend", "bob-space-key", "bob-empty-friend-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
setFriendShareCreatedAt(t, module, 1000, aliceSpace.SpaceID, bobSpace.SpaceID)
setFriendShareCreatedAt(t, module, 1000, bobSpace.SpaceID, aliceSpace.SpaceID)
conversations, nextCursor, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, nextCursor)
require.Len(t, conversations, 1)
require.Equal(t, bobSpace.SpaceID, conversations[0].Friend.SpaceID)
require.Equal(t, "empty", conversations[0].LatestActivity.Type)
require.Equal(t, int64(1000), conversations[0].LatestActivity.CreatedAt)
require.False(t, conversations[0].LatestActivity.MessageID.Valid)
require.False(t, conversations[0].Unread)
require.Zero(t, conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Zero(t, latestActivityAt)
require.NoError(t, module.Friends.DeleteFriendship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, conversations)
}
func TestLatestChatSummariesUseCurrentFriendActivities(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-chat-summary-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-chat-summary-public")
charlieID := insertSpaceUser(t, module, "[email protected]", "charlie-chat-summary-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_chat_summary", "alice-space-key", "alice-chat-summary-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_chat_summary", "bob-space-key", "bob-chat-summary-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, module, charlieID, "charlie_chat_summary", "charlie-space-key", "charlie-chat-summary-public", "charlie-secret", "charlie-secret-nonce", "charlie-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-bob-share-key", aliceSpace.CurrentVersion, "bob-alice-share-key", bobSpace.CurrentVersion))
require.NoError(t, testAddFriend(ctx, module, charlieID, charlieSpace.SpaceID, aliceSpace.SpaceID, "alice-charlie-share-key", aliceSpace.CurrentVersion, "charlie-alice-share-key", charlieSpace.CurrentVersion))
bobMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("bob-summary-message-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("bob-summary-message-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("bob-summary-message-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2000, bobMessage.MessageID)
postID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "summary-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
require.NoError(t, testSetPostLike(ctx, module, postID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 3000, postID, bobSpace.SpaceID)
summaries, err := module.Messages.ListLatestChatSummaries(ctx, aliceSpace.SpaceID, []string{bobSpace.SpaceID, charlieSpace.SpaceID})
require.NoError(t, err)
require.Len(t, summaries, 1)
require.NotContains(t, summaries, charlieSpace.SpaceID)
bobSummary := summaries[bobSpace.SpaceID]
require.Equal(t, "message", bobSummary.LatestActivity.Type)
require.Equal(t, bobMessage.MessageID, bobSummary.LatestActivity.MessageID.String)
require.Len(t, bobSummary.UnreadActivities, 1)
for _, activity := range bobSummary.UnreadActivities {
require.Empty(t, activity.MessageCipher)
require.Empty(t, activity.EncryptedMessageKey)
}
require.Equal(t, int64(1), countChatUnreadActivities(bobSummary.UnreadActivities))
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, 3000))
summaries, err = module.Messages.ListLatestChatSummaries(ctx, aliceSpace.SpaceID, []string{bobSpace.SpaceID, charlieSpace.SpaceID})
require.NoError(t, err)
bobSummary = summaries[bobSpace.SpaceID]
require.Empty(t, bobSummary.UnreadActivities)
require.Equal(t, "message", bobSummary.LatestActivity.Type)
require.NoError(t, module.Friends.DeleteFriendship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID))
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
}
func TestConfirmFriendRequestCreatesFriendshipAndNotifiesRequester(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-confirm-request-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-confirm-request-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_confirm_request", "alice-space-key", "alice-confirm-request-public", "alice-confirm-secret", "alice-confirm-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_confirm_request", "bob-space-key", "bob-confirm-request-public", "bob-confirm-secret", "bob-confirm-secret-nonce", "bob-profile")
require.NoError(t, err)
request, created, err := testCreateFriendRequest(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
aliceUnread, err := module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, aliceUnread)
requesterID, created, err := testConfirmFriendRequest(ctx, module, aliceID, aliceSpace.SpaceID, request.RequestID, "alice-share-key", aliceSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
require.Equal(t, bobID, requesterID)
aliceShare, err := module.Friends.GetShareForFriendAndSpace(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("bob-share-key"), aliceShare.FriendSealedSpaceKey)
bobShare, err := module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("alice-share-key"), bobShare.FriendSealedSpaceKey)
requests, err := module.Friends.ListFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, requests)
aliceUnread, err = module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, aliceUnread)
bobRequests, err := module.Friends.ListFriendRequestsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, bobRequests)
bobUnread, err := module.Notifications.HasUnread(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.True(t, bobUnread)
aliceConversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, aliceConversations, 1)
require.Equal(t, bobSpace.SpaceID, aliceConversations[0].Friend.SpaceID)
require.Equal(t, "empty", aliceConversations[0].LatestActivity.Type)
require.False(t, aliceConversations[0].NotificationUnread)
require.False(t, aliceConversations[0].Unread)
require.Zero(t, aliceConversations[0].UnreadCount)
bobConversations, _, err := listTestConversations(ctx, module, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, bobConversations, 1)
require.Equal(t, aliceSpace.SpaceID, bobConversations[0].Friend.SpaceID)
require.Equal(t, "empty", bobConversations[0].LatestActivity.Type)
require.False(t, bobConversations[0].NotificationUnread)
require.False(t, bobConversations[0].Unread)
require.Zero(t, bobConversations[0].UnreadCount)
require.Empty(t, bobConversations[0].UnreadActivities)
}
func TestReciprocalFriendRequestAutoConfirms(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-reciprocal-request-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-reciprocal-request-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_reciprocal_request", "alice-space-key", "alice-reciprocal-request-public", "alice-reciprocal-secret", "alice-reciprocal-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_reciprocal_request", "bob-space-key", "bob-reciprocal-request-public", "bob-reciprocal-secret", "bob-reciprocal-secret-nonce", "bob-profile")
require.NoError(t, err)
_, created, autoConfirmed, err := module.Friends.CreateFriendRequest(ctx, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, testSpaceBytes("bob-share-key"), bobSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
require.False(t, autoConfirmed)
_, created, autoConfirmed, err = module.Friends.CreateFriendRequest(ctx, aliceID, aliceSpace.SpaceID, bobSpace.SpaceID, testSpaceBytes("alice-share-key"), aliceSpace.CurrentVersion)
require.NoError(t, err)
require.False(t, created)
require.True(t, autoConfirmed)
aliceShare, err := module.Friends.GetShareForFriendAndSpace(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("bob-share-key"), aliceShare.FriendSealedSpaceKey)
bobShare, err := module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("alice-share-key"), bobShare.FriendSealedSpaceKey)
aliceRequests, err := module.Friends.ListFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, aliceRequests)
bobRequests, err := module.Friends.ListFriendRequestsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, bobRequests)
aliceUnread, err := module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, aliceUnread)
bobUnread, err := module.Notifications.HasUnread(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.True(t, bobUnread)
}
func TestDeleteFriendRequestClearsUnread(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-delete-request-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-delete-request-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_delete_request", "alice-space-key", "alice-delete-request-public", "alice-delete-secret", "alice-delete-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_delete_request", "bob-space-key", "bob-delete-request-public", "bob-delete-secret", "bob-delete-secret-nonce", "bob-profile")
require.NoError(t, err)
request, created, err := testCreateFriendRequest(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
aliceUnread, err := module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, aliceUnread)
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, aliceSpace.SpaceID, request.RequestID))
aliceUnread, err = module.Notifications.HasUnread(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, aliceUnread)
requests, err := module.Friends.ListFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, requests)
}
func TestListAndDeleteSentFriendRequests(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-sent-requests-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-sent-requests-public")
charlieID := insertSpaceUser(t, module, "[email protected]", "charlie-sent-requests-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_sent_requests", "alice-space-key", "alice-sent-requests-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_sent_requests", "bob-space-key", "bob-sent-requests-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, module, charlieID, "charlie_sent_requests", "charlie-space-key", "charlie-sent-requests-public", "charlie-secret", "charlie-secret-nonce", "charlie-profile")
require.NoError(t, err)
bobRequest, created, err := testCreateFriendRequest(ctx, module, aliceID, aliceSpace.SpaceID, bobSpace.SpaceID, "bob-share-key", aliceSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
charlieRequest, created, err := testCreateFriendRequest(ctx, module, aliceID, aliceSpace.SpaceID, charlieSpace.SpaceID, "charlie-share-key", aliceSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
setFriendRequestCreatedAt(t, module, 1000, bobRequest.RequestID)
setFriendRequestCreatedAt(t, module, 2000, charlieRequest.RequestID)
requests, err := module.Friends.ListSentFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, requests, 2)
require.Equal(t, charlieSpace.SpaceID, requests[0].Target.SpaceID)
require.Equal(t, bobSpace.SpaceID, requests[1].Target.SpaceID)
err = module.Friends.DeleteFriendRequest(ctx, bobSpace.SpaceID, charlieRequest.RequestID)
require.ErrorIs(t, err, sql.ErrNoRows)
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, aliceSpace.SpaceID, charlieRequest.RequestID))
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, bobSpace.SpaceID, bobRequest.RequestID))
requests, err = module.Friends.ListSentFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, requests)
}
func TestFriendRequestsStayOutOfMessageConversations(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-request-conversation-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-request-conversation-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_request_conversation", "alice-space-key", "alice-request-conversation-public", "alice-request-secret", "alice-request-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_request_conversation", "bob-space-key", "bob-request-conversation-public", "bob-request-secret", "bob-request-secret-nonce", "bob-profile")
require.NoError(t, err)
request, created, err := testCreateFriendRequest(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "bob-share-key-v2", bobSpace.CurrentVersion)
require.NoError(t, err)
require.True(t, created)
setFriendRequestCreatedAt(t, module, 2000, request.RequestID)
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, conversations)
requests, err := module.Friends.ListFriendRequestsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, requests, 1)
require.Equal(t, request.RequestID, requests[0].RequestID)
require.Equal(t, bobSpace.SpaceID, requests[0].Requester.SpaceID)
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
require.NoError(t, module.Friends.DeleteFriendRequest(ctx, aliceSpace.SpaceID, request.RequestID))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Empty(t, conversations)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
}
func TestSpaceMessageConversationPreviewUsesLatestActivityWithSeparateUnreadState(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-preview-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-preview-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_preview_priority", "alice-space-key", "alice-preview-priority-public", "alice-preview-priority-secret", "alice-preview-priority-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_preview_priority", "bob-space-key", "bob-preview-priority-public", "bob-preview-priority-secret", "bob-preview-priority-secret-nonce", "bob-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
aliceOldMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("alice-old-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("alice-old-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("alice-old-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 1000, aliceOldMessage.MessageID)
bobNewMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("bob-new-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("bob-new-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("bob-new-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2000, bobNewMessage.MessageID)
require.NoError(t, module.Messages.SetLike(ctx, aliceOldMessage.MessageID, bobSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 3000, aliceOldMessage.MessageID, bobSpace.SpaceID)
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, conversations, 1)
require.True(t, conversations[0].Unread)
require.True(t, conversations[0].NotificationUnread)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.Equal(t, aliceOldMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, testSpaceBytes("alice-old-cipher"), conversations[0].LatestActivity.MessageCipher)
require.Equal(t, testSpaceBytes("alice-old-sender-key"), conversations[0].LatestActivity.EncryptedMessageKey)
require.Equal(t, int64(3000), conversations[0].SortCreatedAt)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(3000), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.False(t, conversations[0].Unread)
require.False(t, conversations[0].NotificationUnread)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.Equal(t, aliceOldMessage.MessageID, conversations[0].LatestActivity.MessageID.String)
}
func TestPostLikesDoNotAffectMessageUnreadState(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-post-like-unread-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-post-like-unread-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_post_like_unread", "alice-space-key", "alice-post-like-unread-public", "alice-post-like-unread-secret", "alice-post-like-unread-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_post_like_unread", "bob-space-key", "bob-post-like-unread-public", "bob-post-like-unread-secret", "bob-post-like-unread-secret-nonce", "bob-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
aliceMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("alice-message-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("alice-message-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("alice-message-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 1000, aliceMessage.MessageID)
firstPostID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "first-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
secondPostID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "second-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
thirdPostID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "third-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
require.NoError(t, testSetPostLike(ctx, module, firstPostID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 2000, firstPostID, bobSpace.SpaceID)
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, conversations, 1)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
require.NoError(t, testSetPostLike(ctx, module, secondPostID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 3000, secondPostID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(1000), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
require.NoError(t, testSetPostLike(ctx, module, thirdPostID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 4000, thirdPostID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
require.NoError(t, module.Messages.SetLike(ctx, aliceMessage.MessageID, bobSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 5000, aliceMessage.MessageID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.True(t, conversations[0].NotificationUnread)
latestActivityAt, err = module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(5000), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
secondAliceMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("second-alice-message-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("second-alice-message-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("second-alice-message-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 6000, secondAliceMessage.MessageID)
require.NoError(t, module.Messages.SetLike(ctx, secondAliceMessage.MessageID, bobSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 7000, secondAliceMessage.MessageID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.True(t, conversations[0].NotificationUnread)
}
func TestSpaceModuleLifecycle(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
require.Equal(t, 1, aliceSpace.CurrentVersion)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
listedSpaces, err := module.Spaces.ListSpacesByOwner(ctx, aliceID)
require.NoError(t, err)
require.Len(t, listedSpaces, 1)
err = module.Assets.AddTempObject(ctx, SpaceTempObjectRecord{
ObjectKey: ProfileAssetObjectKey(aliceSpace.SpaceID, ProfileAssetTypeAvatar, "avatar.jpg"),
SpaceID: sql.NullString{String: aliceSpace.SpaceID, Valid: true},
Purpose: TempObjectPurposeAvatar,
BucketID: "b2-eu-cen",
ExpectedSize: 111,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
})
require.NoError(t, err)
updatedSpace, err := testUpdateProfile(ctx, module, aliceID, aliceSpace.SpaceID, aliceSpace.CurrentVersion, "alice-profile-v2", &ProfileAssetUpdate{
ObjectID: "avatar.jpg",
BucketID: "b2-eu-cen",
Size: 111,
}, nil, false, false)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("alice-profile-v2"), updatedSpace.EncryptedProfile)
require.Equal(t, "avatar.jpg", updatedSpace.AvatarObjectID.String)
avatarBucketID, err := module.Assets.GetProfileAssetBucketID(ctx, aliceSpace.SpaceID, ProfileAssetTypeAvatar, "avatar.jpg")
require.NoError(t, err)
require.Equal(t, "b2-eu-cen", avatarBucketID)
rotatedSpace, err := testRotateKey(ctx, module, aliceID, aliceSpace.SpaceID, updatedSpace.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v3")
require.NoError(t, err)
require.Equal(t, 2, rotatedSpace.CurrentVersion)
require.Equal(t, sql.NullInt64{Int64: 1, Valid: true}, rotatedSpace.AvatarKeyVersion)
versions, err := module.Spaces.ListVersions(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, versions, 2)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", rotatedSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
shares, err := module.Friends.ListSharesForFriendAndSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Len(t, shares, 1)
require.Equal(t, testSpaceBytes("alice-share-key"), shares[0].FriendSealedSpaceKey)
aliceShares, err := module.Friends.ListSharesForFriendAndSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, aliceShares, 1)
require.Equal(t, testSpaceBytes("bob-share-key"), aliceShares[0].FriendSealedSpaceKey)
friends, err := module.Friends.ListFriendsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, friends, 1)
require.Equal(t, "bobb", friends[0].Friend.SpaceSlug)
bobFriends, err := module.Friends.ListFriendsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Len(t, bobFriends, 1)
require.Equal(t, "alice", bobFriends[0].Friend.SpaceSlug)
require.Equal(t, sql.NullInt64{Int64: 1, Valid: true}, bobFriends[0].Friend.AvatarKeyVersion)
for _, tempObject := range []SpaceTempObjectRecord{
{
ObjectKey: "space/alice/post1/full",
SpaceID: sql.NullString{String: aliceSpace.SpaceID, Valid: true},
Purpose: TempObjectPurposePost,
BucketID: "b2-eu-cen",
ExpectedSize: 123,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
},
{
ObjectKey: "space/alice/post1/thumb",
SpaceID: sql.NullString{String: aliceSpace.SpaceID, Valid: true},
Purpose: TempObjectPurposePost,
BucketID: "b2-eu-cen",
ExpectedSize: 45,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
},
} {
err = module.Assets.AddTempObject(ctx, tempObject)
require.NoError(t, err)
}
postID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "post-key", ptr("caption"), rotatedSpace.CurrentVersion, []SpacePostAssetRecord{
{
ObjectKey: "space/alice/post1/full",
BucketID: "b2-eu-cen",
Size: sqlNullInt64(123),
Position: 0,
MetadataCipher: testSpaceBytes("full-metadata"),
},
{
ObjectKey: "space/alice/post1/thumb",
BucketID: "b2-eu-cen",
Size: sqlNullInt64(45),
Position: 1,
MetadataCipher: testSpaceBytes("thumbnail-metadata"),
},
})
require.NoError(t, err)
post, err := module.Posts.GetPost(ctx, postID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, "alice", post.Author.SpaceSlug)
err = testSetPostLike(ctx, module, postID, bobSpace.SpaceID, true)
require.NoError(t, err)
assets, err := module.Posts.ListAssetsByPostIDs(ctx, []int64{postID})
require.NoError(t, err)
require.Len(t, assets[postID], 2)
require.Equal(t, "b2-eu-cen", assets[postID][0].BucketID)
bucketID, err := module.Assets.GetAssetBucketID(ctx, aliceSpace.SpaceID, "space/alice/post1/full")
require.NoError(t, err)
require.Equal(t, "b2-eu-cen", bucketID)
bucketID, err = module.Assets.GetAssetBucketID(ctx, aliceSpace.SpaceID, ProfileAssetObjectKey(aliceSpace.SpaceID, ProfileAssetTypeAvatar, "avatar.jpg"))
require.NoError(t, err)
require.Equal(t, "b2-eu-cen", bucketID)
tx, err := module.Assets.DB.BeginTx(ctx, nil)
require.NoError(t, err)
referenced, err := IsObjectReferencedTx(ctx, tx, "space/alice/post1/full")
require.NoError(t, err)
require.True(t, referenced)
require.NoError(t, tx.Rollback())
require.NoError(t, module.Posts.DeletePost(ctx, postID, aliceSpace.SpaceID))
requireQueuedTempObject(t, module, "space/alice/post1/full", TempObjectPurposePost, "b2-eu-cen")
requireQueuedTempObject(t, module, "space/alice/post1/thumb", TempObjectPurposePost, "b2-eu-cen")
var likeCount int
err = module.Posts.DB.QueryRow(`SELECT COUNT(*) FROM space_post_likes WHERE post_id = $1`, postID).Scan(&likeCount)
require.NoError(t, err)
require.Equal(t, 0, likeCount)
require.NoError(t, module.Posts.DeletePost(ctx, postID, aliceSpace.SpaceID))
err = module.Posts.DB.QueryRow(`SELECT COUNT(*) FROM space_post_likes WHERE post_id = $1`, postID).Scan(&likeCount)
require.NoError(t, err)
require.Equal(t, 0, likeCount)
_, err = module.Posts.GetPost(ctx, postID, bobSpace.SpaceID)
require.Error(t, err)
err = testUpdateCaption(ctx, module, postID, aliceID, aliceSpace.SpaceID, ptr("edited-caption"))
require.ErrorIs(t, err, sql.ErrNoRows)
_, err = module.Assets.GetAssetBucketID(ctx, aliceSpace.SpaceID, "space/alice/post1/full")
require.Error(t, err)
tx, err = module.Assets.DB.BeginTx(ctx, nil)
require.NoError(t, err)
referenced, err = IsObjectReferencedTx(ctx, tx, "space/alice/post1/full")
require.NoError(t, err)
require.False(t, referenced)
require.NoError(t, tx.Rollback())
lookup, err := module.Spaces.GetSpaceBySlug(ctx, "alice")
require.NoError(t, err)
require.Equal(t, aliceSpace.SpaceID, lookup.SpaceID)
_ = bobSpace
}
func TestReserveTempObjectEnforcesCountAtomically(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
userID := insertSpaceUser(t, module, "[email protected]", "upload-count-public")
space, err := testCreateSpace(ctx, module, userID, "upload_count", "root", "public", "secret", "nonce", "profile")
require.NoError(t, err)
start := make(chan struct{})
errs := make(chan error, MaxActiveUploadCount*2)
var wg sync.WaitGroup
for i := 0; i < MaxActiveUploadCount*2; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
<-start
errs <- module.Assets.ReserveTempObject(ctx, SpaceTempObjectRecord{
ObjectKey: "space/upload-count/" + strconv.Itoa(i),
SpaceID: sql.NullString{String: space.SpaceID, Valid: true},
Purpose: TempObjectPurposePost,
BucketID: "b2-eu-cen",
ExpectedSize: 1,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
})
}(i)
}
close(start)
wg.Wait()
close(errs)
accepted := 0
rejected := 0
for err := range errs {
switch {
case err == nil:
accepted++
case errors.Is(err, ErrSpaceUploadLimitReached):
rejected++
default:
require.NoError(t, err)
}
}
require.Equal(t, MaxActiveUploadCount, accepted)
require.Equal(t, MaxActiveUploadCount, rejected)
require.Equal(t, int64(MaxActiveUploadCount), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_temp_objects WHERE space_id = $1`, space.SpaceID))
}
func TestPostAssetPositionIsUnique(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_assets", "alice-space-key", "alice-assets-public", "alice-assets-secret", "alice-assets-secret-nonce", "alice-profile")
require.NoError(t, err)
postID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
_, err = module.Posts.DB.Exec(`
INSERT INTO space_post_assets (post_id, object_key, bucket_id, position, metadata_cipher)
VALUES ($1, $2, $3, $4, $5)
`, postID, "space/alice-assets/post/full-1", "b2-eu-cen", 0, "metadata-1")
require.NoError(t, err)
_, err = module.Posts.DB.Exec(`
INSERT INTO space_post_assets (post_id, object_key, bucket_id, position, metadata_cipher)
VALUES ($1, $2, $3, $4, $5)
`, postID, "space/alice-assets/post/full-2", "b2-eu-cen", 0, "metadata-2")
require.Error(t, err)
}
func TestUpdateProfileQueuesOldAvatarForCleanup(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
for _, rec := range []SpaceTempObjectRecord{
{
ObjectKey: ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeAvatar, "avatar-old"),
SpaceID: sql.NullString{String: space.SpaceID, Valid: true},
Purpose: TempObjectPurposeAvatar,
BucketID: "b2-eu-cen",
ExpectedSize: 111,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
},
{
ObjectKey: ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeAvatar, "avatar-new"),
SpaceID: sql.NullString{String: space.SpaceID, Valid: true},
Purpose: TempObjectPurposeAvatar,
BucketID: "b2-us-west",
ExpectedSize: 222,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
},
} {
require.NoError(t, module.Assets.AddTempObject(ctx, rec))
}
oldAvatar := &ProfileAssetUpdate{ObjectID: "avatar-old", BucketID: "b2-eu-cen", Size: 111}
_, err = testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-profile-old-avatar", oldAvatar, nil, false, false)
require.NoError(t, err)
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2 AND object_id = $3`, space.SpaceID, ProfileAssetTypeAvatar, "avatar-old"))
newAvatar := &ProfileAssetUpdate{ObjectID: "avatar-new", BucketID: "b2-us-west", Size: 222}
updated, err := testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-profile-new-avatar", newAvatar, nil, false, false)
require.NoError(t, err)
require.Equal(t, "avatar-new", updated.AvatarObjectID.String)
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2 AND object_id = $3`, space.SpaceID, ProfileAssetTypeAvatar, "avatar-old"))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2 AND object_id = $3`, space.SpaceID, ProfileAssetTypeAvatar, "avatar-new"))
requireQueuedTempObject(t, module, ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeAvatar, "avatar-old"), TempObjectPurposeAvatar, "b2-eu-cen")
updated, err = testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-profile-no-avatar", nil, nil, true, false)
require.NoError(t, err)
require.False(t, updated.AvatarObjectID.Valid)
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2`, space.SpaceID, ProfileAssetTypeAvatar))
requireQueuedTempObject(t, module, ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeAvatar, "avatar-new"), TempObjectPurposeAvatar, "b2-us-west")
}
func TestUpdateProfileQueuesOldCoverForCleanup(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice_cover", "alice-space-key", "alice-cover-public", "alice-cover-secret", "alice-cover-secret-nonce", "alice-profile")
require.NoError(t, err)
for _, rec := range []SpaceTempObjectRecord{
{
ObjectKey: ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeCover, "cover-old"),
SpaceID: sql.NullString{String: space.SpaceID, Valid: true},
Purpose: TempObjectPurposeCover,
BucketID: "b2-eu-cen",
ExpectedSize: 333,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
},
{
ObjectKey: ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeCover, "cover-new"),
SpaceID: sql.NullString{String: space.SpaceID, Valid: true},
Purpose: TempObjectPurposeCover,
BucketID: "b2-us-west",
ExpectedSize: 444,
ExpiresAt: timeutil.MicrosecondsAfterMinutes(30),
},
} {
require.NoError(t, module.Assets.AddTempObject(ctx, rec))
}
oldCover := &ProfileAssetUpdate{ObjectID: "cover-old", BucketID: "b2-eu-cen", Size: 333}
_, err = testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-profile-old-cover", nil, oldCover, false, false)
require.NoError(t, err)
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2 AND object_id = $3`, space.SpaceID, ProfileAssetTypeCover, "cover-old"))
newCover := &ProfileAssetUpdate{ObjectID: "cover-new", BucketID: "b2-us-west", Size: 444}
updated, err := testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-profile-new-cover", nil, newCover, false, false)
require.NoError(t, err)
require.Equal(t, "cover-new", updated.CoverObjectID.String)
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2 AND object_id = $3`, space.SpaceID, ProfileAssetTypeCover, "cover-old"))
require.Equal(t, int64(1), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2 AND object_id = $3`, space.SpaceID, ProfileAssetTypeCover, "cover-new"))
requireQueuedTempObject(t, module, ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeCover, "cover-old"), TempObjectPurposeCover, "b2-eu-cen")
updated, err = testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-profile-no-cover", nil, nil, false, true)
require.NoError(t, err)
require.False(t, updated.CoverObjectID.Valid)
require.Equal(t, int64(0), countSpaceRows(t, module, `SELECT COUNT(*) FROM space_profile_assets WHERE space_id = $1 AND asset_type = $2`, space.SpaceID, ProfileAssetTypeCover))
requireQueuedTempObject(t, module, ProfileAssetObjectKey(space.SpaceID, ProfileAssetTypeCover, "cover-new"), TempObjectPurposeCover, "b2-us-west")
}
func TestAddFriendCreatesReciprocalShares(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
share, err := module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("alice-share-key"), share.FriendSealedSpaceKey)
require.Equal(t, aliceSpace.CurrentVersion, share.KeyVersion)
reciprocalShare, err := module.Friends.GetShareForFriendAndSpace(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("bob-share-key"), reciprocalShare.FriendSealedSpaceKey)
require.Equal(t, bobSpace.CurrentVersion, reciprocalShare.KeyVersion)
}
func TestAddFriendRejectsSelfFriendship(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_self", "alice-space-key", "alice-self-public", "alice-self-secret", "alice-self-secret-nonce", "alice-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, aliceID, aliceSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "alice-share-key", aliceSpace.CurrentVersion)
require.ErrorIs(t, err, ErrSelfFriendship)
}
func TestCreateFriendRequestRejectsExistingFriends(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key-v2", aliceSpace.CurrentVersion, "bob-share-key-v2", bobSpace.CurrentVersion)
require.ErrorIs(t, err, ErrAlreadyFriends)
share, err := module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("alice-share-key"), share.FriendSealedSpaceKey)
}
func TestDeleteFriendshipRemovesReciprocalShares(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_delete_friend", "alice-space-key", "alice-delete-friend-public", "alice-delete-friend-secret", "alice-delete-friend-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_delete_friend", "bob-space-key", "bob-delete-friend-public", "bob-delete-friend-secret", "bob-delete-friend-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, aliceID, aliceSpace.SpaceID, bobSpace.SpaceID, "bob-share-key", bobSpace.CurrentVersion, "alice-share-key", aliceSpace.CurrentVersion)
require.NoError(t, err)
aliceShares, err := module.Friends.ListSharesForFriendAndSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Len(t, aliceShares, 1)
bobShares, err := module.Friends.ListSharesForFriendAndSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Len(t, bobShares, 1)
err = module.Friends.DeleteFriendship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
aliceShares, err = module.Friends.ListSharesForFriendAndSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, aliceShares)
bobShares, err = module.Friends.ListSharesForFriendAndSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, bobShares)
aliceFriends, err := module.Friends.ListFriendsForSpace(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, aliceFriends)
bobFriends, err := module.Friends.ListFriendsForSpace(ctx, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, bobFriends)
relationship, err := module.Friends.GetRelationship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Empty(t, relationship)
err = module.Friends.DeleteFriendship(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
}
func TestUpdateShareOnlyRefreshesExistingShares(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testUpsertShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "share-key-v1", aliceSpace.CurrentVersion)
require.NoError(t, err)
rotatedSpace, err := testRotateKey(ctx, module, aliceID, aliceSpace.SpaceID, aliceSpace.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
err = testUpdateShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "share-key-v2", rotatedSpace.CurrentVersion)
require.NoError(t, err)
share, err := module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("share-key-v2"), share.FriendSealedSpaceKey)
require.Equal(t, rotatedSpace.CurrentVersion, share.KeyVersion)
err = deleteShareBySpaceAndFriend(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
err = testUpdateShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "stale-share-key", rotatedSpace.CurrentVersion)
require.ErrorIs(t, err, sql.ErrNoRows)
_, err = module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.ErrorIs(t, err, sql.ErrNoRows)
}
func TestCreatePostRejectsStaleKeyVersion(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
_, err = testRotateKey(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
postID, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-stale", nil, space.CurrentVersion, nil)
require.Zero(t, postID)
require.ErrorIs(t, err, sql.ErrNoRows)
posts, next, err := module.Posts.ListPostsBySpace(ctx, space.SpaceID, space.SpaceID, "", 20)
require.NoError(t, err)
require.Empty(t, next)
require.Empty(t, posts)
}
func TestUpdateProfileRejectsStaleKeyVersion(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key-v1", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile-v1")
require.NoError(t, err)
rotated, err := testRotateKey(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
require.Equal(t, 2, rotated.CurrentVersion)
_, err = testUpdateProfile(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "stale-profile", nil, nil, false, false)
require.ErrorIs(t, err, sql.ErrNoRows)
current, err := module.Spaces.GetSpaceByID(ctx, space.SpaceID)
require.NoError(t, err)
require.Equal(t, rotated.CurrentVersion, current.CurrentVersion)
require.Equal(t, testSpaceBytes("alice-profile-v2"), current.EncryptedProfile)
}
func TestRotateKeyRejectsStaleKeyVersion(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key-v1", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile-v1")
require.NoError(t, err)
rotated, err := testRotateKey(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-space-key-v2", "wrapped-v1", "alice-profile-v2")
require.NoError(t, err)
require.Equal(t, 2, rotated.CurrentVersion)
_, err = testRotateKey(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-space-key-v3", "stale-wrapped-v1", "alice-profile-v3")
require.ErrorIs(t, err, sql.ErrNoRows)
current, err := module.Spaces.GetSpaceByID(ctx, space.SpaceID)
require.NoError(t, err)
require.Equal(t, 2, current.CurrentVersion)
require.Equal(t, testSpaceBytes("alice-space-key-v2"), current.RootWrappedSpaceKey)
versions, err := module.Spaces.ListVersions(ctx, space.SpaceID)
require.NoError(t, err)
require.Len(t, versions, 2)
}
func TestAddFriendRejectsStaleKeyVersion(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
_, err = testRotateKey(ctx, module, aliceID, aliceSpace.SpaceID, aliceSpace.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "stale-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
require.ErrorIs(t, err, ErrSpaceFriendRequestStale)
_, err = module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.ErrorIs(t, err, sql.ErrNoRows)
_, err = module.Friends.GetShareForFriendAndSpace(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.ErrorIs(t, err, sql.ErrNoRows)
}
func TestUpdateShareRejectsStaleKeyVersion(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
err = testUpsertShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "share-key-v1", aliceSpace.CurrentVersion)
require.NoError(t, err)
_, err = testRotateKey(ctx, module, aliceID, aliceSpace.SpaceID, aliceSpace.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
err = testUpdateShare(ctx, module, aliceSpace.SpaceID, bobSpace.SpaceID, "stale-share-key", aliceSpace.CurrentVersion)
require.ErrorIs(t, err, sql.ErrNoRows)
share, err := module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, testSpaceBytes("share-key-v1"), share.FriendSealedSpaceKey)
require.Equal(t, aliceSpace.CurrentVersion, share.KeyVersion)
}
func TestGetVersionReturnsHistoricalProfile(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key-v1", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile-v1")
require.NoError(t, err)
rotated, err := testRotateKey(ctx, module, aliceID, space.SpaceID, space.CurrentVersion, "alice-space-key-v2", "wrapped-prev-key", "alice-profile-v2")
require.NoError(t, err)
require.Equal(t, 2, rotated.CurrentVersion)
v1, err := module.Spaces.GetVersion(ctx, space.SpaceID, 1)
require.NoError(t, err)
require.Equal(t, 1, v1.Version)
require.Equal(t, testSpaceBytes("alice-profile-v1"), v1.EncryptedProfile)
v2, err := module.Spaces.GetVersion(ctx, space.SpaceID, 2)
require.NoError(t, err)
require.Equal(t, 2, v2.Version)
require.Equal(t, testSpaceBytes("alice-profile-v2"), v2.EncryptedProfile)
}
func TestListPostsBySpacePaginates(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
first, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-1", nil, space.CurrentVersion, nil)
require.NoError(t, err)
second, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-2", nil, space.CurrentVersion, nil)
require.NoError(t, err)
third, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-3", nil, space.CurrentVersion, nil)
require.NoError(t, err)
setPostCreatedAt(t, module, 1000, first, second, third)
page, nextCursor, err := module.Posts.ListPostsBySpace(ctx, space.SpaceID, space.SpaceID, "", 2)
require.NoError(t, err)
require.Len(t, page, 2)
require.Equal(t, third, page[0].PostID)
require.Equal(t, second, page[1].PostID)
require.Equal(t, "1000:"+strconv.FormatInt(second, 10), nextCursor)
page, nextCursor, err = module.Posts.ListPostsBySpace(ctx, space.SpaceID, space.SpaceID, nextCursor, 2)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, first, page[0].PostID)
require.Empty(t, nextCursor)
}
func TestListPostsBySpaceCursorUsesCreatedAtSortOrder(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
space, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
first, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-1", nil, space.CurrentVersion, nil)
require.NoError(t, err)
second, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-2", nil, space.CurrentVersion, nil)
require.NoError(t, err)
third, err := testCreatePost(ctx, module, aliceID, space.SpaceID, "post-key-3", nil, space.CurrentVersion, nil)
require.NoError(t, err)
setPostCreatedAt(t, module, 3000, first)
setPostCreatedAt(t, module, 2000, second)
setPostCreatedAt(t, module, 1000, third)
page, nextCursor, err := module.Posts.ListPostsBySpace(ctx, space.SpaceID, space.SpaceID, "", 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, first, page[0].PostID)
require.Equal(t, "3000:"+strconv.FormatInt(first, 10), nextCursor)
page, nextCursor, err = module.Posts.ListPostsBySpace(ctx, space.SpaceID, space.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, second, page[0].PostID)
require.Equal(t, "2000:"+strconv.FormatInt(second, 10), nextCursor)
}
func TestListFeedCursorUsesCreatedAtSortOrder(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-public")
charlieID := insertSpaceUser(t, module, "[email protected]", "charlie-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice", "alice-space-key", "alice-public", "alice-secret", "alice-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bobb", "bob-space-key", "bob-public", "bob-secret", "bob-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, module, charlieID, "charlie", "charlie-space-key", "charlie-public", "charlie-secret", "charlie-secret-nonce", "charlie-profile")
require.NoError(t, err)
err = testAddFriend(ctx, module, aliceID, aliceSpace.SpaceID, bobSpace.SpaceID, "bob-share-key", bobSpace.CurrentVersion, "alice-share-key", aliceSpace.CurrentVersion)
require.NoError(t, err)
ownPost, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "own-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
unrelatedPost, err := testCreatePost(ctx, module, charlieID, charlieSpace.SpaceID, "unrelated-post-key", nil, charlieSpace.CurrentVersion, nil)
require.NoError(t, err)
first, err := testCreatePost(ctx, module, bobID, bobSpace.SpaceID, "post-key-1", nil, bobSpace.CurrentVersion, nil)
require.NoError(t, err)
second, err := testCreatePost(ctx, module, bobID, bobSpace.SpaceID, "post-key-2", nil, bobSpace.CurrentVersion, nil)
require.NoError(t, err)
third, err := testCreatePost(ctx, module, bobID, bobSpace.SpaceID, "post-key-3", nil, bobSpace.CurrentVersion, nil)
require.NoError(t, err)
setPostCreatedAt(t, module, 5000, ownPost)
setPostCreatedAt(t, module, 4000, unrelatedPost)
setPostCreatedAt(t, module, 3000, first)
setPostCreatedAt(t, module, 2000, second)
setPostCreatedAt(t, module, 1000, third)
page, nextCursor, err := module.Posts.ListFeed(ctx, aliceSpace.SpaceID, "", 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, ownPost, page[0].PostID)
require.Equal(t, aliceSpace.SpaceID, page[0].SpaceID)
require.False(t, page[0].ViewerLiked)
require.Equal(t, "5000:"+strconv.FormatInt(ownPost, 10), nextCursor)
page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, first, page[0].PostID)
require.Equal(t, "3000:"+strconv.FormatInt(first, 10), nextCursor)
page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, second, page[0].PostID)
require.Equal(t, "2000:"+strconv.FormatInt(second, 10), nextCursor)
page, nextCursor, err = module.Posts.ListFeed(ctx, aliceSpace.SpaceID, nextCursor, 1)
require.NoError(t, err)
require.Len(t, page, 1)
require.Equal(t, third, page[0].PostID)
require.Empty(t, nextCursor)
}
func TestSpaceReadMarkersDriveNotificationState(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-unread-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-unread-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_unread", "alice-space-key", "alice-unread-public", "alice-unread-secret", "alice-unread-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_unread", "bob-space-key", "bob-unread-public", "bob-unread-secret", "bob-unread-secret-nonce", "bob-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
incoming, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("incoming-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("incoming-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("incoming-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2000, incoming.MessageID)
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, conversations, 1)
require.True(t, conversations[0].Unread)
require.Equal(t, int64(1), conversations[0].UnreadCount)
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, 2000))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
outgoing, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("outgoing-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("outgoing-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("outgoing-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 3000, outgoing.MessageID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, outgoing.MessageID, conversations[0].LatestActivity.MessageID.String)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
}
func TestSpaceNotificationReadMarkersArePerFriend(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-per-friend-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-per-friend-public")
charlieID := insertSpaceUser(t, module, "[email protected]", "charlie-per-friend-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_per_friend_unread", "alice-space-key", "alice-per-friend-unread-public", "alice-per-friend-unread-secret", "alice-per-friend-unread-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_per_friend_unread", "bob-space-key", "bob-per-friend-unread-public", "bob-per-friend-unread-secret", "bob-per-friend-unread-secret-nonce", "bob-profile")
require.NoError(t, err)
charlieSpace, err := testCreateSpace(ctx, module, charlieID, "charlie_per_friend_unread", "charlie-space-key", "charlie-per-friend-unread-public", "charlie-per-friend-unread-secret", "charlie-per-friend-unread-secret-nonce", "charlie-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-bob-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
require.NoError(t, testAddFriend(ctx, module, charlieID, charlieSpace.SpaceID, aliceSpace.SpaceID, "alice-charlie-share-key", aliceSpace.CurrentVersion, "charlie-share-key", charlieSpace.CurrentVersion))
bobMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("bob-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("bob-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("bob-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 1000, bobMessage.MessageID)
aliceMessageToBob, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("alice-bob-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("alice-bob-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("alice-bob-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 1001, aliceMessageToBob.MessageID)
require.NoError(t, module.Messages.SetLike(ctx, aliceMessageToBob.MessageID, bobSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 1002, aliceMessageToBob.MessageID, bobSpace.SpaceID)
charlieMessage, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: charlieSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("charlie-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("charlie-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("charlie-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2000, charlieMessage.MessageID)
conversationBySpaceID := func(spaceID string) SpaceMessageConversationRecord {
t.Helper()
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
for _, conversation := range conversations {
if conversation.Friend.SpaceID == spaceID {
return conversation
}
}
require.FailNowf(t, "conversation not found", "spaceID=%s", spaceID)
return SpaceMessageConversationRecord{}
}
bobConversation := conversationBySpaceID(bobSpace.SpaceID)
require.True(t, bobConversation.Unread)
require.Equal(t, int64(1), bobConversation.UnreadCount)
charlieConversation := conversationBySpaceID(charlieSpace.SpaceID)
require.True(t, charlieConversation.Unread)
require.Equal(t, int64(1), charlieConversation.UnreadCount)
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
bobLatestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(1002), bobLatestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, bobLatestActivityAt))
bobConversation = conversationBySpaceID(bobSpace.SpaceID)
require.False(t, bobConversation.Unread)
require.Equal(t, int64(0), bobConversation.UnreadCount)
charlieConversation = conversationBySpaceID(charlieSpace.SpaceID)
require.True(t, charlieConversation.Unread)
require.Equal(t, int64(1), charlieConversation.UnreadCount)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, charlieSpace.SpaceID, 2000))
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
}
func TestUnreadNotificationsTrackReadableActivityWithoutChangingLatestPreview(t *testing.T) {
ctx := context.Background()
module := newSpaceTestModule(t)
aliceID := insertSpaceUser(t, module, "[email protected]", "alice-priority-unread-public")
bobID := insertSpaceUser(t, module, "[email protected]", "bob-priority-unread-public")
aliceSpace, err := testCreateSpace(ctx, module, aliceID, "alice_priority_unread", "alice-space-key", "alice-priority-unread-public", "alice-priority-unread-secret", "alice-priority-unread-secret-nonce", "alice-profile")
require.NoError(t, err)
bobSpace, err := testCreateSpace(ctx, module, bobID, "bob_priority_unread", "bob-space-key", "bob-priority-unread-public", "bob-priority-unread-secret", "bob-priority-unread-secret-nonce", "bob-profile")
require.NoError(t, err)
require.NoError(t, testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "alice-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion))
incoming, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("incoming-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("incoming-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("incoming-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 1000, incoming.MessageID)
outgoing, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "regular",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("outgoing-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("outgoing-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("outgoing-recipient-key"),
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 2000, outgoing.MessageID)
conversations, _, err := listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Len(t, conversations, 1)
require.Equal(t, outgoing.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, int64(2000), conversations[0].SortCreatedAt)
require.True(t, conversations[0].Unread)
require.Equal(t, int64(1), conversations[0].UnreadCount)
require.True(t, conversations[0].NotificationUnread)
notificationsUnread, err := module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
latestActivityAt, err := module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(2000), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, outgoing.MessageID, conversations[0].LatestActivity.MessageID.String)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
require.NoError(t, module.Messages.SetLike(ctx, incoming.MessageID, aliceSpace.SpaceID, true))
setMessageLikeCreatedAt(t, module, 2500, incoming.MessageID, aliceSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message_like", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.Outgoing)
require.Equal(t, incoming.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, int64(2500), conversations[0].SortCreatedAt)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
latestActivityAt, err = module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(2500), latestActivityAt)
alicePostID, err := testCreatePost(ctx, module, aliceID, aliceSpace.SpaceID, "alice-post-key", nil, aliceSpace.CurrentVersion, nil)
require.NoError(t, err)
bobPostID, err := testCreatePost(ctx, module, bobID, bobSpace.SpaceID, "bob-post-key", nil, bobSpace.CurrentVersion, nil)
require.NoError(t, err)
_, err = module.Posts.DB.Exec(`
INSERT INTO space_post_assets (post_id, object_key, bucket_id, metadata_cipher)
VALUES ($1, $2, $3, $4)
`, bobPostID, "bob-post-object", "bucket", "metadata")
require.NoError(t, err)
require.NoError(t, testSetPostLike(ctx, module, alicePostID, bobSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 3000, alicePostID, bobSpace.SpaceID)
outgoingPostReply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
SenderSpaceID: aliceSpace.SpaceID,
RecipientSpaceID: bobSpace.SpaceID,
MessageCipher: testSpaceBytes("outgoing-post-reply-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("outgoing-post-reply-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("outgoing-post-reply-recipient-key"),
ReplyPostID: sql.NullInt64{Int64: bobPostID, Valid: true},
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 4000, outgoingPostReply.MessageID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.Equal(t, outgoingPostReply.MessageID, conversations[0].LatestActivity.MessageID.String)
require.True(t, conversations[0].LatestActivity.PostID.Valid)
require.Equal(t, bobPostID, conversations[0].LatestActivity.PostID.Int64)
require.Equal(t, int64(4000), conversations[0].SortCreatedAt)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
require.NoError(t, testSetPostLike(ctx, module, bobPostID, aliceSpace.SpaceID, true))
setPostLikeCreatedAt(t, module, 4500, bobPostID, aliceSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "message", conversations[0].LatestActivity.Type)
require.True(t, conversations[0].LatestActivity.Outgoing)
require.True(t, conversations[0].LatestActivity.PostID.Valid)
require.Equal(t, bobPostID, conversations[0].LatestActivity.PostID.Int64)
require.Equal(t, int64(4000), conversations[0].SortCreatedAt)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
latestActivityAt, err = module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(4000), latestActivityAt)
thread, _, err := module.Messages.ListThread(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, "", 10)
require.NoError(t, err)
require.GreaterOrEqual(t, len(thread), 1)
require.Equal(t, "post_reply", thread[0].Kind)
require.Equal(t, outgoingPostReply.MessageID, thread[0].MessageID)
for _, message := range thread {
require.NotEqual(t, "post_like", message.Kind)
}
incomingPostReply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("incoming-post-reply-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("incoming-post-reply-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("incoming-post-reply-recipient-key"),
ReplyPostID: sql.NullInt64{Int64: alicePostID, Valid: true},
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 5000, incomingPostReply.MessageID)
secondIncomingPostReply, err := module.Messages.CreateMessage(ctx, CreateSpaceMessageRecord{
Kind: "post_reply",
SenderSpaceID: bobSpace.SpaceID,
RecipientSpaceID: aliceSpace.SpaceID,
MessageCipher: testSpaceBytes("second-incoming-post-reply-cipher"),
SenderEncryptedMessageKey: testSpaceBytes("second-incoming-post-reply-sender-key"),
RecipientEncryptedMessageKey: testSpaceBytes("second-incoming-post-reply-recipient-key"),
ReplyPostID: sql.NullInt64{Int64: alicePostID, Valid: true},
})
require.NoError(t, err)
setMessageCreatedAt(t, module, 5001, secondIncomingPostReply.MessageID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "post_reply", conversations[0].LatestActivity.Type)
require.Equal(t, secondIncomingPostReply.MessageID, conversations[0].LatestActivity.MessageID.String)
require.Equal(t, int64(5001), conversations[0].SortCreatedAt)
require.True(t, conversations[0].Unread)
require.Equal(t, int64(2), conversations[0].UnreadCount)
require.True(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
setPostLikeCreatedAt(t, module, 6000, alicePostID, bobSpace.SpaceID)
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.Equal(t, "post_reply", conversations[0].LatestActivity.Type)
require.Equal(t, alicePostID, conversations[0].LatestActivity.PostID.Int64)
require.Equal(t, int64(5001), conversations[0].SortCreatedAt)
require.True(t, conversations[0].Unread)
require.Equal(t, int64(2), conversations[0].UnreadCount)
require.True(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.True(t, notificationsUnread)
latestActivityAt, err = module.Read.GetLatestConversationActivityAt(ctx, aliceSpace.SpaceID, bobSpace.SpaceID)
require.NoError(t, err)
require.Equal(t, int64(5001), latestActivityAt)
require.NoError(t, module.Read.UpsertNotificationReadMarker(ctx, aliceSpace.SpaceID, bobSpace.SpaceID, latestActivityAt))
conversations, _, err = listTestConversations(ctx, module, aliceSpace.SpaceID, "", 10)
require.NoError(t, err)
require.False(t, conversations[0].Unread)
require.Equal(t, int64(0), conversations[0].UnreadCount)
require.False(t, conversations[0].NotificationUnread)
notificationsUnread, err = module.Read.HasUnreadNotifications(ctx, aliceSpace.SpaceID)
require.NoError(t, err)
require.False(t, notificationsUnread)
}
func ptr(value string) *string {
return &value
}
func sqlNullInt64(value int64) sql.NullInt64 {
return sql.NullInt64{Int64: value, Valid: true}
}
func requireQueuedTempObject(t *testing.T, module *Module, objectKey, purpose, bucketID string) {
t.Helper()
var gotPurpose, gotBucketID string
var expired, cleanupDelayed bool
err := module.Assets.DB.QueryRow(`
SELECT purpose,
bucket_id,
expires_at <= now_utc_micro_seconds(),
cleanup_after >= now_utc_micro_seconds() + $2
FROM space_temp_objects
WHERE object_key = $1
`, objectKey, SpaceUploadURLExpiry.Microseconds()).Scan(&gotPurpose, &gotBucketID, &expired, &cleanupDelayed)
require.NoError(t, err)
require.Equal(t, purpose, gotPurpose)
require.Equal(t, bucketID, gotBucketID)
require.True(t, expired)
require.True(t, cleanupDelayed)
}
func setPostCreatedAt(t *testing.T, module *Module, createdAt int64, postIDs ...int64) {
t.Helper()
for _, postID := range postIDs {
_, err := module.Posts.DB.Exec(`UPDATE space_posts SET created_at = $1 WHERE post_id = $2`, createdAt, postID)
require.NoError(t, err)
}
}
func setPostLikeCreatedAt(t *testing.T, module *Module, createdAt, postID int64, actorSpaceID string) {
t.Helper()
_, err := module.Posts.DB.Exec(`UPDATE space_post_likes SET created_at = $1 WHERE post_id = $2 AND actor_space_id = $3`, createdAt, postID, actorSpaceID)
require.NoError(t, err)
}
func setFriendRequestCreatedAt(t *testing.T, module *Module, createdAt int64, requestID int64) {
t.Helper()
_, err := module.Friends.DB.Exec(`UPDATE space_friend_requests SET created_at = $1 WHERE request_id = $2`, createdAt, requestID)
require.NoError(t, err)
}
func setFriendShareCreatedAt(t *testing.T, module *Module, createdAt int64, spaceID string, friendSpaceID string) {
t.Helper()
_, err := module.Friends.DB.Exec(`UPDATE space_friend_shares SET created_at = $1 WHERE space_id = $2 AND friend_space_id = $3`, createdAt, spaceID, friendSpaceID)
require.NoError(t, err)
}
func setMessageCreatedAt(t *testing.T, module *Module, createdAt int64, messageID string) {
t.Helper()
_, err := module.Messages.DB.Exec(`UPDATE space_messages SET created_at = $1 WHERE message_id = $2`, createdAt, messageID)
require.NoError(t, err)
}
func setMessageLikeCreatedAt(t *testing.T, module *Module, createdAt int64, messageID string, actorSpaceID string) {
t.Helper()
_, err := module.Messages.DB.Exec(`UPDATE space_messages SET recipient_liked_at = $1 WHERE message_id = $2 AND recipient_space_id = $3`, createdAt, messageID, actorSpaceID)
require.NoError(t, err)
}