feat: exif medium tests (#23561)

server/test/medium.factory.ts

@@ -2,6 +2,7 @@
 import { Insertable, Kysely } from 'kysely';
 import { DateTime } from 'luxon';
 import { createHash, randomBytes } from 'node:crypto';
+import { Stats } from 'node:fs';
 import { Writable } from 'node:stream';
 import { AssetFace } from 'src/database';
 import { AuthDto, LoginResponseDto } from 'src/dtos/auth.dto';
@@ -28,7 +29,9 @@ import { EventRepository } from 'src/repositories/event.repository';
 import { JobRepository } from 'src/repositories/job.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { MachineLearningRepository } from 'src/repositories/machine-learning.repository';
+import { MapRepository } from 'src/repositories/map.repository';
 import { MemoryRepository } from 'src/repositories/memory.repository';
+import { MetadataRepository } from 'src/repositories/metadata.repository';
 import { NotificationRepository } from 'src/repositories/notification.repository';
 import { OcrRepository } from 'src/repositories/ocr.repository';
 import { PartnerRepository } from 'src/repositories/partner.repository';
@@ -61,7 +64,9 @@ import { TagAssetTable } from 'src/schema/tables/tag-asset.table';
 import { TagTable } from 'src/schema/tables/tag.table';
 import { UserTable } from 'src/schema/tables/user.table';
 import { BASE_SERVICE_DEPENDENCIES, BaseService } from 'src/services/base.service';
+import { MetadataService } from 'src/services/metadata.service';
 import { SyncService } from 'src/services/sync.service';
+import { mockEnvData } from 'test/repositories/config.repository.mock';
 import { newTelemetryRepositoryMock } from 'test/repositories/telemetry.repository.mock';
 import { factory, newDate, newEmbedding, newUuid } from 'test/small.factory';
 import { automock, wait } from 'test/utils';
@@ -305,6 +310,63 @@ export class SyncTestContext extends MediumTestContext<SyncService> {
   }
 }
 
+const mockDate = new Date('2024-06-01T12:00:00.000Z');
+const mockStats = {
+  mtime: mockDate,
+  atime: mockDate,
+  ctime: mockDate,
+  birthtime: mockDate,
+  atimeMs: 0,
+  mtimeMs: 0,
+  ctimeMs: 0,
+  birthtimeMs: 0,
+};
+
+export class ExifTestContext extends MediumTestContext<MetadataService> {
+  constructor(database: Kysely<DB>) {
+    super(MetadataService, {
+      database,
+      real: [AssetRepository, AssetJobRepository, MetadataRepository, SystemMetadataRepository, TagRepository],
+      mock: [ConfigRepository, EventRepository, LoggingRepository, MapRepository, StorageRepository],
+    });
+
+    this.getMock(ConfigRepository).getEnv.mockReturnValue(mockEnvData({}));
+    this.getMock(EventRepository).emit.mockResolvedValue();
+    this.getMock(MapRepository).reverseGeocode.mockResolvedValue({ country: null, state: null, city: null });
+    this.getMock(StorageRepository).stat.mockResolvedValue(mockStats as Stats);
+  }
+
+  getMockStats() {
+    return mockStats;
+  }
+
+  getGps(assetId: string) {
+    return this.database
+      .selectFrom('asset_exif')
+      .select(['latitude', 'longitude'])
+      .where('assetId', '=', assetId)
+      .executeTakeFirstOrThrow();
+  }
+
+  getTags(assetId: string) {
+    return this.database
+      .selectFrom('tag')
+      .innerJoin('tag_asset', 'tag.id', 'tag_asset.tagsId')
+      .where('tag_asset.assetsId', '=', assetId)
+      .selectAll()
+      .execute();
+  }
+
+  getDates(assetId: string) {
+    return this.database
+      .selectFrom('asset')
+      .innerJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
+      .where('id', '=', assetId)
+      .select(['asset.fileCreatedAt', 'asset.localDateTime', 'asset_exif.dateTimeOriginal', 'asset_exif.timeZone'])
+      .executeTakeFirstOrThrow();
+  }
+}
+
 const newRealRepository = <T>(key: ClassConstructor<T>, db: Kysely<DB>): T => {
   switch (key) {
     case AccessRepository:
@@ -344,6 +406,14 @@ const newRealRepository = <T>(key: ClassConstructor<T>, db: Kysely<DB>): T => {
       return new key(LoggingRepository.create());
     }
 
+    case MetadataRepository: {
+      return new key(LoggingRepository.create());
+    }
+
+    case StorageRepository: {
+      return new key(LoggingRepository.create());
+    }
+
     case TagRepository: {
       return new key(db, LoggingRepository.create());
     }
@@ -381,6 +451,10 @@ const newMockRepository = <T>(key: ClassConstructor<T>) => {
       return automock(key);
     }
 
+    case MapRepository: {
+      return automock(MapRepository, { args: [undefined, undefined, { setContext: () => {} }] });
+    }
+
     case TelemetryRepository: {
       return newTelemetryRepositoryMock();
     }

server/test/medium/specs/exif/exif-date-time.spec.ts

@@ -0,0 +1,65 @@
+import { Kysely } from 'kysely';
+import { DateTime } from 'luxon';
+import { resolve } from 'node:path';
+import { DB } from 'src/schema';
+import { ExifTestContext } from 'test/medium.factory';
+import { getKyselyDB } from 'test/utils';
+
+let database: Kysely<DB>;
+
+const setup = async (testAssetPath: string) => {
+  const ctx = new ExifTestContext(database);
+
+  const { user } = await ctx.newUser();
+  const originalPath = resolve(`../e2e/test-assets/${testAssetPath}`);
+  const { asset } = await ctx.newAsset({ ownerId: user.id, originalPath });
+
+  return { ctx, sut: ctx.sut, asset };
+};
+
+beforeAll(async () => {
+  database = await getKyselyDB();
+});
+
+describe('exif date time', () => {
+  it('should prioritize DateTimeOriginal', async () => {
+    const { ctx, sut, asset } = await setup('metadata/dates/date-priority-test.jpg');
+
+    await sut.handleMetadataExtraction({ id: asset.id });
+
+    await expect(ctx.getDates(asset.id)).resolves.toEqual({
+      timeZone: null,
+      dateTimeOriginal: DateTime.fromISO('2023-02-02T02:00:00.000Z').toJSDate(),
+      localDateTime: DateTime.fromISO('2023-02-02T02:00:00.000Z').toJSDate(),
+      fileCreatedAt: DateTime.fromISO('2023-02-02T02:00:00.000Z').toJSDate(),
+    });
+  });
+
+  it('should extract GPSDateTime with GPS coordinates ', async () => {
+    const { ctx, sut, asset } = await setup('metadata/dates/gps-datetime.jpg');
+
+    await sut.handleMetadataExtraction({ id: asset.id });
+
+    await expect(ctx.getDates(asset.id)).resolves.toEqual({
+      timeZone: 'America/Los_Angeles',
+      dateTimeOriginal: DateTime.fromISO('2023-11-15T12:30:00.000Z').toJSDate(),
+      localDateTime: DateTime.fromISO('2023-11-15T04:30:00.000Z').toJSDate(),
+      fileCreatedAt: DateTime.fromISO('2023-11-15T12:30:00.000Z').toJSDate(),
+    });
+  });
+
+  it('should ignore the TimeCreated tag', async () => {
+    const { ctx, sut, asset } = await setup('metadata/dates/time-created.jpg');
+
+    await sut.handleMetadataExtraction({ id: asset.id });
+
+    const stats = ctx.getMockStats();
+
+    await expect(ctx.getDates(asset.id)).resolves.toEqual({
+      timeZone: null,
+      dateTimeOriginal: stats.mtime,
+      localDateTime: stats.mtime,
+      fileCreatedAt: stats.mtime,
+    });
+  });
+});

server/test/medium/specs/exif/exif-gps.spec.ts

@@ -0,0 +1,31 @@
+import { Kysely } from 'kysely';
+import { resolve } from 'node:path';
+import { DB } from 'src/schema';
+import { ExifTestContext } from 'test/medium.factory';
+import { getKyselyDB } from 'test/utils';
+
+let database: Kysely<DB>;
+
+const setup = async (testAssetPath: string) => {
+  const ctx = new ExifTestContext(database);
+
+  const { user } = await ctx.newUser();
+  const originalPath = resolve(`../e2e/test-assets/${testAssetPath}`);
+  const { asset } = await ctx.newAsset({ ownerId: user.id, originalPath });
+
+  return { ctx, sut: ctx.sut, asset };
+};
+
+beforeAll(async () => {
+  database = await getKyselyDB();
+});
+
+describe('exif gps', () => {
+  it('should handle empty strings', async () => {
+    const { ctx, sut, asset } = await setup('metadata/gps-position/empty_gps.jpg');
+
+    await sut.handleMetadataExtraction({ id: asset.id });
+
+    await expect(ctx.getGps(asset.id)).resolves.toEqual({ latitude: null, longitude: null });
+  });
+});

server/test/medium/specs/exif/exif-tags.spec.ts

@@ -0,0 +1,34 @@
+import { Kysely } from 'kysely';
+import { resolve } from 'node:path';
+import { DB } from 'src/schema';
+import { ExifTestContext } from 'test/medium.factory';
+import { getKyselyDB } from 'test/utils';
+
+let database: Kysely<DB>;
+
+const setup = async (testAssetPath: string) => {
+  const ctx = new ExifTestContext(database);
+
+  const { user } = await ctx.newUser();
+  const originalPath = resolve(`../e2e/test-assets/${testAssetPath}`);
+  const { asset } = await ctx.newAsset({ ownerId: user.id, originalPath });
+
+  return { ctx, sut: ctx.sut, asset };
+};
+
+beforeAll(async () => {
+  database = await getKyselyDB();
+});
+
+describe('exif tags', () => {
+  it('should detect and regular tags', async () => {
+    const { ctx, sut, asset } = await setup('metadata/tags/picasa.jpg');
+
+    await sut.handleMetadataExtraction({ id: asset.id });
+
+    await expect(ctx.getTags(asset.id)).resolves.toEqual([
+      expect.objectContaining({ assetsId: asset.id, value: 'Frost', parentId: null }),
+      expect.objectContaining({ assetsId: asset.id, value: 'Yard', parentId: null }),
+    ]);
+  });
+});

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

@@ -65,42 +65,6 @@ describe(MetadataService.name, () => {
           timeZone: null,
         },
       },
-      {
-        description: 'should handle no time zone information and server behind UTC',
-        serverTimeZone: 'America/Los_Angeles',
-        exifData: {
-          DateTimeOriginal: '2022:01:01 00:00:00',
-        },
-        expected: {
-          localDateTime: '2022-01-01T00:00:00.000Z',
-          dateTimeOriginal: '2022-01-01T08:00:00.000Z',
-          timeZone: null,
-        },
-      },
-      {
-        description: 'should handle no time zone information and server ahead of UTC',
-        serverTimeZone: 'Europe/Brussels',
-        exifData: {
-          DateTimeOriginal: '2022:01:01 00:00:00',
-        },
-        expected: {
-          localDateTime: '2022-01-01T00:00:00.000Z',
-          dateTimeOriginal: '2021-12-31T23:00:00.000Z',
-          timeZone: null,
-        },
-      },
-      {
-        description: 'should handle no time zone information and server ahead of UTC in the summer',
-        serverTimeZone: 'Europe/Brussels',
-        exifData: {
-          DateTimeOriginal: '2022:06:01 00:00:00',
-        },
-        expected: {
-          localDateTime: '2022-06-01T00:00:00.000Z',
-          dateTimeOriginal: '2022-05-31T22:00:00.000Z',
-          timeZone: null,
-        },
-      },
       {
         description: 'should handle a +13:00 time zone',
         exifData: {