⚙️ CAPÍTULO 03: AS ATIVIDADES DO PROCESSO

🎯 1. Objetivos de Aprendizagem & Competências

Estimativa de Dedicação: 2 horas de estudo autoguiado.
Ao final deste capítulo, você será capaz de:

• 🔹 Compreender as quatro atividades universais de qualquer processo de software: Especificação, Projeto & Implementação, Validação e Evolução (Sommerville/Pressman).
• 🔹 Mapear o fluxo de rastreabilidade bidirecional entre requisitos de negócio, arquitetura, código-fonte e suíte de testes.
• 🔹 Distinguir verificação ("Estamos construindo o produto corretamente?") de validação ("Estamos construindo o produto correto?").
• 🔹 Implementar uma esteira de validação em Python 3.11+ para rastreamento de artefatos de entrega.

🏢 2. Cenário Corporativo & Estudo de Caso (TecProExpress)

Na TecProExpress, um novo sistema de Rastreamento de Cargas e Frotas em Tempo Real foi aprovado para produção. Durante a primeira auditoria de governança, identificou-se que muitas funcionalidades codificadas não possuíam requisitos documentados e não eram cobertas por testes automatizados.

O Desafio: Seu objetivo é instituir a disciplina das 4 atividades universais do processo, criando uma esteira onde nenhum código chega a produção sem especificação prévia, implementação alinhada e validação automatizada.

🧠 3. Fundamentação Teórica & Modelos Visuais

3.1. As Quatro Atividades Universais

Independentemente de a equipe utilizar métodos ágeis (Scrum/Kanban) ou abordagens tradicionais, todo processo de software executa quatro atividades fundamentais:

flowchart TD
    subgraph ATIVIDADES ["AS 4 ATIVIDADES UNIVERSAIS DO PROCESSO (SOMMERVILLE)"]
        direction LR
        E["📋 1. ESPECIFICAÇÃO<br>O que o sistema deve fazer<br>(Requisitos & Regras)"] 
        --> D["📐 2. PROJETO & CÓDIGO<br>Como o sistema será estruturado<br>(Arquitetura & Implementação)"]
        --> V["🧪 3. VALIDAÇÃO<br>Garantir que funciona e atende<br>(Testes Unitários & E2E)"]
        --> EV["🚀 4. EVOLUÇÃO<br>Adaptação a novas demandas<br>(Refatoração & Manutenção)"]
        EV -.-> E
    end
    
    style E fill:#e0f2fe,stroke:#0284c7
    style D fill:#ede7f6,stroke:#5e35b1
    style V fill:#dcfce7,stroke:#16a34a
    style EV fill:#fef3c7,stroke:#d97706

3.2. Matriz de Rastreabilidade de Engenharia

A rastreabilidade garante que cada requisito tenha correspondência direta em classes de código e casos de teste:

flowchart LR
    RF["Requisito Funcional<br>RF01: Check-in de Carga"] --> UC["Caso de Uso / Endpoint<br>POST /api/cargas/"]
    UC --> CL["Classe de Domínio<br>Carga (models.py)"]
    CL --> UT["Teste Automatizado<br>test_checkin_carga()"]
    
    style RF fill:#e3f2fd,stroke:#1565c0
    style UC fill:#f3e5f5,stroke:#7b1fa2
    style CL fill:#fff8e1,stroke:#f57f17
    style UT fill:#dcfce7,stroke:#16a34a

💻 4. Aplicação Prática & Código Executável (Python 3.11+)

Implementação de uma estrutura de rastreamento de artefatos de processo com validação de cobertura.

📋 Pré-requisitos e Instalação

Este módulo utiliza exclusivamente recursos nativos do Python 3.11+ (dataclasses). Nenhuma instalação externa é necessária:

# Ambiente padrão Python 3.11+ (sem dependências externas)

💻 Código Completo e Autocontido (rastreabilidade_processo.py)

Crie o arquivo rastreabilidade_processo.py e insira o código abaixo:

"""
Módulo: rastreabilidade_processo.py
Domínio: Auditoria de rastreabilidade entre Requisitos, Código e Testes.
Stack: Python 3.11+
"""
from dataclasses import dataclass, field

@dataclass
class ItemRastreabilidade:
    id_requisito: str
    descricao_negocio: str
    endpoint_rest: str
    testes_associados: list[str] = field(default_factory=list)

    @property
    def coberto_por_testes(self) -> bool:
        return len(self.testes_associados) > 0

class AuditoriaProcesso:
    def __init__(self):
        self.itens: dict[str, ItemRastreabilidade] = {}

    def registrar_item(self, item: ItemRastreabilidade):
        self.itens[item.id_requisito] = item

    def relatorio_cobertura(self):
        total = len(self.itens)
        cobertos = sum(1 for item in self.itens.values() if item.coberto_por_testes)
        print("\n📊 RELATÓRIO DE RASTREABILIDADE DO PROCESSO:")
        print(f"Total de Requisitos Mapeados: {total}")
        print(f"Requisitos com Testes Automatizados: {cobertos}/{total} ({(cobertos/total)*100:.1f}%)")
        for item in self.itens.values():
            status = "✅ COBERTO" if item.coberto_por_testes else "❌ SEM TESTES"
            print(f" - [{item.id_requisito}] {item.descricao_negocio} -> {status}")

if __name__ == "__main__":
    auditoria = AuditoriaProcesso()
    auditoria.registrar_item(ItemRastreabilidade(
        id_requisito="RF-01",
        descricao_negocio="Registro de Entrada de Veículo",
        endpoint_rest="POST /api/checkin/",
        testes_associados=["test_checkin_sucesso", "test_checkin_vaga_ocupada"]
    ))
    auditoria.registrar_item(ItemRastreabilidade(
        id_requisito="RF-02",
        descricao_negocio="Emissão de Relatório Financeiro",
        endpoint_rest="GET /api/relatorios/faturamento",
        testes_associados=[]
    ))
    auditoria.relatorio_cobertura()

🚀 Como Executar

Execute o script no terminal:

python rastreabilidade_processo.py

🖥️ Saída Esperada no Terminal

📊 RELATÓRIO DE RASTREABILIDADE DO PROCESSO:
Total de Requisitos Mapeados: 2
Requisitos com Testes Automatizados: 1/2 (50.0%)
 - [RF-01] Registro de Entrada de Veículo -> ✅ COBERTO
 - [RF-02] Emissão de Relatório Financeiro -> ❌ SEM TESTES

💡 5. Checkpoint de Engenharia & Boas Práticas

🔗 6. Conexão com os Projetos Integradores

🧪 7. Quiz de Fixação e Autoavaliação (Formative Assessment)

🛠️ 8. Ponte para a Ação: Laboratório Prático

📌 9. Resumo Executivo & Key Takeaways

• 4 Atividades Canônicas: Especificação (O quê), Projeto & Código (Como), Validação (Testes) e Evolução (Melhoria Contínua).
• Rastreabilidade Bidirecional: Cada linha de código corporativo deve ser justificada por um requisito e validada por ao menos um teste automatizado.
• Verificação vs Validação: Construir o software sem bugs (Verificação) e garantir que ele resolve o problema certo (Validação).
• Evolução Contínua: Mais de 60% do custo total de um software ao longo do seu ciclo de vida é gasto na fase de evolução e manutenção.