{
  "name": "my-nestjs-app",
  "version": "1.0.0",
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:cov": "jest --coverage",
    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand"
  },
  "jest": {
    "moduleFileExtensions": ["js", "json", "ts"],
    "rootDir": "src",
    "testRegex": ".*\\.spec\\.ts$",
    "transform": {
      "^.+\\.(t|j)s$": "ts-jest"
    },
    "collectCoverageFrom": [
      "**/*.(t|j)s"
    ],
    "coverageDirectory": "../coverage",
    "testEnvironment": "node"
  }
}

src/
├── user/
│   ├── user.controller.ts
│   ├── user.controller.spec.ts      ← Unit тест контролера
│   ├── user.service.ts
│   ├── user.service.spec.ts         ← Unit тест сервісу
│   ├── user.entity.ts
│   ├── user.module.ts
│   └── dto/
│       ├── create-user.dto.ts
│       └── create-user.dto.spec.ts  ← Тести для DTO валідації
└── app.module.ts

test/
├── app.e2e-spec.ts
├── auth.e2e-spec.ts
└── users.e2e-spec.ts

// validators/email.validator.ts
export function isValidEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

// validators/email.validator.spec.ts
import { isValidEmail } from './email.validator';

describe('isValidEmail', () => {
  it('should return true for valid email addresses', () => {
    expect(isValidEmail('user@example.com')).toBe(true);
    expect(isValidEmail('test.user+tag@domain.co.uk')).toBe(true);
  });

  it('should return false for emails without @ symbol', () => {
    expect(isValidEmail('invalid.email.com')).toBe(false);
  });

  it('should return false for emails without domain', () => {
    expect(isValidEmail('user@')).toBe(false);
  });

  it('should return false for empty string', () => {
    expect(isValidEmail('')).toBe(false);
  });
});

describe('UserService', () => {
  describe('registerUser', () => {
    it('should hash password before saving', () => { /* ... */ });
    it('should throw error if email exists', () => { /* ... */ });
  });

  describe('updateProfile', () => {
    it('should update user name', () => { /* ... */ });
    it('should not update email if already taken', () => { /* ... */ });
  });
});

// Strict equality (використовує ===)
expect(2 + 2).toBe(4);
expect('hello').toBe('hello');
expect(true).toBe(true);

// Truthy/Falsy перевірки
expect('non-empty string').toBeTruthy();
expect(0).toBeFalsy();
expect(null).toBeFalsy();
expect(undefined).toBeUndefined();
expect(value).toBeDefined();
expect(null).toBeNull();

// Числові порівняння
expect(10).toBeGreaterThan(5);
expect(10).toBeGreaterThanOrEqual(10);
expect(5).toBeLessThan(10);
expect(0.1 + 0.2).toBeCloseTo(0.3); // Для floating point

// Deep equality (рекурсивно порівнює структуру)
expect({ name: 'John', age: 30 }).toEqual({ name: 'John', age: 30 });

// Часткове співпадіння (об'єкт містить вказані властивості)
expect({ name: 'John', age: 30, city: 'Kyiv' }).toMatchObject({ 
  name: 'John', 
  age: 30 
});

// Масиви
expect([1, 2, 3]).toHaveLength(3);
expect(['apple', 'banana', 'orange']).toContain('banana');
expect([1, 2, 3]).toEqual(expect.arrayContaining([2, 1])); // Порядок не важливий

// Перевірка, що функція викидає помилку
expect(() => {
  throw new Error('Something went wrong');
}).toThrow();

expect(() => {
  throw new Error('User not found');
}).toThrow('User not found');

expect(() => {
  throw new NotFoundException('User not found');
}).toThrow(NotFoundException);

# Запуск всіх тестів один раз
npm test

# Watch mode: автоматичний перезапуск при змінах
npm run test:watch

# Запуск з code coverage звітом
npm run test:cov

# Запуск тестів для конкретного файлу
npm test user.service.spec.ts

// user/user.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

  async findById(id: string): Promise<User> {
    const user = await this.userRepository.findOne({ where: { id } });
    
    if (!user) {
      throw new NotFoundException(`User with ID ${id} not found`);
    }
    
    return user;
  }

  async createUser(email: string, name: string): Promise<User> {
    const user = this.userRepository.create({ email, name });
    return this.userRepository.save(user);
  }
}

// user/user.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { NotFoundException } from '@nestjs/common';
import { UserService } from './user.service';
import { User } from './user.entity';
import { Repository } from 'typeorm';

describe('UserService', () => {
  let service: UserService;
  let repository: jest.Mocked<Repository<User>>;

  beforeEach(async () => {
    // Створюємо mock репозиторію
    const mockRepository = {
      findOne: jest.fn(),
      create: jest.fn(),
      save: jest.fn(),
    };

    // Створюємо тестовий модуль
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UserService,
        {
          provide: getRepositoryToken(User),
          useValue: mockRepository,
        },
      ],
    }).compile();

    // Отримуємо екземпляри з DI контейнера
    service = module.get<UserService>(UserService);
    repository = module.get(getRepositoryToken(User));
  });

  describe('findById', () => {
    it('should return user when found', async () => {
      // Arrange: налаштовуємо mock
      const mockUser = { id: '123', email: 'test@example.com', name: 'Test User' };
      repository.findOne.mockResolvedValue(mockUser as User);

      // Act: викликаємо тестований метод
      const result = await service.findById('123');

      // Assert: перевіряємо результат
      expect(result).toEqual(mockUser);
      expect(repository.findOne).toHaveBeenCalledWith({ where: { id: '123' } });
    });

    it('should throw NotFoundException when user not found', async () => {
      // Arrange: репозиторій повертає null
      repository.findOne.mockResolvedValue(null);

      // Act & Assert: перевіряємо, що викидається виняток
      await expect(service.findById('999')).rejects.toThrow(NotFoundException);
      await expect(service.findById('999')).rejects.toThrow('User with ID 999 not found');
    });
  });

  describe('createUser', () => {
    it('should create and save new user', async () => {
      // Arrange
      const email = 'new@example.com';
      const name = 'New User';
      const createdUser = { id: '456', email, name };
      
      repository.create.mockReturnValue(createdUser as User);
      repository.save.mockResolvedValue(createdUser as User);

      // Act
      const result = await service.createUser(email, name);

      // Assert
      expect(repository.create).toHaveBeenCalledWith({ email, name });
      expect(repository.save).toHaveBeenCalledWith(createdUser);
      expect(result).toEqual(createdUser);
    });
  });
});

{
  provide: getRepositoryToken(User),
  useValue: mockRepository,
}

const module: TestingModule = await Test.createTestingModule({
  // ...
}).compile();

service = module.get<UserService>(UserService);
repository = module.get(getRepositoryToken(User));

repository.create.mockReturnValue({ id: '1', email: 'test@test.com' } as User);

repository.findOne.mockResolvedValue({ id: '1', email: 'test@test.com' } as User);
// Еквівалентно: mockReturnValue(Promise.resolve(value))

repository.save.mockRejectedValue(new Error('Database connection failed'));

repository.findOne.mockImplementation(async (options) => {
  if (options.where.id === '123') {
    return { id: '123', email: 'test@test.com' } as User;
  }
  return null;
});

describe('UserService', () => {
  let service: UserService;
  let repository: jest.Mocked<Repository<User>>;

  beforeEach(async () => {
    // Цей код виконається ПЕРЕД КОЖНИМ тестом
    const mockRepository = {
      findOne: jest.fn(),
      create: jest.fn(),
      save: jest.fn(),
    };

    const module = await Test.createTestingModule({
      providers: [
        UserService,
        { provide: getRepositoryToken(User), useValue: mockRepository },
      ],
    }).compile();

    service = module.get<UserService>(UserService);
    repository = module.get(getRepositoryToken(User));
  });

  it('test 1', () => {
    // service та repository — свіжі екземпляри
  });

  it('test 2', () => {
    // service та repository — НОВІ свіжі екземпляри (не ті самі, що у test 1)
  });
});

describe('FileService', () => {
  let service: FileService;
  let tempFilePath: string;

  beforeEach(() => {
    service = new FileService();
    tempFilePath = path.join(__dirname, 'temp-test-file.txt');
  });

  afterEach(async () => {
    // Видаляємо тимчасовий файл після кожного тесту
    if (fs.existsSync(tempFilePath)) {
      await fs.promises.unlink(tempFilePath);
    }
  });

  it('should write data to file', async () => {
    await service.writeFile(tempFilePath, 'test data');
    expect(fs.existsSync(tempFilePath)).toBe(true);
  });
  // afterEach() виконається тут і видалить файл

  it('should read data from file', async () => {
    await fs.promises.writeFile(tempFilePath, 'test content');
    const data = await service.readFile(tempFilePath);
    expect(data).toBe('test content');
  });
  // afterEach() виконається знову
});

describe('DatabaseService', () => {
  let service: DatabaseService;
  let connection: Connection;

  beforeAll(async () => {
    // Підключення до БД — дорога операція
    connection = await createConnection({
      type: 'sqlite',
      database: ':memory:',
      entities: [User, Order],
      synchronize: true,
    });
    service = new DatabaseService(connection);
  });

  afterAll(async () => {
    // Закриваємо з'єднання після всіх тестів
    await connection.close();
  });

  beforeEach(async () => {
    // Очищаємо дані між тестами, але НЕ пересоздаємо connection
    await connection.getRepository(User).clear();
    await connection.getRepository(Order).clear();
  });

  it('should save user to database', async () => {
    const user = await service.saveUser({ email: 'test@test.com' });
    expect(user.id).toBeDefined();
  });

  it('should find user by id', async () => {
    const created = await service.saveUser({ email: 'find@test.com' });
    const found = await service.findUserById(created.id);
    expect(found.email).toBe('find@test.com');
  });
});

describe('Outer', () => {
  beforeEach(() => console.log('Outer beforeEach'));
  afterEach(() => console.log('Outer afterEach'));

  it('Outer test', () => console.log('Outer test'));

  describe('Inner', () => {
    beforeEach(() => console.log('Inner beforeEach'));
    afterEach(() => console.log('Inner afterEach'));

    it('Inner test', () => console.log('Inner test'));
  });
});

// Вивід:
// Outer beforeEach
// Outer test
// Outer afterEach
// Outer beforeEach      ← Спочатку батьківський hook
// Inner beforeEach      ← Потім дочірній
// Inner test
// Inner afterEach       ← Дочірній cleanup
// Outer afterEach       ← Батьківський cleanup

describe('UserService', () => {
  let service: UserService;

  it('should fetch user from database', async () => {
    // Використовуємо await для асинхронних викликів
    const user = await service.findById('123');
    
    expect(user.id).toBe('123');
    expect(user.email).toBeDefined();
  });

  it('should create multiple users in sequence', async () => {
    const user1 = await service.createUser('user1@test.com', 'User One');
    const user2 = await service.createUser('user2@test.com', 'User Two');
    
    expect(user1.id).not.toBe(user2.id);
  });
});

it('should throw error when user not found', async () => {
  // ✅ Правильний спосіб: await + .rejects
  await expect(service.findById('nonexistent')).rejects.toThrow(NotFoundException);
  
  // Можна також перевіряти повідомлення помилки
  await expect(service.findById('999')).rejects.toThrow('User with ID 999 not found');
});

it('should resolve with user data', async () => {
  await expect(service.findById('123')).resolves.toMatchObject({
    id: '123',
    email: 'test@example.com',
  });
});

it('should call callback after async operation', (done) => {
  service.findById('123').then(user => {
    expect(user.id).toBe('123');
    done(); // Сигналізує Jest, що тест завершився
  });
});

// Arrange
const mockUser = { id: '123', email: 'test@example.com', name: 'Test' };
repository.findOne.mockResolvedValue(mockUser as User);

// Act
const result = await service.findById('123');

// Assert
expect(result).toEqual(mockUser);
expect(repository.findOne).toHaveBeenCalledWith({ where: { id: '123' } });

it('should update user email', async () => {
  // Arrange
  const userId = '123';
  const newEmail = 'newemail@example.com';
  const existingUser = { id: userId, email: 'old@example.com', name: 'User' };
  repository.findOne.mockResolvedValue(existingUser as User);
  repository.save.mockResolvedValue({ ...existingUser, email: newEmail } as User);

  // Act
  const updated = await service.updateEmail(userId, newEmail);

  // Assert
  expect(updated.email).toBe(newEmail);
  expect(repository.save).toHaveBeenCalledWith(
    expect.objectContaining({ email: newEmail })
  );
});

it('should return user when valid id is provided')
it('should throw NotFoundException when user does not exist')
it('should hash password before saving to database')
it('should not allow duplicate email addresses')
it('should calculate discount for loyalty customers correctly')

it('works') // Що саме працює?
it('test getUserById') // Який саме аспект тестуємо?
it('should work correctly') // Занадто загально
it('case 1') // Незрозумілий контекст

it('should handle user operations', async () => {
  const user = await service.createUser('test@test.com', 'Test');
  expect(user.email).toBe('test@test.com');
  expect(user.password).not.toBe('plaintext');
  
  const found = await service.findById(user.id);
  expect(found).toBeDefined();
  
  await service.deleteUser(user.id);
  await expect(service.findById(user.id)).rejects.toThrow();
  
  // Який саме аспект цей тест перевіряє?!
});

describe('User operations', () => {
  it('should create user with hashed password', async () => {
    const user = await service.createUser('test@test.com', 'password123');
    
    expect(user.password).not.toBe('password123');
    expect(user.password).toMatch(/^\$2[ayb]\$.{56}$/); // bcrypt hash format
  });

  it('should find created user by id', async () => {
    const created = await service.createUser('find@test.com', 'pass');
    const found = await service.findById(created.id);
    
    expect(found.id).toBe(created.id);
    expect(found.email).toBe('find@test.com');
  });

  it('should throw error when finding deleted user', async () => {
    const user = await service.createUser('delete@test.com', 'pass');
    await service.deleteUser(user.id);
    
    await expect(service.findById(user.id)).rejects.toThrow(NotFoundException);
  });
});

// ❌ ПОГАНО: спільний мутабельний стан
const sharedCache = new Map();

describe('CacheService', () => {
  it('test 1', () => {
    sharedCache.set('key', 'value1');
    // ...
  });

  it('test 2', () => {
    // Цей тест побачить 'key' із попереднього тесту!
    expect(sharedCache.has('key')).toBe(false); // FAIL
  });
});

// ✅ ДОБРЕ: кожен тест має свій стан
describe('CacheService', () => {
  let cache: Map<string, string>;

  beforeEach(() => {
    cache = new Map(); // Свіжий екземпляр для кожного тесту
  });

  it('test 1', () => {
    cache.set('key', 'value1');
    expect(cache.get('key')).toBe('value1');
  });

  it('test 2', () => {
    expect(cache.has('key')).toBe(false); // PASS: cache порожній
  });
});

describe('UserService', () => {
  it.only('should test this one', () => {
    // Лише цей тест виконається
  });

  it('should skip this', () => {
    // Буде пропущено
  });
});

it.skip('should test feature not yet implemented', () => {
  // Цей тест не виконається, але залишиться у коді як нагадування
});