paramsx 2.5.0__tar.gz → 2.5.2__tar.gz

{paramsx-2.5.0 → paramsx-2.5.2}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 2.5.2
+
+### Corregido
+
+- **Buscar un parámetro que existe ya no dice que no está**:
+  - En «Ruta» vale también el **nombre completo de un parámetro** (antes solo carpetas: «/dev/app/clave» no encontraba nada) y los parámetros **sin carpeta** (`MiParametro`).
+  - El buscador de «Ruta» sugiere también los **parámetros**, no solo las carpetas.
+  - Con **más de 2.000 parámetros** en la cuenta, el buscador y el filtro de Explorar preguntan también a AWS lo que se escribe; antes solo buscaban en los 2.000 primeros.
+  - Explorar muestra los parámetros sin carpeta.
+
+## 2.5.1
+
+### Corregido
+
+- **Un borrado ya no pisa el cambio de otro**: justo antes de borrar se vuelve a leer la versión de cada parámetro (sin valores). Si alguien lo ha cambiado desde la revisión (también mientras se creaba la copia de un renombrado), no se borra y se avisa; en un renombrado, se dice que la copia se creó con el valor de antes. Si el rol no puede leer la versión, se borra como antes; si la lectura falla por otro motivo, no se borra.
+
 ## 2.5.0
 
 ### Añadido

{paramsx-2.5.0/paramsx.egg-info → paramsx-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramsx
-Version: 2.5.0
+Version: 2.5.2
 Summary: Librería para gestionar y respaldar parámetros de AWS SSM de manera sencilla y eficiente.
 Home-page: https://github.com/pistatxos/paramsx
 Author: Mariox

paramsx-2.5.2/paramsx/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.5.2"

{paramsx-2.5.0 → paramsx-2.5.2}/paramsx/web/app.py

@@ -354,13 +354,14 @@ def crear_app(config_path=None, token=None, sesion_factory=None, perfiles_aws=No
 
     @app.get("/api/explorar")
     def api_explorar():
-        return jsonify(ssm_web.explorar(ssm(), request.args.get("prefijo") or "/"))
+        return jsonify(ssm_web.explorar(ssm(), request.args.get("prefijo") or "/",
+                                        str(request.args.get("contiene") or "")[:200]))
 
     @app.post("/api/cargar")
     def api_cargar():
         ruta = str(cuerpo().get("ruta") or "").strip()
-        if not ruta.startswith("/"):
-            raise ErrorWeb("La ruta empieza por /.")
+        if not ruta:
+            raise ErrorWeb("Escribe una ruta (o el nombre de un parámetro).")
         return jsonify(ssm_web.cargar(ssm(), ruta))
 
     @app.post("/api/plan")

{paramsx-2.5.0 → paramsx-2.5.2}/paramsx/web/ssm.py

@@ -81,8 +81,11 @@ def _meta(p):
     }
 
 
-def describir(ssm, ruta, nombres=None):
-    """{nombre: metadatos} (sin valores) de una ruta (recursivo) o de unos nombres concretos."""
+def describir(ssm, ruta, nombres=None, contiene=""):
+    """{nombre: metadatos} (sin valores) de una ruta (recursivo), de unos nombres concretos o de los
+    que llevan un texto (lo filtra AWS, distingue mayúsculas)."""
+    if contiene:
+        return _describir_filtro(ssm, [{"Key": "Name", "Option": "Contains", "Values": [contiene]}])
     if nombres is not None:
         out = {}
         # El filtro Name admite hasta 50 valores
@@ -170,11 +173,34 @@ def etiquetas(ssm, nombres):
         return dict(pool.map(una, nombres))
 
 
+def _uno(ssm, nombre):
+    """Lo escrito en «Ruta» es un parámetro, no una carpeta (o uno sin «/», que no está en
+    ninguna): (meta, valores) o None si no existe."""
+    try:
+        meta = describir(ssm, "", nombres=[nombre])
+    except ClientError as exc:
+        if not denegado(exc):
+            raise ParametrosError(motivo(exc)) from None
+        meta = None
+    try:
+        valores = valores_por_nombre(ssm, [nombre])
+    except ClientError as exc:
+        raise ParametrosError(motivo(exc)) from None
+    if not meta and valores.get(nombre, {}).get("no_existe"):
+        return None
+    return meta, valores
+
+
 def cargar(ssm, ruta):
     """Los parámetros de una ruta (recursivo) con valor, metadatos y etiquetas. Lo que el rol no
-    puede leer va con `bloqueado`. ParametrosError si no puede ni listar ni leer la ruta."""
-    ruta = "/" + ruta.strip("/") if ruta.strip("/") else "/"
+    puede leer va con `bloqueado`. ParametrosError si no puede ni listar ni leer la ruta. Si la
+    ruta es el nombre de un parámetro (o uno sin «/»), carga ese."""
     avisos = []
+    if not ruta.strip().startswith("/"):  # parámetro sin carpeta (p. ej. «MiParametro»)
+        nombre = ruta.strip()
+        meta, valores = _uno(ssm, nombre) or ({}, {})
+        return _montar(ssm, nombre, meta, valores, avisos)
+    ruta = "/" + ruta.strip("/") if ruta.strip("/") else "/"
     try:
         meta = describir(ssm, ruta)
     except ClientError as exc:
@@ -200,6 +226,14 @@ def cargar(ssm, ruta):
         # La ruta entera no se deja (o un descifrado tumba la página): uno a uno
         valores = valores_por_nombre(ssm, sorted(meta))
 
+    if not meta and not valores and ruta != "/":  # nada debajo: ¿es el nombre de un parámetro?
+        uno = _uno(ssm, ruta)
+        if uno:
+            meta, valores = uno
+    return _montar(ssm, ruta, meta, valores, avisos)
+
+
+def _montar(ssm, ruta, meta, valores, avisos):
     nombres = sorted(n for n in set(meta or {}) | set(valores)
                      if not valores.get(n, {}).get("no_existe"))
     legibles = [n for n in nombres if "bloqueado" not in valores.get(n, {})]
@@ -221,10 +255,11 @@ def cargar(ssm, ruta):
     return {"ruta": ruta, "parametros": parametros, "avisos": avisos}
 
 
-def explorar(ssm, prefijo="/"):
-    """Nombres (sin valores) para el árbol de «Explorar» y la búsqueda de Ajustes."""
+def explorar(ssm, prefijo="/", contiene=""):
+    """Nombres (sin valores) para el árbol de «Explorar» y la búsqueda de Ajustes. Con `contiene`,
+    solo los que llevan ese texto: así se encuentran también cuando hay más de MAX_LISTADO."""
     try:
-        meta = describir(ssm, prefijo or "/")
+        meta = describir(ssm, prefijo or "/", contiene=contiene)
     except ClientError as exc:
         raise ParametrosError(
             "Tu rol de IAM no puede listar parámetros (ssm:DescribeParameters)."
@@ -440,6 +475,30 @@ def aplicar(ssm, items, cfg):
         borrar.remove(b)
         resultados.append(b)
 
+    # Justo antes de borrar, otra vez la versión de cada uno (sin valores ni descifrar): si alguien lo ha cambiado desde
+    # la revisión (también mientras se creaban los renombrados), no se borra. SSM no tiene «borrar solo si sigue en la
+    # versión N»: entre esta lectura y el borrado queda una ventana de milisegundos que no se puede cerrar desde aquí.
+    esperada = {it.get("name"): it.get("version") for it in items if it.get("accion") == "borrar" and it.get("version")}
+    copia_de = {it.get("de"): it.get("name") for it in items if it.get("accion") == "nuevo" and it.get("de")}
+    try:
+        ahora = describir(ssm, "", [b["name"] for b in borrar]) if borrar else {}
+    except (ClientError, BotoCoreError) as exc:
+        if not denegado(exc):
+            # Otro fallo (red, límite de llamadas...): sin comprobar no se borra, pero lo ya aplicado se devuelve
+            for b in borrar:
+                b["error"] = f"No se pudo comprobar la versión antes de borrar ({motivo(exc)}): no se borra."
+            resultados += borrar
+            return resultados
+        ahora = None  # sin permiso para describir: se borra como antes (ya se comprobó al revisar)
+    for b in [b for b in borrar if ahora is not None and b["name"] in ahora and b["name"] in esperada
+              and ahora[b["name"]].get("version") != esperada[b["name"]]]:
+        b["error"] = (f"Ha cambiado en AWS mientras se aplicaba (versión {esperada[b['name']]} → "
+                      f"{ahora[b['name']].get('version')}): no se borra. "
+                      + (f"Su copia «{copia_de[b['name']]}» se creó con el valor de antes: revisa cuál dejar."
+                         if b["name"] in copia_de else "Recarga el grupo."))
+        borrar.remove(b)
+        resultados.append(b)
+
     # Borrados de 10 en 10 (el máximo de DeleteParameters)
     for i in range(0, len(borrar), 10):
         lote = borrar[i:i + 10]

{paramsx-2.5.0 → paramsx-2.5.2}/paramsx/web/static/paramsx.js

@@ -55,7 +55,7 @@
   PX.oyentes.push(st => {
     const donde = st.config ? `${st.config.profile_name}|${st.config.region_name}` : '';
     if (donde !== S.donde) {  // otro perfil o región: lo cargado era de otra cuenta
-      S.donde = donde; S.items = []; S.carpetas = null; S.ruta = ''; $('pBarra').hidden = true; $('pLista').innerHTML = '';
+      S.donde = donde; S.items = []; S.carpetas = null; B.enAws = null; S.ruta = ''; $('pBarra').hidden = true; $('pLista').innerHTML = '';
       $('pEstado').textContent = '';
       pintarDonde();
     }
@@ -90,6 +90,7 @@
     B.pidiendo = B.pidiendo || api('/api/explorar').then(r => {
       const c = {};
       r.nombres.forEach(n => { const seg = n.split('/').filter(Boolean); for (let i = 1; i < seg.length; i++) { const k = '/' + seg.slice(0, i).join('/'); c[k] = (c[k] || 0) + 1; } });
+      S.nombres = new Set(r.nombres); S.limitado = r.limitado;  // los parámetros también se buscan, no solo las carpetas
       S.carpetas = c; return c;
     }).finally(() => { B.pidiendo = null; });
     return B.pidiendo;
@@ -111,12 +112,33 @@
     try { c = await carpetas(); } catch (e) { caja.innerHTML = `<div class="sug-ayuda error">${esc(e.message)}</div>`; return; }
     if ($('pRuta').value.trim().toLowerCase() !== q) return;  // ya se ha escrito otra cosa
     // Primero las que empiezan por lo escrito, luego las más cortas
-    B.lista = Object.keys(c).filter(k => k.toLowerCase().includes(q))
-      .sort((a, b) => (b.toLowerCase().startsWith(q) - a.toLowerCase().startsWith(q)) || a.split('/').length - b.split('/').length || a.localeCompare(b)).slice(0, 200);
-    caja.innerHTML = B.lista.map((k, i) => `<div class="sug" role="option" data-i="${i}"><code>${resaltar(k, q)}</code><span class="exp-n">${c[k]}</span><button type="button" class="secundario sug-grupo" data-grupo-de="${esc(k)}" title="Guardar esta carpeta como grupo (se detecta dónde va el entorno)" tabindex="-1">+ Grupo</button></div>`).join('')
-      + `<div class="sug-ayuda">${B.lista.length ? '<kbd>↑</kbd> <kbd>↓</kbd> para elegir · «+ Grupo» la guarda en tus grupos · ' : 'Ninguna carpeta con eso. '}<kbd>Intro</kbd> carga ${B.lista.length ? 'la elegida' : 'la ruta tal cual'}${q.startsWith('/') ? '' : ' (las rutas empiezan por /)'}</div>`;
+    if (S.limitado && q.length >= 2 && !B.enAws?.has(q)) buscarEnAws(q);
+    const orden = (a, b) => (b.toLowerCase().startsWith(q) - a.toLowerCase().startsWith(q)) || a.split('/').length - b.split('/').length || a.localeCompare(b);
+    const dirs = Object.keys(c).filter(k => k.toLowerCase().includes(q)).sort(orden).slice(0, 200);
+    const params = [...(S.nombres || [])].filter(n => !c[n] && n.toLowerCase().includes(q)).sort(orden).slice(0, 100);  // los parámetros mismos, después
+    B.lista = [...dirs, ...params];
+    caja.innerHTML = B.lista.map((k, i) => i < dirs.length
+      ? `<div class="sug" role="option" data-i="${i}"><code>${resaltar(k, q)}</code><span class="exp-n">${c[k]}</span><button type="button" class="secundario sug-grupo" data-grupo-de="${esc(k)}" title="Guardar esta carpeta como grupo (se detecta dónde va el entorno)" tabindex="-1">+ Grupo</button></div>`
+      : `<div class="sug sug-param" role="option" data-i="${i}" title="Parámetro: se carga solo este"><code>${resaltar(k, q)}</code><span class="exp-n">parámetro</span></div>`).join('')
+      + `<div class="sug-ayuda">${B.enAws?.get(q) === 'buscando' ? 'Buscando también en AWS… · ' : ''}${B.lista.length ? '<kbd>↑</kbd> <kbd>↓</kbd> para elegir · «+ Grupo» la guarda en tus grupos · ' : 'Ninguna carpeta ni parámetro con eso. '}<kbd>Intro</kbd> carga ${B.lista.length ? 'la elegida' : 'la ruta tal cual'}${q.startsWith('/') ? '' : ' (las rutas empiezan por /)'}</div>`;
     marcarActiva(B.lista.length && !q.startsWith('/') ? 0 : -1);
   }
+  // Con más parámetros de los que caben en la lista, lo escrito se pide a AWS (distingue mayúsculas: tal cual, en minúsculas y en mayúsculas)
+  function buscarEnAws(q) {
+    B.enAws = B.enAws || new Map(); B.enAws.set(q, 'buscando');
+    clearTimeout(B.espera);
+    B.espera = setTimeout(async () => {
+      try {
+        const vistas = await Promise.all([...new Set([q, q.toLowerCase(), q.toUpperCase()])].map(t => api('/api/explorar?contiene=' + encodeURIComponent(t))));
+        vistas.forEach(v => v.nombres.forEach(n => {
+          if (S.nombres.has(n)) return; S.nombres.add(n);
+          const seg = n.split('/').filter(Boolean); for (let i = 1; i < seg.length; i++) { const k = '/' + seg.slice(0, i).join('/'); S.carpetas[k] = (S.carpetas[k] || 0) + 1; }
+        }));
+        B.enAws.set(q, 'hecho');
+      } catch (e) { B.enAws.delete(q); toast(e.message, true); }
+      if ($('pRuta').value.trim().toLowerCase() === q) sugerir();
+    }, 400);
+  }
   // «+ Grupo»: guarda la carpeta en la config detectando dónde va el entorno (lo mismo que Explorar y Ajustes)
   async function anadirGrupo(carpeta) {
     try {
@@ -155,7 +177,7 @@
   // ------------------------------------------------ cargar y pintar
   async function cargar() {
     const ruta = $('pRuta').value.trim();
-    if (!ruta.startsWith('/')) return toast('La ruta empieza por /', true);
+    if (!ruta) return toast('Escribe una ruta o el nombre de un parámetro', true);
     $('pEstado').textContent = `Leyendo ${ruta} de AWS…`; $('pLista').innerHTML = ''; $('pBarra').hidden = true;
     try {
       const r = await post('/api/cargar', { ruta });
@@ -365,7 +387,7 @@
         const hechos = new Set(res.resultados.filter(x => x.ok).map(x => x.name));
         const sinHacer = pendientes().filter(p => !hechos.has(nombreEnvio(p))).map(p => ({ ...p, name: nombreEnvio(p) }));
         const conflictos = new Set([...r.plan.filter(f => f.conflicto).map(f => f.name), ...mal.filter(x => /^Conflicto/.test(x.error)).map(x => x.name)]);
-        S.items = []; S.carpetas = null;
+        S.items = []; S.carpetas = null; B.enAws = null;
         await cargar();
         if (sinHacer.length && S.ruta) { reponer(S.items, sinHacer, conflictos); pintar(); }
         toast(mal.length ? `${ok} aplicados, ${mal.length} con error` : `${ok} cambios aplicados`, !!mal.length);
@@ -500,28 +522,46 @@
     modal.abrir('<h2>Explorar</h2><p>Leyendo los nombres (sin valores)…</p>');
     let r;
     try { r = await api('/api/explorar'); } catch (e) { return modal.abrir(`<h2>Explorar</h2><p class="error">${esc(e.message)}</p>`); }
+    const nombres = new Set(r.nombres);  // con más de los que caben, lo que se filtra se pide también a AWS y se añade aquí
     const arbol = q => {
       const raiz = {};
-      r.nombres.filter(n => !q || n.toLowerCase().includes(q)).forEach(n => {
+      [...nombres].filter(n => !q || n.toLowerCase().includes(q)).forEach(n => {
+        const seg = n.split('/').filter(Boolean);
+        if (seg.length === 1) { raiz[n] = raiz[n] || { _n: 1, _hoja: n }; return; }  // sin carpeta: el parámetro mismo
         let nodo = raiz;
-        n.split('/').filter(Boolean).slice(0, -1).forEach(x => { nodo[x] = nodo[x] || { _n: 0 }; nodo[x]._n++; nodo = nodo[x]; });
+        seg.slice(0, -1).forEach(x => { nodo[x] = nodo[x] || { _n: 0 }; nodo[x]._n++; nodo = nodo[x]; });
       });
       return raiz;
     };
-    const fila = (k, ruta, n, nivel) => {
+    const fila = (k, ruta, n, nivel, hoja) => {
       const e = entornoDe(k);
       return `<span class="exp-nombre nivel-${Math.min(nivel, 3)}${e ? ' entorno ' + claseEntorno(e) : ''}">${esc(k)}</span><span class="exp-n" title="Parámetros por debajo">${n}</span>
-        <span class="exp-acciones"><button type="button" class="secundario" data-ruta="${esc(ruta)}">Cargar</button><button type="button" class="secundario" data-grupo-de="${esc(ruta)}" title="Guardar esta carpeta como grupo (se detecta dónde va el entorno)">+ Grupo</button></span>`;
+        <span class="exp-acciones"><button type="button" class="secundario" data-ruta="${esc(ruta)}">Cargar</button>${hoja ? '' : `<button type="button" class="secundario" data-grupo-de="${esc(ruta)}" title="Guardar esta carpeta como grupo (se detecta dónde va el entorno)">+ Grupo</button>`}</span>`;
     };
-    const rama = (nodo, ruta, nivel, abierto) => Object.keys(nodo).filter(k => k !== '_n').sort((a, b) => a.localeCompare(b, 'es', { sensitivity: 'base' })).map(k => {
-      const r2 = `${ruta}/${k}`, hijos = rama(nodo[k], r2, nivel + 1, abierto);
-      return hijos ? `<details class="rama" ${abierto ? 'open' : ''}><summary class="exp-fila">${fila(k, r2, nodo[k]._n, nivel)}</summary><div class="hijos">${hijos}</div></details>`
-        : `<div class="exp-fila exp-hoja">${fila(k, r2, nodo[k]._n, nivel)}</div>`;
+    const rama = (nodo, ruta, nivel, abierto) => Object.keys(nodo).filter(k => k !== '_n' && k !== '_hoja').sort((a, b) => a.localeCompare(b, 'es', { sensitivity: 'base' })).map(k => {
+      const r2 = nodo[k]._hoja || `${ruta}/${k}`, hijos = rama(nodo[k], r2, nivel + 1, abierto);
+      return hijos ? `<details class="rama" ${abierto ? 'open' : ''}><summary class="exp-fila">${fila(k, r2, nodo[k]._n, nivel, nodo[k]._hoja)}</summary><div class="hijos">${hijos}</div></details>`
+        : `<div class="exp-fila exp-hoja">${fila(k, r2, nodo[k]._n, nivel, nodo[k]._hoja)}</div>`;
     }).join('');
-    modal.abrir(`<h2>Explorar · ${r.nombres.length} parámetros</h2><p>Solo nombres. «Cargar» abre la carpeta; «+ Grupo» la guarda en tu configuración para elegirla luego con su entorno.${r.limitado ? ' <span class="warn">Hay más de los que se muestran: filtra.</span>' : ''}</p>
+    modal.abrir(`<h2>Explorar · ${r.nombres.length} parámetros</h2><p>Solo nombres. «Cargar» abre la carpeta; «+ Grupo» la guarda en tu configuración para elegirla luego con su entorno.${r.limitado ? ' <span class="warn">Hay más de los que se muestran: al filtrar se buscan también en AWS.</span>' : ''}</p>
       <div class="exp-cab"><input type="search" id="pExpFiltro" placeholder="Filtrar rutas… (p. ej. rds, api)" ${NOFILL}><span class="leyenda">${cfg().entornos.map(e => `<span class="entorno ${claseEntorno(e)}">${esc(e)}</span>`).join('')}</span></div>
       <div class="arbol" id="pArbol">${rama(arbol(''), '', 0, false) || '<p class="muted">No hay parámetros.</p>'}</div>`);
-    $('pExpFiltro').addEventListener('input', e => { const q = e.target.value.trim().toLowerCase(); $('pArbol').innerHTML = rama(arbol(q), '', 0, !!q) || '<p class="muted">Ninguna ruta con eso.</p>'; });
+    let buscando = false, espera;
+    const pintarArbol = () => { const q = $('pExpFiltro').value.trim().toLowerCase(); $('pArbol').innerHTML = rama(arbol(q), '', 0, !!q) || `<p class="muted">${buscando ? 'Buscando en AWS…' : 'Ninguna ruta con eso.'}</p>`; };
+    $('pExpFiltro').addEventListener('input', () => {
+      pintarArbol();
+      const q = $('pExpFiltro').value.trim();
+      clearTimeout(espera);
+      if (!r.limitado || q.length < 2) return;
+      buscando = true; pintarArbol();
+      espera = setTimeout(async () => {  // AWS distingue mayúsculas: tal cual, en minúsculas y en mayúsculas
+        try {
+          const vistas = await Promise.all([...new Set([q, q.toLowerCase(), q.toUpperCase()])].map(t => api('/api/explorar?contiene=' + encodeURIComponent(t))));
+          vistas.forEach(v => v.nombres.forEach(n => nombres.add(n)));
+        } catch (e) { toast(e.message, true); }
+        buscando = false; if ($('pExpFiltro')?.value.trim() === q) pintarArbol();
+      }, 400);
+    });
     $('pExpFiltro').focus();
     $('pArbol').addEventListener('click', async e => {
       const g = e.target.closest('[data-grupo-de]');

{paramsx-2.5.0 → paramsx-2.5.2/paramsx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paramsx
-Version: 2.5.0
+Version: 2.5.2
 Summary: Librería para gestionar y respaldar parámetros de AWS SSM de manera sencilla y eficiente.
 Home-page: https://github.com/pistatxos/paramsx
 Author: Mariox

{paramsx-2.5.0 → paramsx-2.5.2}/tests/test_web.py

@@ -333,6 +333,71 @@ def test_renombrar_conserva_la_clave_kms_y_nunca_pierde_el_viejo(cliente, ssm, m
     assert "/dev/app/url" in ssm.params and not [o for o in ssm.ops("DeleteParameters") if "/dev/app/url" in o["Names"]]
 
 
+def test_si_el_original_cambia_mientras_se_aplica_no_se_borra(cliente, ssm, monkeypatch):
+    ssm.poner("/dev/app/url", "https://x", tipo="String", tags=TAGS)
+    ssm.poner("/dev/app/b", "b", tipo="String", tags=TAGS)
+    ps = cargar(cliente)
+    aplicar = lambda items: {x["name"]: x for x in cliente.post("/api/aplicar", json={  # noqa: E731
+        "items": items, "confirmacion": CONFIRMA, "borrados": "1"}).get_json()["resultados"]}
+
+    # Mientras se crea la copia renombrada, otro cambia el original
+    real = ssm.put_parameter
+
+    def y_otro_cambia_el_original(**kw):
+        r = real(**kw)
+        if kw["Name"] == "/dev/app/url2":
+            real(Name="/dev/app/url", Value="https://nuevo", Overwrite=True)
+        return r
+    monkeypatch.setattr(ssm, "put_parameter", y_otro_cambia_el_original)
+    r = aplicar(renombrar(ps["/dev/app/url"], "/dev/app/url2"))
+    assert r["/dev/app/url2"]["ok"] and not r["/dev/app/url"]["ok"]
+    assert "Ha cambiado en AWS mientras se aplicaba (versión 1 → 2)" in r["/dev/app/url"]["error"]
+    assert "«/dev/app/url2»" in r["/dev/app/url"]["error"]  # avisa de la copia con el valor de antes
+    assert ssm.params["/dev/app/url"]["value"] == "https://nuevo"  # el cambio del otro no se pierde
+    assert ssm.ops("DeleteParameters") == []
+    monkeypatch.setattr(ssm, "put_parameter", real)
+
+    # Un borrado normal: lo cambian entre la revisión y el borrado
+    revisar_real = ssm_web._revisar
+
+    def revisa_y_cambia(*a, **k):
+        out = revisar_real(*a, **k)
+        ssm.poner("/dev/app/b", "b-de-otro", tipo="String")
+        return out
+    monkeypatch.setattr(ssm_web, "_revisar", revisa_y_cambia)
+    r = aplicar([item(ps["/dev/app/b"], accion="borrar")])
+    assert not r["/dev/app/b"]["ok"] and "Recarga el grupo" in r["/dev/app/b"]["error"]
+    assert "/dev/app/b" in ssm.params and ssm.ops("DeleteParameters") == []
+
+    # Sin permiso para volver a leerla: se borra como antes (ya se comprobó al revisar)
+    def revisa_y_quita_describe(*a, **k):
+        out = revisar_real(*a, **k)
+        ssm.sin_describe = True
+        return out
+    monkeypatch.setattr(ssm_web, "_revisar", revisa_y_quita_describe)
+    ssm.poner("/dev/app/c", "c", tipo="String")
+    r = aplicar([{"name": "/dev/app/c", "accion": "borrar", "version": 1}])
+    assert r["/dev/app/c"]["ok"] and "/dev/app/c" not in ssm.params
+    ssm.sin_describe = False
+
+    # Si falla de otra forma al leerla, no se borra (sin comprobar no se toca)
+    def revisa_y_rompe(*a, **k):
+        out = revisar_real(*a, **k)
+        monkeypatch.setattr(ssm, "describe_parameters", lambda **kw: (_ for _ in ()).throw(
+            ssm_web.ClientError({"Error": {"Code": "ThrottlingException", "Message": "Rate exceeded"}}, "Op")))
+        return out
+    monkeypatch.setattr(ssm_web, "_revisar", revisa_y_rompe)
+    ssm.poner("/dev/app/d", "d", tipo="String")
+    r = aplicar([{"name": "/dev/app/d", "accion": "borrar", "version": 1}])
+    assert not r["/dev/app/d"]["ok"] and "No se pudo comprobar" in r["/dev/app/d"]["error"]
+    assert "/dev/app/d" in ssm.params
+    monkeypatch.undo()
+
+    # Sin cambios, se borra como siempre (b va ya por la versión 2)
+    r = aplicar([{"name": "/dev/app/b", "accion": "borrar", "version": 2}])
+    assert r["/dev/app/b"]["ok"] and "/dev/app/b" not in ssm.params
+
+
 # ---------------------------------------------------------------- nombre sin barra final
 
 def test_nuevo_con_barra_final_se_quita(cliente, ssm):
@@ -407,3 +472,22 @@ def test_js_reponer_lo_no_aplicado(tmp_path):
     assert por["/r/d"]["borrar"] is True
     # Lo que ya no está en AWS no se inventa
     assert "/r/ya-no-esta" not in por and len(out) == 6
+
+
+# ---------------------------------------------------------------- buscar un parámetro
+
+def test_en_ruta_vale_el_nombre_de_un_parametro_o_uno_sin_carpeta(cliente, ssm):
+    ssm.poner("/dev/app/clave", "x1")
+    ssm.poner("SinCarpeta", "raiz", tipo="String")
+    assert list(cargar(cliente, "/dev/app/clave")) == ["/dev/app/clave"]  # el nombre completo, no su carpeta
+    assert cargar(cliente, "/dev/app/clave")["/dev/app/clave"]["value"] == "x1"
+    assert cargar(cliente, "SinCarpeta")["SinCarpeta"]["value"] == "raiz"
+    assert cargar(cliente, "/dev/no/existe") == {}
+    assert cargar(cliente, "NoExiste") == {}
+
+
+def test_explorar_busca_en_aws_lo_que_no_cabe_en_la_lista(cliente, ssm):
+    ssm.poner("/dev/app/clave", "x1")
+    ssm.poner("/prod/otra/Cosa", "x2")
+    r = cliente.get("/api/explorar?contiene=Cosa").get_json()
+    assert r["nombres"] == ["/prod/otra/Cosa"]

paramsx-2.5.0/paramsx/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.5.0"