Lot 21 : mise à jour de Loki tenue par la façade (LOKI_UPDATE=rust)

En conteneur, l'image se met à jour par Docker : /api/update rend la
version du Go sans mise à jour disponible et la note Docker,
/api/update/apply la refuse (409). La façade sert ces deux routes quand
LOKI_UPDATE=rust et LOKI_CONTAINER=1 (sysupdate.rs) ; hors conteneur,
loki-rs ne passe pas la variable et le Go garde le remplacement du
binaire.

Parité : parity_update_test.go tire du Go les quatre réponses en
conteneur, rejouées par tests/sysupdate.rs ; TestFacadeMiseAJour côté Go.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016tcGfJWefW5kUGoC2wL8cv

rust/loki-rs/tests/common/fakego.rs

@@ -634,6 +634,7 @@ pub struct Opts {
     pub system: Option<Arc<loki_rs::system::System>>,
     pub projects: bool,
     pub mcp: Option<Arc<loki_rs::mcp::Mcp>>,
+    pub update: bool,
 }
 
 /// Comme [`start`], avec la conversation tenue par la façade
@@ -734,6 +735,7 @@ pub async fn start_with(
         system: opts.system,
         projects: opts.projects,
         mcp: opts.mcp,
+        update: opts.update,
     };
     tokio::spawn(loki_rs::proxy::serve(fl, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/lot2.rs

@@ -105,6 +105,7 @@ async fn banc(cle: Option<&str>) -> Banc {
         system: None,
         projects: false,
         mcp: None,
+        update: false,
     };
     tokio::spawn(loki_rs::proxy::serve(l, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/parity_update/update.json

@@ -0,0 +1,42 @@
+{
+  "steps": [
+    {
+      "method": "GET",
+      "out": {
+        "available": false,
+        "current": "{{VERSION}}",
+        "note": "Mise à jour par l'image Docker : docker compose pull && docker compose up -d"
+      },
+      "path": "/api/update",
+      "status": 200
+    },
+    {
+      "method": "POST",
+      "out": {
+        "available": false,
+        "current": "{{VERSION}}",
+        "note": "Mise à jour par l'image Docker : docker compose pull && docker compose up -d"
+      },
+      "path": "/api/update",
+      "status": 200
+    },
+    {
+      "method": "POST",
+      "out": {
+        "error": "Mise à jour par l'image Docker : docker compose pull && docker compose up -d",
+        "ok": false
+      },
+      "path": "/api/update/apply",
+      "status": 409
+    },
+    {
+      "method": "GET",
+      "out": {
+        "error": "Mise à jour par l'image Docker : docker compose pull && docker compose up -d",
+        "ok": false
+      },
+      "path": "/api/update/apply",
+      "status": 409
+    }
+  ]
+}

rust/loki-rs/tests/proxy.rs

@@ -111,6 +111,7 @@ async fn facade(backend: SocketAddr) -> (SocketAddr, oneshot::Sender<()>) {
         system: None,
         projects: false,
         mcp: None,
+        update: false,
     };
     tokio::spawn(loki_rs::proxy::serve(l, cfg, async move {
         let _ = rx.await;

rust/loki-rs/tests/sysupdate.rs

@@ -0,0 +1,55 @@
+//! Lot 21 : mise à jour de Loki tenue par la façade (`LOKI_UPDATE=rust`, en
+//! conteneur). Le journal tiré du Go (`internal/loki/parity_update_test.go` →
+//! `tests/parity_update/update.json`) est rejoué par la façade.
+
+mod common;
+
+use common::fakego;
+use serde_json::Value;
+
+#[tokio::test]
+async fn parite_en_conteneur() {
+    let fx: Value = serde_json::from_str(include_str!("parity_update/update.json")).unwrap();
+    let tmp = tempfile::tempdir().unwrap();
+    let (facade, _go, _stop, _) = fakego::start_with(
+        tmp.path().to_path_buf(),
+        fakego::Opts {
+            update: true,
+            ..Default::default()
+        },
+    )
+    .await;
+    for st in fx["steps"].as_array().unwrap() {
+        let (code, b) = fakego::send(
+            facade,
+            st["method"].as_str().unwrap(),
+            st["path"].as_str().unwrap(),
+            &[],
+            "",
+        )
+        .await;
+        assert_eq!(code.as_u16() as i64, st["status"].as_i64().unwrap(), "{st}");
+        // La version est celle du Go (0.15.0 pour le faux Go).
+        let out: Value =
+            serde_json::from_str(&String::from_utf8_lossy(&b).replace("0.15.0", "{{VERSION}}"))
+                .unwrap();
+        assert_eq!(out, st["out"], "{st}");
+    }
+}
+
+#[test]
+fn seulement_en_conteneur() {
+    assert!(loki_rs::sysupdate::usable(Some("1")));
+    assert!(!loki_rs::sysupdate::usable(Some("0")));
+    assert!(!loki_rs::sysupdate::usable(None));
+}
+
+#[tokio::test]
+async fn sans_la_variable_la_mise_a_jour_reste_au_go() {
+    let tmp = tempfile::tempdir().unwrap();
+    let (facade, _go, _stop) = fakego::start(tmp.path().to_path_buf()).await;
+    for p in ["/api/update", "/api/update/apply"] {
+        let (_, _, b) = fakego::get(facade, p, &[]).await;
+        assert_eq!(&b[..], format!("go:{p}").as_bytes());
+    }
+}