Skip to content

High performance self-hosted photo and video management solution.

25.9 KB
Raw Blame
/* eslint-disable unicorn/no-this-outside-of-class */
import { DatabaseConnectionParams, createPostgres } from '@immich/sql-tools';
import { CallHandler, ExecutionContext, Provider } from '@nestjs/common';
import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
import { transformException } from '@nestjs/platform-express/multer/multer/multer.utils';
import { Test } from '@nestjs/testing';
import { NextFunction } from 'express';
import { Kysely } from 'kysely';
import multer, { memoryStorage } from 'multer';
import { ClsService } from 'nestjs-cls';
import { ZodSerializerInterceptor, ZodValidationPipe } from 'nestjs-zod';
import { ChildProcessWithoutNullStreams } from 'node:child_process';
import { Duplex, Readable, Writable } from 'node:stream';
import { PNG } from 'pngjs';
import { Mock, Mocked, assert, vitest } from 'vitest';
import type { RepositoryInterface } from 'src/types.js';
import { UploadFieldName } from 'src/dtos/asset-media.dto.js';
import { AssetUploadInterceptor } from 'src/middleware/asset-upload.interceptor.js';
import { AuthGuard } from 'src/middleware/auth.guard.js';
import { FileUploadInterceptor } from 'src/middleware/file-upload.interceptor.js';
import { GlobalExceptionFilter } from 'src/middleware/global-exception.filter.js';
import { AccessRepository } from 'src/repositories/access.repository.js';
import { ActivityRepository } from 'src/repositories/activity.repository.js';
import { AlbumUserRepository } from 'src/repositories/album-user.repository.js';
import { AlbumRepository } from 'src/repositories/album.repository.js';
import { ApiKeyRepository } from 'src/repositories/api-key.repository.js';
import { AppRepository } from 'src/repositories/app.repository.js';
import { AssetEditRepository } from 'src/repositories/asset-edit.repository.js';
import { AssetFileRepository } from 'src/repositories/asset-file.repository.js';
import { AssetJobRepository } from 'src/repositories/asset-job.repository.js';
import { AssetRepository } from 'src/repositories/asset.repository.js';
import { AuthChallengeRepository } from 'src/repositories/auth-challenge.repository.js';
import { ClusterGroupRepository } from 'src/repositories/cluster-group.repository.js';
import { ConfigRepository } from 'src/repositories/config.repository.js';
import { CronRepository } from 'src/repositories/cron.repository.js';
import { CryptoRepository } from 'src/repositories/crypto.repository.js';
import { DatabaseRepository } from 'src/repositories/database.repository.js';
import { DownloadRepository } from 'src/repositories/download.repository.js';
import { DuplicateRepository } from 'src/repositories/duplicate.repository.js';
import { EmailRepository } from 'src/repositories/email.repository.js';
import { EventRepository } from 'src/repositories/event.repository.js';
import { IntegrityRepository } from 'src/repositories/integrity.repository.js';
import { JobRepository } from 'src/repositories/job.repository.js';
import { LibraryRepository } from 'src/repositories/library.repository.js';
import { LoggingRepository } from 'src/repositories/logging.repository.js';
import { MachineLearningRepository } from 'src/repositories/machine-learning.repository.js';
import { MapRepository } from 'src/repositories/map.repository.js';
import { MediaRepository } from 'src/repositories/media.repository.js';
import { MemoryRepository } from 'src/repositories/memory.repository.js';
import { MetadataRepository } from 'src/repositories/metadata.repository.js';
import { MoveRepository } from 'src/repositories/move.repository.js';
import { NotificationRepository } from 'src/repositories/notification.repository.js';
import { OAuthRepository } from 'src/repositories/oauth.repository.js';
import { OcrRepository } from 'src/repositories/ocr.repository.js';
import { PartnerRepository } from 'src/repositories/partner.repository.js';
import { PasskeyRepository } from 'src/repositories/passkey.repository.js';
import { PersonUserRepository } from 'src/repositories/person-user.repository.js';
import { PersonRepository } from 'src/repositories/person.repository.js';
import { PluginRepository } from 'src/repositories/plugin.repository.js';
import { ProcessRepository } from 'src/repositories/process.repository.js';
import { SearchRepository } from 'src/repositories/search.repository.js';
import { ServerInfoRepository } from 'src/repositories/server-info.repository.js';
import { SessionRepository } from 'src/repositories/session.repository.js';
import { SharedLinkAssetRepository } from 'src/repositories/shared-link-asset.repository.js';
import { SharedLinkRepository } from 'src/repositories/shared-link.repository.js';
import { StackRepository } from 'src/repositories/stack.repository.js';
import { StorageRepository } from 'src/repositories/storage.repository.js';
import { SyncCheckpointRepository } from 'src/repositories/sync-checkpoint.repository.js';
import { SyncRepository } from 'src/repositories/sync.repository.js';
import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository.js';
import { TagRepository } from 'src/repositories/tag.repository.js';
import { TelemetryRepository } from 'src/repositories/telemetry.repository.js';
import { TrashRepository } from 'src/repositories/trash.repository.js';
import { UserRepository } from 'src/repositories/user.repository.js';
import { VersionHistoryRepository } from 'src/repositories/version-history.repository.js';
import { VideoStreamRepository } from 'src/repositories/video-stream.repository.js';
import { ViewRepository } from 'src/repositories/view-repository.js';
import { WebAuthnRepository } from 'src/repositories/webauthn.repository.js';
import { WebsocketRepository } from 'src/repositories/websocket.repository.js';
import { WorkflowRepository } from 'src/repositories/workflow.repository.js';
import { DB } from 'src/schema/index.js';
import { AuthService } from 'src/services/auth.service.js';
import { BaseService } from 'src/services/base.service.js';
import { getKyselyConfig } from 'src/utils/database.js';
import { ClusterGroupFactory } from 'test/factories/cluster-group.factory.js';
import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock.js';
import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock.js';
import { newConfigRepositoryMock } from 'test/repositories/config.repository.mock.js';
import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock.js';
import { newJobRepositoryMock } from 'test/repositories/job.repository.mock.js';
import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock.js';
import { newMetadataRepositoryMock } from 'test/repositories/metadata.repository.mock.js';
import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock.js';
import { newSystemMetadataRepositoryMock } from 'test/repositories/system-metadata.repository.mock.js';
import { ITelemetryRepositoryMock, newTelemetryRepositoryMock } from 'test/repositories/telemetry.repository.mock.js';

export type ControllerContext = {
  authenticate: Mock;
  requireSetupAvailable: Mock;
  getHttpServer: () => any;
  reset: () => void;
  close: () => Promise<void>;
};

type ControllerClass = new (...args: any[]) => unknown;

export const controllerSetup = async (controller: ControllerClass | ControllerClass[], providers: Provider[]) => {
  const noopInterceptor = { intercept: (ctx: never, next: CallHandler<unknown>) => next.handle() };
  const upload = multer({ storage: memoryStorage() });
  const memoryFileInterceptor = {
    intercept: async (ctx: ExecutionContext, next: CallHandler<unknown>) => {
      const context = ctx.switchToHttp();
      const handler = upload.fields([
        { name: UploadFieldName.ASSET_DATA, maxCount: 1 },
        { name: UploadFieldName.SIDECAR_DATA, maxCount: 1 },
      ]);

      await new Promise<void>((resolve, reject) => {
        const next: NextFunction = (error) => (error ? reject(transformException(error)) : resolve());
        const maybePromise = handler(context.getRequest(), context.getResponse(), next);

        Promise.resolve(maybePromise).catch((error) => reject(error));
      });

      return next.handle();
    },
  };
  const moduleRef = await Test.createTestingModule({
    controllers: Array.isArray(controller) ? controller : [controller],
    providers: [
      { provide: APP_FILTER, useClass: GlobalExceptionFilter },
      { provide: APP_PIPE, useClass: ZodValidationPipe },
      { provide: APP_INTERCEPTOR, useClass: ZodSerializerInterceptor },
      { provide: APP_GUARD, useClass: AuthGuard },
      { provide: LoggingRepository, useValue: LoggingRepository.create() },
      { provide: ClsService, useValue: { getId: vi.fn() } },
      { provide: AuthService, useValue: { authenticate: vi.fn(), requireSetupAvailable: vi.fn() } },
      ...providers,
    ],
  })
    .overrideInterceptor(FileUploadInterceptor)
    .useValue(memoryFileInterceptor)
    .overrideInterceptor(AssetUploadInterceptor)
    .useValue(noopInterceptor)
    .compile();
  const app = moduleRef.createNestApplication({
    routeConflictPolicy: { duplicate: 'error' },
    routeResolutionStrategy: 'specificity',
  });
  await app.init();

  // allow the AuthController to override the AuthService itself
  const resolvedAuthService = app.get<Mocked<AuthService>>(AuthService);
  const authenticate = resolvedAuthService.authenticate as Mock;
  const requireSetupAvailable = resolvedAuthService.requireSetupAvailable as Mock;

  return {
    authenticate,
    requireSetupAvailable,
    getHttpServer: () => app.getHttpServer(),
    reset: () => {
      authenticate.mockReset();
      requireSetupAvailable.mockReset();
    },
    close: async () => {
      await app.close();
    },
  };
};

export type AutoMocked<T> = Mocked<T> & { resetAllMocks: () => void };

const mockFn = (label: string, { strict }: { strict: boolean }) => {
  const message = `Called a mock function without a mock implementation (${label})`;
  return vitest.fn(() => {
    {
      if (strict) {
        assert.fail(message);
      } else {
        // console.warn(message);
      }
    }
  });
};

export const mockBaseService = <T extends BaseService>(service: new (...args: any[]) => T) => {
  return automock(service, { args: [{ setContext: () => {} }], strict: false });
};

export const automock = <T>(
  Dependency: new (...args: any[]) => T,
  options?: {
    args?: ConstructorParameters<new (...args: any[]) => T>;
    strict?: boolean;
  },
): AutoMocked<T> => {
  const mock: Record<string, unknown> = {};
  const isStrict = options?.strict ?? true;
  const args = options?.args ?? [];

  const mocks: Mock[] = [];

  const instance = new Dependency(...args);
  const propertyNames = new Set(Object.getOwnPropertyNames(instance));
  for (let proto = Dependency.prototype; proto && proto !== Object.prototype; proto = Object.getPrototypeOf(proto)) {
    for (const property of Object.getOwnPropertyNames(proto)) {
      propertyNames.add(property);
    }
  }
  for (const property of propertyNames) {
    if (property === 'constructor') {
      continue;
    }

    try {
      const label = `${Dependency.name}.${property}`;
      // console.log(`Automocking ${label}`);

      const target = instance[property as keyof T];
      if (typeof target === 'function') {
        const mockImplementation = mockFn(label, { strict: isStrict });
        mock[property] = mockImplementation;
        mocks.push(mockImplementation);
        continue;
      }
    } catch {
      // noop
    }
  }

  const result = mock as AutoMocked<T>;
  result.resetAllMocks = () => {
    for (const mock of mocks) {
      mock.mockReset();
    }
  };

  return result;
};

export type ServiceOverrides = {
  access: AccessRepository;
  activity: ActivityRepository;
  album: AlbumRepository;
  albumUser: AlbumUserRepository;
  apiKey: ApiKeyRepository;
  app: AppRepository;
  asset: AssetRepository;
  assetEdit: AssetEditRepository;
  assetFile: AssetFileRepository;
  assetJob: AssetJobRepository;
  authChallenge: AuthChallengeRepository;
  clusterGroup: ClusterGroupRepository;
  config: ConfigRepository;
  cron: CronRepository;
  crypto: CryptoRepository;
  database: DatabaseRepository;
  downloadRepository: DownloadRepository;
  duplicateRepository: DuplicateRepository;
  email: EmailRepository;
  event: EventRepository;
  integrityReport: IntegrityRepository;
  job: JobRepository;
  library: LibraryRepository;
  logger: LoggingRepository;
  machineLearning: MachineLearningRepository;
  map: MapRepository;
  media: MediaRepository;
  memory: MemoryRepository;
  metadata: MetadataRepository;
  move: MoveRepository;
  notification: NotificationRepository;
  ocr: OcrRepository;
  oauth: OAuthRepository;
  partner: PartnerRepository;
  passkey: PasskeyRepository;
  person: PersonRepository;
  personUser: PersonUserRepository;
  plugin: PluginRepository;
  process: ProcessRepository;
  search: SearchRepository;
  serverInfo: ServerInfoRepository;
  session: SessionRepository;
  sharedLink: SharedLinkRepository;
  sharedLinkAsset: SharedLinkAssetRepository;
  stack: StackRepository;
  storage: StorageRepository;
  sync: SyncRepository;
  syncCheckpoint: SyncCheckpointRepository;
  systemMetadata: SystemMetadataRepository;
  tag: TagRepository;
  telemetry: TelemetryRepository;
  trash: TrashRepository;
  user: UserRepository;
  versionHistory: VersionHistoryRepository;
  videoStream: VideoStreamRepository;
  view: ViewRepository;
  webAuthn: WebAuthnRepository;
  websocket: WebsocketRepository;
  workflow: WorkflowRepository;
};

type As<T> = T extends RepositoryInterface<infer U> ? U : never;
type IAccessRepository = { [K in keyof AccessRepository]: RepositoryInterface<AccessRepository[K]> };

export type ServiceMocks = {
  [K in keyof Omit<ServiceOverrides, 'access' | 'telemetry'>]: Mocked<RepositoryInterface<ServiceOverrides[K]>>;
} & { access: IAccessRepositoryMock; telemetry: ITelemetryRepositoryMock };

type BaseServiceArgs = ConstructorParameters<typeof BaseService>;
type Constructor<Type, Args extends Array<any>> = {
  new (...deps: Args): Type;
};

export const getMocks = () => {
  const loggerMock = { setContext: () => {} };
  const configMock = { getEnv: () => ({}) };

  // eslint-disable-next-line no-sparse-arrays
  const databaseMock = automock(DatabaseRepository, { args: [, loggerMock], strict: false });

  databaseMock.withLock.mockImplementation((_type, fn) => fn());
  databaseMock.getPostgresVersion = vitest.fn().mockResolvedValue('14.10 (Debian 14.10-1.pgdg120+1)');
  databaseMock.getPostgresVersionRange = vitest.fn().mockReturnValue('>=14.0.0');
  databaseMock.createExtension = vitest.fn().mockResolvedValue(void 0);
  databaseMock.vacuum.mockResolvedValue(void 0);

  const mocks: ServiceMocks = {
    access: newAccessRepositoryMock(),
    // eslint-disable-next-line no-sparse-arrays
    logger: automock(LoggingRepository, { args: [, configMock], strict: false }),
    // eslint-disable-next-line no-sparse-arrays
    cron: automock(CronRepository, { args: [, loggerMock] }),
    crypto: newCryptoRepositoryMock(),
    activity: automock(ActivityRepository),
    album: automock(AlbumRepository, { strict: false }),
    albumUser: automock(AlbumUserRepository),
    asset: newAssetRepositoryMock(),
    assetEdit: automock(AssetEditRepository),
    assetFile: automock(AssetFileRepository),
    assetJob: automock(AssetJobRepository),
    authChallenge: automock(AuthChallengeRepository),
    clusterGroup: automock(ClusterGroupRepository),
    app: automock(AppRepository, { strict: false }),
    config: newConfigRepositoryMock(),
    database: databaseMock,
    downloadRepository: automock(DownloadRepository, { strict: false }),
    duplicateRepository: automock(DuplicateRepository),
    email: automock(EmailRepository, { args: [loggerMock] }),
    // eslint-disable-next-line no-sparse-arrays
    event: automock(EventRepository, { args: [, , loggerMock], strict: false }),
    integrityReport: automock(IntegrityRepository, { strict: false }),
    job: newJobRepositoryMock(),
    apiKey: automock(ApiKeyRepository),
    library: automock(LibraryRepository, { strict: false }),
    machineLearning: automock(MachineLearningRepository, { args: [loggerMock], strict: false }),
    map: automock(MapRepository, { args: [undefined, undefined, { setContext: () => {} }] }),
    media: newMediaRepositoryMock(),
    memory: automock(MemoryRepository),
    metadata: newMetadataRepositoryMock(),
    move: automock(MoveRepository, { strict: false }),
    notification: automock(NotificationRepository),
    ocr: automock(OcrRepository, { strict: false }),
    oauth: automock(OAuthRepository, { args: [loggerMock] }),
    partner: automock(PartnerRepository, { strict: false }),
    passkey: automock(PasskeyRepository),
    person: automock(PersonRepository, { strict: false }),
    personUser: automock(PersonUserRepository, { strict: false }),
    plugin: automock(PluginRepository, { strict: true, args: [databaseMock, loggerMock] }),
    process: automock(ProcessRepository),
    search: automock(SearchRepository, { strict: false }),
    // eslint-disable-next-line no-sparse-arrays
    serverInfo: automock(ServerInfoRepository, { args: [, loggerMock], strict: false }),
    session: automock(SessionRepository),
    sharedLink: automock(SharedLinkRepository),
    sharedLinkAsset: automock(SharedLinkAssetRepository),
    stack: automock(StackRepository),
    storage: newStorageRepositoryMock(),
    sync: automock(SyncRepository),
    syncCheckpoint: automock(SyncCheckpointRepository),
    systemMetadata: newSystemMetadataRepositoryMock(),
    // systemMetadata: automock(SystemMetadataRepository, { strict: false }),
    // eslint-disable-next-line no-sparse-arrays
    tag: automock(TagRepository, { args: [, loggerMock], strict: false }),
    telemetry: newTelemetryRepositoryMock(),
    trash: automock(TrashRepository),
    user: automock(UserRepository, { strict: false }),
    versionHistory: automock(VersionHistoryRepository),
    videoStream: automock(VideoStreamRepository, { strict: false }),
    view: automock(ViewRepository),
    webAuthn: automock(WebAuthnRepository),
    // eslint-disable-next-line no-sparse-arrays
    websocket: automock(WebsocketRepository, { args: [, loggerMock], strict: false }),
    workflow: automock(WorkflowRepository, { strict: true }),
  };

  // every new user gets a cluster group, which is incidental to most tests
  mocks.clusterGroup.create.mockResolvedValue(ClusterGroupFactory.create());

  return mocks;
};

export const newTestService = <T extends BaseService>(
  Service: Constructor<T, BaseServiceArgs>,
  overrides: Partial<ServiceOverrides> = {},
) => {
  const mocks = getMocks();

  const sut = new Service(
    overrides.logger || (mocks.logger as As<LoggingRepository>),
    overrides.access || (mocks.access as IAccessRepository as AccessRepository),
    overrides.activity || (mocks.activity as As<ActivityRepository>),
    overrides.album || (mocks.album as As<AlbumRepository>),
    overrides.albumUser || (mocks.albumUser as As<AlbumUserRepository>),
    overrides.apiKey || (mocks.apiKey as As<ApiKeyRepository>),
    overrides.app || (mocks.app as As<AppRepository>),
    overrides.asset || (mocks.asset as As<AssetRepository>),
    overrides.assetEdit || (mocks.assetEdit as As<AssetEditRepository>),
    overrides.assetFile || (mocks.assetFile as As<AssetFileRepository>),
    overrides.assetJob || (mocks.assetJob as As<AssetJobRepository>),
    overrides.authChallenge || (mocks.authChallenge as As<AuthChallengeRepository>),
    overrides.clusterGroup || (mocks.clusterGroup as As<ClusterGroupRepository>),
    overrides.config || (mocks.config as As<ConfigRepository> as ConfigRepository),
    overrides.cron || (mocks.cron as As<CronRepository>),
    overrides.crypto || (mocks.crypto as As<CryptoRepository>),
    overrides.database || (mocks.database as As<DatabaseRepository>),
    overrides.downloadRepository || (mocks.downloadRepository as As<DownloadRepository>),
    overrides.duplicateRepository || (mocks.duplicateRepository as As<DuplicateRepository>),
    overrides.email || (mocks.email as As<EmailRepository>),
    overrides.event || (mocks.event as As<EventRepository>),
    overrides.integrityReport || (mocks.integrityReport as As<IntegrityRepository>),
    overrides.job || (mocks.job as As<JobRepository>),
    overrides.library || (mocks.library as As<LibraryRepository>),
    overrides.machineLearning || (mocks.machineLearning as As<MachineLearningRepository>),
    overrides.map || (mocks.map as As<MapRepository>),
    overrides.media || (mocks.media as As<MediaRepository>),
    overrides.memory || (mocks.memory as As<MemoryRepository>),
    overrides.metadata || (mocks.metadata as As<MetadataRepository>),
    overrides.move || (mocks.move as As<MoveRepository>),
    overrides.notification || (mocks.notification as As<NotificationRepository>),
    overrides.oauth || (mocks.oauth as As<OAuthRepository>),
    overrides.ocr || (mocks.ocr as As<OcrRepository>),
    overrides.partner || (mocks.partner as As<PartnerRepository>),
    overrides.passkey || (mocks.passkey as As<PasskeyRepository>),
    overrides.person || (mocks.person as As<PersonRepository>),
    overrides.personUser || (mocks.personUser as As<PersonUserRepository>),
    overrides.plugin || (mocks.plugin as As<PluginRepository>),
    overrides.process || (mocks.process as As<ProcessRepository>),
    overrides.search || (mocks.search as As<SearchRepository>),
    overrides.serverInfo || (mocks.serverInfo as As<ServerInfoRepository>),
    overrides.session || (mocks.session as As<SessionRepository>),
    overrides.sharedLink || (mocks.sharedLink as As<SharedLinkRepository>),
    overrides.sharedLinkAsset || (mocks.sharedLinkAsset as As<SharedLinkAssetRepository>),
    overrides.stack || (mocks.stack as As<StackRepository>),
    overrides.storage || (mocks.storage as As<StorageRepository>),
    overrides.sync || (mocks.sync as As<SyncRepository>),
    overrides.syncCheckpoint || (mocks.syncCheckpoint as As<SyncCheckpointRepository>),
    overrides.systemMetadata || (mocks.systemMetadata as As<SystemMetadataRepository>),
    overrides.tag || (mocks.tag as As<TagRepository>),
    overrides.telemetry || (mocks.telemetry as unknown as TelemetryRepository),
    overrides.trash || (mocks.trash as As<TrashRepository>),
    overrides.user || (mocks.user as As<UserRepository>),
    overrides.versionHistory || (mocks.versionHistory as As<VersionHistoryRepository>),
    overrides.videoStream || (mocks.videoStream as As<VideoStreamRepository>),
    overrides.view || (mocks.view as As<ViewRepository>),
    overrides.webAuthn || (mocks.webAuthn as As<WebAuthnRepository>),
    overrides.websocket || (mocks.websocket as As<WebsocketRepository>),
    overrides.workflow || (mocks.workflow as As<WorkflowRepository>),
  );

  return {
    sut,
    mocks,
  };
};

const createPNG = (r: number, g: number, b: number) => {
  const image = new PNG({ width: 1, height: 1 });
  image.data[0] = r;
  image.data[1] = g;
  image.data[2] = b;
  image.data[3] = 255;
  return PNG.sync.write(image);
};

function* newPngFactory() {
  for (let r = 0; r < 255; r++) {
    for (let g = 0; g < 255; g++) {
      for (let b = 0; b < 255; b++) {
        yield createPNG(r, g, b);
      }
    }
  }
}

const pngFactory = newPngFactory();

const templateName = 'mich';

const withDatabase = (url: string, name: string) => url.replace(`/${templateName}`, () => `/${name}`);

export const getKyselyDB = async (suffix?: string): Promise<Kysely<DB>> => {
  const testUrl = process.env.IMMICH_TEST_POSTGRES_URL!;
  const connection = { connectionType: 'url', url: withDatabase(testUrl, 'postgres') } as DatabaseConnectionParams;
  const sql = createPostgres({ maxConnections: 1, connection });

  const randomSuffix = Math.random().toString(36).slice(2, 7);
  const dbName = `immich_${suffix ?? randomSuffix}`;
  await sql.unsafe(`CREATE DATABASE ${dbName} WITH TEMPLATE ${templateName} OWNER postgres;`);

  return new Kysely<DB>(getKyselyConfig({ connectionType: 'url', url: withDatabase(testUrl, dbName) }));
};

export const newRandomImage = () => {
  const { value } = pngFactory.next();
  if (!value) {
    throw new Error('Ran out of random asset data');
  }

  return value;
};

export const mockSpawn = vitest.fn((exitCode: number, stdout: string, stderr: string, error?: unknown) => {
  return {
    stdout: new Readable({
      read() {
        this.push(stdout); // write mock data to stdout
        this.push(null); // end stream
      },
    }),
    stderr: new Readable({
      read() {
        this.push(stderr); // write mock data to stderr
        this.push(null); // end stream
      },
    }),
    stdin: new Writable({
      write(chunk, encoding, callback) {
        callback();
      },
    }),
    exitCode,
    on: vitest.fn((event, callback: any) => {
      if (event === 'close') {
        callback(0);
      }
      if (event === 'error' && error) {
        callback(error);
      }
      if (event === 'exit') {
        callback(exitCode);
      }
    }),
    kill: vitest.fn(),
  } as unknown as ChildProcessWithoutNullStreams;
});

export const mockDuplex =
  (chunkCb?: (chunk: Buffer) => void) =>
  (command: string, exitCode: number, stdout: string, stderr: string, error?: unknown) => {
    const duplex = new Duplex({
      write(chunk, _encoding, callback) {
        chunkCb?.(chunk);
        callback();
      },

      read() {},

      final(callback) {
        callback();
      },
    });

    setImmediate(() => {
      if (error) {
        duplex.destroy(error as Error);
      } else if (exitCode === 0) {
        duplex.push(stdout);
        duplex.push(null);
      } else {
        duplex.destroy(new Error(`${command} non-zero exit code (${exitCode})\n${stderr}`));
      }
    });

    return duplex;
  };

export async function* makeStream<T>(items: T[] = []): AsyncGenerator<T> {
  for (const item of items) {
    await Promise.resolve();
    yield item;
  }
}

export const wait = (ms: number): Promise<void> => {
  return new Promise((resolve) => {
    const target = performance.now() + ms;
    const checkDone = () => {
      if (performance.now() >= target) {
        resolve();
      } else {
        setTimeout(checkDone, 1); // Check again after 1ms
      }
    };
    setTimeout(checkDone, ms);
  });
};