Тестування pipes

// parse-positive-int.pipe.spec.ts
import {
  BadRequestException,
  ArgumentMetadata,
} from '@nestjs/common';
import { ParsePositiveIntPipe } from './parse-positive-int.pipe';

describe('ParsePositiveIntPipe', () => {
  const pipe = new ParsePositiveIntPipe();

  const metadata: ArgumentMetadata = {
    type: 'param',
    data: 'id',
    metatype: Number,
  };

  it('перетворює рядок на додатне ціле число', () => {
    const result = pipe.transform('42', metadata);

    expect(result).toBe(42);
    expect(typeof result).toBe('number');
  });

  it.each(['0', '-5', '1.5', 'abc', ''])(
    'кидає BadRequestException для значення "%s"',
    (value) => {
      expect(() => pipe.transform(value, metadata)).toThrow(
        BadRequestException,
      );
    },
  );
});

it('повертає статус 400 для невалідного значення', () => {
  try {
    pipe.transform('not-a-number', metadata);
    fail('Очікувався виняток');
  } catch (error) {
    expect(error).toBeInstanceOf(BadRequestException);

    const exception = error as BadRequestException;

    expect(exception.getStatus()).toBe(400);
    expect(exception.getResponse()).toMatchObject({
      message: 'Значення має бути додатним цілим числом',
      statusCode: 400,
    });
  }
});

import {
  ArgumentMetadata,
  BadRequestException,
  ParseIntPipe,
} from '@nestjs/common';

describe('ParseIntPipe', () => {
  const pipe = new ParseIntPipe();

  const metadata: ArgumentMetadata = {
    type: 'param',
    data: 'userId',
    metatype: Number,
  };

  it('перетворює коректний рядок на число', () => {
    expect(pipe.transform('17', metadata)).toBe(17);
  });

  it('кидає BadRequestException для некоректного числа', () => {
    expect(() => pipe.transform('17abc', metadata)).toThrow(
      BadRequestException,
    );
  });

  it('кидає BadRequestException для порожнього значення', () => {
    expect(() => pipe.transform('', metadata)).toThrow(
      BadRequestException,
    );
  });
});

// create-user.dto.ts
import { Type } from 'class-transformer';
import { IsInt, IsString, Min, MinLength } from 'class-validator';

export class CreateUserDto {
  @IsString()
  @MinLength(2)
  name!: string;

  @Type(() => Number)
  @IsInt()
  @Min(18)
  age!: number;
}

// validation.pipe.spec.ts
import {
  ArgumentMetadata,
  BadRequestException,
  ValidationPipe,
} from '@nestjs/common';
import { CreateUserDto } from './create-user.dto';

describe('ValidationPipe', () => {
  const metadata: ArgumentMetadata = {
    type: 'body',
    metatype: CreateUserDto,
    data: '',
  };

  it('трансформує та повертає екземпляр DTO', async () => {
    const pipe = new ValidationPipe({
      transform: true,
      whitelist: true,
    });

    const result = await pipe.transform(
      {
        name: 'Olena',
        age: '21',
        extra: 'буде видалено',
      },
      metadata,
    );

    expect(result).toBeInstanceOf(CreateUserDto);
    expect(result.name).toBe('Olena');
    expect(result.age).toBe(21);
    expect(typeof result.age).toBe('number');
    expect(result.extra).toBeUndefined();
  });

  it('відхиляє невалідні дані', async () => {
    const pipe = new ValidationPipe({
      transform: true,
      whitelist: true,
    });

    await expect(
      pipe.transform(
        {
          name: 'O',
          age: 'abc',
        },
        metadata,
      ),
    ).rejects.toBeInstanceOf(BadRequestException);
  });
});

it('повертає помилки для кожного невалідного поля', async () => {
  const pipe = new ValidationPipe({
    transform: true,
    whitelist: true,
  });

  let error: unknown;

  try {
    await pipe.transform(
      {
        name: 'A',
        age: 'abc',
      },
      metadata,
    );
  } catch (caughtError) {
    error = caughtError;
  }

  expect(error).toBeInstanceOf(BadRequestException);

  const exception = error as BadRequestException;
  const response = exception.getResponse() as {
    message: string[];
    statusCode: number;
  };

  expect(exception.getStatus()).toBe(400);
  expect(response.statusCode).toBe(400);
  expect(response.message).toEqual(
    expect.arrayContaining([
      expect.stringContaining('name'),
      expect.stringContaining('age'),
    ]),
  );
});

it('видаляє властивості, яких немає в DTO', async () => {
  const pipe = new ValidationPipe({
    transform: true,
    whitelist: true,
  });

  const result = await pipe.transform(
    {
      name: 'Olena',
      age: '25',
      role: 'admin',
    },
    metadata,
  );

  expect(result).toEqual({
    name: 'Olena',
    age: 25,
  });
});

it('відхиляє зайві властивості', async () => {
  const pipe = new ValidationPipe({
    transform: true,
    whitelist: true,
    forbidNonWhitelisted: true,
  });

  await expect(
    pipe.transform(
      {
        name: 'Olena',
        age: '25',
        role: 'admin',
      },
      metadata,
    ),
  ).rejects.toBeInstanceOf(BadRequestException);
});

import { Test } from '@nestjs/testing';

describe('UserExistsPipe', () => {
  it('може отримати mock-залежність через TestingModule', async () => {
    const usersService = {
      exists: jest.fn().mockResolvedValue(true),
    };

    const moduleRef = await Test.createTestingModule({
      providers: [
        UserExistsPipe,
        {
          provide: UsersService,
          useValue: usersService,
        },
      ],
    }).compile();

    const pipe = moduleRef.get(UserExistsPipe);

    const result = await pipe.transform('user-1', {
      type: 'param',
      data: 'userId',
      metatype: String,
    });

    expect(result).toBe('user-1');
    expect(usersService.exists).toHaveBeenCalledWith('user-1');
  });
});

expect(pipe.transform(value, metadata)).toThrow();

await expect(
  pipe.transform(value, metadata),
).rejects.toBeInstanceOf(BadRequestException);