ApiCore/ApiCore-Backend/src/tasks/tasks.service.spec.ts

import { NotFoundException } from '@nestjs/common';
import { TasksService } from './tasks.service';
import { PrismaService } from '../prisma/prisma.service';
import { AuditLogService } from '../audit/audit-log.service';
import { WebhooksService } from '../webhooks/webhooks.service';

describe('TasksService', () => {
  let service: TasksService;
  let prisma: {
    task: {
      findMany: jest.Mock;
      findUnique: jest.Mock;
      create: jest.Mock;
      update: jest.Mock;
    };
  };
  let auditLog: { record: jest.Mock };

  const task = { id: 'task-1', title: 'Beute prüfen', status: 'OPEN' };

  beforeEach(() => {
    prisma = {
      task: {
        findMany: jest.fn(),
        findUnique: jest.fn(),
        create: jest.fn(),
        update: jest.fn(),
      },
    };
    auditLog = { record: jest.fn() };
    const webhooks = { dispatch: jest.fn().mockResolvedValue(undefined) };
    service = new TasksService(
      prisma as unknown as PrismaService,
      auditLog as unknown as AuditLogService,
      webhooks as unknown as WebhooksService,
    );
  });

  it('findById throws NotFoundException when missing', async () => {
    prisma.task.findUnique.mockResolvedValue(null);
    await expect(service.findById('missing')).rejects.toBeInstanceOf(
      NotFoundException,
    );
  });

  it('create stores the acting user as creator', async () => {
    prisma.task.create.mockResolvedValue(task);

    await service.create({ title: 'Beute prüfen' }, 'user-1');

    const [[createArg]] = prisma.task.create.mock.calls as [
      [{ data: { title: string; createdByUserId: string } }],
    ];
    expect(createArg.data.title).toBe('Beute prüfen');
    expect(createArg.data.createdByUserId).toBe('user-1');
  });

  it('complete sets status DONE and completedAt', async () => {
    prisma.task.findUnique.mockResolvedValue(task);
    prisma.task.update.mockResolvedValue({ ...task, status: 'DONE' });

    await service.complete('task-1', 'user-1');

    const [[updateArg]] = prisma.task.update.mock.calls as [
      [{ data: { status: string; completedAt: Date } }],
    ];
    expect(updateArg.data.status).toBe('DONE');
    expect(updateArg.data.completedAt).toBeInstanceOf(Date);
  });
});