Como Empresas Podem Testar APIs Gratuitas Antes de Migrar para Versões Pagas

import requests
import time
import json
import os
from datetime import datetime
from statistics import mean, stdev

class MonitorAPI:
    def __init__(self, api_key: str):
    self.api_key = api_key
    self.base_url = "https://api.cpfhub.io/cpf"
    self.resultados = []
    self.cpf_teste = "12345678909"

    def executar_teste(self) -> dict:
    inicio = time.time()

    try:
    response = requests.get(
    f"{self.base_url}/{self.cpf_teste}",
    headers={"x-api-key": self.api_key},
    timeout=15
    )
    duracao = (time.time() - inicio) * 1000

    resultado = {
    "timestamp": datetime.now().isoformat(),
    "status_code": response.status_code,
    "duracao_ms": round(duracao, 2),
    "sucesso": response.status_code == 200,
    "erro": None
    }

    except requests.exceptions.Timeout:
    resultado = {
    "timestamp": datetime.now().isoformat(),
    "status_code": None,
    "duracao_ms": 15000,
    "sucesso": False,
    "erro": "timeout"
    }
    except Exception as e:
    resultado = {
    "timestamp": datetime.now().isoformat(),
    "status_code": None,
    "duracao_ms": None,
    "sucesso": False,
    "erro": str(e)
    }

    self.resultados.append(resultado)
    return resultado

    def gerar_relatorio(self) -> dict:
    if not self.resultados:
    return {"erro": "Nenhum teste executado"}

    sucessos = [r for r in self.resultados if r["sucesso"]]
    falhas = [r for r in self.resultados if not r["sucesso"]]
    latencias = [r["duracao_ms"] for r in sucessos if r["duracao_ms"]]

    return {
    "periodo": {
    "inicio": self.resultados[0]["timestamp"],
    "fim": self.resultados[-1]["timestamp"],
    "total_testes": len(self.resultados)
    },
    "disponibilidade": {
    "uptime": f"{len(sucessos)/len(self.resultados)*100:.2f}%",
    "total_sucesso": len(sucessos),
    "total_falha": len(falhas)
    },
    "latencia": {
    "media_ms": round(mean(latencias), 2) if latencias else 0,
    "desvio_ms": round(stdev(latencias), 2) if len(latencias) > 1 else 0,
    "p50_ms": round(sorted(latencias)[len(latencias)//2], 2) if latencias else 0,
    "p99_ms": round(sorted(latencias)[int(len(latencias)*0.99)], 2) if latencias else 0,
    }
    }

class TesteFuncionalidade:
    def __init__(self, api_key: str):
    self.api_key = api_key
    self.base_url = "https://api.cpfhub.io/cpf"

    def verificar_campos(self, cpf: str) -> dict:
    response = requests.get(
    f"{self.base_url}/{cpf}",
    headers={"x-api-key": self.api_key},
    timeout=10
    )

    if response.status_code != 200:
    return {"erro": f"Status {response.status_code}"}

    dados = response.json()
    if not dados.get("success"):
    return {"erro": "CPF não encontrado"}

    data = dados["data"]
    campos_esperados = {
    "cpf": str, "name": str, "nameUpper": str,
    "gender": str, "birthDate": str,
    "day": str, "month": str, "year": str
    }

    relatorio = {}
    for campo, tipo in campos_esperados.items():
    presente = campo in data
    tipo_correto = isinstance(data.get(campo), tipo) if presente else False
    nao_vazio = bool(data.get(campo)) if presente else False

    relatorio[campo] = {
    "presente": presente,
    "tipo_correto": tipo_correto,
    "nao_vazio": nao_vazio,
    "valor_exemplo": data.get(campo, "ausente")
    }

    campos_ok = sum(
    1 for r in relatorio.values()
    if r["presente"] and r["tipo_correto"] and r["nao_vazio"]
    )

    return {
    "cobertura": f"{campos_ok}/{len(campos_esperados)}",
    "campos": relatorio
    }

class AnaliseMigracao:
    def __init__(self, relatorio_monitor: dict, uso_mensal: int, limite_gratuito: int):
    self.relatorio = relatorio_monitor
    self.uso = uso_mensal
    self.limite = limite_gratuito

    def avaliar(self) -> dict:
    fatores = []

    # Fator 1: Volume
    uso_percentual = (self.uso / self.limite) * 100
    if uso_percentual > 80:
    fatores.append({
    "fator": "Volume próximo do limite",
    "valor": f"{uso_percentual:.0f}%",
    "urgencia": "alta"
    })
    elif uso_percentual > 50:
    fatores.append({
    "fator": "Volume em crescimento",
    "valor": f"{uso_percentual:.0f}%",
    "urgencia": "media"
    })

    # Fator 2: Disponibilidade insuficiente
    uptime = float(
    self.relatorio["disponibilidade"]["uptime"].replace("%", "")
    )
    if uptime < 99.0:
    fatores.append({
    "fator": "Uptime abaixo do aceitável",
    "valor": f"{uptime}%",
    "urgencia": "alta"
    })

    # Fator 3: Latência alta
    p99 = self.relatorio["latencia"]["p99_ms"]
    if p99 > 2000:
    fatores.append({
    "fator": "Latência p99 acima de 2s",
    "valor": f"{p99}ms",
    "urgencia": "media"
    })

    recomendacao = "migrar" if any(
    f["urgencia"] == "alta" for f in fatores
    ) else "monitorar"

    return {
    "recomendacao": recomendacao,
    "fatores": fatores,
    "resumo": f"{len(fatores)} fatores identificados"
    }