From 72527fae80bcf16fdf03890a66af65ac831fe18a Mon Sep 17 00:00:00 2001
From: E <2974895+eduardomozart@users.noreply.github.com>
Date: Fri, 14 Aug 2026 18:57:40 -0300
Subject: [PATCH 01/12] Fix: Dynamically reload apps.json for Moonlight API if
 modified on disk

This adds a timestamp check in proc::refresh() and calls it from the /applist endpoint to ensure changes made to apps.json outside the Web UI are immediately reflected in Moonlight.
---
 src/nvhttp.cpp  |  1 +
 src/process.cpp | 15 +++++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/nvhttp.cpp b/src/nvhttp.cpp
index e260141a7d7..faaf946c7c0 100644
--- a/src/nvhttp.cpp
+++ b/src/nvhttp.cpp
@@ -955,6 +955,7 @@ namespace nvhttp {
    */
   void applist(resp_https_t response, req_https_t request) {
     print_req<SunshineHTTPS>(request);
+    proc::refresh(config::stream.file_apps);
 
     pt::ptree tree;
 
diff --git a/src/process.cpp b/src/process.cpp
index ca4b50d5552..2cf00bf205c 100644
--- a/src/process.cpp
+++ b/src/process.cpp
@@ -45,6 +45,8 @@ namespace proc {
 
   proc_t proc;  ///< Global process registry used to track and terminate child processes.
 
+  std::filesystem::file_time_type last_apps_file_update;  ///< Timestamp of the last time apps.json was parsed.
+
   /**
    * @brief RAII helper that runs shutdown cleanup when destroyed.
    */
@@ -794,12 +796,25 @@ namespace proc {
 
   /**
    * @brief Refresh cached platform state from the operating system.
+   * 
+   * This function compares the current last modified time of the file to the time it was last parsed. 
+   * If the file has been modified since it was last parsed (or if it has never been parsed), 
+   * it will be re-parsed to update the app list.
    */
   void refresh(const std::string &file_name) {
+    std::error_code ec;
+    auto current_time = std::filesystem::last_write_time(file_name, ec);
+    
+    // Only parse the file if there were no errors reading the timestamp and it has been updated
+    if (!ec && current_time <= last_apps_file_update) {
+      return;
+    }
+
     auto proc_opt = proc::parse(file_name);
 
     if (proc_opt) {
       proc = std::move(*proc_opt);
+      last_apps_file_update = current_time;
     }
   }
 }  // namespace proc

From 9f01397718beb3ae73889aa773c5e6017778c984 Mon Sep 17 00:00:00 2001
From: E <2974895+eduardomozart@users.noreply.github.com>
Date: Fri, 14 Aug 2026 18:57:40 -0300
Subject: [PATCH 02/12] Fix: Dynamically reload apps.json for Moonlight API if
 modified on disk

This adds a timestamp check in proc::refresh() and calls it from the /applist endpoint to ensure changes made to apps.json outside the Web UI are immediately reflected in Moonlight.
---
 src/nvhttp.cpp  |  1 +
 src/process.cpp | 15 +++++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/nvhttp.cpp b/src/nvhttp.cpp
index e260141a7d7..faaf946c7c0 100644
--- a/src/nvhttp.cpp
+++ b/src/nvhttp.cpp
@@ -955,6 +955,7 @@ namespace nvhttp {
    */
   void applist(resp_https_t response, req_https_t request) {
     print_req<SunshineHTTPS>(request);
+    proc::refresh(config::stream.file_apps);
 
     pt::ptree tree;
 
diff --git a/src/process.cpp b/src/process.cpp
index ca4b50d5552..34dfe9c7b05 100644
--- a/src/process.cpp
+++ b/src/process.cpp
@@ -794,12 +794,27 @@ namespace proc {
 
   /**
    * @brief Refresh cached platform state from the operating system.
+   * 
+   * This function compares the current last modified time of the file to the time it was last parsed. 
+   * If the file has been modified since it was last parsed (or if it has never been parsed), 
+   * it will be re-parsed to update the app list.
    */
   void refresh(const std::string &file_name) {
+    static std::filesystem::file_time_type last_apps_file_update;  ///< Timestamp of the last time apps.json was parsed.
+    
+    std::error_code ec;
+    auto current_time = std::filesystem::last_write_time(file_name, ec);
+    
+    // Only parse the file if there were no errors reading the timestamp and it has been updated
+    if (!ec && current_time <= last_apps_file_update) {
+      return;
+    }
+
     auto proc_opt = proc::parse(file_name);
 
     if (proc_opt) {
       proc = std::move(*proc_opt);
+      last_apps_file_update = current_time;
     }
   }
 }  // namespace proc

From 99ecd7e16a0afcd5f7f3c4a6686bb60a3333156c Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 12:25:42 -0300
Subject: [PATCH 03/12] fix(process): prevent initial parse skip and preserve
 running state on refresh

The timestamp guard in proc::refresh() compared against a value-initialized
file_time_type{}, which on MSYS2 UCRT64 GCC 16.2 compares greater-or-equal
to file_time_type::clock::now(). This caused the very first refresh() call
at startup to skip parsing apps.json, leaving the application list empty.

Replace the bare file_time_type with std::optional<file_time_type> so that
nullopt unambiguously represents 'never parsed', regardless of platform
clock epoch.

Additionally, refresh() previously move-assigned the entire newly parsed
proc_t over the global proc::proc, which overwrites _app_id, _process,
_process_group, and cleanup iterators for an in-flight streaming session.
Refreshing the Moonlight app list during a session could therefore lose
process tracking, preventing /cancel from terminating the running app.

Add proc_t::update_apps_and_env() to replace only _apps and _env from the
newly parsed result, preserving all active process state.

Add regression tests covering both fixes.
---
 src/process.cpp             |  32 ++--
 src/process.h               |  11 ++
 tests/unit/test_process.cpp | 306 ++++++++++++++++++++++++++++++++++++
 3 files changed, 340 insertions(+), 9 deletions(-)

diff --git a/src/process.cpp b/src/process.cpp
index d2f4bcb2b03..a5937d6a67a 100644
--- a/src/process.cpp
+++ b/src/process.cpp
@@ -393,6 +393,11 @@ namespace proc {
     return _app.name;
   }
 
+  void proc_t::update_apps_and_env(proc_t &&other) {
+    _env = std::move(other._env);
+    _apps = std::move(other._apps);
+  }
+
   proc_t::~proc_t() {
     // It's not safe to call terminate() here because our proc_t is a static variable
     // that may be destroyed after the Boost loggers have been destroyed. Instead,
@@ -796,26 +801,35 @@ namespace proc {
 
   /**
    * @brief Refresh cached platform state from the operating system.
-   * 
-   * This function compares the current last modified time of the file to the time it was last parsed. 
-   * If the file has been modified since it was last parsed (or if it has never been parsed), 
+   *
+   * This function compares the current last modified time of the file to the time it was last parsed.
+   * If the file has been modified since it was last parsed (or if it has never been parsed),
    * it will be re-parsed to update the app list.
+   *
+   * An optional is used rather than a bare file_time_type because value-initialized
+   * file_time_type{} is not a reliable "never parsed" sentinel. On some toolchains
+   * (e.g. MSYS2 UCRT64 GCC 16.2), file_time_type::clock::now() compares
+   * less-or-equal to file_time_type{}, which would cause the initial parse to be skipped.
+   *
+   * When an app is currently running, only the cached app configuration list and environment
+   * are updated — active process state (_app_id, _process, _process_group, etc.) is preserved
+   * so that the in-flight streaming session can still be terminated properly.
    */
   void refresh(const std::string &file_name) {
-    static std::filesystem::file_time_type last_apps_file_update;  ///< Timestamp of the last time apps.json was parsed.
-    
+    static std::optional<std::filesystem::file_time_type> last_apps_file_update;  ///< Timestamp of the last successful apps.json parse, or nullopt if never parsed.
+
     std::error_code ec;
     auto current_time = std::filesystem::last_write_time(file_name, ec);
-    
-    // Only parse the file if there were no errors reading the timestamp and it has been updated
-    if (!ec && current_time <= last_apps_file_update) {
+
+    // Only skip parsing when we have a known-good timestamp and the file hasn't changed
+    if (last_apps_file_update && !ec && current_time <= *last_apps_file_update) {
       return;
     }
 
     auto proc_opt = proc::parse(file_name);
 
     if (proc_opt) {
-      proc = std::move(*proc_opt);
+      proc.update_apps_and_env(std::move(*proc_opt));
       last_apps_file_update = current_time;
     }
   }
diff --git a/src/process.h b/src/process.h
index 75a9de09ef8..c1dbe4beffb 100644
--- a/src/process.h
+++ b/src/process.h
@@ -151,6 +151,17 @@ namespace proc {
      */
     void terminate();
 
+    /**
+     * @brief Update the cached app list and environment without disturbing running process state.
+     *
+     * This replaces only the application configuration data (_apps and _env) from a newly parsed
+     * proc_t, preserving the current _app_id, _process, _process_group, and other fields that
+     * track an in-flight streaming session.
+     *
+     * @param other The newly parsed proc_t whose apps and env will be moved into this instance.
+     */
+    void update_apps_and_env(proc_t &&other);
+
   private:
     int _app_id;
 
diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 37265db6985..b884268f794 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -8,6 +8,10 @@
 // standard imports
 #include <filesystem>
 #include <fstream>
+#include <thread>
+
+// lib imports
+#include <boost/process/v1.hpp>
 
 // local imports
 #include <src/process.h>
@@ -272,3 +276,305 @@ TEST_F(ProcessPNGTest, ValidateAppImagePath_OldSteamDefault) {
   const std::string result = proc::validate_app_image_path("./assets/steam.png");
   EXPECT_EQ(result, SUNSHINE_ASSETS_DIR "/steam.png");
 }
+
+/**
+ * @brief Test fixture for proc_t::update_apps_and_env and proc::refresh.
+ */
+class ProcessRefreshTest: public BaseTest {
+protected:
+  void SetUp() override {
+    BaseTest::SetUp();
+    test_dir = fs::temp_directory_path() / "sunshine_process_refresh_test";  // NOSONAR(cpp:S5443): safe for tests
+    fs::create_directories(test_dir);
+  }
+
+  void TearDown() override {
+    if (fs::exists(test_dir)) {
+      fs::remove_all(test_dir);
+    }
+    BaseTest::TearDown();
+  }
+
+  /**
+   * @brief Write a minimal valid apps.json file.
+   *
+   * @param path Target path for the JSON file.
+   * @param app_names List of application names to include.
+   */
+  void writeAppsJson(const fs::path &path, const std::vector<std::string> &app_names) const {
+    std::ofstream file(path);
+    file << "{\n  \"env\": {},\n  \"apps\": [\n";
+    for (size_t i = 0; i < app_names.size(); ++i) {
+      file << "    { \"name\": \"" << app_names[i] << "\" }";
+      if (i + 1 < app_names.size()) {
+        file << ",";
+      }
+      file << "\n";
+    }
+    file << "  ]\n}\n";
+    file.close();
+  }
+
+  fs::path test_dir;
+};
+
+// -------------------------------------------------------------------
+// Tests for proc_t::update_apps_and_env
+// -------------------------------------------------------------------
+
+TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_UpdatesAppsList) {
+  // Build an initial proc_t with one app
+  boost::process::v1::environment env = boost::this_process::environment();
+  std::vector<proc::ctx_t> apps_initial;
+  proc::ctx_t ctx_a;
+  ctx_a.name = "AppA";
+  ctx_a.id = "100";
+  apps_initial.push_back(std::move(ctx_a));
+
+  proc::proc_t target(std::move(env), std::move(apps_initial));
+  ASSERT_EQ(target.get_apps().size(), 1u);
+  EXPECT_EQ(target.get_apps()[0].name, "AppA");
+
+  // Build a replacement proc_t with two apps
+  boost::process::v1::environment env2 = boost::this_process::environment();
+  std::vector<proc::ctx_t> apps_new;
+  proc::ctx_t ctx_b;
+  ctx_b.name = "AppB";
+  ctx_b.id = "200";
+  apps_new.push_back(std::move(ctx_b));
+  proc::ctx_t ctx_c;
+  ctx_c.name = "AppC";
+  ctx_c.id = "300";
+  apps_new.push_back(std::move(ctx_c));
+
+  proc::proc_t source(std::move(env2), std::move(apps_new));
+
+  // Act
+  target.update_apps_and_env(std::move(source));
+
+  // Assert — apps list must now contain the new apps
+  ASSERT_EQ(target.get_apps().size(), 2u);
+  EXPECT_EQ(target.get_apps()[0].name, "AppB");
+  EXPECT_EQ(target.get_apps()[1].name, "AppC");
+}
+
+TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesRunningState) {
+  // Build a proc_t and simulate a running app using the execute path.
+  // Since we cannot easily launch a real process in a unit test, we verify
+  // that update_apps_and_env does NOT reset _app_id by checking that the
+  // running() return value is preserved.
+  //
+  // We use a "placebo" app (empty cmd) which sets _app_id without spawning
+  // a real process.
+  boost::process::v1::environment env = boost::this_process::environment();
+  std::vector<proc::ctx_t> apps_initial;
+  proc::ctx_t ctx;
+  ctx.name = "Desktop";
+  ctx.id = "42";
+  // Leave cmd empty so execute() uses placebo mode
+  apps_initial.push_back(std::move(ctx));
+
+  proc::proc_t target(std::move(env), std::move(apps_initial));
+
+  // Stash into global proc so execute() can find the app by ID and
+  // terminate() / running() work correctly.
+  auto &global_proc = proc::proc;
+  auto saved = std::move(global_proc);
+  global_proc = std::move(target);
+
+  // Execute the placebo app (empty cmd → placebo = true, _app_id = 42)
+  auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
+  launch_session->width = 1920;
+  launch_session->height = 1080;
+  launch_session->fps = 60;
+  launch_session->gcmap = 0;
+  launch_session->enable_hdr = false;
+  launch_session->host_audio = false;
+  launch_session->enable_sops = false;
+  launch_session->surround_info = 2;
+  int rc = global_proc.execute(42, launch_session);
+  ASSERT_EQ(rc, 0);
+  ASSERT_EQ(global_proc.running(), 42);
+
+  // Build a replacement proc_t with a different app list
+  boost::process::v1::environment env2 = boost::this_process::environment();
+  std::vector<proc::ctx_t> apps_new;
+  proc::ctx_t ctx_new;
+  ctx_new.name = "NewApp";
+  ctx_new.id = "99";
+  apps_new.push_back(std::move(ctx_new));
+  proc::proc_t source(std::move(env2), std::move(apps_new));
+
+  // Act — update only apps/env, not running process state
+  global_proc.update_apps_and_env(std::move(source));
+
+  // Assert — app list updated, but the running state is preserved
+  ASSERT_EQ(global_proc.get_apps().size(), 1u);
+  EXPECT_EQ(global_proc.get_apps()[0].name, "NewApp");
+  EXPECT_EQ(global_proc.running(), 42) << "update_apps_and_env must not reset _app_id or placebo";
+
+  // Cleanup
+  global_proc.terminate();
+  global_proc = std::move(saved);
+}
+
+// -------------------------------------------------------------------
+// Tests for proc::refresh
+// -------------------------------------------------------------------
+
+TEST_F(ProcessRefreshTest, Refresh_ParsesFileOnFirstCall) {
+  // The first call to refresh() must always parse the file, regardless
+  // of what file_time_type{} compares to relative to the file timestamp.
+  //
+  // NOTE: Because refresh() uses static local variables (has_parsed, last_apps_file_update),
+  // this test exercises the very first call in this test process.  Subsequent
+  // tests that call refresh() share the same static state.
+  const fs::path apps_file = test_dir / "apps_initial.json";
+  writeAppsJson(apps_file, {"TestApp1", "TestApp2"});
+
+  // Save and clear global proc
+  auto saved = std::move(proc::proc);
+  proc::proc = proc::proc_t {};
+
+  ASSERT_TRUE(proc::proc.get_apps().empty());
+
+  // Act
+  proc::refresh(apps_file.string());
+
+  // Assert — must have been parsed
+  ASSERT_EQ(proc::proc.get_apps().size(), 2u);
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "TestApp1");
+  EXPECT_EQ(proc::proc.get_apps()[1].name, "TestApp2");
+
+  // Cleanup
+  proc::proc = std::move(saved);
+}
+
+TEST_F(ProcessRefreshTest, Refresh_SkipsUnchangedFile) {
+  const fs::path apps_file = test_dir / "apps_skip.json";
+  writeAppsJson(apps_file, {"OriginalApp"});
+
+  auto saved = std::move(proc::proc);
+  proc::proc = proc::proc_t {};
+
+  // First refresh — should parse
+  proc::refresh(apps_file.string());
+  ASSERT_EQ(proc::proc.get_apps().size(), 1u);
+
+  // Mutate apps in-memory to detect whether the second refresh re-parses
+  proc::proc.get_apps()[0].name = "Mutated";
+
+  // Second refresh with unchanged file — should be skipped
+  proc::refresh(apps_file.string());
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "Mutated")
+    << "refresh() should skip re-parse when the file timestamp has not changed";
+
+  // Cleanup
+  proc::proc = std::move(saved);
+}
+
+TEST_F(ProcessRefreshTest, Refresh_ReparseAfterFileModified) {
+  const fs::path apps_file = test_dir / "apps_modified.json";
+  writeAppsJson(apps_file, {"BeforeEdit"});
+
+  auto saved = std::move(proc::proc);
+  proc::proc = proc::proc_t {};
+
+  proc::refresh(apps_file.string());
+  ASSERT_EQ(proc::proc.get_apps().size(), 1u);
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "BeforeEdit");
+
+  // Wait briefly, then rewrite to ensure a new timestamp
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  writeAppsJson(apps_file, {"AfterEdit"});
+
+  // Bump the modification time to ensure it differs
+  auto new_time = fs::file_time_type::clock::now();
+  fs::last_write_time(apps_file, new_time);
+
+  proc::refresh(apps_file.string());
+  ASSERT_EQ(proc::proc.get_apps().size(), 1u);
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "AfterEdit");
+
+  // Cleanup
+  proc::proc = std::move(saved);
+}
+
+TEST_F(ProcessRefreshTest, Refresh_PreservesRunningAppDuringReparse) {
+  // This is the critical regression test: refreshing the app list while an
+  // app is running must not lose the active process state.
+  const fs::path apps_file = test_dir / "apps_running.json";
+  writeAppsJson(apps_file, {"Desktop"});
+
+  auto saved = std::move(proc::proc);
+  proc::proc = proc::proc_t {};
+
+  // Initial parse
+  proc::refresh(apps_file.string());
+  ASSERT_FALSE(proc::proc.get_apps().empty());
+
+  // Find the ID of "Desktop" as assigned by parse
+  auto desktop_id = std::stoi(proc::proc.get_apps()[0].id);
+
+  // Execute it in placebo mode (empty cmd)
+  auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
+  launch_session->width = 1920;
+  launch_session->height = 1080;
+  launch_session->fps = 60;
+  launch_session->gcmap = 0;
+  launch_session->enable_hdr = false;
+  launch_session->host_audio = false;
+  launch_session->enable_sops = false;
+  launch_session->surround_info = 2;
+  int rc = proc::proc.execute(desktop_id, launch_session);
+  ASSERT_EQ(rc, 0);
+  ASSERT_EQ(proc::proc.running(), desktop_id);
+
+  // Simulate an external edit to the apps file
+  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  writeAppsJson(apps_file, {"Desktop", "NewApp"});
+  auto new_time = fs::file_time_type::clock::now();
+  fs::last_write_time(apps_file, new_time);
+
+  // Act — refresh while the app is "running"
+  proc::refresh(apps_file.string());
+
+  // Assert — app list is updated but the running state is preserved
+  ASSERT_EQ(proc::proc.get_apps().size(), 2u);
+  EXPECT_EQ(proc::proc.running(), desktop_id)
+    << "refresh() during a running session must preserve active process state";
+
+  // Cleanup — terminate before restoring
+  proc::proc.terminate();
+  proc::proc = std::move(saved);
+}
+
+// -------------------------------------------------------------------
+// Test for file_time_type{} comparison (documents the UCRT64 issue)
+// -------------------------------------------------------------------
+
+TEST_F(ProcessRefreshTest, FileTimeType_DefaultValueComparison) {
+  // This test documents the behavior that triggered the timestamp guard
+  // regression. On some toolchains (MSYS2 UCRT64 GCC 16.2), file timestamps
+  // and clock::now() can compare less-or-equal to file_time_type{}.
+  //
+  // The fix uses std::optional<file_time_type> instead of relying on
+  // file_time_type{} as a "never parsed" indicator.
+  const auto default_time = std::filesystem::file_time_type {};
+  const auto now_time = std::filesystem::file_time_type::clock::now();
+
+  // We cannot assert the comparison direction since it is platform-dependent.
+  // Instead, just log and document both cases.
+  if (now_time <= default_time) {
+    BOOST_LOG(info) << "file_time_type::clock::now() <= file_time_type{} is TRUE on this platform "
+                    << "(this is the UCRT64 case that requires the optional sentinel)";
+  } else {
+    BOOST_LOG(info) << "file_time_type::clock::now() > file_time_type{} on this platform "
+                    << "(default-init guard would have worked, but optional is still safer)";
+  }
+
+  // The actual correctness is verified by Refresh_ParsesFileOnFirstCall above —
+  // if that test passes, the optional fix works regardless of platform behavior.
+  SUCCEED();
+}
+

From 5121de6b5f135bbd6a70e858228ebc2824377b95 Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 13:44:49 -0300
Subject: [PATCH 04/12] fix(process): preserve session env vars during refresh
 and fix tests

---
 src/process.cpp             |  9 +++++
 tests/unit/test_process.cpp | 80 ++++++++++++++++++++++++++++++++-----
 2 files changed, 79 insertions(+), 10 deletions(-)

diff --git a/src/process.cpp b/src/process.cpp
index 895216c1a5d..3e1060981ef 100644
--- a/src/process.cpp
+++ b/src/process.cpp
@@ -416,6 +416,15 @@ namespace proc {
   }
 
   void proc_t::update_apps_and_env(proc_t &&other) {
+    if (_app_id > 0 || placebo) {
+      // Preserve session-specific environment variables for the running app
+      for (const auto &var : _env) {
+        std::string name = var.get_name();
+        if (name.find("SUNSHINE_APP_") == 0 || name.find("SUNSHINE_CLIENT_") == 0) {
+          other._env[name] = var.to_string();
+        }
+      }
+    }
     _env = std::move(other._env);
     _apps = std::move(other._apps);
   }
diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index eb996652928..76323471543 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -321,7 +321,7 @@ class ProcessRefreshTest: public BaseTest {
     std::ofstream file(path);
     file << "{\n  \"env\": {},\n  \"apps\": [\n";
     for (size_t i = 0; i < app_names.size(); ++i) {
-      file << "    { \"name\": \"" << app_names[i] << "\" }";
+      file << R"(    { "name": ")" << app_names[i] << R"(" })";
       if (i + 1 < app_names.size()) {
         file << ",";
       }
@@ -329,6 +329,13 @@ class ProcessRefreshTest: public BaseTest {
     }
     file << "  ]\n}\n";
     file.close();
+
+    // Artificially advance the modification time to guarantee strict monotonicity
+    // across tests. This prevents the static last_apps_file_update in refresh()
+    // from skipping parses when tests execute rapidly in the same clock tick.
+    static int test_time_offset = 1;
+    auto new_time = fs::file_time_type::clock::now() + std::chrono::seconds(test_time_offset++);
+    fs::last_write_time(path, new_time);
   }
 
   fs::path test_dir;
@@ -434,6 +441,67 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesRunningState) {
   global_proc = std::move(saved);
 }
 
+TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
+  // Verify that session-specific environment variables (SUNSHINE_APP_NAME)
+  // are preserved through an update and available to undo commands.
+  boost::process::v1::environment env = boost::this_process::environment();
+  std::vector<proc::ctx_t> apps_initial;
+  proc::ctx_t ctx;
+  ctx.name = "Desktop";
+  ctx.id = "42";
+
+  // Create a prep command with an empty do_cmd (skipped during launch)
+  // but a valid undo_cmd that writes SUNSHINE_APP_NAME to a file.
+  fs::path out_file = test_dir / "undo_env.txt";
+#ifdef _WIN32
+  proc::cmd_t cmd("", "cmd.exe /c echo %SUNSHINE_APP_NAME% > \"" + out_file.string() + "\"", false);
+#else
+  proc::cmd_t cmd("", "sh -c \"echo $SUNSHINE_APP_NAME > '" + out_file.string() + "'\"", false);
+#endif
+  ctx.prep_cmds.push_back(std::move(cmd));
+  apps_initial.push_back(std::move(ctx));
+
+  proc::proc_t target(std::move(env), std::move(apps_initial));
+
+  auto &global_proc = proc::proc;
+  auto saved = std::move(global_proc);
+  global_proc = std::move(target);
+
+  // Launch placebo app to populate session variables
+  auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
+  launch_session->width = 1920;
+  launch_session->height = 1080;
+  launch_session->fps = 60;
+  int rc = global_proc.execute(42, launch_session);
+  ASSERT_EQ(rc, 0);
+
+  // Update apps and env
+  boost::process::v1::environment env2 = boost::this_process::environment();
+  std::vector<proc::ctx_t> apps_new;
+  proc::ctx_t ctx_new;
+  ctx_new.name = "NewApp";
+  ctx_new.id = "99";
+  apps_new.push_back(std::move(ctx_new));
+  proc::proc_t source(std::move(env2), std::move(apps_new));
+
+  global_proc.update_apps_and_env(std::move(source));
+
+  // Terminate should run the undo_cmd using the preserved environment
+  global_proc.terminate();
+
+  // Verify the undo command wrote the app name to the file
+  ASSERT_TRUE(fs::exists(out_file)) << "Undo command failed to execute or write file";
+  std::ifstream ifs(out_file);
+  std::string content;
+  std::getline(ifs, content);
+  
+  // Trim trailing whitespace (like \r\n from echo)
+  content.erase(content.find_last_not_of(" \n\r\t") + 1);
+  EXPECT_EQ(content, "Desktop") << "SUNSHINE_APP_NAME was not preserved in the environment";
+
+  global_proc = std::move(saved);
+}
+
 // -------------------------------------------------------------------
 // Tests for proc::refresh
 // -------------------------------------------------------------------
@@ -500,14 +568,9 @@ TEST_F(ProcessRefreshTest, Refresh_ReparseAfterFileModified) {
   ASSERT_EQ(proc::proc.get_apps().size(), 1u);
   EXPECT_EQ(proc::proc.get_apps()[0].name, "BeforeEdit");
 
-  // Wait briefly, then rewrite to ensure a new timestamp
-  std::this_thread::sleep_for(std::chrono::milliseconds(50));
+  // Rewrite to ensure a new timestamp
   writeAppsJson(apps_file, {"AfterEdit"});
 
-  // Bump the modification time to ensure it differs
-  auto new_time = fs::file_time_type::clock::now();
-  fs::last_write_time(apps_file, new_time);
-
   proc::refresh(apps_file.string());
   ASSERT_EQ(proc::proc.get_apps().size(), 1u);
   EXPECT_EQ(proc::proc.get_apps()[0].name, "AfterEdit");
@@ -547,10 +610,7 @@ TEST_F(ProcessRefreshTest, Refresh_PreservesRunningAppDuringReparse) {
   ASSERT_EQ(proc::proc.running(), desktop_id);
 
   // Simulate an external edit to the apps file
-  std::this_thread::sleep_for(std::chrono::milliseconds(50));
   writeAppsJson(apps_file, {"Desktop", "NewApp"});
-  auto new_time = fs::file_time_type::clock::now();
-  fs::last_write_time(apps_file, new_time);
 
   // Act — refresh while the app is "running"
   proc::refresh(apps_file.string());

From 514e186510aaccb946bd8a939f0abbb9ec9157c9 Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:07:21 -0300
Subject: [PATCH 05/12] test(process): silence sonar cpp:S3656 warning for
 protected members in test fixtures

---
 tests/unit/test_process.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 76323471543..3104b245f91 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -34,7 +34,7 @@ TEST(ProcessTest, PrepareCommand) {
 #endif
 }
 
-class ProcessPNGTest: public BaseTest {
+class ProcessPNGTest: public BaseTest {  // NOSONAR(cpp:S3656): protected members are intentional for test fixture subclassing
 protected:
   void SetUp() override {
     BaseTest::SetUp();
@@ -296,7 +296,7 @@ TEST_F(ProcessPNGTest, ValidateAppImagePath_OldSteamDefault) {
 /**
  * @brief Test fixture for proc_t::update_apps_and_env and proc::refresh.
  */
-class ProcessRefreshTest: public BaseTest {
+class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected members are intentional for test fixture subclassing
 protected:
   void SetUp() override {
     BaseTest::SetUp();

From 95ed08abf2ebf34eccd9c514cced3761e43bc298 Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:16:18 -0300
Subject: [PATCH 06/12] test(process): simplify undo test command using inline
 strings and bypass ci impersonation

---
 tests/unit/test_process.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 3104b245f91..ccd4f3321ed 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -454,9 +454,9 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
   // but a valid undo_cmd that writes SUNSHINE_APP_NAME to a file.
   fs::path out_file = test_dir / "undo_env.txt";
 #ifdef _WIN32
-  proc::cmd_t cmd("", "cmd.exe /c echo %SUNSHINE_APP_NAME% > \"" + out_file.string() + "\"", false);
+  proc::cmd_t cmd("", "cmd.exe /c echo %SUNSHINE_APP_NAME% > \"" + out_file.string() + "\"", true);
 #else
-  proc::cmd_t cmd("", "sh -c \"echo $SUNSHINE_APP_NAME > '" + out_file.string() + "'\"", false);
+  proc::cmd_t cmd("", "sh -c \"echo $SUNSHINE_APP_NAME > '" + out_file.string() + "'\"", true);
 #endif
   ctx.prep_cmds.push_back(std::move(cmd));
   apps_initial.push_back(std::move(ctx));

From c19554acbc171e4e2d8d8b3b7363be62e69c410d Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:47:39 -0300
Subject: [PATCH 07/12] test(process): mock undo environment test to bypass ci
 process launch restrictions and secure get_env

---
 src/process.h               |  9 +++++++++
 tests/unit/test_process.cpp | 34 +++++++++++-----------------------
 2 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/src/process.h b/src/process.h
index 110f5a35ad8..26bb470a196 100644
--- a/src/process.h
+++ b/src/process.h
@@ -160,6 +160,15 @@ namespace proc {
      */
     void update_apps_and_env(proc_t &&other);
 
+#ifdef SUNSHINE_TESTS
+    /**
+     * @brief Get the current process environment (strictly for unit tests).
+     */
+    const boost::process::v1::environment &get_env() const {
+      return _env;
+    }
+#endif
+
   private:
     int _app_id;
 
diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index ccd4f3321ed..97c86259d29 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -449,16 +449,6 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
   proc::ctx_t ctx;
   ctx.name = "Desktop";
   ctx.id = "42";
-
-  // Create a prep command with an empty do_cmd (skipped during launch)
-  // but a valid undo_cmd that writes SUNSHINE_APP_NAME to a file.
-  fs::path out_file = test_dir / "undo_env.txt";
-#ifdef _WIN32
-  proc::cmd_t cmd("", "cmd.exe /c echo %SUNSHINE_APP_NAME% > \"" + out_file.string() + "\"", true);
-#else
-  proc::cmd_t cmd("", "sh -c \"echo $SUNSHINE_APP_NAME > '" + out_file.string() + "'\"", true);
-#endif
-  ctx.prep_cmds.push_back(std::move(cmd));
   apps_initial.push_back(std::move(ctx));
 
   proc::proc_t target(std::move(env), std::move(apps_initial));
@@ -467,7 +457,7 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
   auto saved = std::move(global_proc);
   global_proc = std::move(target);
 
-  // Launch placebo app to populate session variables
+  // Launch placebo app to populate session variables in _env
   auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
   launch_session->width = 1920;
   launch_session->height = 1080;
@@ -475,7 +465,7 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
   int rc = global_proc.execute(42, launch_session);
   ASSERT_EQ(rc, 0);
 
-  // Update apps and env
+  // Update apps and env (simulating a reload)
   boost::process::v1::environment env2 = boost::this_process::environment();
   std::vector<proc::ctx_t> apps_new;
   proc::ctx_t ctx_new;
@@ -486,19 +476,17 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
 
   global_proc.update_apps_and_env(std::move(source));
 
-  // Terminate should run the undo_cmd using the preserved environment
-  global_proc.terminate();
+  // Verify that SUNSHINE_APP_NAME survived the swap
+  const auto &active_env = global_proc.get_env();
+  EXPECT_TRUE(active_env.count("SUNSHINE_APP_NAME") > 0)
+    << "SUNSHINE_APP_NAME was wiped from the environment during update_apps_and_env";
 
-  // Verify the undo command wrote the app name to the file
-  ASSERT_TRUE(fs::exists(out_file)) << "Undo command failed to execute or write file";
-  std::ifstream ifs(out_file);
-  std::string content;
-  std::getline(ifs, content);
-  
-  // Trim trailing whitespace (like \r\n from echo)
-  content.erase(content.find_last_not_of(" \n\r\t") + 1);
-  EXPECT_EQ(content, "Desktop") << "SUNSHINE_APP_NAME was not preserved in the environment";
+  if (active_env.count("SUNSHINE_APP_NAME") > 0) {
+    EXPECT_EQ(active_env.at("SUNSHINE_APP_NAME").to_string(), "Desktop");
+  }
 
+  // Cleanup
+  global_proc.terminate();
   global_proc = std::move(saved);
 }
 

From ed2eae206d44df5ab88308a5c88306d2bd70a7a8 Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:12:13 -0300
Subject: [PATCH 08/12] test(process): refactor to remove duplicate code blocks
 and fix sonar quality gate

---
 src/process.cpp             |   2 +-
 tests/unit/test_process.cpp | 187 ++++++++++++++++--------------------
 2 files changed, 86 insertions(+), 103 deletions(-)

diff --git a/src/process.cpp b/src/process.cpp
index 3e1060981ef..3ca8a718f34 100644
--- a/src/process.cpp
+++ b/src/process.cpp
@@ -853,7 +853,7 @@ namespace proc {
     auto current_time = std::filesystem::last_write_time(file_name, ec);
 
     // Only skip parsing when we have a known-good timestamp and the file hasn't changed
-    if (last_apps_file_update && !ec && current_time <= *last_apps_file_update) {
+    if (last_apps_file_update && !ec && current_time == *last_apps_file_update) {
       return;
     }
 
diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 97c86259d29..2f99fde0387 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -338,6 +338,53 @@ class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected me
     fs::last_write_time(path, new_time);
   }
 
+  void runUpdateWithPlaceboSession(const std::function<void(proc::proc_t &)> &assertions) {
+    boost::process::v1::environment env = boost::this_process::environment();
+    std::vector<proc::ctx_t> apps_initial;
+    proc::ctx_t ctx;
+    ctx.name = "Desktop";
+    ctx.id = "42";
+    apps_initial.push_back(std::move(ctx));
+
+    proc::proc_t target(std::move(env), std::move(apps_initial));
+
+    auto &global_proc = proc::proc;
+    auto saved = std::move(global_proc);
+    global_proc = std::move(target);
+
+    // Launch placebo app to populate session variables in _env
+    auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
+    launch_session->width = 1920;
+    launch_session->height = 1080;
+    launch_session->fps = 60;
+    launch_session->gcmap = 0;
+    launch_session->enable_hdr = false;
+    launch_session->host_audio = false;
+    launch_session->enable_sops = false;
+    launch_session->surround_info = 2;
+    int rc = global_proc.execute(42, launch_session);
+    ASSERT_EQ(rc, 0);
+
+    // Build a replacement proc_t with a different app list
+    boost::process::v1::environment env2 = boost::this_process::environment();
+    std::vector<proc::ctx_t> apps_new;
+    proc::ctx_t ctx_new;
+    ctx_new.name = "NewApp";
+    ctx_new.id = "99";
+    apps_new.push_back(std::move(ctx_new));
+    proc::proc_t source(std::move(env2), std::move(apps_new));
+
+    // Act — update only apps/env, not running process state
+    global_proc.update_apps_and_env(std::move(source));
+
+    // Run custom assertions
+    assertions(global_proc);
+
+    // Cleanup
+    global_proc.terminate();
+    global_proc = std::move(saved);
+  }
+
   fs::path test_dir;
 };
 
@@ -382,112 +429,23 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_UpdatesAppsList) {
 }
 
 TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesRunningState) {
-  // Build a proc_t and simulate a running app using the execute path.
-  // Since we cannot easily launch a real process in a unit test, we verify
-  // that update_apps_and_env does NOT reset _app_id by checking that the
-  // running() return value is preserved.
-  //
-  // We use a "placebo" app (empty cmd) which sets _app_id without spawning
-  // a real process.
-  boost::process::v1::environment env = boost::this_process::environment();
-  std::vector<proc::ctx_t> apps_initial;
-  proc::ctx_t ctx;
-  ctx.name = "Desktop";
-  ctx.id = "42";
-  // Leave cmd empty so execute() uses placebo mode
-  apps_initial.push_back(std::move(ctx));
-
-  proc::proc_t target(std::move(env), std::move(apps_initial));
-
-  // Stash into global proc so execute() can find the app by ID and
-  // terminate() / running() work correctly.
-  auto &global_proc = proc::proc;
-  auto saved = std::move(global_proc);
-  global_proc = std::move(target);
-
-  // Execute the placebo app (empty cmd → placebo = true, _app_id = 42)
-  auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
-  launch_session->width = 1920;
-  launch_session->height = 1080;
-  launch_session->fps = 60;
-  launch_session->gcmap = 0;
-  launch_session->enable_hdr = false;
-  launch_session->host_audio = false;
-  launch_session->enable_sops = false;
-  launch_session->surround_info = 2;
-  int rc = global_proc.execute(42, launch_session);
-  ASSERT_EQ(rc, 0);
-  ASSERT_EQ(global_proc.running(), 42);
-
-  // Build a replacement proc_t with a different app list
-  boost::process::v1::environment env2 = boost::this_process::environment();
-  std::vector<proc::ctx_t> apps_new;
-  proc::ctx_t ctx_new;
-  ctx_new.name = "NewApp";
-  ctx_new.id = "99";
-  apps_new.push_back(std::move(ctx_new));
-  proc::proc_t source(std::move(env2), std::move(apps_new));
-
-  // Act — update only apps/env, not running process state
-  global_proc.update_apps_and_env(std::move(source));
-
-  // Assert — app list updated, but the running state is preserved
-  ASSERT_EQ(global_proc.get_apps().size(), 1u);
-  EXPECT_EQ(global_proc.get_apps()[0].name, "NewApp");
-  EXPECT_EQ(global_proc.running(), 42) << "update_apps_and_env must not reset _app_id or placebo";
-
-  // Cleanup
-  global_proc.terminate();
-  global_proc = std::move(saved);
+  runUpdateWithPlaceboSession([](proc::proc_t &global_proc) {
+    ASSERT_EQ(global_proc.get_apps().size(), 1u);
+    EXPECT_EQ(global_proc.get_apps()[0].name, "NewApp");
+    EXPECT_EQ(global_proc.running(), 42) << "update_apps_and_env must not reset _app_id or placebo";
+  });
 }
 
 TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
-  // Verify that session-specific environment variables (SUNSHINE_APP_NAME)
-  // are preserved through an update and available to undo commands.
-  boost::process::v1::environment env = boost::this_process::environment();
-  std::vector<proc::ctx_t> apps_initial;
-  proc::ctx_t ctx;
-  ctx.name = "Desktop";
-  ctx.id = "42";
-  apps_initial.push_back(std::move(ctx));
-
-  proc::proc_t target(std::move(env), std::move(apps_initial));
+  runUpdateWithPlaceboSession([](proc::proc_t &global_proc) {
+    const auto &active_env = global_proc.get_env();
+    EXPECT_TRUE(active_env.count("SUNSHINE_APP_NAME") > 0)
+      << "SUNSHINE_APP_NAME was wiped from the environment during update_apps_and_env";
 
-  auto &global_proc = proc::proc;
-  auto saved = std::move(global_proc);
-  global_proc = std::move(target);
-
-  // Launch placebo app to populate session variables in _env
-  auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
-  launch_session->width = 1920;
-  launch_session->height = 1080;
-  launch_session->fps = 60;
-  int rc = global_proc.execute(42, launch_session);
-  ASSERT_EQ(rc, 0);
-
-  // Update apps and env (simulating a reload)
-  boost::process::v1::environment env2 = boost::this_process::environment();
-  std::vector<proc::ctx_t> apps_new;
-  proc::ctx_t ctx_new;
-  ctx_new.name = "NewApp";
-  ctx_new.id = "99";
-  apps_new.push_back(std::move(ctx_new));
-  proc::proc_t source(std::move(env2), std::move(apps_new));
-
-  global_proc.update_apps_and_env(std::move(source));
-
-  // Verify that SUNSHINE_APP_NAME survived the swap
-  const auto &active_env = global_proc.get_env();
-  EXPECT_TRUE(active_env.count("SUNSHINE_APP_NAME") > 0)
-    << "SUNSHINE_APP_NAME was wiped from the environment during update_apps_and_env";
-
-  if (active_env.count("SUNSHINE_APP_NAME") > 0) {
-    EXPECT_EQ(active_env.at("SUNSHINE_APP_NAME").to_string(), "Desktop");
-  }
-
-  // Cleanup
-  global_proc.terminate();
-  global_proc = std::move(saved);
+    if (active_env.count("SUNSHINE_APP_NAME") > 0) {
+      EXPECT_EQ(active_env.at("SUNSHINE_APP_NAME").to_string(), "Desktop");
+    }
+  });
 }
 
 // -------------------------------------------------------------------
@@ -567,6 +525,31 @@ TEST_F(ProcessRefreshTest, Refresh_ReparseAfterFileModified) {
   proc::proc = std::move(saved);
 }
 
+TEST_F(ProcessRefreshTest, Refresh_ReparseAfterFileMtimeDecreased) {
+  const fs::path apps_file = test_dir / "apps_reverted.json";
+  writeAppsJson(apps_file, {"Initial"});
+
+  auto saved = std::move(proc::proc);
+  proc::proc = proc::proc_t {};
+
+  proc::refresh(apps_file.string());
+  ASSERT_EQ(proc::proc.get_apps().size(), 1u);
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "Initial");
+
+  // Write a new file but artificially set its timestamp to the PAST
+  // simulating a backup restoration or git checkout
+  writeAppsJson(apps_file, {"OlderBackup"});
+  auto past_time = fs::file_time_type::clock::now() - std::chrono::hours(1);
+  fs::last_write_time(apps_file, past_time);
+
+  proc::refresh(apps_file.string());
+  ASSERT_EQ(proc::proc.get_apps().size(), 1u);
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "OlderBackup")
+    << "refresh() must re-parse if the modification time differs, even if it is strictly earlier";
+
+  proc::proc = std::move(saved);
+}
+
 TEST_F(ProcessRefreshTest, Refresh_PreservesRunningAppDuringReparse) {
   // This is the critical regression test: refreshing the app list while an
   // app is running must not lose the active process state.

From 19c4e06185fe4c3f69140b7fb3742272a6784e5b Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:31:01 -0300
Subject: [PATCH 09/12] test(process): refactor helper to use template
 parameter and const to satisfy sonar

---
 tests/unit/test_process.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 2f99fde0387..4e85b9fd637 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -338,7 +338,8 @@ class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected me
     fs::last_write_time(path, new_time);
   }
 
-  void runUpdateWithPlaceboSession(const std::function<void(proc::proc_t &)> &assertions) {
+  template <typename Func>
+  void runUpdateWithPlaceboSession(Func assertions) const {
     boost::process::v1::environment env = boost::this_process::environment();
     std::vector<proc::ctx_t> apps_initial;
     proc::ctx_t ctx;

From 57fa788b08af2b47606c77b0ea5737b67962eeb4 Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:34:04 -0300
Subject: [PATCH 10/12] test(process): refactor to use a dedicated test fixture
 instead of a helper function

---
 tests/unit/test_process.cpp | 76 +++++++++++++++++++------------------
 1 file changed, 39 insertions(+), 37 deletions(-)

diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 4e85b9fd637..d8c5b045b07 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -338,8 +338,18 @@ class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected me
     fs::last_write_time(path, new_time);
   }
 
-  template <typename Func>
-  void runUpdateWithPlaceboSession(Func assertions) const {
+  fs::path test_dir;
+};
+
+class ProcessUpdateTest : public ProcessRefreshTest { // NOSONAR(cpp:S3656): protected members are intentional for test fixture subclassing
+protected:
+  proc::proc_t saved_global_proc;
+
+  void SetUp() override {
+    ProcessRefreshTest::SetUp();
+
+    saved_global_proc = std::move(proc::proc);
+
     boost::process::v1::environment env = boost::this_process::environment();
     std::vector<proc::ctx_t> apps_initial;
     proc::ctx_t ctx;
@@ -348,12 +358,8 @@ class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected me
     apps_initial.push_back(std::move(ctx));
 
     proc::proc_t target(std::move(env), std::move(apps_initial));
+    proc::proc = std::move(target);
 
-    auto &global_proc = proc::proc;
-    auto saved = std::move(global_proc);
-    global_proc = std::move(target);
-
-    // Launch placebo app to populate session variables in _env
     auto launch_session = std::make_shared<rtsp_stream::launch_session_t>();
     launch_session->width = 1920;
     launch_session->height = 1080;
@@ -363,30 +369,26 @@ class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected me
     launch_session->host_audio = false;
     launch_session->enable_sops = false;
     launch_session->surround_info = 2;
-    int rc = global_proc.execute(42, launch_session);
+    int rc = proc::proc.execute(42, launch_session);
     ASSERT_EQ(rc, 0);
+  }
 
-    // Build a replacement proc_t with a different app list
+  void TearDown() override {
+    proc::proc.terminate();
+    proc::proc = std::move(saved_global_proc);
+    
+    ProcessRefreshTest::TearDown();
+  }
+
+  proc::proc_t buildNewSource() {
     boost::process::v1::environment env2 = boost::this_process::environment();
     std::vector<proc::ctx_t> apps_new;
     proc::ctx_t ctx_new;
     ctx_new.name = "NewApp";
     ctx_new.id = "99";
     apps_new.push_back(std::move(ctx_new));
-    proc::proc_t source(std::move(env2), std::move(apps_new));
-
-    // Act — update only apps/env, not running process state
-    global_proc.update_apps_and_env(std::move(source));
-
-    // Run custom assertions
-    assertions(global_proc);
-
-    // Cleanup
-    global_proc.terminate();
-    global_proc = std::move(saved);
+    return proc::proc_t(std::move(env2), std::move(apps_new));
   }
-
-  fs::path test_dir;
 };
 
 // -------------------------------------------------------------------
@@ -429,24 +431,24 @@ TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_UpdatesAppsList) {
   EXPECT_EQ(target.get_apps()[1].name, "AppC");
 }
 
-TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesRunningState) {
-  runUpdateWithPlaceboSession([](proc::proc_t &global_proc) {
-    ASSERT_EQ(global_proc.get_apps().size(), 1u);
-    EXPECT_EQ(global_proc.get_apps()[0].name, "NewApp");
-    EXPECT_EQ(global_proc.running(), 42) << "update_apps_and_env must not reset _app_id or placebo";
-  });
+TEST_F(ProcessUpdateTest, UpdateAppsAndEnv_PreservesRunningState) {
+  proc::proc.update_apps_and_env(buildNewSource());
+
+  ASSERT_EQ(proc::proc.get_apps().size(), 1u);
+  EXPECT_EQ(proc::proc.get_apps()[0].name, "NewApp");
+  EXPECT_EQ(proc::proc.running(), 42) << "update_apps_and_env must not reset _app_id or placebo";
 }
 
-TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
-  runUpdateWithPlaceboSession([](proc::proc_t &global_proc) {
-    const auto &active_env = global_proc.get_env();
-    EXPECT_TRUE(active_env.count("SUNSHINE_APP_NAME") > 0)
-      << "SUNSHINE_APP_NAME was wiped from the environment during update_apps_and_env";
+TEST_F(ProcessUpdateTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
+  proc::proc.update_apps_and_env(buildNewSource());
 
-    if (active_env.count("SUNSHINE_APP_NAME") > 0) {
-      EXPECT_EQ(active_env.at("SUNSHINE_APP_NAME").to_string(), "Desktop");
-    }
-  });
+  const auto &active_env = proc::proc.get_env();
+  EXPECT_TRUE(active_env.count("SUNSHINE_APP_NAME") > 0)
+    << "SUNSHINE_APP_NAME was wiped from the environment during update_apps_and_env";
+
+  if (active_env.count("SUNSHINE_APP_NAME") > 0) {
+    EXPECT_EQ(active_env.at("SUNSHINE_APP_NAME").to_string(), "Desktop");
+  }
 }
 
 // -------------------------------------------------------------------

From 85a4384a50b3587383e63c182a696489d78a189b Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:52:54 -0300
Subject: [PATCH 11/12] test(process): add const qualifier to test fixture
 helper method

---
 tests/unit/test_process.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index d8c5b045b07..865bead94dd 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -380,7 +380,7 @@ class ProcessUpdateTest : public ProcessRefreshTest { // NOSONAR(cpp:S3656): pro
     ProcessRefreshTest::TearDown();
   }
 
-  proc::proc_t buildNewSource() {
+  proc::proc_t buildNewSource() const {
     boost::process::v1::environment env2 = boost::this_process::environment();
     std::vector<proc::ctx_t> apps_new;
     proc::ctx_t ctx_new;

From 0fbbe2689fce4cc5d5c193019ac48e0d0ff327a6 Mon Sep 17 00:00:00 2001
From: Eduardo Mozart de Oliveira
 <2974895+eduardomozart@users.noreply.github.com>
Date: Tue, 29 Sep 2026 17:09:02 -0300
Subject: [PATCH 12/12] test(process): apply clang-format and doxygen standards
 to test fixture

---
 tests/unit/test_process.cpp | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/tests/unit/test_process.cpp b/tests/unit/test_process.cpp
index 865bead94dd..3cae66d6c1d 100644
--- a/tests/unit/test_process.cpp
+++ b/tests/unit/test_process.cpp
@@ -341,7 +341,10 @@ class ProcessRefreshTest: public BaseTest {  // NOSONAR(cpp:S3656): protected me
   fs::path test_dir;
 };
 
-class ProcessUpdateTest : public ProcessRefreshTest { // NOSONAR(cpp:S3656): protected members are intentional for test fixture subclassing
+/**
+ * @brief Test fixture for testing updates to process apps and environment.
+ */
+class ProcessUpdateTest: public ProcessRefreshTest {  // NOSONAR(cpp:S3656): protected members are intentional for test fixture subclassing
 protected:
   proc::proc_t saved_global_proc;
 
@@ -376,10 +379,14 @@ class ProcessUpdateTest : public ProcessRefreshTest { // NOSONAR(cpp:S3656): pro
   void TearDown() override {
     proc::proc.terminate();
     proc::proc = std::move(saved_global_proc);
-    
     ProcessRefreshTest::TearDown();
   }
 
+  /**
+   * @brief Build a simulated source environment and app list for the update.
+   *
+   * @return A constructed proc_t containing the new applications and environment.
+   */
   proc::proc_t buildNewSource() const {
     boost::process::v1::environment env2 = boost::this_process::environment();
     std::vector<proc::ctx_t> apps_new;
@@ -391,10 +398,6 @@ class ProcessUpdateTest : public ProcessRefreshTest { // NOSONAR(cpp:S3656): pro
   }
 };
 
-// -------------------------------------------------------------------
-// Tests for proc_t::update_apps_and_env
-// -------------------------------------------------------------------
-
 TEST_F(ProcessRefreshTest, UpdateAppsAndEnv_UpdatesAppsList) {
   // Build an initial proc_t with one app
   boost::process::v1::environment env = boost::this_process::environment();
@@ -451,10 +454,6 @@ TEST_F(ProcessUpdateTest, UpdateAppsAndEnv_PreservesSessionEnvironment) {
   }
 }
 
-// -------------------------------------------------------------------
-// Tests for proc::refresh
-// -------------------------------------------------------------------
-
 TEST_F(ProcessRefreshTest, Refresh_ParsesFileOnFirstCall) {
   // The first call to refresh() must always parse the file, regardless
   // of what file_time_type{} compares to relative to the file timestamp.
@@ -599,10 +598,6 @@ TEST_F(ProcessRefreshTest, Refresh_PreservesRunningAppDuringReparse) {
   proc::proc = std::move(saved);
 }
 
-// -------------------------------------------------------------------
-// Test for file_time_type{} comparison (documents the UCRT64 issue)
-// -------------------------------------------------------------------
-
 TEST_F(ProcessRefreshTest, FileTimeType_DefaultValueComparison) {
   // This test documents the behavior that triggered the timestamp guard
   // regression. On some toolchains (MSYS2 UCRT64 GCC 16.2), file timestamps
@@ -627,4 +622,3 @@ TEST_F(ProcessRefreshTest, FileTimeType_DefaultValueComparison) {
   // if that test passes, the optional fix works regardless of platform behavior.
   SUCCEED();
 }
-