Testes unitários, de integração e ponta a ponta

// desconto.ts
export function calcularDesconto(totalCentavos: number, cupom: string): number {
  if (totalCentavos < 0) throw new RangeError("total negativo");
  if (cupom !== "DEZ") return 0;
  return Math.min(Math.floor(totalCentavos * 0.1), 5_000);
}

// desconto.test.ts (Vitest)
import { describe, expect, it } from "vitest";
import { calcularDesconto } from "./desconto";

describe("calcularDesconto com o cupom DEZ", () => {
  it.each([
    [10_000, 1_000],
    [50_000, 5_000],
    [80_000, 5_000],
    [0, 0],
    [5, 0],
  ])("total %i centavos dá desconto de %i", (total, esperado) => {
    expect(calcularDesconto(total, "DEZ")).toBe(esperado);
  });

  it("recusa total negativo", () => {
    expect(() => calcularDesconto(-1, "DEZ")).toThrow(RangeError);
  });

  it("cupom desconhecido não dá desconto", () => {
    expect(calcularDesconto(10_000, "OUTRO")).toBe(0);
  });
});

# desconto.py
def calcular_desconto(total_centavos: int, cupom: str) -> int:
    if total_centavos < 0:
        raise ValueError("total negativo")
    if cupom != "DEZ":
        return 0
    return min(total_centavos // 10, 5_000)


# test_desconto.py (pytest)
import pytest

from desconto import calcular_desconto


@pytest.mark.parametrize(
    ("total", "esperado"),
    [(10_000, 1_000), (50_000, 5_000), (80_000, 5_000), (0, 0), (5, 0)],
)
def test_cupom_dez(total, esperado):
    assert calcular_desconto(total, "DEZ") == esperado


def test_recusa_total_negativo():
    with pytest.raises(ValueError):
        calcular_desconto(-1, "DEZ")


def test_cupom_desconhecido_nao_da_desconto():
    assert calcular_desconto(10_000, "OUTRO") == 0

// desconto.go
package loja

import "errors"

var ErrTotalNegativo = errors.New("total negativo")

func CalcularDesconto(totalCentavos int64, cupom string) (int64, error) {
	if totalCentavos < 0 {
		return 0, ErrTotalNegativo
	}
	if cupom != "DEZ" {
		return 0, nil
	}
	return min(totalCentavos/10, 5_000), nil
}

// desconto_test.go (pacote testing)
package loja

import (
	"errors"
	"testing"
)

func TestCalcularDescontoCupomDez(t *testing.T) {
	casos := []struct {
		nome     string
		total    int64
		esperado int64
	}{
		{"abaixo do limite", 10_000, 1_000},
		{"no limite", 50_000, 5_000},
		{"acima do limite", 80_000, 5_000},
		{"carrinho vazio", 0, 0},
		{"arredondamento", 5, 0},
	}
	for _, c := range casos {
		t.Run(c.nome, func(t *testing.T) {
			desconto, err := CalcularDesconto(c.total, "DEZ")
			if err != nil {
				t.Fatalf("erro inesperado: %v", err)
			}
			if desconto != c.esperado {
				t.Errorf("esperava %d, obteve %d", c.esperado, desconto)
			}
		})
	}
}

func TestCalcularDescontoRecusaTotalNegativo(t *testing.T) {
	if _, err := CalcularDesconto(-1, "DEZ"); !errors.Is(err, ErrTotalNegativo) {
		t.Errorf("esperava ErrTotalNegativo, obteve %v", err)
	}
}

// Desconto.java
public final class Desconto {
    public static long calcular(long totalCentavos, String cupom) {
        if (totalCentavos < 0) throw new IllegalArgumentException("total negativo");
        if (!"DEZ".equals(cupom)) return 0;
        return Math.min(totalCentavos / 10, 5_000);
    }
}

// DescontoTest.java (JUnit 5)
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

class DescontoTest {
    @ParameterizedTest(name = "total {0} centavos dá desconto de {1}")
    @CsvSource({ "10000, 1000", "50000, 5000", "80000, 5000", "0, 0", "5, 0" })
    void cupomDez(long total, long esperado) {
        assertEquals(esperado, Desconto.calcular(total, "DEZ"));
    }

    @Test
    void recusaTotalNegativo() {
        assertThrows(IllegalArgumentException.class, () -> Desconto.calcular(-1, "DEZ"));
    }

    @Test
    void cupomDesconhecidoNaoDaDesconto() {
        assertEquals(0, Desconto.calcular(10_000, "OUTRO"));
    }
}

// Desconto.cs
public static class Desconto
{
    public static long Calcular(long totalCentavos, string cupom)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(totalCentavos);
        if (cupom != "DEZ") return 0;
        return Math.Min(totalCentavos / 10, 5_000);
    }
}

// DescontoTests.cs (xUnit)
using Xunit;

public class DescontoTests
{
    [Theory]
    [InlineData(10_000, 1_000)]
    [InlineData(50_000, 5_000)]
    [InlineData(80_000, 5_000)]
    [InlineData(0, 0)]
    [InlineData(5, 0)]
    public void CupomDez(long total, long esperado)
    {
        Assert.Equal(esperado, Desconto.Calcular(total, "DEZ"));
    }

    [Fact]
    public void RecusaTotalNegativo()
    {
        Assert.Throws<ArgumentOutOfRangeException>(() => Desconto.Calcular(-1, "DEZ"));
    }

    [Fact]
    public void CupomDesconhecidoNaoDaDesconto()
    {
        Assert.Equal(0, Desconto.Calcular(10_000, "OUTRO"));
    }
}