better naming

satrs-core/src/pus/event_srv.rs

@@ -1,52 +1,37 @@
 use crate::events::EventU32;
 use crate::pus::event_man::{EventRequest, EventRequestWithToken};
 use crate::pus::verification::TcStateToken;
-use crate::pus::{
-    EcssTcReceiver, EcssTmSender, PartialPusHandlingError, PusPacketHandlerResult,
-    PusPacketHandlingError,
-};
-use alloc::boxed::Box;
+use crate::pus::{PartialPusHandlingError, PusPacketHandlerResult, PusPacketHandlingError};
 use spacepackets::ecss::event::Subservice;
 use spacepackets::ecss::PusPacket;
 use std::sync::mpsc::Sender;
 
-use super::verification::VerificationReporterWithSender;
-use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHandler};
+use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 
 pub struct PusService5EventHandler<TcInMemConverter: EcssTcInMemConverter> {
-    pub psb: PusServiceHandler<TcInMemConverter>,
+    pub service_helper: PusServiceHelper<TcInMemConverter>,
     event_request_tx: Sender<EventRequestWithToken>,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> PusService5EventHandler<TcInMemConverter> {
     pub fn new(
-        tc_receiver: Box<dyn EcssTcReceiver>,
-        tm_sender: Box<dyn EcssTmSender>,
-        tm_apid: u16,
-        verification_handler: VerificationReporterWithSender,
-        tc_in_mem_converter: TcInMemConverter,
+        service_handler: PusServiceHelper<TcInMemConverter>,
         event_request_tx: Sender<EventRequestWithToken>,
     ) -> Self {
         Self {
-            psb: PusServiceHandler::new(
-                tc_receiver,
-                tm_sender,
-                tm_apid,
-                verification_handler,
-                tc_in_mem_converter,
-            ),
+            service_helper: service_handler,
             event_request_tx,
         }
     }
 
     pub fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-        let possible_packet = self.psb.retrieve_and_accept_next_packet()?;
+        let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
         if possible_packet.is_none() {
             return Ok(PusPacketHandlerResult::Empty);
         }
         let ecss_tc_and_token = possible_packet.unwrap();
         let tc = self
-            .psb
+            .service_helper
             .tc_in_mem_converter
             .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
         let subservice = tc.subservice();
@@ -66,7 +51,7 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService5EventHandler<TcInMemConv
             let user_data = tc.user_data();
             let event_u32 = EventU32::from(u32::from_be_bytes(user_data[0..4].try_into().unwrap()));
             let start_token = self
-                .psb
+                .service_helper
                 .common
                 .verification_handler
                 .borrow_mut()
@@ -126,3 +111,53 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService5EventHandler<TcInMemConv
         Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use delegate::delegate;
+    use spacepackets::ecss::{tc::PusTcCreator, tm::PusTmReader};
+    use std::sync::mpsc::Sender;
+
+    use crate::pus::{
+        event_man::EventRequestWithToken,
+        tests::{PusServiceHandlerWithStoreCommon, PusTestHarness},
+        verification::{TcStateAccepted, VerificationToken},
+        EcssTcInStoreConverter, PusPacketHandlerResult, PusPacketHandlingError,
+    };
+
+    use super::PusService5EventHandler;
+
+    struct Pus5HandlerWithStoreTester {
+        common: PusServiceHandlerWithStoreCommon,
+        handler: PusService5EventHandler<EcssTcInStoreConverter>,
+    }
+
+    impl Pus5HandlerWithStoreTester {
+        pub fn new(event_request_tx: Sender<EventRequestWithToken>) -> Self {
+            let (common, srv_handler) = PusServiceHandlerWithStoreCommon::new();
+            let pus_17_handler = PusService5EventHandler::new(srv_handler, event_request_tx);
+            Self {
+                common,
+                handler: pus_17_handler,
+            }
+        }
+    }
+
+    impl PusTestHarness for Pus5HandlerWithStoreTester {
+        delegate! {
+            to self.common {
+                fn send_tc(&mut self, tc: &PusTcCreator) -> VerificationToken<TcStateAccepted>;
+                fn read_next_tm(&mut self) -> PusTmReader<'_>;
+                fn check_next_verification_tm<STATE>(
+                    &self,
+                    subservice: u8,
+                    token: VerificationToken<STATE>,
+                );
+            }
+
+            to self.handler {
+                fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError>;
+            }
+        }
+    }
+}

satrs-core/src/pus/mod.rs

@@ -833,19 +833,21 @@ pub mod std_mod {
         }
     }
 
-    /// This is a high-level PUS packet handler. It performs some of the boilerplate acitivities
-    /// involved when handling PUS telecommands and it can be used to implement the handling of
-    /// PUS telecommands for certain PUS telecommands groups (for example individual services).
+    /// This is a high-level PUS packet handler helper.
+    ///
+    /// It performs some of the boilerplate acitivities involved when handling PUS telecommands and
+    /// it can be used to implement the handling of PUS telecommands for certain PUS telecommands
+    /// groups (for example individual services).
     ///
     /// This base class can handle PUS telecommands backed by different memory storage machanisms
     /// by using the [EcssTcInMemConverter] abstraction. This object provides some convenience
     /// methods to make the generic parts of TC handling easier.
-    pub struct PusServiceHandler<TcInMemConverter: EcssTcInMemConverter> {
+    pub struct PusServiceHelper<TcInMemConverter: EcssTcInMemConverter> {
         pub common: PusServiceBase,
         pub tc_in_mem_converter: TcInMemConverter,
     }
 
-    impl<TcInMemConverter: EcssTcInMemConverter> PusServiceHandler<TcInMemConverter> {
+    impl<TcInMemConverter: EcssTcInMemConverter> PusServiceHelper<TcInMemConverter> {
         pub fn new(
             tc_receiver: Box<dyn EcssTcReceiver>,
             tm_sender: Box<dyn EcssTmSender>,
@@ -931,7 +933,7 @@ pub mod tests {
     use super::{
         EcssTcAndToken, EcssTcInStoreConverter, EcssTcInVecConverter, MpscTcReceiver,
         MpscTmAsVecSender, MpscTmInStoreSender, PusPacketHandlerResult, PusPacketHandlingError,
-        PusServiceHandler, TcInMemory,
+        PusServiceHelper, TcInMemory,
     };
 
     pub const TEST_APID: u16 = 0x101;
@@ -987,7 +989,7 @@ pub mod tests {
         /// [PusServiceHandler] which might be required for a specific PUS service handler.
         ///
         /// The PUS service handler is instantiated with a [EcssTcInStoreConverter].
-        pub fn new() -> (Self, PusServiceHandler<EcssTcInStoreConverter>) {
+        pub fn new() -> (Self, PusServiceHelper<EcssTcInStoreConverter>) {
             let pool_cfg = PoolCfg::new(vec![(16, 16), (8, 32), (4, 64)]);
             let tc_pool = LocalPool::new(pool_cfg.clone());
             let tm_pool = LocalPool::new(pool_cfg);
@@ -1015,7 +1017,7 @@ pub mod tests {
                     tm_receiver: tm_rx,
                     verification_handler: verification_handler.clone(),
                 },
-                PusServiceHandler::new(
+                PusServiceHelper::new(
                     Box::new(test_srv_tc_receiver),
                     Box::new(test_srv_tm_sender),
                     TEST_APID,
@@ -1079,7 +1081,7 @@ pub mod tests {
     }
 
     impl PusServiceHandlerWithVecCommon {
-        pub fn new() -> (Self, PusServiceHandler<EcssTcInVecConverter>) {
+        pub fn new() -> (Self, PusServiceHelper<EcssTcInVecConverter>) {
             let (test_srv_tc_tx, test_srv_tc_rx) = mpsc::channel();
             let (tm_tx, tm_rx) = mpsc::channel();
 
@@ -1097,7 +1099,7 @@ pub mod tests {
                     tm_receiver: tm_rx,
                     verification_handler: verification_handler.clone(),
                 },
-                PusServiceHandler::new(
+                PusServiceHelper::new(
                     Box::new(test_srv_tc_receiver),
                     Box::new(test_srv_tm_sender),
                     TEST_APID,

satrs-core/src/pus/scheduler_srv.rs

@@ -6,7 +6,7 @@ use spacepackets::time::cds::TimeProvider;
 use std::boxed::Box;
 
 use super::verification::VerificationReporterWithSender;
-use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHandler};
+use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 
 /// This is a helper class for [std] environments to handle generic PUS 11 (scheduling service)
 /// packets. This handler is constrained to using the [PusScheduler], but is able to process
@@ -17,7 +17,7 @@ use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHandler};
 /// [Self::scheduler] and [Self::scheduler_mut] function and then use the scheduler API to release
 /// telecommands when applicable.
 pub struct PusService11SchedHandler<TcInMemConverter: EcssTcInMemConverter> {
-    pub psb: PusServiceHandler<TcInMemConverter>,
+    pub psb: PusServiceHelper<TcInMemConverter>,
     shared_tc_store: SharedPool,
     scheduler: PusScheduler,
 }
@@ -33,7 +33,7 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService11SchedHandler<TcInMemCon
         scheduler: PusScheduler,
     ) -> Self {
         Self {
-            psb: PusServiceHandler::new(
+            psb: PusServiceHelper::new(
                 tc_receiver,
                 tm_sender,
                 tm_apid,
@@ -175,3 +175,6 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService11SchedHandler<TcInMemCon
         Ok(PusPacketHandlerResult::RequestHandled)
     }
 }
+
+#[cfg(test)]
+mod tests {}

satrs-core/src/pus/test.rs

@@ -5,29 +5,29 @@ use spacepackets::ecss::tm::{PusTmCreator, PusTmSecondaryHeader};
 use spacepackets::ecss::PusPacket;
 use spacepackets::SpHeader;
 
-use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHandler};
+use super::{EcssTcInMemConverter, PusServiceBase, PusServiceHelper};
 
 /// This is a helper class for [std] environments to handle generic PUS 17 (test service) packets.
 /// This handler only processes ping requests and generates a ping reply for them accordingly.
 pub struct PusService17TestHandler<TcInMemConverter: EcssTcInMemConverter> {
-    pub psb: PusServiceHandler<TcInMemConverter>,
+    pub service_helper: PusServiceHelper<TcInMemConverter>,
 }
 
 impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConverter> {
-    pub fn new(service_handler: PusServiceHandler<TcInMemConverter>) -> Self {
+    pub fn new(service_helper: PusServiceHelper<TcInMemConverter>) -> Self {
         Self {
-            psb: service_handler,
+            service_helper,
         }
     }
 
     pub fn handle_one_tc(&mut self) -> Result<PusPacketHandlerResult, PusPacketHandlingError> {
-        let possible_packet = self.psb.retrieve_and_accept_next_packet()?;
+        let possible_packet = self.service_helper.retrieve_and_accept_next_packet()?;
         if possible_packet.is_none() {
             return Ok(PusPacketHandlerResult::Empty);
         }
         let ecss_tc_and_token = possible_packet.unwrap();
         let tc = self
-            .psb
+            .service_helper
             .tc_in_mem_converter
             .convert_ecss_tc_in_memory_to_reader(&ecss_tc_and_token.tc_in_memory)?;
         if tc.service() != 17 {
@@ -37,7 +37,7 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConv
             let mut partial_error = None;
             let time_stamp = PusServiceBase::get_current_timestamp(&mut partial_error);
             let result = self
-                .psb
+                .service_helper
                 .common
                 .verification_handler
                 .get_mut()
@@ -50,11 +50,11 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConv
                 None
             };
             // Sequence count will be handled centrally in TM funnel.
-            let mut reply_header = SpHeader::tm_unseg(self.psb.common.tm_apid, 0, 0).unwrap();
+            let mut reply_header = SpHeader::tm_unseg(self.service_helper.common.tm_apid, 0, 0).unwrap();
             let tc_header = PusTmSecondaryHeader::new_simple(17, 2, &time_stamp);
             let ping_reply = PusTmCreator::new(&mut reply_header, tc_header, &[], true);
             let result = self
-                .psb
+                .service_helper
                 .common
                 .tm_sender
                 .send_tm(PusTmWrapper::Direct(ping_reply))
@@ -65,7 +65,7 @@ impl<TcInMemConverter: EcssTcInMemConverter> PusService17TestHandler<TcInMemConv
 
             if let Some(start_token) = start_token {
                 if self
-                    .psb
+                    .service_helper
                     .common
                     .verification_handler
                     .get_mut()