Tests unitaires, tests d’intégration et couverture

def calculate_discount(price: float, percentage: float) -> float:
    if price < 0:
        raise ValueError("price must be non-negative")

    if percentage < 0 or percentage > 100:
        raise ValueError("percentage must be between 0 and 100")

    return price - price * (percentage / 100)

Write tests.

Generate pytest unit tests for this function.

Cover:
- valid discount
- zero discount
- 100 percent discount
- negative price
- negative percentage
- percentage greater than 100

Do not modify the production code.

import pytest

def test_calculate_discount_with_valid_percentage():
    assert calculate_discount(100, 20) == 80

def test_calculate_discount_with_zero_percentage():
    assert calculate_discount(100, 0) == 100

def test_calculate_discount_with_full_discount():
    assert calculate_discount(100, 100) == 0

def test_calculate_discount_rejects_negative_price():
    with pytest.raises(ValueError, match="price must be non-negative"):
        calculate_discount(-100, 20)

def test_calculate_discount_rejects_negative_percentage():
    with pytest.raises(ValueError, match="percentage must be between 0 and 100"):
        calculate_discount(100, -1)

def test_calculate_discount_rejects_percentage_over_100():
    with pytest.raises(ValueError, match="percentage must be between 0 and 100"):
        calculate_discount(100, 101)

export function normalizeEmail(email: string): string {
  const normalizedEmail = email.trim().toLowerCase();

  if (!normalizedEmail) {
    throw new Error("Email must not be empty");
  }

  return normalizedEmail;
}

Generate Jest unit tests for normalizeEmail.

Cover:
- trimming spaces
- lowercasing
- already normalized email
- empty string
- whitespace-only string

import { normalizeEmail } from "./normalizeEmail";

describe("normalizeEmail", () => {
  it("trims surrounding spaces", () => {
    expect(normalizeEmail(" user@example.com ")).toBe("user@example.com");
  });

  it("lowercases the email", () => {
    expect(normalizeEmail("USER@EXAMPLE.COM")).toBe("user@example.com");
  });

  it("keeps an already normalized email unchanged", () => {
    expect(normalizeEmail("user@example.com")).toBe("user@example.com");
  });

  it("throws an error for an empty string", () => {
    expect(() => normalizeEmail("")).toThrow("Email must not be empty");
  });

  it("throws an error for whitespace-only input", () => {
    expect(() => normalizeEmail("   ")).toThrow("Email must not be empty");
  });
});

Generate unit tests for the selected function.

Use [test framework].

Cover:
- normal cases
- edge cases
- invalid inputs
- boundary values
- expected exceptions

Constraints:
- do not modify production code
- follow the existing test style
- explain any missing test cases

app.post("/users", validateUserInput, async (req, res) => {
  const user = await userService.createUser(req.body);
  res.status(201).json(user);
});

Generate integration tests for POST /users using Jest and Supertest.

Cover:
- successful user creation
- missing email
- invalid email
- missing password
- duplicate email
- response must not include passwordHash

Use the existing test setup.

import request from "supertest";
import { app } from "../src/app";

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

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

  it("returns 400 when email is missing", async () => {
    const response = await request(app)
      .post("/users")
      .send({
        password: "StrongPassword123!",
        name: "Alice"
      });

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

  it("returns 400 when email is invalid", async () => {
    const response = await request(app)
      .post("/users")
      .send({
        email: "not-an-email",
        password: "StrongPassword123!",
        name: "Alice"
      });

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

Generate integration tests for this FastAPI endpoint using pytest and TestClient.

Cover:
- valid request
- missing required field
- invalid payload
- unauthorized request
- forbidden request

Generate integration tests for [endpoint/workflow].

Use:
- [framework]
- existing test setup

Cover:
- successful flow
- validation errors
- authentication failure
- authorization failure
- dependency failure
- expected response format

Constraints:
- do not use real external services
- use test database or mocks where appropriate
- do not include real secrets

tests unitaires + tests d’intégration + mocks/stubs adaptés

export function getShippingCost(country: string, total: number): number {
  if (total >= 100) {
    return 0;
  }

  if (country === "FR") {
    return 5;
  }

  if (country === "US") {
    return 10;
  }

  return 20;
}

it("returns free shipping for large orders", () => {
  expect(getShippingCost("FR", 100)).toBe(0);
});

Identify missing test cases for this function.
Focus on branch coverage and boundary values.

describe("getShippingCost", () => {
  it("returns free shipping when total is exactly 100", () => {
    expect(getShippingCost("FR", 100)).toBe(0);
  });

  it("returns free shipping when total is greater than 100", () => {
    expect(getShippingCost("US", 150)).toBe(0);
  });

  it("returns 5 for France when total is below 100", () => {
    expect(getShippingCost("FR", 99)).toBe(5);
  });

  it("returns 10 for US when total is below 100", () => {
    expect(getShippingCost("US", 99)).toBe(10);
  });

  it("returns 20 for unknown countries when total is below 100", () => {
    expect(getShippingCost("DE", 99)).toBe(20);
  });
});

Review the selected function and existing tests.

Identify:
- uncovered branches
- missing edge cases
- missing error cases
- weak assertions

Then generate tests to improve coverage without modifying production code.