Merge branch 'endrift/screenreader' into 'master'

Screen reader fixes

See merge request holo/steamos-manager!5

src/screenreader.rs

@@ -10,6 +10,7 @@ use gio::{prelude::SettingsExt, Settings};
 use lazy_static::lazy_static;
 use serde_json::{Map, Value};
 use std::collections::HashMap;
+use std::io::ErrorKind;
 use std::ops::RangeInclusive;
 use std::path::PathBuf;
 use tokio::fs::{read_to_string, write};
@@ -105,7 +106,12 @@ impl<'dbus> OrcaManager<'dbus> {
                 .set_boolean(SCREEN_READER_SETTING, enable)
                 .map_err(|e| anyhow!("Unable to set screen reader enabled gsetting, {e}"))?;
         }
-        self.set_orca_enabled(enable).await?;
+        if let Err(e) = self.set_orca_enabled(enable).await {
+            match e.downcast_ref::<std::io::Error>() {
+                Some(e) if e.kind() == ErrorKind::NotFound => (),
+                _ => return Err(e),
+            }
+        }
         if enable {
             self.restart_orca().await?;
         } else {
@@ -267,51 +273,83 @@ impl<'dbus> OrcaManager<'dbus> {
         Ok(write(self.settings_path()?, data.as_bytes()).await?)
     }
 
-    #[cfg(not(test))]
     async fn restart_orca(&self) -> Result<()> {
         trace!("Restarting orca...");
+        self.orca_unit.enable().await?;
         self.orca_unit.restart().await
     }
 
-    #[cfg(test)]
-    async fn restart_orca(&self) -> Result<()> {
-        Ok(())
-    }
-
-    #[cfg(not(test))]
     async fn stop_orca(&self) -> Result<()> {
         trace!("Stopping orca...");
+        self.orca_unit.disable().await?;
         self.orca_unit.stop().await
     }
-
-    #[cfg(test)]
-    async fn stop_orca(&self) -> Result<()> {
-        Ok(())
-    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::systemd::test::{MockManager, MockUnit};
+    use crate::systemd::EnableState;
     use crate::testing;
+    use std::time::Duration;
     use tokio::fs::{copy, remove_file};
+    use tokio::time::sleep;
 
     #[tokio::test]
     async fn test_enable_disable() {
         let mut h = testing::start();
+        let mut unit = MockUnit::default();
+        unit.active = String::from("inactive");
+        unit.unit_file = String::from("disabled");
+        let connection = h.new_dbus().await.expect("dbus");
+        connection
+            .request_name("org.freedesktop.systemd1")
+            .await
+            .expect("request_name");
+        let object_server = connection.object_server();
+        object_server
+            .at("/org/freedesktop/systemd1/unit/orca_2eservice", unit)
+            .await
+            .expect("at");
+        object_server
+            .at("/org/freedesktop/systemd1", MockManager::default())
+            .await
+            .expect("at");
+
+        sleep(Duration::from_millis(10)).await;
+
+        let unit = SystemdUnit::new(connection.clone(), "orca.service")
+            .await
+            .expect("unit");
+
+        let mut manager = OrcaManager::new(&connection)
+            .await
+            .expect("OrcaManager::new");
+        manager.set_enabled(true).await.unwrap();
+        assert_eq!(manager.enabled(), true);
+        assert_eq!(unit.active().await.unwrap(), true);
+        assert_eq!(unit.enabled().await.unwrap(), EnableState::Enabled);
+
+        manager.set_enabled(false).await.unwrap();
+        assert_eq!(manager.enabled(), false);
+        assert_eq!(unit.active().await.unwrap(), false);
+        assert_eq!(unit.enabled().await.unwrap(), EnableState::Disabled);
+
         copy(TEST_ORCA_SETTINGS, h.test.path().join(ORCA_SETTINGS))
             .await
             .unwrap();
-        let mut manager = OrcaManager::new(&h.new_dbus().await.expect("new_dbus"))
+        manager.load_values().await.unwrap();
-            .await
-            .expect("OrcaManager::new");
-        let enable_result = manager.set_enabled(true).await;
-        assert!(enable_result.is_ok());
-        assert_eq!(manager.enabled(), true);
 
-        let disable_result = manager.set_enabled(false).await;
+        manager.set_enabled(true).await.unwrap();
-        assert!(disable_result.is_ok());
+        assert_eq!(manager.enabled(), true);
+        assert_eq!(unit.active().await.unwrap(), true);
+        assert_eq!(unit.enabled().await.unwrap(), EnableState::Enabled);
+
+        manager.set_enabled(false).await.unwrap();
         assert_eq!(manager.enabled(), false);
+        assert_eq!(unit.active().await.unwrap(), false);
+        assert_eq!(unit.enabled().await.unwrap(), EnableState::Disabled);
     }
 
     #[tokio::test]

src/systemd.rs

@@ -115,7 +115,6 @@ impl<'dbus> SystemdUnit<'dbus> {
         Ok(())
     }
 
-    #[allow(unused)]
     pub async fn enable(&self) -> Result<bool> {
         let manager = SystemdManagerProxy::new(&self.connection).await?;
         let (_, res) = manager
@@ -124,7 +123,6 @@ impl<'dbus> SystemdUnit<'dbus> {
         Ok(!res.is_empty())
     }
 
-    #[allow(unused)]
     pub async fn disable(&self) -> Result<bool> {
         let manager = SystemdManagerProxy::new(&self.connection).await?;
         let res = manager