siesa-agents 2.1.72-qa.2 → 2.1.72-qa.21

package/siesa-agents/scripts/converters/convert_pdf_to_test_design.py

@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+"""
+convert_pdf_to_test_design.py — Convierte PDF a test-design YAML
+Lee PDF con secciones [SECCION] (metadata key-value) + tabla de pasos.
+Uso: python convert_pdf_to_test_design.py <input.pdf> [output.yml]
+"""
+
+import re
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. Instalar con: pip install pyyaml")
+    sys.exit(1)
+
+try:
+    import pdfplumber
+except ImportError:
+    print("ERROR: pdfplumber requerido. Instalar con: pip install pdfplumber")
+    sys.exit(1)
+
+
+# --- YAML formatting helpers ---
+
+class LiteralStr(str):
+    pass
+
+
+def literal_representer(dumper, data):
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data, style=">")
+
+
+yaml.add_representer(LiteralStr, literal_representer)
+
+
+def yaml_str_representer(dumper, data):
+    if any(c in data for c in (":", "{", "}", "[", "]", ",", "&", "*", "?", "|", ">", "!", "%", "@", "`")):
+        return dumper.represent_scalar("tag:yaml.org,2002:str", data, style='"')
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data)
+
+
+yaml.add_representer(str, yaml_str_representer)
+
+
+# --- PDF extraction ---
+
+def extract_all_text(pdf) -> str:
+    """Extrae todo el texto de paginas sin tabla de pasos."""
+    texts = []
+    for page in pdf.pages:
+        tables = page.extract_tables() or []
+        if tables:
+            # Pagina con tabla: solo extraer texto antes de [PASOS]
+            text = page.extract_text() or ""
+            idx = text.find("[PASOS]")
+            if idx >= 0:
+                texts.append(text[:idx])
+            # La tabla se procesa aparte
+        else:
+            texts.append(page.extract_text() or "")
+    return "\n".join(texts)
+
+
+def extract_steps_table(pdf) -> list[list[str]]:
+    """Extrae la tabla de pasos del PDF."""
+    for page in pdf.pages:
+        tables = page.extract_tables() or []
+        for table in tables:
+            if table and table[0] and "Paso" in str(table[0][0]):
+                return table
+    return []
+
+
+def parse_sections(text: str) -> dict[str, list[str]]:
+    """Divide el texto en secciones por marcadores [SECCION]."""
+    sections = {}
+    current = "_header"
+    sections[current] = []
+
+    for line in text.split("\n"):
+        line = line.strip()
+        if not line:
+            continue
+        match = re.match(r"^\[([A-Z_]+)\]$", line)
+        if match:
+            current = match.group(1).lower()
+            sections[current] = []
+        else:
+            sections[current].append(line)
+
+    return sections
+
+
+_KNOWN_KEYS = re.compile(
+    r"^("
+    r"modulo|version|autor|fecha|stack|"
+    r"id|nombre|descripcion|criterios_aceptacion|"
+    r"objetivo|framework|precondiciones|"
+    r"prioridad|tipo|scripts|"
+    r"ambiente_\d+\.\w+|tiempos\.\w+|"
+    r"variable\.\w+|comando\.\w+|"
+    r"\w+\.\w+"  # fallback para keys con punto (integraciones)
+    r")\s"
+)
+
+
+def parse_kv_lines(lines: list[str]) -> list[tuple[str, str]]:
+    """Parsea lineas key-value con soporte para continuacion de valores largos."""
+    pairs = []
+    for line in lines:
+        match = re.match(r"^(\S+)\s+(.+)$", line)
+        if match and _KNOWN_KEYS.match(line):
+            pairs.append((match.group(1), match.group(2).strip()))
+        elif pairs:
+            # Linea de continuacion: anexar al valor anterior
+            prev_key, prev_val = pairs[-1]
+            pairs[-1] = (prev_key, prev_val + " " + line.strip())
+    return pairs
+
+
+def clean_cell(val) -> str:
+    """Limpia valor de celda PDF, corrigiendo artefactos de word-wrap."""
+    if val is None:
+        return ""
+    text = str(val).replace("\n", " ")
+    text = re.sub(r" {2,}", " ", text).strip()
+    return fixup_pdf_wordwrap(text)
+
+
+def fixup_pdf_wordwrap(text: str) -> str:
+    """Corrige artefactos comunes de word-wrap en PDFs."""
+    # Fix split file extensions: "xxx.sp ec.ts" → "xxx.spec.ts"
+    text = re.sub(r"\.sp ec\.ts", ".spec.ts", text)
+    # Fix split URL paths: "/BLSurveyDocumentSearch Results/" → sin espacio
+    text = re.sub(r"(/[A-Za-z]+) ([A-Za-z]+/)", lambda m: m.group(0).replace(" ", ""), text)
+    return text
+
+
+def parse_pipe_list(value: str) -> list[str]:
+    if not value:
+        return []
+    return [v.strip() for v in value.split("|") if v.strip()]
+
+
+# --- YAML builders ---
+
+def build_metadata(kv: list[tuple[str, str]]) -> dict:
+    d = dict(kv)
+    result = {}
+    for field in ("modulo", "version", "autor", "fecha", "stack"):
+        if field in d:
+            result[field] = d[field]
+    return result
+
+
+def build_requisito(kv: list[tuple[str, str]]) -> dict:
+    d = dict(kv)
+    result = {}
+    for field in ("id", "nombre"):
+        if field in d:
+            result[field] = d[field]
+    desc = d.get("descripcion", "")
+    if desc:
+        result["descripcion"] = LiteralStr(desc)
+    criterios = parse_pipe_list(d.get("criterios_aceptacion", ""))
+    if criterios:
+        result["criterios_aceptacion"] = criterios
+    return result
+
+
+def build_plan_pruebas(kv: list[tuple[str, str]]) -> dict:
+    d = dict(kv)
+    result = {}
+    for field in ("id", "nombre", "framework"):
+        if field in d:
+            result[field] = d[field]
+    objetivo = d.get("objetivo", "")
+    if objetivo:
+        result["objetivo"] = LiteralStr(objetivo)
+
+    precondiciones = parse_pipe_list(d.get("precondiciones", ""))
+    if precondiciones:
+        result["precondiciones"] = precondiciones
+
+    # ambientes
+    ambientes = []
+    i = 0
+    while True:
+        nombre = d.get(f"ambiente_{i}.nombre", "")
+        if not nombre:
+            break
+        amb = {"nombre": nombre}
+        url = d.get(f"ambiente_{i}.url", "")
+        if url:
+            amb["url"] = url
+        usuario = d.get(f"ambiente_{i}.usuario", "")
+        if usuario:
+            amb["usuario"] = usuario
+        amb["validado"] = True
+        ambientes.append(amb)
+        i += 1
+    if ambientes:
+        result["ambientes"] = ambientes
+
+    # tiempos
+    tiempos = {}
+    for key, val in kv:
+        if key.startswith("tiempos."):
+            t_key = key.replace("tiempos.", "")
+            tiempos[t_key] = val
+    if tiempos:
+        result["tiempos_referencia"] = tiempos
+
+    return result
+
+
+def build_caso_prueba(kv: list[tuple[str, str]], pasos: list[dict]) -> dict:
+    d = dict(kv)
+    result = {}
+    for field in ("id", "nombre", "prioridad", "tipo"):
+        if field in d:
+            result[field] = d[field]
+    scripts = parse_pipe_list(d.get("scripts", ""))
+    if scripts:
+        result["scripts"] = scripts
+    result["pasos"] = pasos
+    return result
+
+
+def build_ejecucion(kv: list[tuple[str, str]]) -> dict:
+    d = dict(kv)
+    result = {}
+    for field in ("id", "nombre"):
+        if field in d:
+            result[field] = d[field]
+
+    variables = []
+    comandos = {}
+    for key, val in kv:
+        if key.startswith("variable."):
+            var_name = key.replace("variable.", "")
+            parts = [p.strip() for p in val.split("|")]
+            var = {"nombre": var_name}
+            if len(parts) >= 1:
+                var["descripcion"] = parts[0]
+            if len(parts) >= 2:
+                var["default"] = parts[1]
+            variables.append(var)
+        elif key.startswith("comando."):
+            cmd_name = key.replace("comando.", "")
+            comandos[cmd_name] = val
+
+    if variables:
+        result["variables_entorno"] = variables
+    if comandos:
+        result["comandos"] = comandos
+    return result
+
+
+def build_integraciones(kv: list[tuple[str, str]]) -> dict:
+    result = {}
+    for key, val in kv:
+        parts = key.split(".", 1)
+        if len(parts) == 2:
+            integ_name, field = parts
+            if integ_name not in result:
+                result[integ_name] = {}
+            result[integ_name][field] = val
+    return result
+
+
+def parse_table_to_steps(table: list[list[str]]) -> list[dict]:
+    """Convierte tabla PDF a lista de pasos."""
+    if not table or len(table) < 2:
+        return []
+
+    headers_raw = [clean_cell(c).lower() for c in table[0]]
+    header_map = {
+        "paso": "paso", "nombre": "nombre", "accion": "accion",
+        "resultado esperado": "resultado", "datos": "datos",
+        "script": "script", "auto": "automatizado",
+        "bloqueado": "bloqueado", "nota": "nota",
+    }
+    headers = [header_map.get(h, h) for h in headers_raw]
+
+    pasos = []
+    for row in table[1:]:
+        if not row or not row[0]:
+            continue
+        row_dict = {}
+        for i, val in enumerate(row):
+            if i < len(headers):
+                row_dict[headers[i]] = clean_cell(val)
+
+        paso_val = row_dict.get("paso", "").strip()
+        if paso_val.isdigit():
+            paso_key = int(paso_val)
+        else:
+            paso_key = paso_val
+
+        step = {"paso": paso_key}
+        step["nombre"] = row_dict.get("nombre", "")
+        step["accion"] = row_dict.get("accion", "")
+        step["resultado"] = row_dict.get("resultado", "")
+
+        datos = row_dict.get("datos", "")
+        if datos:
+            step["datos"] = datos
+
+        script = row_dict.get("script", "")
+        if script:
+            step["script"] = script
+
+        auto_str = row_dict.get("automatizado", "False").strip()
+        step["automatizado"] = auto_str.lower() == "true"
+
+        bloqueado = row_dict.get("bloqueado", "")
+        if bloqueado:
+            step["bloqueado"] = bloqueado
+
+        nota = row_dict.get("nota", "")
+        if nota:
+            step["nota"] = nota
+
+        pasos.append(step)
+
+    return pasos
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python convert_pdf_to_test_design.py <input.pdf> [output.yml]")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    if not input_path.exists():
+        print(f"ERROR: No se encontro {input_path}")
+        sys.exit(1)
+
+    if len(sys.argv) >= 3:
+        output_path = Path(sys.argv[2])
+    else:
+        output_path = input_path.with_name(
+            input_path.stem.replace("test-cases-", "test-design-") + ".yml"
+        )
+
+    with pdfplumber.open(input_path) as pdf:
+        full_text = extract_all_text(pdf)
+        table = extract_steps_table(pdf)
+
+    sections = parse_sections(full_text)
+
+    # Parse cada seccion
+    meta_kv = parse_kv_lines(sections.get("metadata", []))
+    req_kv = parse_kv_lines(sections.get("requisito", []))
+    plan_kv = parse_kv_lines(sections.get("plan_pruebas", []))
+    caso_kv = parse_kv_lines(sections.get("caso_prueba", []))
+    ejec_kv = parse_kv_lines(sections.get("ejecucion", []))
+    integ_kv = parse_kv_lines(sections.get("integraciones", []))
+
+    pasos = parse_table_to_steps(table)
+
+    # Construir YAML
+    autor = dict(meta_kv).get("autor", "QA Team")
+    doc = {}
+
+    metadata = build_metadata(meta_kv)
+    if metadata:
+        doc["metadata"] = metadata
+
+    requisito = build_requisito(req_kv)
+    if requisito:
+        doc["requisito"] = requisito
+
+    plan = build_plan_pruebas(plan_kv)
+    if plan:
+        doc["plan_pruebas"] = plan
+
+    caso = build_caso_prueba(caso_kv, pasos)
+    doc["caso_prueba"] = caso
+
+    ejecucion = build_ejecucion(ejec_kv)
+    if ejecucion:
+        doc["ejecucion"] = ejecucion
+
+    integraciones = build_integraciones(integ_kv)
+    if integraciones:
+        doc["integraciones"] = integraciones
+
+    header = (
+        f"# test-design generado desde {input_path.name}\n"
+        f"# Input para: AgileTest + Playwright + Agente de Datos\n"
+        f"# Autor: {autor}\n\n"
+    )
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(header)
+        yaml.dump(
+            doc, f,
+            default_flow_style=False,
+            allow_unicode=True,
+            sort_keys=False,
+            width=120,
+        )
+
+    print(f"OK: {input_path.name} -> {output_path.name} ({len(pasos)} pasos convertidos)")
+
+
+if __name__ == "__main__":
+    main()

package/siesa-agents/scripts/converters/export_yaml_to_csv.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+export_yaml_to_csv.py — Exporta test-design YAML a CSV
+Formato CSV:
+  - Metadata en lineas comentario (#) con formato: # seccion.campo: valor
+  - Pasos como filas CSV estandar
+Uso: python export_yaml_to_csv.py <input.yml> [output.csv]
+"""
+
+import csv
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. Instalar con: pip install pyyaml")
+    sys.exit(1)
+
+
+def write_meta_line(f, section: str, key: str, value: str):
+    """Escribe una linea de metadata como comentario CSV."""
+    clean = str(value).replace("\n", " ").strip()
+    f.write(f"# {section}.{key}: {clean}\n")
+
+
+def export_metadata(f, data: dict):
+    """Exporta todas las secciones de metadata como comentarios."""
+    # metadata
+    meta = data.get("metadata", {})
+    for key in ("modulo", "version", "autor", "fecha", "stack"):
+        if key in meta:
+            write_meta_line(f, "metadata", key, meta[key])
+
+    # requisito
+    req = data.get("requisito", {})
+    for key in ("id", "nombre", "descripcion"):
+        if key in req:
+            write_meta_line(f, "requisito", key, req[key])
+    criterios = req.get("criterios_aceptacion", [])
+    if criterios:
+        write_meta_line(f, "requisito", "criterios_aceptacion", " | ".join(criterios))
+
+    # plan_pruebas
+    plan = data.get("plan_pruebas", {})
+    for key in ("id", "nombre", "objetivo", "framework"):
+        if key in plan:
+            write_meta_line(f, "plan_pruebas", key, plan[key])
+    precondiciones = plan.get("precondiciones", [])
+    if precondiciones:
+        write_meta_line(f, "plan_pruebas", "precondiciones", " | ".join(precondiciones))
+    ambientes = plan.get("ambientes", [])
+    for i, amb in enumerate(ambientes):
+        prefix = f"plan_pruebas.ambiente_{i}"
+        for key in ("nombre", "url", "usuario"):
+            if key in amb:
+                f.write(f"# {prefix}.{key}: {amb[key]}\n")
+    tiempos = plan.get("tiempos_referencia", {})
+    for key, val in tiempos.items():
+        write_meta_line(f, "plan_pruebas.tiempos", key, val)
+
+    # caso_prueba (sin pasos)
+    caso = data.get("caso_prueba", {})
+    for key in ("id", "nombre", "prioridad", "tipo"):
+        if key in caso:
+            write_meta_line(f, "caso_prueba", key, caso[key])
+    scripts = caso.get("scripts", [])
+    if scripts:
+        write_meta_line(f, "caso_prueba", "scripts", " | ".join(scripts))
+
+    # ejecucion
+    ejec = data.get("ejecucion", {})
+    for key in ("id", "nombre"):
+        if key in ejec:
+            write_meta_line(f, "ejecucion", key, ejec[key])
+    variables = ejec.get("variables_entorno", [])
+    for var in variables:
+        nombre = var.get("nombre", "")
+        desc = var.get("descripcion", "")
+        default = var.get("default", "")
+        f.write(f"# ejecucion.variable: {nombre} | {desc} | {default}\n")
+    comandos = ejec.get("comandos", {})
+    for key, val in comandos.items():
+        write_meta_line(f, "ejecucion.comando", key, val)
+
+    # integraciones
+    integ = data.get("integraciones", {})
+    for nombre_integ, info in integ.items():
+        for key, val in info.items():
+            write_meta_line(f, f"integracion.{nombre_integ}", key, val)
+
+
+def export_steps(f, data: dict):
+    """Exporta los pasos como filas CSV."""
+    pasos = data.get("caso_prueba", {}).get("pasos", [])
+    if not pasos:
+        print("WARN: No se encontraron pasos en caso_prueba.pasos")
+        return
+
+    headers = [
+        "paso", "nombre", "accion", "resultado_esperado",
+        "datos", "script", "automatizado", "bloqueado", "nota"
+    ]
+    writer = csv.DictWriter(f, fieldnames=headers, quoting=csv.QUOTE_MINIMAL)
+    writer.writeheader()
+
+    for p in pasos:
+        writer.writerow({
+            "paso": p.get("paso", ""),
+            "nombre": p.get("nombre", ""),
+            "accion": p.get("accion", ""),
+            "resultado_esperado": p.get("resultado", ""),
+            "datos": p.get("datos", ""),
+            "script": p.get("script", ""),
+            "automatizado": str(p.get("automatizado", False)).lower(),
+            "bloqueado": p.get("bloqueado", ""),
+            "nota": p.get("nota", ""),
+        })
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python export_yaml_to_csv.py <input.yml> [output.csv]")
+        sys.exit(1)
+
+    input_path = Path(sys.argv[1])
+    if not input_path.exists():
+        print(f"ERROR: No se encontro {input_path}")
+        sys.exit(1)
+
+    if len(sys.argv) >= 3:
+        output_path = Path(sys.argv[2])
+    else:
+        output_path = input_path.with_suffix(".csv")
+
+    with open(input_path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    with open(output_path, "w", encoding="utf-8", newline="") as f:
+        export_metadata(f, data)
+        f.write("#\n")  # separador visual
+        export_steps(f, data)
+
+    n_pasos = len(data.get("caso_prueba", {}).get("pasos", []))
+    print(f"OK: {input_path.name} -> {output_path.name} ({n_pasos} pasos exportados)")
+
+
+if __name__ == "__main__":
+    main()