chore: migrate to vitest (#7156)

* chore: jest => vitest

* chore: replace jest-when

server/test/repositories/access.repository.mock.ts

@@ -1,16 +1,17 @@
 import { AccessCore } from 'src/cores/access.core';
 import { IAccessRepository } from 'src/interfaces/access.interface';
+import { Mocked, vitest } from 'vitest';
 
 export interface IAccessRepositoryMock {
-  activity: jest.Mocked<IAccessRepository['activity']>;
-  asset: jest.Mocked<IAccessRepository['asset']>;
-  album: jest.Mocked<IAccessRepository['album']>;
-  authDevice: jest.Mocked<IAccessRepository['authDevice']>;
-  library: jest.Mocked<IAccessRepository['library']>;
-  timeline: jest.Mocked<IAccessRepository['timeline']>;
-  memory: jest.Mocked<IAccessRepository['memory']>;
-  person: jest.Mocked<IAccessRepository['person']>;
-  partner: jest.Mocked<IAccessRepository['partner']>;
+  activity: Mocked<IAccessRepository['activity']>;
+  asset: Mocked<IAccessRepository['asset']>;
+  album: Mocked<IAccessRepository['album']>;
+  authDevice: Mocked<IAccessRepository['authDevice']>;
+  library: Mocked<IAccessRepository['library']>;
+  timeline: Mocked<IAccessRepository['timeline']>;
+  memory: Mocked<IAccessRepository['memory']>;
+  person: Mocked<IAccessRepository['person']>;
+  partner: Mocked<IAccessRepository['partner']>;
 }
 
 export const newAccessRepositoryMock = (reset = true): IAccessRepositoryMock => {
@@ -20,47 +21,47 @@ export const newAccessRepositoryMock = (reset = true): IAccessRepositoryMock =>
 
   return {
     activity: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkAlbumOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkCreateAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkAlbumOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkCreateAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     asset: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkAlbumAccess: jest.fn().mockResolvedValue(new Set()),
-      checkPartnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkSharedLinkAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkAlbumAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkPartnerAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkSharedLinkAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     album: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkSharedAlbumAccess: jest.fn().mockResolvedValue(new Set()),
-      checkSharedLinkAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkSharedAlbumAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkSharedLinkAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     authDevice: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     library: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     timeline: {
-      checkPartnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkPartnerAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     memory: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     person: {
-      checkFaceOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkFaceOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vitest.fn().mockResolvedValue(new Set()),
     },
 
     partner: {
-      checkUpdateAccess: jest.fn().mockResolvedValue(new Set()),
+      checkUpdateAccess: vitest.fn().mockResolvedValue(new Set()),
     },
   };
 };

server/test/repositories/activity.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IActivityRepository } from 'src/interfaces/activity.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newActivityRepositoryMock = (): jest.Mocked<IActivityRepository> => {
+export const newActivityRepositoryMock = (): Mocked<IActivityRepository> => {
   return {
-    search: jest.fn(),
-    create: jest.fn(),
-    delete: jest.fn(),
-    getStatistics: jest.fn(),
+    search: vitest.fn(),
+    create: vitest.fn(),
+    delete: vitest.fn(),
+    getStatistics: vitest.fn(),
   };
 };

server/test/repositories/album.repository.mock.ts

@@ -1,27 +1,28 @@
 import { IAlbumRepository } from 'src/interfaces/album.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newAlbumRepositoryMock = (): jest.Mocked<IAlbumRepository> => {
+export const newAlbumRepositoryMock = (): Mocked<IAlbumRepository> => {
   return {
-    getById: jest.fn(),
-    getByIds: jest.fn(),
-    getByAssetId: jest.fn(),
-    getMetadataForIds: jest.fn(),
-    getInvalidThumbnail: jest.fn(),
-    getOwned: jest.fn(),
-    getShared: jest.fn(),
-    getNotShared: jest.fn(),
-    restoreAll: jest.fn(),
-    softDeleteAll: jest.fn(),
-    deleteAll: jest.fn(),
-    getAll: jest.fn(),
-    addAssetIds: jest.fn(),
-    removeAsset: jest.fn(),
-    removeAssetIds: jest.fn(),
-    getAssetIds: jest.fn(),
-    hasAsset: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    updateThumbnails: jest.fn(),
+    getById: vitest.fn(),
+    getByIds: vitest.fn(),
+    getByAssetId: vitest.fn(),
+    getMetadataForIds: vitest.fn(),
+    getInvalidThumbnail: vitest.fn(),
+    getOwned: vitest.fn(),
+    getShared: vitest.fn(),
+    getNotShared: vitest.fn(),
+    restoreAll: vitest.fn(),
+    softDeleteAll: vitest.fn(),
+    deleteAll: vitest.fn(),
+    getAll: vitest.fn(),
+    addAssetIds: vitest.fn(),
+    removeAsset: vitest.fn(),
+    removeAssetIds: vitest.fn(),
+    getAssetIds: vitest.fn(),
+    hasAsset: vitest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    delete: vitest.fn(),
+    updateThumbnails: vitest.fn(),
   };
 };

server/test/repositories/api-key.repository.mock.ts

@@ -1,12 +1,13 @@
 import { IKeyRepository } from 'src/interfaces/api-key.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newKeyRepositoryMock = (): jest.Mocked<IKeyRepository> => {
+export const newKeyRepositoryMock = (): Mocked<IKeyRepository> => {
   return {
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getKey: jest.fn(),
-    getById: jest.fn(),
-    getByUserId: jest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    delete: vitest.fn(),
+    getKey: vitest.fn(),
+    getById: vitest.fn(),
+    getByUserId: vitest.fn(),
   };
 };

server/test/repositories/asset-stack.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IAssetStackRepository } from 'src/interfaces/asset-stack.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newAssetStackRepositoryMock = (): jest.Mocked<IAssetStackRepository> => {
+export const newAssetStackRepositoryMock = (): Mocked<IAssetStackRepository> => {
   return {
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getById: jest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    delete: vitest.fn(),
+    getById: vitest.fn(),
   };
 };

server/test/repositories/asset.repository.mock.ts

@@ -1,41 +1,42 @@
 import { IAssetRepository } from 'src/interfaces/asset.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newAssetRepositoryMock = (): jest.Mocked<IAssetRepository> => {
+export const newAssetRepositoryMock = (): Mocked<IAssetRepository> => {
   return {
-    create: jest.fn(),
-    upsertExif: jest.fn(),
-    upsertJobStatus: jest.fn(),
-    getByDayOfYear: jest.fn(),
-    getByIds: jest.fn().mockResolvedValue([]),
-    getByIdsWithAllRelations: jest.fn().mockResolvedValue([]),
-    getByAlbumId: jest.fn(),
-    getByUserId: jest.fn(),
-    getById: jest.fn(),
-    getWithout: jest.fn(),
-    getByChecksum: jest.fn(),
-    getWith: jest.fn(),
-    getRandom: jest.fn(),
-    getFirstAssetForAlbumId: jest.fn(),
-    getLastUpdatedAssetForAlbumId: jest.fn(),
-    getAll: jest.fn().mockResolvedValue({ items: [], hasNextPage: false }),
-    getAllByDeviceId: jest.fn(),
-    updateAll: jest.fn(),
-    getExternalLibraryAssetPaths: jest.fn(),
-    getByLibraryIdAndOriginalPath: jest.fn(),
-    deleteAll: jest.fn(),
-    update: jest.fn(),
-    remove: jest.fn(),
-    findLivePhotoMatch: jest.fn(),
-    getMapMarkers: jest.fn(),
-    getStatistics: jest.fn(),
-    getTimeBucket: jest.fn(),
-    getTimeBuckets: jest.fn(),
-    restoreAll: jest.fn(),
-    softDeleteAll: jest.fn(),
-    getAssetIdByCity: jest.fn(),
-    getAssetIdByTag: jest.fn(),
-    searchMetadata: jest.fn(),
-    getAllForUserFullSync: jest.fn(),
-    getChangedDeltaSync: jest.fn(),
+    create: vitest.fn(),
+    upsertExif: vitest.fn(),
+    upsertJobStatus: vitest.fn(),
+    getByDayOfYear: vitest.fn(),
+    getByIds: vitest.fn().mockResolvedValue([]),
+    getByIdsWithAllRelations: vitest.fn().mockResolvedValue([]),
+    getByAlbumId: vitest.fn(),
+    getByUserId: vitest.fn(),
+    getById: vitest.fn(),
+    getWithout: vitest.fn(),
+    getByChecksum: vitest.fn(),
+    getWith: vitest.fn(),
+    getRandom: vitest.fn(),
+    getFirstAssetForAlbumId: vitest.fn(),
+    getLastUpdatedAssetForAlbumId: vitest.fn(),
+    getAll: vitest.fn().mockResolvedValue({ items: [], hasNextPage: false }),
+    getAllByDeviceId: vitest.fn(),
+    updateAll: vitest.fn(),
+    getExternalLibraryAssetPaths: vitest.fn(),
+    getByLibraryIdAndOriginalPath: vitest.fn(),
+    deleteAll: vitest.fn(),
+    update: vitest.fn(),
+    remove: vitest.fn(),
+    findLivePhotoMatch: vitest.fn(),
+    getMapMarkers: vitest.fn(),
+    getStatistics: vitest.fn(),
+    getTimeBucket: vitest.fn(),
+    getTimeBuckets: vitest.fn(),
+    restoreAll: vitest.fn(),
+    softDeleteAll: vitest.fn(),
+    getAssetIdByCity: vitest.fn(),
+    getAssetIdByTag: vitest.fn(),
+    searchMetadata: vitest.fn(),
+    getAllForUserFullSync: vitest.fn(),
+    getChangedDeltaSync: vitest.fn(),
   };
 };

server/test/repositories/audit.repository.mock.ts

@@ -1,8 +1,9 @@
 import { IAuditRepository } from 'src/interfaces/audit.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newAuditRepositoryMock = (): jest.Mocked<IAuditRepository> => {
+export const newAuditRepositoryMock = (): Mocked<IAuditRepository> => {
   return {
-    getAfter: jest.fn(),
-    removeBefore: jest.fn(),
+    getAfter: vitest.fn(),
+    removeBefore: vitest.fn(),
   };
 };

server/test/repositories/crypto.repository.mock.ts

@@ -1,14 +1,15 @@
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newCryptoRepositoryMock = (): jest.Mocked<ICryptoRepository> => {
+export const newCryptoRepositoryMock = (): Mocked<ICryptoRepository> => {
   return {
-    randomUUID: jest.fn().mockReturnValue('random-uuid'),
-    randomBytes: jest.fn().mockReturnValue(Buffer.from('random-bytes', 'utf8')),
-    compareBcrypt: jest.fn().mockReturnValue(true),
-    hashBcrypt: jest.fn().mockImplementation((input) => Promise.resolve(`${input} (hashed)`)),
-    hashSha256: jest.fn().mockImplementation((input) => `${input} (hashed)`),
-    hashSha1: jest.fn().mockImplementation((input) => Buffer.from(`${input.toString()} (hashed)`)),
-    hashFile: jest.fn().mockImplementation((input) => `${input} (file-hashed)`),
-    newPassword: jest.fn().mockReturnValue(Buffer.from('random-bytes').toString('base64')),
+    randomUUID: vitest.fn().mockReturnValue('random-uuid'),
+    randomBytes: vitest.fn().mockReturnValue(Buffer.from('random-bytes', 'utf8')),
+    compareBcrypt: vitest.fn().mockReturnValue(true),
+    hashBcrypt: vitest.fn().mockImplementation((input) => Promise.resolve(`${input} (hashed)`)),
+    hashSha256: vitest.fn().mockImplementation((input) => `${input} (hashed)`),
+    hashSha1: vitest.fn().mockImplementation((input) => Buffer.from(`${input.toString()} (hashed)`)),
+    hashFile: vitest.fn().mockImplementation((input) => `${input} (file-hashed)`),
+    newPassword: vitest.fn().mockReturnValue(Buffer.from('random-bytes').toString('base64')),
   };
 };

server/test/repositories/database.repository.mock.ts

@@ -1,21 +1,22 @@
 import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { Version } from 'src/utils/version';
+import { Mocked, vitest } from 'vitest';
 
-export const newDatabaseRepositoryMock = (): jest.Mocked<IDatabaseRepository> => {
+export const newDatabaseRepositoryMock = (): Mocked<IDatabaseRepository> => {
   return {
-    getExtensionVersion: jest.fn(),
-    getAvailableExtensionVersion: jest.fn(),
-    getPreferredVectorExtension: jest.fn(),
-    getPostgresVersion: jest.fn().mockResolvedValue(new Version(14, 0, 0)),
-    createExtension: jest.fn().mockImplementation(() => Promise.resolve()),
-    updateExtension: jest.fn(),
-    updateVectorExtension: jest.fn(),
-    reindex: jest.fn(),
-    shouldReindex: jest.fn(),
-    runMigrations: jest.fn(),
-    withLock: jest.fn().mockImplementation((_, function_: <R>() => Promise<R>) => function_()),
-    tryLock: jest.fn(),
-    isBusy: jest.fn(),
-    wait: jest.fn(),
+    getExtensionVersion: vitest.fn(),
+    getAvailableExtensionVersion: vitest.fn(),
+    getPreferredVectorExtension: vitest.fn(),
+    getPostgresVersion: vitest.fn().mockResolvedValue(new Version(14, 0, 0)),
+    createExtension: vitest.fn().mockImplementation(() => Promise.resolve()),
+    updateExtension: vitest.fn(),
+    updateVectorExtension: vitest.fn(),
+    reindex: vitest.fn(),
+    shouldReindex: vitest.fn(),
+    runMigrations: vitest.fn(),
+    withLock: vitest.fn().mockImplementation((_, function_: <R>() => Promise<R>) => function_()),
+    tryLock: vitest.fn(),
+    isBusy: vitest.fn(),
+    wait: vitest.fn(),
   };
 };

server/test/repositories/event.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IEventRepository } from 'src/interfaces/event.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newEventRepositoryMock = (): jest.Mocked<IEventRepository> => {
+export const newEventRepositoryMock = (): Mocked<IEventRepository> => {
   return {
-    clientSend: jest.fn(),
-    clientBroadcast: jest.fn(),
-    serverSend: jest.fn(),
-    serverSendAsync: jest.fn(),
+    clientSend: vitest.fn(),
+    clientBroadcast: vitest.fn(),
+    serverSend: vitest.fn(),
+    serverSendAsync: vitest.fn(),
   };
 };

server/test/repositories/job.repository.mock.ts

@@ -1,20 +1,21 @@
 import { IJobRepository } from 'src/interfaces/job.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newJobRepositoryMock = (): jest.Mocked<IJobRepository> => {
+export const newJobRepositoryMock = (): Mocked<IJobRepository> => {
   return {
-    addHandler: jest.fn(),
-    addCronJob: jest.fn(),
-    deleteCronJob: jest.fn(),
-    updateCronJob: jest.fn(),
-    setConcurrency: jest.fn(),
-    empty: jest.fn(),
-    pause: jest.fn(),
-    resume: jest.fn(),
-    queue: jest.fn().mockImplementation(() => Promise.resolve()),
-    queueAll: jest.fn().mockImplementation(() => Promise.resolve()),
-    getQueueStatus: jest.fn(),
-    getJobCounts: jest.fn(),
-    clear: jest.fn(),
-    waitForQueueCompletion: jest.fn(),
+    addHandler: vitest.fn(),
+    addCronJob: vitest.fn(),
+    deleteCronJob: vitest.fn(),
+    updateCronJob: vitest.fn(),
+    setConcurrency: vitest.fn(),
+    empty: vitest.fn(),
+    pause: vitest.fn(),
+    resume: vitest.fn(),
+    queue: vitest.fn().mockImplementation(() => Promise.resolve()),
+    queueAll: vitest.fn().mockImplementation(() => Promise.resolve()),
+    getQueueStatus: vitest.fn(),
+    getJobCounts: vitest.fn(),
+    clear: vitest.fn(),
+    waitForQueueCompletion: vitest.fn(),
   };
 };

server/test/repositories/library.repository.mock.ts

@@ -1,18 +1,19 @@
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newLibraryRepositoryMock = (): jest.Mocked<ILibraryRepository> => {
+export const newLibraryRepositoryMock = (): Mocked<ILibraryRepository> => {
   return {
-    get: jest.fn(),
-    getCountForUser: jest.fn(),
-    create: jest.fn(),
-    delete: jest.fn(),
-    softDelete: jest.fn(),
-    update: jest.fn(),
-    getStatistics: jest.fn(),
-    getDefaultUploadLibrary: jest.fn(),
-    getUploadLibraryCount: jest.fn(),
-    getAssetIds: jest.fn(),
-    getAllDeleted: jest.fn(),
-    getAll: jest.fn(),
+    get: vitest.fn(),
+    getCountForUser: vitest.fn(),
+    create: vitest.fn(),
+    delete: vitest.fn(),
+    softDelete: vitest.fn(),
+    update: vitest.fn(),
+    getStatistics: vitest.fn(),
+    getDefaultUploadLibrary: vitest.fn(),
+    getUploadLibraryCount: vitest.fn(),
+    getAssetIds: vitest.fn(),
+    getAllDeleted: vitest.fn(),
+    getAll: vitest.fn(),
   };
 };

server/test/repositories/logger.repository.mock.ts

@@ -1,15 +1,16 @@
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newLoggerRepositoryMock = (): jest.Mocked<ILoggerRepository> => {
+export const newLoggerRepositoryMock = (): Mocked<ILoggerRepository> => {
   return {
-    setLogLevel: jest.fn(),
-    setContext: jest.fn(),
+    setLogLevel: vitest.fn(),
+    setContext: vitest.fn(),
 
-    verbose: jest.fn(),
-    debug: jest.fn(),
-    log: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-    fatal: jest.fn(),
+    verbose: vitest.fn(),
+    debug: vitest.fn(),
+    log: vitest.fn(),
+    warn: vitest.fn(),
+    error: vitest.fn(),
+    fatal: vitest.fn(),
   };
 };

server/test/repositories/machine-learning.repository.mock.ts

@@ -1,9 +1,10 @@
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newMachineLearningRepositoryMock = (): jest.Mocked<IMachineLearningRepository> => {
+export const newMachineLearningRepositoryMock = (): Mocked<IMachineLearningRepository> => {
   return {
-    encodeImage: jest.fn(),
-    encodeText: jest.fn(),
-    detectFaces: jest.fn(),
+    encodeImage: vitest.fn(),
+    encodeText: vitest.fn(),
+    detectFaces: vitest.fn(),
   };
 };

server/test/repositories/media.repository.mock.ts

@@ -1,11 +1,12 @@
 import { IMediaRepository } from 'src/interfaces/media.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newMediaRepositoryMock = (): jest.Mocked<IMediaRepository> => {
+export const newMediaRepositoryMock = (): Mocked<IMediaRepository> => {
   return {
-    generateThumbhash: jest.fn(),
-    resize: jest.fn(),
-    crop: jest.fn(),
-    probe: jest.fn(),
-    transcode: jest.fn(),
+    generateThumbhash: vitest.fn(),
+    resize: vitest.fn(),
+    crop: vitest.fn(),
+    probe: vitest.fn(),
+    transcode: vitest.fn(),
   };
 };

server/test/repositories/memory.repository.mock.ts

@@ -1,14 +1,15 @@
 import { IMemoryRepository } from 'src/interfaces/memory.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newMemoryRepositoryMock = (): jest.Mocked<IMemoryRepository> => {
+export const newMemoryRepositoryMock = (): Mocked<IMemoryRepository> => {
   return {
-    search: jest.fn().mockResolvedValue([]),
-    get: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getAssetIds: jest.fn().mockResolvedValue(new Set()),
-    addAssetIds: jest.fn(),
-    removeAssetIds: jest.fn(),
+    search: vitest.fn().mockResolvedValue([]),
+    get: vitest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    delete: vitest.fn(),
+    getAssetIds: vitest.fn().mockResolvedValue(new Set()),
+    addAssetIds: vitest.fn(),
+    removeAssetIds: vitest.fn(),
   };
 };

server/test/repositories/metadata.repository.mock.ts

@@ -1,17 +1,18 @@
 import { IMetadataRepository } from 'src/interfaces/metadata.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newMetadataRepositoryMock = (): jest.Mocked<IMetadataRepository> => {
+export const newMetadataRepositoryMock = (): Mocked<IMetadataRepository> => {
   return {
-    init: jest.fn(),
-    teardown: jest.fn(),
-    reverseGeocode: jest.fn(),
-    readTags: jest.fn(),
-    writeTags: jest.fn(),
-    extractBinaryTag: jest.fn(),
-    getCameraMakes: jest.fn(),
-    getCameraModels: jest.fn(),
-    getCities: jest.fn(),
-    getCountries: jest.fn(),
-    getStates: jest.fn(),
+    init: vitest.fn(),
+    teardown: vitest.fn(),
+    reverseGeocode: vitest.fn(),
+    readTags: vitest.fn(),
+    writeTags: vitest.fn(),
+    extractBinaryTag: vitest.fn(),
+    getCameraMakes: vitest.fn(),
+    getCameraModels: vitest.fn(),
+    getCities: vitest.fn(),
+    getCountries: vitest.fn(),
+    getStates: vitest.fn(),
   };
 };

server/test/repositories/metric.repository.mock.ts

@@ -1,30 +1,31 @@
 import { IMetricRepository } from 'src/interfaces/metric.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newMetricRepositoryMock = (): jest.Mocked<IMetricRepository> => {
+export const newMetricRepositoryMock = (): Mocked<IMetricRepository> => {
   return {
     api: {
-      addToCounter: jest.fn(),
-      addToGauge: jest.fn(),
-      addToHistogram: jest.fn(),
-      configure: jest.fn(),
+      addToCounter: vitest.fn(),
+      addToGauge: vitest.fn(),
+      addToHistogram: vitest.fn(),
+      configure: vitest.fn(),
     },
     host: {
-      addToCounter: jest.fn(),
-      addToGauge: jest.fn(),
-      addToHistogram: jest.fn(),
-      configure: jest.fn(),
+      addToCounter: vitest.fn(),
+      addToGauge: vitest.fn(),
+      addToHistogram: vitest.fn(),
+      configure: vitest.fn(),
     },
     jobs: {
-      addToCounter: jest.fn(),
-      addToGauge: jest.fn(),
-      addToHistogram: jest.fn(),
-      configure: jest.fn(),
+      addToCounter: vitest.fn(),
+      addToGauge: vitest.fn(),
+      addToHistogram: vitest.fn(),
+      configure: vitest.fn(),
     },
     repo: {
-      addToCounter: jest.fn(),
-      addToGauge: jest.fn(),
-      addToHistogram: jest.fn(),
-      configure: jest.fn(),
+      addToCounter: vitest.fn(),
+      addToGauge: vitest.fn(),
+      addToHistogram: vitest.fn(),
+      configure: vitest.fn(),
     },
   };
 };

server/test/repositories/move.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IMoveRepository } from 'src/interfaces/move.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newMoveRepositoryMock = (): jest.Mocked<IMoveRepository> => {
+export const newMoveRepositoryMock = (): Mocked<IMoveRepository> => {
   return {
-    create: jest.fn(),
-    getByEntity: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
+    create: vitest.fn(),
+    getByEntity: vitest.fn(),
+    update: vitest.fn(),
+    delete: vitest.fn(),
   };
 };

server/test/repositories/partner.repository.mock.ts

@@ -1,11 +1,12 @@
 import { IPartnerRepository } from 'src/interfaces/partner.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newPartnerRepositoryMock = (): jest.Mocked<IPartnerRepository> => {
+export const newPartnerRepositoryMock = (): Mocked<IPartnerRepository> => {
   return {
-    create: jest.fn(),
-    remove: jest.fn(),
-    getAll: jest.fn(),
-    get: jest.fn(),
-    update: jest.fn(),
+    create: vitest.fn(),
+    remove: vitest.fn(),
+    getAll: vitest.fn(),
+    get: vitest.fn(),
+    update: vitest.fn(),
   };
 };

server/test/repositories/person.repository.mock.ts

@@ -1,32 +1,33 @@
 import { IPersonRepository } from 'src/interfaces/person.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newPersonRepositoryMock = (): jest.Mocked<IPersonRepository> => {
+export const newPersonRepositoryMock = (): Mocked<IPersonRepository> => {
   return {
-    getById: jest.fn(),
-    getAll: jest.fn(),
-    getAllForUser: jest.fn(),
-    getAssets: jest.fn(),
-    getAllWithoutFaces: jest.fn(),
+    getById: vitest.fn(),
+    getAll: vitest.fn(),
+    getAllForUser: vitest.fn(),
+    getAssets: vitest.fn(),
+    getAllWithoutFaces: vitest.fn(),
 
-    getByName: jest.fn(),
+    getByName: vitest.fn(),
 
-    create: jest.fn(),
-    update: jest.fn(),
-    deleteAll: jest.fn(),
-    delete: jest.fn(),
-    deleteAllFaces: jest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    deleteAll: vitest.fn(),
+    delete: vitest.fn(),
+    deleteAllFaces: vitest.fn(),
 
-    getStatistics: jest.fn(),
-    getAllFaces: jest.fn(),
-    getFacesByIds: jest.fn(),
-    getRandomFace: jest.fn(),
+    getStatistics: vitest.fn(),
+    getAllFaces: vitest.fn(),
+    getFacesByIds: vitest.fn(),
+    getRandomFace: vitest.fn(),
 
-    reassignFaces: jest.fn(),
-    createFaces: jest.fn(),
-    getFaces: jest.fn(),
-    reassignFace: jest.fn(),
-    getFaceById: jest.fn(),
-    getFaceByIdWithAssets: jest.fn(),
-    getNumberOfPeople: jest.fn(),
+    reassignFaces: vitest.fn(),
+    createFaces: vitest.fn(),
+    getFaces: vitest.fn(),
+    reassignFace: vitest.fn(),
+    getFaceById: vitest.fn(),
+    getFaceByIdWithAssets: vitest.fn(),
+    getNumberOfPeople: vitest.fn(),
   };
 };

server/test/repositories/search.repository.mock.ts

@@ -1,14 +1,15 @@
 import { ISearchRepository } from 'src/interfaces/search.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newSearchRepositoryMock = (): jest.Mocked<ISearchRepository> => {
+export const newSearchRepositoryMock = (): Mocked<ISearchRepository> => {
   return {
-    init: jest.fn(),
-    searchMetadata: jest.fn(),
-    searchSmart: jest.fn(),
-    searchFaces: jest.fn(),
-    upsert: jest.fn(),
-    searchPlaces: jest.fn(),
-    getAssetsByCity: jest.fn(),
-    deleteAllSearchEmbeddings: jest.fn(),
+    init: vitest.fn(),
+    searchMetadata: vitest.fn(),
+    searchSmart: vitest.fn(),
+    searchFaces: vitest.fn(),
+    upsert: vitest.fn(),
+    searchPlaces: vitest.fn(),
+    getAssetsByCity: vitest.fn(),
+    deleteAllSearchEmbeddings: vitest.fn(),
   };
 };

server/test/repositories/shared-link.repository.mock.ts

@@ -1,12 +1,13 @@
 import { ISharedLinkRepository } from 'src/interfaces/shared-link.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newSharedLinkRepositoryMock = (): jest.Mocked<ISharedLinkRepository> => {
+export const newSharedLinkRepositoryMock = (): Mocked<ISharedLinkRepository> => {
   return {
-    getAll: jest.fn(),
-    get: jest.fn(),
-    getByKey: jest.fn(),
-    create: jest.fn(),
-    remove: jest.fn(),
-    update: jest.fn(),
+    getAll: vitest.fn(),
+    get: vitest.fn(),
+    getByKey: vitest.fn(),
+    create: vitest.fn(),
+    remove: vitest.fn(),
+    update: vitest.fn(),
   };
 };

server/test/repositories/storage.repository.mock.ts

@@ -1,6 +1,7 @@
 import { WatchOptions } from 'chokidar';
 import { StorageCore } from 'src/cores/storage.core';
 import { IStorageRepository, WatchEvents } from 'src/interfaces/storage.interface';
+import { Mocked, vitest } from 'vitest';
 
 interface MockWatcherOptions {
   items?: Array<{ event: 'change' | 'add' | 'unlink' | 'error'; value: string }>;
@@ -38,29 +39,29 @@ export const makeMockWatcher =
     return () => Promise.resolve();
   };
 
-export const newStorageRepositoryMock = (reset = true): jest.Mocked<IStorageRepository> => {
+export const newStorageRepositoryMock = (reset = true): Mocked<IStorageRepository> => {
   if (reset) {
     StorageCore.reset();
   }
 
   return {
-    createZipStream: jest.fn(),
-    createReadStream: jest.fn(),
-    readFile: jest.fn(),
-    writeFile: jest.fn(),
-    unlink: jest.fn(),
-    unlinkDir: jest.fn().mockResolvedValue(true),
-    removeEmptyDirs: jest.fn(),
-    checkFileExists: jest.fn(),
-    mkdirSync: jest.fn(),
-    checkDiskUsage: jest.fn(),
-    readdir: jest.fn(),
-    stat: jest.fn(),
-    crawl: jest.fn(),
-    walk: jest.fn().mockImplementation(async function* () {}),
-    rename: jest.fn(),
-    copyFile: jest.fn(),
-    utimes: jest.fn(),
-    watch: jest.fn().mockImplementation(makeMockWatcher({})),
+    createZipStream: vitest.fn(),
+    createReadStream: vitest.fn(),
+    readFile: vitest.fn(),
+    writeFile: vitest.fn(),
+    unlink: vitest.fn(),
+    unlinkDir: vitest.fn().mockResolvedValue(true),
+    removeEmptyDirs: vitest.fn(),
+    checkFileExists: vitest.fn(),
+    mkdirSync: vitest.fn(),
+    checkDiskUsage: vitest.fn(),
+    readdir: vitest.fn(),
+    stat: vitest.fn(),
+    crawl: vitest.fn(),
+    walk: vitest.fn().mockImplementation(async function* () {}),
+    rename: vitest.fn(),
+    copyFile: vitest.fn(),
+    utimes: vitest.fn(),
+    watch: vitest.fn().mockImplementation(makeMockWatcher({})),
   };
 };

server/test/repositories/system-config.repository.mock.ts

@@ -1,16 +1,17 @@
 import { SystemConfigCore } from 'src/cores/system-config.core';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newSystemConfigRepositoryMock = (reset = true): jest.Mocked<ISystemConfigRepository> => {
+export const newSystemConfigRepositoryMock = (reset = true): Mocked<ISystemConfigRepository> => {
   if (reset) {
     SystemConfigCore.reset();
   }
 
   return {
-    fetchStyle: jest.fn(),
-    load: jest.fn().mockResolvedValue([]),
-    readFile: jest.fn(),
-    saveAll: jest.fn().mockResolvedValue([]),
-    deleteKeys: jest.fn(),
+    fetchStyle: vitest.fn(),
+    load: vitest.fn().mockResolvedValue([]),
+    readFile: vitest.fn(),
+    saveAll: vitest.fn().mockResolvedValue([]),
+    deleteKeys: vitest.fn(),
   };
 };

server/test/repositories/system-info.repository.mock.ts

@@ -1,7 +1,8 @@
 import { IServerInfoRepository } from 'src/interfaces/server-info.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newServerInfoRepositoryMock = (): jest.Mocked<IServerInfoRepository> => {
+export const newServerInfoRepositoryMock = (): Mocked<IServerInfoRepository> => {
   return {
-    getGitHubRelease: jest.fn(),
+    getGitHubRelease: vitest.fn(),
   };
 };

server/test/repositories/system-metadata.repository.mock.ts

@@ -1,8 +1,9 @@
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newSystemMetadataRepositoryMock = (): jest.Mocked<ISystemMetadataRepository> => {
+export const newSystemMetadataRepositoryMock = (): Mocked<ISystemMetadataRepository> => {
   return {
-    get: jest.fn(),
-    set: jest.fn(),
+    get: vitest.fn() as any,
+    set: vitest.fn(),
   };
 };

server/test/repositories/tag.repository.mock.ts

@@ -1,16 +1,17 @@
 import { ITagRepository } from 'src/interfaces/tag.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newTagRepositoryMock = (): jest.Mocked<ITagRepository> => {
+export const newTagRepositoryMock = (): Mocked<ITagRepository> => {
   return {
-    getAll: jest.fn(),
-    getById: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    remove: jest.fn(),
-    hasAsset: jest.fn(),
-    hasName: jest.fn(),
-    getAssets: jest.fn(),
-    addAssets: jest.fn(),
-    removeAssets: jest.fn(),
+    getAll: vitest.fn(),
+    getById: vitest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    remove: vitest.fn(),
+    hasAsset: vitest.fn(),
+    hasName: vitest.fn(),
+    getAssets: vitest.fn(),
+    addAssets: vitest.fn(),
+    removeAssets: vitest.fn(),
   };
 };

server/test/repositories/user-token.repository.mock.ts

@@ -1,11 +1,12 @@
 import { IUserTokenRepository } from 'src/interfaces/user-token.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newUserTokenRepositoryMock = (): jest.Mocked<IUserTokenRepository> => {
+export const newUserTokenRepositoryMock = (): Mocked<IUserTokenRepository> => {
   return {
-    create: jest.fn(),
-    save: jest.fn(),
-    delete: jest.fn(),
-    getByToken: jest.fn(),
-    getAll: jest.fn(),
+    create: vitest.fn(),
+    save: vitest.fn(),
+    delete: vitest.fn(),
+    getByToken: vitest.fn(),
+    getAll: vitest.fn(),
   };
 };

server/test/repositories/user.repository.mock.ts

@@ -1,25 +1,26 @@
 import { UserCore } from 'src/cores/user.core';
 import { IUserRepository } from 'src/interfaces/user.interface';
+import { Mocked, vitest } from 'vitest';
 
-export const newUserRepositoryMock = (reset = true): jest.Mocked<IUserRepository> => {
+export const newUserRepositoryMock = (reset = true): Mocked<IUserRepository> => {
   if (reset) {
     UserCore.reset();
   }
 
   return {
-    get: jest.fn(),
-    getAdmin: jest.fn(),
-    getByEmail: jest.fn(),
-    getByStorageLabel: jest.fn(),
-    getByOAuthId: jest.fn(),
-    getUserStats: jest.fn(),
-    getList: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getDeletedUsers: jest.fn(),
-    hasAdmin: jest.fn(),
-    updateUsage: jest.fn(),
-    syncUsage: jest.fn(),
+    get: vitest.fn(),
+    getAdmin: vitest.fn(),
+    getByEmail: vitest.fn(),
+    getByStorageLabel: vitest.fn(),
+    getByOAuthId: vitest.fn(),
+    getUserStats: vitest.fn(),
+    getList: vitest.fn(),
+    create: vitest.fn(),
+    update: vitest.fn(),
+    delete: vitest.fn(),
+    getDeletedUsers: vitest.fn(),
+    hasAdmin: vitest.fn(),
+    updateUsage: vitest.fn(),
+    syncUsage: vitest.fn(),
   };
 };