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

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

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+convert_md_to_test_design.py — Convierte Markdown a test-design YAML
+Lee MD con secciones ## (key-value en listas) + tabla pipe de pasos.
+Uso: python convert_md_to_test_design.py <input.md> [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)
+
+
+# --- 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)
+
+
+# --- Parsing ---
+
+def parse_pipe_list(value: str) -> list[str]:
+    if not value:
+        return []
+    return [v.strip() for v in value.split("|") if v.strip()]
+
+
+def parse_sections(text: str) -> dict[str, list[str]]:
+    """Divide el markdown en secciones por headers ##."""
+    sections = {}
+    current = "_title"
+    sections[current] = []
+
+    for line in text.split("\n"):
+        stripped = line.strip()
+        if stripped.startswith("## "):
+            current = stripped[3:].strip().lower()
+            # Normalizar nombres de seccion
+            current = current.replace(" de pruebas", "_pruebas").replace(" de prueba", "_prueba")
+            sections[current] = []
+        elif stripped.startswith("# "):
+            sections["_title"] = [stripped[2:].strip()]
+        else:
+            sections[current].append(line)
+
+    return sections
+
+
+def parse_kv_from_list(lines: list[str]) -> list[tuple[str, str]]:
+    """Extrae key-value de lineas con formato '- **key**: value'."""
+    pairs = []
+    for line in lines:
+        match = re.match(r"^-\s+\*\*(.+?)\*\*:\s*(.*)$", line.strip())
+        if match:
+            pairs.append((match.group(1).strip(), match.group(2).strip()))
+    return pairs
+
+
+def parse_table(lines: list[str]) -> list[dict]:
+    """Parsea tabla Markdown pipe como lista de dicts."""
+    # Encontrar header y filas
+    table_lines = [l.strip() for l in lines if l.strip().startswith("|")]
+    if len(table_lines) < 3:  # header + separator + al menos 1 fila
+        return []
+
+    # Parsear header
+    raw_headers = [c.strip() for c in table_lines[0].split("|")]
+    raw_headers = [h for h in raw_headers if h]  # quitar vacios
+    header_map = {
+        "paso": "paso", "nombre": "nombre", "accion": "accion",
+        "resultado esperado": "resultado", "datos": "datos",
+        "script": "script", "automatizado": "automatizado",
+        "bloqueado": "bloqueado", "nota": "nota",
+    }
+    headers = [header_map.get(h.lower(), h.lower()) for h in raw_headers]
+
+    pasos = []
+    for row_line in table_lines[2:]:  # skip header + separator
+        # Splitear respetando escaped pipes (\|)
+        cells = re.split(r"(?<!\\)\|", row_line)
+        cells = [c.strip().replace("\\|", "|") for c in cells if c.strip() or cells.index(c) not in (0, len(cells)-1)]
+        # Filtrar celdas vacias del inicio/final del split
+        cells = [c.strip().replace("\\|", "|") for c in row_line.split("|")][1:-1]
+
+        if not cells or not cells[0].strip():
+            continue
+
+        row_dict = {}
+        for i, val in enumerate(cells):
+            if i < len(headers):
+                row_dict[headers[i]] = val.strip().replace("\\|", "|")
+
+        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().lower()
+        step["automatizado"] = auto_str == "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
+
+
+# --- YAML builders ---
+
+def get_kv(pairs: list[tuple[str, str]], key: str, default: str = "") -> str:
+    d = dict(pairs)
+    return d.get(key, default)
+
+
+def build_metadata_section(pairs: list[tuple[str, str]]) -> dict:
+    d = dict(pairs)
+    result = {}
+    for field in ("modulo", "version", "autor", "fecha", "stack"):
+        if field in d:
+            result[field] = d[field]
+    return result
+
+
+def build_requisito_section(pairs: list[tuple[str, str]]) -> dict:
+    d = dict(pairs)
+    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_section(pairs: list[tuple[str, str]]) -> dict:
+    d = dict(pairs)
+    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 = []
+    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 = {}
+    for key, val in pairs:
+        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_section(pairs: list[tuple[str, str]], pasos: list[dict]) -> dict:
+    d = dict(pairs)
+    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_section(pairs: list[tuple[str, str]]) -> dict:
+    d = dict(pairs)
+    result = {}
+    for field in ("id", "nombre"):
+        if field in d:
+            result[field] = d[field]
+
+    variables = []
+    comandos = {}
+    for key, val in pairs:
+        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_section(pairs: list[tuple[str, str]]) -> dict:
+    result = {}
+    for key, val in pairs:
+        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 main():
+    if len(sys.argv) < 2:
+        print("Uso: python convert_md_to_test_design.py <input.md> [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 open(input_path, "r", encoding="utf-8") as f:
+        text = f.read()
+
+    sections = parse_sections(text)
+
+    # Parsear secciones key-value
+    meta_kv = parse_kv_from_list(sections.get("metadata", []))
+    req_kv = parse_kv_from_list(sections.get("requisito", []))
+    plan_kv = parse_kv_from_list(sections.get("plan_pruebas", []))
+    caso_kv = parse_kv_from_list(sections.get("caso_prueba", []))
+    ejec_kv = parse_kv_from_list(sections.get("ejecucion", []))
+    integ_kv = parse_kv_from_list(sections.get("integraciones", []))
+
+    # Parsear tabla de pasos
+    pasos = parse_table(sections.get("pasos", []))
+
+    # Construir YAML
+    autor = get_kv(meta_kv, "autor", "QA Team")
+    doc = {}
+
+    metadata = build_metadata_section(meta_kv)
+    if metadata:
+        doc["metadata"] = metadata
+
+    requisito = build_requisito_section(req_kv)
+    if requisito:
+        doc["requisito"] = requisito
+
+    plan = build_plan_section(plan_kv)
+    if plan:
+        doc["plan_pruebas"] = plan
+
+    caso = build_caso_prueba_section(caso_kv, pasos)
+    doc["caso_prueba"] = caso
+
+    ejecucion = build_ejecucion_section(ejec_kv)
+    if ejecucion:
+        doc["ejecucion"] = ejecucion
+
+    integraciones = build_integraciones_section(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()