@koalarx/nest 3.1.50 → 4.0.2

package/koala-nest/src/test/application/delete-person.handler.spec.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'bun:test';
+import { NotFoundException } from '@nestjs/common';
+import { DeletePersonHandler } from '@/application/person/delete/delete-person.handler';
+import { Person } from '@/domain/entities/person/person';
+import { PERSON_LIST_CACHE_PREFIX } from '@/core/utils/person-list-cache';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { CacheStub } from '@/test/services/cache.stub';
+
+describe('DeletePersonHandler', () => {
+  it('remove pessoa existente e invalida cache', async () => {
+    const cache = new CacheStub();
+    const person = Person.from({
+      id: 1,
+      name: 'Jane',
+      active: true,
+      address: undefined,
+      contacts: [],
+    });
+
+    const deleted: Person[] = [];
+
+    const repository = {
+      findById: async () => person,
+      delete: async (entity: Person) => {
+        deleted.push(entity);
+      },
+    } as unknown as IPersonRepository;
+
+    const handler = new DeletePersonHandler(repository, cache);
+    await handler.handle(1);
+
+    expect(deleted).toEqual([person]);
+    expect(cache.invalidateByPrefixCalls).toEqual([PERSON_LIST_CACHE_PREFIX]);
+  });
+
+  it('lança NotFoundException quando a pessoa não existe', async () => {
+    const repository = {
+      findById: async () => null,
+      delete: async () => undefined,
+    } as unknown as IPersonRepository;
+
+    const handler = new DeletePersonHandler(repository, new CacheStub());
+
+    await expect(handler.handle(99)).rejects.toBeInstanceOf(NotFoundException);
+  });
+});

package/koala-nest/src/test/application/exchange-code.handler.spec.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'bun:test';
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { OAuthExchangeCodeHandler } from '@/application/auth/oauth2/exchange-code/exchange-code.handler';
+import { UserStatus } from '@/domain/entities/user/enums/user-status.enum';
+import { User } from '@/domain/entities/user/user';
+import type {
+  IOAuth2Service,
+  IJwtTokenService,
+} from '@/domain/auth/services/iauth.service';
+import type { IUserRepository } from '@/domain/repositories/iuser.repository';
+
+describe('OAuthExchangeCodeHandler', () => {
+  it('cria usuário quando necessário e retorna par de tokens JWT', async () => {
+    const oauth2Service = {
+      exchangeCode: async (provider: string, code: string, state: string) => ({
+        email: `${provider}-${code}@example.com`,
+        login: state,
+        name: 'OAuth User',
+        profile: AuthProfile.user,
+      }),
+    } as IOAuth2Service;
+
+    const savedUser = Object.assign(new User(), {
+      id: 'user-oauth-1',
+      email: 'google-auth-code@example.com',
+      login: 'oauth.user',
+      name: 'OAuth User',
+      profile: AuthProfile.user,
+      status: UserStatus.active,
+      password: 'hashed',
+    });
+
+    const userRepository = {
+      getByEmail: async () => null,
+      getByLogin: async () => null,
+      save: async (user: User) => {
+        Object.assign(savedUser, user, { id: 'user-oauth-1' });
+        return savedUser;
+      },
+    } as unknown as IUserRepository;
+
+    const jwtTokenService = {
+      signTokenPair: (claims: { sub: string }) => ({
+        accessToken: `access-${claims.sub}`,
+        refreshToken: `refresh-${claims.sub}`,
+      }),
+    } as unknown as IJwtTokenService;
+
+    const handler = new OAuthExchangeCodeHandler(
+      oauth2Service,
+      userRepository,
+      jwtTokenService,
+    );
+
+    const result = await handler.handle({
+      provider: 'google',
+      code: 'auth-code',
+      state: 'csrf-state',
+      redirectUri: 'http://localhost/callback',
+    });
+
+    expect(result).toEqual({
+      accessToken: 'access-user-oauth-1',
+      refreshToken: 'refresh-user-oauth-1',
+    });
+  });
+});

package/koala-nest/src/test/application/inactive-person.handler.spec.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'bun:test';
+import { InactivePersonHandler } from '@/application/person/jobs/events/person/inactive-person/inactive-person.handler';
+import { InactivePersonEvent } from '@/application/person/jobs/events/person/inactive-person/inactive-person.event';
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import { PERSON_LIST_CACHE_PREFIX } from '@/core/utils/person-list-cache';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { CacheStub } from '@/test/services/cache.stub';
+
+describe('InactivePersonHandler', () => {
+  it('inativa todas as pessoas ativas e invalida cache', async () => {
+    const cache = new CacheStub();
+    const activePerson = Person.from({
+      id: 1,
+      name: 'Jane',
+      active: true,
+      address: PersonAddress.from({ id: 1, address: 'Street' }),
+      contacts: [],
+    });
+
+    const calls = {
+      findMany: [] as Parameters<IPersonRepository['findMany']>,
+      save: [] as Person[],
+    };
+
+    const repository = {
+      findMany: async (query: Parameters<IPersonRepository['findMany']>[0]) => {
+        calls.findMany.push(query);
+        return { items: [activePerson], count: 1 };
+      },
+      findById: async () => null,
+      save: async (person: Person) => {
+        calls.save.push(person);
+        return person;
+      },
+      delete: async () => undefined,
+    } as unknown as IPersonRepository;
+
+    const handler = new InactivePersonHandler(repository, cache);
+
+    await handler.handleEvent(new InactivePersonEvent());
+
+    expect(calls.findMany[0]?.active).toBe(true);
+    expect(activePerson.active).toBe(false);
+    expect(calls.save).toEqual([activePerson]);
+    expect(cache.invalidateByPrefixCalls).toEqual([PERSON_LIST_CACHE_PREFIX]);
+  });
+});

package/koala-nest/src/test/application/login.handler.spec.ts

@@ -0,0 +1,55 @@
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { describe, expect, it } from 'bun:test';
+import { LoginHandler } from '@/application/auth/login/login.handler';
+import { UserStatus } from '@/domain/entities/user/enums/user-status.enum';
+import { User } from '@/domain/entities/user/user';
+import { IUserRepository } from '@/domain/repositories/iuser.repository';
+import { IJwtTokenService } from '@/domain/auth/services/iauth.service';
+import { UnauthorizedException } from '@nestjs/common';
+
+describe('LoginHandler', () => {
+  const user = Object.assign(new User(), {
+    id: 'user-123',
+    email: 'admin@example.com',
+    login: 'admin.demo',
+    password: '$2b$06$eyA412UuUAPsAOBREzXPue1AJW.GLAwjenHRSBVCc1.gB1AcASWo6',
+    profile: AuthProfile.admin,
+    status: UserStatus.active,
+    name: 'Admin Demo',
+  });
+
+  const userRepository = {
+    getByEmail: async (email: string) =>
+      email === 'admin@example.com' ? user : null,
+  } as unknown as IUserRepository;
+
+  const jwtTokenService = {
+    signTokenPair: (claims: { sub: string }) => ({
+      accessToken: `access-${claims.sub}`,
+      refreshToken: `refresh-${claims.sub}`,
+    }),
+  } as unknown as IJwtTokenService;
+
+  const handler = new LoginHandler(userRepository, jwtTokenService);
+
+  it('gera par de tokens com credenciais válidas', async () => {
+    const result = await handler.handle({
+      username: 'admin@example.com',
+      password: 'admin123',
+    });
+
+    expect(result).toEqual({
+      accessToken: 'access-user-123',
+      refreshToken: 'refresh-user-123',
+    });
+  });
+
+  it('rejeita credenciais inválidas', async () => {
+    await expect(
+      handler.handle({
+        username: 'admin@example.com',
+        password: 'wrong-password',
+      }),
+    ).rejects.toThrow(UnauthorizedException);
+  });
+});

package/koala-nest/src/test/application/read-many-person.handler.spec.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it, beforeAll } from 'bun:test';
+import { ReadManyPersonHandler } from '@/application/person/read-many/read-many-person.handler';
+import { ReadManyPersonRequest } from '@/application/person/read-many/read-many-person.request';
+import { PersonMapper } from '@/application/mapping/person.mapper';
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { CacheStub } from '@/test/services/cache.stub';
+
+describe('ReadManyPersonHandler', () => {
+  beforeAll(() => {
+    PersonMapper.createMap();
+  });
+
+  it('lista pessoas com paginação mapeada', async () => {
+    const person = Person.from({
+      id: 1,
+      name: 'Jane',
+      active: true,
+      address: PersonAddress.from({ id: 2, address: 'Street' }),
+      contacts: [],
+    });
+
+    const repository = {
+      findMany: async () => ({ items: [person], count: 1 }),
+    } as unknown as IPersonRepository;
+
+    const handler = new ReadManyPersonHandler(repository, new CacheStub());
+    const result = await handler.handle(new ReadManyPersonRequest());
+
+    expect(result.count).toBe(1);
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].name).toBe('Jane');
+  });
+
+  it('reutiliza cache para a mesma consulta de listagem', async () => {
+    const person = Person.from({
+      id: 1,
+      name: 'Jane',
+      active: true,
+      address: PersonAddress.from({ id: 2, address: 'Street' }),
+      contacts: [],
+    });
+
+    let calls = 0;
+    const repository = {
+      findMany: async () => {
+        calls += 1;
+        return { items: [person], count: 1 };
+      },
+    } as unknown as IPersonRepository;
+
+    const cache = new CacheStub();
+    const handler = new ReadManyPersonHandler(repository, cache);
+    const request = new ReadManyPersonRequest();
+
+    await handler.handle(request);
+    await handler.handle(request);
+
+    expect(calls).toBe(1);
+    expect(cache.store.size).toBe(1);
+    expect([...cache.store.keys()][0]).toContain('person:list:');
+  });
+});

package/koala-nest/src/test/application/read-person.handler.spec.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it, beforeAll } from 'bun:test';
+import { NotFoundException } from '@nestjs/common';
+import { ReadPersonHandler } from '@/application/person/read/read-person.handler';
+import { PersonMapper } from '@/application/mapping/person.mapper';
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+
+describe('ReadPersonHandler', () => {
+  beforeAll(() => {
+    PersonMapper.createMap();
+  });
+
+  it('retorna pessoa mapeada quando encontrada', async () => {
+    const person = Person.from({
+      id: 1,
+      name: 'Jane',
+      active: true,
+      address: PersonAddress.from({ id: 2, address: 'Street' }),
+      contacts: [],
+    });
+
+    const repository = {
+      findById: async (id: number) => (id === 1 ? person : null),
+    } as unknown as IPersonRepository;
+
+    const handler = new ReadPersonHandler(repository);
+    const result = await handler.handle(1);
+
+    expect(result.id).toBe(1);
+    expect(result.name).toBe('Jane');
+    expect(result.address.address).toBe('Street');
+  });
+
+  it('lança NotFoundException quando a pessoa não existe', async () => {
+    const repository = {
+      findById: async () => null,
+    } as unknown as IPersonRepository;
+
+    const handler = new ReadPersonHandler(repository);
+
+    await expect(handler.handle(99)).rejects.toBeInstanceOf(NotFoundException);
+  });
+});

package/koala-nest/src/test/application/refresh-token.handler.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'bun:test';
+import { AuthProfile } from '@/core/auth/auth-profile.enum';
+import { RefreshTokenHandler } from '@/application/auth/refresh-token/refresh-token.handler';
+import { LoggedUserInfoDto } from '@/domain/dtos/logged-user-info.dto';
+import { IJwtTokenService } from '@/domain/auth/services/iauth.service';
+import { LoggedUserInfoFakeService } from '@/test/services/logged-user-info.fake-service';
+
+describe('RefreshTokenHandler', () => {
+  it('emite novo par de tokens a partir do usuário logado', async () => {
+    const jwtTokenService = {
+      signTokenPair: (claims: { sub: string; profile?: AuthProfile }) => ({
+        accessToken: `access-${claims.sub}`,
+        refreshToken: `refresh-${claims.sub}`,
+      }),
+    } as unknown as IJwtTokenService;
+
+    const loggedUserInfo = new LoggedUserInfoFakeService();
+    loggedUserInfo.setContext({
+      user: Object.assign(new LoggedUserInfoDto(), {
+        sub: 'user-1',
+        profile: AuthProfile.admin,
+      }),
+    });
+
+    const handler = new RefreshTokenHandler(jwtTokenService, loggedUserInfo);
+
+    const result = await handler.handle();
+
+    expect(result).toEqual({
+      accessToken: 'access-user-1',
+      refreshToken: 'refresh-user-1',
+    });
+  });
+});

package/koala-nest/src/test/application/scalar-oauth-token.handler.spec.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'bun:test';
+import { ScalarOAuthTokenHandler } from '@/application/auth/oauth2/scalar-token/scalar-oauth-token.handler';
+import { OAuthExchangeCodeHandler } from '@/application/auth/oauth2/exchange-code/exchange-code.handler';
+import { BadRequestException } from '@nestjs/common';
+
+describe('ScalarOAuthTokenHandler', () => {
+  const tokens = {
+    accessToken: 'access-token',
+    refreshToken: 'refresh-token',
+  };
+
+  const exchangeCode = {
+    handle: async () => tokens,
+  } as unknown as OAuthExchangeCodeHandler;
+
+  const handler = new ScalarOAuthTokenHandler(exchangeCode);
+
+  it('delega a troca de code/state para o exchange-code handler', async () => {
+    const result = await handler.handle({
+      provider: 'google',
+      code: 'auth-code',
+      state: 'state-123',
+      redirect_uri: 'http://localhost/callback',
+    });
+
+    expect(result).toEqual(tokens);
+  });
+
+  it('aceita ssoCode e redirectUri como aliases do Scalar', async () => {
+    const result = await handler.handle({
+      provider: 'google',
+      ssoCode: 'auth-code',
+      redirectUri: 'http://localhost/callback',
+    });
+
+    expect(result).toEqual(tokens);
+  });
+
+  it('não exige state (fluxo Scalar authorization code)', async () => {
+    const scalarExchange = {
+      handle: async (request: { state?: string }) => {
+        expect(request.state).toBeUndefined();
+        return tokens;
+      },
+    } as unknown as OAuthExchangeCodeHandler;
+
+    const scalarHandler = new ScalarOAuthTokenHandler(scalarExchange);
+
+    await expect(
+      scalarHandler.handle({
+        provider: 'google',
+        code: 'auth-code',
+        redirect_uri: 'http://localhost/callback',
+      }),
+    ).resolves.toEqual(tokens);
+  });
+
+  it('lança BadRequestException quando provider ou code estão ausentes', async () => {
+    await expect(
+      handler.handle({ provider: 'google', code: '' }),
+    ).rejects.toThrow(BadRequestException);
+  });
+});

package/koala-nest/src/test/application/update-person.handler.spec.ts

@@ -0,0 +1,78 @@
+import { NotFoundException } from '@nestjs/common';
+import { UpdatePersonHandler } from '@/application/person/update/update-person.handler';
+import { Person } from '@/domain/entities/person/person';
+import { PersonAddress } from '@/domain/entities/person/person-address';
+import { PersonContact } from '@/domain/entities/person/person-contact';
+import { PERSON_LIST_CACHE_PREFIX } from '@/core/utils/person-list-cache';
+import type { IPersonRepository } from '@/domain/repositories/iperson.repository';
+import { CacheStub } from '@/test/services/cache.stub';
+
+describe('UpdatePersonHandler', () => {
+  it('carrega a entidade existente antes de salvar e invalida cache', async () => {
+    const cache = new CacheStub();
+    const existingContact = PersonContact.from({
+      id: 10,
+      contact: 'old@example.com',
+      person: undefined as unknown as Person,
+    });
+
+    const person = Person.from({
+      id: 1,
+      name: 'Jane',
+      active: true,
+      address: PersonAddress.from({ id: 5, address: 'Old street' }),
+      contacts: [existingContact],
+    });
+    existingContact.person = person;
+
+    const calls = {
+      findById: [] as number[],
+      save: [] as Person[],
+    };
+
+    const repository = {
+      findById: async (id: number) => {
+        calls.findById.push(id);
+        return id === 1 ? person : null;
+      },
+      save: async (entity: Person) => {
+        calls.save.push(entity);
+        return entity;
+      },
+    } as unknown as IPersonRepository;
+
+    const handler = new UpdatePersonHandler(repository, cache);
+
+    await handler.handle({
+      id: 1,
+      name: 'Jane Updated',
+      address: { id: 5, address: 'New street' },
+      contacts: [{ id: 10, contact: 'new@example.com' }],
+    });
+
+    expect(calls.findById).toEqual([1]);
+    expect(person.name).toBe('Jane Updated');
+    expect(person.address.address).toBe('New street');
+    expect(person.contacts[0].contact).toBe('new@example.com');
+    expect(calls.save).toEqual([person]);
+    expect(cache.invalidateByPrefixCalls).toEqual([PERSON_LIST_CACHE_PREFIX]);
+  });
+
+  it('lança NotFoundException quando a pessoa não existe', async () => {
+    const repository = {
+      findById: async () => null,
+      save: async () => undefined,
+    } as unknown as IPersonRepository;
+
+    const handler = new UpdatePersonHandler(repository, new CacheStub());
+
+    await expect(
+      handler.handle({
+        id: 99,
+        name: 'Ghost',
+        address: { id: 1, address: 'Nowhere' },
+        contacts: [],
+      }),
+    ).rejects.toBeInstanceOf(NotFoundException);
+  });
+});

package/koala-nest/src/test/bun-test-globals.d.ts

@@ -0,0 +1 @@
+/// <reference types="bun-types/test-globals" />

package/koala-nest/src/test/core/auth.guard.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'bun:test';
+import { applyRefreshTokenForRefreshRoute } from '@/core/auth/resolve-refresh-token';
+import { AuthGuard } from '@/host/security/guards/auth.guard';
+import { IS_PUBLIC_KEY } from '@/host/decorators/is-public.decorator';
+import { Reflector } from '@nestjs/core';
+import { ExecutionContext } from '@nestjs/common';
+
+describe('AuthGuard', () => {
+  it('permite acesso em rotas marcadas com @IsPublic', async () => {
+    const reflector = new Reflector();
+    const userRepository = { getById: async () => null } as never;
+    const guard = new AuthGuard(reflector, userRepository);
+    const handler = () => undefined;
+    Reflect.defineMetadata(IS_PUBLIC_KEY, true, handler);
+
+    const context = {
+      getHandler: () => handler,
+      getClass: () => class {},
+      switchToHttp: () => ({
+        getRequest: () => ({ headers: {} }),
+      }),
+    } as unknown as ExecutionContext;
+
+    await expect(guard.canActivate(context)).resolves.toBe(true);
+  });
+
+  it('injeta refreshToken do cookie como Bearer em /auth/refresh', () => {
+    const request = {
+      url: '/auth/refresh',
+      cookies: { refreshToken: 'refresh-from-cookie' },
+      headers: {} as Record<string, string | string[] | undefined>,
+    };
+
+    applyRefreshTokenForRefreshRoute(request);
+
+    expect(request.headers.authorization).toBe('Bearer refresh-from-cookie');
+  });
+
+  it('injeta refreshToken do body como Bearer em /auth/refresh', () => {
+    const request = {
+      url: '/auth/refresh',
+      body: { refresh_token: 'refresh-from-body' },
+      headers: {} as Record<string, string | string[] | undefined>,
+    };
+
+    applyRefreshTokenForRefreshRoute(request);
+
+    expect(request.headers.authorization).toBe('Bearer refresh-from-body');
+  });
+
+  it('não sobrescreve Bearer já presente em /auth/refresh', () => {
+    const request = {
+      url: '/auth/refresh',
+      cookies: { refreshToken: 'refresh-from-cookie' },
+      headers: { authorization: 'Bearer existing-token' },
+    };
+
+    applyRefreshTokenForRefreshRoute(request);
+
+    expect(request.headers.authorization).toBe('Bearer existing-token');
+  });
+
+  it('injeta refresh_token do body mesmo com Authorization Basic (Scalar OAuth)', () => {
+    const request = {
+      url: '/auth/refresh',
+      body: { grant_type: 'refresh_token', refresh_token: 'refresh-oauth' },
+      headers: {
+        authorization:
+          'Basic ' + Buffer.from('client-id:client-secret').toString('base64'),
+      },
+    };
+
+    applyRefreshTokenForRefreshRoute(request);
+
+    expect(request.headers.authorization).toBe('Bearer refresh-oauth');
+  });
+});

package/koala-nest/src/test/core/build-list-cache-key.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'bun:test';
+import { buildListCacheKey } from '@/core/utils/build-list-cache-key';
+
+describe('buildListCacheKey', () => {
+  it('monta chave estável a partir dos filtros da listagem', () => {
+    const key = buildListCacheKey('person:list', {
+      page: 0,
+      limit: 10,
+      name: 'Jane',
+      active: true,
+    });
+
+    expect(key).toBe(
+      'person:list:{"active":true,"limit":10,"name":"Jane","page":0}',
+    );
+  });
+
+  it('ignora métodos e filtros vazios ou nulos', () => {
+    const key = buildListCacheKey('person:list', {
+      page: 0,
+      name: undefined,
+      active: null,
+      orderBy: '',
+      skip: () => 0,
+    });
+
+    expect(key).toBe('person:list:{"page":0}');
+  });
+});

package/koala-nest/src/test/core/cron-expression-to-boolean.spec.ts

@@ -0,0 +1,22 @@
+/// <reference types="bun-types/test-globals" />
+
+import { cronExpressionToBoolean } from '@/core/utils/cron-expression-to-boolean';
+import { describe, expect, it } from 'bun:test';
+
+describe('cronExpressionToBoolean', () => {
+  it('retorna true quando o instante atual coincide com o tick da expressão', () => {
+    const at = new Date(2024, 5, 12, 12, 0, 0, 1);
+
+    expect(cronExpressionToBoolean('0 0 12 * * *', at)).toBe(true);
+  });
+
+  it('retorna false quando o instante atual não coincide com o tick da expressão', () => {
+    const at = new Date(2024, 5, 12, 12, 0, 1);
+
+    expect(cronExpressionToBoolean('0 0 12 * * *', at)).toBe(false);
+  });
+
+  it('retorna false para expressão inválida', () => {
+    expect(cronExpressionToBoolean('not a cron')).toBe(false);
+  });
+});

package/koala-nest/src/test/core/cron-job.handler.spec.ts

@@ -0,0 +1,40 @@
+/// <reference types="bun-types/test-globals" />
+
+import { delay } from '@koalarx/utils/KlDelay';
+import {
+  CronJobHandlerBase,
+  CronJobSettings,
+} from '@/core/background-services/cron-service/cron-job.handler.base';
+import { FakeLoggingService } from '@/test/services/fake-logging.service';
+import { FakeRedLockService } from '@/test/services/fake-red-lock.service';
+import { describe, expect, it, spyOn } from 'bun:test';
+
+class CronJobTest extends CronJobHandlerBase {
+  constructor() {
+    super(new FakeRedLockService(), new FakeLoggingService());
+  }
+
+  protected async settings(): Promise<CronJobSettings> {
+    return { isActive: true, timeInMinutes: 0.01 };
+  }
+
+  static async isCalled(): Promise<void> {
+    return undefined;
+  }
+
+  protected run(): Promise<void> {
+    return CronJobTest.isCalled();
+  }
+}
+
+describe('CronJobHandlerBase', () => {
+  it('executa o callback do job quando ativo', async () => {
+    const callbackSpy = spyOn(CronJobTest, 'isCalled');
+
+    void new CronJobTest().start();
+
+    await delay(100);
+
+    expect(callbackSpy).toHaveBeenCalled();
+  });
+});