rust/sat-rs
rust/sat-rs
5
1
Fork 0
Code Issues 9 Pull Requests Projects Releases 22 Wiki Activity

move test code to dedicated integration test module

Browse Source
This commit is contained in:
Robin Müller 2024-02-22 17:37:18 +01:00
parent 508561d791
commit f285095488
Signed by: muellerr
GPG Key ID: A649FB78196E3849
2 changed files with 288 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

288
satrs/src/mode_tree.rs
View File

@ -366,292 +366,4 @@ pub trait ModeRequestHandler: ModeProvider {
#[cfg(test)]
mod tests {
use std::{println, sync::mpsc};
use alloc::string::{String, ToString};
use super::*;
use crate::{
mode::{ModeAndSubmode, ModeReply, ModeRequest},
mode_tree::ModeRequestSender,
ChannelId,
};
pub enum TestChannelId {
Device1 = 1,
Device2 = 2,
Assembly = 3,
PusModeService = 4,
}
struct PusModeService {
pub mode_node: MpscBoundedModeRequestorConnector,
}
impl PusModeService {
pub fn send_announce_mode_cmd_to_assy(&self) {
self.mode_node
.send_mode_request(
TestChannelId::Assembly as u32,
ModeRequest::AnnounceModeRecursive,
)
.unwrap();
}
}
struct TestDevice {
pub name: String,
pub mode_node: MpscBoundedModeRequestHandlerConnector,
pub mode_and_submode: ModeAndSubmode,
pub mode_req_commander: Option<ChannelId>,
}
impl TestDevice {
pub fn run(&mut self) {
self.check_mode_requests().expect("mode messaging error");
}
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(request_and_id) = self.mode_node.try_recv_mode_request()? {
match request_and_id.message {
ModeRequest::SetMode(mode_and_submode) => {
self.start_transition(mode_and_submode).unwrap();
self.mode_req_commander = Some(request_and_id.sender_id);
}
ModeRequest::ReadMode => self
.mode_node
.send_mode_reply(
request_and_id.sender_id,
ModeReply::ModeReply(self.mode_and_submode),
)
.unwrap(),
ModeRequest::AnnounceMode => self.announce_mode(false),
ModeRequest::AnnounceModeRecursive => self.announce_mode(true),
}
}
Ok(())
}
}
impl ModeProvider for TestDevice {
fn mode_and_submode(&self) -> ModeAndSubmode {
self.mode_and_submode
}
}
impl ModeRequestHandler for TestDevice {
fn start_transition(&mut self, mode_and_submode: ModeAndSubmode) -> Result<(), ModeError> {
self.mode_and_submode = mode_and_submode;
self.handle_mode_reached()?;
Ok(())
}
fn announce_mode(&self, _recursive: bool) {
println!(
"{}: announcing mode: {:?}",
self.name, self.mode_and_submode
);
}
fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
self.mode_node.send_mode_reply(
self.mode_req_commander.unwrap(),
ModeReply::ModeReply(self.mode_and_submode),
)?;
Ok(())
}
}
struct TestAssembly {
pub mode_node: MpscBoundedModeConnector,
pub mode_req_commander: Option<ChannelId>,
pub mode_and_submode: ModeAndSubmode,
pub target_mode_and_submode: Option<ModeAndSubmode>,
}
impl ModeProvider for TestAssembly {
fn mode_and_submode(&self) -> ModeAndSubmode {
self.mode_and_submode
}
}
impl TestAssembly {
pub fn run(&mut self) {
self.check_mode_requests().expect("mode messaging error");
self.check_mode_replies().expect("mode messaging error");
}
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(request_and_id) = self.mode_node.try_recv_mode_request()? {
match request_and_id.message {
ModeRequest::SetMode(mode_and_submode) => {
self.start_transition(mode_and_submode).unwrap();
self.mode_req_commander = Some(request_and_id.sender_id);
}
ModeRequest::ReadMode => {
// self.handle_read_mode_request(0, self.mode_and_submode, &mut self.mode_reply_sender).unwrap()
self.mode_node
.send_mode_reply(
request_and_id.sender_id,
ModeReply::ModeReply(self.mode_and_submode),
)
.unwrap()
}
ModeRequest::AnnounceMode => self.announce_mode(false),
ModeRequest::AnnounceModeRecursive => self.announce_mode(true),
}
}
Ok(())
}
pub fn check_mode_replies(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
match reply_and_id.message {
ModeReply::ModeInfo(_) => todo!(),
ModeReply::ModeReply(reply) => {
println!(
"TestAssembly: Received mode reply from {:?}, reached: {:?}",
reply_and_id.sender_id, reply
);
}
ModeReply::CantReachMode(_) => todo!(),
ModeReply::WrongMode { expected, reached } => {
println!(
"TestAssembly: Wrong mode reply from {:?}, reached {:?}, expected {:?}",
reply_and_id.sender_id, reached, expected
);
}
}
}
Ok(())
}
}
impl ModeRequestHandler for TestAssembly {
fn start_transition(
&mut self,
mode_and_submode: ModeAndSubmode,
) -> Result<(), super::ModeError> {
self.target_mode_and_submode = Some(mode_and_submode);
Ok(())
}
fn announce_mode(&self, recursive: bool) {
println!(
"TestAssembly: Announcing mode (recursively: {}): {:?}",
recursive, self.mode_and_submode
);
let mut mode_request = ModeRequest::AnnounceMode;
if recursive {
mode_request = ModeRequest::AnnounceModeRecursive;
}
self.mode_node
.request_sender_map
.0
.iter()
.for_each(|(_, sender)| {
sender
.send(MessageWithSenderId::new(
self.mode_node.local_channel_id_generic(),
mode_request,
))
.expect("sending mode request failed");
});
}
fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
self.mode_node.send_mode_reply(
self.mode_req_commander.unwrap(),
ModeReply::ModeReply(self.mode_and_submode),
)?;
Ok(())
}
}
#[test]
fn basic_test() {
// All request channel handles.
let (request_sender_to_dev1, request_receiver_dev1) = mpsc::sync_channel(10);
let (request_sender_to_dev2, request_receiver_dev2) = mpsc::sync_channel(10);
let (request_sender_to_assy, request_receiver_assy) = mpsc::sync_channel(10);
// All reply channel handles.
let (reply_sender_to_assy, reply_receiver_assy) = mpsc::sync_channel(10);
let (reply_sender_to_pus, reply_receiver_pus) = mpsc::sync_channel(10);
// Mode requestors and handlers.
let mut mode_node_assy = MpscBoundedModeConnector::new(
TestChannelId::Assembly as u32,
request_receiver_assy,
reply_receiver_assy,
);
// Mode requestors only.
let mut mode_node_pus = MpscBoundedModeRequestorConnector::new(
TestChannelId::PusModeService as u32,
reply_receiver_pus,
);
// Request handlers only.
let mut mode_node_dev1 = MpscBoundedModeRequestHandlerConnector::new(
TestChannelId::Device1 as u32,
request_receiver_dev1,
);
let mut mode_node_dev2 = MpscBoundedModeRequestHandlerConnector::new(
TestChannelId::Device2 as u32,
request_receiver_dev2,
);
// Set up mode request senders first.
mode_node_pus.add_message_target(TestChannelId::Assembly as u32, request_sender_to_assy);
mode_node_pus.add_message_target(
TestChannelId::Device1 as u32,
request_sender_to_dev1.clone(),
);
mode_node_pus.add_message_target(
TestChannelId::Device2 as u32,
request_sender_to_dev2.clone(),
);
mode_node_assy.add_request_target(TestChannelId::Device1 as u32, request_sender_to_dev1);
mode_node_assy.add_request_target(TestChannelId::Device2 as u32, request_sender_to_dev2);
// Set up mode reply senders.
mode_node_dev1
.add_message_target(TestChannelId::Assembly as u32, reply_sender_to_assy.clone());
mode_node_dev1.add_message_target(
TestChannelId::PusModeService as u32,
reply_sender_to_pus.clone(),
);
mode_node_dev2.add_message_target(TestChannelId::Assembly as u32, reply_sender_to_assy);
mode_node_dev2.add_message_target(
TestChannelId::PusModeService as u32,
reply_sender_to_pus.clone(),
);
mode_node_assy.add_reply_target(TestChannelId::PusModeService as u32, reply_sender_to_pus);
let mut device1 = TestDevice {
name: "Test Device 1".to_string(),
mode_node: mode_node_dev1,
mode_req_commander: None,
mode_and_submode: ModeAndSubmode::new(0, 0),
};
let mut device2 = TestDevice {
name: "Test Device 2".to_string(),
mode_node: mode_node_dev2,
mode_req_commander: None,
mode_and_submode: ModeAndSubmode::new(0, 0),
};
let mut assy = TestAssembly {
mode_node: mode_node_assy,
mode_req_commander: None,
mode_and_submode: ModeAndSubmode::new(0, 0),
target_mode_and_submode: None,
};
let pus_service = PusModeService {
mode_node: mode_node_pus,
};
pus_service.send_announce_mode_cmd_to_assy();
assy.run();
device1.run();
device2.run();
assy.run();
}
}

288
satrs/tests/mode_tree.rs Normal file
View File

@ -0,0 +1,288 @@
use std::{println, sync::mpsc};
use satrs::mode_tree::ModeRequestSender;
use satrs::{
mode::{ModeAndSubmode, ModeReply, ModeRequest},
mode_tree::{
ModeError, ModeProvider, ModeReplyReceiver, ModeReplySender, ModeRequestHandler,
ModeRequestReceiver, MpscBoundedModeConnector, MpscBoundedModeRequestHandlerConnector,
MpscBoundedModeRequestorConnector,
},
queue::GenericTargetedMessagingError,
request::MessageWithSenderId,
ChannelId,
};
use std::string::{String, ToString};
pub enum TestChannelId {
Device1 = 1,
Device2 = 2,
Assembly = 3,
PusModeService = 4,
}
struct PusModeService {
pub mode_node: MpscBoundedModeRequestorConnector,
}
impl PusModeService {
pub fn send_announce_mode_cmd_to_assy(&self) {
self.mode_node
.send_mode_request(
TestChannelId::Assembly as u32,
ModeRequest::AnnounceModeRecursive,
)
.unwrap();
}
}
struct TestDevice {
pub name: String,
pub mode_node: MpscBoundedModeRequestHandlerConnector,
pub mode_and_submode: ModeAndSubmode,
pub mode_req_commander: Option<ChannelId>,
}
impl TestDevice {
pub fn run(&mut self) {
self.check_mode_requests().expect("mode messaging error");
}
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(request_and_id) = self.mode_node.try_recv_mode_request()? {
match request_and_id.message {
ModeRequest::SetMode(mode_and_submode) => {
self.start_transition(mode_and_submode).unwrap();
self.mode_req_commander = Some(request_and_id.sender_id);
}
ModeRequest::ReadMode => self
.mode_node
.send_mode_reply(
request_and_id.sender_id,
ModeReply::ModeReply(self.mode_and_submode),
)
.unwrap(),
ModeRequest::AnnounceMode => self.announce_mode(false),
ModeRequest::AnnounceModeRecursive => self.announce_mode(true),
}
}
Ok(())
}
}
impl ModeProvider for TestDevice {
fn mode_and_submode(&self) -> ModeAndSubmode {
self.mode_and_submode
}
}
impl ModeRequestHandler for TestDevice {
fn start_transition(&mut self, mode_and_submode: ModeAndSubmode) -> Result<(), ModeError> {
self.mode_and_submode = mode_and_submode;
self.handle_mode_reached()?;
Ok(())
}
fn announce_mode(&self, _recursive: bool) {
println!(
"{}: announcing mode: {:?}",
self.name, self.mode_and_submode
);
}
fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
self.mode_node.send_mode_reply(
self.mode_req_commander.unwrap(),
ModeReply::ModeReply(self.mode_and_submode),
)?;
Ok(())
}
}
struct TestAssembly {
pub mode_node: MpscBoundedModeConnector,
pub mode_req_commander: Option<ChannelId>,
pub mode_and_submode: ModeAndSubmode,
pub target_mode_and_submode: Option<ModeAndSubmode>,
}
impl ModeProvider for TestAssembly {
fn mode_and_submode(&self) -> ModeAndSubmode {
self.mode_and_submode
}
}
impl TestAssembly {
pub fn run(&mut self) {
self.check_mode_requests().expect("mode messaging error");
self.check_mode_replies().expect("mode messaging error");
}
pub fn check_mode_requests(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(request_and_id) = self.mode_node.try_recv_mode_request()? {
match request_and_id.message {
ModeRequest::SetMode(mode_and_submode) => {
self.start_transition(mode_and_submode).unwrap();
self.mode_req_commander = Some(request_and_id.sender_id);
}
ModeRequest::ReadMode => {
// self.handle_read_mode_request(0, self.mode_and_submode, &mut self.mode_reply_sender).unwrap()
self.mode_node
.send_mode_reply(
request_and_id.sender_id,
ModeReply::ModeReply(self.mode_and_submode),
)
.unwrap()
}
ModeRequest::AnnounceMode => self.announce_mode(false),
ModeRequest::AnnounceModeRecursive => self.announce_mode(true),
}
}
Ok(())
}
pub fn check_mode_replies(&mut self) -> Result<(), GenericTargetedMessagingError> {
if let Some(reply_and_id) = self.mode_node.try_recv_mode_reply()? {
match reply_and_id.message {
ModeReply::ModeInfo(_) => todo!(),
ModeReply::ModeReply(reply) => {
println!(
"TestAssembly: Received mode reply from {:?}, reached: {:?}",
reply_and_id.sender_id, reply
);
}
ModeReply::CantReachMode(_) => todo!(),
ModeReply::WrongMode { expected, reached } => {
println!(
"TestAssembly: Wrong mode reply from {:?}, reached {:?}, expected {:?}",
reply_and_id.sender_id, reached, expected
);
}
}
}
Ok(())
}
}
impl ModeRequestHandler for TestAssembly {
fn start_transition(&mut self, mode_and_submode: ModeAndSubmode) -> Result<(), ModeError> {
self.target_mode_and_submode = Some(mode_and_submode);
Ok(())
}
fn announce_mode(&self, recursive: bool) {
println!(
"TestAssembly: Announcing mode (recursively: {}): {:?}",
recursive, self.mode_and_submode
);
let mut mode_request = ModeRequest::AnnounceMode;
if recursive {
mode_request = ModeRequest::AnnounceModeRecursive;
}
self.mode_node
.request_sender_map
.0
.iter()
.for_each(|(_, sender)| {
sender
.send(MessageWithSenderId::new(
self.mode_node.local_channel_id_generic(),
mode_request,
))
.expect("sending mode request failed");
});
}
fn handle_mode_reached(&mut self) -> Result<(), GenericTargetedMessagingError> {
self.mode_node.send_mode_reply(
self.mode_req_commander.unwrap(),
ModeReply::ModeReply(self.mode_and_submode),
)?;
Ok(())
}
}
fn main() {
// All request channel handles.
let (request_sender_to_dev1, request_receiver_dev1) = mpsc::sync_channel(10);
let (request_sender_to_dev2, request_receiver_dev2) = mpsc::sync_channel(10);
let (request_sender_to_assy, request_receiver_assy) = mpsc::sync_channel(10);
// All reply channel handles.
let (reply_sender_to_assy, reply_receiver_assy) = mpsc::sync_channel(10);
let (reply_sender_to_pus, reply_receiver_pus) = mpsc::sync_channel(10);
// Mode requestors and handlers.
let mut mode_node_assy = MpscBoundedModeConnector::new(
TestChannelId::Assembly as u32,
request_receiver_assy,
reply_receiver_assy,
);
// Mode requestors only.
let mut mode_node_pus = MpscBoundedModeRequestorConnector::new(
TestChannelId::PusModeService as u32,
reply_receiver_pus,
);
// Request handlers only.
let mut mode_node_dev1 = MpscBoundedModeRequestHandlerConnector::new(
TestChannelId::Device1 as u32,
request_receiver_dev1,
);
let mut mode_node_dev2 = MpscBoundedModeRequestHandlerConnector::new(
TestChannelId::Device2 as u32,
request_receiver_dev2,
);
// Set up mode request senders first.
mode_node_pus.add_message_target(TestChannelId::Assembly as u32, request_sender_to_assy);
mode_node_pus.add_message_target(
TestChannelId::Device1 as u32,
request_sender_to_dev1.clone(),
);
mode_node_pus.add_message_target(
TestChannelId::Device2 as u32,
request_sender_to_dev2.clone(),
);
mode_node_assy.add_request_target(TestChannelId::Device1 as u32, request_sender_to_dev1);
mode_node_assy.add_request_target(TestChannelId::Device2 as u32, request_sender_to_dev2);
// Set up mode reply senders.
mode_node_dev1.add_message_target(TestChannelId::Assembly as u32, reply_sender_to_assy.clone());
mode_node_dev1.add_message_target(
TestChannelId::PusModeService as u32,
reply_sender_to_pus.clone(),
);
mode_node_dev2.add_message_target(TestChannelId::Assembly as u32, reply_sender_to_assy);
mode_node_dev2.add_message_target(
TestChannelId::PusModeService as u32,
reply_sender_to_pus.clone(),
);
mode_node_assy.add_reply_target(TestChannelId::PusModeService as u32, reply_sender_to_pus);
let mut device1 = TestDevice {
name: "Test Device 1".to_string(),
mode_node: mode_node_dev1,
mode_req_commander: None,
mode_and_submode: ModeAndSubmode::new(0, 0),
};
let mut device2 = TestDevice {
name: "Test Device 2".to_string(),
mode_node: mode_node_dev2,
mode_req_commander: None,
mode_and_submode: ModeAndSubmode::new(0, 0),
};
let mut assy = TestAssembly {
mode_node: mode_node_assy,
mode_req_commander: None,
mode_and_submode: ModeAndSubmode::new(0, 0),
target_mode_and_submode: None,
};
let pus_service = PusModeService {
mode_node: mode_node_pus,
};
pus_service.send_announce_mode_cmd_to_assy();
assy.run();
device1.run();
device2.run();
assy.run();
}