Make run_test infallible

Running a test should never abort the execution of the remaining tests.
This could happen before if `get_mullvad_app_logs()` failed, which was a
bit surprising.

test/test-manager/src/logging.rs

@@ -115,7 +115,7 @@ pub struct TestOutput {
     pub error_messages: Vec<Output>,
     pub test_name: &'static str,
     pub result: Result<Result<(), Error>, PanicMessage>,
-    pub log_output: LogOutput,
+    pub log_output: Option<LogOutput>,
 }
 
 impl TestOutput {
@@ -150,21 +150,28 @@ impl TestOutput {
         }
 
         println!("{}", format!("TEST {} HAD LOGS:", self.test_name).red());
-        match &self.log_output.settings_json {
-            Ok(settings) => println!("settings.json: {}", settings),
-            Err(e) => println!("Could not get settings.json: {}", e),
-        }
+        match &self.log_output {
+            Some(log) => {
+                match &log.settings_json {
+                    Ok(settings) => println!("settings.json: {}", settings),
+                    Err(e) => println!("Could not get settings.json: {}", e),
+                }
 
-        match &self.log_output.log_files {
-            Ok(log_files) => {
-                for log in log_files {
-                    match log {
-                        Ok(log) => println!("Log {}:\n{}", log.name.to_str().unwrap(), log.content),
-                        Err(e) => println!("Could not get log: {}", e),
+                match &log.log_files {
+                    Ok(log_files) => {
+                        for log in log_files {
+                            match log {
+                                Ok(log) => {
+                                    println!("Log {}:\n{}", log.name.to_str().unwrap(), log.content)
+                                }
+                                Err(e) => println!("Could not get log: {}", e),
+                            }
+                        }
                     }
+                    Err(e) => println!("Could not get logs: {}", e),
                 }
             }
-            Err(e) => println!("Could not get logs: {}", e),
+            None => println!("Missing logs for {}", self.test_name),
         }
 
         println!(

test/test-manager/src/run_tests.rs

@@ -100,8 +100,7 @@ pub async fn run(
             test.name,
             test_context.clone(),
         )
-        .await
-        .context("Failed to run test")?;
+        .await;
 
         if test.mullvad_client_version == MullvadClientVersion::New {
             // Try to reset the daemon state if the test failed OR if the test doesn't explicitly
@@ -183,7 +182,7 @@ pub async fn run_test<F, R, MullvadClient>(
     test: &F,
     test_name: &'static str,
     test_context: super::tests::TestContext,
-) -> Result<TestOutput, Error>
+) -> TestOutput
 where
     F: Fn(super::tests::TestContext, ServiceClient, MullvadClient) -> R,
     R: Future<Output = Result<(), Error>>,
@@ -211,15 +210,13 @@ where
             }
         }
     }
-    let log_output = runner_rpc
-        .get_mullvad_app_logs()
-        .await
-        .map_err(Error::Rpc)?;
 
-    Ok(TestOutput {
+    let log_output = runner_rpc.get_mullvad_app_logs().await.ok();
+
+    TestOutput {
         log_output,
         test_name,
         error_messages: output,
         result,
-    })
+    }
 }