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

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

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+convert_csv_to_test_design.py — Convierte CSV a test-design YAML
+Lee CSV con metadata en lineas # y pasos como filas estandar.
+Uso: python convert_csv_to_test_design.py <input.csv> [output.yml]
+"""
+
+import csv
+import io
+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):
+    """String que se serializa como bloque literal YAML (>)."""
+    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):
+    """Fuerza comillas dobles solo cuando es necesario."""
+    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_meta_lines(lines: list[str]) -> tuple[dict, list[tuple[str, str]]]:
+    """Parsea lineas # en un dict + lista de pares (para claves duplicadas)."""
+    meta = {}
+    pairs = []
+    for line in lines:
+        line = line.lstrip("# ").strip()
+        if not line or ":" not in line:
+            continue
+        key, _, value = line.partition(":")
+        key = key.strip()
+        value = value.strip()
+        meta[key] = value
+        pairs.append((key, value))
+    return meta, pairs
+
+
+def get_meta(meta: dict, key: str, default: str = "") -> str:
+    return meta.get(key, default)
+
+
+def parse_pipe_list(value: str) -> list[str]:
+    """Separa valores delimitados por |."""
+    if not value:
+        return []
+    return [v.strip() for v in value.split("|") if v.strip()]
+
+
+def build_metadata_section(meta: dict) -> dict:
+    result = {}
+    for field in ("modulo", "version", "autor", "fecha", "stack"):
+        val = get_meta(meta, f"metadata.{field}")
+        if val:
+            result[field] = val
+    return result
+
+
+def build_requisito_section(meta: dict) -> dict:
+    result = {}
+    for field in ("id", "nombre"):
+        val = get_meta(meta, f"requisito.{field}")
+        if val:
+            result[field] = val
+    desc = get_meta(meta, "requisito.descripcion")
+    if desc:
+        result["descripcion"] = LiteralStr(desc)
+    criterios = parse_pipe_list(get_meta(meta, "requisito.criterios_aceptacion"))
+    if criterios:
+        result["criterios_aceptacion"] = criterios
+    return result
+
+
+def build_plan_section(meta: dict) -> dict:
+    result = {}
+    for field in ("id", "nombre", "framework"):
+        val = get_meta(meta, f"plan_pruebas.{field}")
+        if val:
+            result[field] = val
+    objetivo = get_meta(meta, "plan_pruebas.objetivo")
+    if objetivo:
+        result["objetivo"] = LiteralStr(objetivo)
+
+    # ambientes
+    ambientes = []
+    i = 0
+    while True:
+        nombre = get_meta(meta, f"plan_pruebas.ambiente_{i}.nombre")
+        if not nombre:
+            break
+        amb = {"nombre": nombre}
+        url = get_meta(meta, f"plan_pruebas.ambiente_{i}.url")
+        if url:
+            amb["url"] = url
+        usuario = get_meta(meta, f"plan_pruebas.ambiente_{i}.usuario")
+        if usuario:
+            amb["usuario"] = usuario
+        amb["validado"] = True
+        ambientes.append(amb)
+        i += 1
+    if ambientes:
+        result["ambientes"] = ambientes
+
+    # precondiciones
+    precondiciones = parse_pipe_list(get_meta(meta, "plan_pruebas.precondiciones"))
+    if precondiciones:
+        result["precondiciones"] = precondiciones
+
+    # tiempos
+    tiempos = {}
+    for key, val in meta.items():
+        if key.startswith("plan_pruebas.tiempos."):
+            t_key = key.replace("plan_pruebas.tiempos.", "")
+            tiempos[t_key] = val
+    if tiempos:
+        result["tiempos_referencia"] = tiempos
+
+    return result
+
+
+def build_caso_prueba_section(meta: dict, pasos: list[dict]) -> dict:
+    result = {}
+    for field in ("id", "nombre", "prioridad", "tipo"):
+        val = get_meta(meta, f"caso_prueba.{field}")
+        if val:
+            result[field] = val
+    scripts = parse_pipe_list(get_meta(meta, "caso_prueba.scripts"))
+    if scripts:
+        result["scripts"] = scripts
+    result["pasos"] = pasos
+    return result
+
+
+def build_ejecucion_section(meta: dict, pairs: list[tuple[str, str]]) -> dict:
+    result = {}
+    for field in ("id", "nombre"):
+        val = get_meta(meta, f"ejecucion.{field}")
+        if val:
+            result[field] = val
+
+    # variables_entorno (usa pairs para capturar claves duplicadas)
+    variables = []
+    for key, val in pairs:
+        if key == "ejecucion.variable":
+            parts = [p.strip() for p in val.split("|")]
+            if len(parts) >= 3:
+                variables.append({
+                    "nombre": parts[0],
+                    "descripcion": parts[1],
+                    "default": parts[2],
+                })
+    if variables:
+        result["variables_entorno"] = variables
+
+    # comandos
+    comandos = {}
+    for key, val in meta.items():
+        if key.startswith("ejecucion.comando."):
+            cmd_key = key.replace("ejecucion.comando.", "")
+            comandos[cmd_key] = val
+    if comandos:
+        result["comandos"] = comandos
+
+    return result
+
+
+def build_integraciones_section(meta: dict) -> dict:
+    result = {}
+    for key, val in meta.items():
+        if key.startswith("integracion."):
+            rest = key.replace("integracion.", "")
+            parts = rest.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_csv_steps(csv_text: str) -> list[dict]:
+    """Parsea filas CSV como pasos de test."""
+    reader = csv.DictReader(io.StringIO(csv_text))
+    pasos = []
+    for row in reader:
+        paso_val = row.get("paso", "").strip()
+        # Determinar tipo de paso
+        if paso_val.isdigit():
+            paso_key = int(paso_val)
+        else:
+            paso_key = paso_val  # "manual" u otro
+
+        step = {"paso": paso_key}
+        step["nombre"] = row.get("nombre", "").strip()
+        step["accion"] = row.get("accion", "").strip()
+        step["resultado"] = row.get("resultado_esperado", "").strip()
+
+        datos = row.get("datos", "").strip()
+        if datos:
+            step["datos"] = datos
+
+        script = row.get("script", "").strip()
+        if script:
+            step["script"] = script
+
+        auto_str = row.get("automatizado", "false").strip().lower()
+        step["automatizado"] = auto_str == "true"
+
+        bloqueado = row.get("bloqueado", "").strip()
+        if bloqueado:
+            step["bloqueado"] = bloqueado
+
+        nota = row.get("nota", "").strip()
+        if nota:
+            step["nota"] = nota
+
+        pasos.append(step)
+
+    return pasos
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Uso: python convert_csv_to_test_design.py <input.csv> [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"
+        )
+
+    # Leer archivo y separar metadata de CSV
+    with open(input_path, "r", encoding="utf-8") as f:
+        raw_lines = f.readlines()
+
+    meta_lines = []
+    csv_lines = []
+    for line in raw_lines:
+        if line.startswith("#"):
+            meta_lines.append(line)
+        else:
+            csv_lines.append(line)
+
+    meta, pairs = parse_meta_lines(meta_lines)
+    csv_text = "".join(csv_lines)
+    pasos = parse_csv_steps(csv_text)
+
+    # Construir YAML
+    autor = get_meta(meta, "metadata.autor", "QA Team")
+    doc = {}
+
+    metadata = build_metadata_section(meta)
+    if metadata:
+        doc["metadata"] = metadata
+
+    requisito = build_requisito_section(meta)
+    if requisito:
+        doc["requisito"] = requisito
+
+    plan = build_plan_section(meta)
+    if plan:
+        doc["plan_pruebas"] = plan
+
+    caso = build_caso_prueba_section(meta, pasos)
+    doc["caso_prueba"] = caso
+
+    ejecucion = build_ejecucion_section(meta, pairs)
+    if ejecucion:
+        doc["ejecucion"] = ejecucion
+
+    integraciones = build_integraciones_section(meta)
+    if integraciones:
+        doc["integraciones"] = integraciones
+
+    # Escribir YAML
+    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/convert_excel_to_test_design.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""
+convert_excel_to_test_design.py — Convierte Excel (.xlsx) a test-design YAML
+Lee Excel con hoja "Metadata" (Seccion/Campo/Valor) + hoja "Pasos" (tabla).
+Uso: python convert_excel_to_test_design.py <input.xlsx> [output.yml]
+"""
+
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. Instalar con: pip install pyyaml")
+    sys.exit(1)
+
+try:
+    from openpyxl import load_workbook
+except ImportError:
+    print("ERROR: openpyxl requerido. Instalar con: pip install openpyxl")
+    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 cell_str(val) -> str:
+    """Convierte valor de celda a string limpio."""
+    if val is None:
+        return ""
+    return str(val).strip()
+
+
+def parse_pipe_list(value: str) -> list[str]:
+    if not value:
+        return []
+    return [v.strip() for v in value.split("|") if v.strip()]
+
+
+def read_metadata_sheet(wb) -> tuple[dict, list[tuple[str, str, str]]]:
+    """Lee hoja Metadata y retorna dict + lista de tuplas para claves duplicadas."""
+    ws = wb["Metadata"]
+    meta = {}
+    triples = []
+
+    for row in ws.iter_rows(min_row=2, values_only=True):
+        if not row or not row[0]:
+            continue
+        seccion = cell_str(row[0])
+        campo = cell_str(row[1]) if len(row) > 1 else ""
+        valor = cell_str(row[2]) if len(row) > 2 else ""
+
+        key = f"{seccion}.{campo}" if campo else seccion
+        meta[key] = valor
+        triples.append((seccion, campo, valor))
+
+    return meta, triples
+
+
+def read_pasos_sheet(wb) -> list[dict]:
+    """Lee hoja Pasos y retorna lista de dicts de pasos."""
+    ws = wb["Pasos"]
+    pasos = []
+
+    # Leer headers de la primera fila
+    headers_raw = [cell_str(c) for c in next(ws.iter_rows(min_row=1, max_row=1, values_only=True))]
+    # Normalizar headers
+    header_map = {
+        "paso": "paso", "nombre": "nombre", "accion": "accion",
+        "resultado esperado": "resultado", "datos": "datos",
+        "script": "script", "automatizado": "automatizado",
+        "bloqueado": "bloqueado", "nota": "nota",
+    }
+    headers = []
+    for h in headers_raw:
+        normalized = h.lower().strip()
+        headers.append(header_map.get(normalized, normalized))
+
+    for row in ws.iter_rows(min_row=2, values_only=True):
+        if not row or row[0] is None:
+            continue
+
+        row_dict = {}
+        for i, val in enumerate(row):
+            if i < len(headers):
+                row_dict[headers[i]] = val
+
+        paso_val = row_dict.get("paso", "")
+        if isinstance(paso_val, (int, float)):
+            paso_key = int(paso_val)
+        else:
+            paso_key = cell_str(paso_val)
+            if paso_key.isdigit():
+                paso_key = int(paso_key)
+
+        step = {"paso": paso_key}
+        step["nombre"] = cell_str(row_dict.get("nombre", ""))
+        step["accion"] = cell_str(row_dict.get("accion", ""))
+        step["resultado"] = cell_str(row_dict.get("resultado", ""))
+
+        datos = cell_str(row_dict.get("datos", ""))
+        if datos:
+            step["datos"] = datos
+
+        script = cell_str(row_dict.get("script", ""))
+        if script:
+            step["script"] = script
+
+        auto_val = row_dict.get("automatizado", False)
+        if isinstance(auto_val, bool):
+            step["automatizado"] = auto_val
+        else:
+            step["automatizado"] = cell_str(auto_val).lower() == "true"
+
+        bloqueado = cell_str(row_dict.get("bloqueado", ""))
+        if bloqueado:
+            step["bloqueado"] = bloqueado
+
+        nota = cell_str(row_dict.get("nota", ""))
+        if nota:
+            step["nota"] = nota
+
+        pasos.append(step)
+
+    return pasos
+
+
+# --- YAML builders ---
+
+def get_meta(meta: dict, key: str, default: str = "") -> str:
+    return meta.get(key, default)
+
+
+def build_metadata_section(meta: dict) -> dict:
+    result = {}
+    for field in ("modulo", "version", "autor", "fecha", "stack"):
+        val = get_meta(meta, f"metadata.{field}")
+        if val:
+            result[field] = val
+    return result
+
+
+def build_requisito_section(meta: dict) -> dict:
+    result = {}
+    for field in ("id", "nombre"):
+        val = get_meta(meta, f"requisito.{field}")
+        if val:
+            result[field] = val
+    desc = get_meta(meta, "requisito.descripcion")
+    if desc:
+        result["descripcion"] = LiteralStr(desc)
+    criterios = parse_pipe_list(get_meta(meta, "requisito.criterios_aceptacion"))
+    if criterios:
+        result["criterios_aceptacion"] = criterios
+    return result
+
+
+def build_plan_section(meta: dict) -> dict:
+    result = {}
+    for field in ("id", "nombre", "framework"):
+        val = get_meta(meta, f"plan_pruebas.{field}")
+        if val:
+            result[field] = val
+    objetivo = get_meta(meta, "plan_pruebas.objetivo")
+    if objetivo:
+        result["objetivo"] = LiteralStr(objetivo)
+
+    # ambientes
+    ambientes = []
+    i = 0
+    while True:
+        nombre = get_meta(meta, f"plan_pruebas.ambiente_{i}.nombre")
+        if not nombre:
+            break
+        amb = {"nombre": nombre}
+        url = get_meta(meta, f"plan_pruebas.ambiente_{i}.url")
+        if url:
+            amb["url"] = url
+        usuario = get_meta(meta, f"plan_pruebas.ambiente_{i}.usuario")
+        if usuario:
+            amb["usuario"] = usuario
+        amb["validado"] = True
+        ambientes.append(amb)
+        i += 1
+    if ambientes:
+        result["ambientes"] = ambientes
+
+    precondiciones = parse_pipe_list(get_meta(meta, "plan_pruebas.precondiciones"))
+    if precondiciones:
+        result["precondiciones"] = precondiciones
+
+    tiempos = {}
+    for key, val in meta.items():
+        if key.startswith("plan_pruebas.tiempos."):
+            t_key = key.replace("plan_pruebas.tiempos.", "")
+            tiempos[t_key] = val
+    if tiempos:
+        result["tiempos_referencia"] = tiempos
+
+    return result
+
+
+def build_caso_prueba_section(meta: dict, pasos: list[dict]) -> dict:
+    result = {}
+    for field in ("id", "nombre", "prioridad", "tipo"):
+        val = get_meta(meta, f"caso_prueba.{field}")
+        if val:
+            result[field] = val
+    scripts = parse_pipe_list(get_meta(meta, "caso_prueba.scripts"))
+    if scripts:
+        result["scripts"] = scripts
+    result["pasos"] = pasos
+    return result
+
+
+def build_ejecucion_section(meta: dict, triples: list[tuple[str, str, str]]) -> dict:
+    result = {}
+    for field in ("id", "nombre"):
+        val = get_meta(meta, f"ejecucion.{field}")
+        if val:
+            result[field] = val
+
+    # variables (usa triples para capturar duplicados)
+    variables = []
+    for seccion, campo, valor in triples:
+        if seccion == "ejecucion.variable":
+            parts = [p.strip() for p in valor.split("|")]
+            if len(parts) >= 2:
+                var = {"nombre": campo, "descripcion": parts[0]}
+                if len(parts) >= 2:
+                    var["default"] = parts[1]
+                variables.append(var)
+    if variables:
+        result["variables_entorno"] = variables
+
+    # comandos
+    comandos = {}
+    for seccion, campo, valor in triples:
+        if seccion == "ejecucion.comando":
+            comandos[campo] = valor
+    if comandos:
+        result["comandos"] = comandos
+
+    return result
+
+
+def build_integraciones_section(meta: dict) -> dict:
+    result = {}
+    for key, val in meta.items():
+        if key.startswith("integracion."):
+            rest = key.replace("integracion.", "")
+            parts = rest.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_excel_to_test_design.py <input.xlsx> [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"
+        )
+
+    wb = load_workbook(input_path, read_only=True, data_only=True)
+
+    # Validar hojas requeridas
+    required = {"Metadata", "Pasos"}
+    found = set(wb.sheetnames)
+    missing = required - found
+    if missing:
+        print(f"ERROR: Hojas faltantes: {missing}. Encontradas: {found}")
+        sys.exit(1)
+
+    meta, triples = read_metadata_sheet(wb)
+    pasos = read_pasos_sheet(wb)
+    wb.close()
+
+    # Construir YAML
+    autor = get_meta(meta, "metadata.autor", "QA Team")
+    doc = {}
+
+    metadata = build_metadata_section(meta)
+    if metadata:
+        doc["metadata"] = metadata
+
+    requisito = build_requisito_section(meta)
+    if requisito:
+        doc["requisito"] = requisito
+
+    plan = build_plan_section(meta)
+    if plan:
+        doc["plan_pruebas"] = plan
+
+    caso = build_caso_prueba_section(meta, pasos)
+    doc["caso_prueba"] = caso
+
+    ejecucion = build_ejecucion_section(meta, triples)
+    if ejecucion:
+        doc["ejecucion"] = ejecucion
+
+    integraciones = build_integraciones_section(meta)
+    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()