refactor: tests (#25987)

server/test/factories/asset-edit.factory.ts

@@ -0,0 +1,38 @@
+import { Selectable } from 'kysely';
+import { AssetEditAction } from 'src/dtos/editing.dto';
+import { AssetEditTable } from 'src/schema/tables/asset-edit.table';
+import { AssetFactory } from 'test/factories/asset.factory';
+import { build } from 'test/factories/builder.factory';
+import { AssetEditLike, AssetLike, FactoryBuilder } from 'test/factories/types';
+import { newUuid } from 'test/small.factory';
+
+export class AssetEditFactory {
+  private constructor(private readonly value: Selectable<AssetEditTable>) {}
+
+  static create(dto: AssetEditLike = {}) {
+    return AssetEditFactory.from(dto).build();
+  }
+
+  static from(dto: AssetEditLike = {}) {
+    const id = dto.id ?? newUuid();
+
+    return new AssetEditFactory({
+      id,
+      assetId: newUuid(),
+      action: AssetEditAction.Crop,
+      parameters: { x: 5, y: 6, width: 200, height: 100 },
+      sequence: 1,
+      ...dto,
+    });
+  }
+
+  asset(dto: AssetLike = {}, builder?: FactoryBuilder<AssetFactory>) {
+    const asset = build(AssetFactory.from(dto), builder);
+    this.value.assetId = asset.build().id;
+    return this;
+  }
+
+  build() {
+    return { ...this.value } as Selectable<AssetEditTable<AssetEditAction.Crop>>;
+  }
+}

server/test/factories/asset-file.factory.ts

@@ -0,0 +1,43 @@
+import { Selectable } from 'kysely';
+import { AssetFileType } from 'src/enum';
+import { AssetFileTable } from 'src/schema/tables/asset-file.table';
+import { AssetFactory } from 'test/factories/asset.factory';
+import { build } from 'test/factories/builder.factory';
+import { AssetFileLike, AssetLike, FactoryBuilder } from 'test/factories/types';
+import { newDate, newUuid, newUuidV7 } from 'test/small.factory';
+
+export class AssetFileFactory {
+  private constructor(private readonly value: Selectable<AssetFileTable>) {}
+
+  static create(dto: AssetFileLike = {}) {
+    return AssetFileFactory.from(dto).build();
+  }
+
+  static from(dto: AssetFileLike = {}) {
+    const id = dto.id ?? newUuid();
+    const isEdited = dto.isEdited ?? false;
+
+    return new AssetFileFactory({
+      id,
+      assetId: newUuid(),
+      createdAt: newDate(),
+      updatedAt: newDate(),
+      type: AssetFileType.Thumbnail,
+      path: `/data/12/34/thumbs/${id.slice(0, 2)}/${id.slice(2, 4)}/${id}${isEdited ? '_edited' : ''}.jpg`,
+      updateId: newUuidV7(),
+      isProgressive: false,
+      isEdited,
+      ...dto,
+    });
+  }
+
+  asset(dto: AssetLike = {}, builder?: FactoryBuilder<AssetFactory>) {
+    const asset = build(AssetFactory.from(dto), builder);
+    this.value.assetId = asset.build().id;
+    return this;
+  }
+
+  build() {
+    return { ...this.value };
+  }
+}

server/test/factories/asset.factory.ts

@@ -1,15 +1,20 @@
 import { Selectable } from 'kysely';
-import { AssetStatus, AssetType, AssetVisibility } from 'src/enum';
+import { AssetFileType, AssetStatus, AssetType, AssetVisibility } from 'src/enum';
+import { AssetFaceTable } from 'src/schema/tables/asset-face.table';
 import { AssetTable } from 'src/schema/tables/asset.table';
+import { AssetEditFactory } from 'test/factories/asset-edit.factory';
 import { AssetExifFactory } from 'test/factories/asset-exif.factory';
+import { AssetFileFactory } from 'test/factories/asset-file.factory';
 import { build } from 'test/factories/builder.factory';
-import { AssetExifLike, AssetLike, FactoryBuilder, UserLike } from 'test/factories/types';
+import { AssetEditLike, AssetExifLike, AssetFileLike, AssetLike, FactoryBuilder, UserLike } from 'test/factories/types';
 import { UserFactory } from 'test/factories/user.factory';
-import { factory, newDate, newSha1, newUuid, newUuidV7 } from 'test/small.factory';
+import { newDate, newSha1, newUuid, newUuidV7 } from 'test/small.factory';
 
 export class AssetFactory {
-  #assetExif?: AssetExifFactory;
   #owner!: UserFactory;
+  #assetExif?: AssetExifFactory;
+  #files: AssetFileFactory[] = [];
+  #edits: AssetEditFactory[] = [];
 
   private constructor(private readonly value: Selectable<AssetTable>) {
     value.ownerId ??= newUuid();
@@ -21,8 +26,12 @@ export class AssetFactory {
   }
 
   static from(dto: AssetLike = {}) {
+    const id = dto.id ?? newUuid();
+
+    const originalFileName = dto.originalFileName ?? `IMG_${id}.jpg`;
+
     return new AssetFactory({
-      id: factory.uuid(),
+      id,
       createdAt: newDate(),
       updatedAt: newDate(),
       deletedAt: null,
@@ -42,8 +51,8 @@ export class AssetFactory {
       libraryId: null,
       livePhotoVideoId: null,
       localDateTime: newDate(),
-      originalFileName: 'IMG_123.jpg',
-      originalPath: `/data/12/34/IMG_123.jpg`,
+      originalFileName,
+      originalPath: `/data/library/${originalFileName}`,
       ownerId: newUuid(),
       stackId: null,
       thumbhash: null,
@@ -67,13 +76,51 @@ export class AssetFactory {
     return this;
   }
 
+  edit(dto: AssetEditLike = {}, builder?: FactoryBuilder<AssetEditFactory>) {
+    this.#edits.push(build(AssetEditFactory.from(dto).asset(this.value), builder));
+    this.value.isEdited = true;
+    return this;
+  }
+
+  file(dto: AssetFileLike = {}, builder?: FactoryBuilder<AssetFileFactory>) {
+    this.#files.push(build(AssetFileFactory.from(dto).asset(this.value), builder));
+    return this;
+  }
+
+  files(dto?: 'edits'): AssetFactory;
+  files(items: AssetFileLike[], builder?: FactoryBuilder<AssetFileFactory>): AssetFactory;
+  files(items: AssetFileType[], builder?: FactoryBuilder<AssetFileFactory>): AssetFactory;
+  files(dto?: 'edits' | AssetFileLike[] | AssetFileType[], builder?: FactoryBuilder<AssetFileFactory>): AssetFactory {
+    const items: AssetFileLike[] = [];
+
+    if (dto === undefined || dto === 'edits') {
+      items.push(...Object.values(AssetFileType).map((type) => ({ type })));
+
+      if (dto === 'edits') {
+        items.push(...Object.values(AssetFileType).map((type) => ({ type, isEdited: true })));
+      }
+    } else {
+      for (const item of dto) {
+        items.push(typeof item === 'string' ? { type: item as AssetFileType } : item);
+      }
+    }
+    for (const item of items) {
+      this.file(item, builder);
+    }
+
+    return this;
+  }
+
   build() {
     const exif = this.#assetExif?.build();
 
     return {
       ...this.value,
-      exifInfo: exif as NonNullable<typeof exif>,
       owner: this.#owner.build(),
+      exifInfo: exif as NonNullable<typeof exif>,
+      files: this.#files.map((file) => file.build()),
+      edits: this.#edits.map((edit) => edit.build()),
+      faces: [] as Selectable<AssetFaceTable>[],
     };
   }
 }

server/test/factories/types.ts

@@ -1,7 +1,9 @@
 import { Selectable } from 'kysely';
 import { AlbumUserTable } from 'src/schema/tables/album-user.table';
 import { AlbumTable } from 'src/schema/tables/album.table';
+import { AssetEditTable } from 'src/schema/tables/asset-edit.table';
 import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
+import { AssetFileTable } from 'src/schema/tables/asset-file.table';
 import { AssetTable } from 'src/schema/tables/asset.table';
 import { SharedLinkTable } from 'src/schema/tables/shared-link.table';
 import { UserTable } from 'src/schema/tables/user.table';
@@ -10,6 +12,8 @@ export type FactoryBuilder<T, R extends T = T> = (builder: T) => R;
 
 export type AssetLike = Partial<Selectable<AssetTable>>;
 export type AssetExifLike = Partial<Selectable<AssetExifTable>>;
+export type AssetEditLike = Partial<Selectable<AssetEditTable>>;
+export type AssetFileLike = Partial<Selectable<AssetFileTable>>;
 export type AlbumLike = Partial<Selectable<AlbumTable>>;
 export type AlbumUserLike = Partial<Selectable<AlbumUserTable>>;
 export type SharedLinkLike = Partial<Selectable<SharedLinkTable>>;