High performance self-hosted photo and video management solution.
TypeScript backup-toolfluttergoogle-photosgoogle-photos-alternativejavascriptmobile-appnestjsnodejsphoto-galleryphotosphotos-managementself-hostedsveltesveltekittypescriptvideos
refactor: duplicate e2e (#30773)
Jason Rasmussen342a9472c4aa
diff --git a/e2e/src/api/specs/duplicate.e2e-spec.ts b/e2e/src/api/specs/duplicate.e2e-spec.tsdeleted file mode 100644index d6d0ec1394..0000000000--- a/e2e/src/api/specs/duplicate.e2e-spec.ts+++ /dev/null@@ -1,651 +0,0 @@-import { LoginResponseDto } from '@immich/sdk';-import { createUserDto, uuidDto } from 'src/fixtures';-import { errorDto } from 'src/responses';-import { app, utils } from 'src/utils';-import request from 'supertest';-import { beforeAll, beforeEach, describe, expect, it } from 'vitest';--describe('/duplicates', () => {- let admin: LoginResponseDto;- let user1: LoginResponseDto;- let user2: LoginResponseDto;-- beforeAll(async () => {- await utils.resetDatabase();-- admin = await utils.adminSetup();-- [user1, user2] = await Promise.all([- utils.userSetup(admin.accessToken, createUserDto.user1),- utils.userSetup(admin.accessToken, createUserDto.user2),- ]);- });-- beforeEach(async () => {- // Reset assets, albums, tags, and stacks between tests to ensure clean state for repeated test runs- // Note: We don't reset users since they're set up once in beforeAll- // Stack must be reset before asset due to foreign key constraint- await utils.resetDatabase(['stack', 'asset', 'album', 'tag']);- });-- describe('GET /duplicates', () => {- it('should return empty array when no duplicates', async () => {- const { status, body } = await request(app)- .get('/duplicates')- .set('Authorization', `Bearer ${user1.accessToken}`);-- expect(status).toBe(200);- expect(body).toEqual([]);- });-- it('should return duplicate groups with suggestedKeepAssetIds', async () => {- // Create assets with different file sizes for duplicate detection- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Manually set duplicateId on both assets to create a duplicate group- const duplicateId = '00000000-0000-4000-8000-000000000001';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .get('/duplicates')- .set('Authorization', `Bearer ${user1.accessToken}`);-- expect(status).toBe(200);- expect(body).toEqual([- {- duplicateId,- assets: expect.arrayContaining([- expect.objectContaining({ id: asset1.id }),- expect.objectContaining({ id: asset2.id }),- ]),- suggestedKeepAssetIds: expect.any(Array),- },- ]);- expect(body[0].suggestedKeepAssetIds.length).toBe(1);- });- });-- describe('POST /duplicates/resolve', () => {- it('should require authentication', async () => {- const { status, body } = await request(app)- .post('/duplicates/resolve')- .send({- groups: [{ duplicateId: uuidDto.dummy, keepAssetIds: [], trashAssetIds: [] }],- });-- expect(status).toBe(401);- expect(body).toEqual(errorDto.unauthorized);- });-- it('should return failure for non-existent duplicate group', async () => {- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId: uuidDto.dummy, keepAssetIds: [], trashAssetIds: [] }],- });-- expect(status).toBe(200);- expect(body).toEqual({- status: 'COMPLETED',- results: [- {- duplicateId: uuidDto.dummy,- status: 'FAILED',- reason: expect.stringContaining('not found or access denied'),- },- ],- });- });-- it('should resolve duplicate group with keepers', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000002';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body).toEqual({- status: 'COMPLETED',- results: [- {- duplicateId,- status: 'SUCCESS',- },- ],- });-- // Verify side effects: duplicateId cleared on kept asset- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.duplicateId).toBeNull();-- // Verify side effects: trashed asset is trashed and duplicateId cleared- const trashedAsset = await utils.getAssetInfo(user1.accessToken, asset2.id);- expect(trashedAsset.isTrashed).toBe(true);- expect(trashedAsset.duplicateId).toBeNull();- });-- it('should reject when keepAssetIds and trashAssetIds overlap', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000003';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset1.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('FAILED');- expect(body.results[0].reason).toContain('disjoint');- });-- it('should require keepAssetIds when partially trashing', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000004';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [], trashAssetIds: [asset1.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('FAILED');- expect(body.results[0].reason).toContain('must cover all assets');- });-- it('should reject partial resolution (not all assets covered)', async () => {- const [asset1, asset2, asset3] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000010';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset3.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('FAILED');- expect(body.results[0].reason).toContain('must cover all assets');- });-- it('should reject asset not in duplicate group', async () => {- const [asset1, asset2, outsideAsset] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000011';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [outsideAsset.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('FAILED');- expect(body.results[0].reason).toContain('not a member of duplicate group');- });-- it('should allow trash-all without keepers', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000012';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [], trashAssetIds: [asset1.id, asset2.id] }],- });-- expect(status).toBe(200);- expect(body).toEqual({- status: 'COMPLETED',- results: [- {- duplicateId,- status: 'SUCCESS',- },- ],- });-- // Verify both assets are trashed- const [asset1Info, asset2Info] = await Promise.all([- utils.getAssetInfo(user1.accessToken, asset1.id),- utils.getAssetInfo(user1.accessToken, asset2.id),- ]);-- expect(asset1Info.isTrashed).toBe(true);- expect(asset1Info.duplicateId).toBeNull();- expect(asset2Info.isTrashed).toBe(true);- expect(asset2Info.duplicateId).toBeNull();- });-- it('should reject cross-user duplicate group access', async () => {- const asset1 = await utils.createAsset(user1.accessToken);- const asset2 = await utils.createAsset(user2.accessToken);-- const duplicateId = '00000000-0000-4000-8000-000000000013';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user2.accessToken, asset2.id, duplicateId);-- // User1 tries to resolve a group containing user2's asset- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('FAILED');- expect(body.results[0].reason).toContain('not a member of duplicate group');- });-- it('should synchronize favorites when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Mark one asset as favorite- await request(app)- .put('/assets')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({ ids: [asset2.id], isFavorite: true });-- const duplicateId = '00000000-0000-4000-8000-000000000020';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify favorite was synchronized to keeper- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.isFavorite).toBe(true);- expect(keptAsset.duplicateId).toBeNull();- });-- it('should synchronize visibility when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Archive one asset- await utils.archiveAssets(user1.accessToken, [asset2.id]);-- const duplicateId = '00000000-0000-4000-8000-000000000021';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify visibility was synchronized to keeper- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.visibility).toBe('archive');- expect(keptAsset.duplicateId).toBeNull();- });-- it('should synchronize rating when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Set rating on one asset- await request(app)- .put('/assets')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({ ids: [asset2.id], rating: 5 });-- const duplicateId = '00000000-0000-4000-8000-000000000022';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify rating was synchronized to keeper- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.exifInfo?.rating).toBe(5);- expect(keptAsset.duplicateId).toBeNull();- });-- it('should synchronize description when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Set description on one asset- await request(app)- .put('/assets')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({ ids: [asset2.id], description: 'Test description for duplicate' });-- const duplicateId = '00000000-0000-4000-8000-000000000023';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify description was synchronized to keeper- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.exifInfo?.description).toBe('Test description for duplicate');- expect(keptAsset.duplicateId).toBeNull();- });-- it('should synchronize location when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Set location on one asset- await request(app)- .put('/assets')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({ ids: [asset2.id], latitude: 40.7128, longitude: -74.006 });-- const duplicateId = '00000000-0000-4000-8000-000000000024';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify location was synchronized to keeper- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.exifInfo?.latitude).toBe(40.7128);- expect(keptAsset.exifInfo?.longitude).toBe(-74.006);- expect(keptAsset.duplicateId).toBeNull();- });-- it('should synchronize albums when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Create albums and add assets to different albums- const album1 = await utils.createAlbum(user1.accessToken, {- albumName: 'Album 1',- assetIds: [asset1.id],- });- const album2 = await utils.createAlbum(user1.accessToken, {- albumName: 'Album 2',- assetIds: [asset2.id],- });-- const duplicateId = '00000000-0000-4000-8000-000000000025';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify keeper is now in both albums- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.duplicateId).toBeNull();-- // Check albums directly- const { status: album1Status, body: album1Body } = await request(app)- .get(`/albums/${album1.id}`)- .set('Authorization', `Bearer ${user1.accessToken}`);- const { status: album2Status, body: album2Body } = await request(app)- .get(`/albums/${album2.id}`)- .set('Authorization', `Bearer ${user1.accessToken}`);-- expect(album1Status).toBe(200);- expect(album2Status).toBe(200);- expect(album1Body.assets.map((a: any) => a.id)).toContain(asset1.id);- expect(album2Body.assets.map((a: any) => a.id)).toContain(asset1.id);- });-- it('should synchronize tags when enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- // Wait for metadata extraction to complete before adding tags- // Otherwise, metadata jobs will race and overwrite our tags- await utils.waitForQueueFinish(admin.accessToken, 'metadataExtraction');-- // Create tags and tag assets differently- const tags = await utils.upsertTags(user1.accessToken, ['tag1', 'tag2']);- await utils.tagAssets(user1.accessToken, tags[0].id, [asset1.id]);- await utils.tagAssets(user1.accessToken, tags[1].id, [asset2.id]);-- const duplicateId = '00000000-0000-4000-8000-000000000026';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify keeper has both tags- const keptAsset = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(keptAsset.duplicateId).toBeNull();- expect(keptAsset.tags).toBeDefined();- const tagIds = keptAsset.tags?.map((t) => t.id) || [];- expect(tagIds).toContain(tags[0].id);- expect(tagIds).toContain(tags[1].id);- });-- it('should handle batch resolve with mixed success and failure', async () => {- // Create first group that will succeed- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);- const duplicateId1 = '00000000-0000-4000-8000-000000000027';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId1);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId1);-- // Create second group with non-existent duplicate ID (will fail)- const fakeId = '00000000-0000-4000-8000-000000000099';-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [- { duplicateId: duplicateId1, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] },- { duplicateId: fakeId, keepAssetIds: [], trashAssetIds: [] },- ],- });-- expect(status).toBe(200);- expect(body.status).toBe('COMPLETED');- expect(body.results).toHaveLength(2);-- // First group should succeed- expect(body.results[0].duplicateId).toBe(duplicateId1);- expect(body.results[0].status).toBe('SUCCESS');-- // Second group should fail- expect(body.results[1].duplicateId).toBe(fakeId);- expect(body.results[1].status).toBe('FAILED');- expect(body.results[1].reason).toContain('not found or access denied');-- // Verify first group was actually resolved despite second failure- const asset1Info = await utils.getAssetInfo(user1.accessToken, asset1.id);- expect(asset1Info.duplicateId).toBeNull();- const asset2Info = await utils.getAssetInfo(user1.accessToken, asset2.id);- expect(asset2Info.isTrashed).toBe(true);- });-- it('should trash assets when trash is enabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000028';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- // Ensure trash is enabled (default)- const config = await utils.getSystemConfig(admin.accessToken);- expect(config.trash.enabled).toBe(true);-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Verify asset is trashed (not deleted)- const trashedAsset = await utils.getAssetInfo(user1.accessToken, asset2.id);- expect(trashedAsset.isTrashed).toBe(true);- });-- it('should delete assets when trash is disabled', async () => {- const [asset1, asset2] = await Promise.all([- utils.createAsset(user1.accessToken),- utils.createAsset(user1.accessToken),- ]);-- const duplicateId = '00000000-0000-4000-8000-000000000029';- await utils.setAssetDuplicateId(user1.accessToken, asset1.id, duplicateId);- await utils.setAssetDuplicateId(user1.accessToken, asset2.id, duplicateId);-- // Disable trash- await request(app)- .put('/system-config')- .set('Authorization', `Bearer ${admin.accessToken}`)- .send({- trash: { enabled: false, days: 30 },- });-- const { status, body } = await request(app)- .post('/duplicates/resolve')- .set('Authorization', `Bearer ${user1.accessToken}`)- .send({- groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }],- });-- expect(status).toBe(200);- expect(body.results[0].status).toBe('SUCCESS');-- // Asset should be marked as deleted (force delete)- const { status: getStatus } = await request(app)- .get(`/assets/${asset2.id}`)- .set('Authorization', `Bearer ${user1.accessToken}`);-- // Asset should still be accessible (soft deleted) but marked as deleted- expect(getStatus).toBe(200);-- // Re-enable trash for other tests- await utils.resetAdminConfig(admin.accessToken);- });- });-});diff --git a/server/test/medium.factory.ts b/server/test/medium.factory.tsindex f0f14757b2..860189d9a9 100644--- a/server/test/medium.factory.ts+++ b/server/test/medium.factory.ts@@ -29,6 +29,7 @@ import { ConfigRepository } from 'src/repositories/config.repository';import { CronRepository } from 'src/repositories/cron.repository';import { CryptoRepository } from 'src/repositories/crypto.repository';import { DatabaseRepository } from 'src/repositories/database.repository';+import { DuplicateRepository } from 'src/repositories/duplicate.repository';import { EmailRepository } from 'src/repositories/email.repository';import { EventRepository } from 'src/repositories/event.repository';import { IntegrityRepository } from 'src/repositories/integrity.repository';@@ -445,6 +446,7 @@ const newRealRepository = <T extends BaseServiceDeps[number]>(key: T, db: Kyselycase AssetRepository:case AssetEditRepository:case AssetJobRepository:+ case DuplicateRepository:case IntegrityRepository:case MemoryRepository:case NotificationRepository:diff --git a/server/test/medium/specs/services/duplicate.service.spec.ts b/server/test/medium/specs/services/duplicate.service.spec.tsnew file mode 100644index 0000000000..6afae277cb--- /dev/null+++ b/server/test/medium/specs/services/duplicate.service.spec.ts@@ -0,0 +1,622 @@+import { Kysely } from 'kysely';+import { BulkIdErrorReason, BulkIdResponseDto } from 'src/dtos/asset-ids.response.dto';+import { AssetStatus, AssetVisibility } from 'src/enum';+import { AccessRepository } from 'src/repositories/access.repository';+import { AlbumRepository } from 'src/repositories/album.repository';+import { AssetRepository } from 'src/repositories/asset.repository';+import { ConfigRepository } from 'src/repositories/config.repository';+import { DuplicateRepository } from 'src/repositories/duplicate.repository';+import { EventRepository } from 'src/repositories/event.repository';+import { JobRepository } from 'src/repositories/job.repository';+import { LoggingRepository } from 'src/repositories/logging.repository';+import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';+import { TagRepository } from 'src/repositories/tag.repository';+import { DB } from 'src/schema';+import { DuplicateService } from 'src/services/duplicate.service';+import { clearConfigCache } from 'src/utils/config';+import { MediumTestContext, newMediumService } from 'test/medium.factory';+import { factory } from 'test/small.factory';+import { getKyselyDB } from 'test/utils';++let defaultDatabase: Kysely<DB>;++const setup = (db?: Kysely<DB>) => {+ const { sut, ctx } = newMediumService(DuplicateService, {+ database: db || defaultDatabase,+ real: [+ AccessRepository,+ AlbumRepository,+ AssetRepository,+ ConfigRepository,+ DuplicateRepository,+ SystemMetadataRepository,+ TagRepository,+ ],+ mock: [EventRepository, JobRepository, LoggingRepository],+ });++ ctx.getMock(EventRepository).emit.mockResolvedValue();+ ctx.getMock(JobRepository).queueAll.mockResolvedValue();++ return { sut, ctx };+};++const newDuplicateAsset = async (+ ctx: MediumTestContext,+ {+ ownerId,+ duplicateId,+ ...dto+ }: { ownerId: string; duplicateId?: string; isFavorite?: boolean; visibility?: AssetVisibility },+ exif: { rating?: number; description?: string; latitude?: number; longitude?: number; fileSizeInByte?: number } = {},+) => {+ const { asset } = await ctx.newAsset({ ownerId, duplicateId, ...dto });+ await ctx.newExif({ assetId: asset.id, fileSizeInByte: 1000, ...exif });+ return asset;+};++const newTag = async (ctx: MediumTestContext, userId: string, value: string) => {+ return ctx.get(TagRepository).create({ userId, value });+};++const expectSuccess = (results: BulkIdResponseDto[], duplicateId: string) => {+ expect(results).toEqual([{ id: duplicateId, success: true }]);+};++beforeAll(async () => {+ defaultDatabase = await getKyselyDB();+});++beforeEach(() => {+ clearConfigCache();+});++describe(DuplicateService.name, () => {+ describe('getDuplicates', () => {+ it('should return an empty list when the user has no duplicates', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const auth = factory.auth({ user: { id: user.id } });++ await expect(sut.getDuplicates(auth)).resolves.toEqual([]);+ });++ it('should return a duplicate group with a suggested keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const small = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { fileSizeInByte: 1000 });+ const large = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { fileSizeInByte: 2000 });++ const auth = factory.auth({ user: { id: user.id } });+ const duplicates = await sut.getDuplicates(auth);++ expect(duplicates).toHaveLength(1);+ expect(duplicates[0].duplicateId).toBe(duplicateId);+ expect(duplicates[0].assets.map(({ id }) => id).sort()).toEqual([small.id, large.id].sort());+ // largest file size wins+ expect(duplicates[0].suggestedKeepAssetIds).toEqual([large.id]);+ });++ it('should not return duplicates owned by someone else', async () => {+ const { sut, ctx } = setup();+ const { user: owner } = await ctx.newUser();+ const { user: other } = await ctx.newUser();+ const duplicateId = factory.uuid();++ await newDuplicateAsset(ctx, { ownerId: owner.id, duplicateId });+ await newDuplicateAsset(ctx, { ownerId: owner.id, duplicateId });++ const auth = factory.auth({ user: { id: other.id } });+ await expect(sut.getDuplicates(auth)).resolves.toEqual([]);+ });++ it('should clear the duplicateId of a singleton group', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const asset = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(sut.getDuplicates(auth)).resolves.toEqual([]);++ await expect(ctx.get(AssetRepository).getById(asset.id)).resolves.toMatchObject({ duplicateId: null });+ });+ });++ describe('resolve', () => {+ it('should throw when the duplicate group does not exist', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const auth = factory.auth({ user: { id: user.id } });++ await expect(+ sut.resolve(auth, { groups: [{ duplicateId: factory.uuid(), keepAssetIds: [], trashAssetIds: [] }] }),+ ).rejects.toThrow('Not found or no duplicate.delete access');+ });++ it('should throw when the duplicate group belongs to another user', async () => {+ const { sut, ctx } = setup();+ const { user: owner } = await ctx.newUser();+ const { user: other } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const asset1 = await newDuplicateAsset(ctx, { ownerId: owner.id, duplicateId });+ const asset2 = await newDuplicateAsset(ctx, { ownerId: owner.id, duplicateId });++ const auth = factory.auth({ user: { id: other.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }] }),+ ).rejects.toThrow('Not found or no duplicate.delete access');+ });++ it('should clear the duplicateId of the keeper and trash the rest', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }] }),+ ).resolves.toEqual([{ id: duplicateId, success: true }]);++ const assetRepo = ctx.get(AssetRepository);+ await expect(assetRepo.getById(keeper.id)).resolves.toMatchObject({+ duplicateId: null,+ deletedAt: null,+ });+ await expect(assetRepo.getById(trashed.id)).resolves.toMatchObject({+ duplicateId: null,+ status: AssetStatus.Trashed,+ });+ });++ it('should emit AssetTrashAll for the trashed assets', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }] }),+ duplicateId,+ );++ expect(ctx.getMock(EventRepository).emit).toHaveBeenCalledWith('AssetTrashAll', {+ assetIds: [trashed.id],+ userId: user.id,+ });+ });++ it('should fail when an asset is in both keepAssetIds and trashAssetIds', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const asset1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset1.id] }] }),+ ).resolves.toEqual([+ {+ id: duplicateId,+ success: false,+ error: BulkIdErrorReason.VALIDATION,+ errorMessage: 'An asset cannot be in both keepAssetIds and trashAssetIds',+ },+ ]);+ });++ it('should fail when the group is only partially covered', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const asset1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const asset2 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [asset2.id] }] }),+ ).resolves.toEqual([+ {+ id: duplicateId,+ success: false,+ error: BulkIdErrorReason.VALIDATION,+ errorMessage: 'Every asset must be in either keepAssetIds or trashAssetIds',+ },+ ]);+ });++ it('should ignore ids that are not members of the group', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const asset1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const outsider = await newDuplicateAsset(ctx, { ownerId: user.id });++ // the outsider is filtered out, which leaves asset2 uncovered+ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [asset1.id], trashAssetIds: [outsider.id] }] }),+ ).resolves.toEqual([+ {+ id: duplicateId,+ success: false,+ error: BulkIdErrorReason.VALIDATION,+ errorMessage: 'Every asset must be in either keepAssetIds or trashAssetIds',+ },+ ]);++ await expect(ctx.get(AssetRepository).getById(outsider.id)).resolves.toMatchObject({ deletedAt: null });+ });++ it('should trash every asset when no keepers are given', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const asset1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const asset2 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [], trashAssetIds: [asset1.id, asset2.id] }],+ }),+ ).resolves.toEqual([{ id: duplicateId, success: true }]);++ const assetRepo = ctx.get(AssetRepository);+ for (const { id } of [asset1, asset2]) {+ await expect(assetRepo.getById(id)).resolves.toMatchObject({+ duplicateId: null,+ status: AssetStatus.Trashed,+ });+ }+ });++ it('should fail without permission to delete an asset owned by someone else', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const { user: other } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const mine = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const theirs = await newDuplicateAsset(ctx, { ownerId: other.id, duplicateId });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [mine.id], trashAssetIds: [theirs.id] }] }),+ ).resolves.toEqual([+ {+ id: duplicateId,+ success: false,+ error: BulkIdErrorReason.NO_PERMISSION,+ errorMessage: 'No permission to delete assets',+ },+ ]);++ await expect(ctx.get(AssetRepository).getById(theirs.id)).resolves.toMatchObject({ deletedAt: null });+ });++ it('should resolve several groups in one request', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId1 = factory.uuid();+ const duplicateId2 = factory.uuid();++ const keeper1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: duplicateId1 });+ const trashed1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: duplicateId1 });+ const keeper2 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: duplicateId2 });+ const trashed2 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: duplicateId2 });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, {+ groups: [+ { duplicateId: duplicateId1, keepAssetIds: [keeper1.id], trashAssetIds: [trashed1.id] },+ { duplicateId: duplicateId2, keepAssetIds: [keeper2.id], trashAssetIds: [trashed2.id] },+ ],+ }),+ ).resolves.toEqual([+ { id: duplicateId1, success: true },+ { id: duplicateId2, success: true },+ ]);++ const assetRepo = ctx.get(AssetRepository);+ await expect(assetRepo.getById(trashed1.id)).resolves.toMatchObject({ status: AssetStatus.Trashed });+ await expect(assetRepo.getById(trashed2.id)).resolves.toMatchObject({ status: AssetStatus.Trashed });+ });++ it('should report per-group failures without abandoning the valid groups', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const goodId = factory.uuid();+ const badId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: goodId });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: goodId });+ // the bad group exists (so access passes) but is left partially covered+ const badKeeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: badId });+ await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId: badId });++ const auth = factory.auth({ user: { id: user.id } });+ const results = await sut.resolve(auth, {+ groups: [+ { duplicateId: goodId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] },+ { duplicateId: badId, keepAssetIds: [badKeeper.id], trashAssetIds: [] },+ ],+ });++ expect(results).toEqual([+ { id: goodId, success: true },+ {+ id: badId,+ success: false,+ error: BulkIdErrorReason.VALIDATION,+ errorMessage: 'Every asset must be in either keepAssetIds or trashAssetIds',+ },+ ]);++ // the good group still went through+ await expect(ctx.get(AssetRepository).getById(trashed.id)).resolves.toMatchObject({+ status: AssetStatus.Trashed,+ });+ });++ describe('metadata merging', () => {+ it('should merge isFavorite into the keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId, isFavorite: false });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId, isFavorite: true });++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ await expect(ctx.get(AssetRepository).getById(keeper.id)).resolves.toMatchObject({+ isFavorite: true,+ duplicateId: null,+ });+ });++ it('should merge the most restrictive visibility into the keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeperAsset = await newDuplicateAsset(ctx, {+ ownerId: user.id,+ duplicateId,+ visibility: AssetVisibility.Timeline,+ });+ const trashedAsset = await newDuplicateAsset(ctx, {+ ownerId: user.id,+ duplicateId,+ visibility: AssetVisibility.Archive,+ });++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeperAsset.id], trashAssetIds: [trashedAsset.id] }],+ }),+ duplicateId,+ );++ await expect(ctx.get(AssetRepository).getById(keeperAsset.id)).resolves.toMatchObject({+ visibility: AssetVisibility.Archive,+ duplicateId: null,+ });+ });++ it('should merge the highest rating into the keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { rating: 1 });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { rating: 5 });++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ const result = await ctx.get(AssetRepository).getById(keeper.id, { exifInfo: true });+ expect(result?.exifInfo).toMatchObject({ rating: 5 });+ });++ it('should merge distinct description lines into the keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { description: 'from keeper' });+ const trashed = await newDuplicateAsset(+ ctx,+ { ownerId: user.id, duplicateId },+ { description: 'from trashed' },+ );++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ const result = await ctx.get(AssetRepository).getById(keeper.id, { exifInfo: true });+ expect(result?.exifInfo?.description?.split('\n').sort()).toEqual(['from keeper', 'from trashed']);+ });++ it('should merge a location that both assets agree on', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const trashed = await newDuplicateAsset(+ ctx,+ { ownerId: user.id, duplicateId },+ { latitude: 40.7128, longitude: -74.006 },+ );++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ const result = await ctx.get(AssetRepository).getById(keeper.id, { exifInfo: true });+ expect(result?.exifInfo).toMatchObject({ latitude: 40.7128, longitude: -74.006 });+ });++ it('should not merge a location the assets disagree on', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { latitude: 1, longitude: 1 });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId }, { latitude: 2, longitude: 2 });++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ const result = await ctx.get(AssetRepository).getById(keeper.id, { exifInfo: true });+ expect(result?.exifInfo).toMatchObject({ latitude: 1, longitude: 1 });+ });++ it('should add the keeper to every album the group belonged to', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const { album: album1 } = await ctx.newAlbum({ ownerId: user.id }, [keeper.id]);+ const { album: album2 } = await ctx.newAlbum({ ownerId: user.id }, [trashed.id]);++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ const albumRepo = ctx.get(AlbumRepository);+ await expect(albumRepo.getAssetIds(album1.id, [keeper.id])).resolves.toEqual(new Set([keeper.id]));+ await expect(albumRepo.getAssetIds(album2.id, [keeper.id])).resolves.toEqual(new Set([keeper.id]));+ });++ it('should merge the tags of the group onto the keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const tag1 = await newTag(ctx, user.id, 'tag1');+ const tag2 = await newTag(ctx, user.id, 'tag2');+ await ctx.newTagAsset({ tagIds: [tag1.id], assetIds: [keeper.id] });+ await ctx.newTagAsset({ tagIds: [tag2.id], assetIds: [trashed.id] });++ const auth = factory.auth({ user: { id: user.id } });+ expectSuccess(+ await sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }],+ }),+ duplicateId,+ );++ const result = await ctx.get(AssetRepository).getById(keeper.id, { tags: true });+ expect(result?.tags?.map(({ id }) => id).sort()).toEqual([tag1.id, tag2.id].sort());+ });++ it('should not merge metadata when there is more than one keeper', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper1 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId, isFavorite: false });+ const keeper2 = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId, isFavorite: true });++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, {+ groups: [{ duplicateId, keepAssetIds: [keeper1.id, keeper2.id], trashAssetIds: [] }],+ }),+ ).resolves.toEqual([{ id: duplicateId, success: true }]);++ await expect(ctx.get(AssetRepository).getById(keeper1.id)).resolves.toMatchObject({+ isFavorite: false,+ duplicateId: null,+ });+ });+ });++ describe('when trash is disabled', () => {+ it('should delete instead of trash', async () => {+ const { sut, ctx } = setup();+ const { user } = await ctx.newUser();+ const duplicateId = factory.uuid();++ const keeper = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });+ const trashed = await newDuplicateAsset(ctx, { ownerId: user.id, duplicateId });++ const config = await ctx.getConfig();+ await ctx.updateConfig({ ...config, trash: { ...config.trash, enabled: false } });+ clearConfigCache();++ const auth = factory.auth({ user: { id: user.id } });+ await expect(+ sut.resolve(auth, { groups: [{ duplicateId, keepAssetIds: [keeper.id], trashAssetIds: [trashed.id] }] }),+ ).resolves.toEqual([{ id: duplicateId, success: true }]);++ await expect(ctx.get(AssetRepository).getById(trashed.id)).resolves.toMatchObject({+ duplicateId: null,+ status: AssetStatus.Deleted,+ });++ expect(ctx.getMock(EventRepository).emit).toHaveBeenCalledWith('AssetDeleteAll', {+ assetIds: [trashed.id],+ userId: user.id,+ });+ });+ });+ });+});