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)
         }
     }
 

satrs/src/pus/event_srv.rs

@@ -231,7 +231,7 @@ mod tests {
             .expect("writing test event failed");
         let ping_tc = PusTcCreator::new(&mut sp_header, sec_header, &app_data, true);
         let token = test_harness.send_tc(&ping_tc);
-        let request_id = token.req_id();
+        let request_id = token.request_id();
         test_harness.handle_one_tc().unwrap();
         test_harness.check_next_verification_tm(1, request_id);
         test_harness.check_next_verification_tm(3, request_id);

satrs/src/pus/scheduler_srv.rs

@@ -347,7 +347,7 @@ mod tests {
         let enable_scheduling = PusTcCreator::new(&mut reply_header, tc_header, &[0; 7], true);
         let token = test_harness.send_tc(&enable_scheduling);
 
-        let request_id = token.req_id();
+        let request_id = token.request_id();
         let time_stamp = cds::TimeProvider::new_with_u16_days(0, 0).to_vec().unwrap();
         test_harness
             .handler
@@ -408,7 +408,7 @@ mod tests {
         );
         let token = test_harness.send_tc(&enable_scheduling);
 
-        let request_id = token.req_id();
+        let request_id = token.request_id();
         test_harness.handle_one_tc().unwrap();
         test_harness.check_next_verification_tm(1, request_id);
         test_harness.check_next_verification_tm(3, request_id);

satrs/src/pus/test.rs

@@ -264,7 +264,7 @@ mod tests {
         let sec_header = PusTcSecondaryHeader::new_simple(17, 1);
         let ping_tc = PusTcCreator::new_no_app_data(&mut sp_header, sec_header, true);
         let token = test_harness.send_tc(&ping_tc);
-        let request_id = token.req_id();
+        let request_id = token.request_id();
         let result = test_harness.handle_one_tc();
         assert!(result.is_ok());
         // We should see 4 replies in the TM queue now: Acceptance TM, Start TM, ping reply and

satrs/src/pus/verification.rs

@@ -220,19 +220,19 @@ impl<T> From<VerificationErrorWithToken<T>> for VerificationOrSendErrorWithToken
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct VerificationToken<STATE> {
     state: PhantomData<STATE>,
-    req_id: RequestId,
+    request_id: RequestId,
 }
 
 impl<STATE> VerificationToken<STATE> {
     fn new(req_id: RequestId) -> VerificationToken<TcStateNone> {
         VerificationToken {
             state: PhantomData,
-            req_id,
+            request_id: req_id,
         }
     }
 
-    pub fn req_id(&self) -> RequestId {
-        self.req_id
+    pub fn request_id(&self) -> RequestId {
+        self.request_id
     }
 }
 
@@ -242,7 +242,7 @@ impl VerificationToken<TcStateAccepted> {
     pub fn new_accepted_state(req_id: RequestId) -> VerificationToken<TcStateAccepted> {
         VerificationToken {
             state: PhantomData,
-            req_id,
+            request_id: req_id,
         }
     }
 }
@@ -253,7 +253,7 @@ impl VerificationToken<TcStateStarted> {
     pub fn new_started_state(req_id: RequestId) -> VerificationToken<TcStateStarted> {
         VerificationToken {
             state: PhantomData,
-            req_id,
+            request_id: req_id,
         }
     }
 }
@@ -283,6 +283,17 @@ pub enum TcStateToken {
     Completed(VerificationToken<TcStateCompleted>),
 }
 
+impl TcStateToken {
+    pub fn request_id(&self) -> RequestId {
+        match self {
+            TcStateToken::None(token) => token.request_id(),
+            TcStateToken::Accepted(token) => token.request_id(),
+            TcStateToken::Started(token) => token.request_id(),
+            TcStateToken::Completed(token) => token.request_id(),
+        }
+    }
+}
+
 impl From<VerificationToken<TcStateNone>> for TcStateToken {
     fn from(t: VerificationToken<TcStateNone>) -> Self {
         TcStateToken::None(t)
@@ -440,7 +451,7 @@ impl<'src_data> VerificationSendable<'src_data, TcStateNone, VerifSuccess> {
     pub fn send_success_acceptance_success(self) -> VerificationToken<TcStateAccepted> {
         VerificationToken {
             state: PhantomData,
-            req_id: self.token.unwrap().req_id(),
+            request_id: self.token.unwrap().request_id(),
         }
     }
 }
@@ -449,7 +460,7 @@ impl<'src_data> VerificationSendable<'src_data, TcStateAccepted, VerifSuccess> {
     pub fn send_success_start_success(self) -> VerificationToken<TcStateStarted> {
         VerificationToken {
             state: PhantomData,
-            req_id: self.token.unwrap().req_id(),
+            request_id: self.token.unwrap().request_id(),
         }
     }
 }
@@ -588,7 +599,7 @@ impl VerificationReporterCore {
                 subservice,
                 seq_count,
                 msg_count,
-                &token.req_id,
+                &token.request_id,
                 time_stamp,
                 None::<&dyn EcssEnumeration>,
             )
@@ -618,7 +629,7 @@ impl VerificationReporterCore {
                 subservice,
                 seq_count,
                 msg_count,
-                &token.req_id,
+                &token.request_id,
                 step,
                 params,
             )
@@ -788,7 +799,7 @@ impl VerificationReporterCore {
                 Subservice::TmStepSuccess.into(),
                 seq_count,
                 msg_count,
-                &token.req_id,
+                &token.request_id,
                 time_stamp,
                 Some(&step),
             )?,
@@ -816,7 +827,7 @@ impl VerificationReporterCore {
                 Subservice::TmStepFailure.into(),
                 seq_count,
                 msg_count,
-                &token.req_id,
+                &token.request_id,
                 Some(params.step),
                 &params.params,
             )
@@ -1509,7 +1520,7 @@ pub mod test_util {
             );
             VerificationToken {
                 state: core::marker::PhantomData,
-                req_id,
+                request_id: req_id,
             }
         }
 
@@ -1522,16 +1533,16 @@ pub mod test_util {
             super::VerificationOrSendErrorWithToken<TcStateNone>,
         > {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => entry.accepted = Some(true),
                 None => panic!(
                     "unexpected acceptance success for request ID {}",
-                    token.req_id()
+                    token.request_id()
                 ),
             };
             Ok(VerificationToken {
                 state: core::marker::PhantomData,
-                req_id: token.req_id,
+                request_id: token.request_id,
             })
         }
 
@@ -1541,7 +1552,7 @@ pub mod test_util {
             params: FailParams,
         ) -> Result<(), super::VerificationOrSendErrorWithToken<TcStateNone>> {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => {
                     entry.accepted = Some(false);
                     entry.failure_data = Some(params.failure_data.to_vec());
@@ -1549,7 +1560,7 @@ pub mod test_util {
                 }
                 None => panic!(
                     "unexpected acceptance failure for request ID {}",
-                    token.req_id()
+                    token.request_id()
                 ),
             };
             Ok(())
@@ -1564,13 +1575,16 @@ pub mod test_util {
             super::VerificationOrSendErrorWithToken<super::TcStateAccepted>,
         > {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => entry.started = Some(true),
-                None => panic!("unexpected start success for request ID {}", token.req_id()),
+                None => panic!(
+                    "unexpected start success for request ID {}",
+                    token.request_id()
+                ),
             };
             Ok(VerificationToken {
                 state: core::marker::PhantomData,
-                req_id: token.req_id,
+                request_id: token.request_id,
             })
         }
 
@@ -1580,13 +1594,16 @@ pub mod test_util {
             params: FailParams,
         ) -> Result<(), super::VerificationOrSendErrorWithToken<super::TcStateAccepted>> {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => {
                     entry.started = Some(false);
                     entry.failure_data = Some(params.failure_data.to_vec());
                     entry.fail_enum = Some(params.failure_code.value());
                 }
-                None => panic!("unexpected start failure for request ID {}", token.req_id()),
+                None => panic!(
+                    "unexpected start failure for request ID {}",
+                    token.request_id()
+                ),
             };
             Ok(())
         }
@@ -1598,12 +1615,15 @@ pub mod test_util {
             step: impl spacepackets::ecss::EcssEnumeration,
         ) -> Result<(), EcssTmtcError> {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => {
                     entry.step = step.value().try_into().unwrap();
                     entry.step_status = Some(true);
                 }
-                None => panic!("unexpected start success for request ID {}", token.req_id()),
+                None => panic!(
+                    "unexpected start success for request ID {}",
+                    token.request_id()
+                ),
             };
             Ok(())
         }
@@ -1614,14 +1634,17 @@ pub mod test_util {
             params: FailParamsWithStep,
         ) -> Result<(), super::VerificationOrSendErrorWithToken<super::TcStateStarted>> {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => {
                     entry.step_status = Some(false);
                     entry.step = params.step.value().try_into().unwrap();
                     entry.failure_data = Some(params.params.failure_data.to_vec());
                     entry.fail_enum = Some(params.params.failure_code.value());
                 }
-                None => panic!("unexpected start success for request ID {}", token.req_id()),
+                None => panic!(
+                    "unexpected start success for request ID {}",
+                    token.request_id()
+                ),
             };
             Ok(())
         }
@@ -1632,11 +1655,11 @@ pub mod test_util {
             _time_stamp: &[u8],
         ) -> Result<(), super::VerificationOrSendErrorWithToken<TcState>> {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => entry.completed = Some(true),
                 None => panic!(
                     "unexpected acceptance success for request ID {}",
-                    token.req_id()
+                    token.request_id()
                 ),
             };
             Ok(())
@@ -1648,7 +1671,7 @@ pub mod test_util {
             params: FailParams,
         ) -> Result<(), super::VerificationOrSendErrorWithToken<TcState>> {
             let verif_map = self.verification_map.lock().unwrap();
-            match verif_map.borrow_mut().get_mut(&token.req_id) {
+            match verif_map.borrow_mut().get_mut(&token.request_id) {
                 Some(entry) => {
                     entry.completed = Some(false);
                     entry.failure_data = Some(params.failure_data.to_vec());
@@ -1656,7 +1679,7 @@ pub mod test_util {
                 }
                 None => panic!(
                     "unexpected acceptance success for request ID {}",
-                    token.req_id()
+                    token.request_id()
                 ),
             };
             Ok(())
@@ -1887,7 +1910,7 @@ pub mod tests {
         let mut sender = TestSender::default();
         b.vr.acceptance_success(tok, &sender, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
-        acceptance_check(&mut sender, &tok.req_id);
+        acceptance_check(&mut sender, &tok.request_id);
     }
 
     #[test]
@@ -1896,7 +1919,7 @@ pub mod tests {
         b.helper
             .acceptance_success(tok, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
-        acceptance_check(&mut b.helper.sender, &tok.req_id);
+        acceptance_check(&mut b.helper.sender, &tok.request_id);
     }
 
     fn acceptance_fail_check(sender: &mut TestSender, req_id: RequestId, stamp_buf: [u8; 7]) {
@@ -1927,7 +1950,7 @@ pub mod tests {
         let fail_params = FailParams::new_no_fail_data(stamp_buf.as_slice(), &fail_code);
         b.vr.acceptance_failure(tok, &sender, fail_params)
             .expect("Sending acceptance success failed");
-        acceptance_fail_check(&mut sender, tok.req_id, stamp_buf);
+        acceptance_fail_check(&mut sender, tok.request_id, stamp_buf);
     }
 
     #[test]
@@ -1940,7 +1963,7 @@ pub mod tests {
         b.helper
             .acceptance_failure(tok, fail_params)
             .expect("Sending acceptance success failed");
-        acceptance_fail_check(&mut b.helper.sender, tok.req_id, stamp_buf);
+        acceptance_fail_check(&mut b.helper.sender, tok.request_id, stamp_buf);
     }
 
     #[test]
@@ -1996,7 +2019,7 @@ pub mod tests {
                 time_stamp: EMPTY_STAMP,
             },
             additional_data: Some([10, 0, 0, 0, 12].to_vec()),
-            req_id: tok.req_id,
+            req_id: tok.request_id,
         };
         let mut service_queue = sender.service_queue.borrow_mut();
         assert_eq!(service_queue.len(), 1);
@@ -2051,7 +2074,7 @@ pub mod tests {
                 .expect("Sending acceptance success failed");
         b.vr.start_failure(accepted_token, &sender, fail_params)
             .expect("Start failure failure");
-        start_fail_check(&mut sender, tok.req_id, fail_data_raw);
+        start_fail_check(&mut sender, tok.request_id, fail_data_raw);
     }
 
     #[test]
@@ -2070,7 +2093,7 @@ pub mod tests {
         b.helper
             .start_failure(accepted_token, fail_params)
             .expect("Start failure failure");
-        start_fail_check(&mut b.helper.sender, tok.req_id, fail_data_raw);
+        start_fail_check(&mut b.helper.sender, tok.request_id, fail_data_raw);
     }
 
     fn step_success_check(sender: &mut TestSender, req_id: RequestId) {
@@ -2147,7 +2170,7 @@ pub mod tests {
         b.vr.step_success(&started_token, &sender, &EMPTY_STAMP, EcssEnumU8::new(1))
             .expect("Sending step 1 success failed");
         assert_eq!(sender.service_queue.borrow().len(), 4);
-        step_success_check(&mut sender, tok.req_id);
+        step_success_check(&mut sender, tok.request_id);
     }
 
     #[test]
@@ -2168,7 +2191,7 @@ pub mod tests {
             .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(1))
             .expect("Sending step 1 success failed");
         assert_eq!(b.helper.sender.service_queue.borrow().len(), 4);
-        step_success_check(&mut b.helper.sender, tok.req_id);
+        step_success_check(&mut b.helper.sender, tok.request_id);
     }
 
     fn check_step_failure(sender: &mut TestSender, req_id: RequestId, fail_data_raw: [u8; 4]) {
@@ -2242,7 +2265,7 @@ pub mod tests {
     fn test_step_failure() {
         let (b, tok) = base_init(false);
         let mut sender = TestSender::default();
-        let req_id = tok.req_id;
+        let req_id = tok.request_id;
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_data: f32 = -22.3232;
         let mut fail_data_raw = [0; 4];
@@ -2271,7 +2294,7 @@ pub mod tests {
     #[test]
     fn test_steps_failure_with_helper() {
         let (mut b, tok) = base_with_helper_init();
-        let req_id = tok.req_id;
+        let req_id = tok.request_id;
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_data: f32 = -22.3232;
         let mut fail_data_raw = [0; 4];
@@ -2351,7 +2374,7 @@ pub mod tests {
     fn test_completion_failure() {
         let (b, tok) = base_init(false);
         let mut sender = TestSender::default();
-        let req_id = tok.req_id;
+        let req_id = tok.request_id;
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_params = FailParams::new_no_fail_data(&EMPTY_STAMP, &fail_code);
 
@@ -2369,7 +2392,7 @@ pub mod tests {
     #[test]
     fn test_completion_failure_with_helper() {
         let (mut b, tok) = base_with_helper_init();
-        let req_id = tok.req_id;
+        let req_id = tok.request_id;
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_params = FailParams::new_no_fail_data(&EMPTY_STAMP, &fail_code);
 
@@ -2443,7 +2466,7 @@ pub mod tests {
                 .expect("Sending start success failed");
         b.vr.completion_success(started_token, &sender, &EMPTY_STAMP)
             .expect("Sending completion success failed");
-        completion_success_check(&mut sender, tok.req_id);
+        completion_success_check(&mut sender, tok.request_id);
     }
 
     #[test]
@@ -2460,7 +2483,7 @@ pub mod tests {
         b.helper
             .completion_success(started_token, &EMPTY_STAMP)
             .expect("Sending completion success failed");
-        completion_success_check(&mut b.helper.sender, tok.req_id);
+        completion_success_check(&mut b.helper.sender, tok.request_id);
     }
 
     #[test]