refactor: test mocks (#16008)

server/test/medium/metadata.service.spec.ts

@@ -3,15 +3,11 @@ import { writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { AssetEntity } from 'src/entities/asset.entity';
-import { IAssetRepository } from 'src/interfaces/asset.interface';
-import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { MetadataRepository } from 'src/repositories/metadata.repository';
 import { MetadataService } from 'src/services/metadata.service';
-import { ILoggingRepository } from 'src/types';
-import { newLoggingRepositoryMock } from 'test/repositories/logger.repository.mock';
-import { newRandomImage, newTestService } from 'test/utils';
-import { Mocked } from 'vitest';
+import { ILoggingRepository, newLoggingRepositoryMock } from 'test/repositories/logger.repository.mock';
+import { newRandomImage, newTestService, ServiceMocks } from 'test/utils';
 
 const metadataRepository = new MetadataRepository(
   newLoggingRepositoryMock() as ILoggingRepository as LoggingRepository,
@@ -38,14 +34,12 @@ type TimeZoneTest = {
 
 describe(MetadataService.name, () => {
   let sut: MetadataService;
-
-  let assetMock: Mocked<IAssetRepository>;
-  let storageMock: Mocked<IStorageRepository>;
+  let mocks: ServiceMocks;
 
   beforeEach(() => {
-    ({ sut, assetMock, storageMock } = newTestService(MetadataService, { metadataRepository }));
+    ({ sut, mocks } = newTestService(MetadataService, { metadataRepository }));
 
-    storageMock.stat.mockResolvedValue({ size: 123_456 } as Stats);
+    mocks.storage.stat.mockResolvedValue({ size: 123_456 } as Stats);
 
     delete process.env.TZ;
   });
@@ -120,18 +114,18 @@ describe(MetadataService.name, () => {
       process.env.TZ = serverTimeZone ?? undefined;
 
       const { filePath } = await createTestFile(exifData);
-      assetMock.getByIds.mockResolvedValue([{ id: 'asset-1', originalPath: filePath } as AssetEntity]);
+      mocks.asset.getByIds.mockResolvedValue([{ id: 'asset-1', originalPath: filePath } as AssetEntity]);
 
       await sut.handleMetadataExtraction({ id: 'asset-1' });
 
-      expect(assetMock.upsertExif).toHaveBeenCalledWith(
+      expect(mocks.asset.upsertExif).toHaveBeenCalledWith(
         expect.objectContaining({
           dateTimeOriginal: new Date(expected.dateTimeOriginal),
           timeZone: expected.timeZone,
         }),
       );
 
-      expect(assetMock.update).toHaveBeenCalledWith(
+      expect(mocks.asset.update).toHaveBeenCalledWith(
         expect.objectContaining({
           localDateTime: new Date(expected.localDateTime),
         }),

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

@@ -1,7 +1,12 @@
-import { IAccessRepository } from 'src/types';
+import { AccessRepository } from 'src/repositories/access.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export type IAccessRepositoryMock = { [K in keyof IAccessRepository]: Mocked<IAccessRepository[K]> };
+type IAccessRepository = { [K in keyof AccessRepository]: RepositoryInterface<AccessRepository[K]> };
+
+export type IAccessRepositoryMock = {
+  [K in keyof IAccessRepository]: Mocked<IAccessRepository[K]>;
+};
 
 export const newAccessRepositoryMock = (): IAccessRepositoryMock => {
   return {

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

@@ -1,7 +1,8 @@
-import { IActivityRepository } from 'src/types';
+import { ActivityRepository } from 'src/repositories/activity.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newActivityRepositoryMock = (): Mocked<IActivityRepository> => {
+export const newActivityRepositoryMock = (): Mocked<RepositoryInterface<ActivityRepository>> => {
   return {
     search: vitest.fn(),
     create: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IAlbumUserRepository } from 'src/types';
+import { AlbumUserRepository } from 'src/repositories/album-user.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked } from 'vitest';
 
-export const newAlbumUserRepositoryMock = (): Mocked<IAlbumUserRepository> => {
+export const newAlbumUserRepositoryMock = (): Mocked<RepositoryInterface<AlbumUserRepository>> => {
   return {
     create: vitest.fn(),
     delete: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IApiKeyRepository } from 'src/types';
+import { ApiKeyRepository } from 'src/repositories/api-key.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newKeyRepositoryMock = (): Mocked<IApiKeyRepository> => {
+export const newKeyRepositoryMock = (): Mocked<RepositoryInterface<ApiKeyRepository>> => {
   return {
     create: vitest.fn(),
     update: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IAuditRepository } from 'src/types';
+import { AuditRepository } from 'src/repositories/audit.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newAuditRepositoryMock = (): Mocked<IAuditRepository> => {
+export const newAuditRepositoryMock = (): Mocked<RepositoryInterface<AuditRepository>> => {
   return {
     getAfter: vitest.fn(),
     removeBefore: vitest.fn(),

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

@@ -1,7 +1,7 @@
 import { ImmichEnvironment, ImmichWorker } from 'src/enum';
 import { DatabaseExtension } from 'src/interfaces/database.interface';
-import { EnvData } from 'src/repositories/config.repository';
-import { IConfigRepository } from 'src/types';
+import { ConfigRepository, EnvData } from 'src/repositories/config.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
 const envData: EnvData = {
@@ -97,7 +97,7 @@ const envData: EnvData = {
 };
 
 export const mockEnvData = (config: Partial<EnvData>) => ({ ...envData, ...config });
-export const newConfigRepositoryMock = (): Mocked<IConfigRepository> => {
+export const newConfigRepositoryMock = (): Mocked<RepositoryInterface<ConfigRepository>> => {
   return {
     getEnv: vitest.fn().mockReturnValue(mockEnvData({})),
     getWorker: vitest.fn().mockReturnValue(ImmichWorker.API),

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

@@ -1,7 +1,8 @@
-import { ICronRepository } from 'src/types';
+import { CronRepository } from 'src/repositories/cron.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newCronRepositoryMock = (): Mocked<ICronRepository> => {
+export const newCronRepositoryMock = (): Mocked<RepositoryInterface<CronRepository>> => {
   return {
     create: vitest.fn(),
     update: vitest.fn(),

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

@@ -1,6 +1,20 @@
-import { ILoggingRepository } from 'src/types';
+import { LoggingRepository } from 'src/repositories/logging.repository';
 import { Mocked, vitest } from 'vitest';
 
+export type ILoggingRepository = Pick<
+  LoggingRepository,
+  | 'verbose'
+  | 'log'
+  | 'debug'
+  | 'warn'
+  | 'error'
+  | 'fatal'
+  | 'isLevelEnabled'
+  | 'setLogLevel'
+  | 'setContext'
+  | 'setAppName'
+>;
+
 export const newLoggingRepositoryMock = (): Mocked<ILoggingRepository> => {
   return {
     setLogLevel: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IMapRepository } from 'src/types';
+import { MapRepository } from 'src/repositories/map.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked } from 'vitest';
 
-export const newMapRepositoryMock = (): Mocked<IMapRepository> => {
+export const newMapRepositoryMock = (): Mocked<RepositoryInterface<MapRepository>> => {
   return {
     init: vitest.fn(),
     reverseGeocode: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IMediaRepository } from 'src/types';
+import { MediaRepository } from 'src/repositories/media.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newMediaRepositoryMock = (): Mocked<IMediaRepository> => {
+export const newMediaRepositoryMock = (): Mocked<RepositoryInterface<MediaRepository>> => {
   return {
     generateThumbnail: vitest.fn().mockImplementation(() => Promise.resolve()),
     generateThumbhash: vitest.fn().mockResolvedValue(Buffer.from('')),

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

@@ -1,7 +1,8 @@
-import { IMemoryRepository } from 'src/types';
+import { MemoryRepository } from 'src/repositories/memory.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newMemoryRepositoryMock = (): Mocked<IMemoryRepository> => {
+export const newMemoryRepositoryMock = (): Mocked<RepositoryInterface<MemoryRepository>> => {
   return {
     search: vitest.fn().mockResolvedValue([]),
     get: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IMetadataRepository } from 'src/types';
+import { MetadataRepository } from 'src/repositories/metadata.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newMetadataRepositoryMock = (): Mocked<IMetadataRepository> => {
+export const newMetadataRepositoryMock = (): Mocked<RepositoryInterface<MetadataRepository>> => {
   return {
     teardown: vitest.fn(),
     readTags: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { INotificationRepository } from 'src/types';
+import { NotificationRepository } from 'src/repositories/notification.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked } from 'vitest';
 
-export const newNotificationRepositoryMock = (): Mocked<INotificationRepository> => {
+export const newNotificationRepositoryMock = (): Mocked<RepositoryInterface<NotificationRepository>> => {
   return {
     renderEmail: vitest.fn(),
     sendEmail: vitest.fn().mockResolvedValue({ messageId: 'message-1' }),

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

@@ -1,7 +1,8 @@
-import { IOAuthRepository } from 'src/types';
+import { OAuthRepository } from 'src/repositories/oauth.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked } from 'vitest';
 
-export const newOAuthRepositoryMock = (): Mocked<IOAuthRepository> => {
+export const newOAuthRepositoryMock = (): Mocked<RepositoryInterface<OAuthRepository>> => {
   return {
     init: vitest.fn(),
     authorize: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IProcessRepository } from 'src/types';
+import { ProcessRepository } from 'src/repositories/process.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newProcessRepositoryMock = (): Mocked<IProcessRepository> => {
+export const newProcessRepositoryMock = (): Mocked<RepositoryInterface<ProcessRepository>> => {
   return {
     spawn: vitest.fn(),
   };

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

@@ -1,7 +1,8 @@
-import { IServerInfoRepository } from 'src/types';
+import { ServerInfoRepository } from 'src/repositories/server-info.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newServerInfoRepositoryMock = (): Mocked<IServerInfoRepository> => {
+export const newServerInfoRepositoryMock = (): Mocked<RepositoryInterface<ServerInfoRepository>> => {
   return {
     getGitHubRelease: vitest.fn(),
     getBuildVersions: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { ISessionRepository } from 'src/types';
+import { SessionRepository } from 'src/repositories/session.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newSessionRepositoryMock = (): Mocked<ISessionRepository> => {
+export const newSessionRepositoryMock = (): Mocked<RepositoryInterface<SessionRepository>> => {
   return {
     search: vitest.fn(),
     create: vitest.fn() as any,

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

@@ -1,8 +1,9 @@
-import { ISystemMetadataRepository } from 'src/types';
+import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
+import { RepositoryInterface } from 'src/types';
 import { clearConfigCache } from 'src/utils/config';
 import { Mocked, vitest } from 'vitest';
 
-export const newSystemMetadataRepositoryMock = (): Mocked<ISystemMetadataRepository> => {
+export const newSystemMetadataRepositoryMock = (): Mocked<RepositoryInterface<SystemMetadataRepository>> => {
   clearConfigCache();
   return {
     get: vitest.fn() as any,

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

@@ -1,4 +1,5 @@
-import { ITelemetryRepository, RepositoryInterface } from 'src/types';
+import { TelemetryRepository } from 'src/repositories/telemetry.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
 const newMetricGroupMock = () => {
@@ -10,6 +11,8 @@ const newMetricGroupMock = () => {
   };
 };
 
+type ITelemetryRepository = RepositoryInterface<TelemetryRepository>;
+
 export type ITelemetryRepositoryMock = {
   [K in keyof ITelemetryRepository]: Mocked<RepositoryInterface<ITelemetryRepository[K]>>;
 };

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

@@ -1,7 +1,8 @@
-import { ITrashRepository } from 'src/types';
+import { TrashRepository } from 'src/repositories/trash.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newTrashRepositoryMock = (): Mocked<ITrashRepository> => {
+export const newTrashRepositoryMock = (): Mocked<RepositoryInterface<TrashRepository>> => {
   return {
     empty: vitest.fn(),
     restore: vitest.fn(),

server/test/repositories/version-history.repository.mock.ts

@@ -1,7 +1,8 @@
-import { IVersionHistoryRepository } from 'src/types';
+import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newVersionHistoryRepositoryMock = (): Mocked<IVersionHistoryRepository> => {
+export const newVersionHistoryRepositoryMock = (): Mocked<RepositoryInterface<VersionHistoryRepository>> => {
   return {
     getAll: vitest.fn().mockResolvedValue([]),
     getLatest: vitest.fn(),

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

@@ -1,7 +1,8 @@
-import { IViewRepository } from 'src/types';
+import { ViewRepository } from 'src/repositories/view-repository';
+import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
 
-export const newViewRepositoryMock = (): Mocked<IViewRepository> => {
+export const newViewRepositoryMock = (): Mocked<RepositoryInterface<ViewRepository>> => {
   return {
     getAssetsByOriginalPath: vitest.fn(),
     getUniqueOriginalPaths: vitest.fn(),

server/test/utils.ts

@@ -2,51 +2,49 @@ import { ChildProcessWithoutNullStreams } from 'node:child_process';
 import { Writable } from 'node:stream';
 import { PNG } from 'pngjs';
 import { ImmichWorker } from 'src/enum';
+import { IAlbumRepository } from 'src/interfaces/album.interface';
+import { IAssetRepository } from 'src/interfaces/asset.interface';
+import { ICryptoRepository } from 'src/interfaces/crypto.interface';
+import { IEventRepository } from 'src/interfaces/event.interface';
+import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
+import { IUserRepository } from 'src/interfaces/user.interface';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
 import { ApiKeyRepository } from 'src/repositories/api-key.repository';
 import { AuditRepository } from 'src/repositories/audit.repository';
+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 { JobRepository } from 'src/repositories/job.repository';
+import { LibraryRepository } from 'src/repositories/library.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { MapRepository } from 'src/repositories/map.repository';
 import { MediaRepository } from 'src/repositories/media.repository';
 import { MemoryRepository } from 'src/repositories/memory.repository';
 import { MetadataRepository } from 'src/repositories/metadata.repository';
+import { MoveRepository } from 'src/repositories/move.repository';
 import { NotificationRepository } from 'src/repositories/notification.repository';
 import { OAuthRepository } from 'src/repositories/oauth.repository';
+import { PartnerRepository } from 'src/repositories/partner.repository';
+import { PersonRepository } from 'src/repositories/person.repository';
 import { ProcessRepository } from 'src/repositories/process.repository';
+import { SearchRepository } from 'src/repositories/search.repository';
 import { ServerInfoRepository } from 'src/repositories/server-info.repository';
 import { SessionRepository } from 'src/repositories/session.repository';
+import { SharedLinkRepository } from 'src/repositories/shared-link.repository';
+import { StackRepository } from 'src/repositories/stack.repository';
+import { StorageRepository } from 'src/repositories/storage.repository';
 import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
+import { TagRepository } from 'src/repositories/tag.repository';
 import { TelemetryRepository } from 'src/repositories/telemetry.repository';
 import { TrashRepository } from 'src/repositories/trash.repository';
 import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
 import { ViewRepository } from 'src/repositories/view-repository';
 import { BaseService } from 'src/services/base.service';
-import {
-  IAccessRepository,
-  IActivityRepository,
-  IAlbumUserRepository,
-  IApiKeyRepository,
-  IAuditRepository,
-  ICronRepository,
-  ILoggingRepository,
-  IMapRepository,
-  IMediaRepository,
-  IMemoryRepository,
-  IMetadataRepository,
-  INotificationRepository,
-  IOAuthRepository,
-  IProcessRepository,
-  IServerInfoRepository,
-  ISessionRepository,
-  ISystemMetadataRepository,
-  ITrashRepository,
-  IVersionHistoryRepository,
-  IViewRepository,
-} from 'src/types';
-import { newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
+import { RepositoryInterface } from 'src/types';
+import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
 import { newActivityRepositoryMock } from 'test/repositories/activity.repository.mock';
 import { newAlbumUserRepositoryMock } from 'test/repositories/album-user.repository.mock';
 import { newAlbumRepositoryMock } from 'test/repositories/album.repository.mock';
@@ -60,7 +58,7 @@ import { newDatabaseRepositoryMock } from 'test/repositories/database.repository
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
 import { newLibraryRepositoryMock } from 'test/repositories/library.repository.mock';
-import { newLoggingRepositoryMock } from 'test/repositories/logger.repository.mock';
+import { ILoggingRepository, newLoggingRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMachineLearningRepositoryMock } from 'test/repositories/machine-learning.repository.mock';
 import { newMapRepositoryMock } from 'test/repositories/map.repository.mock';
 import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock';
@@ -80,7 +78,7 @@ import { newStackRepositoryMock } from 'test/repositories/stack.repository.mock'
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemMetadataRepositoryMock } from 'test/repositories/system-metadata.repository.mock';
 import { newTagRepositoryMock } from 'test/repositories/tag.repository.mock';
-import { newTelemetryRepositoryMock } from 'test/repositories/telemetry.repository.mock';
+import { ITelemetryRepositoryMock, newTelemetryRepositoryMock } from 'test/repositories/telemetry.repository.mock';
 import { newTrashRepositoryMock } from 'test/repositories/trash.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
 import { newVersionHistoryRepositoryMock } from 'test/repositories/version-history.repository.mock';
@@ -97,6 +95,50 @@ type Constructor<Type, Args extends Array<any>> = {
   new (...deps: Args): Type;
 };
 
+type IAccessRepository = { [K in keyof AccessRepository]: RepositoryInterface<AccessRepository[K]> };
+
+export type ServiceMocks = {
+  access: IAccessRepositoryMock;
+  activity: Mocked<RepositoryInterface<ActivityRepository>>;
+  album: Mocked<IAlbumRepository>;
+  albumUser: Mocked<RepositoryInterface<AlbumUserRepository>>;
+  apiKey: Mocked<RepositoryInterface<ApiKeyRepository>>;
+  audit: Mocked<RepositoryInterface<AuditRepository>>;
+  asset: Mocked<IAssetRepository>;
+  config: Mocked<RepositoryInterface<ConfigRepository>>;
+  cron: Mocked<RepositoryInterface<CronRepository>>;
+  crypto: Mocked<ICryptoRepository>;
+  database: Mocked<RepositoryInterface<DatabaseRepository>>;
+  event: Mocked<IEventRepository>;
+  job: Mocked<RepositoryInterface<JobRepository>>;
+  library: Mocked<RepositoryInterface<LibraryRepository>>;
+  logger: Mocked<ILoggingRepository>;
+  machineLearning: Mocked<IMachineLearningRepository>;
+  map: Mocked<RepositoryInterface<MapRepository>>;
+  media: Mocked<RepositoryInterface<MediaRepository>>;
+  memory: Mocked<RepositoryInterface<MemoryRepository>>;
+  metadata: Mocked<RepositoryInterface<MetadataRepository>>;
+  move: Mocked<RepositoryInterface<MoveRepository>>;
+  notification: Mocked<RepositoryInterface<NotificationRepository>>;
+  oauth: Mocked<RepositoryInterface<OAuthRepository>>;
+  partner: Mocked<RepositoryInterface<PartnerRepository>>;
+  person: Mocked<RepositoryInterface<PersonRepository>>;
+  process: Mocked<RepositoryInterface<ProcessRepository>>;
+  search: Mocked<RepositoryInterface<SearchRepository>>;
+  serverInfo: Mocked<RepositoryInterface<ServerInfoRepository>>;
+  session: Mocked<RepositoryInterface<SessionRepository>>;
+  sharedLink: Mocked<RepositoryInterface<SharedLinkRepository>>;
+  stack: Mocked<RepositoryInterface<StackRepository>>;
+  storage: Mocked<RepositoryInterface<StorageRepository>>;
+  systemMetadata: Mocked<RepositoryInterface<SystemMetadataRepository>>;
+  tag: Mocked<RepositoryInterface<TagRepository>>;
+  telemetry: ITelemetryRepositoryMock;
+  trash: Mocked<RepositoryInterface<TrashRepository>>;
+  user: Mocked<IUserRepository>;
+  versionHistory: Mocked<RepositoryInterface<VersionHistoryRepository>>;
+  view: Mocked<RepositoryInterface<ViewRepository>>;
+};
+
 export const newTestService = <T extends BaseService>(
   Service: Constructor<T, BaseServiceArgs>,
   overrides?: Overrides,
@@ -116,13 +158,15 @@ export const newTestService = <T extends BaseService>(
   const databaseMock = newDatabaseRepositoryMock();
   const eventMock = newEventRepositoryMock();
   const jobMock = newJobRepositoryMock();
-  const keyMock = newKeyRepositoryMock();
+  const apiKeyMock = newKeyRepositoryMock();
   const libraryMock = newLibraryRepositoryMock();
   const machineLearningMock = newMachineLearningRepositoryMock();
   const mapMock = newMapRepositoryMock();
   const mediaMock = newMediaRepositoryMock();
   const memoryMock = newMemoryRepositoryMock();
-  const metadataMock = (metadataRepository || newMetadataRepositoryMock()) as Mocked<IMetadataRepository>;
+  const metadataMock = (metadataRepository || newMetadataRepositoryMock()) as Mocked<
+    RepositoryInterface<MetadataRepository>
+  >;
   const moveMock = newMoveRepositoryMock();
   const notificationMock = newNotificationRepositoryMock();
   const oauthMock = newOAuthRepositoryMock();
@@ -146,86 +190,88 @@ export const newTestService = <T extends BaseService>(
   const sut = new Service(
     loggerMock as ILoggingRepository as LoggingRepository,
     accessMock as IAccessRepository as AccessRepository,
-    activityMock as IActivityRepository as ActivityRepository,
-    auditMock as IAuditRepository as AuditRepository,
+    activityMock as RepositoryInterface<ActivityRepository> as ActivityRepository,
+    auditMock as RepositoryInterface<AuditRepository> as AuditRepository,
     albumMock,
-    albumUserMock as IAlbumUserRepository as AlbumUserRepository,
+    albumUserMock as RepositoryInterface<AlbumUserRepository> as AlbumUserRepository,
     assetMock,
     configMock,
-    cronMock as ICronRepository as CronRepository,
-    cryptoMock,
+    cronMock as RepositoryInterface<CronRepository> as CronRepository,
+    cryptoMock as RepositoryInterface<CryptoRepository> as CryptoRepository,
     databaseMock,
     eventMock,
     jobMock,
-    keyMock as IApiKeyRepository as ApiKeyRepository,
+    apiKeyMock as RepositoryInterface<ApiKeyRepository> as ApiKeyRepository,
     libraryMock,
     machineLearningMock,
-    mapMock as IMapRepository as MapRepository,
-    mediaMock as IMediaRepository as MediaRepository,
-    memoryMock as IMemoryRepository as MemoryRepository,
-    metadataMock as IMetadataRepository as MetadataRepository,
+    mapMock as RepositoryInterface<MapRepository> as MapRepository,
+    mediaMock as RepositoryInterface<MediaRepository> as MediaRepository,
+    memoryMock as RepositoryInterface<MemoryRepository> as MemoryRepository,
+    metadataMock as RepositoryInterface<MetadataRepository> as MetadataRepository,
     moveMock,
-    notificationMock as INotificationRepository as NotificationRepository,
-    oauthMock as IOAuthRepository as OAuthRepository,
+    notificationMock as RepositoryInterface<NotificationRepository> as NotificationRepository,
+    oauthMock as RepositoryInterface<OAuthRepository> as OAuthRepository,
     partnerMock,
     personMock,
-    processMock as IProcessRepository as ProcessRepository,
+    processMock as RepositoryInterface<ProcessRepository> as ProcessRepository,
     searchMock,
-    serverInfoMock as IServerInfoRepository as ServerInfoRepository,
-    sessionMock as ISessionRepository as SessionRepository,
+    serverInfoMock as RepositoryInterface<ServerInfoRepository> as ServerInfoRepository,
+    sessionMock as RepositoryInterface<SessionRepository> as SessionRepository,
     sharedLinkMock,
     stackMock,
     storageMock,
-    systemMock as ISystemMetadataRepository as SystemMetadataRepository,
+    systemMock as RepositoryInterface<SystemMetadataRepository> as SystemMetadataRepository,
     tagMock,
     telemetryMock as unknown as TelemetryRepository,
-    trashMock as ITrashRepository as TrashRepository,
+    trashMock as RepositoryInterface<TrashRepository> as TrashRepository,
     userMock,
-    versionHistoryMock as IVersionHistoryRepository as VersionHistoryRepository,
-    viewMock as IViewRepository as ViewRepository,
+    versionHistoryMock as RepositoryInterface<VersionHistoryRepository> as VersionHistoryRepository,
+    viewMock as RepositoryInterface<ViewRepository> as ViewRepository,
   );
 
   return {
     sut,
-    accessMock,
-    loggerMock,
-    cronMock,
-    cryptoMock,
-    activityMock,
-    auditMock,
-    albumMock,
-    albumUserMock,
-    assetMock,
-    configMock,
-    databaseMock,
-    eventMock,
-    jobMock,
-    keyMock,
-    libraryMock,
-    machineLearningMock,
-    mapMock,
-    mediaMock,
-    memoryMock,
-    metadataMock,
-    moveMock,
-    notificationMock,
-    oauthMock,
-    partnerMock,
-    personMock,
-    processMock,
-    searchMock,
-    serverInfoMock,
-    sessionMock,
-    sharedLinkMock,
-    stackMock,
-    storageMock,
-    systemMock,
-    tagMock,
-    telemetryMock,
-    trashMock,
-    userMock,
-    versionHistoryMock,
-    viewMock,
+    mocks: {
+      access: accessMock,
+      apiKey: apiKeyMock,
+      cron: cronMock,
+      crypto: cryptoMock,
+      activity: activityMock,
+      audit: auditMock,
+      album: albumMock,
+      albumUser: albumUserMock,
+      asset: assetMock,
+      config: configMock,
+      database: databaseMock,
+      event: eventMock,
+      job: jobMock,
+      library: libraryMock,
+      logger: loggerMock,
+      machineLearning: machineLearningMock,
+      map: mapMock,
+      media: mediaMock,
+      memory: memoryMock,
+      metadata: metadataMock,
+      move: moveMock,
+      notification: notificationMock,
+      oauth: oauthMock,
+      partner: partnerMock,
+      person: personMock,
+      process: processMock,
+      search: searchMock,
+      serverInfo: serverInfoMock,
+      session: sessionMock,
+      sharedLink: sharedLinkMock,
+      stack: stackMock,
+      storage: storageMock,
+      systemMetadata: systemMock,
+      tag: tagMock,
+      telemetry: telemetryMock,
+      trash: trashMock,
+      user: userMock,
+      versionHistory: versionHistoryMock,
+      view: viewMock,
+    } as ServiceMocks,
   };
 };