π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
package collections
import (
"context"
"database/sql"
"errors"
"net/http/httptest"
"strconv"
"sync/atomic"
"testing"
"time"
"github.com/ente/museum/ente"
"github.com/ente/museum/internal/testutil"
museumcontroller "github.com/ente/museum/pkg/controller"
"github.com/ente/museum/pkg/controller/access"
"github.com/ente/museum/pkg/repo"
castRepo "github.com/ente/museum/pkg/repo/cast"
publicRepo "github.com/ente/museum/pkg/repo/public"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type panicUserLookup struct{}
func requireBadRequestError(t *testing.T, err error) {
t.Helper()
var apiErr *ente.ApiError
if !errors.As(err, &apiErr) || apiErr.Code != ente.BadRequest {
t.Fatalf("error = %v, want %s", err, ente.BadRequest)
}
}
func (panicUserLookup) LookupUserID(int64, string) (int64, error) {
panic("user lookup must not be called while revoking collection access")
}
func (panicUserLookup) VerifyUserID(int64, string, int64) error {
panic("user lookup must not be called while revoking collection access")
}
type fixedUserLookup struct {
userID int64
}
func (l fixedUserLookup) LookupUserID(int64, string) (int64, error) {
return l.userID, nil
}
func (fixedUserLookup) VerifyUserID(int64, string, int64) error {
return nil
}
func newShareTestCollectionRepo(db *sql.DB) *repo.CollectionRepository {
return &repo.CollectionRepository{
DB: db,
CollectionLinkRepo: publicRepo.NewCollectionLinkRepository(db, ""),
SecretEncryptionKey: testutil.SecretEncryptionKey(),
}
}
func newShareTestUserLookup(db *sql.DB) *museumcontroller.UserLookupController {
return museumcontroller.NewUserLookupController(&repo.UserRepository{
DB: db,
HashingKey: testutil.HashingKey(),
}, nil)
}
func createShareTestCollection(t *testing.T, collectionRepo *repo.CollectionRepository, ownerID int64) int64 {
return createShareTestCollectionOfType(t, collectionRepo, ownerID, "album")
}
func createShareTestCollectionOfType(
t *testing.T,
collectionRepo *repo.CollectionRepository,
ownerID int64,
collectionType string,
) int64 {
t.Helper()
collection, err := collectionRepo.Create(ente.Collection{
Owner: ente.CollectionUser{ID: ownerID},
EncryptedKey: "encrypted-key",
KeyDecryptionNonce: "key-nonce",
Name: "Test collection",
Type: collectionType,
Attributes: ente.CollectionAttributes{},
UpdationTime: 1,
App: string(ente.Photos),
})
if err != nil {
t.Fatal(err)
}
return collection.ID
}
func setupCollectionShareTest(
t *testing.T,
) (*sql.DB, *repo.CollectionRepository, int64, int64) {
t.Helper()
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
ownerID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 1,
Email: "[email protected]",
CreationTime: 1,
})
shareeID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 2,
Email: "[email protected]",
CreationTime: 1,
})
return db, newShareTestCollectionRepo(db), ownerID, shareeID
}
func newBatchShareTestController(
db *sql.DB,
collectionRepo *repo.CollectionRepository,
) *CollectionController {
return &CollectionController{
PushCtrl: &museumcontroller.PushController{},
AccessCtrl: access.NewAccessController(collectionRepo, nil),
CollectionRepo: collectionRepo,
UserLookup: newShareTestUserLookup(db),
}
}
func newBatchShareTestContext(userID int64) *gin.Context {
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = httptest.NewRequest("POST", "/collections/share/batch", nil)
ctx.Request.Header.Set("X-Auth-User-ID", strconv.FormatInt(userID, 10))
return ctx
}
func setShareTestFamilyAdmin(t *testing.T, db *sql.DB, userID int64, familyAdminID any) {
t.Helper()
if _, err := db.Exec(
`UPDATE users SET family_admin_id = $1 WHERE user_id = $2`,
familyAdminID,
userID,
); err != nil {
t.Fatal(err)
}
}
func requireCollectionShareStatus(
t *testing.T,
status, want ente.CollectionShareStatus,
err error,
) {
t.Helper()
if err != nil || status != want {
t.Fatalf("share status = %q, want %q; error = %v", status, want, err)
}
}
func collectionUpdationTime(t *testing.T, db *sql.DB, collectionID int64) int64 {
t.Helper()
var updationTime int64
err := db.QueryRow(
`SELECT updation_time FROM collections WHERE collection_id = $1`,
collectionID,
).Scan(&updationTime)
if err != nil {
t.Fatal(err)
}
return updationTime
}
func collectionShareCount(t *testing.T, db *sql.DB, collectionID int64) int {
t.Helper()
var count int
if err := db.QueryRow(
`SELECT count(*) FROM collection_shares WHERE collection_id = $1`,
collectionID,
).Scan(&count); err != nil {
t.Fatal(err)
}
return count
}
func addShareTestShare(
t *testing.T,
collectionRepo *repo.CollectionRepository,
collectionID, ownerID, shareeID int64,
role ente.CollectionParticipantRole,
) {
t.Helper()
if err := collectionRepo.Share(collectionID, ownerID, shareeID, "share-key", role, 1); err != nil {
t.Fatal(err)
}
}
func addShareTestOwnerFile(t *testing.T, db *sql.DB, collectionID, ownerID int64) int64 {
t.Helper()
var fileID int64
err := db.QueryRow(
`WITH inserted_file AS (
INSERT INTO files(owner_id, file_decryption_header, thumbnail_decryption_header, metadata_decryption_header, encrypted_metadata, updation_time, info)
VALUES($1, 'file-header', 'thumbnail-header', 'metadata-header', 'encrypted-metadata', 1, '{}'::jsonb)
RETURNING file_id
)
INSERT INTO collection_files(collection_id, file_id, encrypted_key, key_decryption_nonce, updation_time, c_owner_id, f_owner_id)
SELECT $2, file_id, 'collection-file-key', 'collection-file-nonce', 1, $1, $1 FROM inserted_file
RETURNING file_id`,
ownerID,
collectionID,
).Scan(&fileID)
if err != nil {
t.Fatal(err)
}
return fileID
}
func TestUnShareResolvesTargetFromCurrentSharees(t *testing.T) {
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
ownerID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 1,
Email: "[email protected]",
CreationTime: 1,
})
shareeID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 2,
Email: "[email protected]",
CreationTime: 1,
})
collectionRepo := newShareTestCollectionRepo(db)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
addShareTestShare(t, collectionRepo, collectionID, ownerID, shareeID, ente.VIEWER)
controller := &CollectionController{
CollectionRepo: collectionRepo,
CastRepo: &castRepo.Repository{DB: db},
UserLookup: panicUserLookup{},
}
gin.SetMode(gin.TestMode)
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
sharees, err := controller.UnShare(ctx, collectionID, ownerID, " [email protected] ")
if err != nil {
t.Fatalf("unshare returned error: %v", err)
}
if len(sharees) != 0 {
t.Fatalf("sharees after unshare = %+v, want none", sharees)
}
var isDeleted bool
err = db.QueryRow(
`SELECT is_deleted FROM collection_shares WHERE collection_id = $1 AND to_user_id = $2`,
collectionID,
shareeID,
).Scan(&isDeleted)
if err != nil {
t.Fatal(err)
}
if !isDeleted {
t.Fatal("collection share remains active after unshare")
}
_, err = controller.UnShare(ctx, collectionID, ownerID, "[email protected]")
if !errors.Is(err, ente.ErrNotFound) {
t.Fatalf("missing sharee error = %v, want %v", err, ente.ErrNotFound)
}
}
func TestShareAuthorizesBeforeUserLookup(t *testing.T) {
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
ownerID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 1,
Email: "[email protected]",
CreationTime: 1,
})
collectionRepo := newShareTestCollectionRepo(db)
controller := &CollectionController{
CollectionRepo: collectionRepo,
UserLookup: panicUserLookup{},
}
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = httptest.NewRequest("POST", "/collections/share", nil)
ctx.Request.Header.Set("X-Auth-User-ID", "2")
_, err := controller.Share(ctx, ente.AlterShareRequest{
CollectionID: createShareTestCollection(t, collectionRepo, ownerID),
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
})
if !errors.Is(err, ente.ErrPermissionDenied) {
t.Fatalf("share error = %v, want %v", err, ente.ErrPermissionDenied)
}
}
func TestCollectionOwnerCannotBecomeShareeOrBeUnshared(t *testing.T) {
testutil.WithServerRoot(t)
db := testutil.RequireTestDB(t)
testutil.ResetTables(t, db)
t.Cleanup(func() { testutil.ResetTables(t, db) })
ownerID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 1,
Email: "[email protected]",
CreationTime: 1,
})
adminID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 2,
Email: "[email protected]",
CreationTime: 1,
})
collectionRepo := newShareTestCollectionRepo(db)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
addShareTestShare(t, collectionRepo, collectionID, ownerID, adminID, ente.ADMIN)
controller := &CollectionController{
CollectionRepo: collectionRepo,
UserLookup: fixedUserLookup{userID: ownerID},
}
gin.SetMode(gin.TestMode)
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = httptest.NewRequest("POST", "/collections/share", nil)
ctx.Request.Header.Set("X-Auth-User-ID", strconv.FormatInt(adminID, 10))
_, err := controller.Share(ctx, ente.AlterShareRequest{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
})
if !errors.Is(err, ente.ErrBadRequest) {
t.Fatalf("sharing to owner error = %v, want %v", err, ente.ErrBadRequest)
}
addShareTestShare(t, collectionRepo, collectionID, ownerID, ownerID, ente.VIEWER)
fileID := addShareTestOwnerFile(t, db, collectionID, ownerID)
_, err = controller.UnShare(ctx, collectionID, adminID, "[email protected]")
if !errors.Is(err, ente.ErrPermissionDenied) {
t.Fatalf("unsharing owner error = %v, want %v", err, ente.ErrPermissionDenied)
}
var ownerShareDeleted, ownerFileDeleted bool
err = db.QueryRow(
`SELECT cs.is_deleted, cf.is_deleted
FROM collection_shares cs
JOIN collection_files cf ON cf.collection_id = cs.collection_id
WHERE cs.collection_id = $1 AND cs.to_user_id = $2 AND cf.file_id = $3`,
collectionID,
ownerID,
fileID,
).Scan(&ownerShareDeleted, &ownerFileDeleted)
if err != nil {
t.Fatal(err)
}
if ownerShareDeleted || ownerFileDeleted {
t.Fatalf("owner state changed: share deleted=%t, file deleted=%t", ownerShareDeleted, ownerFileDeleted)
}
}
func TestAutomaticShareLifecycle(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
ctx := context.Background()
manualCollectionID := createShareTestCollection(t, collectionRepo, ownerID)
if err := collectionRepo.Share(
manualCollectionID,
ownerID,
shareeID,
"manual-key",
ente.ADMIN,
1,
); err != nil {
t.Fatal(err)
}
status, err := collectionRepo.ShareAutomatically(
ctx,
manualCollectionID,
ownerID,
shareeID,
"automatic-key",
ente.VIEWER,
2,
)
requireCollectionShareStatus(t, status, ente.CollectionAlreadyShared, err)
var encryptedKey, role string
var isDeleted bool
err = db.QueryRow(
`SELECT encrypted_key, role_type, is_deleted
FROM collection_shares
WHERE collection_id = $1 AND to_user_id = $2`,
manualCollectionID,
shareeID,
).Scan(&encryptedKey, &role, &isDeleted)
if err != nil {
t.Fatal(err)
}
if encryptedKey != "manual-key" || role != string(ente.ADMIN) || isDeleted {
t.Fatalf(
"manual share changed: key=%q role=%q deleted=%t",
encryptedKey,
role,
isDeleted,
)
}
status, err = collectionRepo.UnShareContext(
ctx,
manualCollectionID,
shareeID,
)
requireCollectionShareStatus(t, status, ente.CollectionUnshared, err)
status, err = collectionRepo.ShareAutomatically(
ctx,
manualCollectionID,
ownerID,
shareeID,
"automatic-key",
ente.VIEWER,
3,
)
requireCollectionShareStatus(t, status, ente.CollectionBlockedPriorRemoval, err)
automaticCollectionID := createShareTestCollection(t, collectionRepo, ownerID)
status, err = collectionRepo.ShareAutomatically(
ctx,
automaticCollectionID,
ownerID,
shareeID,
"automatic-key",
ente.VIEWER,
1,
)
requireCollectionShareStatus(t, status, ente.CollectionShared, err)
}
func TestAutomaticShareRejectsDeletedCollection(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
if _, err := db.Exec(`UPDATE collections SET is_deleted = TRUE WHERE collection_id = $1`, collectionID); err != nil {
t.Fatal(err)
}
_, err := collectionRepo.ShareAutomatically(context.Background(), collectionID, ownerID, shareeID, "share-key", ente.VIEWER, 2)
if !errors.Is(err, ente.ErrCollectionDeleted) {
t.Fatalf("ShareAutomatically() error = %v, want %v", err, ente.ErrCollectionDeleted)
}
if count := collectionShareCount(t, db, collectionID); count != 0 {
t.Fatalf("collection shares = %d, want 0", count)
}
}
func TestUnShareContextBumpsCollectionForDeletedShareRow(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
ctx := context.Background()
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
if err := collectionRepo.Share(
collectionID,
ownerID,
shareeID,
"share-key",
ente.VIEWER,
1,
); err != nil {
t.Fatal(err)
}
status, err := collectionRepo.UnShareContext(ctx, collectionID, shareeID)
requireCollectionShareStatus(t, status, ente.CollectionUnshared, err)
if _, err := db.Exec(
`UPDATE collections SET updation_time = 1 WHERE collection_id = $1`,
collectionID,
); err != nil {
t.Fatal(err)
}
status, err = collectionRepo.UnShareContext(ctx, collectionID, shareeID)
requireCollectionShareStatus(t, status, ente.CollectionAlreadyUnshared, err)
if got := collectionUpdationTime(t, db, collectionID); got == 1 {
t.Fatal("collection updation_time was not bumped for deleted share row")
}
}
func TestUncategorizedCollectionsOnlyAllowViewerShares(t *testing.T) {
_, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
collectionID := createShareTestCollectionOfType(
t,
collectionRepo,
ownerID,
"uncategorized",
)
controller := &CollectionController{CollectionRepo: collectionRepo}
item := ente.BulkCollectionShareItem{
CollectionID: collectionID,
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: ente.VIEWER,
}
status, _, err := controller.shareCollectionWithUserID(
context.Background(),
ownerID,
shareeID,
ente.ManualShare,
item,
)
requireCollectionShareStatus(t, status, ente.CollectionShared, err)
item.Role = ente.ADMIN
_, _, err = controller.shareCollectionWithUserID(
context.Background(),
ownerID,
shareeID,
ente.ManualShare,
item,
)
if !errors.Is(err, ente.ErrBadRequest) {
t.Fatalf("admin share error = %v, want %v", err, ente.ErrBadRequest)
}
}
func TestBulkShareAndUnshareReturnPerCollectionStatuses(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
setShareTestFamilyAdmin(t, db, ownerID, ownerID)
setShareTestFamilyAdmin(t, db, shareeID, ownerID)
albumID := createShareTestCollection(t, collectionRepo, ownerID)
neverSharedID := createShareTestCollection(t, collectionRepo, ownerID)
uncategorizedID := createShareTestCollectionOfType(
t,
collectionRepo,
ownerID,
"uncategorized",
)
controller := &CollectionController{
CollectionRepo: collectionRepo,
CastRepo: &castRepo.Repository{DB: db},
UserRepo: &repo.UserRepository{DB: db},
UserLookup: newShareTestUserLookup(db),
}
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = httptest.NewRequest("POST", "/collections/share/bulk", nil)
ctx.Request.Header.Set("X-Auth-User-ID", strconv.FormatInt(ownerID, 10))
results, err := controller.BulkShare(ctx, ente.BulkCollectionShareRequest{
RecipientUserID: shareeID,
RecipientEmail: "[email protected]",
Source: ente.AutomaticShare,
Collections: []ente.BulkCollectionShareItem{
{
CollectionID: albumID,
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: ente.VIEWER,
},
{
CollectionID: uncategorizedID,
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: ente.ADMIN,
},
},
})
if err != nil {
t.Fatal(err)
}
if results[0].Status != ente.CollectionShared ||
results[1].Status != ente.CollectionShareOperationFailed {
t.Fatalf("bulk share results = %+v", results)
}
controller.UserLookup = panicUserLookup{}
unshareResults, err := controller.BulkUnShare(ctx, ente.BulkCollectionUnshareRequest{
RecipientUserID: shareeID,
Source: ente.AutomaticShare,
CollectionIDs: []int64{albumID, neverSharedID},
})
if err != nil {
t.Fatal(err)
}
if unshareResults[0].Status != ente.CollectionUnshared ||
unshareResults[1].Status != ente.CollectionNotShared {
t.Fatalf("bulk unshare results = %+v", unshareResults)
}
}
func TestBulkShareAutomaticRecipientMustBeInSameFamily(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
controller := &CollectionController{
PushCtrl: &museumcontroller.PushController{},
CollectionRepo: collectionRepo,
UserRepo: &repo.UserRepository{DB: db},
UserLookup: newShareTestUserLookup(db),
}
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = httptest.NewRequest("POST", "/collections/share/bulk", nil)
ctx.Request.Header.Set("X-Auth-User-ID", strconv.FormatInt(ownerID, 10))
share := func(collectionID int64, source ente.CollectionShareSource) error {
_, err := controller.BulkShare(ctx, ente.BulkCollectionShareRequest{
RecipientUserID: shareeID,
RecipientEmail: "[email protected]",
Source: source,
Collections: []ente.BulkCollectionShareItem{{
CollectionID: collectionID,
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: ente.VIEWER,
}},
})
return err
}
setShareTestFamilyAdmin(t, db, ownerID, ownerID)
setShareTestFamilyAdmin(t, db, shareeID, shareeID)
if err := share(createShareTestCollection(t, collectionRepo, ownerID), ente.AutomaticShare); !errors.Is(err, ente.ErrAutomaticShareRecipientNotEligible) {
t.Fatalf("unrelated automatic share error = %v, want %v", err, ente.ErrAutomaticShareRecipientNotEligible)
}
setShareTestFamilyAdmin(t, db, shareeID, nil)
if err := share(createShareTestCollection(t, collectionRepo, ownerID), ente.AutomaticShare); !errors.Is(err, ente.ErrAutomaticShareRecipientNotEligible) {
t.Fatalf("former family member automatic share error = %v, want %v", err, ente.ErrAutomaticShareRecipientNotEligible)
}
var shareCount int
if err := db.QueryRow(`SELECT count(*) FROM collection_shares`).Scan(&shareCount); err != nil {
t.Fatal(err)
}
if shareCount != 0 {
t.Fatalf("collection shares after rejected requests = %d, want 0", shareCount)
}
if err := share(createShareTestCollection(t, collectionRepo, ownerID), ente.ManualShare); err != nil {
t.Fatalf("manual share error = %v", err)
}
setShareTestFamilyAdmin(t, db, shareeID, ownerID)
if err := share(createShareTestCollection(t, collectionRepo, ownerID), ente.AutomaticShare); err != nil {
t.Fatalf("same-family automatic share error = %v", err)
}
}
func TestBulkShareRejectsRecipientIdentityMismatchBeforeMutation(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
controller := &CollectionController{
CollectionRepo: collectionRepo,
UserLookup: newShareTestUserLookup(db),
}
ctx, _ := gin.CreateTestContext(httptest.NewRecorder())
ctx.Request = httptest.NewRequest("POST", "/collections/share/bulk", nil)
ctx.Request.Header.Set("X-Auth-User-ID", strconv.FormatInt(ownerID, 10))
_, err := controller.BulkShare(ctx, ente.BulkCollectionShareRequest{
RecipientUserID: shareeID + 1,
RecipientEmail: "[email protected]",
Source: ente.AutomaticShare,
Collections: []ente.BulkCollectionShareItem{{
CollectionID: collectionID,
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: ente.VIEWER,
}},
})
if !errors.Is(err, ente.ErrRecipientIdentityMismatch) {
t.Fatalf("bulk share error = %v, want %v", err, ente.ErrRecipientIdentityMismatch)
}
var shareCount int
if err := db.QueryRow(
`SELECT count(*) FROM collection_shares WHERE collection_id = $1`,
collectionID,
).Scan(&shareCount); err != nil {
t.Fatal(err)
}
if shareCount != 0 {
t.Fatalf("collection shares after rejected request = %d, want 0", shareCount)
}
}
func TestBulkShareRejectsOversizedBatch(t *testing.T) {
items := make([]ente.BulkCollectionShareItem, ente.MaxCollectionShareBatchSize+1)
for index := range items {
items[index].CollectionID = int64(index + 1)
}
controller := &CollectionController{}
_, err := controller.BulkShare(&gin.Context{}, ente.BulkCollectionShareRequest{
RecipientUserID: 1,
Source: ente.AutomaticShare,
Collections: items,
})
if !errors.Is(err, ente.ErrBatchSizeTooLarge) {
t.Fatalf("oversized batch error = %v, want %v", err, ente.ErrBatchSizeTooLarge)
}
}
func TestBatchShareWritesEveryShareWithOneTimestamp(t *testing.T) {
db, collectionRepo, ownerID, firstShareeID := setupCollectionShareTest(t)
secondShareeID := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 3,
Email: "[email protected]",
CreationTime: 1,
})
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
addShareTestShare(t, collectionRepo, collectionID, ownerID, firstShareeID, ente.VIEWER)
if _, err := collectionRepo.UnShareContext(context.Background(), collectionID, firstShareeID); err != nil {
t.Fatal(err)
}
controller := newBatchShareTestController(db, collectionRepo)
ctx := newBatchShareTestContext(ownerID)
admin := ente.ADMIN
collaborator := ente.COLLABORATOR
sharees, err := controller.BatchShare(ctx, []ente.AlterShareRequest{
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: &admin,
},
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: &collaborator,
},
})
if err != nil {
t.Fatal(err)
}
if len(sharees) != 2 {
t.Fatalf("sharees = %+v, want 2", sharees)
}
roles := make(map[int64]ente.CollectionParticipantRole, len(sharees))
for _, sharee := range sharees {
roles[sharee.ID] = sharee.Role
}
if roles[firstShareeID] != ente.ADMIN || roles[secondShareeID] != ente.COLLABORATOR {
t.Fatalf("sharee roles = %+v", roles)
}
var existingKey string
if err := db.QueryRow(
`SELECT encrypted_key FROM collection_shares
WHERE collection_id = $1 AND to_user_id = $2`,
collectionID,
firstShareeID,
).Scan(&existingKey); err != nil {
t.Fatal(err)
}
if existingKey != "share-key" {
t.Fatalf("existing encrypted key = %q, want %q", existingKey, "share-key")
}
var collectionTime, shareTime int64
var distinctShareTimes int
if err := db.QueryRow(
`SELECT count(DISTINCT updation_time), min(updation_time)
FROM collection_shares WHERE collection_id = $1`,
collectionID,
).Scan(&distinctShareTimes, &shareTime); err != nil {
t.Fatal(err)
}
if err := db.QueryRow(
`SELECT updation_time FROM collections WHERE collection_id = $1`,
collectionID,
).Scan(&collectionTime); err != nil {
t.Fatal(err)
}
if distinctShareTimes != 1 || shareTime != collectionTime {
t.Fatalf("share times = %d distinct at %d; collection time = %d", distinctShareTimes, shareTime, collectionTime)
}
}
func TestBatchShareDoesNotWriteWhenAnyLookupFails(t *testing.T) {
db, collectionRepo, ownerID, _ := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
controller := newBatchShareTestController(db, collectionRepo)
ctx := newBatchShareTestContext(ownerID)
_, err := controller.BatchShare(ctx, []ente.AlterShareRequest{
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
},
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
},
})
if err == nil {
t.Fatal("BatchShare() error = nil, want missing-user error")
}
if count := collectionShareCount(t, db, collectionID); count != 0 {
t.Fatalf("collection shares = %d, want 0", count)
}
}
func TestBatchShareRollsBackWhenAnyWriteFails(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
originalCollectionTime := collectionUpdationTime(t, db, collectionID)
err := collectionRepo.BatchShare(
context.Background(),
collectionID,
ownerID,
[]repo.CollectionShareItem{
{ToUserID: shareeID, EncryptedKey: "share-key", Role: ente.VIEWER},
{ToUserID: shareeID + 1000, EncryptedKey: "missing-user-key", Role: ente.VIEWER},
},
originalCollectionTime+1,
)
if err == nil {
t.Fatal("BatchShare() error = nil, want foreign-key error")
}
shareCount := collectionShareCount(t, db, collectionID)
collectionTime := collectionUpdationTime(t, db, collectionID)
if shareCount != 0 || collectionTime != originalCollectionTime {
t.Fatalf("after rollback: shares = %d, collection time = %d, want %d", shareCount, collectionTime, originalCollectionTime)
}
}
func TestBatchShareRejectsDeletedCollection(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
if _, err := db.Exec(
`UPDATE collections SET is_deleted = TRUE WHERE collection_id = $1`,
collectionID,
); err != nil {
t.Fatal(err)
}
controller := newBatchShareTestController(db, collectionRepo)
_, err := controller.BatchShare(newBatchShareTestContext(ownerID), []ente.AlterShareRequest{
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
},
})
if !errors.Is(err, ente.ErrCollectionDeleted) {
t.Fatalf("BatchShare() error = %v, want %v", err, ente.ErrCollectionDeleted)
}
_, err = controller.BatchShare(newBatchShareTestContext(shareeID), []ente.AlterShareRequest{
{CollectionID: collectionID, Email: "[email protected]"},
})
if !errors.Is(err, ente.ErrPermissionDenied) {
t.Fatalf("unauthorized BatchShare() error = %v, want %v", err, ente.ErrPermissionDenied)
}
err = collectionRepo.BatchShare(
context.Background(),
collectionID,
ownerID,
[]repo.CollectionShareItem{{
ToUserID: shareeID,
EncryptedKey: "share-key",
Role: ente.VIEWER,
}},
2,
)
if !errors.Is(err, ente.ErrCollectionDeleted) {
t.Fatalf("CollectionRepository.BatchShare() error = %v, want %v", err, ente.ErrCollectionDeleted)
}
if count := collectionShareCount(t, db, collectionID); count != 0 {
t.Fatalf("collection shares = %d, want 0", count)
}
}
func TestBulkUnShareStillSucceedsOnDeletedCollection(t *testing.T) {
db, collectionRepo, ownerID, shareeID := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
addShareTestShare(t, collectionRepo, collectionID, ownerID, shareeID, ente.VIEWER)
for _, query := range []string{
`UPDATE collection_shares SET is_deleted = TRUE WHERE collection_id = $1`,
`UPDATE collections SET is_deleted = TRUE WHERE collection_id = $1`,
} {
if _, err := db.Exec(query, collectionID); err != nil {
t.Fatal(err)
}
}
controller := &CollectionController{
CollectionRepo: collectionRepo,
CastRepo: &castRepo.Repository{DB: db},
UserLookup: panicUserLookup{},
}
results, err := controller.BulkUnShare(newBatchShareTestContext(ownerID), ente.BulkCollectionUnshareRequest{
RecipientUserID: shareeID,
Source: ente.ManualShare,
CollectionIDs: []int64{collectionID},
})
if err != nil {
t.Fatal(err)
}
if len(results) != 1 || results[0].Status != ente.CollectionAlreadyUnshared {
t.Fatalf("bulk unshare results = %+v, want %q", results, ente.CollectionAlreadyUnshared)
}
}
func TestBatchShareRejectsInvalidInputAsBadRequest(t *testing.T) {
db, collectionRepo, ownerID, _ := setupCollectionShareTest(t)
collectionID := createShareTestCollection(t, collectionRepo, ownerID)
invalidRole := ente.CollectionParticipantRole("INVALID")
controller := newBatchShareTestController(db, collectionRepo)
_, err := controller.BatchShare(newBatchShareTestContext(ownerID), []ente.AlterShareRequest{
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
Role: &invalidRole,
},
})
requireBadRequestError(t, err)
_, err = controller.BatchShare(newBatchShareTestContext(ownerID), []ente.AlterShareRequest{
{
CollectionID: collectionID,
Email: "[email protected]",
EncryptedKey: "invalid",
},
})
requireBadRequestError(t, err)
}
func TestBatchShareRejectsNormalizedDuplicates(t *testing.T) {
err := validateBatchShares([]ente.AlterShareRequest{
{CollectionID: 1, Email: "[email protected]"},
{CollectionID: 1, Email: " [email protected] "},
})
if !errors.Is(err, ente.ErrBadRequest) {
t.Fatalf("duplicate share email error = %v, want %v", err, ente.ErrBadRequest)
}
}
func TestBatchShareRejectsDifferentCollectionsBeforeWrites(t *testing.T) {
controller := &CollectionController{}
_, err := controller.BatchShare(&gin.Context{}, []ente.AlterShareRequest{
{CollectionID: 1, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen)},
{CollectionID: 2, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen)},
})
if !errors.Is(err, ente.ErrBadRequest) {
t.Fatalf("different collection IDs error = %v, want %v", err, ente.ErrBadRequest)
}
}
func TestBatchShareRejectsOversizedBatch(t *testing.T) {
shares := make([]ente.AlterShareRequest, ente.MaxBatchShareSize+1)
for index := range shares {
shares[index] = ente.AlterShareRequest{
CollectionID: 1,
Email: "sharee" + strconv.Itoa(index) + "@example.com",
EncryptedKey: b64OfLen(sealedCollectionKeyLen),
}
}
controller := &CollectionController{}
_, err := controller.BatchShare(&gin.Context{}, shares)
if !errors.Is(err, ente.ErrBatchSizeTooLarge) {
t.Fatalf("oversized share batch error = %v, want %v", err, ente.ErrBatchSizeTooLarge)
}
}
type albumSharePushFunc func(context.Context, []int64)
func (f albumSharePushFunc) NotifyAlbumShare(ctx context.Context, recipients []int64) {
f(ctx, recipients)
}
func TestAlbumShareNotifiesAfterEverySuccessfulShare(t *testing.T) {
db, r, owner, recipient := setupCollectionShareTest(t)
c := newBatchShareTestController(db, r)
id := createShareTestCollection(t, r, owner)
notifications := make(chan []int64, 4)
c.PushCtrl = albumSharePushFunc(func(ctx context.Context, users []int64) {
_, pooledContext := ctx.(*gin.Context)
assert.False(t, pooledContext)
var active bool
assert.NoError(t, db.QueryRow(`SELECT NOT is_deleted FROM collection_shares WHERE collection_id=$1 AND to_user_id=$2`, id, recipient).Scan(&active))
assert.True(t, active, "notification must run after commit")
notifications <- users
})
request := ente.AlterShareRequest{CollectionID: id, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen)}
_, err := c.Share(newBatchShareTestContext(owner), request)
require.NoError(t, err)
require.Eventually(t, func() bool { return len(notifications) == 1 }, time.Second, time.Millisecond)
require.Equal(t, []int64{recipient}, <-notifications)
_, err = c.BatchShare(newBatchShareTestContext(owner), []ente.AlterShareRequest{request})
require.NoError(t, err)
role := ente.COLLABORATOR
request.Role = &role
_, err = c.Share(newBatchShareTestContext(owner), request)
require.NoError(t, err)
require.Eventually(t, func() bool { return len(notifications) == 2 }, time.Second, time.Millisecond, "retry and role change must notify")
require.Equal(t, []int64{recipient}, <-notifications)
require.Equal(t, []int64{recipient}, <-notifications)
require.NoError(t, r.UnShare(id, recipient))
_, err = c.BatchShare(newBatchShareTestContext(owner), []ente.AlterShareRequest{request})
require.NoError(t, err)
require.Eventually(t, func() bool { return len(notifications) == 1 }, time.Second, time.Millisecond)
require.Equal(t, []int64{recipient}, <-notifications, "restored access should notify")
require.NoError(t, r.UnShare(id, recipient))
_, err = db.Exec(`UPDATE collections SET is_deleted = TRUE WHERE collection_id = $1`, id)
require.NoError(t, err)
_, err = c.Share(newBatchShareTestContext(owner), request)
require.ErrorIs(t, err, ente.ErrCollectionDeleted)
require.Never(t, func() bool { return len(notifications) > 0 }, 50*time.Millisecond, time.Millisecond)
var deleted bool
require.NoError(t, db.QueryRow(`SELECT is_deleted FROM collection_shares WHERE collection_id=$1 AND to_user_id=$2`, id, recipient).Scan(&deleted))
require.True(t, deleted, "failed share must roll back restored access")
}
func TestBatchShareNotifiesAllRecipients(t *testing.T) {
db, r, owner, existingRecipient := setupCollectionShareTest(t)
newRecipient := testutil.InsertUser(t, db, testutil.UserFixture{
UserID: 3, Email: "[email protected]", CreationTime: 1,
})
id := createShareTestCollection(t, r, owner)
addShareTestShare(t, r, id, owner, existingRecipient, ente.VIEWER)
c := newBatchShareTestController(db, r)
notifications := make(chan []int64, 1)
c.PushCtrl = albumSharePushFunc(func(_ context.Context, recipients []int64) {
notifications <- recipients
})
admin, collaborator := ente.ADMIN, ente.COLLABORATOR
_, err := c.BatchShare(newBatchShareTestContext(owner), []ente.AlterShareRequest{
{CollectionID: id, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen), Role: &admin},
{CollectionID: id, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen), Role: &collaborator},
})
require.NoError(t, err)
select {
case recipients := <-notifications:
require.ElementsMatch(t, []int64{existingRecipient, newRecipient}, recipients)
case <-time.After(time.Second):
t.Fatal("new recipient was not notified")
}
}
func TestBulkAlbumShareNotifiesOnceAfterAllMutations(t *testing.T) {
db, r, owner, recipient := setupCollectionShareTest(t)
c := newBatchShareTestController(db, r)
request := ente.BulkCollectionShareRequest{RecipientUserID: recipient, RecipientEmail: "[email protected]", Source: ente.ManualShare}
for range 2 {
request.Collections = append(request.Collections, ente.BulkCollectionShareItem{CollectionID: createShareTestCollection(t, r, owner), EncryptedKey: b64OfLen(sealedCollectionKeyLen), Role: ente.VIEWER})
}
var calls atomic.Int32
c.PushCtrl = albumSharePushFunc(func(_ context.Context, _ []int64) {
for _, item := range request.Collections {
var count int
assert.NoError(t, db.QueryRow(`SELECT COUNT(*) FROM collection_shares WHERE collection_id=$1`, item.CollectionID).Scan(&count))
assert.Equal(t, 1, count)
}
calls.Add(1)
})
for range 2 {
_, err := c.BulkShare(newBatchShareTestContext(owner), request)
require.NoError(t, err)
}
require.Eventually(t, func() bool { return calls.Load() == 2 }, time.Second, time.Millisecond)
}
func TestAlbumSharePushEligibility(t *testing.T) {
db, r, owner, recipient := setupCollectionShareTest(t)
c := newBatchShareTestController(db, r)
var calls atomic.Int32
var expected int32
c.PushCtrl = albumSharePushFunc(func(context.Context, []int64) { calls.Add(1) })
for _, collection := range []ente.Collection{
{Type: "album", App: string(ente.Photos)},
{Type: "album", App: string(ente.Locker)},
{Type: "folder", App: string(ente.Photos)},
{Type: "favorites", App: string(ente.Photos)},
{Type: "uncategorized", App: string(ente.Photos)},
} {
id := createShareTestCollection(t, r, owner)
_, err := db.Exec(`UPDATE collections SET type=$2, app=$3 WHERE collection_id=$1`, id, collection.Type, collection.App)
require.NoError(t, err)
for _, flow := range []string{"single", "batch", "bulk"} {
request := ente.AlterShareRequest{CollectionID: id, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen)}
switch flow {
case "single":
_, err = c.Share(newBatchShareTestContext(owner), request)
case "batch":
_, err = c.BatchShare(newBatchShareTestContext(owner), []ente.AlterShareRequest{request})
case "bulk":
_, err = c.BulkShare(newBatchShareTestContext(owner), ente.BulkCollectionShareRequest{
RecipientUserID: recipient, RecipientEmail: request.Email, Source: ente.ManualShare,
Collections: []ente.BulkCollectionShareItem{{CollectionID: id, EncryptedKey: request.EncryptedKey, Role: ente.VIEWER}},
})
}
require.NoError(t, err)
require.Equal(t, 1, collectionShareCount(t, db, id))
require.NoError(t, r.UnShare(id, recipient))
}
if collection.App == string(ente.Photos) {
expected += 3
require.Eventually(t, func() bool { return calls.Load() == expected }, time.Second, time.Millisecond)
}
}
require.Never(t, func() bool { return calls.Load() > expected }, 50*time.Millisecond, time.Millisecond)
}
func TestAlbumShareDoesNotWaitForPush(t *testing.T) {
for _, flow := range []string{"single", "batch", "bulk"} {
t.Run(flow, func(t *testing.T) {
db, r, owner, recipient := setupCollectionShareTest(t)
c := newBatchShareTestController(db, r)
id := createShareTestCollection(t, r, owner)
request := ente.AlterShareRequest{CollectionID: id, Email: "[email protected]", EncryptedKey: b64OfLen(sealedCollectionKeyLen)}
started := make(chan struct{})
release := make(chan struct{})
returned := make(chan struct{})
c.PushCtrl = albumSharePushFunc(func(context.Context, []int64) {
close(started)
<-release
})
t.Cleanup(func() { close(release); <-returned })
var err error
go func() {
switch flow {
case "single":
_, err = c.Share(newBatchShareTestContext(owner), request)
case "batch":
_, err = c.BatchShare(newBatchShareTestContext(owner), []ente.AlterShareRequest{request})
case "bulk":
_, err = c.BulkShare(newBatchShareTestContext(owner), ente.BulkCollectionShareRequest{
RecipientUserID: recipient, RecipientEmail: request.Email, Source: ente.ManualShare,
Collections: []ente.BulkCollectionShareItem{{CollectionID: id, EncryptedKey: request.EncryptedKey, Role: ente.VIEWER}},
})
}
close(returned)
}()
select {
case <-returned:
require.NoError(t, err)
case <-time.After(5 * time.Second):
t.Fatal("sharing must return while push delivery is blocked")
}
select {
case <-started:
case <-time.After(time.Second):
t.Fatal("push delivery was not started")
}
})
}
}