refactor: test mocks (#16008)

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(),