clean up, continue test

satrs/src/dev_mgmt.rs

@@ -27,6 +27,16 @@ pub enum DevManagerHelperError {
 }
 
 pub trait DevManagerUserHook: Debug {
+    fn send_mode_cmd_to_child(
+        &self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        mode: ModeAndSubmode,
+        forced: bool,
+        children_mode_store: &mut ModeStoreVec,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericTargetedMessagingError>;
+
     fn send_mode_cmds_to_children(
         &self,
         request_id: RequestId,
@@ -62,6 +72,30 @@ impl DevManagerUserHook for TransparentDevManagerHook {
         }
         Ok(())
     }
+
+    fn send_mode_cmd_to_child(
+        &self,
+        request_id: RequestId,
+        target_id: ComponentId,
+        mode: ModeAndSubmode,
+        forced: bool,
+        children_mode_store: &mut ModeStoreVec,
+        mode_req_sender: &impl ModeRequestSender,
+    ) -> Result<(), GenericTargetedMessagingError> {
+        let mut_val = children_mode_store
+            .get_mut(target_id)
+            .ok_or(GenericSendError::TargetDoesNotExist(target_id))?;
+        mut_val.awaiting_reply = true;
+        mode_req_sender.send_mode_request(
+            request_id,
+            target_id,
+            ModeRequest::SetMode {
+                mode_and_submode: mode,
+                forced,
+            },
+        )?;
+        Ok(())
+    }
 }
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
@@ -112,13 +146,13 @@ impl<UserHook: DevManagerUserHook> DevManagerCommandingHelper<UserHook> {
         mode_req_sender: &impl ModeRequestSender,
     ) -> Result<(), GenericTargetedMessagingError> {
         self.state = DevManagerCommandingState::new_active_cmd(mode_and_submode, request_id);
-        mode_req_sender.send_mode_request(
+        self.user_hook.send_mode_cmd_to_child(
             request_id,
             target_id,
-            ModeRequest::SetMode {
-                mode_and_submode,
-                forced,
-            },
+            mode_and_submode,
+            forced,
+            &mut self.children_mode_store,
+            mode_req_sender,
         )?;
         Ok(())
     }
@@ -152,38 +186,6 @@ 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,
@@ -332,12 +334,12 @@ mod tests {
 
     #[test]
     fn test_mode_commanding_one_child() {
-        let mut assy_helper = AssemblyCommandingHelper::default();
+        let mut assy_helper = DevManagerCommandingHelper::new(TransparentDevManagerHook::default());
         let mode_req_sender = ModeReqSenderMock::default();
         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(
+            .send_mode_cmd_to_one_child(
                 1,
                 ExampleId::Id1 as u64,
                 expected_mode,
@@ -356,14 +358,26 @@ mod tests {
                 forced: false
             }
         );
-        assert_eq!(assy_helper.state(), ModeTreeHelperState::ModeCommanding);
+        matches!(
+            assy_helper.state(),
+            DevManagerCommandingState::AwaitingReplies { .. }
+        );
+        if let DevManagerCommandingState::AwaitingReplies(ctx) = assy_helper.state() {
+            assert_eq!(ctx.target_mode, expected_mode);
+            assert_eq!(ctx.active_request_id, 1);
+        }
         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
-        );
+        if let DevManagerHelperResult::ModeCommandingDone(ActiveModeCommandContext {
+            target_mode,
+            active_request_id,
+        }) = assy_helper.handle_mode_reply(&reply).unwrap()
+        {
+            assert_eq!(target_mode, expected_mode);
+            assert_eq!(active_request_id, 1);
+        }
+        matches!(assy_helper.state(), DevManagerCommandingState::Idle);
     }
 }