def test_calculate_total():
    assert calculate_total([10, 20, 30]) == 60
    assert calculate_total([]) == 0

def test_create_decision_integration():
    # Testa criação de decisão com banco real
    decision = create_decision(context_id=123)
    assert decision.id is not None
    assert decision.status == "pending"

def test_decision_flow_e2e():
    # Testa fluxo completo: contexto -> decisão -> outcome
    context = create_context()
    decision = trigger_decision(context.id)
    outcome = wait_for_outcome(decision.id)
    assert outcome.status == "completed"

c-suite/
├── tests/
│   ├── unit/
│   │   ├── test_utils.py
│   │   ├── test_validators.py
│   │   └── test_models.py
│   ├── integration/
│   │   ├── test_api.py
│   │   ├── test_database.py
│   │   └── test_services.py
│   ├── e2e/
│   │   ├── test_decision_flow.py
│   │   └── test_agent_loop.py
│   ├── fixtures/
│   │   ├── sample_data.py
│   │   └── mocks.py
│   └── conftest.py

# tests/conftest.py
import pytest
from fastapi.testclient import TestClient
from app.main import app

@pytest.fixture
def client():
    return TestClient(app)

@pytest.fixture
def db_session():
    # Setup database session
    session = create_session()
    yield session
    # Teardown
    session.close()

def test_example():
    # Arrange: Preparar dados
    data = {"name": "Test", "value": 123}

    # Act: Executar ação
    result = process_data(data)

    # Assert: Verificar resultado
    assert result.status == "success"
    assert result.value == 123

def test_get_health(client):
    response = client.get("/health")
    assert response.status_code == 200
    assert response.json() == {"status": "ok"}

def test_create_decision(client, db_session):
    payload = {
        "context_id": 123,
        "entity_id": 456
    }
    response = client.post("/api/v1/decisions", json=payload)
    assert response.status_code == 201
    assert response.json()["id"] is not None

def test_create_context(db_session):
    context = Context(
        entity_id=123,
        entity_type="revenda",
        data={"key": "value"}
    )
    db_session.add(context)
    db_session.commit()

    result = db_session.query(Context).filter_by(entity_id=123).first()
    assert result is not None
    assert result.data == {"key": "value"}

from unittest.mock import Mock, patch

@patch('app.external_api.call')
def test_with_mock(mock_call):
    mock_call.return_value = {"status": "ok"}

    result = my_function()

    assert result == {"status": "ok"}
    mock_call.assert_called_once()

pytest

# Por arquivo
pytest tests/test_api.py

# Por função
pytest tests/test_api.py::test_get_health

# Por padrão
pytest tests/unit/

# Verbose
pytest -v

# Mostrar prints
pytest -s

# Parar no primeiro erro
pytest -x

# Executar apenas testes que falharam
pytest --lf

import pytest

@pytest.mark.unit
def test_unit():
    pass

@pytest.mark.integration
def test_integration():
    pass

@pytest.mark.slow
def test_slow():
    pass

# Apenas unitários
pytest -m unit

# Apenas integração
pytest -m integration

# Excluir lentos
pytest -m "not slow"

pip install pytest-cov

# Cobertura básica
pytest --cov=app

# Cobertura com relatório HTML
pytest --cov=app --cov-report=html

# Cobertura com relatório terminal
pytest --cov=app --cov-report=term-missing

pytest --cov=app --cov-fail-under=70

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts = 
    --cov=app
    --cov-report=html
    --cov-report=term-missing
    --cov-fail-under=70

version: '3.8'
services:
  mysql-test:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: test_password
      MYSQL_DATABASE: csuite_test
    ports:
      - "3307:3306"

docker-compose -f docker-compose.test.yml up -d
pytest tests/integration/
docker-compose -f docker-compose.test.yml down

@pytest.fixture
def test_db():
    # Setup test database
    engine = create_engine("mysql://root:test@localhost:3307/csuite_test")
    Base.metadata.create_all(engine)
    yield engine
    # Teardown
    Base.metadata.drop_all(engine)

def test_api_with_db(client, test_db):
    # Test API with real database
    response = client.post("/api/v1/contexts", json={"entity_id": 123})
    assert response.status_code == 201

docker-compose up -d
pytest tests/e2e/
docker-compose down

def test_decision_flow_e2e():
    # 1. Criar contexto
    context_response = requests.post(
        "http://localhost:8080/api/v1/contexts",
        json={"entity_id": 123, "entity_type": "revenda"}
    )
    context_id = context_response.json()["id"]

    # 2. Trigger decisão
    decision_response = requests.post(
        f"http://localhost:8080/api/v1/decisions",
        json={"context_id": context_id}
    )
    decision_id = decision_response.json()["id"]

    # 3. Aguardar outcome
    outcome = wait_for_outcome(decision_id, timeout=30)
    assert outcome["status"] == "completed"

name: Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.11'
      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install pytest pytest-cov
      - name: Run tests
        run: pytest --cov=app --cov-report=xml
      - name: Upload coverage
        uses: codecov/codecov-action@v2

# Bom
def test_create_decision_with_valid_context():
    pass

# Ruim
def test1():
    pass

def test_decision_status():
    decision = create_decision()
    assert decision.status == "pending"

def test_decision_creation():
    decision = create_decision()
    assert decision.id is not None
    assert decision.status == "pending"
    assert decision.created_at is not None

def test_create_decision():
    decision = create_decision()
    assert decision.id is not None

def test_get_decision():
    decision = create_decision()
    result = get_decision(decision.id)
    assert result.id == decision.id

# Testes dependentes (evitar)
decision_id = None

def test_create():
    global decision_id
    decision = create_decision()
    decision_id = decision.id

def test_get():
    # Depende de test_create ter executado antes
    result = get_decision(decision_id)