add another unittest

satrs-example/src/pus/action.rs

@@ -366,7 +366,10 @@ mod tests {
     };
 
     use crate::{
-        pus::tests::{TargetedPusRequestTestbench, TARGET_ID, TEST_APID, TEST_APID_TARGET_ID},
+        pus::tests::{
+            PusConverterTestbench, TargetedPusRequestTestbench, TARGET_ID, TEST_APID,
+            TEST_APID_TARGET_ID,
+        },
         requests::CompositeRequest,
     };
 
@@ -561,5 +564,72 @@ mod tests {
         // Verify the correct result and completion failure.
     }
 
-    // TODO: Add more dedicated tests using the dedicated converter and reply handler testbenches.
+    #[test]
+    fn converter_action_req_no_data() {
+        let mut testbench = PusConverterTestbench::new(ExampleActionRequestConverter::default());
+        let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap();
+        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
+        let action_id = 5_u32;
+        let mut app_data: [u8; 8] = [0; 8];
+        // Invalid ID, routing should fail.
+        app_data[0..4].copy_from_slice(&TEST_APID_TARGET_ID.to_be_bytes());
+        app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
+        let pus8_packet = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true);
+        let token = testbench.add_tc(&pus8_packet);
+        let result = testbench.convert(token, &[]);
+        assert!(result.is_ok());
+        let (active_req, request) = result.unwrap();
+        if let ActionRequestVariant::NoData = request.variant {
+            assert_eq!(request.action_id, action_id);
+            assert_eq!(active_req.action_id, action_id);
+            assert_eq!(
+                active_req.target_id(),
+                TargetAndApidId::new(TEST_APID, TEST_APID_TARGET_ID).raw()
+            );
+            assert_eq!(
+                active_req.token().request_id(),
+                testbench.request_id().unwrap()
+            );
+        } else {
+            panic!("unexpected action request variant");
+        }
+    }
+
+    #[test]
+    fn converter_action_req_with_data() {
+        let mut testbench = PusConverterTestbench::new(ExampleActionRequestConverter::default());
+        let mut sp_header = SpHeader::tc_unseg(TEST_APID, 0, 0).unwrap();
+        let sec_header = PusTcSecondaryHeader::new_simple(8, 128);
+        let action_id = 5_u32;
+        let mut app_data: [u8; 16] = [0; 16];
+        // Invalid ID, routing should fail.
+        app_data[0..4].copy_from_slice(&TEST_APID_TARGET_ID.to_be_bytes());
+        app_data[4..8].copy_from_slice(&action_id.to_be_bytes());
+        for i in 0..8 {
+            app_data[i + 8] = i as u8;
+        }
+        let pus8_packet = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true);
+        let token = testbench.add_tc(&pus8_packet);
+        let result = testbench.convert(token, &[]);
+        assert!(result.is_ok());
+        let (active_req, request) = result.unwrap();
+        if let ActionRequestVariant::VecData(vec) = request.variant {
+            assert_eq!(request.action_id, action_id);
+            assert_eq!(active_req.action_id, action_id);
+            assert_eq!(
+                active_req.target_id(),
+                TargetAndApidId::new(TEST_APID, TEST_APID_TARGET_ID).raw()
+            );
+            assert_eq!(
+                active_req.token().request_id(),
+                testbench.request_id().unwrap()
+            );
+            assert_eq!(vec, app_data[8..].to_vec());
+        } else {
+            panic!("unexpected action request variant");
+        }
+    }
+
+    #[test]
+    fn reply_handling_completion_success() {}
 }

satrs-example/src/pus/hk.rs

@@ -404,10 +404,8 @@ mod tests {
             true,
         );
         let accepted_token = hk_bench.add_tc(&hk_req);
-        let pus_tc_raw = hk_req.to_vec().unwrap();
-        let pus_tc_reader = PusTcReader::new(&pus_tc_raw).expect("invalid pus tc");
         let (active_req, req) = hk_bench
-            .convert(accepted_token, &pus_tc_reader.0, &[])
+            .convert(accepted_token, &[])
             .expect("conversion failed");
         assert_eq!(
             active_req.target_id(),

satrs-example/src/pus/mod.rs

@@ -479,7 +479,10 @@ pub(crate) mod tests {
         },
         request::TargetAndApidId,
         spacepackets::{
-            ecss::tc::{PusTcCreator, PusTcSecondaryHeader},
+            ecss::{
+                tc::{PusTcCreator, PusTcSecondaryHeader},
+                WritablePusPacket,
+            },
             SpHeader,
         },
     };
@@ -549,7 +552,7 @@ pub(crate) mod tests {
                 .start_success(accepted, time_stamp)
                 .expect("start failed");
             (
-                started.req_id(),
+                started.request_id(),
                 ActivePusRequestStd::new(target_id, started, Duration::from_secs(30)),
             )
         }
@@ -579,6 +582,8 @@ pub(crate) mod tests {
         pub shared_verif_map: SharedVerificationMap,
         pub verif_reporter: TestVerificationReporter,
         pub converter: Converter,
+        current_request_id: Option<verification::RequestId>,
+        current_packet: Option<Vec<u8>>,
         phantom: std::marker::PhantomData<(ActiveRequestInfo, Request)>,
     }
 
@@ -595,25 +600,39 @@ pub(crate) mod tests {
                 shared_verif_map,
                 verif_reporter: test_verif_reporter,
                 converter,
+                current_request_id: None,
+                current_packet: None,
                 phantom: std::marker::PhantomData,
             }
         }
 
         pub fn add_tc(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted> {
             let token = self.verif_reporter.add_tc(tc);
+            self.current_request_id = Some(verification::RequestId::new(tc));
+            self.current_packet = Some(tc.to_vec().unwrap());
             self.verif_reporter
                 .acceptance_success(token, &[])
                 .expect("acceptance failed")
         }
 
+        pub fn request_id(&self) -> Option<verification::RequestId> {
+            self.current_request_id
+        }
+
         pub fn convert(
             &mut self,
             token: VerificationToken<TcStateAccepted>,
-            tc_reader: &PusTcReader,
             time_stamp: &[u8],
         ) -> Result<(ActiveRequestInfo, Request), Converter::Error> {
+            if self.current_packet.is_none() {
+                return Err(GenericConversionError::InvalidAppData(
+                    "call add_tc first".to_string(),
+                ));
+            }
+            let current_packet = self.current_packet.take().unwrap();
+            let tc_reader = PusTcReader::new(&current_packet).unwrap();
             self.converter
-                .convert(token, tc_reader, time_stamp, &self.verif_reporter)
+                .convert(token, &tc_reader.0, time_stamp, &self.verif_reporter)
         }
     }