going towards unittest completion

satrs/src/hk.rs

@@ -1,24 +1,37 @@
 use crate::ComponentId;
 
 pub type CollectionIntervalFactor = u32;
+/// Unique Identifier for a certain housekeeping dataset.
 pub type UniqueId = u32;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum HkRequest {
-    OneShot(UniqueId),
-    Enable(UniqueId),
-    Disable(UniqueId),
-    ModifyCollectionInterval(UniqueId, CollectionIntervalFactor),
+pub struct HkRequest {
+    pub unique_id: UniqueId,
+    pub variant: HkRequestVariant,
+}
+
+impl HkRequest {
+    pub fn new(unique_id: UniqueId, variant: HkRequestVariant) -> Self {
+        Self { unique_id, variant }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum HkRequestVariant {
+    OneShot,
+    Enable,
+    Disable,
+    ModifyCollectionInterval(CollectionIntervalFactor),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct TargetedHkRequest {
     pub target_id: ComponentId,
-    pub hk_request: HkRequest,
+    pub hk_request: HkRequestVariant,
 }
 
 impl TargetedHkRequest {
-    pub fn new(target_id: ComponentId, hk_request: HkRequest) -> Self {
+    pub fn new(target_id: ComponentId, hk_request: HkRequestVariant) -> Self {
         Self {
             target_id,
             hk_request,

satrs/src/pus/action.rs

@@ -25,7 +25,7 @@ pub struct ActionRequestWithId {
 /// A reply to an action request, but tailored to the PUS standard verification process.
 #[non_exhaustive]
 #[derive(Clone, PartialEq, Debug)]
-pub enum ActionReplyPus {
+pub enum ActionReplyVariant {
     Completed,
     StepSuccess {
         step: u16,
@@ -42,31 +42,27 @@ pub enum ActionReplyPus {
 }
 
 #[derive(Debug, PartialEq, Clone)]
-pub struct ActionReplyPusWithActionId {
+pub struct PusActionReply {
     pub action_id: ActionId,
-    pub variant: ActionReplyPus,
+    pub variant: ActionReplyVariant,
 }
 
-impl ActionReplyPusWithActionId {
-    pub fn new(action_id: ActionId, variant: ActionReplyPus) -> Self {
+impl PusActionReply {
+    pub fn new(action_id: ActionId, variant: ActionReplyVariant) -> Self {
         Self { action_id, variant }
     }
 }
 
-pub type GenericActionReplyPus = GenericMessage<ActionReplyPusWithActionId>;
+pub type GenericActionReplyPus = GenericMessage<PusActionReply>;
 
 impl GenericActionReplyPus {
     pub fn new_action_reply(
         request_id: RequestId,
         sender_id: ComponentId,
         action_id: ActionId,
-        reply: ActionReplyPus,
+        reply: ActionReplyVariant,
     ) -> Self {
-        Self::new(
-            request_id,
-            sender_id,
-            ActionReplyPusWithActionId::new(action_id, reply),
-        )
+        Self::new(request_id, sender_id, PusActionReply::new(action_id, reply))
     }
 }
 
@@ -82,13 +78,13 @@ pub mod alloc_mod {
         ComponentId,
     };
 
-    use super::ActionReplyPusWithActionId;
+    use super::PusActionReply;
 
     /// Helper type definition for a mode handler which can handle mode requests.
     pub type ActionRequestHandlerInterface<S, R> =
-        MessageSenderAndReceiver<ActionReplyPusWithActionId, ActionRequest, S, R>;
+        MessageSenderAndReceiver<PusActionReply, ActionRequest, S, R>;
 
-    impl<S: MessageSender<ActionReplyPusWithActionId>, R: MessageReceiver<ActionRequest>>
+    impl<S: MessageSender<PusActionReply>, R: MessageReceiver<ActionRequest>>
         ActionRequestHandlerInterface<S, R>
     {
         pub fn try_recv_action_request(
@@ -101,7 +97,7 @@ pub mod alloc_mod {
             &self,
             request_id: RequestId,
             target_id: ComponentId,
-            reply: ActionReplyPusWithActionId,
+            reply: PusActionReply,
         ) -> Result<(), GenericTargetedMessagingError> {
             self.send_message(request_id, target_id, reply)
         }
@@ -110,15 +106,14 @@ pub mod alloc_mod {
     /// Helper type defintion for a mode handler object which can send mode requests and receive
     /// mode replies.
     pub type ActionRequestorInterface<S, R> =
-        MessageSenderAndReceiver<ActionRequest, ActionReplyPusWithActionId, S, R>;
+        MessageSenderAndReceiver<ActionRequest, PusActionReply, S, R>;
 
-    impl<S: MessageSender<ActionRequest>, R: MessageReceiver<ActionReplyPusWithActionId>>
+    impl<S: MessageSender<ActionRequest>, R: MessageReceiver<PusActionReply>>
         ActionRequestorInterface<S, R>
     {
         pub fn try_recv_action_reply(
             &self,
-        ) -> Result<Option<GenericMessage<ActionReplyPusWithActionId>>, GenericTargetedMessagingError>
-        {
+        ) -> Result<Option<GenericMessage<PusActionReply>>, GenericTargetedMessagingError> {
             self.try_recv_message()
         }
 
@@ -186,21 +181,21 @@ pub mod std_mod {
     pub type DefaultActiveActionRequestMap = DefaultActiveRequestMap<ActivePusActionRequestStd>;
 
     pub type ActionRequestHandlerMpsc = ActionRequestHandlerInterface<
-        mpsc::Sender<GenericMessage<ActionReplyPusWithActionId>>,
+        mpsc::Sender<GenericMessage<PusActionReply>>,
         mpsc::Receiver<GenericMessage<ActionRequest>>,
     >;
     pub type ActionRequestHandlerMpscBounded = ActionRequestHandlerInterface<
-        mpsc::SyncSender<GenericMessage<ActionReplyPusWithActionId>>,
+        mpsc::SyncSender<GenericMessage<PusActionReply>>,
         mpsc::Receiver<GenericMessage<ActionRequest>>,
     >;
 
     pub type ActionRequestorMpsc = ActionRequestorInterface<
         mpsc::Sender<GenericMessage<ActionRequest>>,
-        mpsc::Receiver<GenericMessage<ActionReplyPusWithActionId>>,
+        mpsc::Receiver<GenericMessage<PusActionReply>>,
     >;
     pub type ActionRequestorBoundedMpsc = ActionRequestorInterface<
         mpsc::SyncSender<GenericMessage<ActionRequest>>,
-        mpsc::Receiver<GenericMessage<ActionReplyPusWithActionId>>,
+        mpsc::Receiver<GenericMessage<PusActionReply>>,
     >;
 
     /*

satrs/src/pus/mod.rs

@@ -322,7 +322,7 @@ pub trait PusReplyHandler<ActiveRequestInfo: ActiveRequestProvider, ReplyType> {
         tm_sender: &impl EcssTmSenderCore,
     ) -> Result<bool, Self::Error>;
 
-    fn handle_unexpected_reply(
+    fn handle_unrequested_reply(
         &mut self,
         reply: &GenericMessage<ReplyType>,
         tm_sender: &impl EcssTmSenderCore,