added basic unittests for PCDU

satrs-example/src/eps/pcdu.rs

@@ -101,9 +101,7 @@ impl SerialInterface for SerialInterfaceDummy {
     type Error = ();
 
     fn send(&self, data: &[u8]) -> Result<(), Self::Error> {
-        let sim_req: SimRequest = serde_json::from_slice(data).unwrap();
+        let pcdu_req: PcduRequest = serde_json::from_slice(data).unwrap();
-        let pcdu_req =
-            PcduRequest::from_sim_message(&sim_req).expect("PCDU request creation failed");
         let switch_map_mut = &mut self.switch_map.borrow_mut().0;
         match pcdu_req {
             PcduRequest::SwitchDevice { switch, state } => {
@@ -119,7 +117,7 @@ impl SerialInterface for SerialInterfaceDummy {
             PcduRequest::RequestSwitchInfo => {
                 let mut reply_deque_mut = self.reply_deque.borrow_mut();
                 reply_deque_mut.push_back(SimReply::new(&PcduReply::SwitchInfo(
-                    self.switch_map.borrow().0.clone(),
+                    switch_map_mut.clone(),
                 )));
             }
         };
@@ -381,10 +379,12 @@ impl<ComInterface: SerialInterface, TmSender: EcssTmSender> PcduHandler<ComInter
                 PcduReply::SwitchInfo(switch_info) => {
                     let switch_map_wrapper =
                         SwitchMapWrapper::from_binary_switch_map_ref(&switch_info);
-                    self.shared_switch_map
+                    let mut shared_switch_map = self
+                        .shared_switch_map
                         .lock()
-                        .expect("failed to lock switch map")
+                        .expect("failed to lock switch map");
-                        .switch_map = switch_map_wrapper.0;
+                    shared_switch_map.switch_map = switch_map_wrapper.0;
+                    shared_switch_map.valid = true;
                 }
             }
         }) {
@@ -480,8 +480,11 @@ impl<ComInterface: SerialInterface, TmSender: EcssTmSender> ModeRequestHandler
 mod tests {
     use std::sync::mpsc;
 
-    use satrs::{mode::ModeRequest, request::GenericMessage, tmtc::PacketAsVec};
+    use satrs::{
-    use satrs_example::config::components::Apid;
+        mode::ModeRequest, power::SwitchStateBinary, request::GenericMessage, tmtc::PacketAsVec,
+    };
+    use satrs_example::config::components::{Apid, MGM_HANDLER_0};
+    use satrs_minisim::eps::SwitchMapBinary;
 
     use super::*;
 
@@ -567,6 +570,51 @@ mod tests {
                 ),
             }
         }
+
+        pub fn verify_switch_info_req_was_sent(&self, expected_queue_len: usize) {
+            // Check that there is now communication happening.
+            let mut send_queue_mut = self.handler.com_interface.send_queue.borrow_mut();
+            assert_eq!(send_queue_mut.len(), expected_queue_len);
+            let packet_sent = send_queue_mut.pop_front().unwrap();
+            drop(send_queue_mut);
+            let pcdu_req: PcduRequest = serde_json::from_slice(&packet_sent).unwrap();
+            assert_eq!(pcdu_req, PcduRequest::RequestSwitchInfo);
+        }
+
+        pub fn verify_switch_req_was_sent(
+            &self,
+            expected_queue_len: usize,
+            switch_id: PcduSwitch,
+            target_state: SwitchStateBinary,
+        ) {
+            // Check that there is now communication happening.
+            let mut send_queue_mut = self.handler.com_interface.send_queue.borrow_mut();
+            assert_eq!(send_queue_mut.len(), expected_queue_len);
+            let packet_sent = send_queue_mut.pop_front().unwrap();
+            drop(send_queue_mut);
+            let pcdu_req: PcduRequest = serde_json::from_slice(&packet_sent).unwrap();
+            assert_eq!(
+                pcdu_req,
+                PcduRequest::SwitchDevice {
+                    switch: switch_id,
+                    state: target_state
+                }
+            )
+        }
+
+        pub fn verify_switch_reply_received(
+            &self,
+            expected_queue_len: usize,
+            expected_map: SwitchMapBinary,
+        ) {
+            // Check that a switch reply was read back.
+            let mut reply_received_mut = self.handler.com_interface.reply_queue.borrow_mut();
+            assert_eq!(reply_received_mut.len(), expected_queue_len);
+            let reply_received = reply_received_mut.pop_front().unwrap();
+            let sim_reply: SimReply = serde_json::from_str(&reply_received).unwrap();
+            let pcdu_reply = PcduReply::from_sim_message(&sim_reply).unwrap();
+            assert_eq!(pcdu_reply, PcduReply::SwitchInfo(expected_map));
+        }
     }
 
     #[test]
@@ -598,4 +646,71 @@ mod tests {
         );
         assert_eq!(testbench.handler.mode_and_submode().submode(), 0_u16);
     }
+
+    #[test]
+    fn test_normal_mode() {
+        let mut testbench = PcduTestbench::new();
+        testbench
+            .mode_request_tx
+            .send(GenericMessage::new(
+                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
+                ModeRequest::SetMode(ModeAndSubmode::new(DeviceMode::Normal as u32, 0)),
+            ))
+            .expect("failed to send mode request");
+        let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap();
+        assert!(!switch_map_shared.valid);
+        drop(switch_map_shared);
+        testbench.handler.periodic_operation(OpCode::RegularOp);
+        testbench
+            .handler
+            .periodic_operation(OpCode::PollAndRecvReplies);
+        // Check correctness of mode.
+        assert_eq!(
+            testbench.handler.mode_and_submode().mode(),
+            DeviceMode::Normal as u32
+        );
+        assert_eq!(testbench.handler.mode_and_submode().submode(), 0);
+
+        testbench.verify_switch_info_req_was_sent(1);
+        testbench.verify_switch_reply_received(1, SwitchMapBinaryWrapper::default().0);
+
+        let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap();
+        assert!(switch_map_shared.valid);
+        drop(switch_map_shared);
+    }
+
+    #[test]
+    fn test_switch_request_handling() {
+        let mut testbench = PcduTestbench::new();
+        testbench
+            .mode_request_tx
+            .send(GenericMessage::new(
+                MessageMetadata::new(0, PUS_MODE_SERVICE.id()),
+                ModeRequest::SetMode(ModeAndSubmode::new(DeviceMode::Normal as u32, 0)),
+            ))
+            .expect("failed to send mode request");
+        testbench
+            .switch_request_tx
+            .send(GenericMessage::new(
+                MessageMetadata::new(0, MGM_HANDLER_0.id()),
+                SwitchRequest::new(0, SwitchStateBinary::On),
+            ))
+            .expect("failed to send switch request");
+        testbench.handler.periodic_operation(OpCode::RegularOp);
+        testbench
+            .handler
+            .periodic_operation(OpCode::PollAndRecvReplies);
+
+        testbench.verify_switch_req_was_sent(2, PcduSwitch::Mgm, SwitchStateBinary::On);
+        testbench.verify_switch_info_req_was_sent(1);
+        let mut switch_map = SwitchMapBinaryWrapper::default().0;
+        *switch_map
+            .get_mut(&PcduSwitch::Mgm)
+            .expect("switch state setting failed") = SwitchStateBinary::On;
+        testbench.verify_switch_reply_received(1, switch_map);
+
+        let switch_map_shared = testbench.handler.shared_switch_map.lock().unwrap();
+        assert!(switch_map_shared.valid);
+        drop(switch_map_shared);
+    }
 }

satrs-minisim/src/lib.rs

@@ -236,7 +236,7 @@ pub mod eps {
         RequestSwitchInfo = 1,
     }
 
-    #[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
     pub enum PcduRequest {
         SwitchDevice {
             switch: PcduSwitch,