refactor: medium tests (#19537)

2025-06-26 15:32:06 -04:00
parent b96c95beda
commit 3105094a3d
19 changed files with 1579 additions and 2253 deletions
@@ -1,44 +1,33 @@
 import { Kysely } from 'kysely';
 import { DB } from 'src/db';
 import { AssetRepository } from 'src/repositories/asset.repository';
-import { UserRepository } from 'src/repositories/user.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
 import { AssetService } from 'src/services/asset.service';
-import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { newMediumService } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
 import { getKyselyDB } from 'test/utils';

-describe(AssetService.name, () => {
-  let defaultDatabase: Kysely<DB>;
-  let assetRepo: AssetRepository;
-  let userRepo: UserRepository;
+let defaultDatabase: Kysely<DB>;

-  const createSut = (db?: Kysely<DB>) => {
-    return newMediumService(AssetService, {
-      database: db || defaultDatabase,
-      repos: {
-        asset: 'real',
-      },
-    });
-  };
-
-  beforeAll(async () => {
-    defaultDatabase = await getKyselyDB();
-
-    assetRepo = new AssetRepository(defaultDatabase);
-    userRepo = new UserRepository(defaultDatabase);
+const setup = (db?: Kysely<DB>) => {
+  return newMediumService(AssetService, {
+    database: db || defaultDatabase,
+    real: [AssetRepository],
+    mock: [LoggingRepository],
  });
+};

+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(AssetService.name, () => {
  describe('getStatistics', () => {
    it('should return stats as numbers, not strings', async () => {
-      const { sut } = createSut();
-
-      const user = mediumFactory.userInsert();
-      const asset = mediumFactory.assetInsert({ ownerId: user.id });
-
-      await userRepo.create(user);
-      await assetRepo.create(asset);
-      await assetRepo.upsertExif({ assetId: asset.id, fileSizeInByte: 12_345 });
-
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, fileSizeInByte: 12_345 });
      const auth = factory.auth({ user: { id: user.id } });
      await expect(sut.getStatistics(auth, {})).resolves.toEqual({ images: 1, total: 1, videos: 0 });
    });
@@ -1,74 +1,63 @@
-import { Kysely } from 'kysely';
-import { DB } from 'src/db';
-import { AssetRepository } from 'src/repositories/asset.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
 import { PartnerRepository } from 'src/repositories/partner.repository';
 import { UserRepository } from 'src/repositories/user.repository';
 import { partners_delete_audit } from 'src/schema/functions';
-import { mediumFactory } from 'test/medium.factory';
+import { BaseService } from 'src/services/base.service';
+import { MediumTestContext } from 'test/medium.factory';
 import { getKyselyDB } from 'test/utils';

 describe('audit', () => {
-  let defaultDatabase: Kysely<DB>;
-  let assetRepo: AssetRepository;
-  let userRepo: UserRepository;
-  let partnerRepo: PartnerRepository;
+  let ctx: MediumTestContext;

  beforeAll(async () => {
-    defaultDatabase = await getKyselyDB();
-
-    assetRepo = new AssetRepository(defaultDatabase);
-    userRepo = new UserRepository(defaultDatabase);
-    partnerRepo = new PartnerRepository(defaultDatabase);
+    ctx = new MediumTestContext(BaseService, {
+      database: await getKyselyDB(),
+      real: [],
+      mock: [LoggingRepository],
+    });
  });

  describe(partners_delete_audit.name, () => {
    it('should not cascade user deletes to partners_audit', async () => {
-      const user1 = mediumFactory.userInsert();
-      const user2 = mediumFactory.userInsert();
-
-      await Promise.all([userRepo.create(user1), userRepo.create(user2)]);
+      const partnerRepo = ctx.get(PartnerRepository);
+      const userRepo = ctx.get(UserRepository);
+      const { user: user1 } = await ctx.newUser();
+      const { user: user2 } = await ctx.newUser();
      await partnerRepo.create({ sharedById: user1.id, sharedWithId: user2.id });
      await userRepo.delete(user1, true);
-
      await expect(
-        defaultDatabase.selectFrom('partners_audit').select(['id']).where('sharedById', '=', user1.id).execute(),
+        ctx.database.selectFrom('partners_audit').select(['id']).where('sharedById', '=', user1.id).execute(),
      ).resolves.toHaveLength(0);
    });
  });

  describe('assets_audit', () => {
    it('should not cascade user deletes to assets_audit', async () => {
-      const user = mediumFactory.userInsert();
-      const asset = mediumFactory.assetInsert({ ownerId: user.id });
-
-      await userRepo.create(user);
-      await assetRepo.create(asset);
+      const userRepo = ctx.get(UserRepository);
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
      await userRepo.delete(user, true);
-
      await expect(
-        defaultDatabase.selectFrom('assets_audit').select(['id']).where('assetId', '=', asset.id).execute(),
+        ctx.database.selectFrom('assets_audit').select(['id']).where('assetId', '=', asset.id).execute(),
      ).resolves.toHaveLength(0);
    });
  });

  describe('exif', () => {
    it('should automatically set updatedAt and updateId when the row is updated', async () => {
-      const user = mediumFactory.userInsert();
-      const asset = mediumFactory.assetInsert({ ownerId: user.id });
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, make: 'Canon' });

-      await userRepo.create(user);
-      await assetRepo.create(asset);
-      await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' });
-
-      const before = await defaultDatabase
+      const before = await ctx.database
        .selectFrom('exif')
        .select(['updatedAt', 'updateId'])
        .where('assetId', '=', asset.id)
        .executeTakeFirstOrThrow();

-      await assetRepo.upsertExif({ assetId: asset.id, make: 'Canon 2' });
+      await ctx.newExif({ assetId: asset.id, make: 'Canon 2' });

-      const after = await defaultDatabase
+      const after = await ctx.database
        .selectFrom('exif')
        .select(['updatedAt', 'updateId'])
        .where('assetId', '=', asset.id)
@@ -2,71 +2,66 @@ import { Kysely } from 'kysely';
 import { DateTime } from 'luxon';
 import { DB } from 'src/db';
 import { AssetFileType } from 'src/enum';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { DatabaseRepository } from 'src/repositories/database.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { MemoryRepository } from 'src/repositories/memory.repository';
+import { PartnerRepository } from 'src/repositories/partner.repository';
+import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
 import { UserRepository } from 'src/repositories/user.repository';
 import { MemoryService } from 'src/services/memory.service';
-import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { newMediumService } from 'test/medium.factory';
 import { getKyselyDB } from 'test/utils';

+let defaultDatabase: Kysely<DB>;
+
+const setup = (db?: Kysely<DB>) => {
+  return newMediumService(MemoryService, {
+    database: db || defaultDatabase,
+    real: [
+      AssetRepository,
+      DatabaseRepository,
+      MemoryRepository,
+      UserRepository,
+      SystemMetadataRepository,
+      UserRepository,
+      PartnerRepository,
+    ],
+    mock: [LoggingRepository],
+  });
+};
+
 describe(MemoryService.name, () => {
-  let defaultDatabase: Kysely<DB>;
-
-  const createSut = (db?: Kysely<DB>) => {
-    return newMediumService(MemoryService, {
-      database: db || defaultDatabase,
-      repos: {
-        asset: 'real',
-        database: 'real',
-        memory: 'real',
-        user: 'real',
-        systemMetadata: 'real',
-        partner: 'real',
-      },
-    });
-  };
-
  beforeEach(async () => {
    defaultDatabase = await getKyselyDB();
-    const userRepo = new UserRepository(defaultDatabase);
-    const admin = mediumFactory.userInsert({ isAdmin: true });
-    await userRepo.create(admin);
  });

  describe('onMemoryCreate', () => {
    it('should work on an empty database', async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      await expect(sut.onMemoriesCreate()).resolves.not.toThrow();
    });

    it('should create a memory from an asset', async () => {
-      const { sut, repos, getRepository } = createSut();
-
+      const { sut, ctx } = setup();
+      const assetRepo = ctx.get(AssetRepository);
+      const memoryRepo = ctx.get(MemoryRepository);
      const now = DateTime.fromObject({ year: 2025, month: 2, day: 25 }, { zone: 'utc' }) as DateTime<true>;
-      const user = mediumFactory.userInsert();
-      const asset = mediumFactory.assetInsert({
-        ownerId: user.id,
-        localDateTime: now.minus({ years: 1 }).toISO(),
-      });
-      const jobStatus = mediumFactory.assetJobStatusInsert({ assetId: asset.id });
-
-      const userRepo = getRepository('user');
-      const assetRepo = getRepository('asset');
-
-      await userRepo.create(user);
-      await assetRepo.create(asset);
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id, localDateTime: now.minus({ years: 1 }).toISO() });
      await Promise.all([
-        assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' }),
+        ctx.newExif({ assetId: asset.id, make: 'Canon' }),
+        ctx.newJobStatus({ assetId: asset.id }),
        assetRepo.upsertFiles([
          { assetId: asset.id, type: AssetFileType.PREVIEW, path: '/path/to/preview.jpg' },
          { assetId: asset.id, type: AssetFileType.THUMBNAIL, path: '/path/to/thumbnail.jpg' },
        ]),
-        assetRepo.upsertJobStatus(jobStatus),
      ]);

      vi.setSystemTime(now.toJSDate());
-
      await sut.onMemoriesCreate();

-      const memories = await repos.memory.search(user.id, {});
+      const memories = await memoryRepo.search(user.id, {});
      expect(memories.length).toBe(1);
      expect(memories[0]).toEqual(
        expect.objectContaining({
@@ -88,16 +83,11 @@ describe(MemoryService.name, () => {
    });

    it('should not generate a memory twice for the same day', async () => {
-      const { sut, repos, getRepository } = createSut();
-
+      const { sut, ctx } = setup();
+      const assetRepo = ctx.get(AssetRepository);
+      const memoryRepo = ctx.get(MemoryRepository);
      const now = DateTime.fromObject({ year: 2025, month: 2, day: 20 }, { zone: 'utc' }) as DateTime<true>;
-
-      const assetRepo = getRepository('asset');
-      const memoryRepo = getRepository('memory');
-
-      const user = mediumFactory.userInsert();
-      await repos.user.create(user);
-
+      const { user } = await ctx.newUser();
      for (const dto of [
        {
          ownerId: user.id,
@@ -112,11 +102,10 @@ describe(MemoryService.name, () => {
          localDateTime: now.minus({ year: 1 }).plus({ days: 5 }).toISO(),
        },
      ]) {
-        const asset = mediumFactory.assetInsert(dto);
-        await assetRepo.create(asset);
+        const { asset } = await ctx.newAsset(dto);
        await Promise.all([
-          assetRepo.upsertExif({ assetId: asset.id, make: 'Canon' }),
-          assetRepo.upsertJobStatus(mediumFactory.assetJobStatusInsert({ assetId: asset.id })),
+          ctx.newExif({ assetId: asset.id, make: 'Canon' }),
+          ctx.newJobStatus({ assetId: asset.id }),
          assetRepo.upsertFiles([
            { assetId: asset.id, type: AssetFileType.PREVIEW, path: '/path/to/preview.jpg' },
            { assetId: asset.id, type: AssetFileType.THUMBNAIL, path: '/path/to/thumbnail.jpg' },
@@ -125,13 +114,13 @@ describe(MemoryService.name, () => {
      }

      vi.setSystemTime(now.toJSDate());
-
      await sut.onMemoriesCreate();

      const memories = await memoryRepo.search(user.id, {});
      expect(memories.length).toBe(1);

      await sut.onMemoriesCreate();
+
      const memoriesAfter = await memoryRepo.search(user.id, {});
      expect(memoriesAfter.length).toBe(1);
    });
@@ -139,7 +128,7 @@ describe(MemoryService.name, () => {

  describe('onMemoriesCleanup', () => {
    it('should run without error', async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      await expect(sut.onMemoriesCleanup()).resolves.not.toThrow();
    });
  });
@@ -1,90 +1,80 @@
 import { Kysely } from 'kysely';
 import { DB } from 'src/db';
+import { AccessRepository } from 'src/repositories/access.repository';
+import { DatabaseRepository } from 'src/repositories/database.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { PersonRepository } from 'src/repositories/person.repository';
+import { StorageRepository } from 'src/repositories/storage.repository';
 import { PersonService } from 'src/services/person.service';
-import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { newMediumService } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
 import { getKyselyDB } from 'test/utils';

-describe.concurrent(PersonService.name, () => {
-  let defaultDatabase: Kysely<DB>;
+let defaultDatabase: Kysely<DB>;

-  const createSut = (db?: Kysely<DB>) => {
-    return newMediumService(PersonService, {
-      database: db || defaultDatabase,
-      repos: {
-        access: 'real',
-        database: 'real',
-        person: 'real',
-        storage: 'mock',
-      },
-    });
-  };
-
-  beforeEach(async () => {
-    defaultDatabase = await getKyselyDB();
+const setup = (db?: Kysely<DB>) => {
+  return newMediumService(PersonService, {
+    database: db || defaultDatabase,
+    real: [AccessRepository, DatabaseRepository, PersonRepository],
+    mock: [LoggingRepository, StorageRepository],
  });
+};

+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(PersonService.name, () => {
  describe('delete', () => {
    it('should throw an error when there is no access', async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      const auth = factory.auth();
      const personId = factory.uuid();
      await expect(sut.delete(auth, personId)).rejects.toThrow('Not found or no person.delete access');
    });

    it('should delete the person', async () => {
-      const { sut, getRepository, mocks } = createSut();
-
-      const user = mediumFactory.userInsert();
+      const { sut, ctx } = setup();
+      const personRepo = ctx.get(PersonRepository);
+      const storageMock = ctx.getMock(StorageRepository);
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
      const auth = factory.auth({ user });
-      const person = mediumFactory.personInsert({ ownerId: auth.user.id });
-      mocks.storage.unlink.mockResolvedValue();
-
-      const userRepo = getRepository('user');
-      await userRepo.create(user);
-
-      const personRepo = getRepository('person');
-      await personRepo.create(person);
+      storageMock.unlink.mockResolvedValue();

      await expect(personRepo.getById(person.id)).resolves.toEqual(expect.objectContaining({ id: person.id }));
      await expect(sut.delete(auth, person.id)).resolves.toBeUndefined();
      await expect(personRepo.getById(person.id)).resolves.toBeUndefined();

-      expect(mocks.storage.unlink).toHaveBeenCalledWith(person.thumbnailPath);
+      expect(storageMock.unlink).toHaveBeenCalledWith(person.thumbnailPath);
    });
  });

  describe('deleteAll', () => {
    it('should throw an error when there is no access', async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      const auth = factory.auth();
      const personId = factory.uuid();
      await expect(sut.deleteAll(auth, { ids: [personId] })).rejects.toThrow('Not found or no person.delete access');
    });

    it('should delete the person', async () => {
-      const { sut, getRepository, mocks } = createSut();
-
-      const user = mediumFactory.userInsert();
+      const { sut, ctx } = setup();
+      const storageMock = ctx.getMock(StorageRepository);
+      const personRepo = ctx.get(PersonRepository);
+      const { user } = await ctx.newUser();
+      const { person: person1 } = await ctx.newPerson({ ownerId: user.id });
+      const { person: person2 } = await ctx.newPerson({ ownerId: user.id });
      const auth = factory.auth({ user });
-      const person1 = mediumFactory.personInsert({ ownerId: auth.user.id });
-      const person2 = mediumFactory.personInsert({ ownerId: auth.user.id });
-      mocks.storage.unlink.mockResolvedValue();
-
-      const userRepo = getRepository('user');
-      await userRepo.create(user);
-
-      const personRepo = getRepository('person');
-      await personRepo.create(person1);
-      await personRepo.create(person2);
+      storageMock.unlink.mockResolvedValue();

      await expect(sut.deleteAll(auth, { ids: [person1.id, person2.id] })).resolves.toBeUndefined();
      await expect(personRepo.getById(person1.id)).resolves.toBeUndefined();
      await expect(personRepo.getById(person2.id)).resolves.toBeUndefined();

-      expect(mocks.storage.unlink).toHaveBeenCalledTimes(2);
-      expect(mocks.storage.unlink).toHaveBeenCalledWith(person1.thumbnailPath);
-      expect(mocks.storage.unlink).toHaveBeenCalledWith(person2.thumbnailPath);
+      expect(storageMock.unlink).toHaveBeenCalledTimes(2);
+      expect(storageMock.unlink).toHaveBeenCalledWith(person1.thumbnailPath);
+      expect(storageMock.unlink).toHaveBeenCalledWith(person2.thumbnailPath);
    });
  });
 });
@@ -2,72 +2,65 @@ import { Kysely } from 'kysely';
 import { DateTime } from 'luxon';
 import { DB } from 'src/db';
 import { ImmichEnvironment, JobName, JobStatus } from 'src/enum';
+import { ConfigRepository } from 'src/repositories/config.repository';
+import { CryptoRepository } from 'src/repositories/crypto.repository';
+import { JobRepository } from 'src/repositories/job.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
+import { UserRepository } from 'src/repositories/user.repository';
 import { UserService } from 'src/services/user.service';
 import { mediumFactory, newMediumService } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
 import { getKyselyDB } from 'test/utils';

-describe(UserService.name, () => {
-  let defaultDatabase: Kysely<DB>;
+let defaultDatabase: Kysely<DB>;

-  const createSut = (db?: Kysely<DB>) => {
-    process.env.IMMICH_ENV = ImmichEnvironment.TESTING;
+const setup = (db?: Kysely<DB>) => {
+  process.env.IMMICH_ENV = ImmichEnvironment.TESTING;

-    return newMediumService(UserService, {
-      database: db || defaultDatabase,
-      repos: {
-        user: 'real',
-        crypto: 'real',
-        config: 'real',
-        job: 'mock',
-        systemMetadata: 'real',
-      },
-    });
-  };
-
-  beforeAll(async () => {
-    defaultDatabase = await getKyselyDB();
-    const { repos } = createSut();
-    await repos.user.create({ isAdmin: true, email: 'admin@immich.cloud' });
+  return newMediumService(UserService, {
+    database: db || defaultDatabase,
+    real: [CryptoRepository, ConfigRepository, SystemMetadataRepository, UserRepository],
+    mock: [LoggingRepository, JobRepository],
  });
+};

+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+  const { ctx } = setup();
+  await ctx.newUser({ isAdmin: true, email: 'admin@immich.cloud' });
+});
+
+describe(UserService.name, () => {
  describe('create', () => {
    it('should create a user', async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      const user = mediumFactory.userInsert();
-
      await expect(sut.createUser({ name: user.name, email: user.email })).resolves.toEqual(
        expect.objectContaining({ name: user.name, email: user.email }),
      );
    });

    it('should reject user with duplicate email', async () => {
-      const { sut } = createSut();
-
+      const { sut } = setup();
      const user = mediumFactory.userInsert();
-
      await expect(sut.createUser({ email: user.email })).resolves.toMatchObject({ email: user.email });
      await expect(sut.createUser({ email: user.email })).rejects.toThrow('User exists');
    });

    it('should not return password', async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      const dto = mediumFactory.userInsert({ password: 'password' });
-
      const user = await sut.createUser({ email: dto.email, password: 'password' });
-
      expect((user as any).password).toBeUndefined();
    });
  });

  describe('search', () => {
    it('should get users', async () => {
-      const { sut, repos } = createSut();
-      const user1 = mediumFactory.userInsert();
-      const user2 = mediumFactory.userInsert();
-
-      await Promise.all([repos.user.create(user1), repos.user.create(user2)]);
-
+      const { sut, ctx } = setup();
+      const { user: user1 } = await ctx.newUser();
+      const { user: user2 } = await ctx.newUser();
      const auth = factory.auth({ user: user1 });

      await expect(sut.search(auth)).resolves.toEqual(
@@ -81,10 +74,8 @@ describe(UserService.name, () => {

  describe('get', () => {
    it('should get a user', async () => {
-      const { sut, repos } = createSut();
-      const user = mediumFactory.userInsert();
-
-      await repos.user.create(user);
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();

      await expect(sut.get(user.id)).resolves.toEqual(
        expect.objectContaining({
@@ -96,11 +87,8 @@ describe(UserService.name, () => {
    });

    it('should not return password', async () => {
-      const { sut, repos } = createSut();
-      const user = mediumFactory.userInsert();
-
-      await repos.user.create(user);
-
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
      const result = await sut.get(user.id);

      expect((result as any).password).toBeUndefined();
@@ -109,10 +97,9 @@ describe(UserService.name, () => {

  describe('updateMe', () => {
    it('should update a user', async () => {
-      const { sut, repos: repositories } = createSut();
-
-      const before = await repositories.user.create(mediumFactory.userInsert());
-      const auth = factory.auth({ user: { id: before.id } });
+      const { sut, ctx } = setup();
+      const { user, result: before } = await ctx.newUser();
+      const auth = factory.auth({ user: { id: user.id } });
      const after = await sut.updateMe(auth, { name: `${before.name} Updated` });

      expect(before.updatedAt).toBeDefined();
@@ -128,17 +115,13 @@ describe(UserService.name, () => {
        activationKey:
          'KuX8KsktrBSiXpQMAH0zLgA5SpijXVr_PDkzLdWUlAogCTMBZ0I3KCHXK0eE9EEd7harxup8_EHMeqAWeHo5VQzol6LGECpFv585U9asXD4Zc-UXt3mhJr2uhazqipBIBwJA2YhmUCDy8hiyiGsukDQNu9Rg9C77UeoKuZBWVjWUBWG0mc1iRqfvF0faVM20w53czAzlhaMxzVGc3Oimbd7xi_CAMSujF_2y8QpA3X2fOVkQkzdcH9lV0COejl7IyH27zQQ9HrlrXv3Lai5Hw67kNkaSjmunVBxC5PS0TpKoc9SfBJMaAGWnaDbjhjYUrm-8nIDQnoeEAidDXVAdPw',
      };
-      const { sut, repos } = createSut();
-      const user = mediumFactory.userInsert();
-      await repos.user.create(user);
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
      const auth = factory.auth({ user: { id: user.id } });
-
      await expect(sut.getLicense(auth)).rejects.toThrowError();
      const after = await sut.setLicense(auth, license);
-
      expect(after.licenseKey).toEqual(license.licenseKey);
      expect(after.activationKey).toEqual(license.activationKey);
-
      const getResponse = await sut.getLicense(auth);
      expect(getResponse).toEqual(after);
    });
@@ -146,7 +129,7 @@ describe(UserService.name, () => {

  describe.sequential('handleUserDeleteCheck', () => {
    beforeEach(async () => {
-      const { sut } = createSut();
+      const { sut } = setup();
      // These tests specifically have to be sequential otherwise we hit race conditions with config changes applying in incorrect tests
      const config = await sut.getConfig({ withCache: false });
      config.user.deleteDelay = 7;
@@ -154,52 +137,43 @@ describe(UserService.name, () => {
    });

    it('should work when there are no deleted users', async () => {
-      const { sut, mocks } = createSut();
-      mocks.job.queueAll.mockResolvedValue(void 0);
-
+      const { sut, ctx } = setup();
+      const jobMock = ctx.getMock(JobRepository);
+      jobMock.queueAll.mockResolvedValue(void 0);
      await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
-      expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([]);
+      expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([]);
    });

    it('should work when there is a user to delete', async () => {
-      const { sut, repos, mocks } = createSut(await getKyselyDB());
-      mocks.job.queueAll.mockResolvedValue(void 0);
-      const user = mediumFactory.userInsert({ deletedAt: DateTime.now().minus({ days: 60 }).toJSDate() });
-      await repos.user.create(user);
-
+      const { sut, ctx } = setup(await getKyselyDB());
+      const jobMock = ctx.getMock(JobRepository);
+      const { user } = await ctx.newUser({ deletedAt: DateTime.now().minus({ days: 60 }).toJSDate() });
+      jobMock.queueAll.mockResolvedValue(void 0);
      await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
-      expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([
+      expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([
        { name: JobName.USER_DELETION, data: { id: user.id } },
      ]);
    });

    it('should skip a recently deleted user', async () => {
-      const { sut, repos, mocks } = createSut(await getKyselyDB());
-      mocks.job.queueAll.mockResolvedValue(void 0);
-      const user = mediumFactory.userInsert({ deletedAt: DateTime.now().minus({ days: 5 }).toJSDate() });
-      await repos.user.create(user);
-
+      const { sut, ctx } = setup(await getKyselyDB());
+      const jobMock = ctx.getMock(JobRepository);
+      await ctx.newUser({ deletedAt: DateTime.now().minus({ days: 5 }).toJSDate() });
+      jobMock.queueAll.mockResolvedValue(void 0);
      await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
-      expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([]);
+      expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([]);
    });

    it('should respect a custom user delete delay', async () => {
-      const { sut, repos, mocks } = createSut(await getKyselyDB());
-      mocks.job.queueAll.mockResolvedValue(void 0);
-      const user = mediumFactory.userInsert({ deletedAt: DateTime.now().minus({ days: 25 }).toJSDate() });
-      await repos.user.create(user);
-
+      const { sut, ctx } = setup(await getKyselyDB());
+      const jobMock = ctx.getMock(JobRepository);
+      await ctx.newUser({ deletedAt: DateTime.now().minus({ days: 25 }).toJSDate() });
+      jobMock.queueAll.mockResolvedValue(void 0);
      const config = await sut.getConfig({ withCache: false });
      config.user.deleteDelay = 30;
-
      await sut.updateConfig(config);
-
      await expect(sut.handleUserDeleteCheck()).resolves.toEqual(JobStatus.SUCCESS);
-
-      expect(mocks.job.queueAll).toHaveBeenCalledExactlyOnceWith([]);
+      expect(jobMock.queueAll).toHaveBeenCalledExactlyOnceWith([]);
    });
  });
 });
@@ -2,38 +2,40 @@ import { Kysely } from 'kysely';
 import { serverVersion } from 'src/constants';
 import { DB } from 'src/db';
 import { JobName } from 'src/enum';
+import { DatabaseRepository } from 'src/repositories/database.repository';
+import { JobRepository } from 'src/repositories/job.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
 import { VersionService } from 'src/services/version.service';
 import { newMediumService } from 'test/medium.factory';
 import { getKyselyDB } from 'test/utils';

-describe(VersionService.name, () => {
-  let defaultDatabase: Kysely<DB>;
+let defaultDatabase: Kysely<DB>;

-  const setup = (db?: Kysely<DB>) => {
-    return newMediumService(VersionService, {
-      database: db || defaultDatabase,
-      repos: {
-        job: 'mock',
-        database: 'real',
-        versionHistory: 'real',
-      },
-    });
-  };
-
-  beforeAll(async () => {
-    defaultDatabase = await getKyselyDB();
+const setup = (db?: Kysely<DB>) => {
+  return newMediumService(VersionService, {
+    database: db || defaultDatabase,
+    real: [DatabaseRepository, VersionHistoryRepository],
+    mock: [LoggingRepository, JobRepository],
  });
+};

+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(VersionService.name, () => {
  describe('onBootstrap', () => {
    it('record the current version on startup', async () => {
-      const { sut, repos } = setup();
+      const { sut, ctx } = setup();
+      const versionHistoryRepo = ctx.get(VersionHistoryRepository);

-      const itemsBefore = await repos.versionHistory.getAll();
+      const itemsBefore = await versionHistoryRepo.getAll();
      expect(itemsBefore).toHaveLength(0);

      await sut.onBootstrap();

-      const itemsAfter = await repos.versionHistory.getAll();
+      const itemsAfter = await versionHistoryRepo.getAll();
      expect(itemsAfter).toHaveLength(1);
      expect(itemsAfter[0]).toEqual({
        createdAt: expect.any(Date),
@@ -43,22 +45,26 @@ describe(VersionService.name, () => {
    });

    it('should queue memory creation when upgrading from 1.128.0', async () => {
-      const { sut, repos, mocks } = setup();
-      mocks.job.queue.mockResolvedValue(void 0);
+      const { sut, ctx } = setup();
+      const jobMock = ctx.getMock(JobRepository);
+      const versionHistoryRepo = ctx.get(VersionHistoryRepository);
+      jobMock.queue.mockResolvedValue(void 0);

-      await repos.versionHistory.create({ version: 'v1.128.0' });
+      await versionHistoryRepo.create({ version: 'v1.128.0' });
      await sut.onBootstrap();

-      expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.MEMORIES_CREATE });
+      expect(jobMock.queue).toHaveBeenCalledWith({ name: JobName.MEMORIES_CREATE });
    });

    it('should not queue memory creation when upgrading from 1.129.0', async () => {
-      const { sut, repos, mocks } = setup();
+      const { sut, ctx } = setup();
+      const jobMock = ctx.getMock(JobRepository);
+      const versionHistoryRepo = ctx.get(VersionHistoryRepository);

-      await repos.versionHistory.create({ version: 'v1.129.0' });
+      await versionHistoryRepo.create({ version: 'v1.129.0' });
      await sut.onBootstrap();

-      expect(mocks.job.queue).not.toHaveBeenCalled();
+      expect(jobMock.queue).not.toHaveBeenCalled();
    });
  });
 });