From 60091279fab81dc9482c020049ceefa90fd10e4b Mon Sep 17 00:00:00 2001
From: Robin Mueller <muellerr@irs.uni-stuttgart.de>
Date: Tue, 4 Feb 2025 16:21:12 +0100
Subject: [PATCH] continue tests

---
 satrs/src/dev_mgmt.rs | 80 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 75 insertions(+), 5 deletions(-)

diff --git a/satrs/src/dev_mgmt.rs b/satrs/src/dev_mgmt.rs
index 2bbffa9..c9405b7 100644
--- a/satrs/src/dev_mgmt.rs
+++ b/satrs/src/dev_mgmt.rs
@@ -1,7 +1,7 @@
 use crate::{
     mode::{ModeAndSubmode, ModeReply, ModeRequest, ModeRequestSender},
     mode_tree::{ModeStoreProvider, ModeStoreVec},
-    queue::GenericTargetedMessagingError,
+    queue::{GenericSendError, GenericTargetedMessagingError},
     request::{GenericMessage, RequestId},
     ComponentId,
 };
@@ -13,7 +13,7 @@ pub struct ActiveModeCommandContext {
     pub active_request_id: RequestId,
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, PartialEq, Eq)]
 pub enum DevManagerHelperResult {
     #[default]
     Idle,
@@ -152,6 +152,38 @@ impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
         self.state
     }
 
+    pub fn send_mode_cmd_to_child(
+        &mut self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        mode_and_submode: ModeAndSubmode,
+        forced: bool,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        self.target_mode = Some(mode_and_submode);
+        let val = self
+            .children_mode_store
+            .0
+            .iter_mut()
+            .find(|val| val.id() == target_id);
+        if val.is_none() {
+            return Err(GenericSendError::TargetDoesNotExist(target_id).into());
+        }
+        let val = val.unwrap();
+        mode_req_sender.send_mode_request(
+            request_id,
+            target_id,
+            ModeRequest::SetMode {
+                mode_and_submode,
+                forced,
+            },
+        )?;
+        val.awaiting_reply = true;
+        self.active_request_id = Some(request_id);
+        self.state = ModeTreeHelperState::ModeCommanding;
+        Ok(())
+    }
+
     pub fn send_announce_mode_cmd_to_children(
         &self,
         request_id: RequestId,
@@ -235,7 +267,10 @@ impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
 
 #[cfg(test)]
 mod tests {
-    use crate::mode::{tests::ModeReqSenderMock, UNKNOWN_MODE};
+    use crate::{
+        mode::{tests::ModeReqSenderMock, UNKNOWN_MODE},
+        request::MessageMetadata,
+    };
 
     use super::*;
 
@@ -244,6 +279,11 @@ mod tests {
         Id2 = 2,
     }
 
+    pub enum ExampleMode {
+        Mode1 = 1,
+        Mode2 = 2,
+    }
+
     #[test]
     fn test_basic() {
         let assy_helper = DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
@@ -292,8 +332,38 @@ mod tests {
 
     #[test]
     fn test_mode_commanding_one_child() {
-        let mut assy_helper = DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
+        let mut assy_helper = AssemblyCommandingHelper::default();
         let mode_req_sender = ModeReqSenderMock::default();
-        //assy_helper.send_mode_cmd_to_all_children_with_reply_awaition(1, , forced, mode_req_sender)
+        assy_helper.add_mode_child(ExampleId::Id1 as u64, UNKNOWN_MODE);
+        let expected_mode = ModeAndSubmode::new(ExampleMode::Mode1 as u32, 0);
+        assy_helper
+            .send_mode_cmd_to_child(
+                1,
+                ExampleId::Id1 as u64,
+                expected_mode,
+                false,
+                &mode_req_sender,
+            )
+            .unwrap();
+        assert_eq!(mode_req_sender.requests.borrow().len(), 1);
+        let req = mode_req_sender.requests.borrow_mut().pop_front().unwrap();
+        assert_eq!(req.target_id, ExampleId::Id1 as u64);
+        assert_eq!(req.request_id, 1);
+        assert_eq!(
+            req.request,
+            ModeRequest::SetMode {
+                mode_and_submode: expected_mode,
+                forced: false
+            }
+        );
+        assert_eq!(assy_helper.state(), ModeTreeHelperState::ModeCommanding);
+        let reply = GenericMessage::new(
+            MessageMetadata::new(1, ExampleId::Id1 as u64),
+            ModeReply::ModeReply(expected_mode),
+        );
+        assert_eq!(
+            assy_helper.handle_mode_reply(&reply),
+            AssemblyHelperResult::ModeCommandingDone
+        );
     }
 }