Restore credentials service unit test

Author: iinuwa

creds-lib/src/client.rs

@@ -5,7 +5,7 @@ use futures_lite::Stream;
 use crate::model::{BackgroundEvent, Device};
 
 /// Used for communication from trusted UI to credential service
-pub trait CredentialServiceClient {
+pub trait FlowController {
     fn get_available_public_key_devices(
         &self,
     ) -> impl Future<Output = Result<Vec<Device>, ()>> + Send;

creds-lib/src/model.rs

@@ -260,6 +260,7 @@ pub enum UsbState {
     Failed(Error),
 }
 
+#[derive(Debug)]
 pub enum BackgroundEvent {
     UsbStateChanged(UsbState),
     HybridQrStateChanged(HybridState),

creds-ui/src/client.rs

@@ -1,5 +1,5 @@
 use async_std::stream::Stream;
-use creds_lib::client::CredentialServiceClient;
+use creds_lib::client::FlowController;
 use futures_lite::StreamExt;
 use zbus::{Connection, zvariant};
 
@@ -20,7 +20,7 @@ impl DbusCredentialClient {
     }
 }
 
-impl CredentialServiceClient for DbusCredentialClient {
+impl FlowController for DbusCredentialClient {
     async fn get_available_public_key_devices(
         &self,
     ) -> std::result::Result<Vec<creds_lib::model::Device>, ()> {

creds-ui/src/gui/mod.rs

@@ -6,32 +6,32 @@ use std::{sync::Arc, thread::JoinHandle};
 use async_std::{channel::Receiver, sync::Mutex as AsyncMutex};
 
 use creds_lib::server::ViewRequest;
-use creds_lib::{client::CredentialServiceClient, model::ViewUpdate};
+use creds_lib::{client::FlowController, model::ViewUpdate};
 
 use view_model::ViewEvent;
 
-pub(super) fn start_gui_thread<C: CredentialServiceClient + Send + Sync + 'static>(
+pub(super) fn start_gui_thread<F: FlowController + Send + Sync + 'static>(
     rx: Receiver<ViewRequest>,
-    client: C,
+    flow_controller: F,
 ) -> Result<JoinHandle<()>, std::io::Error> {
     thread::Builder::new().name("gui".into()).spawn(move || {
-        let client = Arc::new(AsyncMutex::new(client));
+        let flow_controller = Arc::new(AsyncMutex::new(flow_controller));
         // D-Bus received a request and needs a window open
         while let Ok(view_request) = rx.recv_blocking() {
-            run_gui(client.clone(), view_request);
+            run_gui(flow_controller.clone(), view_request);
         }
     })
 }
 
-fn run_gui<C: CredentialServiceClient + Send + Sync + 'static>(
-    client: Arc<AsyncMutex<C>>,
+fn run_gui<F: FlowController + Send + Sync + 'static>(
+    flow_controller: Arc<AsyncMutex<F>>,
     request: ViewRequest,
 ) {
     let operation = request.operation;
     let (tx_update, rx_update) = async_std::channel::unbounded::<ViewUpdate>();
     let (tx_event, rx_event) = async_std::channel::unbounded::<ViewEvent>();
     let event_loop = async_std::task::spawn(async move {
-        let mut vm = view_model::ViewModel::new(operation, client, rx_event, tx_update);
+        let mut vm = view_model::ViewModel::new(operation, flow_controller, rx_event, tx_update);
         vm.start_event_loop().await;
         println!("event loop ended?");
     });

creds-ui/src/gui/view_model/mod.rs

@@ -11,19 +11,19 @@ use serde::{Deserialize, Serialize};
 use tracing::{error, info};
 
 use creds_lib::{
-    client::CredentialServiceClient,
+    client::FlowController,
     model::{
         BackgroundEvent, Credential, Device, Error, HybridState, Operation, Transport, UsbState,
         ViewUpdate,
     },
 };
 
 #[derive(Debug)]
-pub(crate) struct ViewModel<C>
+pub(crate) struct ViewModel<F>
 where
-    C: CredentialServiceClient + Send,
+    F: FlowController + Send,
 {
-    credential_service: Arc<AsyncMutex<C>>,
+    flow_controller: Arc<AsyncMutex<F>>,
     tx_update: Sender<ViewUpdate>,
     rx_event: Receiver<ViewEvent>,
     title: String,
@@ -39,15 +39,15 @@ where
     // hybrid_linked_state: HybridState,
 }
 
-impl<C: CredentialServiceClient + Send> ViewModel<C> {
+impl<F: FlowController + Send> ViewModel<F> {
     pub(crate) fn new(
         operation: Operation,
-        credential_service: Arc<AsyncMutex<C>>,
+        flow_controller: Arc<AsyncMutex<F>>,
         rx_event: Receiver<ViewEvent>,
         tx_update: Sender<ViewUpdate>,
     ) -> Self {
         Self {
-            credential_service,
+            flow_controller,
             rx_event,
             tx_update,
             operation,
@@ -73,7 +73,7 @@ impl<C: CredentialServiceClient + Send> ViewModel<C> {
 
     async fn update_devices(&mut self) {
         let devices = self
-            .credential_service
+            .flow_controller
             .lock()
             .await
             .get_available_public_key_devices()
@@ -111,11 +111,11 @@ impl<C: CredentialServiceClient + Send> ViewModel<C> {
         // start discovery for newly selected device
         match device.transport {
             Transport::Usb => {
-                let mut cred_service = self.credential_service.lock().await;
+                let mut cred_service = self.flow_controller.lock().await;
                 (*cred_service).get_usb_credential().await.unwrap();
             }
             Transport::HybridQr => {
-                let mut cred_service = self.credential_service.lock().await;
+                let mut cred_service = self.flow_controller.lock().await;
                 cred_service.get_hybrid_credential().await.unwrap();
             }
             _ => {
@@ -132,7 +132,7 @@ impl<C: CredentialServiceClient + Send> ViewModel<C> {
     pub(crate) async fn start_event_loop(&mut self) {
         let view_events = self.rx_event.clone().map(Event::View);
         let bg_events = {
-            let mut cred_service = self.credential_service.lock().await;
+            let mut cred_service = self.flow_controller.lock().await;
             cred_service.initiate_event_stream().await.unwrap()
         };
         let mut all_events = view_events.merge(bg_events.map(Event::Background));
@@ -147,7 +147,7 @@ impl<C: CredentialServiceClient + Send> ViewModel<C> {
                     println!("Selected device {id}");
                 }
                 Event::View(ViewEvent::UsbPinEntered(pin)) => {
-                    let mut cred_service = self.credential_service.lock().await;
+                    let mut cred_service = self.flow_controller.lock().await;
                     if cred_service.enter_client_pin(pin).await.is_err() {
                         error!("Failed to send pin to device");
                     }
@@ -159,7 +159,7 @@ impl<C: CredentialServiceClient + Send> ViewModel<C> {
                     );
 
                     if let Err(_) = self
-                        .credential_service
+                        .flow_controller
                         .lock()
                         .await
                         .select_credential(cred_id)

credsd/Cargo.toml

@@ -27,3 +27,4 @@ zbus = { version = "5.9.0", default-features = false, features = ["tokio"] }
 
 [dev-dependencies]
 gio = "0.21.0"
+zbus = { version = "5.9.0", default-features = false, features = ["blocking-api", "tokio"] }

credsd/src/credential_service/hybrid.rs

@@ -270,6 +270,15 @@ pub(super) mod test {
         stream: DummyHybridStateStream,
     }
 
+    impl DummyHybridHandler {
+        #[cfg(test)]
+        pub fn new(states: Vec<HybridStateInternal>) -> Self {
+            Self {
+                stream: DummyHybridStateStream { states },
+            }
+        }
+    }
+
     impl Default for DummyHybridHandler {
         fn default() -> Self {
             Self {