Edge cases, assertions et mocks

Identify edge cases for this function.
Focus on invalid inputs, boundary values, empty values, null values, and security-sensitive cases.

export function getFirstItem<T>(items: T[]): T {
  return items[0];
}

Identify edge cases for this function and suggest tests.

export function getFirstItem<T>(items: T[]): T {
  if (!items.length) {
    throw new Error("items must not be empty");
  }

  return items[0];
}

describe("getFirstItem", () => {
  it("returns the first item", () => {
    expect(getFirstItem([1, 2, 3])).toBe(1);
  });

  it("throws when the array is empty", () => {
    expect(() => getFirstItem([])).toThrow("items must not be empty");
  });
});

Identify edge cases for the selected function.

Group them by:
- input validation
- boundary values
- business rules
- security risks
- dependency failures

Then suggest unit tests for the top priority cases.

assert calculate_discount(100, 20) == 80

expect(calculateDiscount(100, 20)).toBe(80);

expect(response.status).toBe(201);

expect(response.status).toBe(201);
expect(response.body.email).toBe("alice@example.com");
expect(response.body).not.toHaveProperty("passwordHash");
expect(response.body.id).toBeDefined();

Improve the assertions in this test.
Make sure it verifies the response body, status code, and that sensitive fields are not returned.

it("creates a user", async () => {
  const response = await request(app)
    .post("/users")
    .send({
      email: "alice@example.com",
      password: "StrongPassword123!"
    });

  expect(response.status).toBe(201);
});

it("creates a user without exposing passwordHash", async () => {
  const response = await request(app)
    .post("/users")
    .send({
      email: "alice@example.com",
      password: "StrongPassword123!"
    });

  expect(response.status).toBe(201);
  expect(response.body.id).toBeDefined();
  expect(response.body.email).toBe("alice@example.com");
  expect(response.body).not.toHaveProperty("password");
  expect(response.body).not.toHaveProperty("passwordHash");
});

with pytest.raises(ValueError, match="email must not be empty"):
    normalize_email("   ")

expect(() => normalizeEmail("   ")).toThrow("Email must not be empty");

Review these tests and improve the assertions.

Focus on:
- verifying status codes
- verifying response body
- checking error messages
- ensuring sensitive fields are not returned
- avoiding overly broad assertions

export class PasswordResetService {
  constructor(
    private readonly userRepository: UserRepository,
    private readonly emailService: EmailService
  ) {}

  async requestReset(email: string): Promise<void> {
    const user = await this.userRepository.findByEmail(email);

    if (!user || !user.active) {
      return;
    }

    await this.emailService.sendPasswordResetEmail(user.email);
  }
}

Generate Jest unit tests for PasswordResetService.

Use mocks for:
- userRepository
- emailService

Cover:
- active user receives reset email
- unknown user does not receive email
- inactive user does not receive email

describe("PasswordResetService", () => {
  const userRepository = {
    findByEmail: jest.fn()
  };

  const emailService = {
    sendPasswordResetEmail: jest.fn()
  };

  let service: PasswordResetService;

  beforeEach(() => {
    jest.clearAllMocks();
    service = new PasswordResetService(userRepository, emailService);
  });

  it("sends reset email for active user", async () => {
    userRepository.findByEmail.mockResolvedValue({
      email: "alice@example.com",
      active: true
    });

    await service.requestReset("alice@example.com");

    expect(emailService.sendPasswordResetEmail).toHaveBeenCalledWith("alice@example.com");
  });

  it("does not send reset email for unknown user", async () => {
    userRepository.findByEmail.mockResolvedValue(null);

    await service.requestReset("missing@example.com");

    expect(emailService.sendPasswordResetEmail).not.toHaveBeenCalled();
  });

  it("does not send reset email for inactive user", async () => {
    userRepository.findByEmail.mockResolvedValue({
      email: "inactive@example.com",
      active: false
    });

    await service.requestReset("inactive@example.com");

    expect(emailService.sendPasswordResetEmail).not.toHaveBeenCalled();
  });
});

Generate pytest tests for this service.
Mock the external payment client.
Cover success, declined payment, and network error.

from unittest.mock import Mock
import pytest

def test_process_payment_success():
    payment_client = Mock()
    payment_client.charge.return_value = {"status": "paid"}

    service = PaymentService(payment_client)

    result = service.process_payment(amount=100)

    assert result["status"] == "paid"
    payment_client.charge.assert_called_once_with(amount=100)