repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_status.rs | workspace_tests/src/progress_model/progress_status.rs | use peace::progress_model::{ProgressComplete, ProgressStatus};
#[test]
fn debug() {
assert_eq!("Initialized", format!("{:?}", ProgressStatus::Initialized))
}
#[test]
fn clone() {
assert_eq!(
ProgressStatus::Initialized,
ProgressStatus::Initialized.clone()
)
}
#[test]
fn deserialize() {
assert_eq!(
ProgressStatus::Complete(ProgressComplete::Success),
serde_yaml::from_str("!Complete Success\n").unwrap()
)
}
#[test]
fn serialize() {
assert_eq!(
"!Complete Success\n",
serde_yaml::to_string(&ProgressStatus::Complete(ProgressComplete::Success)).unwrap()
)
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_update.rs | workspace_tests/src/progress_model/progress_update.rs | use peace::progress_model::{ProgressComplete, ProgressDelta, ProgressLimit, ProgressUpdate};
#[test]
fn clone() {
let progress_update_0 = ProgressUpdate::Delta(ProgressDelta::Tick);
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let progress_update_1 = progress_update_0.clone();
assert_eq!(progress_update_0, progress_update_1);
}
#[test]
fn deserialize() {
assert_eq!(
ProgressUpdate::Delta(ProgressDelta::Inc(3)),
serde_yaml::from_str("!Delta\nInc: 3\n").unwrap()
)
}
#[test]
fn serialize() {
assert_eq!(
"!Delta\nInc: 3\n",
serde_yaml::to_string(&ProgressUpdate::Delta(ProgressDelta::Inc(3))).unwrap()
)
}
#[test]
fn deserialize_json() {
assert_eq!(
ProgressUpdate::Delta(ProgressDelta::Inc(3)),
serde_json::from_str(r#"{"Delta":{"Inc":3}}"#).unwrap()
)
}
#[test]
fn serialize_json() {
assert_eq!(
r#"{"Delta":{"Inc":3}}"#,
serde_json::to_string(&ProgressUpdate::Delta(ProgressDelta::Inc(3))).unwrap()
)
}
#[test]
fn eq() {
assert_eq!(
ProgressUpdate::Limit(ProgressLimit::Steps(3)),
ProgressUpdate::Limit(ProgressLimit::Steps(3))
);
assert_eq!(
ProgressUpdate::Delta(ProgressDelta::Inc(3)),
ProgressUpdate::Delta(ProgressDelta::Inc(3))
);
assert_eq!(
ProgressUpdate::Complete(ProgressComplete::Success),
ProgressUpdate::Complete(ProgressComplete::Success)
);
}
#[test]
fn ne() {
assert_ne!(
ProgressUpdate::Limit(ProgressLimit::Steps(3)),
ProgressUpdate::Limit(ProgressLimit::Steps(4))
);
assert_ne!(
ProgressUpdate::Delta(ProgressDelta::Inc(3)),
ProgressUpdate::Delta(ProgressDelta::Inc(4))
);
assert_ne!(
ProgressUpdate::Complete(ProgressComplete::Success),
ProgressUpdate::Complete(ProgressComplete::Fail)
);
}
#[test]
fn debug() {
assert_eq!(
r#"Limit(Steps(3))"#,
format!("{:?}", ProgressUpdate::Limit(ProgressLimit::Steps(3)))
);
assert_eq!(
r#"Delta(Inc(3))"#,
format!("{:?}", ProgressUpdate::Delta(ProgressDelta::Inc(3)))
);
assert_eq!(
r#"Complete(Success)"#,
format!("{:?}", ProgressUpdate::Complete(ProgressComplete::Success))
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_tracker.rs | workspace_tests/src/progress_model/progress_tracker.rs | use std::time::Duration;
use peace::{
progress_model::{ProgressLimit, ProgressStatus, ProgressTracker},
rt_model::indicatif::ProgressBar,
};
#[test]
fn progress_status_begins_as_initialized() {
let progress_tracker = ProgressTracker::new(ProgressBar::hidden());
assert_eq!(
&ProgressStatus::Initialized,
progress_tracker.progress_status()
);
}
#[test]
fn inc_increases_progress_bar_position_and_updates_last_update_dt() {
let progress_bar = ProgressBar::hidden();
progress_bar.set_length(10);
progress_bar.set_position(1);
let mut progress_tracker = ProgressTracker::new(progress_bar);
let last_update_dt_before = progress_tracker.last_update_dt();
progress_tracker.inc(3);
assert_eq!(4, progress_tracker.units_current());
assert!(progress_tracker.last_update_dt() > last_update_dt_before);
}
#[test]
fn tick_ticks_progress_bar_and_updates_last_update_dt() {
let progress_bar = ProgressBar::hidden();
progress_bar.set_length(10);
progress_bar.set_position(1);
let mut progress_tracker = ProgressTracker::new(progress_bar);
let last_update_dt_before = progress_tracker.last_update_dt();
progress_tracker.tick();
// We can't actually check internal state, but we can check that the position
// hasn't changed.
assert_eq!(1, progress_tracker.units_current());
assert!(progress_tracker.last_update_dt() > last_update_dt_before);
}
#[test]
fn set_progress_status_with_sets_progress_status_and_updates_last_update_dt() {
let progress_bar = ProgressBar::hidden();
let mut progress_tracker = ProgressTracker::new(progress_bar);
let last_update_dt_before = progress_tracker.last_update_dt();
progress_tracker.set_progress_status(ProgressStatus::Running);
assert_eq!(&ProgressStatus::Running, progress_tracker.progress_status());
assert!(progress_tracker.last_update_dt() > last_update_dt_before);
}
#[test]
fn set_progress_limit_with_unknown_does_not_set_progress_bar_length_and_updates_last_update_dt() {
let progress_bar = ProgressBar::hidden();
let mut progress_tracker = ProgressTracker::new(progress_bar);
let last_update_dt_before = progress_tracker.last_update_dt();
progress_tracker.set_progress_limit(ProgressLimit::Unknown);
assert_eq!(
Some(ProgressLimit::Unknown),
progress_tracker.progress_limit()
);
assert_eq!(None, progress_tracker.progress_bar().length());
assert_eq!(None, progress_tracker.units_total());
assert!(progress_tracker.last_update_dt() > last_update_dt_before);
}
#[test]
fn set_progress_limit_with_steps_sets_progress_bar_length_and_updates_last_update_dt() {
let progress_bar = ProgressBar::hidden();
progress_bar.set_length(10);
let mut progress_tracker = ProgressTracker::new(progress_bar);
let last_update_dt_before = progress_tracker.last_update_dt();
progress_tracker.set_progress_limit(ProgressLimit::Steps(123));
assert_eq!(
Some(ProgressLimit::Steps(123)),
progress_tracker.progress_limit()
);
assert_eq!(Some(123), progress_tracker.progress_bar().length());
assert_eq!(Some(123), progress_tracker.units_total());
assert!(progress_tracker.last_update_dt() > last_update_dt_before);
}
#[test]
fn set_progress_limit_with_bytes_sets_progress_bar_length_and_updates_last_update_dt() {
let progress_bar = ProgressBar::hidden();
progress_bar.set_length(10);
let mut progress_tracker = ProgressTracker::new(progress_bar);
let last_update_dt_before = progress_tracker.last_update_dt();
progress_tracker.set_progress_limit(ProgressLimit::Bytes(123));
assert_eq!(
Some(ProgressLimit::Bytes(123)),
progress_tracker.progress_limit()
);
assert_eq!(Some(123), progress_tracker.progress_bar().length());
assert_eq!(Some(123), progress_tracker.units_total());
assert!(progress_tracker.last_update_dt() > last_update_dt_before);
}
#[test]
fn eta() {
let progress_bar = ProgressBar::hidden();
progress_bar.set_length(100);
let mut progress_tracker = ProgressTracker::new(progress_bar);
progress_tracker.inc(50);
let eta = progress_tracker.eta();
assert!(eta < Duration::from_millis(500));
}
#[test]
fn elapsed() {
let progress_bar = ProgressBar::hidden();
progress_bar.set_length(10);
let mut progress_tracker = ProgressTracker::new(progress_bar);
progress_tracker.tick();
let elapsed = progress_tracker.elapsed();
assert!(elapsed > Duration::from_millis(0));
assert!(elapsed < Duration::from_millis(500));
}
#[test]
fn debug() {
let progress_tracker = ProgressTracker::new(ProgressBar::hidden());
assert!(format!("{progress_tracker:?}").starts_with("ProgressTracker"));
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_sender.rs | workspace_tests/src/progress_model/progress_sender.rs | use peace::{
item_model::item_id,
progress_model::{
CmdProgressUpdate, ProgressDelta, ProgressMsgUpdate, ProgressSender, ProgressUpdateAndId,
},
rt_model::ProgressUpdate,
};
use tokio::sync::mpsc::{self, error::TryRecvError};
#[test]
fn clone() {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = Clone::clone(&ProgressSender::new(&item_id, &progress_tx));
progress_sender.inc(123, ProgressMsgUpdate::NoChange);
progress_rx.close();
let cmd_progress_update = progress_rx.try_recv().unwrap();
assert_eq!(
CmdProgressUpdate::ItemProgress {
progress_update_and_id: ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(123)),
msg_update: ProgressMsgUpdate::NoChange,
}
},
cmd_progress_update
);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
}
#[test]
fn inc_sends_progress_update() -> Result<(), Box<dyn std::error::Error>> {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
progress_sender.inc(123, ProgressMsgUpdate::NoChange);
let cmd_progress_update = progress_rx.try_recv().unwrap();
assert_eq!(
CmdProgressUpdate::ItemProgress {
progress_update_and_id: ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(123)),
msg_update: ProgressMsgUpdate::NoChange,
}
},
cmd_progress_update
);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
Ok(())
}
#[test]
fn inc_is_received_if_sent_before_progress_channel_is_closed(
) -> Result<(), Box<dyn std::error::Error>> {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
progress_sender.inc(123, ProgressMsgUpdate::NoChange);
progress_rx.close();
let cmd_progress_update = progress_rx.try_recv().unwrap();
assert_eq!(
CmdProgressUpdate::ItemProgress {
progress_update_and_id: ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(123)),
msg_update: ProgressMsgUpdate::NoChange,
}
},
cmd_progress_update
);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
Ok(())
}
#[test]
fn inc_does_not_panic_when_progress_channel_is_closed() -> Result<(), Box<dyn std::error::Error>> {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
progress_rx.close();
progress_sender.inc(123, ProgressMsgUpdate::NoChange);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
Ok(())
}
#[test]
fn tick_sends_progress_update() -> Result<(), Box<dyn std::error::Error>> {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
progress_sender.tick(ProgressMsgUpdate::NoChange);
let cmd_progress_update = progress_rx.try_recv().unwrap();
assert_eq!(
CmdProgressUpdate::ItemProgress {
progress_update_and_id: ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Tick),
msg_update: ProgressMsgUpdate::NoChange,
}
},
cmd_progress_update
);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
Ok(())
}
#[test]
fn tick_is_received_if_sent_before_progress_channel_is_closed(
) -> Result<(), Box<dyn std::error::Error>> {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
progress_sender.tick(ProgressMsgUpdate::NoChange);
progress_rx.close();
let cmd_progress_update = progress_rx.try_recv().unwrap();
assert_eq!(
CmdProgressUpdate::ItemProgress {
progress_update_and_id: ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Tick),
msg_update: ProgressMsgUpdate::NoChange,
}
},
cmd_progress_update
);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
Ok(())
}
#[test]
fn tick_does_not_panic_when_progress_channel_is_closed() -> Result<(), Box<dyn std::error::Error>> {
let item_id = item_id!("test_item_id");
let (progress_tx, mut progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
progress_rx.close();
progress_sender.tick(ProgressMsgUpdate::NoChange);
let error = progress_rx.try_recv().unwrap_err();
assert_eq!(TryRecvError::Empty, error);
Ok(())
}
#[test]
fn debug() {
let item_id = item_id!("test_item_id");
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(&item_id, &progress_tx);
assert!(format!("{progress_sender:?}")
.starts_with(r#"ProgressSender { item_id: ItemId("test_item_id"), progress_tx: Sender"#));
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_update_and_id.rs | workspace_tests/src/progress_model/progress_update_and_id.rs | use peace::{
item_model::item_id,
progress_model::{
ProgressComplete, ProgressDelta, ProgressLimit, ProgressMsgUpdate, ProgressUpdate,
ProgressUpdateAndId,
},
};
#[test]
fn clone() {
let progress_update_and_id_0 = ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Tick),
msg_update: ProgressMsgUpdate::NoChange,
};
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let progress_update_and_id_1 = progress_update_and_id_0.clone();
assert_eq!(progress_update_and_id_0, progress_update_and_id_1);
}
#[test]
fn deserialize() {
assert_eq!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
},
serde_yaml::from_str(
r#"item_id: test_item_id
progress_update: !Delta
Inc: 3
msg_update: NoChange
"#
)
.unwrap()
)
}
#[test]
fn serialize() {
assert_eq!(
r#"item_id: test_item_id
progress_update: !Delta
Inc: 3
msg_update: NoChange
"#,
serde_yaml::to_string(&ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
})
.unwrap()
)
}
#[test]
fn deserialize_json() {
assert_eq!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
},
serde_json::from_str(
r#"{"item_id":"test_item_id","progress_update":{"Delta":{"Inc":3}},"msg_update":"NoChange"}"#
)
.unwrap()
)
}
#[test]
fn serialize_json() {
assert_eq!(
r#"{"item_id":"test_item_id","progress_update":{"Delta":{"Inc":3}},"msg_update":"NoChange"}"#,
serde_json::to_string(&ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
})
.unwrap()
)
}
#[test]
fn eq() {
assert_eq!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Limit(ProgressLimit::Steps(3)),
msg_update: ProgressMsgUpdate::NoChange,
},
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Limit(ProgressLimit::Steps(3)),
msg_update: ProgressMsgUpdate::NoChange,
}
);
assert_eq!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
},
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
}
);
assert_eq!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Complete(ProgressComplete::Success),
msg_update: ProgressMsgUpdate::NoChange,
},
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Complete(ProgressComplete::Success),
msg_update: ProgressMsgUpdate::NoChange,
}
);
}
#[test]
fn ne() {
assert_ne!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Limit(ProgressLimit::Steps(3)),
msg_update: ProgressMsgUpdate::NoChange,
},
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Limit(ProgressLimit::Steps(4)),
msg_update: ProgressMsgUpdate::Clear,
}
);
assert_ne!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
},
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(4)),
msg_update: ProgressMsgUpdate::Clear,
}
);
assert_ne!(
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Complete(ProgressComplete::Success),
msg_update: ProgressMsgUpdate::NoChange,
},
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Complete(ProgressComplete::Fail),
msg_update: ProgressMsgUpdate::Clear,
}
);
}
#[test]
fn debug() {
assert_eq!(
r#"ProgressUpdateAndId { item_id: ItemId("test_item_id"), progress_update: Limit(Steps(3)), msg_update: NoChange }"#,
format!(
"{:?}",
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Limit(ProgressLimit::Steps(3)),
msg_update: ProgressMsgUpdate::NoChange,
}
)
);
assert_eq!(
r#"ProgressUpdateAndId { item_id: ItemId("test_item_id"), progress_update: Delta(Inc(3)), msg_update: NoChange }"#,
format!(
"{:?}",
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Delta(ProgressDelta::Inc(3)),
msg_update: ProgressMsgUpdate::NoChange,
}
)
);
assert_eq!(
r#"ProgressUpdateAndId { item_id: ItemId("test_item_id"), progress_update: Complete(Success), msg_update: NoChange }"#,
format!(
"{:?}",
ProgressUpdateAndId {
item_id: item_id!("test_item_id"),
progress_update: ProgressUpdate::Complete(ProgressComplete::Success),
msg_update: ProgressMsgUpdate::NoChange,
}
)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_delta.rs | workspace_tests/src/progress_model/progress_delta.rs | use peace::progress_model::ProgressDelta;
#[test]
fn debug() {
assert_eq!("Tick", format!("{:?}", ProgressDelta::Tick))
}
#[test]
fn clone() {
assert_eq!(ProgressDelta::Tick, ProgressDelta::Tick.clone())
}
#[test]
fn deserialize() {
assert_eq!(
ProgressDelta::Inc(3),
serde_yaml::from_str("!Inc 3\n").unwrap()
)
}
#[test]
fn serialize() {
assert_eq!(
"!Inc 3\n",
serde_yaml::to_string(&ProgressDelta::Inc(3)).unwrap()
)
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/progress_model/progress_complete.rs | workspace_tests/src/progress_model/progress_complete.rs | use peace::progress_model::ProgressComplete;
#[test]
fn debug() {
assert_eq!("Success", format!("{:?}", ProgressComplete::Success))
}
#[test]
fn clone() {
assert_eq!(ProgressComplete::Success, ProgressComplete::Success.clone())
}
#[test]
fn deserialize() {
assert_eq!(
ProgressComplete::Success,
serde_yaml::from_str("Success\n").unwrap()
)
}
#[test]
fn serialize() {
assert_eq!(
"Success\n",
serde_yaml::to_string(&ProgressComplete::Success).unwrap()
)
}
#[test]
fn is_successful() {
assert!(ProgressComplete::Success.is_successful());
assert!(!ProgressComplete::Fail.is_successful());
}
#[test]
fn is_failure() {
assert!(!ProgressComplete::Success.is_failure());
assert!(ProgressComplete::Fail.is_failure());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_rt/cmd_execution.rs | workspace_tests/src/cmd_rt/cmd_execution.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
cmd_rt::{CmdBlockRt, CmdBlockWrapper, CmdExecution},
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
resource_rt::states::{
ts::{Current, Goal},
StateDiffs, StatesCurrent,
},
rt::cmd_blocks::{DiffCmdBlock, StatesDiscoverCmdBlock},
rt_model::{Workspace, WorkspaceSpec},
};
use tempfile::TempDir;
use crate::{
mock_item::{MockItem, MockSrc},
no_op_output::NoOpOutput,
peace_cmd_ctx_types::TestCctNoOpOutput,
peace_test_error::PeaceTestError,
VecA, VecCopyItem,
};
mod cmd_execution_error_builder;
#[tokio::test]
async fn runs_one_cmd_block() -> Result<(), PeaceTestError> {
let states_discover_cmd_block = CmdBlockWrapper::new(
StatesDiscoverCmdBlock::<TestCctNoOpOutput, _>::current(),
StatesCurrent::from,
);
let states_discover_cmd_block_desc = states_discover_cmd_block.cmd_block_desc();
let TestCtx {
tempdir: _tempdir,
workspace,
flow,
} = test_ctx_init().await?;
let mut cmd_execution = CmdExecution::builder()
.with_cmd_block(states_discover_cmd_block)
.build();
let output = NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace(workspace.into())
.with_profile_selection(peace::cmd_ctx::ProfileSelection::Specified(profile!(
"test_profile"
)))
.with_flow(flow.into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let cmd_outcome = cmd_execution.exec(&mut cmd_ctx).await?;
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&cmd_outcome,
CmdOutcome::Complete {
value: states_current,
cmd_blocks_processed,
}
if states_current.len() == 2
&& cmd_blocks_processed.len() == 1
&& cmd_blocks_processed[0] == states_discover_cmd_block_desc
),
"Expected states_current to have 2 items,\n\
but cmd_outcome was: {cmd_outcome:?}"
);
}
})();
Ok(())
}
#[tokio::test]
async fn chains_multiple_cmd_blocks() -> Result<(), PeaceTestError> {
let TestCtx {
tempdir: _tempdir,
workspace,
flow,
} = test_ctx_init().await?;
let mut cmd_execution = CmdExecution::<StateDiffs, TestCctNoOpOutput>::builder()
.with_cmd_block(CmdBlockWrapper::new(
StatesDiscoverCmdBlock::current_and_goal(),
// Should we support diffing the accumulated states?
// Requires passing through `cmd_view` to here.
|_states_current_and_goal_mut| StateDiffs::new(),
))
.with_cmd_block(CmdBlockWrapper::new(
DiffCmdBlock::<_, Current, Goal>::new(),
|_state_diffs_ts0_and_ts1| StateDiffs::new(),
))
.build();
let output = NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace(workspace.into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let cmd_outcome = cmd_execution.exec(&mut cmd_ctx).await?;
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&cmd_outcome,
CmdOutcome::Complete {
value: state_diffs,
cmd_blocks_processed: _,
}
if state_diffs.len() == 2
),
"Expected state_diffs to have 2 items,\n\
but cmd_outcome was: {cmd_outcome:?}"
);
}
})();
Ok(())
}
async fn test_ctx_init() -> Result<TestCtx, PeaceTestError> {
let tempdir = tempfile::tempdir().map_err(PeaceTestError::TempDir)?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let flow = {
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
Flow::new(FlowId::new(crate::fn_name_short!())?, graph)
};
Ok(TestCtx {
tempdir,
workspace,
flow,
})
}
struct TestCtx {
tempdir: TempDir,
workspace: Workspace,
flow: Flow<PeaceTestError>,
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_rt/cmd_execution/cmd_execution_error_builder.rs | workspace_tests/src/cmd_rt/cmd_execution/cmd_execution_error_builder.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::{CmdExecutionError, InputFetchError},
cmd_rt::{CmdBlockWrapper, CmdExecution},
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
resource_rt::states::{
ts::{Current, Goal},
StateDiffs,
},
rt::cmd_blocks::{DiffCmdBlock, StatesDiscoverCmdBlock},
rt_model::{self, Workspace, WorkspaceSpec},
};
use tempfile::TempDir;
use crate::{
mock_item::{MockItem, MockSrc},
no_op_output::NoOpOutput,
peace_cmd_ctx_types::TestCctNoOpOutput,
peace_test_error::PeaceTestError,
VecA, VecCopyItem,
};
#[tokio::test]
async fn builds_error_for_missing_input_tuple_first_parameter() -> Result<(), PeaceTestError> {
let TestCtx {
tempdir: _tempdir,
workspace,
flow,
} = test_ctx_init().await?;
let mut cmd_execution = CmdExecution::<StateDiffs, TestCctNoOpOutput>::builder()
.with_cmd_block(CmdBlockWrapper::new(
// Note: deliberately don't discover `Current`, so error will occur in `DiffCmdBlock`.
StatesDiscoverCmdBlock::goal(),
// Should we support diffing the accumulated states?
// Requires passing through `cmd_view` to here.
|_states_current_and_goal_mut| StateDiffs::new(),
))
.with_cmd_block(CmdBlockWrapper::new(
DiffCmdBlock::<_, Current, Goal>::new(),
|_state_diffs_ts0_and_ts1| StateDiffs::new(),
))
.build();
let output = NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::builder()
.with_workspace(workspace.into())
.with_output(output.into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let error = cmd_execution.exec(&mut cmd_ctx).await.unwrap_err();
match error {
PeaceTestError::PeaceRt(rt_model::Error::CmdExecution(CmdExecutionError::InputFetch(
input_fetch_error,
))) => {
let InputFetchError {
cmd_block_descs,
cmd_block_index,
input_name_short,
input_name_full,
#[cfg(feature = "error_reporting")]
cmd_execution_src,
#[cfg(feature = "error_reporting")]
input_span,
#[cfg(feature = "error_reporting")]
full_span,
} = *input_fetch_error;
assert_eq!(2, cmd_block_descs.len());
assert_eq!(1, cmd_block_index);
assert_eq!("States<Current>", input_name_short);
assert_eq!(
"peace_resource_rt::states::States<peace_resource_rt::states::ts::Current>",
input_name_full
);
#[cfg(feature = "error_reporting")]
{
assert_eq!(
r#"CmdExecution:
ExecutionOutcome: StateDiffs
CmdBlocks:
- StatesDiscoverCmdBlock:
Input: ()
Outcome: States<Goal>
- DiffCmdBlock:
Input: (States<Current>, States<Goal>)
Outcome: (StateDiffs, States<Current>, States<Goal>)
"#,
cmd_execution_src
);
match input_span {
Some(input_span) => {
assert_eq!(154, input_span.offset());
assert_eq!("States<Current>".len(), input_span.len());
}
None => panic!(
"Expected `input_span` to be `Some(SourceSpan::from((154, 15)))`, but was `None`."
),
}
assert_eq!(0, full_span.offset());
assert_eq!(cmd_execution_src.len(), full_span.len());
}
}
_ => panic!("Expected `error` to be a `CmdExecutionError`, but was `{error}`"),
}
Ok(())
}
#[tokio::test]
async fn builds_error_for_missing_input_tuple_second_parameter() -> Result<(), PeaceTestError> {
let TestCtx {
tempdir: _tempdir,
workspace,
flow,
} = test_ctx_init().await?;
let mut cmd_execution = CmdExecution::<StateDiffs, TestCctNoOpOutput>::builder()
.with_cmd_block(CmdBlockWrapper::new(
// Note: deliberately don't discover `Goal`, so error will occur in `DiffCmdBlock`.
StatesDiscoverCmdBlock::current(),
// Should we support diffing the accumulated states?
// Requires passing through `cmd_view` to here.
|_states_current_and_goal_mut| StateDiffs::new(),
))
.with_cmd_block(CmdBlockWrapper::new(
DiffCmdBlock::<_, Current, Goal>::new(),
|_state_diffs_ts0_and_ts1| StateDiffs::new(),
))
.build();
let output = NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::builder()
.with_workspace(workspace.into())
.with_output(output.into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let error = cmd_execution.exec(&mut cmd_ctx).await.unwrap_err();
match error {
PeaceTestError::PeaceRt(rt_model::Error::CmdExecution(CmdExecutionError::InputFetch(
input_fetch_error,
))) => {
let InputFetchError {
cmd_block_descs,
cmd_block_index,
input_name_short,
input_name_full,
#[cfg(feature = "error_reporting")]
cmd_execution_src,
#[cfg(feature = "error_reporting")]
input_span,
#[cfg(feature = "error_reporting")]
full_span,
} = *input_fetch_error;
assert_eq!(2, cmd_block_descs.len());
assert_eq!(1, cmd_block_index);
assert_eq!("States<Goal>", input_name_short);
assert_eq!(
"peace_resource_rt::states::States<peace_resource_rt::states::ts::Goal>",
input_name_full
);
#[cfg(feature = "error_reporting")]
{
assert_eq!(
r#"CmdExecution:
ExecutionOutcome: StateDiffs
CmdBlocks:
- StatesDiscoverCmdBlock:
Input: ()
Outcome: States<Current>
- DiffCmdBlock:
Input: (States<Current>, States<Goal>)
Outcome: (StateDiffs, States<Current>, States<Goal>)
"#,
cmd_execution_src
);
match input_span {
Some(input_span) => {
assert_eq!(174, input_span.offset());
assert_eq!("States<Goal>".len(), input_span.len());
}
None => panic!(
"Expected `input_span` to be `Some(SourceSpan::from((174, 12)))`, but was `None`."
),
}
assert_eq!(0, full_span.offset());
assert_eq!(cmd_execution_src.len(), full_span.len());
}
}
_ => panic!("Expected `error` to be a `CmdExecutionError`, but was `{error}`"),
}
Ok(())
}
async fn test_ctx_init() -> Result<TestCtx, PeaceTestError> {
let tempdir = tempfile::tempdir().map_err(PeaceTestError::TempDir)?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let flow = {
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
Flow::new(FlowId::new(crate::fn_name_short!())?, graph)
};
Ok(TestCtx {
tempdir,
workspace,
flow,
})
}
struct TestCtx {
tempdir: TempDir,
workspace: Workspace,
flow: Flow<PeaceTestError>,
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/state_rt/states_serializer.rs | workspace_tests/src/state_rt/states_serializer.rs | use peace::{
flow_model::flow_id,
flow_rt::ItemGraphBuilder,
item_model::item_id,
resource_rt::{
internal::StatesMut, paths::StatesCurrentFile, states::StatesCurrentStored,
type_reg::untagged::TypeReg,
},
rt_model::{Error, StatesDeserializeError, Storage},
state_rt::StatesSerializer,
};
use pretty_assertions::assert_eq;
use crate::{
mock_item::{MockItem, MockState},
vec_copy_item::VecCopyState,
PeaceTestError, VecCopyItem,
};
#[tokio::test]
async fn serialize() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let storage = Storage;
let states_current_file = StatesCurrentFile::new(tempdir.path().join("states_current.yaml"));
let item_one = item_id!("one");
let item_two = item_id!("two");
let item_three = item_id!("three");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fns([
VecCopyItem::new(item_one.clone()).into(),
MockItem::<()>::new(item_two.clone()).into(),
MockItem::<()>::new(item_three.clone()).into(),
]);
item_graph_builder.build()
};
let states = {
let mut states_mut = StatesMut::new();
states_mut.insert(item_one.clone(), VecCopyState::from(vec![1u8]));
states_mut.insert(item_two.clone(), MockState(2u8));
StatesCurrentStored::from(states_mut)
};
StatesSerializer::<PeaceTestError>::serialize(
&storage,
&item_graph,
&states,
&states_current_file,
)
.await?;
let serialized = tokio::fs::read_to_string(states_current_file).await?;
assert_eq!(
"\
one:\n\
- 1\n\
two: 2\n\
three: null\n\
",
serialized
);
Ok(())
}
#[tokio::test]
async fn deserialize_stored() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let flow_id = flow_id!("test_flow");
let storage = Storage;
let states_current_file = StatesCurrentFile::new(tempdir.path().join("states_current.yaml"));
let item_one = item_id!("one");
let item_two = item_id!("two");
let item_three = item_id!("three");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fns([
VecCopyItem::new(item_one.clone()).into(),
MockItem::<()>::new(item_two.clone()).into(),
MockItem::<()>::new(item_three.clone()).into(),
]);
item_graph_builder.build()
};
let states = {
let mut states_mut = StatesMut::new();
states_mut.insert(item_one.clone(), VecCopyState::from(vec![1u8]));
states_mut.insert(item_two.clone(), MockState(2u8));
StatesCurrentStored::from(states_mut)
};
let mut states_type_reg = TypeReg::new_typed();
states_type_reg.register::<VecCopyState>(item_one.clone());
states_type_reg.register::<MockState>(item_two.clone());
states_type_reg.register::<MockState>(item_three.clone());
StatesSerializer::<PeaceTestError>::serialize(
&storage,
&item_graph,
&states,
&states_current_file,
)
.await?;
let states_deserialized = StatesSerializer::<PeaceTestError>::deserialize_stored(
&flow_id,
&storage,
&states_type_reg,
&states_current_file,
)
.await?;
assert_eq!(
Some(VecCopyState::from(vec![1u8])),
states_deserialized
.get::<VecCopyState, _>(&item_one)
.cloned()
);
assert_eq!(
Some(MockState(2u8)),
states_deserialized.get::<MockState, _>(&item_two).cloned()
);
assert_eq!(
None,
states_deserialized
.get::<MockState, _>(&item_three)
.cloned()
);
Ok(())
}
#[tokio::test]
async fn deserialize_stored_error_maps_byte_indices() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let flow_id = flow_id!("test_flow");
let storage = Storage;
let item_id = item_id!("a");
let mut states_type_reg = TypeReg::new_typed();
states_type_reg.register::<u32>(item_id.clone());
let states_current_file = StatesCurrentFile::new(tempdir.path().join("states_current.yaml"));
let contents = "a: [123]\n";
tokio::fs::write(&states_current_file, contents).await?;
let error = StatesSerializer::<PeaceTestError>::deserialize_stored(
&flow_id,
&storage,
&states_type_reg,
&states_current_file,
)
.await
.unwrap_err();
#[cfg(feature = "error_reporting")]
{
use peace::miette::SourceOffset;
let error_span_expected = {
let line = 1;
let column = 4;
Some(SourceOffset::from_location(contents, line, column))
};
if let PeaceTestError::PeaceRt(Error::StatesDeserialize(states_deserialize_error)) = error {
let StatesDeserializeError {
flow_id: flow_id_actual,
states_file_source: _,
error_span,
error_message,
context_span,
error: _,
} = *states_deserialize_error;
assert_eq!(flow_id, flow_id_actual);
assert_eq!(error_span_expected, error_span);
assert_eq!("a: invalid type: sequence, expected u32", error_message);
assert_eq!(None, context_span);
} else {
panic!("Expected error to be `Error::StatesDeserialize {{ .. }}`, but was {error:?}");
}
}
#[cfg(not(feature = "error_reporting"))]
{
assert!(matches!(
error,
PeaceTestError::PeaceRt(Error::StatesDeserialize(states_deserialize_error))
if {
let StatesDeserializeError {
flow_id: flow_id_actual,
error: _,
} = states_deserialize_error.as_ref();
&flow_id == flow_id_actual
}
));
}
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/diff/tracked.rs | workspace_tests/src/diff/tracked.rs | use std::{
collections::hash_map::DefaultHasher,
hash::{Hash, Hasher},
};
use peace::diff::{Equality, MaybeEq, Tracked};
mod maybe_eq {
use peace::diff::{Equality, MaybeEq, Tracked};
use super::Value;
#[test]
fn tracked_unknown_returns_equality_unknown() {
assert_eq!(
Equality::Unknown,
Tracked::<Value>::Unknown.maybe_eq(&Tracked::<Value>::None)
);
assert_eq!(
Equality::Unknown,
Tracked::<Value>::Unknown.maybe_eq(&Tracked::Unknown)
);
assert_eq!(
Equality::Unknown,
Tracked::Unknown.maybe_eq(&Tracked::Known(Value(1)))
);
}
#[test]
fn tracked_nones_are_equal() {
assert_eq!(
Equality::Equal,
Tracked::<Value>::None.maybe_eq(&Tracked::<Value>::None)
);
}
#[test]
fn tracked_knowns_delegate_to_known_value() {
assert_eq!(
Equality::Equal,
Tracked::Known(Value(1)).maybe_eq(&Tracked::Known(Value(1)))
);
assert_eq!(
Equality::NotEqual,
Tracked::Known(Value(1)).maybe_eq(&Tracked::Known(Value(2)))
);
}
#[test]
fn tracked_known_does_not_equal_tracked_none() {
assert_eq!(
Equality::NotEqual,
Tracked::Known(Value(1)).maybe_eq(&Tracked::None)
);
assert_eq!(
Equality::NotEqual,
Tracked::None.maybe_eq(&Tracked::Known(Value(2)))
);
}
}
mod partial_eq {
use peace::diff::Tracked;
use super::Value;
#[test]
fn tracked_unknown_returns_equality_unknown() {
assert!(!(Tracked::<Value>::Unknown == Tracked::<Value>::None));
assert!(!(Tracked::<Value>::Unknown == Tracked::Unknown));
assert!(!(Tracked::Unknown == Tracked::Known(Value(1))));
}
#[test]
fn tracked_nones_are_equal() {
assert!(Tracked::<Value>::None == Tracked::<Value>::None);
}
#[test]
fn tracked_knowns_delegate_to_known_value() {
assert!(Tracked::Known(Value(1)) == Tracked::Known(Value(1)));
assert!(!(Tracked::Known(Value(1)) == Tracked::Known(Value(2))));
}
#[test]
fn tracked_known_does_not_equal_tracked_none() {
assert!(!(Tracked::Known(Value(1)) == Tracked::None));
assert!(!(Tracked::None == Tracked::Known(Value(2))));
}
}
#[test]
fn serialize() -> Result<(), serde_yaml::Error> {
assert_eq!(
"Unknown\n\
",
serde_yaml::to_string(&Tracked::<u8>::Unknown)?
);
Ok(())
}
#[test]
fn deserialize() -> Result<(), serde_yaml::Error> {
assert!(matches!(
serde_yaml::from_str("Unknown")?,
Tracked::<u8>::Unknown
));
Ok(())
}
#[test]
fn hash() {
assert_eq!(hash_code(Tracked::None), hash_code(Tracked::None));
assert_ne!(hash_code(Tracked::None), hash_code(Tracked::Unknown));
assert_ne!(
hash_code(Tracked::None),
hash_code(Tracked::Known(Value(0)))
);
assert_eq!(hash_code(Tracked::Unknown), hash_code(Tracked::Unknown));
assert_ne!(
hash_code(Tracked::Unknown),
hash_code(Tracked::Known(Value(0)))
);
assert_eq!(
hash_code(Tracked::Known(Value(0))),
hash_code(Tracked::Known(Value(0)))
);
}
fn hash_code(tracked: Tracked<Value>) -> u64 {
let mut hasher = DefaultHasher::new();
tracked.hash(&mut hasher);
hasher.finish()
}
// for coverage
#[test]
fn clone() {
assert_eq!(
Tracked::<Value>::Known(Value(0)),
Tracked::<Value>::Known(Value(0)).clone()
)
}
#[test]
fn debug() {
let tracked = Tracked::<Value>::Known(Value(0));
assert_eq!("Known(Value(0))", format!("{tracked:?}"))
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Value(u8);
impl MaybeEq for Value {
fn maybe_eq(&self, other: &Self) -> Equality {
Equality::from(self == other)
}
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/diff/changeable.rs | workspace_tests/src/diff/changeable.rs | use peace::diff::{Changeable, Equality, Tracked};
#[test]
fn equality_returns_from_cmp_to() {
let changeable = Changeable::new(Tracked::<u8>::Unknown, Tracked::<u8>::Known(1));
assert_eq!(Equality::Unknown, changeable.equality());
}
// for coverage
#[test]
fn clone() {
let changeable = Changeable::known(1, 1);
assert_eq!(changeable, changeable.clone());
}
#[test]
fn debug() {
let changeable = Changeable::new(Tracked::<u8>::Unknown, Tracked::<u8>::Known(1));
assert_eq!(
"Changeable { from: Unknown, to: Known(1) }",
format!("{changeable:?}")
);
}
#[test]
fn partial_eq() {
let changeable_0 = Changeable::new(Tracked::<u8>::Unknown, Tracked::<u8>::Known(1));
let changeable_1 = Changeable::known(1, 1);
assert!(changeable_0 != changeable_0);
assert!(changeable_0 != changeable_1);
assert!(changeable_1 == changeable_1);
}
#[test]
fn serialize() -> Result<(), serde_yaml::Error> {
let changeable = Changeable::new(Tracked::<u8>::Unknown, Tracked::<u8>::Known(1));
assert_eq!(
"from: Unknown\n\
to: !Known 1\n\
",
serde_yaml::to_string(&changeable)?
);
Ok(())
}
#[test]
fn deserialize() -> Result<(), serde_yaml::Error> {
assert!(matches!(
serde_yaml::from_str(
"from: Unknown\n\
to: !Known 1\n\
"
)?,
Changeable {
from: Tracked::<u8>::Unknown,
to: Tracked::<u8>::Known(1),
}
));
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/diff/maybe_eq.rs | workspace_tests/src/diff/maybe_eq.rs | use std::collections::{HashMap, HashSet};
use peace::diff::{Equality, MaybeEq, Tracked};
#[test]
fn vec_eq() {
assert_eq!(Equality::Equal, vec![1, 2, 3].maybe_eq(&vec![1, 2, 3]));
assert_eq!(
Equality::Equal,
vec![Tracked::Known(Value(1))].maybe_eq(&vec![Tracked::Known(Value(1))])
);
}
#[test]
fn vec_not_eq() {
assert_eq!(Equality::NotEqual, vec![1, 2].maybe_eq(&vec![1, 2, 3]));
assert_eq!(
Equality::NotEqual,
vec![Tracked::Known(Value(1)), Tracked::Known(Value(2))]
.maybe_eq(&vec![Tracked::Known(Value(1))])
);
// Note: Currently we do not do element-wise comparisons.
assert_eq!(
Equality::NotEqual,
vec![Tracked::<u8>::Unknown].maybe_eq(&vec![Tracked::<u8>::Unknown])
);
}
#[test]
fn set_eq() {
let mut set_0 = HashSet::new();
set_0.insert(1);
let mut set_1 = HashSet::new();
set_1.insert(1);
assert_eq!(Equality::Equal, set_0.maybe_eq(&set_1));
let mut set_0 = HashSet::new();
set_0.insert(Tracked::Known(Value(1)));
let mut set_1 = HashSet::new();
set_1.insert(Tracked::Known(Value(1)));
assert_eq!(Equality::Equal, set_0.maybe_eq(&set_1));
}
#[test]
fn set_not_eq() {
let mut set_0 = HashSet::new();
set_0.insert(1);
let mut set_1 = HashSet::new();
set_1.insert(2);
assert_eq!(Equality::NotEqual, set_0.maybe_eq(&set_1));
let mut set_0 = HashSet::new();
set_0.insert(Tracked::Known(Value(1)));
let mut set_1 = HashSet::new();
set_1.insert(Tracked::Known(Value(2)));
assert_eq!(Equality::NotEqual, set_0.maybe_eq(&set_1));
// Note: Currently we do not do element-wise comparisons.
let mut set_0 = HashSet::new();
set_0.insert(Tracked::<u8>::Unknown);
let mut set_1 = HashSet::new();
set_1.insert(Tracked::<u8>::Unknown);
assert_eq!(Equality::NotEqual, set_0.maybe_eq(&set_1));
}
#[test]
fn map_eq() {
let mut map_0 = HashMap::new();
map_0.insert(1, 1);
let mut map_1 = HashMap::new();
map_1.insert(1, 1);
assert_eq!(Equality::Equal, map_0.maybe_eq(&map_1));
let mut map_0 = HashMap::new();
map_0.insert(1, Tracked::Known(Value(1)));
let mut map_1 = HashMap::new();
map_1.insert(1, Tracked::Known(Value(1)));
assert_eq!(Equality::Equal, map_0.maybe_eq(&map_1));
}
#[test]
fn map_not_eq() {
let mut map_0 = HashMap::new();
map_0.insert(0, 1);
map_0.insert(1, 1);
map_0.insert(2, 1);
let mut map_1 = HashMap::new();
map_1.insert(0, 1);
map_1.insert(1, 2);
map_1.insert(2, 1);
assert_eq!(Equality::NotEqual, map_0.maybe_eq(&map_1));
// different length
let mut map_0 = HashMap::new();
map_0.insert(0, 1);
map_0.insert(1, 1);
let mut map_1 = HashMap::new();
map_1.insert(0, 1);
assert_eq!(Equality::NotEqual, map_0.maybe_eq(&map_1));
let mut map_0 = HashMap::new();
map_0.insert(0, Tracked::Known(Value(1)));
map_0.insert(1, Tracked::Known(Value(1)));
map_0.insert(2, Tracked::Known(Value(1)));
let mut map_1 = HashMap::new();
map_1.insert(0, Tracked::Known(Value(1)));
map_1.insert(1, Tracked::Known(Value(2)));
map_1.insert(2, Tracked::Known(Value(1)));
assert_eq!(Equality::NotEqual, map_0.maybe_eq(&map_1));
}
#[test]
fn map_unknown() {
let mut map_0 = HashMap::new();
map_0.insert(0, Tracked::<u8>::Known(1));
map_0.insert(1, Tracked::<u8>::Unknown);
map_0.insert(2, Tracked::<u8>::Known(1));
let mut map_1 = HashMap::new();
map_1.insert(0, Tracked::<u8>::Known(1));
map_1.insert(1, Tracked::<u8>::Unknown);
map_1.insert(2, Tracked::<u8>::Known(1));
assert_eq!(Equality::Unknown, map_0.maybe_eq(&map_1));
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Value(u8);
impl MaybeEq for Value {
fn maybe_eq(&self, other: &Self) -> Equality {
Equality::from(self == other)
}
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/diff/equality.rs | workspace_tests/src/diff/equality.rs | use std::{cmp::Ordering, collections::HashMap};
use peace::diff::Equality;
#[test]
fn clone() {
let _not_equal = Clone::clone(&Equality::NotEqual);
}
#[test]
fn debug() {
assert_eq!("NotEqual", format!("{:?}", Equality::NotEqual));
assert_eq!("Equal", format!("{:?}", Equality::Equal));
assert_eq!("Unknown", format!("{:?}", Equality::Unknown));
}
#[test]
fn display() {
assert_eq!("!=", format!("{}", Equality::NotEqual));
assert_eq!("==", format!("{}", Equality::Equal));
assert_eq!("?=", format!("{}", Equality::Unknown));
}
#[test]
fn hash() {
let mut hash_map = HashMap::new();
hash_map.insert(Equality::NotEqual, ());
}
#[test]
fn partial_ord() {
assert_eq!(
Some(Ordering::Equal),
Equality::NotEqual.partial_cmp(&Equality::NotEqual)
);
assert_eq!(
Some(Ordering::Less),
Equality::NotEqual.partial_cmp(&Equality::Equal)
);
assert_eq!(
Some(Ordering::Less),
Equality::NotEqual.partial_cmp(&Equality::Unknown)
);
assert_eq!(
Some(Ordering::Greater),
Equality::Equal.partial_cmp(&Equality::NotEqual)
);
assert_eq!(
Some(Ordering::Equal),
Equality::Equal.partial_cmp(&Equality::Equal)
);
assert_eq!(
Some(Ordering::Less),
Equality::Equal.partial_cmp(&Equality::Unknown)
);
assert_eq!(
Some(Ordering::Greater),
Equality::Unknown.partial_cmp(&Equality::NotEqual)
);
assert_eq!(
Some(Ordering::Greater),
Equality::Unknown.partial_cmp(&Equality::Equal)
);
assert_eq!(None, Equality::Unknown.partial_cmp(&Equality::Unknown));
}
#[test]
fn bool_from() {
assert!(!bool::from(Equality::NotEqual));
assert!(bool::from(Equality::Equal));
assert!(!bool::from(Equality::Unknown));
}
#[test]
fn from_bool() {
assert_eq!(Equality::Equal, Equality::from(true));
assert_eq!(Equality::NotEqual, Equality::from(false));
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks.rs | workspace_tests/src/rt/cmd_blocks.rs | mod apply_exec_cmd_block;
mod apply_state_sync_check_cmd_block;
mod diff_cmd_block;
mod states_clean_insertion_cmd_block;
mod states_current_read_cmd_block;
mod states_discover_cmd_block;
mod states_goal_read_cmd_block;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds.rs | workspace_tests/src/rt/cmds.rs | mod apply_stored_state_sync;
mod clean_cmd;
mod diff_cmd;
mod ensure_cmd;
mod states_current_read_cmd;
mod states_current_stored_display_cmd;
mod states_discover_cmd;
mod states_goal_display_cmd;
mod states_goal_read_cmd;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/states_current_read_cmd.rs | workspace_tests/src/rt/cmds/states_current_read_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
rt::cmds::{StatesCurrentReadCmd, StatesDiscoverCmd},
rt_model::{Error, Workspace, WorkspaceSpec},
};
use crate::{
peace_cmd_ctx_types::TestCctNoOpOutput, NoOpOutput, PeaceTestError, VecA, VecCopyItem,
VecCopyState,
};
#[tokio::test]
async fn reads_states_current_stored_from_disk_when_present(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_current_from_discover,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
// Re-read states from disk.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_current_stored_from_read,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let vec_copy_state_from_discover =
states_current_from_discover.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_state_from_read =
states_current_stored_from_read.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(vec_copy_state_from_discover, vec_copy_state_from_read);
Ok(())
}
#[tokio::test]
async fn returns_error_when_states_not_on_disk() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
// Try and read states from disk.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let exec_result = StatesCurrentReadCmd::exec(&mut cmd_ctx).await;
assert!(matches!(
exec_result,
Err(PeaceTestError::PeaceRt(
Error::StatesCurrentDiscoverRequired
))
));
Ok(())
}
#[test]
fn debug() {
let debug_str = format!("{:?}", StatesCurrentReadCmd::<TestCctNoOpOutput>::default());
assert_eq!(
r#"StatesCurrentReadCmd(PhantomData<workspace_tests::peace_cmd_ctx_types::test_cct_no_op_output::TestCctNoOpOutput>)"#,
debug_str,
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/states_goal_read_cmd.rs | workspace_tests/src/rt/cmds/states_goal_read_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
rt::cmds::{StatesDiscoverCmd, StatesGoalReadCmd},
rt_model::{Error, Workspace, WorkspaceSpec},
};
use crate::{
peace_cmd_ctx_types::TestCctNoOpOutput, NoOpOutput, PeaceTestError, VecA, VecCopyItem,
VecCopyState,
};
#[tokio::test]
async fn reads_states_goal_from_disk_when_present() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_goal_from_discover,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::goal` to complete successfully.");
};
// Re-read states from disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_goal_from_read,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
let vec_copy_state_from_discover =
states_goal_from_discover.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_state_from_read =
states_goal_from_read.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(vec_copy_state_from_discover, vec_copy_state_from_read);
Ok(())
}
#[tokio::test]
async fn returns_error_when_states_not_on_disk() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = NoOpOutput;
// Try and read goal states from disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_workspace(workspace.into())
.with_output(output.into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let exec_result = StatesGoalReadCmd::exec(&mut cmd_ctx).await;
assert!(matches!(
exec_result,
Err(PeaceTestError::PeaceRt(Error::StatesGoalDiscoverRequired))
));
Ok(())
}
#[test]
fn debug() {
let debug_str = format!("{:?}", StatesGoalReadCmd::<TestCctNoOpOutput>::default());
assert_eq!(
r#"StatesGoalReadCmd(PhantomData<workspace_tests::peace_cmd_ctx_types::test_cct_no_op_output::TestCctNoOpOutput>)"#,
debug_str,
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/apply_stored_state_sync.rs | workspace_tests/src/rt/cmds/apply_stored_state_sync.rs | use peace::rt::cmds::ApplyStoredStateSync;
#[test]
fn clone() {
let _diff_state_spec = Clone::clone(&ApplyStoredStateSync::Both);
}
#[test]
fn debug() {
assert_eq!("Both", format!("{:?}", ApplyStoredStateSync::Both));
}
#[test]
fn partial_eq() {
assert_eq!(ApplyStoredStateSync::Both, ApplyStoredStateSync::Both);
assert_ne!(ApplyStoredStateSync::Goal, ApplyStoredStateSync::Current);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/clean_cmd.rs | workspace_tests/src/rt/cmds/clean_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt::cmds::{
ApplyStoredStateSync, CleanCmd, EnsureCmd, StatesCurrentReadCmd, StatesDiscoverCmd,
StatesGoalReadCmd,
},
rt_model::{
ApplyCmdError, Error as PeaceRtError, StateStoredAndDiscovered, Workspace, WorkspaceSpec,
},
};
use crate::{
mock_item::{MockItem, MockItemError, MockSrc, MockState},
peace_cmd_ctx_types::TestCctNoOpOutput,
vec_copy_item::VecB,
NoOpOutput, PeaceTestError, VecA, VecCopyItem, VecCopyState,
};
#[tokio::test]
async fn resources_cleaned_dry_does_not_alter_state_when_state_not_ensured(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let CmdOutcome::Complete {
value: states_current,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.")
};
// Dry-clean states
let CmdOutcome::Complete {
value: states_cleaned_dry,
cmd_blocks_processed: _,
} = CleanCmd::exec_dry(&mut cmd_ctx).await?
else {
panic!("Expected `CleanCmd::exec_dry` to complete successfully.")
};
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_cleaned_dry.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState::default()).as_ref(),
states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState::default()).as_ref(),
states_cleaned_dry.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn resources_cleaned_dry_does_not_alter_state_when_state_ensured(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Ensure states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
// Dry-clean states.
let CmdOutcome::Complete {
value: states_clean_dry,
cmd_blocks_processed: _,
} = CleanCmd::exec_dry(&mut cmd_ctx).await?
else {
panic!("Expected `CleanCmd::exec_dry` to complete successfully.");
};
// Re-read states from disk.
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_current,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_clean_dry.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_current_stored.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState::default()).as_ref(),
states_clean_dry.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn resources_cleaned_contains_state_cleaned_for_each_item_when_state_not_ensured(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
StatesDiscoverCmd::current(&mut cmd_ctx).await?;
// Clean states.
let CmdOutcome::Complete {
value: states_cleaned,
cmd_blocks_processed: _,
} = CleanCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `CleanCmd::exec` to complete successfully.");
};
// Re-read states from disk.
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_cleaned.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn resources_cleaned_contains_state_cleaned_for_each_item_when_state_ensured(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Ensure states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
// Clean states.
let CmdOutcome::Complete {
value: states_cleaned,
cmd_blocks_processed: _,
} = CleanCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `CleanCmd::exec` to complete successfully.");
};
// Re-read states from disk.
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7]),).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_cleaned.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn exec_dry_returns_sync_error_when_current_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Overwrite states current.
cmd_ctx
.fields_mut()
.resources_mut()
.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
// Dry-clean states.
let exec_dry_result =
CleanCmd::exec_dry_with(&mut cmd_ctx, ApplyStoredStateSync::Current).await;
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&exec_dry_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::ApplyCmdError(
ApplyCmdError::StatesCurrentOutOfSync { items_state_stored_stale }
)))
if items_state_stored_stale.len() == 1
&& matches!(
items_state_stored_stale.iter().next(),
Some((item_id, state_stored_and_discovered))
if item_id == VecCopyItem::ID_DEFAULT
&& matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == [0, 1, 2, 3]
)
&& matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == [0, 1, 2, 3, 4, 5, 6, 7]
)
),
)
),
"Expected `exec_dry_result` to be \
`Err(.. {{ ApplyCmdError::StatesCurrentOutOfSync {{ .. }} }})`,\n\
but was {exec_dry_result:?}",
);
}
})();
Ok(())
}
/// This should not return an error, because the target state for cleaning is
/// not `state_goal`, but `state_clean`.
#[tokio::test]
async fn exec_dry_does_not_return_sync_error_when_goal_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Dry-clean states.
let CmdOutcome::Complete {
value: states_cleaned_dry,
cmd_blocks_processed: _,
} = CleanCmd::exec_dry_with(&mut cmd_ctx, ApplyStoredStateSync::Goal).await?
else {
panic!("Expected `CleanCmd::exec_dry_with` to complete successfully.");
};
// Re-read states from disk.
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_goal_stored,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: (states_current, states_goal),
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3])).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3])).as_ref(),
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3])).as_ref(),
states_goal_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_cleaned_dry.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn exec_returns_sync_error_when_current_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Overwrite states current.
cmd_ctx
.fields_mut()
.resources_mut()
.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
// Clean states.
let exec_result = CleanCmd::exec_with(&mut cmd_ctx, ApplyStoredStateSync::Current).await;
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&exec_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::ApplyCmdError(
ApplyCmdError::StatesCurrentOutOfSync { items_state_stored_stale }
)))
if items_state_stored_stale.len() == 1
&& matches!(
items_state_stored_stale.iter().next(),
Some((item_id, state_stored_and_discovered))
if item_id == VecCopyItem::ID_DEFAULT
&& matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == [0, 1, 2, 3]
)
&& matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == [0, 1, 2, 3, 4, 5, 6, 7]
)
),
)
),
"Expected `exec_result` to be \
`Err(.. {{ ApplyCmdError::StatesCurrentOutOfSync {{ .. }} }})`,\n\
but was {exec_result:?}",
);
}
})();
Ok(())
}
/// This should not return an error, because the target state for cleaning is
/// not `state_goal`, but `state_clean`.
#[tokio::test]
async fn exec_does_not_return_sync_error_when_goal_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Clean states.
let CmdOutcome::Complete {
value: states_cleaned,
cmd_blocks_processed: _,
} = CleanCmd::exec_with(&mut cmd_ctx, ApplyStoredStateSync::Goal).await?
else {
panic!("Expected `CleanCmd::exec_with` to complete successfully.");
};
// Re-read states from disk.
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_goal_stored,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: (states_current, states_goal),
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3])).as_ref(),
states_goal_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_cleaned.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn states_current_not_serialized_on_states_clean_insert_cmd_block_fail(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(
MockItem::<()>::default()
.with_state_clean(|_, _| {
Err(MockItemError::Synthetic(String::from("state_clean_err")))
})
.into(),
);
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Write current and goal states to disk.
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let CmdOutcome::ItemError {
item_stream_outcome,
cmd_blocks_processed: _,
cmd_blocks_not_processed: _,
errors,
} = CleanCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `CleanCmd::exec` to complete with item error.");
};
let states_cleaned = item_stream_outcome.value();
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
None,
states_cleaned.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
None,
states_cleaned.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_current_stored.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
let mock_error = errors.get(MockItem::<()>::ID_DEFAULT);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
mock_error,
Some(PeaceTestError::Mock(MockItemError::Synthetic(s)))
if s == "state_clean_err"
),
"Expected `mock_error` to be \
`Err(.. {{ MockItemError::Synthetic {{ \"state_clean_err\" }} }})`,\n\
but was `{mock_error:?}`",
);
}
})();
Ok(())
}
#[tokio::test]
async fn states_current_not_serialized_on_states_discover_cmd_block_fail(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | true |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/states_current_stored_display_cmd.rs | workspace_tests/src/rt/cmds/states_current_stored_display_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
rt::cmds::{StatesCurrentStoredDisplayCmd, StatesDiscoverCmd},
rt_model::{Error, Workspace, WorkspaceSpec},
};
use crate::{
peace_cmd_ctx_types::{TestCctFnTrackerOutput, TestCctNoOpOutput},
FnInvocation, FnTrackerOutput, NoOpOutput, PeaceTestError, VecA, VecCopyItem, VecCopyState,
};
#[tokio::test]
async fn reads_states_current_stored_from_disk_when_present(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let mut fn_tracker_output = FnTrackerOutput::new();
// Write current states to disk.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_current_stored_from_discover,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
// Re-read states from disk in a new set of resources.
let mut cmd_ctx = CmdCtxSpsf::<TestCctFnTrackerOutput>::builder()
.with_output((&mut fn_tracker_output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_current_stored_from_read,
cmd_blocks_processed: _,
} = StatesCurrentStoredDisplayCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentStoredDisplayCmd::exec` to complete successfully.");
};
let fn_tracker_output = cmd_ctx.output();
let vec_copy_state_from_discover =
states_current_stored_from_discover.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let states_current_stored_from_read = &*states_current_stored_from_read;
let vec_copy_state_from_read =
states_current_stored_from_read.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(vec_copy_state_from_discover, vec_copy_state_from_read);
assert_eq!(
vec![FnInvocation::new(
"present",
vec![Some(serde_yaml::to_string(
states_current_stored_from_read
)?)],
)],
fn_tracker_output.fn_invocations()
);
Ok(())
}
#[tokio::test]
async fn returns_error_when_states_not_on_disk() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let mut fn_tracker_output = FnTrackerOutput::new();
// Try and display states from disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctFnTrackerOutput>::builder()
.with_output((&mut fn_tracker_output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let exec_result = StatesCurrentStoredDisplayCmd::exec(&mut cmd_ctx).await;
assert!(matches!(
exec_result,
Err(PeaceTestError::PeaceRt(
Error::StatesCurrentDiscoverRequired
))
));
let err = PeaceTestError::PeaceRt(Error::StatesCurrentDiscoverRequired);
assert_eq!(
vec![FnInvocation::new(
"write_err",
vec![Some(format!("{err:?}"))],
)],
fn_tracker_output.fn_invocations()
);
Ok(())
}
#[test]
fn debug() {
let debug_str = format!(
"{:?}",
StatesCurrentStoredDisplayCmd::<TestCctNoOpOutput>::default()
);
assert_eq!(
r#"StatesCurrentStoredDisplayCmd(PhantomData<workspace_tests::peace_cmd_ctx_types::test_cct_no_op_output::TestCctNoOpOutput>)"#,
debug_str,
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/states_goal_display_cmd.rs | workspace_tests/src/rt/cmds/states_goal_display_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
rt::cmds::{StatesDiscoverCmd, StatesGoalDisplayCmd},
rt_model::{Error, Workspace, WorkspaceSpec},
};
use crate::{
peace_cmd_ctx_types::{TestCctFnTrackerOutput, TestCctNoOpOutput},
FnInvocation, FnTrackerOutput, NoOpOutput, PeaceTestError, VecA, VecCopyItem, VecCopyState,
};
#[tokio::test]
async fn reads_states_goal_from_disk_when_present() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let mut fn_tracker_output = FnTrackerOutput::new();
// Write goal states to disk.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_goal_from_discover,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::goal` to complete successfully.");
};
// Re-read states from disk in a new set of resources.
let mut cmd_ctx = CmdCtxSpsf::<TestCctFnTrackerOutput>::builder()
.with_output((&mut fn_tracker_output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_goal_from_read,
cmd_blocks_processed: _,
} = StatesGoalDisplayCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalDisplayCmd::exec` to complete successfully.");
};
let fn_tracker_output = cmd_ctx.output();
let vec_copy_state_from_discover =
states_goal_from_discover.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let states_goal_from_read = &*states_goal_from_read;
let vec_copy_state_from_read =
states_goal_from_read.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(vec_copy_state_from_discover, vec_copy_state_from_read);
assert_eq!(
vec![FnInvocation::new(
"present",
vec![Some(serde_yaml::to_string(states_goal_from_read)?)],
)],
fn_tracker_output.fn_invocations()
);
Ok(())
}
#[tokio::test]
async fn returns_error_when_states_not_on_disk() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let mut fn_tracker_output = FnTrackerOutput::new();
// Try and display states from disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctFnTrackerOutput>::builder()
.with_output((&mut fn_tracker_output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let exec_result = StatesGoalDisplayCmd::exec(&mut cmd_ctx).await;
assert!(matches!(
exec_result,
Err(PeaceTestError::PeaceRt(Error::StatesGoalDiscoverRequired))
));
let err = PeaceTestError::PeaceRt(Error::StatesGoalDiscoverRequired);
assert_eq!(
vec![FnInvocation::new(
"write_err",
vec![Some(format!("{err:?}"))],
)],
fn_tracker_output.fn_invocations()
);
Ok(())
}
#[test]
fn debug() {
let debug_str = format!("{:?}", StatesGoalDisplayCmd::<TestCctNoOpOutput>::default());
assert_eq!(
r#"StatesGoalDisplayCmd(PhantomData<workspace_tests::peace_cmd_ctx_types::test_cct_no_op_output::TestCctNoOpOutput>)"#,
debug_str,
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/ensure_cmd.rs | workspace_tests/src/rt/cmds/ensure_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{
interruptible::{InterruptSignal, InterruptStrategy, Interruptibility},
CmdCtxSpsf, ProfileSelection,
},
cmd_model::{CmdBlockDesc, CmdOutcome},
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
resource_rt::{
paths::{StatesCurrentFile, StatesGoalFile},
type_reg::untagged::BoxDataTypeDowncast,
},
rt::cmds::{ApplyStoredStateSync, EnsureCmd, StatesCurrentReadCmd, StatesDiscoverCmd},
rt_model::{
ApplyCmdError, Error as PeaceRtError, StateStoredAndDiscovered, Workspace, WorkspaceSpec,
},
};
use tokio::sync::mpsc;
use crate::{
mock_item::{MockItem, MockItemError, MockSrc, MockState},
peace_cmd_ctx_types::TestCctNoOpOutput,
vec_copy_item::VecB,
NoOpOutput, PeaceTestError, VecA, VecCopyItem, VecCopyState,
};
#[tokio::test]
async fn resources_ensured_dry_does_not_alter_state() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Dry-ensured states.
// The returned states are currently the same as `StatesCurrentStored`, but it
// would be useful to return simulated ensured states.
let CmdOutcome::Complete {
value: states_ensured_dry,
cmd_blocks_processed: _,
} = EnsureCmd::exec_dry(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec_dry` to complete successfully.");
};
// TODO: When EnsureCmd returns the execution report, assert on the state that
// was discovered.
//
// ```rust,ignore
// let states = resources.borrow::<StatesCurrent>();
// let states_goal = resources.borrow::<StatesGoal>();
// assert_eq!(
// Some(VecCopyState::new()).as_ref(),
// states.get::<VecCopyState, _>(&VecCopyItem::ID_DEFAULT)
// );
// assert_eq!(
// Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
// states_goal
// .get::<VecCopyState, _>(&VecCopyItem::ID_DEFAULT)
//
// );
// ```
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_ensured_dry.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_ensured_dry.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn resources_ensured_contains_state_ensured_for_each_item_when_state_not_yet_ensured(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.await?;
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
// Re-read states from disk.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.await?;
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
// TODO: When EnsureCmd returns the execution report, assert on the state that
// was discovered.
//
// ```rust,ignore
// let ensured_states_before = resources_ensured.borrow::<StatesCurrent>();
// let ensured_states_goal = resources_ensured.borrow::<StatesGoal>();
// assert_eq!(
// Some(VecCopyState::new()).as_ref(),
// ensured_states_before.get::<VecCopyState, _>(&VecCopyItem::ID_DEFAULT)
// );
// assert_eq!(
// Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
// ensured_states_goal
// .get::<VecCopyState, _>(&VecCopyItem::ID_DEFAULT)
//
// );
// ```
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_current_stored.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn resources_ensured_contains_state_ensured_for_each_item_when_state_already_ensured(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
// Dry ensure states.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
// Changing params changes VecCopyItem state_goal
StatesDiscoverCmd::goal(&mut cmd_ctx).await?;
let CmdOutcome::Complete {
value: states_ensured_dry,
cmd_blocks_processed: _,
} = EnsureCmd::exec_dry(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec_dry` to complete successfully.");
};
// Re-read states from disk.
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
// TODO: When EnsureCmd returns the execution report, assert on the state that
// was discovered.
//
// ```rust,ignore
// let ensured_states_before = // StatesCurrent passed in(?) to EnsureCmd
// let ensured_states_goal = // StatesGoal passed in(?) to EnsureCmd
// assert_eq!(
// Some(VecCopyState::new()).as_ref(),
// ensured_states_before.get::<VecCopyState,
// _>(&VecCopyItem::ID_DEFAULT) );
// assert_eq!(
// Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
// ensured_states_goal
// .get::<VecCopyState, _>(&VecCopyItem::ID_DEFAULT)
//
// );
// ```
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured_dry.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured_dry.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
assert_eq!(
Some(MockState(1)).as_ref(),
states_current_stored.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn exec_dry_returns_sync_error_when_current_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Overwrite states current.
cmd_ctx
.fields_mut()
.resources_mut()
.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
// Dry ensure states.
let exec_dry_result =
EnsureCmd::exec_dry_with(&mut cmd_ctx, ApplyStoredStateSync::Current).await;
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&exec_dry_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::ApplyCmdError(
ApplyCmdError::StatesCurrentOutOfSync { items_state_stored_stale }
)))
if items_state_stored_stale.len() == 1
&& matches!(
items_state_stored_stale.iter().next(),
Some((item_id, state_stored_and_discovered))
if item_id == VecCopyItem::ID_DEFAULT
&& matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == [0, 1, 2, 3]
)
&& matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == [0, 1, 2, 3, 4, 5, 6, 7]
)
),
)
),
"Expected `exec_dry_result` to be \
`Err(.. {{ ApplyCmdError::StatesCurrentOutOfSync {{ .. }} }})`,\n\
but was `{exec_dry_result:?}`",
);
}
})();
Ok(())
}
#[tokio::test]
async fn exec_dry_returns_sync_error_when_goal_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Dry ensure states.
let exec_dry_result = EnsureCmd::exec_dry_with(&mut cmd_ctx, ApplyStoredStateSync::Goal).await;
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&exec_dry_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::ApplyCmdError(
ApplyCmdError::StatesGoalOutOfSync { items_state_stored_stale }
)))
if items_state_stored_stale.len() == 2
&& matches!(
items_state_stored_stale.get(VecCopyItem::ID_DEFAULT),
Some(state_stored_and_discovered)
if matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == [0, 1, 2, 3]
)
&& matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == [0, 1, 2, 3, 4, 5, 6, 7]
)
),
)
&& matches!(
items_state_stored_stale.get(MockItem::<()>::ID_DEFAULT),
Some(state_stored_and_discovered)
if matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<MockState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == 0
)
&& matches!(
BoxDataTypeDowncast::<MockState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == 1
)
),
)
),
"Expected `exec_dry_result` to be \
`Err(.. {{ ApplyCmdError::StatesGoalOutOfSync {{ .. }} }})`,\n\
but was `{exec_dry_result:?}`",
);
}
})();
Ok(())
}
#[tokio::test]
async fn exec_returns_sync_error_when_current_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Overwrite states current.
cmd_ctx
.fields_mut()
.resources_mut()
.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
// Ensure states.
let exec_result = EnsureCmd::exec_with(&mut cmd_ctx, ApplyStoredStateSync::Current).await;
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&exec_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::ApplyCmdError(
ApplyCmdError::StatesCurrentOutOfSync { items_state_stored_stale }
)))
if items_state_stored_stale.len() == 1
&& matches!(
items_state_stored_stale.iter().next(),
Some((item_id, state_stored_and_discovered))
if item_id == VecCopyItem::ID_DEFAULT
&& matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == [0, 1, 2, 3]
)
&& matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == [0, 1, 2, 3, 4, 5, 6, 7]
)
),
)
),
"Expected `exec_result` to be \
`Err(.. {{ ApplyCmdError::StatesCurrentOutOfSync {{ .. }} }})`,\n\
but was {exec_result:?}",
);
}
})();
Ok(())
}
#[tokio::test]
async fn exec_returns_sync_error_when_goal_state_out_of_sync(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `EnsureCmd::exec` to complete successfully.");
};
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Ensure states.
let exec_result = EnsureCmd::exec_with(&mut cmd_ctx, ApplyStoredStateSync::Goal).await;
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3])).as_ref(),
states_ensured.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(MockState(0)).as_ref(),
states_ensured.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&exec_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::ApplyCmdError(
ApplyCmdError::StatesGoalOutOfSync { items_state_stored_stale }
)))
if items_state_stored_stale.len() == 2
&& matches!(
items_state_stored_stale.get(VecCopyItem::ID_DEFAULT),
Some(state_stored_and_discovered)
if matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == [0, 1, 2, 3]
)
&& matches!(
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == [0, 1, 2, 3, 4, 5, 6, 7]
)
),
)
&& matches!(
items_state_stored_stale.get(MockItem::<()>::ID_DEFAULT),
Some(state_stored_and_discovered)
if matches!(
state_stored_and_discovered,
StateStoredAndDiscovered::ValuesDiffer { state_stored, state_discovered }
if matches!(
BoxDataTypeDowncast::<MockState>::downcast_ref(state_stored),
Some(state_stored)
if **state_stored == 0
)
&& matches!(
BoxDataTypeDowncast::<MockState>::downcast_ref(state_discovered),
Some(state_discovered)
if **state_discovered == 1
)
),
)
),
"Expected `exec_result` to be \
`Err(.. {{ ApplyCmdError::StatesGoalOutOfSync {{ .. }} }})`,\n\
but was {exec_result:?}",
);
}
})();
Ok(())
}
#[tokio::test]
async fn exec_dry_returns_item_error_when_item_discover_current_returns_error(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Write current and goal states to disk.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(0).into())
.await?;
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?;
// Alter states.
let CmdOutcome::Complete {
value: states_ensured,
cmd_blocks_processed: _,
} = EnsureCmd::exec(&mut cmd_ctx).await?
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | true |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/states_discover_cmd.rs | workspace_tests/src/rt/cmds/states_discover_cmd.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
item_model::ItemId,
resource_rt::{
paths::StatesGoalFile,
states::{StatesCurrentStored, StatesGoal},
type_reg::untagged::{BoxDtDisplay, TypeReg},
},
rt::cmds::{EnsureCmd, StatesCurrentReadCmd, StatesDiscoverCmd, StatesGoalReadCmd},
rt_model::{Workspace, WorkspaceSpec},
};
use crate::{
mock_item::{MockItem, MockItemError, MockSrc, MockState},
peace_cmd_ctx_types::TestCctNoOpOutput,
vec_copy_item::VecB,
NoOpOutput, PeaceTestError, VecA, VecCopyItem, VecCopyState,
};
#[cfg(feature = "output_progress")]
use peace::progress_model::{ProgressComplete, ProgressStatus};
#[tokio::test]
async fn current_and_goal_discovers_both_states_current_and_goal(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let CmdOutcome::Complete {
value: (states_current, states_goal),
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_goal_stored,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
let vec_copy_current_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_current_stored_state =
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_goal_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_goal_stored_state =
states_goal_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_goal_state
);
assert_eq!(vec_copy_current_state, vec_copy_current_stored_state);
assert_eq!(vec_copy_goal_state, vec_copy_goal_stored_state);
let mock_current_state = states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_current_stored_state =
states_current_stored.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_goal_state = states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_goal_stored_state = states_goal_stored.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(0)).as_ref(), mock_current_state);
assert_eq!(Some(MockState(1)).as_ref(), mock_goal_state);
assert_eq!(mock_current_state, mock_current_stored_state);
assert_eq!(mock_goal_state, mock_goal_stored_state);
#[cfg(feature = "output_progress")]
{
let cmd_progress_tracker = cmd_ctx.cmd_progress_tracker();
let progress_tracker = cmd_progress_tracker
.progress_trackers()
.get(VecCopyItem::ID_DEFAULT)
.unwrap_or_else(
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
panic!(
"Expected `progress_tracker` to exist for {}",
VecCopyItem::ID_DEFAULT
)
},
);
assert_eq!(
&ProgressStatus::Complete(ProgressComplete::Success),
progress_tracker.progress_status()
);
}
Ok(())
}
#[tokio::test]
async fn current_runs_state_current_for_each_item() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_current,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let vec_copy_current_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_current_stored_state =
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(vec_copy_current_state, vec_copy_current_stored_state);
Ok(())
}
#[tokio::test]
async fn current_inserts_states_current_stored_from_states_current_file(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
// Writes to states_current_file.yaml
StatesDiscoverCmd::current(&mut cmd_ctx).await?;
// Execute again to ensure StatesCurrentStored is included
//
// Note: The actual logic is part of `CmdCtxBuilder::build`, implemented by
// `impl_build.rs`.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
StatesDiscoverCmd::current(&mut cmd_ctx).await?;
let resources = cmd_ctx.fields().resources();
let states_current_stored_from_cmd_ctx = resources.borrow::<StatesCurrentStored>();
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let vec_copy_current_state =
states_current_stored_from_cmd_ctx.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(
states_current_stored_from_cmd_ctx.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn current_returns_error_when_try_state_current_returns_error(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(
MockItem::<()>::default()
.with_try_state_current(|_fn_ctx, _params_partial, _data| {
Err(MockItemError::Synthetic(String::from("synthetic")))
})
.into(),
);
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1u8).into())
.await?;
let CmdOutcome::ItemError {
item_stream_outcome,
cmd_blocks_processed: _,
cmd_blocks_not_processed: _,
errors,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete with item error.");
};
let states_current = item_stream_outcome.value();
let vec_copy_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_state);
assert_eq!(
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
let error = errors.get(MockItem::<()>::ID_DEFAULT);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&error,
Some(PeaceTestError::Mock(MockItemError::Synthetic(s)))
if s == "synthetic"
),
"expected error to be `Some(PeaceTestError::Mock(MockItemError::Synthetic(\"synthetic\")))`,\n\
but was {error:?}"
)
}
})();
Ok(())
}
#[tokio::test]
async fn goal_returns_error_when_try_state_goal_returns_error(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(
MockItem::<()>::default()
.with_try_state_goal(|_fn_ctx, _params_partial, _data| {
Err(MockItemError::Synthetic(String::from("synthetic")))
})
.into(),
);
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1u8).into())
.await?;
let CmdOutcome::ItemError {
item_stream_outcome,
cmd_blocks_processed: _,
cmd_blocks_not_processed: _,
errors,
} = StatesDiscoverCmd::goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::goal` to complete with item error.");
};
let states_goal = item_stream_outcome.value();
let vec_copy_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_state
);
assert_eq!(
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
let error = errors.get(MockItem::<()>::ID_DEFAULT);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&error,
Some(PeaceTestError::Mock(MockItemError::Synthetic(s)))
if s == "synthetic"
),
"expected error to be `Some(PeaceTestError::Mock(MockItemError::Synthetic(\"synthetic\")))`,\n\
but was {error:?}"
)
}
})();
Ok(())
}
#[tokio::test]
async fn current_and_goal_returns_error_when_try_state_current_returns_error(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(
MockItem::<()>::default()
.with_try_state_current(|_fn_ctx, _params_partial, _data| {
Err(MockItemError::Synthetic(String::from("synthetic")))
})
.into(),
);
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1u8).into())
.await?;
let CmdOutcome::ItemError {
item_stream_outcome,
cmd_blocks_processed: _,
cmd_blocks_not_processed: _,
errors,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete with item error.");
};
let (states_current, states_goal) = item_stream_outcome.value();
// States current assertions
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let vec_copy_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_state);
assert_eq!(
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
// States goal assertions
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
let vec_copy_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_state
);
assert_eq!(
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
let mock_state = states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(1u8)).as_ref(), mock_state);
assert_eq!(
states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT),
states_on_disk.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
let error = errors.get(MockItem::<()>::ID_DEFAULT);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&error,
Some(PeaceTestError::Mock(MockItemError::Synthetic(s)))
if s == "synthetic"
),
"expected error to be `Some(PeaceTestError::Mock(MockItemError::Synthetic(\"synthetic\")))`,\n\
but was {error:?}"
)
}
})();
Ok(())
}
#[tokio::test]
async fn current_and_goal_returns_error_when_try_state_goal_returns_error(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(
MockItem::<()>::default()
.with_try_state_goal(|_fn_ctx, _params_partial, _data| {
Err(MockItemError::Synthetic(String::from("synthetic")))
})
.into(),
);
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1u8).into())
.await?;
let CmdOutcome::ItemError {
item_stream_outcome,
cmd_blocks_processed: _,
cmd_blocks_not_processed: _,
errors,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete with item error.");
};
let (states_current, states_goal) = item_stream_outcome.value();
// States current assertions
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let vec_copy_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_state);
assert_eq!(
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
let mock_state = states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState::new()).as_ref(), mock_state);
assert_eq!(
states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT),
states_on_disk.get::<MockState, _>(MockItem::<()>::ID_DEFAULT)
);
// States goal assertions
let vec_copy_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_state
);
assert_eq!(
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
let error = errors.get(MockItem::<()>::ID_DEFAULT);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&error,
Some(PeaceTestError::Mock(MockItemError::Synthetic(s)))
if s == "synthetic"
),
"expected error to be `Some(PeaceTestError::Mock(MockItemError::Synthetic(\"synthetic\")))`,\n\
but was {error:?}"
)
}
})();
Ok(())
}
#[tokio::test]
async fn current_and_goal_returns_current_error_when_both_try_state_current_and_try_state_goal_return_error(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(
MockItem::<()>::default()
.with_try_state_current(|_fn_ctx, _params_partial, _data| {
Err(MockItemError::Synthetic(String::from("current_err")))
})
.with_try_state_goal(|_fn_ctx, _params_partial, _data| {
Err(MockItemError::Synthetic(String::from("goal_err")))
})
.into(),
);
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1u8).into())
.await?;
let CmdOutcome::ItemError {
item_stream_outcome,
cmd_blocks_processed: _,
cmd_blocks_not_processed: _,
errors,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete with item error.");
};
let (states_current, states_goal) = item_stream_outcome.value();
// States current assertions
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
let vec_copy_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_state);
assert_eq!(
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
// States goal assertions
let vec_copy_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let CmdOutcome::Complete {
value: states_on_disk,
cmd_blocks_processed: _,
} = StatesGoalReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesGoalReadCmd::exec` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_state
);
assert_eq!(
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
let error = errors.get(MockItem::<()>::ID_DEFAULT);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&error,
Some(PeaceTestError::Mock(MockItemError::Synthetic(s)))
if s == "current_err"
),
"expected error to be `Some(PeaceTestError::Mock(MockItemError::Synthetic(\"current_err\")))`,\n\
but was {error:?}"
)
}
})();
Ok(())
}
#[tokio::test]
async fn goal_runs_state_goal_for_each_item() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let CmdOutcome::Complete {
value: states_goal,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::goal` to complete successfully.");
};
let resources = cmd_ctx.fields().resources();
let vec_copy_goal_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let states_goal_on_disk = {
let states_goal_file = resources.borrow::<StatesGoalFile>();
let states_slice = std::fs::read(&*states_goal_file)?;
let mut type_reg = TypeReg::<ItemId, BoxDtDisplay>::new_typed();
type_reg.register::<VecCopyState>(VecCopyItem::ID_DEFAULT.clone());
let deserializer = serde_yaml::Deserializer::from_slice(&states_slice);
StatesGoal::from(type_reg.deserialize_map(deserializer)?)
};
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_goal_state
);
assert_eq!(
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
states_goal_on_disk.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
Ok(())
}
#[tokio::test]
async fn current_with_does_not_serialize_states_when_told_not_to(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3]).into(),
)
.await?;
// Write to disk first.
assert!(matches!(
StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?,
CmdOutcome::Complete { .. }
));
assert!(matches!(
EnsureCmd::exec(&mut cmd_ctx).await?,
CmdOutcome::Complete { .. }
));
// Discover without serializing to storage.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.await?;
// Overwrite states current.
cmd_ctx
.fields_mut()
.resources_mut()
.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
let CmdOutcome::Complete {
value: states_current,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current_with(&mut cmd_ctx, false).await?
else {
panic!("Expected `StatesDiscoverCmd::current_with` to complete successfully.");
};
let vec_copy_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let CmdOutcome::Complete {
value: states_current_stored,
cmd_blocks_processed: _,
} = StatesCurrentReadCmd::exec(&mut cmd_ctx).await?
else {
panic!("Expected `StatesCurrentReadCmd::exec` to complete successfully.");
};
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_state
);
assert_eq!(
Some(&VecCopyState::from(vec![0, 1, 2, 3])),
states_current_stored.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(&VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7])),
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT),
);
Ok(())
}
#[tokio::test]
async fn goal_with_does_not_serialize_states_when_told_not_to(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | true |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/diff_cmd.rs | workspace_tests/src/rt/cmds/diff_cmd.rs | use diff::{VecDiff, VecDiffType};
use peace::{
cfg::{app_name, profile},
cli::output::CliOutput,
cmd_ctx::{CmdCtxMpsf, CmdCtxSpsf, CmdCtxTypes, ProfileSelection},
cmd_model::CmdOutcome,
flow_model::FlowId,
flow_rt::{Flow, ItemGraphBuilder},
params::ParamsSpec,
resource_rt::states::{
ts::{Current, CurrentStored, Goal, GoalStored},
StatesCurrent, StatesGoal,
},
rt::cmds::{DiffCmd, StatesDiscoverCmd},
rt_model::{output::OutputWrite, Workspace, WorkspaceSpec},
};
use crate::{
mock_item::{MockDest, MockDiff, MockItem, MockSrc, MockState},
peace_cmd_ctx_types::TestCctNoOpOutput,
NoOpOutput, PeaceTestError, VecA, VecB, VecCopyDiff, VecCopyItem, VecCopyState,
};
mod diff_info_spec;
mod diff_state_spec;
#[tokio::test]
async fn diff_stored_contains_state_diff_for_each_item() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Discover current and goal states.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let CmdOutcome::Complete {
value: (states_current, states_goal),
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete successfully.");
};
// Diff current and goal states.
let CmdOutcome::Complete {
value: state_diffs,
cmd_blocks_processed: _,
} = DiffCmd::diff_stored(&mut cmd_ctx).await?
else {
panic!("Expected `DiffCmd::diff_stored` to complete successfully.");
};
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_current_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_goal_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_goal_state
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
vec_diff
);
let mock_diff = state_diffs.get::<MockDiff, _>(MockItem::<()>::ID_DEFAULT);
let mock_current_state = states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_goal_state = states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(0)).as_ref(), mock_current_state);
assert_eq!(Some(MockState(1)).as_ref(), mock_goal_state);
assert_eq!(Some(MockDiff(1)).as_ref(), mock_diff);
Ok(())
}
#[tokio::test]
async fn diff_discover_current_on_demand() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Discover goal state.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let CmdOutcome::Complete {
value: states_goal,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::goal` to complete successfully.");
};
// Diff current and stored goal states.
let CmdOutcome::Complete {
value: state_diffs,
cmd_blocks_processed: _,
} = DiffCmd::diff::<Current, GoalStored>(&mut cmd_ctx).await?
else {
panic!("Expected `DiffCmd::diff` to complete successfully.");
};
// Note: discovered `StatesGoal` is not automatically serialized to storage.
let resources = cmd_ctx.fields().resources();
let states_current = resources.borrow::<StatesCurrent>();
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_current_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_goal_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_goal_state
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
vec_diff
);
let mock_diff = state_diffs.get::<MockDiff, _>(MockItem::<()>::ID_DEFAULT);
let mock_current_state = states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_goal_state = states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(0)).as_ref(), mock_current_state);
assert_eq!(Some(MockState(1)).as_ref(), mock_goal_state);
assert_eq!(Some(MockDiff(1)).as_ref(), mock_diff);
Ok(())
}
#[tokio::test]
async fn diff_discover_goal_on_demand() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// Discover current state.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let CmdOutcome::Complete {
value: states_current,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
// Diff current stored and goal states.
let CmdOutcome::Complete {
value: state_diffs,
cmd_blocks_processed: _,
} = DiffCmd::diff::<CurrentStored, Goal>(&mut cmd_ctx).await?
else {
panic!("Expected `DiffCmd::diff` to complete successfully.");
};
// Note: discovered `StatesGoal` is not automatically serialized to storage.
let resources = cmd_ctx.fields().resources();
let states_goal = resources.borrow::<StatesGoal>();
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_current_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_goal_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_goal_state
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
vec_diff
);
let mock_diff = state_diffs.get::<MockDiff, _>(MockItem::<()>::ID_DEFAULT);
let mock_current_state = states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_goal_state = states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(0)).as_ref(), mock_current_state);
assert_eq!(Some(MockState(1)).as_ref(), mock_goal_state);
assert_eq!(Some(MockDiff(1)).as_ref(), mock_diff);
Ok(())
}
#[tokio::test]
async fn diff_discover_current_and_goal_on_demand() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// No discovery of current or goal states before diffing.
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
// Diff current and goal states.
let CmdOutcome::Complete {
value: state_diffs,
cmd_blocks_processed: _,
} = DiffCmd::diff::<Current, Goal>(&mut cmd_ctx).await?
else {
panic!("Expected `DiffCmd::diff` to complete successfully.");
};
// Note: discovered `StatesCurrent` and `StatesGoal` are not automatically
// serialized to storage.
let resources = cmd_ctx.fields().resources();
let states_current = resources.borrow::<StatesCurrent>();
let states_goal = resources.borrow::<StatesGoal>();
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_current_state = states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_goal_state = states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_current_state);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_goal_state
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
vec_diff
);
let mock_diff = state_diffs.get::<MockDiff, _>(MockItem::<()>::ID_DEFAULT);
let mock_current_state = states_current.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_goal_state = states_goal.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(0)).as_ref(), mock_current_state);
assert_eq!(Some(MockState(1)).as_ref(), mock_goal_state);
assert_eq!(Some(MockDiff(1)).as_ref(), mock_diff);
Ok(())
}
#[tokio::test]
async fn diff_stored_with_multiple_profiles() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.add_fn(MockItem::<()>::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// profile_0
let profile_0 = profile!("test_profile_0");
let mut cmd_ctx_0 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_0.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(1).into())
.await?;
let resources = cmd_ctx_0.fields_mut().resources_mut();
resources.insert(MockDest(1));
let CmdOutcome::Complete {
value: states_current_0,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx_0).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
// profile_1
let profile_1 = profile!("test_profile_1");
let mut cmd_ctx_1 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_1.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.with_item_params::<MockItem<()>>(MockItem::<()>::ID_DEFAULT.clone(), MockSrc(3).into())
.await?;
let resources = cmd_ctx_1.fields_mut().resources_mut();
resources.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
resources.insert(MockDest(3));
let CmdOutcome::Complete {
value: states_current_1,
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current(&mut cmd_ctx_1).await?
else {
panic!("Expected `StatesDiscoverCmd::current` to complete successfully.");
};
let mut cmd_ctx_mpsf = CmdCtxMpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.await?;
// Diff current states for profile_0 and profile_1.
let state_diffs =
DiffCmd::diff_current_stored(&mut cmd_ctx_mpsf, &profile_0, &profile_1).await?;
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(
Some(VecCopyState::new()).as_ref(),
states_current_0.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
states_current_1.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
vec_diff
);
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_0_current_state = states_current_0.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
let vec_copy_1_current_state = states_current_1.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(Some(VecCopyState::new()).as_ref(), vec_copy_0_current_state);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
vec_copy_1_current_state
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
vec_diff
);
let mock_diff = state_diffs.get::<MockDiff, _>(MockItem::<()>::ID_DEFAULT);
let mock_0_current_state = states_current_0.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
let mock_1_current_state = states_current_1.get::<MockState, _>(MockItem::<()>::ID_DEFAULT);
assert_eq!(Some(MockState(1)).as_ref(), mock_0_current_state);
assert_eq!(Some(MockState(3)).as_ref(), mock_1_current_state);
assert_eq!(Some(MockDiff(2)).as_ref(), mock_diff);
Ok(())
}
#[tokio::test]
async fn diff_stored_with_missing_profile_0() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// profile_0
let profile_0 = profile!("test_profile_0");
// profile_1
let profile_1 = profile!("test_profile_1");
let mut cmd_ctx_1 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_1.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let resources = cmd_ctx_1.fields_mut().resources_mut();
resources.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
StatesDiscoverCmd::current(&mut cmd_ctx_1).await?;
let mut cmd_ctx_mpsf = CmdCtxMpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.await?;
let diff_result = DiffCmd::diff_current_stored(&mut cmd_ctx_mpsf, &profile_0, &profile_1).await;
assert!(matches!(
diff_result,
Err(PeaceTestError::PeaceRt(
peace::rt_model::Error::ProfileNotInScope { profile, profiles_in_scope }
))
if profile == profile_0 && profiles_in_scope == vec![profile_1]));
Ok(())
}
#[tokio::test]
async fn diff_stored_with_missing_profile_1() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// profile_0
let profile_0 = profile!("test_profile_0");
let mut cmd_ctx_0 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_0.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
StatesDiscoverCmd::current(&mut cmd_ctx_0).await?;
// profile_1
let profile_1 = profile!("test_profile_1");
let mut cmd_ctx_mpsf = CmdCtxMpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.await?;
let diff_result = DiffCmd::diff_current_stored(&mut cmd_ctx_mpsf, &profile_0, &profile_1).await;
assert!(matches!(
diff_result,
Err(PeaceTestError::PeaceRt(
peace::rt_model::Error::ProfileNotInScope { profile, profiles_in_scope }
))
if profile == profile_1 && profiles_in_scope == vec![profile_0]));
Ok(())
}
#[tokio::test]
async fn diff_stored_with_profile_0_missing_states_current(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// profile_0
let profile_0 = profile!("test_profile_0");
let mut cmd_ctx_0 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_0.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
StatesDiscoverCmd::goal(&mut cmd_ctx_0).await?;
// profile_1
let profile_1 = profile!("test_profile_1");
let mut cmd_ctx_1 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_1.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
let resources = cmd_ctx_1.fields_mut().resources_mut();
resources.insert(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]));
StatesDiscoverCmd::current(&mut cmd_ctx_1).await?;
let mut cmd_ctx_mpsf = CmdCtxMpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.await?;
let diff_result = DiffCmd::diff_current_stored(&mut cmd_ctx_mpsf, &profile_0, &profile_1).await;
assert!(matches!(
diff_result,
Err(PeaceTestError::PeaceRt(
peace::rt_model::Error::ProfileStatesCurrentNotDiscovered { profile }
))
if profile == profile_0));
Ok(())
}
#[tokio::test]
async fn diff_stored_with_profile_1_missing_states_current(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let output = &mut NoOpOutput;
// profile_0
let profile_0 = profile!("test_profile_0");
let mut cmd_ctx_0 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_0.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
StatesDiscoverCmd::current(&mut cmd_ctx_0).await?;
// profile_1
let profile_1 = profile!("test_profile_1");
let mut cmd_ctx_1 = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile_1.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(
VecCopyItem::ID_DEFAULT.clone(),
VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]).into(),
)
.await?;
StatesDiscoverCmd::goal(&mut cmd_ctx_1).await?;
let mut cmd_ctx_mpsf = CmdCtxMpsf::<TestCctNoOpOutput>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.await?;
let diff_result = DiffCmd::diff_current_stored(&mut cmd_ctx_mpsf, &profile_0, &profile_1).await;
assert!(matches!(
diff_result,
Err(PeaceTestError::PeaceRt(
peace::rt_model::Error::ProfileStatesCurrentNotDiscovered { profile }
))
if profile == profile_1));
Ok(())
}
#[tokio::test]
async fn diff_with_multiple_changes() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = Workspace::new(
app_name!(),
WorkspaceSpec::Path(tempdir.path().to_path_buf()),
)?;
let graph = {
let mut graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
graph_builder.add_fn(VecCopyItem::default().into());
graph_builder.build()
};
let flow = Flow::new(FlowId::new(crate::fn_name_short!())?, graph);
let mut output = CliOutput::new_with_writer(Vec::with_capacity(256));
// Discover current and goal states.
let mut cmd_ctx = CmdCtxSpsf::<TestCctCliBuffer>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile!("test_profile")))
.with_flow((&flow).into())
// overwrite initial state
.with_resource(VecA(vec![0, 1, 2, 4, 5, 6, 8, 9]))
.with_resource(VecB(vec![0, 1, 2, 3, 4, 5, 6, 7]))
.with_item_params::<VecCopyItem>(VecCopyItem::ID_DEFAULT.clone(), ParamsSpec::InMemory)
.await?;
let CmdOutcome::Complete {
value: (states_current, states_goal),
cmd_blocks_processed: _,
} = StatesDiscoverCmd::current_and_goal(&mut cmd_ctx).await?
else {
panic!("Expected `StatesDiscoverCmd::current_and_goal` to complete successfully.");
};
// Diff current and goal states.
let CmdOutcome::Complete {
value: state_diffs,
cmd_blocks_processed: _,
} = DiffCmd::diff_stored(&mut cmd_ctx).await?
else {
panic!("Expected `DiffCmd::diff_stored` to complete successfully.");
};
<_ as OutputWrite>::present(cmd_ctx.output_mut(), &state_diffs).await?;
let vec_diff = state_diffs.get::<VecCopyDiff, _>(VecCopyItem::ID_DEFAULT);
assert_eq!(
Some(VecCopyState::from(vec![0, 1, 2, 3, 4, 5, 6, 7]),).as_ref(),
states_current.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 4, 5, 6, 8, 9])).as_ref(),
states_goal.get::<VecCopyState, _>(VecCopyItem::ID_DEFAULT)
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![
VecDiffType::Removed { index: 3, len: 1 },
VecDiffType::Altered {
index: 7,
changes: vec![1] // 8 - 7 = 1
},
VecDiffType::Inserted {
index: 8,
changes: vec![9]
},
])))
.as_ref(),
vec_diff
);
let buffer = output.writer();
assert_eq!(
"1. `vec_copy`: [(-)3..4, (~)7;1, (+)8;9, ]\n",
String::from_utf8(buffer.to_vec())?
);
Ok(())
}
#[test]
fn debug() {
let debug_str = format!("{:?}", DiffCmd::<TestCctNoOpOutput, ()>::default());
assert_eq!(
r#"DiffCmd(PhantomData<(workspace_tests::peace_cmd_ctx_types::test_cct_no_op_output::TestCctNoOpOutput, ())>)"#,
debug_str,
);
}
#[derive(Debug)]
pub struct TestCctCliBuffer;
impl CmdCtxTypes for TestCctCliBuffer {
type AppError = PeaceTestError;
type FlowParamsKey = ();
type MappingFns = ();
type Output = CliOutput<Vec<u8>>;
type ProfileParamsKey = ();
type WorkspaceParamsKey = ();
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/diff_cmd/diff_info_spec.rs | workspace_tests/src/rt/cmds/diff_cmd/diff_info_spec.rs | use peace::{
cfg::profile,
rt::cmds::{DiffInfoSpec, DiffStateSpec},
};
#[test]
fn clone() {
let _diff_info_spec = Clone::clone(&DiffInfoSpec::new(
&profile!("profile"),
DiffStateSpec::Current,
));
}
#[test]
fn debug() {
let profile = profile!("profile");
let diff_info_spec = DiffInfoSpec::new(&profile, DiffStateSpec::Current);
assert_eq!(
"DiffInfoSpec { \
profile: Profile(\"profile\"), \
diff_state_spec: Current \
}",
format!("{diff_info_spec:?}")
);
}
#[test]
fn partial_eq() {
let profile = profile!("profile");
let profile_2 = profile!("profile_2");
let diff_info_spec_0 = DiffInfoSpec::new(&profile, DiffStateSpec::Current);
let diff_info_spec_1 = DiffInfoSpec::new(&profile, DiffStateSpec::Current);
let diff_info_spec_2 = DiffInfoSpec::new(&profile_2, DiffStateSpec::Current);
assert_eq!(diff_info_spec_0, diff_info_spec_1);
assert_ne!(diff_info_spec_0, diff_info_spec_2);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmds/diff_cmd/diff_state_spec.rs | workspace_tests/src/rt/cmds/diff_cmd/diff_state_spec.rs | use peace::rt::cmds::DiffStateSpec;
#[test]
fn clone() {
let _diff_state_spec = Clone::clone(&DiffStateSpec::Current);
}
#[test]
fn debug() {
assert_eq!("Current", format!("{:?}", DiffStateSpec::Current));
}
#[test]
fn partial_eq() {
assert_eq!(DiffStateSpec::Current, DiffStateSpec::Current);
assert_ne!(DiffStateSpec::Goal, DiffStateSpec::GoalStored);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/states_discover_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/states_discover_cmd_block.rs | use peace::{cmd_rt::CmdBlock, rt::cmd_blocks::StatesDiscoverCmdBlock};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_includes_states_compared() {
macro_rules! assert_input_type_names {
($constructor:ident) => {
let cmd_block = StatesDiscoverCmdBlock::<TestCctNoOpOutput, _>::$constructor();
let input_type_names: Vec<String> = cmd_block.input_type_names();
assert_eq!(&[] as &[&str], input_type_names.as_slice());
};
}
assert_input_type_names!(current);
assert_input_type_names!(goal);
assert_input_type_names!(current_and_goal);
}
#[test]
fn outcome_type_names_includes_states_compared() {
macro_rules! assert_outcome_type_names {
($constructor:ident, $expected:expr) => {
let cmd_block = StatesDiscoverCmdBlock::<TestCctNoOpOutput, _>::$constructor();
let outcome_type_names = cmd_block.outcome_type_names();
assert_eq!($expected as &[&str], outcome_type_names.as_slice());
};
}
assert_outcome_type_names!(current, &["States<Current>"]);
assert_outcome_type_names!(goal, &["States<Goal>"]);
assert_outcome_type_names!(current_and_goal, &["States<Current>", "States<Goal>"]);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/apply_exec_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/apply_exec_cmd_block.rs | use peace::{
cmd_rt::CmdBlock,
resource_rt::states::ts::{Cleaned, CleanedDry, Ensured, EnsuredDry},
rt::cmd_blocks::ApplyExecCmdBlock,
};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_includes_states_current_and_states_target() {
macro_rules! assert_input_type_names {
($states_ts:ident, $expected:expr) => {
let cmd_block = ApplyExecCmdBlock::<TestCctNoOpOutput, $states_ts>::new();
let input_type_names = cmd_block.input_type_names();
assert_eq!($expected, input_type_names.as_slice());
};
}
assert_input_type_names!(Ensured, &["States<Current>", "States<Goal>"]);
assert_input_type_names!(EnsuredDry, &["States<Current>", "States<Goal>"]);
assert_input_type_names!(Cleaned, &["States<Current>", "States<Clean>"]);
assert_input_type_names!(CleanedDry, &["States<Current>", "States<Clean>"]);
}
#[test]
fn outcome_type_names_includes_states_previous_states_target() {
macro_rules! assert_outcome_type_names {
($states_ts:ident, $expected:expr) => {
let cmd_block = ApplyExecCmdBlock::<TestCctNoOpOutput, $states_ts>::new();
let outcome_type_names = cmd_block.outcome_type_names();
assert_eq!($expected, outcome_type_names.as_slice());
};
}
assert_outcome_type_names!(
Ensured,
&["States<Previous>", "States<Ensured>", "States<Goal>"]
);
assert_outcome_type_names!(
EnsuredDry,
&["States<Previous>", "States<EnsuredDry>", "States<Goal>"]
);
assert_outcome_type_names!(
Cleaned,
&["States<Previous>", "States<Cleaned>", "States<Clean>"]
);
assert_outcome_type_names!(
CleanedDry,
&["States<Previous>", "States<CleanedDry>", "States<Clean>"]
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/apply_state_sync_check_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/apply_state_sync_check_cmd_block.rs | use peace::{cmd_rt::CmdBlock, rt::cmd_blocks::ApplyStateSyncCheckCmdBlock};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_includes_states_compared() {
macro_rules! assert_input_type_names {
($constructor:ident, $expected:expr) => {
let cmd_block = ApplyStateSyncCheckCmdBlock::<TestCctNoOpOutput, _>::$constructor();
let input_type_names: Vec<String> = cmd_block.input_type_names();
assert_eq!($expected as &[&str], input_type_names.as_slice());
};
}
assert_input_type_names!(none, &[]);
assert_input_type_names!(current, &["States<CurrentStored>", "States<Current>"]);
assert_input_type_names!(goal, &["States<GoalStored>", "States<Goal>"]);
assert_input_type_names!(
current_and_goal,
&[
"States<CurrentStored>",
"States<Current>",
"States<GoalStored>",
"States<Goal>"
]
);
}
#[test]
fn outcome_type_names_includes_states_compared() {
macro_rules! assert_outcome_type_names {
($constructor:ident, $expected:expr) => {
let cmd_block = ApplyStateSyncCheckCmdBlock::<TestCctNoOpOutput, _>::$constructor();
let outcome_type_names = cmd_block.outcome_type_names();
assert_eq!($expected as &[&str], outcome_type_names.as_slice());
};
}
assert_outcome_type_names!(none, &[]);
assert_outcome_type_names!(current, &["States<CurrentStored>", "States<Current>"]);
assert_outcome_type_names!(goal, &["States<GoalStored>", "States<Goal>"]);
assert_outcome_type_names!(
current_and_goal,
&[
"States<CurrentStored>",
"States<Current>",
"States<GoalStored>",
"States<Goal>"
]
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/diff_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/diff_cmd_block.rs | use peace::{
cmd_rt::CmdBlock,
resource_rt::states::ts::{Current, CurrentStored, Goal, GoalStored},
rt::cmd_blocks::DiffCmdBlock,
};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_includes_states_ts0_and_states_ts1() {
macro_rules! assert_input_type_names {
($states_ts0:ident, $states_ts1:ident, $expected:expr) => {
let cmd_block = DiffCmdBlock::<TestCctNoOpOutput, $states_ts0, $states_ts1>::new();
let input_type_names: Vec<String> = cmd_block.input_type_names();
assert_eq!($expected as &[&str], input_type_names.as_slice());
};
}
assert_input_type_names!(Current, Goal, &["States<Current>", "States<Goal>"]);
assert_input_type_names!(
CurrentStored,
GoalStored,
&["States<CurrentStored>", "States<GoalStored>"]
);
}
#[test]
fn outcome_type_names_includes_state_diffs_states_ts0_and_states_ts1() {
macro_rules! assert_outcome_type_names {
($states_ts0:ident, $states_ts1:ident, $expected:expr) => {
let cmd_block = DiffCmdBlock::<TestCctNoOpOutput, $states_ts0, $states_ts1>::new();
let outcome_type_names = cmd_block.outcome_type_names();
assert_eq!($expected as &[&str], outcome_type_names.as_slice());
};
}
assert_outcome_type_names!(
Current,
Goal,
&["StateDiffs", "States<Current>", "States<Goal>"]
);
assert_outcome_type_names!(
CurrentStored,
GoalStored,
&["StateDiffs", "States<CurrentStored>", "States<GoalStored>"]
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/states_goal_read_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/states_goal_read_cmd_block.rs | use peace::{cmd_rt::CmdBlock, rt::cmd_blocks::StatesGoalReadCmdBlock};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_is_empty() {
let cmd_block = StatesGoalReadCmdBlock::<TestCctNoOpOutput>::new();
let input_type_names: Vec<String> = cmd_block.input_type_names();
assert_eq!(&[] as &[&str], input_type_names.as_slice());
}
#[test]
fn outcome_type_names_includes_states_goal_stored() {
let cmd_block = StatesGoalReadCmdBlock::<TestCctNoOpOutput>::new();
let outcome_type_names: Vec<String> = cmd_block.outcome_type_names();
assert_eq!(&["States<GoalStored>"], outcome_type_names.as_slice());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/states_current_read_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/states_current_read_cmd_block.rs | use peace::{cmd_rt::CmdBlock, rt::cmd_blocks::StatesCurrentReadCmdBlock};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_is_empty() {
let cmd_block = StatesCurrentReadCmdBlock::<TestCctNoOpOutput>::new();
let input_type_names: Vec<String> = cmd_block.input_type_names();
assert_eq!(&[] as &[&str], input_type_names.as_slice());
}
#[test]
fn outcome_type_names_includes_states_current_stored() {
let cmd_block = StatesCurrentReadCmdBlock::<TestCctNoOpOutput>::new();
let outcome_type_names: Vec<String> = cmd_block.outcome_type_names();
assert_eq!(&["States<CurrentStored>"], outcome_type_names.as_slice());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt/cmd_blocks/states_clean_insertion_cmd_block.rs | workspace_tests/src/rt/cmd_blocks/states_clean_insertion_cmd_block.rs | use peace::{cmd_rt::CmdBlock, rt::cmd_blocks::StatesCleanInsertionCmdBlock};
use crate::peace_cmd_ctx_types::TestCctNoOpOutput;
#[test]
fn input_type_names_is_empty() {
let cmd_block = StatesCleanInsertionCmdBlock::<TestCctNoOpOutput>::new();
let input_type_names: Vec<String> = cmd_block.input_type_names();
assert_eq!(&[] as &[&str], input_type_names.as_slice());
}
#[test]
fn outcome_type_names_includes_states_clean() {
let cmd_block = StatesCleanInsertionCmdBlock::<TestCctNoOpOutput>::new();
let outcome_type_names: Vec<String> = cmd_block.outcome_type_names();
assert_eq!(&["States<Clean>"], outcome_type_names.as_slice());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes.rs | workspace_tests/src/rt_model/outcomes.rs | mod item_apply;
mod item_apply_boxed;
mod item_apply_partial;
mod item_apply_partial_boxed;
mod item_apply_partial_rt;
mod item_apply_rt;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/in_memory_text_output.rs | workspace_tests/src/rt_model/in_memory_text_output.rs | use peace::rt_model::output::OutputWrite;
#[cfg(not(feature = "error_reporting"))]
#[tokio::test]
async fn write_err() -> Result<(), Box<dyn std::error::Error>> {
use peace::{item_model::item_id, rt_model::InMemoryTextOutput};
let mut output = InMemoryTextOutput::new();
let item_id = item_id!("test_item");
let error = peace::rt_model::Error::ParamsSpecNotFound { item_id };
output.write_err(&error).await?;
assert_eq!(
"A `Params::Spec` was not present for item: `test_item`\n",
output.into_inner().as_str()
);
Ok(())
}
#[cfg(feature = "error_reporting")]
#[tokio::test]
async fn write_err() -> Result<(), Box<dyn std::error::Error>> {
use peace::{item_model::item_id, rt_model::InMemoryTextOutput};
let mut output = InMemoryTextOutput::new();
let item_id = item_id!("test_item");
let error = peace::rt_model::Error::ParamsSpecNotFound { item_id };
output.write_err(&error).await?;
assert_eq!(
r#"peace_rt_model::params_spec_not_found
x A `Params::Spec` was not present for item: `test_item`
help: If you are an end user, please ask for help from the providers of your automation tool.
If you are developing a tool with the Peace framework,
please open an issue in the Peace repository:
https://github.com/azriel91/peace/
"#,
output.into_inner().as_str()
);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/item_graph.rs | workspace_tests/src/rt_model/item_graph.rs | use peace::{
flow_rt::{ItemGraph, ItemGraphBuilder},
item_model::item_id,
resource_rt::{
internal::StatesMut,
states::{StatesCurrent, StatesSerde},
},
rt_model::{fn_graph::FnGraph, ItemBoxed},
};
use crate::{
mock_item::{MockItem, MockState},
vec_copy_item::VecCopyState,
PeaceTestError, VecCopyItem,
};
#[test]
fn clone() {
let item_graph = ItemGraphBuilder::<PeaceTestError>::new().build();
let _item_graph = Clone::clone(&item_graph);
}
#[test]
fn debug() {
let item_graph = ItemGraphBuilder::<PeaceTestError>::new().build();
assert!(format!("{item_graph:?}").starts_with("ItemGraph"));
}
#[test]
fn partial_eq() {
let item_graph_0 = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let item_graph_1 = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let item_graph_2 = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fn(VecCopyItem::new(item_id!("rara")).into());
item_graph_builder.build()
};
assert_eq!(item_graph_0, item_graph_1);
assert_ne!(item_graph_0, item_graph_2);
}
#[test]
fn into_inner() {
let _fn_graph = ItemGraphBuilder::<PeaceTestError>::new()
.build()
.into_inner();
}
#[test]
fn deref() {
let item_graph = ItemGraphBuilder::<PeaceTestError>::new().build();
let _fn_graph: &FnGraph<ItemBoxed<PeaceTestError>> = &item_graph;
}
#[test]
fn deref_mut() {
let mut item_graph = ItemGraphBuilder::<PeaceTestError>::new().build();
let _fn_graph: &mut FnGraph<ItemBoxed<PeaceTestError>> = &mut item_graph;
}
#[test]
fn from() {
let fn_graph = FnGraph::<ItemBoxed<PeaceTestError>>::new();
let _item_graph = ItemGraph::<PeaceTestError>::from(fn_graph);
}
#[test]
fn states_serde_from_item_graph() {
let one = item_id!("one");
let two = item_id!("two");
let three = item_id!("three");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fns([
VecCopyItem::new(one.clone()).into(),
MockItem::<()>::new(two.clone()).into(),
MockItem::<()>::new(three.clone()).into(),
]);
item_graph_builder.build()
};
let states_serde = StatesSerde::<serde_yaml::Value>::from(&item_graph);
assert_eq!(Some(None), states_serde.get::<VecCopyState, _>(&one));
assert_eq!(Some(None), states_serde.get::<MockState, _>(&two));
assert_eq!(Some(None), states_serde.get::<MockState, _>(&three));
let mut states_serde_keys = states_serde.keys();
assert_eq!(Some(&one), states_serde_keys.next());
assert_eq!(Some(&two), states_serde_keys.next());
assert_eq!(Some(&three), states_serde_keys.next());
assert_eq!(None, states_serde_keys.next());
}
#[test]
fn states_serde_from_item_graph_and_states() {
let one = item_id!("one");
let two = item_id!("two");
let three = item_id!("three");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::<PeaceTestError>::new();
item_graph_builder.add_fns([
VecCopyItem::new(one.clone()).into(),
MockItem::<()>::new(two.clone()).into(),
MockItem::<()>::new(three.clone()).into(),
]);
item_graph_builder.build()
};
let states = {
let mut states_mut = StatesMut::new();
states_mut.insert(one.clone(), VecCopyState::from(vec![1u8]));
states_mut.insert(two.clone(), MockState(2u8));
StatesCurrent::from(states_mut)
};
let states_serde = item_graph.states_serde::<serde_yaml::Value, _>(&states);
assert_eq!(
Some(Some(&VecCopyState::from(vec![1u8]))),
states_serde.get::<VecCopyState, _>(&one)
);
assert_eq!(
Some(Some(&MockState(2u8))),
states_serde.get::<MockState, _>(&two)
);
assert_eq!(Some(None), states_serde.get::<MockState, _>(&three));
let mut states_serde_keys = states_serde.keys();
assert_eq!(Some(&one), states_serde_keys.next());
assert_eq!(Some(&two), states_serde_keys.next());
assert_eq!(Some(&three), states_serde_keys.next());
assert_eq!(None, states_serde_keys.next());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params.rs | workspace_tests/src/rt_model/params.rs | mod flow_params;
mod flow_params_opt;
mod profile_params;
mod profile_params_opt;
mod workspace_params;
mod workspace_params_opt;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/native.rs | workspace_tests/src/rt_model/native.rs | mod workspace_spec;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/item_boxed.rs | workspace_tests/src/rt_model/item_boxed.rs | use std::any::TypeId;
use peace::{
data::{DataAccessDyn, TypeIds},
item_model::item_id,
rt_model::{ItemBoxed, ItemRt},
};
use crate::{
vec_copy_item::{VecA, VecB},
VecCopyError, VecCopyItem,
};
#[test]
fn deref_to_dyn_item_rt() {
let vec_copy_item = VecCopyItem::default();
let item_boxed: ItemBoxed<VecCopyError> = vec_copy_item.clone().into();
let item_rt: &dyn ItemRt<_> = &*item_boxed;
assert_eq!(format!("{vec_copy_item:?}"), format!("{item_rt:?}"));
}
#[test]
fn deref_mut_to_dyn_item_rt() {
let vec_copy_item = VecCopyItem::default();
let mut item_boxed: ItemBoxed<VecCopyError> = vec_copy_item.clone().into();
let item_rt: &mut dyn ItemRt<_> = &mut *item_boxed;
assert_eq!(format!("{vec_copy_item:?}"), format!("{item_rt:?}"));
}
#[test]
fn data_access_dyn_borrows() {
let mut type_ids = TypeIds::new();
type_ids.push(TypeId::of::<VecA>());
let vec_copy_item = VecCopyItem::default();
let item_boxed: ItemBoxed<VecCopyError> = vec_copy_item.into();
assert_eq!(
type_ids,
<ItemBoxed<VecCopyError> as DataAccessDyn>::borrows(&item_boxed)
);
}
#[test]
fn data_access_dyn_borrow_muts() {
let mut type_ids = TypeIds::new();
type_ids.push(TypeId::of::<VecB>());
let vec_copy_item = VecCopyItem::default();
let item_boxed: ItemBoxed<VecCopyError> = vec_copy_item.into();
assert_eq!(
type_ids,
<ItemBoxed<VecCopyError> as DataAccessDyn>::borrow_muts(&item_boxed)
);
}
#[test]
fn clone() {
let vec_copy_item = VecCopyItem::default();
let item_boxed: ItemBoxed<VecCopyError> = vec_copy_item.into();
let _item_boxed = Clone::clone(&item_boxed);
}
#[test]
fn debug() {
let vec_copy_item = VecCopyItem::default();
let item_boxed: ItemBoxed<VecCopyError> = vec_copy_item.into();
assert_eq!(
"ItemBoxed(VecCopyItem { id: ItemId(\"vec_copy\") })",
format!("{item_boxed:?}")
);
}
#[test]
fn partial_eq() {
let item_boxed_0: ItemBoxed<VecCopyError> = VecCopyItem::default().into();
let item_boxed_1: ItemBoxed<VecCopyError> = VecCopyItem::default().into();
let item_boxed_2: ItemBoxed<VecCopyError> = VecCopyItem::new(item_id!("rara")).into();
assert_eq!(item_boxed_0, item_boxed_1);
assert_ne!(item_boxed_0, item_boxed_2);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/storage.rs | workspace_tests/src/rt_model/storage.rs | use peace::{
resource_rt::type_reg::untagged::{TypeMapOpt, TypeReg},
rt_model::{params::WorkspaceParams, Error, Storage},
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize)]
struct TestStruct {
a: u32,
}
#[test]
fn clone() {
let _ = Clone::clone(&Storage);
let _ = Clone::clone(&TestStruct { a: 1 });
}
#[test]
fn debug() {
assert_eq!("Storage", format!("{Storage:?}"));
assert_eq!("TestStruct { a: 1 }", format!("{:?}", TestStruct { a: 1 }));
}
#[test]
fn serialize() -> Result<(), serde_yaml::Error> {
assert_eq!("a: 1\n", serde_yaml::to_string(&TestStruct { a: 1 })?);
Ok(())
}
#[test]
fn deserialize() -> Result<(), serde_yaml::Error> {
assert_eq!(TestStruct { a: 1 }, serde_yaml::from_str("a: 1\n")?);
Ok(())
}
#[tokio::test]
async fn read_to_string_returns_string_when_path_exists() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
tokio::fs::write(&file_path, br#"a: 1"#).await?;
let file_contents = Storage.read_to_string(&file_path).await?;
assert_eq!(r#"a: 1"#, &file_contents);
Ok(())
}
#[tokio::test]
async fn read_to_string_returns_error_when_path_not_exists(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
let error = Storage.read_to_string(&file_path).await.unwrap_err();
assert!(matches!(error, Error::ItemNotExists { path } if path == file_path ));
Ok(())
}
#[tokio::test]
async fn serialized_read_returns_t_when_path_exists() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
tokio::fs::write(&file_path, br#"a: 1"#).await?;
let test_struct = Storage
.serialized_read::<TestStruct, _>(
crate::fn_name_short!().to_string(),
&file_path,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `test_struct` to be deserialized."),
)
.await?;
assert_eq!(TestStruct { a: 1 }, test_struct);
Ok(())
}
#[tokio::test]
async fn serialized_read_returns_error_when_path_not_exists(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
let error = Storage
.serialized_read::<TestStruct, _>(
crate::fn_name_short!().to_string(),
&file_path,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `Error::ItemNotExists` to be returned."),
)
.await
.unwrap_err();
assert!(matches!(error, Error::ItemNotExists { path } if path == file_path ));
Ok(())
}
#[tokio::test]
async fn serialized_read_opt_returns_t_when_path_exists() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
tokio::fs::write(&file_path, br#"a: 1"#).await?;
let test_struct = Storage
.serialized_read_opt::<TestStruct, _>(
crate::fn_name_short!().to_string(),
&file_path,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `test_struct` to be deserialized."),
)
.await?;
assert_eq!(Some(TestStruct { a: 1 }), test_struct);
Ok(())
}
#[tokio::test]
async fn serialized_read_opt_returns_none_when_path_not_exists(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
let test_struct = Storage
.serialized_read_opt::<TestStruct, _>(
crate::fn_name_short!().to_string(),
&file_path,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `None` to be returned."),
)
.await?;
assert!(test_struct.is_none());
Ok(())
}
#[tokio::test]
async fn serialized_typemap_read_opt_returns_typemap_when_path_exists(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
tokio::fs::write(&file_path, br#"0: { a: 1 }"#).await?;
let mut type_reg = TypeReg::new();
type_reg.register::<TestStruct>(0);
let workspace_params: WorkspaceParams<u32> = Storage
.serialized_typemap_read_opt(
crate::fn_name_short!().to_string(),
&type_reg,
&file_path,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `workspace_params` to be deserialized."),
)
.await?
.map(TypeMapOpt::into_type_map)
.map(WorkspaceParams::<u32>::from)
.unwrap();
assert_eq!(Some(TestStruct { a: 1 }).as_ref(), workspace_params.get(&0));
Ok(())
}
#[tokio::test]
async fn serialized_typemap_read_opt_returns_none_when_path_not_exists(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
let mut type_reg = TypeReg::new();
type_reg.register::<TestStruct>(0);
let workspace_params: Option<WorkspaceParams<u32>> = Storage
.serialized_typemap_read_opt(
crate::fn_name_short!().to_string(),
&type_reg,
&file_path,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `None` to be returned."),
)
.await?
.map(TypeMapOpt::into_type_map)
.map(WorkspaceParams::<u32>::from);
assert!(workspace_params.is_none());
Ok(())
}
#[tokio::test]
async fn serialized_write_serializes_t() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let file_path = tempdir.path().join("t.yaml");
let test_struct = TestStruct { a: 1 };
Storage
.serialized_write(
crate::fn_name_short!().to_string(),
&file_path,
&test_struct,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `test_struct` to be serialized."),
)
.await?;
let serialized = tokio::fs::read_to_string(&file_path).await?;
assert_eq!("a: 1\n", serialized);
Ok(())
}
#[tokio::test]
async fn serialized_write_string_serializes_t() -> Result<(), Box<dyn std::error::Error>> {
let test_struct = TestStruct { a: 1 };
let serialized = Storage.serialized_write_string(
&test_struct,
#[cfg_attr(coverage_nightly, coverage(off))]
|_error| panic!("Expected `test_struct` to be serialized."),
)?;
assert_eq!("a: 1\n", serialized);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/error.rs | workspace_tests/src/rt_model/error.rs | use std::fmt;
use peace::{
item_model::item_id,
miette::{Diagnostic, GraphicalReportHandler, GraphicalTheme},
params::{ParamsSpec, ParamsSpecs},
rt_model::Error,
};
use crate::mock_item::MockSrc;
mod params_specs_deserialize_error;
mod states_deserialize_error;
#[test]
fn params_specs_mismatch_display_with_all_error_cases() -> fmt::Result {
let item_ids_with_no_params_specs = vec![item_id!("no_params_0"), item_id!("no_params_1")];
let params_specs_provided_mismatches = {
let mut params_specs_provided_mismatches = ParamsSpecs::new();
params_specs_provided_mismatches.insert(
item_id!("params_spec_provided_with_no_item_0"),
ParamsSpec::<MockSrc>::InMemory,
);
params_specs_provided_mismatches.insert(
item_id!("params_spec_provided_with_no_item_1"),
ParamsSpec::<MockSrc>::Stored,
);
Box::new(params_specs_provided_mismatches)
};
let params_specs_stored_mismatches = {
let mut params_specs_stored_mismatches = ParamsSpecs::new();
params_specs_stored_mismatches.insert(
item_id!("params_spec_stored_with_no_item_0"),
ParamsSpec::<MockSrc>::InMemory,
);
params_specs_stored_mismatches.insert(
item_id!("params_spec_stored_with_no_item_1"),
ParamsSpec::<MockSrc>::Stored,
);
Box::new(Some(params_specs_stored_mismatches))
};
let params_specs_not_usable = vec![
item_id!("stored_mapping_fn_0"),
item_id!("stored_mapping_fn_1"),
];
let error = Error::ParamsSpecsMismatch {
item_ids_with_no_params_specs,
params_specs_provided_mismatches,
params_specs_stored_mismatches,
params_specs_not_usable,
};
let report_handler = GraphicalReportHandler::new()
.without_cause_chain()
.with_theme(GraphicalTheme::none());
let mut err_buffer = String::with_capacity(1280);
report_handler.render_report(&mut err_buffer, &error)?;
let err_buffer = err_buffer.lines().fold(
String::with_capacity(err_buffer.len()),
|mut buffer, line| {
if line.trim().is_empty() {
buffer.push('\n');
} else {
buffer.push_str(line);
buffer.push('\n');
}
buffer
},
);
assert_eq!(
r#"peace_rt_model::params_specs_mismatch
x Item params specs do not match with the items in the flow.
help: The following items do not have parameters provided:
* no_params_0
* no_params_1
The following provided params specs do not correspond to any items in the flow:
* params_spec_provided_with_no_item_0
* params_spec_provided_with_no_item_1
The following stored params specs do not correspond to any items in the flow:
* params_spec_stored_with_no_item_0
* params_spec_stored_with_no_item_1
The following items either have not had a params spec provided previously,
or had contained a mapping function, which cannot be loaded from disk.
So the params spec needs to be provided to the command context for:
* stored_mapping_fn_0
* stored_mapping_fn_1
"#,
err_buffer
);
Ok(())
}
#[test]
fn coverage_diagnostic() {
let error = Box::new(Error::StatesCurrentDiscoverRequired);
std::borrow::Borrow::<dyn miette::Diagnostic + '_>::borrow(&error);
let _ = error.code();
let _ = error.severity();
let _ = error.help();
let _ = error.url();
let _ = error.source_code();
let _ = error.labels();
let _ = error.related();
let _ = error.diagnostic_source();
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/item_wrapper.rs | workspace_tests/src/rt_model/item_wrapper.rs | use diff::{VecDiff, VecDiffType};
use peace::{
cfg::{ApplyCheck, FnCtx},
data::marker::{ApplyDry, Clean, Current, Goal},
item_model::item_id,
params::{MappingFnReg, ParamsSpec, ParamsSpecs},
resource_rt::{
internal::StatesMut,
resources::ts::SetUp,
states::{self, StatesCurrent, StatesCurrentStored, StatesGoal},
type_reg::untagged::{BoxDataTypeDowncast, BoxDtDisplay},
Resources,
},
rt_model::{Error as PeaceRtError, ItemRt, ItemWrapper, StateDowncastError},
};
use peace_items::blank::BlankItem;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
use peace::progress_model::{ProgressLimit, ProgressSender};
use tokio::sync::mpsc;
}
}
use crate::{
PeaceTestError, VecA, VecB, VecCopyDiff, VecCopyError, VecCopyItem, VecCopyItemWrapper,
VecCopyState,
};
#[test]
fn eq_returns_true_for_same_item_type() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let item_rt_0: &dyn ItemRt<_> = &item_wrapper;
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let item_rt_1: &dyn ItemRt<_> = &item_wrapper;
assert!(item_rt_0.eq(item_rt_1));
let item_wrapper =
ItemWrapper::<_, PeaceTestError>::from(BlankItem::<()>::new(item_id!("blank")));
let item_rt_0: &dyn ItemRt<_> = &item_wrapper;
let item_wrapper =
ItemWrapper::<_, PeaceTestError>::from(BlankItem::<()>::new(item_id!("blank")));
let item_rt_1: &dyn ItemRt<_> = &item_wrapper;
assert!(item_rt_0.eq(item_rt_1));
}
#[test]
fn eq_returns_false_for_different_item_type() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::new(item_id!("blank")));
let item_rt_0: &dyn ItemRt<_> = &item_wrapper;
let item_wrapper =
ItemWrapper::<_, PeaceTestError>::from(BlankItem::<()>::new(item_id!("blank")));
let item_rt_1: &dyn ItemRt<_> = &item_wrapper;
assert!(!item_rt_0.eq(item_rt_1));
assert!(!item_rt_1.eq(item_rt_0));
}
#[test]
fn eq_returns_false_for_different_item_id() {
let item_wrapper =
ItemWrapper::<_, PeaceTestError>::from(BlankItem::<()>::new(item_id!("blank_0")));
let item_rt_0: &dyn ItemRt<_> = &item_wrapper;
let item_wrapper =
ItemWrapper::<_, PeaceTestError>::from(BlankItem::<()>::new(item_id!("blank_1")));
let item_rt_1: &dyn ItemRt<_> = &item_wrapper;
assert!(!item_rt_0.eq(item_rt_1));
}
#[test]
fn state_eq_returns_true_for_same_value() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let state_eq = item_wrapper.state_eq(
&BoxDtDisplay::new(VecCopyState::from(vec![0u8])),
&BoxDtDisplay::new(VecCopyState::from(vec![0u8])),
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(&state_eq, Ok(true)),
"expected `state_eq` to be `Ok(true)`, but was `{state_eq:?}`."
);
}
})();
}
#[test]
fn state_eq_returns_false_for_different_value() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let state_eq = item_wrapper.state_eq(
&BoxDtDisplay::new(VecCopyState::from(vec![0u8])),
&BoxDtDisplay::new(VecCopyState::from(vec![1u8])),
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(&state_eq, Ok(false)),
"expected `state_eq` to be `Ok(false)`, but was `{state_eq:?}`."
);
}
})();
}
#[test]
fn state_eq_returns_err_first_when_first_fails_downcast() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let state_eq = item_wrapper.state_eq(
&BoxDtDisplay::new(String::from("string_a")),
&BoxDtDisplay::new(VecCopyState::from(vec![1u8])),
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&state_eq,
Err(PeaceTestError::PeaceRt(PeaceRtError::StateDowncastError(
StateDowncastError::First { ty_name, state_a }
))) if
ty_name == "VecCopyState" &&
format!("{state_a}") == "string_a"
),
"expected `state_eq` to be `Err( .. {{ StateDowncastError::First {{ .. }} }})`,\n\
but was `{state_eq:?}`."
);
}
})();
}
#[test]
fn state_eq_returns_err_second_when_second_fails_downcast() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let state_eq = item_wrapper.state_eq(
&BoxDtDisplay::new(VecCopyState::from(vec![0u8])),
&BoxDtDisplay::new(String::from("string_b")),
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&state_eq,
Err(PeaceTestError::PeaceRt(PeaceRtError::StateDowncastError(
StateDowncastError::Second { ty_name, state_b }
))) if
ty_name == "VecCopyState" &&
format!("{state_b}") == "string_b"
),
"expected `state_eq` to be `Err( .. {{ StateDowncastError::Second {{ .. }} }})`,\n\
but was `{state_eq:?}`."
);
}
})();
}
#[test]
fn state_eq_returns_err_both_when_both_fail_downcast() {
let item_wrapper = ItemWrapper::<_, PeaceTestError>::from(VecCopyItem::default());
let state_eq = item_wrapper.state_eq(
&BoxDtDisplay::new(String::from("string_a")),
&BoxDtDisplay::new(String::from("string_b")),
);
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&state_eq,
Err(PeaceTestError::PeaceRt(PeaceRtError::StateDowncastError(
StateDowncastError::Both { ty_name, state_a, state_b }
))) if
ty_name == "VecCopyState" &&
format!("{state_a}") == "string_a" &&
format!("{state_b}") == "string_b"
),
"expected `state_eq` to be `Err( .. {{ StateDowncastError::Both {{ .. }} }})`,\n\
but was `{state_eq:?}`."
);
}
})();
}
#[tokio::test]
async fn deref_to_dyn_item_rt() {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item.clone());
let item_rt: &dyn ItemRt<_> = &item_wrapper;
assert_eq!(format!("{vec_copy_item:?}"), format!("{item_rt:?}"));
}
#[tokio::test]
async fn deref_mut_to_dyn_item_rt() {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item.clone());
let item_rt: &dyn ItemRt<_> = &item_wrapper;
assert_eq!(format!("{vec_copy_item:?}"), format!("{item_rt:?}"));
}
#[tokio::test]
async fn setup() -> Result<(), Box<dyn std::error::Error>> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let mut resources = Resources::new();
<dyn ItemRt<_>>::setup(&item_wrapper, &mut resources).await?;
resources.insert(VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]));
assert!(resources.try_borrow::<VecA>().is_ok());
// Automatic `Current<State>` and `Goal<State>` insertion.
assert!(resources.try_borrow::<Current<VecCopyState>>().is_ok());
assert!(resources.borrow::<Current<VecCopyState>>().is_none());
assert!(resources.try_borrow::<Goal<VecCopyState>>().is_ok());
assert!(resources.borrow::<Goal<VecCopyState>>().is_none());
Ok(())
}
#[tokio::test]
async fn state_current_try_exec() -> Result<(), Box<dyn std::error::Error>> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources) = resources_set_up(&item_wrapper).await?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
let state = item_wrapper
.state_current_try_exec(¶ms_specs, &mapping_fn_reg, &resources, fn_ctx)
.await?
.unwrap();
assert_eq!(
Some(VecCopyState::new()).as_ref(),
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(&state)
);
// Automatic `Current<State>` insertion.
assert_eq!(
Some(VecCopyState::new()).as_ref(),
resources.borrow::<Current<VecCopyState>>().as_ref()
);
Ok(())
}
#[tokio::test]
async fn state_goal_try_exec() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources) = resources_set_up(&item_wrapper).await?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
let state_goal = item_wrapper
.state_goal_try_exec(¶ms_specs, &mapping_fn_reg, &resources, fn_ctx)
.await?
.unwrap();
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
BoxDataTypeDowncast::<VecCopyState>::downcast_ref(&state_goal)
);
// Automatic `Goal<State>` insertion.
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
resources.borrow::<Goal<VecCopyState>>().as_ref()
);
Ok(())
}
#[tokio::test]
async fn state_diff_exec() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources, states_current_stored, states_goal) =
resources_and_states_current_stored_and_goal(&item_wrapper).await?;
let state_diff = item_wrapper
.state_diff_exec(
¶ms_specs,
&mapping_fn_reg,
&resources,
&states_current_stored,
&states_goal,
)
.await?
.expect(
"Expected state_diff to be Some when state_current_stored and state_goal both exist.",
);
assert_eq!(
Some(VecCopyDiff::from(VecDiff(vec![VecDiffType::Inserted {
index: 0,
changes: vec![0u8, 1, 2, 3, 4, 5, 6, 7]
}])))
.as_ref(),
BoxDataTypeDowncast::<VecCopyDiff>::downcast_ref(&state_diff)
);
Ok(())
}
#[tokio::test]
async fn ensure_prepare() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources) = resources_set_up(&item_wrapper).await?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
match <dyn ItemRt<_>>::ensure_prepare(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
)
.await
{
Ok(item_apply) => {
#[cfg(not(feature = "output_progress"))]
assert_eq!(ApplyCheck::ExecRequired, item_apply.apply_check());
#[cfg(feature = "output_progress")]
assert_eq!(
ApplyCheck::ExecRequired {
progress_limit: ProgressLimit::Bytes(8)
},
item_apply.apply_check()
);
Ok(())
}
Err((error, _item_apply_partial)) => Err(error),
}
}
#[tokio::test]
async fn apply_exec_dry_for_ensure() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources) = resources_set_up(&item_wrapper).await?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
let mut item_apply_boxed = <dyn ItemRt<_>>::ensure_prepare(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
)
.await
.map_err(|(error, _)| error)?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
<dyn ItemRt<_>>::apply_exec_dry(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
&mut item_apply_boxed,
)
.await?;
let vec_b = resources.borrow::<VecB>();
assert_eq!(&[0u8; 0], &*vec_b.0);
// Automatic `Current<State>` insertion.
assert_eq!(
Some(VecCopyState::new()).as_ref(),
resources.borrow::<Current<VecCopyState>>().as_ref()
);
// Automatic `ApplyDry<State>` insertion.
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
resources.borrow::<ApplyDry<VecCopyState>>().as_ref()
);
// Goal should also exist.
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
resources.borrow::<Goal<VecCopyState>>().as_ref()
);
Ok(())
}
#[tokio::test]
async fn apply_exec_for_ensure() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources) = resources_set_up(&item_wrapper).await?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
let mut item_apply_boxed = <dyn ItemRt<_>>::ensure_prepare(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
)
.await
.map_err(|(error, _)| error)?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
<dyn ItemRt<_>>::apply_exec(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
&mut item_apply_boxed,
)
.await?;
let vec_b = resources.borrow::<VecB>();
assert_eq!(&[0u8, 1, 2, 3, 4, 5, 6, 7], &*vec_b.0);
// Automatic `Current<State>` insertion.
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
resources.borrow::<Current<VecCopyState>>().as_ref()
);
// Goal should also exist.
assert_eq!(
Some(VecCopyState::from(vec![0u8, 1, 2, 3, 4, 5, 6, 7])).as_ref(),
resources.borrow::<Goal<VecCopyState>>().as_ref()
);
Ok(())
}
#[tokio::test]
async fn clean_prepare() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources, states_current) =
resources_set_up_with_pre_stored_state(&item_wrapper).await?;
match <dyn ItemRt<_>>::clean_prepare(
&item_wrapper,
&states_current,
¶ms_specs,
&mapping_fn_reg,
&resources,
)
.await
{
Ok(item_apply) => {
#[cfg(not(feature = "output_progress"))]
assert_eq!(ApplyCheck::ExecRequired, item_apply.apply_check());
#[cfg(feature = "output_progress")]
assert_eq!(
ApplyCheck::ExecRequired {
progress_limit: ProgressLimit::Bytes(8)
},
item_apply.apply_check()
);
Ok(())
}
Err((error, _item_apply_partial)) => Err(error),
}
}
#[tokio::test]
async fn apply_exec_dry_for_clean() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources, states_current) =
resources_set_up_with_pre_stored_state(&item_wrapper).await?;
let mut item_apply_boxed = <dyn ItemRt<_>>::clean_prepare(
&item_wrapper,
&states_current,
¶ms_specs,
&mapping_fn_reg,
&resources,
)
.await
.map_err(|(error, _)| error)?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
<dyn ItemRt<_>>::apply_exec_dry(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
&mut item_apply_boxed,
)
.await?;
let vec_b = resources.borrow::<VecB>();
assert_eq!(&[0u8, 1, 2, 3, 4, 5, 6, 7], &*vec_b.0);
// Automatic `ApplyDry<State>` insertion.
assert_eq!(
Some(VecCopyState::new()).as_ref(),
resources.borrow::<ApplyDry<VecCopyState>>().as_ref()
);
// Clean should also exist.
assert_eq!(
Some(VecCopyState::new()).as_ref(),
resources.borrow::<Clean<VecCopyState>>().as_ref()
);
Ok(())
}
#[tokio::test]
async fn apply_exec_for_clean() -> Result<(), VecCopyError> {
let vec_copy_item = VecCopyItem::default();
let item_wrapper = ItemWrapper::<_, VecCopyError>::from(vec_copy_item);
let (params_specs, mapping_fn_reg, resources, states_current) =
resources_set_up_with_pre_stored_state(&item_wrapper).await?;
let mut item_apply_boxed = <dyn ItemRt<_>>::clean_prepare(
&item_wrapper,
&states_current,
¶ms_specs,
&mapping_fn_reg,
&resources,
)
.await
.map_err(|(error, _)| error)?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
<dyn ItemRt<_>>::apply_exec(
&item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
&mut item_apply_boxed,
)
.await?;
let vec_b = resources.borrow::<VecB>();
assert_eq!(&[0u8; 0], &*vec_b.0);
// Automatic `Current<State>` insertion.
assert_eq!(
Some(VecCopyState::new()).as_ref(),
resources.borrow::<Current<VecCopyState>>().as_ref()
);
// Clean should also exist.
assert_eq!(
Some(VecCopyState::new()).as_ref(),
resources.borrow::<Clean<VecCopyState>>().as_ref()
);
Ok(())
}
async fn resources_set_up(
item_wrapper: &VecCopyItemWrapper,
) -> Result<(ParamsSpecs, MappingFnReg, Resources<SetUp>), VecCopyError> {
let mut params_specs = ParamsSpecs::new();
params_specs.insert(
VecCopyItem::ID_DEFAULT.clone(),
ParamsSpec::Value {
value: VecA(vec![0, 1, 2, 3, 4, 5, 6, 7]),
},
);
let mapping_fn_reg = MappingFnReg::new();
let mut resources = Resources::new();
<dyn ItemRt<_>>::setup(item_wrapper, &mut resources).await?;
let resources = Resources::<SetUp>::from(resources);
Ok((params_specs, mapping_fn_reg, resources))
}
async fn resources_set_up_with_pre_stored_state(
item_wrapper: &VecCopyItemWrapper,
) -> Result<(ParamsSpecs, MappingFnReg, Resources<SetUp>, StatesCurrent), VecCopyError> {
let (params_specs, mapping_fn_reg, mut resources) = resources_set_up(item_wrapper).await?;
let stored_state = vec![0, 1, 2, 3, 4, 5, 6, 7];
resources.insert(VecB(stored_state.clone()));
resources.insert(Current(Some(VecCopyState::from(stored_state.clone()))));
let states_current = {
let mut states_mut = StatesMut::new();
states_mut.insert(
VecCopyItem::ID_DEFAULT.clone(),
VecCopyState::from(stored_state),
);
StatesCurrent::from(states_mut)
};
Ok((params_specs, mapping_fn_reg, resources, states_current))
}
async fn resources_and_states_current_stored_and_goal(
item_wrapper: &VecCopyItemWrapper,
) -> Result<
(
ParamsSpecs,
MappingFnReg,
Resources<SetUp>,
StatesCurrentStored,
StatesGoal,
),
VecCopyError,
> {
let (params_specs, mapping_fn_reg, resources) = resources_set_up(item_wrapper).await?;
cfg_if::cfg_if! {
if #[cfg(feature = "output_progress")] {
let (progress_tx, _progress_rx) = mpsc::channel(10);
let progress_sender = ProgressSender::new(
VecCopyItem::ID_DEFAULT,
&progress_tx,
);
}
}
let fn_ctx = FnCtx::new(
VecCopyItem::ID_DEFAULT,
#[cfg(feature = "output_progress")]
progress_sender,
);
let states_current_stored = {
let mut states_mut = StatesMut::new();
let state = <dyn ItemRt<_>>::state_current_try_exec(
item_wrapper,
¶ms_specs,
&mapping_fn_reg,
&resources,
fn_ctx,
)
.await?;
if let Some(state) = state {
states_mut.insert_raw(<dyn ItemRt<_>>::id(item_wrapper).clone(), state);
}
Into::<StatesCurrentStored>::into(StatesCurrent::from(states_mut))
};
let states_goal = {
let mut states_goal_mut = StatesMut::<states::ts::Goal>::new();
let state_goal = item_wrapper
.state_goal_try_exec(¶ms_specs, &mapping_fn_reg, &resources, fn_ctx)
.await?
.unwrap();
states_goal_mut.insert_raw(<dyn ItemRt<_>>::id(item_wrapper).clone(), state_goal);
StatesGoal::from(states_goal_mut)
};
Ok((
params_specs,
mapping_fn_reg,
resources,
states_current_stored,
states_goal,
))
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/workspace_dirs_builder.rs | workspace_tests/src/rt_model/workspace_dirs_builder.rs | use std::path::Path;
use peace::{
cfg::app_name,
rt_model::{Error, NativeError, WorkspaceDirsBuilder, WorkspaceSpec},
};
#[test]
fn returns_workspace_dir_from_working_directory() -> Result<(), Box<dyn std::error::Error>> {
let workspace_dirs = WorkspaceDirsBuilder::build(&app_name!(), WorkspaceSpec::WorkingDir)?;
let workspace_dir = workspace_dirs.workspace_dir();
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
workspace_dir.ends_with("peace/workspace_tests"),
"Expected `{}` to end with `peace/workspace_tests`",
workspace_dir.display()
);
}
})();
Ok(())
}
#[test]
fn returns_workspace_dir_from_first_dir_with_file() -> Result<(), Box<dyn std::error::Error>> {
let workspace_dirs = WorkspaceDirsBuilder::build(
&app_name!(),
WorkspaceSpec::FirstDirWithFile("Cargo.lock".into()),
)?;
let workspace_dir = workspace_dirs.workspace_dir();
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
workspace_dir.ends_with("peace"),
"Expected `{}` to end with `peace`",
workspace_dir.display()
);
}
})();
Ok(())
}
#[test]
fn returns_workspace_file_not_found_when_workspace_root_file_does_not_exist(
) -> Result<(), Box<dyn std::error::Error>> {
let workspace_dirs_result = WorkspaceDirsBuilder::build(
&app_name!(),
WorkspaceSpec::FirstDirWithFile("non_existent_file".into()),
);
assert!(matches!(
workspace_dirs_result,
Err(Error::Native(NativeError::WorkspaceFileNotFound {
working_dir: _,
file_name,
})) if file_name == Path::new("non_existent_file")
));
Ok(())
}
#[test]
fn returns_workspace_dir_from_path() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace_dirs = WorkspaceDirsBuilder::build(
&app_name!(),
WorkspaceSpec::Path(Path::new(tempdir.path()).to_path_buf()),
)?;
let workspace_dir = workspace_dirs.workspace_dir();
assert!(&**workspace_dir == tempdir.path());
Ok(())
}
#[test]
fn returns_peace_dir_relative_to_workspace_dir() -> Result<(), Box<dyn std::error::Error>> {
let workspace_dirs = WorkspaceDirsBuilder::build(
&app_name!(),
WorkspaceSpec::FirstDirWithFile("Cargo.lock".into()),
)?;
let peace_dir = workspace_dirs.peace_dir();
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
peace_dir.ends_with("peace/.peace"),
"Expected `{}` to end with `peace/.peace`",
peace_dir.display()
);
}
})();
Ok(())
}
#[test]
fn returns_peace_app_dir_relative_to_peace_dir() -> Result<(), Box<dyn std::error::Error>> {
let workspace_dirs = WorkspaceDirsBuilder::build(
&app_name!(),
WorkspaceSpec::FirstDirWithFile("Cargo.lock".into()),
)?;
let peace_app_dir = workspace_dirs.peace_app_dir();
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
peace_app_dir.ends_with("peace/.peace/workspace_tests"),
"Expected `{}` to end with `peace/.peace/workspace_tests`",
peace_app_dir.display()
);
}
})();
Ok(())
}
#[test]
fn debug() {
let workspace_dirs_builder = WorkspaceDirsBuilder;
assert_eq!(
"WorkspaceDirsBuilder",
format!("{workspace_dirs_builder:?}")
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/item_graph_builder.rs | workspace_tests/src/rt_model/item_graph_builder.rs | use peace::{
flow_rt::ItemGraphBuilder,
rt_model::{fn_graph::FnGraphBuilder, Error, ItemBoxed},
};
#[test]
fn debug() {
let builder = ItemGraphBuilder::<Error>::new();
assert!(format!("{builder:?}").starts_with("ItemGraphBuilder"));
}
#[test]
fn into_inner() {
let _fn_graph_builder = ItemGraphBuilder::<Error>::new().into_inner();
}
#[test]
fn deref() {
let builder = ItemGraphBuilder::<Error>::new();
let _fn_graph_builder: &FnGraphBuilder<ItemBoxed<Error>> = &builder;
}
#[test]
fn deref_mut() {
let mut builder = ItemGraphBuilder::<Error>::new();
let _fn_graph_builder: &mut FnGraphBuilder<ItemBoxed<Error>> = &mut builder;
}
#[test]
fn from() {
let fn_graph_builder = FnGraphBuilder::<ItemBoxed<Error>>::new();
let _builder = ItemGraphBuilder::<Error>::from(fn_graph_builder);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params/workspace_params.rs | workspace_tests/src/rt_model/params/workspace_params.rs | use peace::{cmd_ctx::type_reg::untagged::TypeMap, rt_model::params::WorkspaceParams};
#[test]
fn new() {
let workspace_params = WorkspaceParams::<()>::new();
assert_eq!(0, workspace_params.len());
assert_eq!(0, workspace_params.capacity());
}
#[test]
fn with_capacity() {
let workspace_params = WorkspaceParams::<()>::with_capacity(10);
assert_eq!(0, workspace_params.len());
assert_eq!(10, workspace_params.capacity());
}
#[test]
fn into_inner() {
let workspace_params = WorkspaceParams::<()>::with_capacity(10);
let type_map = workspace_params.into_inner();
assert_eq!(0, type_map.len());
assert_eq!(10, type_map.capacity());
}
#[test]
fn deref() {
let workspace_params = WorkspaceParams::<()>::with_capacity(10);
assert_eq!(0, (*workspace_params).len());
}
#[test]
fn deref_mut() {
let mut workspace_params = WorkspaceParams::<()>::with_capacity(10);
assert_eq!(0, (*workspace_params).as_mut_slice().len());
}
#[test]
fn from_type_map() {
let workspace_params = WorkspaceParams::from(TypeMap::<()>::new());
assert_eq!(0, workspace_params.len());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params/flow_params.rs | workspace_tests/src/rt_model/params/flow_params.rs | use peace::{cmd_ctx::type_reg::untagged::TypeMap, rt_model::params::FlowParams};
#[test]
fn new() {
let flow_params = FlowParams::<()>::new();
assert_eq!(0, flow_params.len());
assert_eq!(0, flow_params.capacity());
}
#[test]
fn with_capacity() {
let flow_params = FlowParams::<()>::with_capacity(10);
assert_eq!(0, flow_params.len());
assert_eq!(10, flow_params.capacity());
}
#[test]
fn into_inner() {
let flow_params = FlowParams::<()>::with_capacity(10);
let type_map = flow_params.into_inner();
assert_eq!(0, type_map.len());
assert_eq!(10, type_map.capacity());
}
#[test]
fn deref() {
let flow_params = FlowParams::<()>::with_capacity(10);
assert_eq!(0, (*flow_params).len());
}
#[test]
fn deref_mut() {
let mut flow_params = FlowParams::<()>::with_capacity(10);
assert_eq!(0, (*flow_params).as_mut_slice().len());
}
#[test]
fn from_type_map() {
let flow_params = FlowParams::from(TypeMap::<()>::new());
assert_eq!(0, flow_params.len());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params/profile_params_opt.rs | workspace_tests/src/rt_model/params/profile_params_opt.rs | use peace::{cmd_ctx::type_reg::untagged::TypeMapOpt, rt_model::params::ProfileParamsOpt};
#[test]
fn new() {
let profile_params_opt = ProfileParamsOpt::<()>::new();
assert_eq!(0, profile_params_opt.len());
assert_eq!(0, profile_params_opt.capacity());
}
#[test]
fn with_capacity() {
let profile_params_opt = ProfileParamsOpt::<()>::with_capacity(10);
assert_eq!(0, profile_params_opt.len());
assert_eq!(10, profile_params_opt.capacity());
}
#[test]
fn into_inner() {
let profile_params_opt = ProfileParamsOpt::<()>::with_capacity(10);
let type_map_opt = profile_params_opt.into_inner();
assert_eq!(0, type_map_opt.len());
assert_eq!(10, type_map_opt.capacity());
}
#[test]
fn deref() {
let profile_params_opt = ProfileParamsOpt::<()>::with_capacity(10);
assert_eq!(0, (*profile_params_opt).len());
}
#[test]
fn deref_mut() {
let mut profile_params_opt = ProfileParamsOpt::<()>::with_capacity(10);
assert_eq!(0, (*profile_params_opt).as_mut_slice().len());
}
#[test]
fn from_type_map_opt() {
let profile_params_opt = ProfileParamsOpt::from(TypeMapOpt::<()>::new());
assert_eq!(0, profile_params_opt.len());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params/workspace_params_opt.rs | workspace_tests/src/rt_model/params/workspace_params_opt.rs | use peace::{cmd_ctx::type_reg::untagged::TypeMapOpt, rt_model::params::WorkspaceParamsOpt};
#[test]
fn new() {
let workspace_params_opt = WorkspaceParamsOpt::<()>::new();
assert_eq!(0, workspace_params_opt.len());
assert_eq!(0, workspace_params_opt.capacity());
}
#[test]
fn with_capacity() {
let workspace_params_opt = WorkspaceParamsOpt::<()>::with_capacity(10);
assert_eq!(0, workspace_params_opt.len());
assert_eq!(10, workspace_params_opt.capacity());
}
#[test]
fn into_inner() {
let workspace_params_opt = WorkspaceParamsOpt::<()>::with_capacity(10);
let type_map_opt = workspace_params_opt.into_inner();
assert_eq!(0, type_map_opt.len());
assert_eq!(10, type_map_opt.capacity());
}
#[test]
fn deref() {
let workspace_params_opt = WorkspaceParamsOpt::<()>::with_capacity(10);
assert_eq!(0, (*workspace_params_opt).len());
}
#[test]
fn deref_mut() {
let mut workspace_params_opt = WorkspaceParamsOpt::<()>::with_capacity(10);
assert_eq!(0, (*workspace_params_opt).as_mut_slice().len());
}
#[test]
fn from_type_map_opt() {
let workspace_params_opt = WorkspaceParamsOpt::from(TypeMapOpt::<()>::new());
assert_eq!(0, workspace_params_opt.len());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params/flow_params_opt.rs | workspace_tests/src/rt_model/params/flow_params_opt.rs | use peace::{cmd_ctx::type_reg::untagged::TypeMapOpt, rt_model::params::FlowParamsOpt};
#[test]
fn new() {
let flow_params_opt = FlowParamsOpt::<()>::new();
assert_eq!(0, flow_params_opt.len());
assert_eq!(0, flow_params_opt.capacity());
}
#[test]
fn with_capacity() {
let flow_params_opt = FlowParamsOpt::<()>::with_capacity(10);
assert_eq!(0, flow_params_opt.len());
assert_eq!(10, flow_params_opt.capacity());
}
#[test]
fn into_inner() {
let flow_params_opt = FlowParamsOpt::<()>::with_capacity(10);
let type_map_opt = flow_params_opt.into_inner();
assert_eq!(0, type_map_opt.len());
assert_eq!(10, type_map_opt.capacity());
}
#[test]
fn deref() {
let flow_params_opt = FlowParamsOpt::<()>::with_capacity(10);
assert_eq!(0, (*flow_params_opt).len());
}
#[test]
fn deref_mut() {
let mut flow_params_opt = FlowParamsOpt::<()>::with_capacity(10);
assert_eq!(0, (*flow_params_opt).as_mut_slice().len());
}
#[test]
fn from_type_map_opt() {
let flow_params_opt = FlowParamsOpt::from(TypeMapOpt::<()>::new());
assert_eq!(0, flow_params_opt.len());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/params/profile_params.rs | workspace_tests/src/rt_model/params/profile_params.rs | use peace::{cmd_ctx::type_reg::untagged::TypeMap, rt_model::params::ProfileParams};
#[test]
fn new() {
let profile_params = ProfileParams::<()>::new();
assert_eq!(0, profile_params.len());
assert_eq!(0, profile_params.capacity());
}
#[test]
fn with_capacity() {
let profile_params = ProfileParams::<()>::with_capacity(10);
assert_eq!(0, profile_params.len());
assert_eq!(10, profile_params.capacity());
}
#[test]
fn into_inner() {
let profile_params = ProfileParams::<()>::with_capacity(10);
let type_map = profile_params.into_inner();
assert_eq!(0, type_map.len());
assert_eq!(10, type_map.capacity());
}
#[test]
fn deref() {
let profile_params = ProfileParams::<()>::with_capacity(10);
assert_eq!(0, (*profile_params).len());
}
#[test]
fn deref_mut() {
let mut profile_params = ProfileParams::<()>::with_capacity(10);
assert_eq!(0, (*profile_params).as_mut_slice().len());
}
#[test]
fn from_type_map() {
let profile_params = ProfileParams::from(TypeMap::<()>::new());
assert_eq!(0, profile_params.len());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/native/workspace_spec.rs | workspace_tests/src/rt_model/native/workspace_spec.rs | use peace::rt_model::WorkspaceSpec;
#[test]
fn clone() {
let workspace_spec = WorkspaceSpec::Path(".git".into());
assert_eq!(workspace_spec.clone(), workspace_spec);
}
#[test]
fn debug() {
let workspace_spec = WorkspaceSpec::WorkingDir;
assert_eq!("WorkingDir", format!("{workspace_spec:?}"));
}
#[test]
fn partial_eq() {
assert_eq!(WorkspaceSpec::WorkingDir, WorkspaceSpec::WorkingDir);
assert_ne!(
WorkspaceSpec::FirstDirWithFile(".git".into()),
WorkspaceSpec::FirstDirWithFile(".peace".into())
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/error/params_specs_deserialize_error.rs | workspace_tests/src/rt_model/error/params_specs_deserialize_error.rs | use miette::{Diagnostic, NamedSource};
use peace::{cfg::profile, flow_model::flow_id, rt_model::ParamsSpecsDeserializeError};
use serde::de::Error;
#[test]
fn coverage_diagnostic() {
let error = Box::new(ParamsSpecsDeserializeError {
profile: profile!("test_profile"),
flow_id: flow_id!("test_flow"),
params_specs_file_source: NamedSource::new(
"params_specs.yaml",
String::from("vec_item: ~"),
),
error_span: None,
error_message: String::from("params specs was not provided for `VecCopyItem`."),
context_span: None,
error: serde_yaml::Error::custom("custom error"),
});
std::borrow::Borrow::<dyn miette::Diagnostic + '_>::borrow(&error);
let _ = error.code();
let _ = error.severity();
let _ = error.help();
let _ = error.url();
let _ = error.source_code();
let _ = error.labels();
let _ = error.related();
let _ = error.diagnostic_source();
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/error/states_deserialize_error.rs | workspace_tests/src/rt_model/error/states_deserialize_error.rs | use miette::{Diagnostic, NamedSource};
use peace::{flow_model::flow_id, rt_model::StatesDeserializeError};
use serde::de::Error;
#[test]
fn coverage_diagnostic() {
let error = Box::new(StatesDeserializeError {
flow_id: flow_id!("test_flow"),
states_file_source: NamedSource::new("states_current.yaml", String::from("vec_item: ~")),
error_span: None,
error_message: String::from("Failed to deserialize states."),
context_span: None,
error: serde_yaml::Error::custom("custom error"),
});
std::borrow::Borrow::<dyn miette::Diagnostic + '_>::borrow(&error);
let _ = error.code();
let _ = error.severity();
let _ = error.help();
let _ = error.url();
let _ = error.source_code();
let _ = error.labels();
let _ = error.related();
let _ = error.diagnostic_source();
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes/item_apply_partial_rt.rs | workspace_tests/src/rt_model/outcomes/item_apply_partial_rt.rs | use peace::{
cfg::ApplyCheck,
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt_model::outcomes::{ItemApplyPartial, ItemApplyPartialRt},
};
#[test]
fn item_apply_rt_state_current_stored_returns_state_current_stored(
) -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_boxed = Box::new(item_apply_partial) as Box<dyn ItemApplyPartialRt>;
let state_current_stored =
ItemApplyPartialRt::state_current_stored(&item_apply_partial_boxed).unwrap();
assert_eq!(
456u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current_stored).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_current_returns_state_current() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_boxed = Box::new(item_apply_partial) as Box<dyn ItemApplyPartialRt>;
let state_current = ItemApplyPartialRt::state_current(&item_apply_partial_boxed).unwrap();
assert_eq!(
123u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_target_returns_state_target() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_boxed = Box::new(item_apply_partial) as Box<dyn ItemApplyPartialRt>;
let state_target = ItemApplyPartialRt::state_target(&item_apply_partial_boxed).unwrap();
assert_eq!(
789u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_target).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_diff_returns_state_diff() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_boxed = Box::new(item_apply_partial) as Box<dyn ItemApplyPartialRt>;
let state_diff = ItemApplyPartialRt::state_diff(&item_apply_partial_boxed).unwrap();
assert_eq!(
8u8,
*BoxDataTypeDowncast::<u8>::downcast_ref(&state_diff).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_apply_check_returns_apply_check() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_boxed = Box::new(item_apply_partial) as Box<dyn ItemApplyPartialRt>;
let apply_check = ItemApplyPartialRt::apply_check(&item_apply_partial_boxed).unwrap();
assert_eq!(ApplyCheck::ExecNotRequired, apply_check);
Ok(())
}
#[test]
fn item_apply_rt_as_data_type_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_clone = item_apply_partial.clone();
let item_apply_partial_clone_boxed =
Box::new(item_apply_partial_clone) as Box<dyn ItemApplyPartialRt>;
let data_type = ItemApplyPartialRt::as_data_type(&item_apply_partial_clone_boxed);
assert_eq!(
item_apply_partial,
*data_type
.downcast_ref::<ItemApplyPartial<u32, u8>>()
.unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_as_data_type_mut_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_clone = item_apply_partial.clone();
let mut item_apply_partial_clone_boxed =
Box::new(item_apply_partial_clone) as Box<dyn ItemApplyPartialRt>;
let data_type = ItemApplyPartialRt::as_data_type_mut(&mut item_apply_partial_clone_boxed);
assert_eq!(
item_apply_partial,
*data_type
.downcast_mut::<ItemApplyPartial<u32, u8>>()
.unwrap()
);
Ok(())
}
#[test]
fn serialize() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply_partial_boxed = Box::new(item_apply_partial) as Box<dyn ItemApplyPartialRt>;
let serialized = serde_yaml::to_string(&item_apply_partial_boxed)?;
assert_eq!(
r#"state_current_stored: 456
state_current: 123
state_target: 789
state_diff: 8
apply_check: ExecNotRequired
"#,
serialized
);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes/item_apply_boxed.rs | workspace_tests/src/rt_model/outcomes/item_apply_boxed.rs | use std::ops::{Deref, DerefMut};
use peace::{
cfg::{state::External, ApplyCheck, State},
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt_model::outcomes::{ItemApply, ItemApplyBoxed, ItemApplyPartial},
};
use pretty_assertions::assert_eq;
#[test]
fn clone() {
let item_apply_boxed = ItemApplyBoxed::from(item_apply());
let mut item_apply_boxed_clone = Clone::clone(&item_apply_boxed);
*BoxDataTypeDowncast::<ItemApply<State<u32, External<u32>>, u32>>::downcast_mut(
&mut item_apply_boxed_clone,
)
.unwrap() = item_apply();
assert_eq!(
Some(item_apply()),
BoxDataTypeDowncast::<ItemApply<State<u32, External<u32>>, u32>>::downcast_ref(
&item_apply_boxed
)
.cloned()
);
assert_eq!(
Some(item_apply()),
BoxDataTypeDowncast::<ItemApply<State<u32, External<u32>>, u32>>::downcast_ref(
&item_apply_boxed_clone
)
.cloned()
);
}
#[test]
fn debug() {
let item_apply_boxed = ItemApplyBoxed::from(item_apply());
assert_eq!(
r#"ItemApplyBoxed(
ItemApply {
state_current_stored: None,
state_current: State {
logical: 1,
physical: Value(
0,
),
},
state_target: State {
logical: 3,
physical: Tbd,
},
state_diff: 2,
apply_check: ExecNotRequired,
state_applied: None,
},
)"#,
format!("{item_apply_boxed:#?}")
);
}
#[test]
fn deref() {
let item_apply_boxed = ItemApplyBoxed::from(item_apply());
let _data_type = Deref::deref(&item_apply_boxed);
}
#[test]
fn deref_mut() {
let mut item_apply_boxed = ItemApplyBoxed::from(item_apply());
let _data_type = DerefMut::deref_mut(&mut item_apply_boxed);
}
#[test]
fn serialize() -> Result<(), serde_yaml::Error> {
let item_apply_boxed = ItemApplyBoxed::from(item_apply());
let data_type_wrapper = &item_apply_boxed;
assert_eq!(
r#"state_current_stored: null
state_current:
logical: 1
physical: !Value 0
state_target:
logical: 3
physical: !Tbd null
state_diff: 2
apply_check: ExecNotRequired
state_applied: null
"#,
serde_yaml::to_string(data_type_wrapper)?
);
Ok(())
}
fn item_apply() -> ItemApply<State<u32, External<u32>>, u32> {
let mut item_apply_partial = ItemApplyPartial::new();
item_apply_partial.state_current = Some(State::new(1, External::Value(0)));
item_apply_partial.state_target = Some(State::new(3, External::Tbd));
item_apply_partial.state_diff = Some(2);
item_apply_partial.apply_check = Some(ApplyCheck::ExecNotRequired);
ItemApply::try_from((item_apply_partial, None)).unwrap()
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes/item_apply_rt.rs | workspace_tests/src/rt_model/outcomes/item_apply_rt.rs | use peace::{
cfg::ApplyCheck,
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt_model::outcomes::{ItemApply, ItemApplyPartial, ItemApplyRt},
};
#[test]
fn state_current_stored_returns_state_current_stored() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let state_current_stored = ItemApplyRt::state_current_stored(&item_apply_boxed).unwrap();
assert_eq!(
456u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current_stored).unwrap()
);
Ok(())
}
#[test]
fn state_current_returns_state_current() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let state_current = ItemApplyRt::state_current(&item_apply_boxed);
assert_eq!(
123u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current).unwrap()
);
Ok(())
}
#[test]
fn state_target_returns_state_target() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let state_target = ItemApplyRt::state_target(&item_apply_boxed);
assert_eq!(
789u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_target).unwrap()
);
Ok(())
}
#[test]
fn state_diff_returns_state_diff() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let state_diff = ItemApplyRt::state_diff(&item_apply_boxed);
assert_eq!(
8u8,
*BoxDataTypeDowncast::<u8>::downcast_ref(&state_diff).unwrap()
);
Ok(())
}
#[test]
fn apply_check_returns_apply_check() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let apply_check = ItemApplyRt::apply_check(&item_apply_boxed);
assert_eq!(ApplyCheck::ExecNotRequired, apply_check);
Ok(())
}
#[test]
fn state_applied_returns_state_applied() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, Some(456u32))).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let state_applied = ItemApplyRt::state_applied(&item_apply_boxed).unwrap();
assert_eq!(
456u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_applied).unwrap()
);
Ok(())
}
#[test]
fn as_data_type_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_clone = item_apply.clone();
let item_apply_clone_boxed = Box::new(item_apply_clone) as Box<dyn ItemApplyRt>;
let data_type = ItemApplyRt::as_data_type(&item_apply_clone_boxed);
assert_eq!(
item_apply,
*data_type.downcast_ref::<ItemApply<u32, u8>>().unwrap()
);
Ok(())
}
#[test]
fn as_data_type_mut_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let item_apply_clone = item_apply.clone();
let mut item_apply_clone_boxed = Box::new(item_apply_clone) as Box<dyn ItemApplyRt>;
let data_type = ItemApplyRt::as_data_type_mut(&mut item_apply_clone_boxed);
assert_eq!(
item_apply,
*data_type.downcast_mut::<ItemApply<u32, u8>>().unwrap()
);
Ok(())
}
#[test]
fn serialize() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, Some(456u32))).unwrap();
let item_apply_boxed = Box::new(item_apply) as Box<dyn ItemApplyRt>;
let serialized = serde_yaml::to_string(&item_apply_boxed)?;
assert_eq!(
r#"state_current_stored: 456
state_current: 123
state_target: 789
state_diff: 8
apply_check: ExecNotRequired
state_applied: 456
"#,
serialized
);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes/item_apply.rs | workspace_tests/src/rt_model/outcomes/item_apply.rs | use peace::{
cfg::ApplyCheck,
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt_model::outcomes::{ItemApply, ItemApplyPartial, ItemApplyRt},
};
#[test]
fn try_from_returns_ok_when_state_current_stored_is_none_and_others_are_some(
) -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: None,
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
assert_eq!(
ItemApply {
state_current_stored: None,
state_current: 123u32,
state_target: 789u32,
state_diff: 8u8,
apply_check: ApplyCheck::ExecNotRequired,
state_applied: None,
},
item_apply
);
Ok(())
}
#[test]
fn try_from_returns_ok_when_all_fields_are_some() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
assert_eq!(
ItemApply {
state_current_stored: Some(456u32),
state_current: 123u32,
state_target: 789u32,
state_diff: 8u8,
apply_check: ApplyCheck::ExecNotRequired,
state_applied: None,
},
item_apply
);
Ok(())
}
#[test]
fn try_from_passes_through_state_applied() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, Some(789))).unwrap();
assert_eq!(
ItemApply {
state_current_stored: Some(456u32),
state_current: 123u32,
state_target: 789u32,
state_diff: 8u8,
apply_check: ApplyCheck::ExecNotRequired,
state_applied: Some(789),
},
item_apply
);
Ok(())
}
#[test]
fn try_from_returns_err_when_state_current_is_none() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: None,
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let (item_apply_partial, state_applied) =
ItemApply::try_from((item_apply_partial, None)).unwrap_err();
assert_eq!(
ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: None,
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
},
item_apply_partial
);
assert!(state_applied.is_none());
Ok(())
}
#[test]
fn try_from_returns_err_when_state_target_is_none() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: None,
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let (item_apply_partial, state_applied) =
ItemApply::try_from((item_apply_partial, None)).unwrap_err();
assert_eq!(
ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: None,
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
},
item_apply_partial
);
assert!(state_applied.is_none());
Ok(())
}
#[test]
fn try_from_returns_err_when_state_diff_is_none() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: None::<u8>,
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let (item_apply_partial, state_applied) =
ItemApply::try_from((item_apply_partial, None)).unwrap_err();
assert_eq!(
ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: None,
apply_check: Some(ApplyCheck::ExecNotRequired),
},
item_apply_partial
);
assert!(state_applied.is_none());
Ok(())
}
#[test]
fn try_from_returns_err_when_apply_check_is_none() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: None,
};
let (item_apply_partial, state_applied) =
ItemApply::try_from((item_apply_partial, None)).unwrap_err();
assert_eq!(
ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: None,
},
item_apply_partial
);
assert!(state_applied.is_none());
Ok(())
}
#[test]
fn item_apply_rt_state_current_stored_returns_state_current_stored(
) -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let state_current_stored = ItemApplyRt::state_current_stored(&item_apply).unwrap();
assert_eq!(
456u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current_stored).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_current_returns_state_current() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let state_current = ItemApplyRt::state_current(&item_apply);
assert_eq!(
123u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_target_returns_state_target() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let state_target = ItemApplyRt::state_target(&item_apply);
assert_eq!(
789u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_target).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_diff_returns_state_diff() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let state_diff = ItemApplyRt::state_diff(&item_apply);
assert_eq!(
8u8,
*BoxDataTypeDowncast::<u8>::downcast_ref(&state_diff).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_apply_check_returns_apply_check() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let apply_check = ItemApplyRt::apply_check(&item_apply);
assert_eq!(ApplyCheck::ExecNotRequired, apply_check);
Ok(())
}
#[test]
fn item_apply_rt_state_applied_returns_state_applied() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, Some(456u32))).unwrap();
let state_applied = ItemApplyRt::state_applied(&item_apply).unwrap();
assert_eq!(
456u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_applied).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_as_data_type_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let data_type = ItemApplyRt::as_data_type(&item_apply);
assert_eq!(
item_apply,
*data_type.downcast_ref::<ItemApply<u32, u8>>().unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_as_data_type_mut_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let item_apply = ItemApply::try_from((item_apply_partial, None)).unwrap();
let mut item_apply_clone = item_apply.clone();
let data_type = ItemApplyRt::as_data_type_mut(&mut item_apply_clone);
assert_eq!(
item_apply,
*data_type.downcast_mut::<ItemApply<u32, u8>>().unwrap()
);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes/item_apply_partial_boxed.rs | workspace_tests/src/rt_model/outcomes/item_apply_partial_boxed.rs | use std::ops::{Deref, DerefMut};
use peace::{
cfg::{state::External, ApplyCheck, State},
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt_model::outcomes::{ItemApplyPartial, ItemApplyPartialBoxed},
};
use pretty_assertions::assert_eq;
#[test]
fn clone() {
let item_apply_partial_boxed = ItemApplyPartialBoxed::from(item_apply_partial());
let mut item_apply_partial_boxed_clone = Clone::clone(&item_apply_partial_boxed);
*BoxDataTypeDowncast::<ItemApplyPartial<State<u32, External<u32>>, u32>>::downcast_mut(
&mut item_apply_partial_boxed_clone,
)
.unwrap() = item_apply_partial();
assert_eq!(
Some(item_apply_partial()),
BoxDataTypeDowncast::<ItemApplyPartial<State<u32, External<u32>>, u32>>::downcast_ref(
&item_apply_partial_boxed
)
.cloned()
);
assert_eq!(
Some(item_apply_partial()),
BoxDataTypeDowncast::<ItemApplyPartial<State<u32, External<u32>>, u32>>::downcast_ref(
&item_apply_partial_boxed_clone
)
.cloned()
);
}
#[test]
fn debug() {
let item_apply_partial_boxed = ItemApplyPartialBoxed::from(item_apply_partial());
assert_eq!(
r#"ItemApplyPartialBoxed(
ItemApplyPartial {
state_current_stored: None,
state_current: Some(
State {
logical: 1,
physical: Value(
0,
),
},
),
state_target: Some(
State {
logical: 3,
physical: Tbd,
},
),
state_diff: Some(
2,
),
apply_check: Some(
ExecNotRequired,
),
},
)"#,
format!("{item_apply_partial_boxed:#?}")
);
}
#[test]
fn deref() {
let item_apply_partial_boxed = ItemApplyPartialBoxed::from(item_apply_partial());
let _data_type = Deref::deref(&item_apply_partial_boxed);
}
#[test]
fn deref_mut() {
let mut item_apply_partial_boxed = ItemApplyPartialBoxed::from(item_apply_partial());
let _data_type = DerefMut::deref_mut(&mut item_apply_partial_boxed);
}
#[test]
fn serialize() -> Result<(), serde_yaml::Error> {
let item_apply_partial_boxed = ItemApplyPartialBoxed::from(item_apply_partial());
let data_type_wrapper = &item_apply_partial_boxed;
assert_eq!(
r#"state_current_stored: null
state_current:
logical: 1
physical: !Value 0
state_target:
logical: 3
physical: !Tbd null
state_diff: 2
apply_check: ExecNotRequired
"#,
serde_yaml::to_string(data_type_wrapper)?
);
Ok(())
}
fn item_apply_partial() -> ItemApplyPartial<State<u32, External<u32>>, u32> {
let mut item_apply_partial = ItemApplyPartial::new();
item_apply_partial.state_current = Some(State::new(1, External::Value(0)));
item_apply_partial.state_target = Some(State::new(3, External::Tbd));
item_apply_partial.state_diff = Some(2);
item_apply_partial.apply_check = Some(ApplyCheck::ExecNotRequired);
item_apply_partial
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/rt_model/outcomes/item_apply_partial.rs | workspace_tests/src/rt_model/outcomes/item_apply_partial.rs | use peace::{
cfg::ApplyCheck,
resource_rt::type_reg::untagged::BoxDataTypeDowncast,
rt_model::outcomes::{ItemApplyPartial, ItemApplyPartialRt},
};
#[test]
fn item_apply_rt_state_current_stored_returns_state_current_stored(
) -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let state_current_stored =
ItemApplyPartialRt::state_current_stored(&item_apply_partial).unwrap();
assert_eq!(
456u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current_stored).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_current_returns_state_current() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let state_current = ItemApplyPartialRt::state_current(&item_apply_partial).unwrap();
assert_eq!(
123u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_current).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_target_returns_state_target() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let state_target = ItemApplyPartialRt::state_target(&item_apply_partial).unwrap();
assert_eq!(
789u32,
*BoxDataTypeDowncast::<u32>::downcast_ref(&state_target).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_state_diff_returns_state_diff() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let state_diff = ItemApplyPartialRt::state_diff(&item_apply_partial).unwrap();
assert_eq!(
8u8,
*BoxDataTypeDowncast::<u8>::downcast_ref(&state_diff).unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_apply_check_returns_apply_check() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let apply_check = ItemApplyPartialRt::apply_check(&item_apply_partial).unwrap();
assert_eq!(ApplyCheck::ExecNotRequired, apply_check);
Ok(())
}
#[test]
fn item_apply_rt_as_data_type_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let item_apply_partial_clone = item_apply_partial.clone();
let data_type = ItemApplyPartialRt::as_data_type(&item_apply_partial_clone);
assert_eq!(
item_apply_partial,
*data_type
.downcast_ref::<ItemApplyPartial<u32, u8>>()
.unwrap()
);
Ok(())
}
#[test]
fn item_apply_rt_as_data_type_mut_returns_self() -> Result<(), Box<dyn std::error::Error>> {
let item_apply_partial = ItemApplyPartial {
state_current_stored: Some(456u32),
state_current: Some(123u32),
state_target: Some(789u32),
state_diff: Some(8u8),
apply_check: Some(ApplyCheck::ExecNotRequired),
};
let mut item_apply_partial_clone = item_apply_partial.clone();
let data_type = ItemApplyPartialRt::as_data_type_mut(&mut item_apply_partial_clone);
assert_eq!(
item_apply_partial,
*data_type
.downcast_mut::<ItemApplyPartial<u32, u8>>()
.unwrap()
);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_mpsf_params.rs | workspace_tests/src/cmd_ctx/cmd_ctx_mpsf_params.rs | use std::collections::BTreeMap;
use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxMpsf, CmdCtxTypes},
flow_model::flow_id,
flow_rt::{Flow, ItemGraphBuilder},
params::ParamsSpec,
resource_rt::{
paths::{FlowDir, ParamsSpecsFile, ProfileDir, ProfileHistoryDir},
type_reg::untagged::TypeReg,
},
rt_model::{ParamsSpecsTypeReg, StatesTypeReg},
};
use crate::{
no_op_output::NoOpOutput, test_support::workspace_with, PeaceTestError, VecA, VecCopyItem,
};
use super::{FlowParamsKey, ProfileParamsKey, WorkspaceParamsKey};
#[tokio::test]
async fn build() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
let profile_other_flow_dir = FlowDir::from((&profile_other_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
flow_dirs.insert(profile_other.clone(), profile_other_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
let profile_other_flow_dir = FlowDir::from((&profile_other_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
flow_dirs.insert(profile_other.clone(), profile_other_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_profile_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
let profile_other_flow_dir = FlowDir::from((&profile_other_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
flow_dirs.insert(profile_other.clone(), profile_other_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(3u32),
profile_params.get(&ProfileParamsKey::U32Param).copied()
);
assert_eq!(
None::<u64>,
profile_params.get(&ProfileParamsKey::U64Param).copied()
);
assert_eq!(
Some(-4i64),
profile_params.get(&ProfileParamsKey::I64Param).copied()
);
Ok(())
}
#[tokio::test]
async fn build_with_flow_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
// Overwrite existing value
.with_flow_param::<bool>(&profile, FlowParamsKey::BoolParam, Some(true))
// Erase existing value
.with_flow_param::<u16>(&profile, FlowParamsKey::U16Param, None)
// Add new value
.with_flow_param::<i16>(&profile, FlowParamsKey::I16Param, Some(-5i16))
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
let profile_other_flow_dir = FlowDir::from((&profile_other_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
flow_dirs.insert(profile_other.clone(), profile_other_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let profile_to_flow_params = fields.profile_to_flow_params();
let flow_params = profile_to_flow_params
.get(&profile)
.expect("Expected flow params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(
None::<u16>,
flow_params.get(&FlowParamsKey::U16Param).copied()
);
assert_eq!(
Some(-5i16),
flow_params.get(&FlowParamsKey::I16Param).copied()
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
let profile_other_flow_dir = FlowDir::from((&profile_other_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
flow_dirs.insert(profile_other.clone(), profile_other_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
Some(3u32),
profile_params.get(&ProfileParamsKey::U32Param).copied()
);
assert_eq!(
None::<u64>,
profile_params.get(&ProfileParamsKey::U64Param).copied()
);
assert_eq!(
Some(-4i64),
profile_params.get(&ProfileParamsKey::I64Param).copied()
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_flow_params(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
// Overwrite existing value
.with_flow_param::<bool>(&profile, FlowParamsKey::BoolParam, Some(true))
// Erase existing value
.with_flow_param::<u16>(&profile, FlowParamsKey::U16Param, None)
// Add new value
.with_flow_param::<i16>(&profile, FlowParamsKey::I16Param, Some(-5i16))
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
let profile_other_flow_dir = FlowDir::from((&profile_other_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
flow_dirs.insert(profile_other.clone(), profile_other_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
let profile_to_flow_params = fields.profile_to_flow_params();
let flow_params = profile_to_flow_params
.get(&profile)
.expect("Expected flow params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
Some(3u32),
profile_params.get(&ProfileParamsKey::U32Param).copied()
);
assert_eq!(
None::<u64>,
profile_params.get(&ProfileParamsKey::U64Param).copied()
);
assert_eq!(
Some(-4i64),
profile_params.get(&ProfileParamsKey::I64Param).copied()
);
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(
None::<u16>,
flow_params.get(&FlowParamsKey::U16Param).copied()
);
assert_eq!(
Some(-5i16),
flow_params.get(&FlowParamsKey::I16Param).copied()
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_filter() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_profile_filter_fn(|profile| **profile == "test_profile")
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone()], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_profile_filter(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.with_profile_filter_fn(|profile| **profile == "test_profile")
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
// Overwrite existing value
.with_flow_param::<bool>(&profile, FlowParamsKey::BoolParam, Some(true))
// Erase existing value
.with_flow_param::<u16>(&profile, FlowParamsKey::U16Param, None)
// Add new value
.with_flow_param::<i16>(&profile, FlowParamsKey::I16Param, Some(-5i16))
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
let profile_to_flow_params = fields.profile_to_flow_params();
let flow_params = profile_to_flow_params
.get(&profile)
.expect("Expected flow params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone()], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
Some(3u32),
profile_params.get(&ProfileParamsKey::U32Param).copied()
);
assert_eq!(
None::<u64>,
profile_params.get(&ProfileParamsKey::U64Param).copied()
);
assert_eq!(
Some(-4i64),
profile_params.get(&ProfileParamsKey::I64Param).copied()
);
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(
None::<u16>,
flow_params.get(&FlowParamsKey::U16Param).copied()
);
assert_eq!(
Some(-5i16),
flow_params.get(&FlowParamsKey::I16Param).copied()
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_profile_filter_with_flow_params_none_specified(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpsf_params"),
&[profile.clone(), profile_other.clone()],
Some(flow.flow_id()),
)
.await?;
let output = NoOpOutput;
let cmd_ctx_save = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.with_profile_filter_fn(|profile| **profile == "test_profile")
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some(String::from("ws_param_1_value")),
)
.with_workspace_param(WorkspaceParamsKey::U8Param, None::<u8>)
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
// Overwrite existing value
.with_flow_param::<bool>(&profile, FlowParamsKey::BoolParam, Some(true))
// Erase existing value
.with_flow_param::<u16>(&profile, FlowParamsKey::U16Param, None)
// Add new value
.with_flow_param::<i16>(&profile, FlowParamsKey::I16Param, Some(-5i16))
.await?;
drop(cmd_ctx_save);
let cmd_ctx = CmdCtxMpsf::<TestCctCmdCtxMpsf>::builder()
.with_output(NoOpOutput.into())
.with_workspace((&workspace).into())
.with_flow((&flow).into())
.with_profile_filter_fn(|profile| **profile == "test_profile")
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs, flow_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let mut flow_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
profile_dirs.insert(profile.clone(), profile_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
flow_dirs.insert(profile.clone(), profile_flow_dir);
(profile_dirs, profile_history_dirs, flow_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
let profile_to_flow_params = fields.profile_to_flow_params();
let flow_params = profile_to_flow_params
.get(&profile)
.expect("Expected flow params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone()], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dirs, fields.flow_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&String::from("ws_param_1_value")),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
None::<u8>,
workspace_params.get(&WorkspaceParamsKey::U8Param).copied()
);
assert_eq!(
Some(3u32),
profile_params.get(&ProfileParamsKey::U32Param).copied()
);
assert_eq!(
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | true |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_npnf_params.rs | workspace_tests/src/cmd_ctx/cmd_ctx_npnf_params.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxNpnf, CmdCtxTypes},
};
use crate::{no_op_output::NoOpOutput, test_support::workspace, PeaceTestError};
use super::WorkspaceParamsKey;
#[tokio::test]
async fn build() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_npnf_params")).await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxNpnf::<TestCctCmdCtxNpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.await?;
assert!(std::ptr::eq(&workspace, cmd_ctx.fields().workspace()));
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_npnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxNpnf::<TestCctCmdCtxNpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_none_specified() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_npnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx_save = CmdCtxNpnf::<TestCctCmdCtxNpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some(String::from("ws_param_1_value")),
)
.with_workspace_param(WorkspaceParamsKey::U8Param, None::<u8>)
.await?;
drop(cmd_ctx_save);
let cmd_ctx = CmdCtxNpnf::<TestCctCmdCtxNpnf>::builder()
.with_output(NoOpOutput.into())
.with_workspace((&workspace).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&String::from("ws_param_1_value")),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
None::<u8>,
workspace_params.get(&WorkspaceParamsKey::U8Param).copied()
);
Ok(())
}
#[derive(Debug)]
pub struct TestCctCmdCtxNpnf;
impl CmdCtxTypes for TestCctCmdCtxNpnf {
type AppError = PeaceTestError;
type FlowParamsKey = ();
type MappingFns = ();
type Output = NoOpOutput;
type ProfileParamsKey = ();
type WorkspaceParamsKey = WorkspaceParamsKey;
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_spnf.rs | workspace_tests/src/cmd_ctx/cmd_ctx_spnf.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpnf, ProfileSelection},
};
use crate::{
no_op_output::NoOpOutput, peace_cmd_ctx_types::TestCctNoOpOutput, test_support::workspace,
};
#[tokio::test]
async fn coverage_getters() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf")).await?;
let profile = profile!("test_profile");
let mut output = NoOpOutput;
let mut cmd_ctx = CmdCtxSpnf::<TestCctNoOpOutput>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.await?;
let _output = cmd_ctx.output();
let _output_mut = cmd_ctx.output_mut();
let _fields = cmd_ctx.fields();
let fields_mut = cmd_ctx.fields_mut();
let _ = fields_mut.interruptibility_state();
let _ = fields_mut.workspace();
let _ = fields_mut.workspace_dir();
let _ = fields_mut.peace_dir();
let _ = fields_mut.peace_app_dir();
let _ = fields_mut.profile();
let _ = fields_mut.profile_dir();
let _ = fields_mut.profile_history_dir();
let _ = fields_mut.workspace_params_type_reg();
let _ = fields_mut.workspace_params_type_reg_mut();
let _ = fields_mut.workspace_params();
let _ = fields_mut.workspace_params_mut();
let _ = fields_mut.profile_params_type_reg();
let _ = fields_mut.profile_params_type_reg_mut();
let _ = fields_mut.profile_params();
let _ = fields_mut.profile_params_mut();
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_mpnf_params.rs | workspace_tests/src/cmd_ctx/cmd_ctx_mpnf_params.rs | use std::collections::BTreeMap;
use peace::{
cfg::app_name,
cmd_ctx::{CmdCtxMpnf, CmdCtxTypes},
profile_model::{profile, Profile, ProfileInvalidFmt},
resource_rt::{
paths::{ProfileDir, ProfileHistoryDir},
type_reg::untagged::TypeReg,
},
rt_model::{Error as PeaceRtError, NativeError},
};
use crate::{no_op_output::NoOpOutput, test_support::workspace_with, PeaceTestError};
use super::{ProfileParamsKey, WorkspaceParamsKey};
#[tokio::test]
async fn build() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_profile_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, None)
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let profile_other_dir = ProfileDir::from((peace_app_dir, &profile_other));
let profile_other_history_dir = ProfileHistoryDir::from(&profile_other_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_dirs.insert(profile_other.clone(), profile_other_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
profile_history_dirs.insert(profile_other.clone(), profile_other_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone(), profile_other], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&3u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(
None::<&u64>,
profile_params.get(&ProfileParamsKey::U64Param)
);
assert_eq!(
Some(&-4i64),
profile_params.get(&ProfileParamsKey::I64Param)
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_filter() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_profile_filter_fn(|profile| **profile == "test_profile")
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone()], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_profile_filter(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_profile_filter_fn(|profile| **profile == "test_profile")
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone()], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&3u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(
None::<&u64>,
profile_params.get(&ProfileParamsKey::U64Param)
);
assert_eq!(
Some(&-4i64),
profile_params.get(&ProfileParamsKey::I64Param)
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_profile_filter_none_provided(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx_save = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_filter_fn(|profile| **profile == "test_profile")
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some(String::from("ws_param_1_value")),
)
.with_workspace_param(WorkspaceParamsKey::U8Param, None::<u8>)
// Overwrite existing value
.with_profile_param::<u32>(&profile, ProfileParamsKey::U32Param, Some(3u32))
// Erase existing value
.with_profile_param::<u64>(&profile, ProfileParamsKey::U64Param, None)
// Add new value
.with_profile_param::<i64>(&profile, ProfileParamsKey::I64Param, Some(-4i64))
.await?;
drop(cmd_ctx_save);
// No workspace / profile params provided.
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(NoOpOutput.into())
.with_workspace((&workspace).into())
.with_profile_filter_fn(|profile| **profile == "test_profile")
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let (profile_dirs, profile_history_dirs) = {
let mut profile_dirs = BTreeMap::new();
let mut profile_history_dirs = BTreeMap::new();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
profile_dirs.insert(profile.clone(), profile_dir);
profile_history_dirs.insert(profile.clone(), profile_history_dir);
(profile_dirs, profile_history_dirs)
};
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_to_profile_params = fields.profile_to_profile_params();
let profile_params = profile_to_profile_params
.get(&profile)
.expect("Expected profile params to exist.");
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&[profile.clone()], fields.profiles());
assert_eq!(&profile_dirs, fields.profile_dirs());
assert_eq!(&profile_history_dirs, fields.profile_history_dirs());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&String::from("ws_param_1_value")),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
None::<u8>,
workspace_params.get(&WorkspaceParamsKey::U8Param).copied()
);
assert_eq!(Some(&3u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(
None::<&u64>,
profile_params.get(&ProfileParamsKey::U64Param)
);
assert_eq!(
Some(&-4i64),
profile_params.get(&ProfileParamsKey::I64Param)
);
Ok(())
}
#[tokio::test]
async fn list_profile_dirs_invalid_profile_name() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
// sneaky usage of `new_unchecked`.
let profile_other = Profile::new_unchecked("test_profile_spécïál");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx_result = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.build()
.await;
let profile_other_dir = ProfileDir::from((workspace.dirs().peace_app_dir(), &profile_other));
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&cmd_ctx_result,
Err(PeaceTestError::PeaceRt(PeaceRtError::Native(
NativeError::ProfileDirInvalidName {
dir_name,
path,
error,
}
)))
if dir_name == "test_profile_spécïál"
&& path == &*profile_other_dir
&& error == &ProfileInvalidFmt::new("test_profile_spécïál".into())
),
"expected `cmd_ctx_result` to be \n\
`Err(PeaceTestError::PeaceRt(PeaceRtError::Native(NativeError::ProfileDirInvalidName {{ .. }})))`,\n\
but was {cmd_ctx_result:?}",
);
}
})();
Ok(())
}
#[tokio::test]
async fn getters() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let mut cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.await?;
assert!(matches!(cmd_ctx.output(), NoOpOutput));
assert!(matches!(cmd_ctx.output_mut(), NoOpOutput));
let fields = cmd_ctx.fields();
assert_eq!(workspace.dirs().workspace_dir(), fields.workspace_dir());
assert_eq!(workspace.dirs().peace_dir(), fields.peace_dir());
assert_eq!(workspace.dirs().peace_app_dir(), fields.peace_app_dir());
assert!(matches!(fields.workspace_params_type_reg(), TypeReg { .. }));
assert!(matches!(fields.profile_params_type_reg(), TypeReg { .. }));
Ok(())
}
#[tokio::test]
async fn debug() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let profile = profile!("test_profile");
let profile_other = profile!("test_profile_other");
let workspace = workspace_with(
&tempdir,
app_name!("test_cmd_ctx_mpnf_params"),
&[profile.clone(), profile_other.clone()],
None,
)
.await?;
let output = NoOpOutput;
let cmd_ctx = CmdCtxMpnf::<TestCctCmdCtxMpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.await?;
assert!(format!("{cmd_ctx:?}").contains("CmdCtxMpnf {"));
let fields = cmd_ctx.fields();
assert!(format!("{fields:?}").contains("CmdCtxMpnfFields {"));
Ok(())
}
#[derive(Debug)]
pub struct TestCctCmdCtxMpnf;
impl CmdCtxTypes for TestCctCmdCtxMpnf {
type AppError = PeaceTestError;
type FlowParamsKey = ();
type MappingFns = ();
type Output = NoOpOutput;
type ProfileParamsKey = ProfileParamsKey;
type WorkspaceParamsKey = WorkspaceParamsKey;
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_spnf_params.rs | workspace_tests/src/cmd_ctx/cmd_ctx_spnf_params.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpnf, CmdCtxTypes, ProfileSelection},
resource_rt::paths::{ProfileDir, ProfileHistoryDir},
};
use crate::{no_op_output::NoOpOutput, test_support::workspace, PeaceTestError};
use super::{ProfileParamsKey, WorkspaceParamsKey};
#[tokio::test]
async fn build() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.build()
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.build()
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_profile_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.build()
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
let profile_params = fields.profile_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.build()
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_from_params(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.build()
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_profile_from_params(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let output = NoOpOutput;
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output(output.into())
.with_workspace((&workspace).into())
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.build()
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_none_provided(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spnf_params")).await?;
let profile = profile!("test_profile");
let mut output = NoOpOutput;
let cmd_ctx_save = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some(String::from("ws_param_1_value")),
)
.with_workspace_param(WorkspaceParamsKey::U8Param, None::<u8>)
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.await?;
drop(cmd_ctx_save);
let cmd_ctx = CmdCtxSpnf::<TestCctCmdCtxSpnf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&String::from("ws_param_1_value")),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
None::<u8>,
workspace_params.get(&WorkspaceParamsKey::U8Param).copied()
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
Ok(())
}
#[derive(Debug)]
pub struct TestCctCmdCtxSpnf;
impl CmdCtxTypes for TestCctCmdCtxSpnf {
type AppError = PeaceTestError;
type FlowParamsKey = ();
type MappingFns = ();
type Output = NoOpOutput;
type ProfileParamsKey = ProfileParamsKey;
type WorkspaceParamsKey = WorkspaceParamsKey;
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_npnf.rs | workspace_tests/src/cmd_ctx/cmd_ctx_npnf.rs | use peace::{cfg::app_name, cmd_ctx::CmdCtxNpnf};
use crate::{
no_op_output::NoOpOutput, peace_cmd_ctx_types::TestCctNoOpOutput, test_support::workspace,
};
#[tokio::test]
async fn coverage_getters() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_npnf")).await?;
let mut output = NoOpOutput;
let mut cmd_ctx = CmdCtxNpnf::<TestCctNoOpOutput>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.await?;
let _output = cmd_ctx.output();
let _output_mut = cmd_ctx.output_mut();
let _fields = cmd_ctx.fields();
let fields_mut = cmd_ctx.fields_mut();
let _ = fields_mut.interruptibility_state();
let _ = fields_mut.workspace();
let _ = fields_mut.workspace_dir();
let _ = fields_mut.peace_dir();
let _ = fields_mut.peace_app_dir();
let _ = fields_mut.workspace_params_type_reg();
let _ = fields_mut.workspace_params_type_reg_mut();
let _ = fields_mut.workspace_params();
let _ = fields_mut.workspace_params_mut();
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_mpnf.rs | workspace_tests/src/cmd_ctx/cmd_ctx_mpnf.rs | use peace::{cfg::app_name, cmd_ctx::CmdCtxMpnf};
use crate::{
no_op_output::NoOpOutput, peace_cmd_ctx_types::TestCctNoOpOutput, test_support::workspace,
};
#[tokio::test]
async fn coverage_getters() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_mpnf")).await?;
let mut output = NoOpOutput;
let mut cmd_ctx = CmdCtxMpnf::<TestCctNoOpOutput>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_filter_fn(|profile_candidate| profile_candidate.as_str() == "test_profile")
.await?;
let _output = cmd_ctx.output();
let _output_mut = cmd_ctx.output_mut();
let _fields = cmd_ctx.fields();
let fields_mut = cmd_ctx.fields_mut();
let _ = fields_mut.interruptibility_state();
let _ = fields_mut.workspace();
let _ = fields_mut.workspace_dir();
let _ = fields_mut.peace_dir();
let _ = fields_mut.peace_app_dir();
let _ = fields_mut.profiles();
let _ = fields_mut.profile_dirs();
let _ = fields_mut.profile_history_dirs();
let _ = fields_mut.workspace_params_type_reg();
let _ = fields_mut.workspace_params_type_reg_mut();
let _ = fields_mut.workspace_params();
let _ = fields_mut.workspace_params_mut();
let _ = fields_mut.profile_params_type_reg();
let _ = fields_mut.profile_params_type_reg_mut();
let _ = fields_mut.profile_to_profile_params();
let _ = fields_mut.profile_to_profile_params_mut();
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_spsf_params.rs | workspace_tests/src/cmd_ctx/cmd_ctx_spsf_params.rs | use peace::{
cfg::{app_name, Item},
cmd_ctx::{CmdCtxSpsf, CmdCtxTypes, ProfileSelection},
enum_iterator::Sequence,
flow_model::flow_id,
flow_rt::{Flow, ItemGraphBuilder},
item_model::item_id,
params::{
FromFunc, MappingFn, MappingFnId, MappingFnImpl, MappingFnReg, MappingFns, Params,
ParamsSpec, ValueResolutionCtx, ValueResolutionMode, ValueSpec,
},
profile_model::{profile, Profile},
resource_rt::{
internal::WorkspaceParamsFile,
paths::{FlowDir, ProfileDir, ProfileHistoryDir},
type_reg::untagged::BoxDataTypeDowncast,
},
};
use serde::{Deserialize, Serialize};
use crate::{
no_op_output::NoOpOutput,
test_support::{assert_flow_params, assert_profile_params, assert_workspace_params, workspace},
vec_copy_item::{VecA, VecAFieldWise, VecCopyItem},
PeaceTestError,
};
use super::{FlowParamsKey, ProfileParamsKey, WorkspaceParamsKey};
#[tokio::test]
async fn build() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
let resources = fields.resources();
let res_profile = &*resources.borrow::<Profile>();
assert_eq!(&profile, res_profile);
assert_workspace_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_profile_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
let resources = fields.resources();
assert_profile_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_flow_params() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_flow_param(FlowParamsKey::BoolParam, Some(true))
.with_flow_param(FlowParamsKey::U16Param, Some(456u16))
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let flow_params = fields.flow_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(Some(&456u16), flow_params.get(&FlowParamsKey::U16Param));
let resources = fields.resources();
assert_flow_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params() -> Result<(), Box<dyn std::error::Error>>
{
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
let resources = fields.resources();
let res_profile = &*resources.borrow::<Profile>();
assert_eq!(&profile, res_profile);
assert_workspace_params(resources).await?;
assert_profile_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_flow_params(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_flow_param(FlowParamsKey::BoolParam, Some(true))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_flow_param(FlowParamsKey::U16Param, Some(456u16))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
let flow_params = fields.flow_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(Some(&456u16), flow_params.get(&FlowParamsKey::U16Param));
let resources = fields.resources();
let res_profile = &*resources.borrow::<Profile>();
assert_eq!(&profile, res_profile);
assert_workspace_params(resources).await?;
assert_profile_params(resources).await?;
assert_flow_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_flow_params_none_provided(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx_save = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_workspace_param(WorkspaceParamsKey::U8Param, None::<u8>)
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_flow_param(FlowParamsKey::BoolParam, Some(true))
.with_flow_param(FlowParamsKey::U16Param, Some(456u16))
.await?;
drop(cmd_ctx_save);
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
let flow_params = fields.flow_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&String::from("ws_param_1_value")),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(
None::<u8>,
workspace_params.get(&WorkspaceParamsKey::U8Param).copied()
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(Some(&456u16), flow_params.get(&FlowParamsKey::U16Param));
let resources = fields.resources();
let res_profile = &*resources.borrow::<Profile>();
assert_eq!(&profile, res_profile);
assert_workspace_params(resources).await?;
assert_profile_params(resources).await?;
assert_flow_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_from_params(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
let resources = fields.resources();
let res_profile = &*resources.borrow::<Profile>();
assert_eq!(&profile, res_profile);
assert_workspace_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_workspace_params_with_profile_params_with_profile_from_params(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_param(ProfileParamsKey::U32Param, Some(1u32))
.with_workspace_param(WorkspaceParamsKey::Profile, Some(profile.clone()))
.with_profile_param(ProfileParamsKey::U64Param, Some(2u64))
.with_workspace_param(
WorkspaceParamsKey::StringParam,
Some("ws_param_1_value".to_string()),
)
.with_flow_param(FlowParamsKey::BoolParam, Some(true))
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.with_flow_param(FlowParamsKey::U16Param, Some(456u16))
.with_flow((&flow).into())
.await?;
let peace_app_dir = workspace.dirs().peace_app_dir();
let profile_dir = ProfileDir::from((peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let flow_dir = FlowDir::from((&profile_dir, flow.flow_id()));
let fields = cmd_ctx.fields();
let workspace_params = fields.workspace_params();
let profile_params = fields.profile_params();
let flow_params = fields.flow_params();
assert!(std::ptr::eq(&workspace, fields.workspace()));
assert_eq!(peace_app_dir, fields.workspace().dirs().peace_app_dir());
assert_eq!(&profile, fields.profile());
assert_eq!(&profile_dir, fields.profile_dir());
assert_eq!(&profile_history_dir, fields.profile_history_dir());
assert_eq!(flow.flow_id(), fields.flow().flow_id());
assert_eq!(&flow_dir, fields.flow_dir());
assert_eq!(
Some(&profile),
workspace_params.get(&WorkspaceParamsKey::Profile)
);
assert_eq!(
Some(&"ws_param_1_value".to_string()),
workspace_params.get(&WorkspaceParamsKey::StringParam)
);
assert_eq!(Some(&1u32), profile_params.get(&ProfileParamsKey::U32Param));
assert_eq!(Some(&2u64), profile_params.get(&ProfileParamsKey::U64Param));
assert_eq!(
Some(true),
flow_params.get(&FlowParamsKey::BoolParam).copied()
);
assert_eq!(Some(&456u16), flow_params.get(&FlowParamsKey::U16Param));
let resources = fields.resources();
let res_profile = &*resources.borrow::<Profile>();
assert_eq!(&profile, res_profile);
assert_workspace_params(resources).await?;
assert_profile_params(resources).await?;
assert_flow_params(resources).await?;
Ok(())
}
#[tokio::test]
async fn build_with_with_profile_from_params_returns_error_when_profile_not_found(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let flow_id = flow_id!("test_flow_id");
let flow = Flow::<PeaceTestError>::new(flow_id, ItemGraphBuilder::new().build());
let mut output = NoOpOutput;
let error = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
// Deliberately not setting workspace param.
// .with_workspace_param(WorkspaceParamsKey::Profile, Some(profile!("test_profile")))
.with_profile_selection(ProfileSelection::FromWorkspaceParam(
WorkspaceParamsKey::Profile.into(),
))
.with_flow((&flow).into())
.await
.unwrap_err();
let workspace_params_file_expected =
WorkspaceParamsFile::from(workspace.dirs().peace_app_dir());
if let PeaceTestError::PeaceRt(peace::rt_model::Error::WorkspaceParamsProfileNone {
profile_key,
workspace_params_file,
workspace_params_file_contents,
}) = &error
{
assert_eq!(profile_key, "profile");
assert_eq!(workspace_params_file, &workspace_params_file_expected);
assert_eq!(workspace_params_file_contents, "");
} else {
panic!(
"Expected error to be \
`PeaceTestError::PeaceRt(Error::WorkspaceParamsProfileNone {{ .. }})`, \
but it was: {error:?}"
);
}
Ok(())
}
#[tokio::test]
async fn build_with_item_params_returns_ok_when_params_provided(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let flow = Flow::<PeaceTestError>::new(flow_id, item_graph);
let mapping_fn_reg = MappingFnReg::new();
let mut output = NoOpOutput;
let cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(VecCopyItem::ID_DEFAULT.clone(), VecA(vec![1u8]).into())
.await?;
let fields = cmd_ctx.fields();
let params_specs = fields.params_specs();
let resources = fields.resources();
let vec_a_spec = params_specs
.get::<ParamsSpec<<VecCopyItem as Item>::Params<'_>>, _>(VecCopyItem::ID_DEFAULT);
let mut value_resolution_ctx = ValueResolutionCtx::new(
ValueResolutionMode::Current,
VecCopyItem::ID_DEFAULT.clone(),
tynm::type_name::<VecA>(),
);
assert!(matches!(vec_a_spec,
Some(ParamsSpec::Value { value: VecA(value) })
if value == &[1u8]
));
assert_eq!(
Some(VecA(vec![1u8])),
vec_a_spec.and_then(|vec_a_spec| vec_a_spec
.resolve(&mapping_fn_reg, resources, &mut value_resolution_ctx)
.ok()),
);
Ok(())
}
#[tokio::test]
async fn build_with_item_params_returns_err_when_params_not_provided_and_not_stored(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let flow = Flow::<PeaceTestError>::new(flow_id, item_graph);
let mut output = NoOpOutput;
let cmd_ctx_result = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.build()
.await;
({
#[cfg_attr(coverage_nightly, coverage(off))]
|| {
assert!(
matches!(
&cmd_ctx_result,
Err(PeaceTestError::PeaceRt(
peace::rt_model::Error::ParamsSpecsMismatch {
item_ids_with_no_params_specs,
params_specs_provided_mismatches,
params_specs_stored_mismatches,
params_specs_not_usable,
}
))
if item_ids_with_no_params_specs == &vec![VecCopyItem::ID_DEFAULT.clone()]
&& params_specs_provided_mismatches.is_empty()
&& params_specs_stored_mismatches.is_none()
&& params_specs_not_usable.is_empty(),
),
"was {cmd_ctx_result:#?}"
);
}
})();
Ok(())
}
#[tokio::test]
async fn build_with_item_params_returns_ok_when_params_not_provided_but_are_stored(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let flow = Flow::<PeaceTestError>::new(flow_id, item_graph);
let mapping_fn_reg = MappingFnReg::new();
let mut output = NoOpOutput;
let _cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(VecCopyItem::ID_DEFAULT.clone(), VecA(vec![1u8]).into())
.await?;
let cmd_ctx_from_stored = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.await?;
let fields = cmd_ctx_from_stored.fields();
let params_specs = fields.params_specs();
let resources = fields.resources();
let vec_a_spec = params_specs
.get::<ParamsSpec<<VecCopyItem as Item>::Params<'_>>, _>(VecCopyItem::ID_DEFAULT);
let mut value_resolution_ctx = ValueResolutionCtx::new(
ValueResolutionMode::Current,
VecCopyItem::ID_DEFAULT.clone(),
tynm::type_name::<VecA>(),
);
assert!(matches!(vec_a_spec,
Some(ParamsSpec::Value { value: VecA(value) })
if value == &[1u8]
));
assert_eq!(
Some(VecA(vec![1u8])),
vec_a_spec.and_then(|vec_a_spec| vec_a_spec
.resolve(&mapping_fn_reg, resources, &mut value_resolution_ctx)
.ok()),
);
Ok(())
}
#[tokio::test]
async fn build_with_item_params_returns_ok_and_uses_params_provided_when_params_provided_and_stored(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let flow = Flow::<PeaceTestError>::new(flow_id, item_graph);
let mapping_fn_reg = MappingFnReg::new();
let mut output = NoOpOutput;
let _cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(VecCopyItem::ID_DEFAULT.clone(), VecA(vec![1u8]).into())
.await?;
let cmd_ctx_from_stored = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.with_item_params::<VecCopyItem>(VecCopyItem::ID_DEFAULT.clone(), VecA(vec![2u8]).into())
.await?;
let fields = cmd_ctx_from_stored.fields();
let params_specs = fields.params_specs();
let resources = fields.resources();
let vec_a_spec = params_specs
.get::<ParamsSpec<<VecCopyItem as Item>::Params<'_>>, _>(VecCopyItem::ID_DEFAULT);
let mut value_resolution_ctx = ValueResolutionCtx::new(
ValueResolutionMode::Current,
VecCopyItem::ID_DEFAULT.clone(),
tynm::type_name::<VecA>(),
);
assert!(matches!(vec_a_spec,
Some(ParamsSpec::Value { value: VecA(value) })
if value == &[2u8]
));
assert_eq!(
Some(VecA(vec![2u8])),
vec_a_spec.and_then(|vec_a_spec| vec_a_spec
.resolve(&mapping_fn_reg, resources, &mut value_resolution_ctx)
.ok()),
);
Ok(())
}
#[tokio::test]
async fn build_with_item_params_returns_err_when_params_provided_mismatch(
) -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf_params")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let item_graph = {
let mut item_graph_builder = ItemGraphBuilder::new();
item_graph_builder.add_fn(VecCopyItem::default().into());
item_graph_builder.build()
};
let flow = Flow::<PeaceTestError>::new(flow_id, item_graph);
let mut output = NoOpOutput;
let _cmd_ctx = CmdCtxSpsf::<TestCctCmdCtxSpsf>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | true |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_mpsf.rs | workspace_tests/src/cmd_ctx/cmd_ctx_mpsf.rs | use peace::{
cfg::app_name,
cmd_ctx::CmdCtxMpsf,
flow_model::flow_id,
flow_rt::{Flow, ItemGraphBuilder},
};
use crate::{
no_op_output::NoOpOutput, peace_cmd_ctx_types::TestCctNoOpOutput, test_support::workspace,
PeaceTestError,
};
#[tokio::test]
async fn coverage_getters() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_mpsf")).await?;
let flow_id = flow_id!("test_flow_id");
let item_graph = ItemGraphBuilder::new().build();
let flow = Flow::<PeaceTestError>::new(flow_id.clone(), item_graph);
let mut output = NoOpOutput;
let mut cmd_ctx = CmdCtxMpsf::<TestCctNoOpOutput>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_filter_fn(|profile_candidate| profile_candidate.as_str() == "test_profile")
.with_flow((&flow).into())
.await?;
let _output = cmd_ctx.output();
let _output_mut = cmd_ctx.output_mut();
let _fields = cmd_ctx.fields();
let fields_mut = cmd_ctx.fields_mut();
let _ = fields_mut.interruptibility_state();
let _ = fields_mut.workspace();
let _ = fields_mut.workspace_dir();
let _ = fields_mut.peace_dir();
let _ = fields_mut.peace_app_dir();
let _ = fields_mut.profiles();
let _ = fields_mut.profile_dirs();
let _ = fields_mut.profile_history_dirs();
let _ = fields_mut.flow();
let _ = fields_mut.flow_dirs();
let _ = fields_mut.workspace_params_type_reg();
let _ = fields_mut.workspace_params_type_reg_mut();
let _ = fields_mut.workspace_params();
let _ = fields_mut.workspace_params_mut();
let _ = fields_mut.profile_params_type_reg();
let _ = fields_mut.profile_params_type_reg_mut();
let _ = fields_mut.profile_to_profile_params();
let _ = fields_mut.profile_to_profile_params_mut();
let _ = fields_mut.flow_params_type_reg();
let _ = fields_mut.flow_params_type_reg_mut();
let _ = fields_mut.profile_to_flow_params();
let _ = fields_mut.profile_to_flow_params_mut();
let _ = fields_mut.profile_to_states_current_stored();
let _ = fields_mut.params_specs_type_reg();
let _ = fields_mut.profile_to_params_specs();
let _ = fields_mut.states_type_reg();
let _ = fields_mut.resources();
let _ = fields_mut.resources_mut();
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/cmd_ctx/cmd_ctx_spsf.rs | workspace_tests/src/cmd_ctx/cmd_ctx_spsf.rs | use peace::{
cfg::{app_name, profile},
cmd_ctx::{CmdCtxSpsf, ProfileSelection},
flow_model::flow_id,
flow_rt::{Flow, ItemGraphBuilder},
};
use crate::{
no_op_output::NoOpOutput, peace_cmd_ctx_types::TestCctNoOpOutput, test_support::workspace,
PeaceTestError,
};
#[tokio::test]
async fn coverage_getters() -> Result<(), Box<dyn std::error::Error>> {
let tempdir = tempfile::tempdir()?;
let workspace = workspace(&tempdir, app_name!("test_cmd_ctx_spsf")).await?;
let profile = profile!("test_profile");
let flow_id = flow_id!("test_flow_id");
let item_graph = ItemGraphBuilder::new().build();
let flow = Flow::<PeaceTestError>::new(flow_id.clone(), item_graph);
let mut output = NoOpOutput;
let mut cmd_ctx = CmdCtxSpsf::<TestCctNoOpOutput>::builder()
.with_output((&mut output).into())
.with_workspace((&workspace).into())
.with_profile_selection(ProfileSelection::Specified(profile.clone()))
.with_flow((&flow).into())
.await?;
let _output = cmd_ctx.output();
let _output_mut = cmd_ctx.output_mut();
#[cfg(feature = "output_progress")]
{
let _cmd_progress_tracker = cmd_ctx.cmd_progress_tracker();
let _cmd_progress_tracker_mut = cmd_ctx.cmd_progress_tracker_mut();
}
let _fields = cmd_ctx.fields();
let fields_mut = cmd_ctx.fields_mut();
let _ = fields_mut.interruptibility_state();
let _ = fields_mut.workspace();
let _ = fields_mut.workspace_dir();
let _ = fields_mut.peace_dir();
let _ = fields_mut.peace_app_dir();
let _ = fields_mut.profile();
let _ = fields_mut.profile_dir();
let _ = fields_mut.profile_history_dir();
let _ = fields_mut.flow();
let _ = fields_mut.flow_dir();
let _ = fields_mut.workspace_params_type_reg();
let _ = fields_mut.workspace_params_type_reg_mut();
let _ = fields_mut.workspace_params();
let _ = fields_mut.workspace_params_mut();
let _ = fields_mut.profile_params_type_reg();
let _ = fields_mut.profile_params_type_reg_mut();
let _ = fields_mut.profile_params();
let _ = fields_mut.profile_params_mut();
let _ = fields_mut.flow_params_type_reg();
let _ = fields_mut.flow_params_type_reg_mut();
let _ = fields_mut.flow_params();
let _ = fields_mut.flow_params_mut();
let _ = fields_mut.params_specs_type_reg();
let _ = fields_mut.params_specs();
let _ = fields_mut.states_type_reg();
let _ = fields_mut.resources();
let _ = fields_mut.resources_mut();
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal.rs | workspace_tests/src/resource_rt/internal.rs | mod flow_params_file;
mod profile_params_file;
mod state_diffs_mut;
mod states_mut;
mod workspace_dirs;
mod workspace_params_file;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/resources.rs | workspace_tests/src/resource_rt/resources.rs | use std::any::{Any, TypeId};
use peace::resource_rt::{
resources::ts::{Empty, SetUp},
states::{StatesCurrent, StatesGoal},
Resources,
};
mod ts;
#[test]
fn debug() {
let mut resources = Resources::new();
resources.insert(1u32);
assert_eq!(
r#"Resources { inner: {u32: 1}, marker: PhantomData<peace_resource_rt::resources::ts::Empty> }"#,
format!("{resources:?}")
);
}
#[test]
fn defaults_to_resources_empty() {
let resources_default = Resources::default();
assert_eq!(
TypeId::of::<Resources::<Empty>>(),
resources_default.type_id()
);
}
#[test]
fn resources_set_up_from_resources_empty() {
let resources_empty = Resources::new();
let resources_set_up = Resources::<SetUp>::from(resources_empty);
// no default resources
assert!(!resources_set_up.contains::<StatesCurrent>());
assert!(!resources_set_up.contains::<StatesGoal>());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir.rs | workspace_tests/src/resource_rt/dir.rs | mod peace_dir;
mod profile_dir;
mod profile_history_dir;
mod states_current_file;
mod states_goal_file;
mod workspace_dir;
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states.rs | workspace_tests/src/resource_rt/states.rs | use peace::{
item_model::item_id,
resource_rt::{internal::StatesMut, states::StatesCurrent, type_reg::untagged::TypeMap},
};
mod states_cleaned;
mod states_cleaned_dry;
mod states_current;
mod states_current_stored;
mod states_ensured;
mod states_ensured_dry;
mod states_goal;
mod states_goal_stored;
mod states_previous;
mod ts;
#[test]
fn with_capacity_reserves_enough_capacity() {
let states = StatesCurrent::with_capacity(100);
assert!(states.capacity() >= 100);
}
#[test]
fn into_inner() {
let states = test_states();
let type_map = states.into_inner();
assert_eq!(1, type_map.len())
}
#[test]
fn deref() {
let states = StatesCurrent::new();
// deref
assert_eq!(0, states.len())
}
#[test]
fn from_type_map() {
let _states = StatesCurrent::from(TypeMap::new_typed());
}
#[test]
fn from_states_mut() {
let _states = StatesCurrent::from(StatesMut::new());
}
#[test]
fn clone() {
let states = Clone::clone(&test_states());
assert_eq!(Some(123), states.get::<i32, _>(&item_id!("key")).copied());
}
#[test]
fn debug() {
let states = test_states();
assert_eq!(
r#"States({ItemId("key"): TypedValue { type: "i32", value: 123 }}, PhantomData<peace_resource_rt::states::ts::Current>)"#,
format!("{states:?}")
);
}
fn test_states() -> StatesCurrent {
let mut states = StatesMut::new();
states.insert(item_id!("key"), 123i32);
StatesCurrent::from(states)
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/state_diffs.rs | workspace_tests/src/resource_rt/state_diffs.rs | use peace::{
item_model::item_id,
resource_rt::{internal::StateDiffsMut, states::StateDiffs, type_reg::untagged::TypeMap},
};
#[test]
fn with_capacity_reserves_enough_capacity() {
let state_diffs = StateDiffs::with_capacity(100);
assert!(state_diffs.capacity() >= 100);
}
#[test]
fn into_inner() {
let state_diffs = test_state_diffs();
let type_map = state_diffs.into_inner();
assert_eq!(1, type_map.len())
}
#[test]
fn deref() {
let state_diffs = StateDiffs::new();
// deref
assert_eq!(0, state_diffs.len())
}
#[test]
fn from_type_map() {
let _state_diffs = StateDiffs::from(TypeMap::new_typed());
}
#[test]
fn from_state_diffs_mut() {
let _state_diffs = StateDiffs::from(StateDiffsMut::new());
}
#[test]
fn debug() {
let state_diffs = test_state_diffs();
assert_eq!(
r#"StateDiffs({ItemId("key"): TypedValue { type: "i32", value: 123 }})"#,
format!("{state_diffs:?}")
);
}
fn test_state_diffs() -> StateDiffs {
let mut state_diffs = StateDiffsMut::new();
state_diffs.insert(item_id!("key"), 123);
StateDiffs::from(state_diffs)
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal/profile_params_file.rs | workspace_tests/src/resource_rt/internal/profile_params_file.rs | use std::{
ffi::OsStr,
path::{Path, PathBuf},
};
use peace::{
cfg::{app_name, profile},
resource_rt::{
internal::ProfileParamsFile,
paths::{PeaceAppDir, PeaceDir, ProfileDir},
},
};
#[test]
pub fn debug() {
let profile_params_file =
ProfileParamsFile::from(Path::new("profile_params.yaml").to_path_buf());
assert_eq!(
r#"ProfileParamsFile("profile_params.yaml")"#,
format!("{profile_params_file:?}")
);
}
#[test]
pub fn display() {
let profile_params_file =
ProfileParamsFile::from(Path::new("profile_params.yaml").to_path_buf());
assert_eq!(
format!(
"{profile_params_path}",
profile_params_path = AsRef::<Path>::as_ref(&profile_params_file).display()
),
format!("{profile_params_file}")
);
}
#[test]
pub fn partial_eq() {
let profile_params_file_0 =
ProfileParamsFile::from(Path::new("profile_params.yaml").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let profile_params_file_1 = profile_params_file_0.clone();
assert_eq!(profile_params_file_0, profile_params_file_1);
}
#[test]
pub fn from_path_buf() {
let profile_params_file =
ProfileParamsFile::from(Path::new("profile_params.yaml").to_path_buf());
assert_eq!(Path::new("profile_params.yaml"), &*profile_params_file);
}
#[test]
pub fn from_profile_dir_relative() {
let app_name = app_name!();
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let profile = profile!("test_profile");
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name));
let profile_dir = ProfileDir::from((&peace_app_dir, &profile));
let profile_params_file = ProfileParamsFile::from(&profile_dir);
let path = PathBuf::from_iter([".", &**app_name!(), "test_profile", "profile_params.yaml"]);
assert_eq!(path, &*profile_params_file);
}
#[test]
pub fn into_inner_returns_path_buf() {
let profile_params_file =
ProfileParamsFile::new(Path::new("profile_params.yaml").to_path_buf());
assert_eq!(
Path::new("profile_params.yaml").to_path_buf(),
profile_params_file.into_inner()
);
}
#[test]
pub fn as_ref_os_str() {
let profile_params_file =
ProfileParamsFile::new(Path::new("profile_params.yaml").to_path_buf());
assert_eq!(
OsStr::new("profile_params.yaml"),
<ProfileParamsFile as AsRef<OsStr>>::as_ref(&profile_params_file)
);
}
#[test]
pub fn as_ref_path() {
let profile_params_file =
ProfileParamsFile::new(Path::new("profile_params.yaml").to_path_buf());
assert_eq!(
Path::new("profile_params.yaml"),
<ProfileParamsFile as AsRef<Path>>::as_ref(&profile_params_file)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal/workspace_params_file.rs | workspace_tests/src/resource_rt/internal/workspace_params_file.rs | use std::{
ffi::OsStr,
path::{Path, PathBuf},
};
use peace::{
cfg::app_name,
resource_rt::{
internal::WorkspaceParamsFile,
paths::{PeaceAppDir, PeaceDir},
},
};
#[test]
pub fn debug() {
let workspace_params_file =
WorkspaceParamsFile::from(Path::new("workspace_params.yaml").to_path_buf());
assert_eq!(
r#"WorkspaceParamsFile("workspace_params.yaml")"#,
format!("{workspace_params_file:?}")
);
}
#[test]
pub fn display() {
let workspace_params_file =
WorkspaceParamsFile::from(Path::new("workspace_params.yaml").to_path_buf());
assert_eq!(
format!(
"{workspace_params_path}",
workspace_params_path = AsRef::<Path>::as_ref(&workspace_params_file).display()
),
format!("{workspace_params_file}")
);
}
#[test]
pub fn partial_eq() {
let workspace_params_file_0 =
WorkspaceParamsFile::from(Path::new("workspace_params.yaml").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let workspace_params_file_1 = workspace_params_file_0.clone();
assert_eq!(workspace_params_file_0, workspace_params_file_1);
}
#[test]
pub fn from_path_buf() {
let workspace_params_file =
WorkspaceParamsFile::from(Path::new("workspace_params.yaml").to_path_buf());
assert_eq!(Path::new("workspace_params.yaml"), &*workspace_params_file);
}
#[test]
pub fn from_peace_app_dir_relative() {
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name!()));
let workspace_params_file = WorkspaceParamsFile::from(&peace_app_dir);
let path = PathBuf::from_iter([".", &**app_name!(), "workspace_params.yaml"]);
assert_eq!(path, &*workspace_params_file);
}
#[test]
pub fn into_inner_returns_path_buf() {
let workspace_params_file =
WorkspaceParamsFile::new(Path::new("workspace_params.yaml").to_path_buf());
assert_eq!(
Path::new("workspace_params.yaml").to_path_buf(),
workspace_params_file.into_inner()
);
}
#[test]
pub fn as_ref_os_str() {
let workspace_params_file =
WorkspaceParamsFile::new(Path::new("workspace_params.yaml").to_path_buf());
assert_eq!(
OsStr::new("workspace_params.yaml"),
<WorkspaceParamsFile as AsRef<OsStr>>::as_ref(&workspace_params_file)
);
}
#[test]
pub fn as_ref_path() {
let workspace_params_file =
WorkspaceParamsFile::new(Path::new("workspace_params.yaml").to_path_buf());
assert_eq!(
Path::new("workspace_params.yaml"),
<WorkspaceParamsFile as AsRef<Path>>::as_ref(&workspace_params_file)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal/states_mut.rs | workspace_tests/src/resource_rt/internal/states_mut.rs | use peace::{
item_model::item_id,
resource_rt::{internal::StatesMut, states::ts::Current, type_reg::untagged::TypeMap},
};
#[test]
fn with_capacity_reserves_enough_capacity() {
let states = StatesMut::<Current>::with_capacity(100);
assert!(states.capacity() >= 100);
}
#[test]
fn into_inner() {
let states = test_states();
let type_map = states.into_inner();
assert_eq!(1, type_map.len())
}
#[test]
fn deref_and_deref_mut() {
let mut states = StatesMut::<Current>::new();
// deref_mut
states.insert(item_id!("key"), 123);
// deref
assert_eq!(1, states.len())
}
#[test]
fn from_type_map() {
let _states = StatesMut::<Current>::from(TypeMap::new_typed());
}
#[test]
fn debug() {
let states = test_states();
let debug_str = format!("{states:?}");
assert!(
debug_str
== r#"StatesMut({ItemId("key"): TypedValue { type: "i32", value: 123 }}, PhantomData<peace_resource_rt::states::ts::Current>)"#
|| debug_str
== r#"StatesMut({ItemId("key"): TypedValue { type: "i32", value: 123 }}, PhantomData)"#
);
}
fn test_states() -> StatesMut<Current> {
let mut states = StatesMut::<Current>::new();
states.insert(item_id!("key"), 123);
states
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal/flow_params_file.rs | workspace_tests/src/resource_rt/internal/flow_params_file.rs | use std::{
ffi::OsStr,
path::{Path, PathBuf},
};
use peace::{
cfg::{app_name, profile},
flow_model::flow_id,
resource_rt::{
internal::FlowParamsFile,
paths::{FlowDir, PeaceAppDir, PeaceDir, ProfileDir},
},
};
#[test]
pub fn debug() {
let flow_params_file = FlowParamsFile::from(Path::new("flow_params.yaml").to_path_buf());
assert_eq!(
r#"FlowParamsFile("flow_params.yaml")"#,
format!("{flow_params_file:?}")
);
}
#[test]
pub fn display() {
let flow_params_file = FlowParamsFile::from(Path::new("flow_params.yaml").to_path_buf());
assert_eq!(
format!(
"{flow_params_path}",
flow_params_path = AsRef::<Path>::as_ref(&flow_params_file).display()
),
format!("{flow_params_file}")
);
}
#[test]
pub fn partial_eq() {
let flow_params_file_0 = FlowParamsFile::from(Path::new("flow_params.yaml").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let flow_params_file_1 = flow_params_file_0.clone();
assert_eq!(flow_params_file_0, flow_params_file_1);
}
#[test]
pub fn from_path_buf() {
let flow_params_file = FlowParamsFile::from(Path::new("flow_params.yaml").to_path_buf());
assert_eq!(Path::new("flow_params.yaml"), &*flow_params_file);
}
#[test]
pub fn from_flow_dir_relative() {
let app_name = app_name!();
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let profile = profile!("test_profile");
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name));
let profile_dir = ProfileDir::from((&peace_app_dir, &profile));
let flow_dir = FlowDir::from((&profile_dir, &flow_id!("test_flow")));
let flow_params_file = FlowParamsFile::from(&flow_dir);
let path = PathBuf::from_iter([
".",
&**app_name!(),
"test_profile",
"test_flow",
"flow_params.yaml",
]);
assert_eq!(path, &*flow_params_file);
}
#[test]
pub fn into_inner_returns_path_buf() {
let flow_params_file = FlowParamsFile::new(Path::new("flow_params.yaml").to_path_buf());
assert_eq!(
Path::new("flow_params.yaml").to_path_buf(),
flow_params_file.into_inner()
);
}
#[test]
pub fn as_ref_os_str() {
let flow_params_file = FlowParamsFile::new(Path::new("flow_params.yaml").to_path_buf());
assert_eq!(
OsStr::new("flow_params.yaml"),
<FlowParamsFile as AsRef<OsStr>>::as_ref(&flow_params_file)
);
}
#[test]
pub fn as_ref_path() {
let flow_params_file = FlowParamsFile::new(Path::new("flow_params.yaml").to_path_buf());
assert_eq!(
Path::new("flow_params.yaml"),
<FlowParamsFile as AsRef<Path>>::as_ref(&flow_params_file)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal/workspace_dirs.rs | workspace_tests/src/resource_rt/internal/workspace_dirs.rs | use std::path::PathBuf;
use peace::resource_rt::{
internal::WorkspaceDirs,
paths::{PeaceAppDir, PeaceDir, WorkspaceDir},
};
#[test]
fn into_inner() {
let workspace_dir = WorkspaceDir::new(PathBuf::from("workspace_dir"));
let peace_dir = PeaceDir::new(PathBuf::from("peace_dir"));
let peace_app_dir = PeaceAppDir::new(PathBuf::from("peace_app_dir"));
let workspace_dirs = WorkspaceDirs::new(
workspace_dir.clone(),
peace_dir.clone(),
peace_app_dir.clone(),
);
let (workspace_dir_inner, peace_dir_inner, peace_app_dir_inner) = workspace_dirs.into_inner();
assert_eq!(workspace_dir, workspace_dir_inner);
assert_eq!(peace_dir, peace_dir_inner);
assert_eq!(peace_app_dir, peace_app_dir_inner);
}
#[test]
fn clone() {
let workspace_dir = WorkspaceDir::new(PathBuf::from("workspace_dir"));
let peace_dir = PeaceDir::new(PathBuf::from("peace_dir"));
let peace_app_dir = PeaceAppDir::new(PathBuf::from("peace_app_dir"));
let workspace_dirs_0 = WorkspaceDirs::new(workspace_dir, peace_dir, peace_app_dir);
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let workspace_dirs_1 = workspace_dirs_0.clone();
assert_eq!(workspace_dirs_0, workspace_dirs_1);
}
#[test]
fn debug() {
let workspace_dir = WorkspaceDir::new(PathBuf::from("workspace_dir"));
let peace_dir = PeaceDir::new(PathBuf::from("peace_dir"));
let peace_app_dir = PeaceAppDir::new(PathBuf::from("peace_app_dir"));
let workspace_dirs = WorkspaceDirs::new(workspace_dir, peace_dir, peace_app_dir);
assert_eq!(
"WorkspaceDirs { \
workspace_dir: WorkspaceDir(\"workspace_dir\"), \
peace_dir: PeaceDir(\"peace_dir\"), \
peace_app_dir: PeaceAppDir(\"peace_app_dir\") \
}",
format!("{workspace_dirs:?}")
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/internal/state_diffs_mut.rs | workspace_tests/src/resource_rt/internal/state_diffs_mut.rs | use peace::{
item_model::item_id,
resource_rt::{internal::StateDiffsMut, type_reg::untagged::TypeMap},
};
#[test]
fn with_capacity_reserves_enough_capacity() {
let state_diffs_mut = StateDiffsMut::with_capacity(100);
assert!(state_diffs_mut.capacity() >= 100);
}
#[test]
fn into_inner() {
let state_diffs_mut = test_state_diffs_mut();
let type_map = state_diffs_mut.into_inner();
assert_eq!(1, type_map.len())
}
#[test]
fn deref_and_deref_mut() {
let mut state_diffs_mut = StateDiffsMut::new();
// deref_mut
state_diffs_mut.insert(item_id!("key"), 123);
// deref
assert_eq!(1, state_diffs_mut.len())
}
#[test]
fn from_type_map() {
let _state_diffs_mut = StateDiffsMut::from(TypeMap::new_typed());
}
#[test]
fn debug() {
let state_diffs_mut = test_state_diffs_mut();
assert_eq!(
r#"StateDiffsMut({ItemId("key"): TypedValue { type: "i32", value: 123 }})"#,
format!("{state_diffs_mut:?}")
);
}
fn test_state_diffs_mut() -> StateDiffsMut {
let mut state_diffs_mut = StateDiffsMut::new();
state_diffs_mut.insert(item_id!("key"), 123);
state_diffs_mut
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/resources/ts.rs | workspace_tests/src/resource_rt/resources/ts.rs | mod debug {
use peace::resource_rt::resources::ts::{Empty, SetUp};
#[test]
fn empty() {
assert_eq!("Empty", format!("{Empty:?}"));
}
#[test]
fn set_up() {
assert_eq!("SetUp", format!("{SetUp:?}"));
}
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir/profile_history_dir.rs | workspace_tests/src/resource_rt/dir/profile_history_dir.rs | use std::{ffi::OsStr, path::Path};
use peace::{
cfg::{app_name, profile},
resource_rt::paths::{PeaceAppDir, PeaceDir, ProfileDir, ProfileHistoryDir},
};
#[test]
pub fn debug() {
let profile_history_dir = ProfileHistoryDir::from(Path::new(".").to_path_buf());
assert_eq!(
r#"ProfileHistoryDir(".")"#,
format!("{profile_history_dir:?}")
);
}
#[test]
pub fn partial_eq() {
let profile_history_dir_0 = ProfileHistoryDir::from(Path::new(".").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let profile_history_dir_1 = profile_history_dir_0.clone();
assert_eq!(profile_history_dir_0, profile_history_dir_1);
}
#[test]
pub fn from_path_buf() {
let profile_history_dir = ProfileHistoryDir::from(Path::new(".").to_path_buf());
assert_eq!(Path::new("."), &*profile_history_dir);
}
#[test]
pub fn from_profile_dir_relative() {
let app_name = app_name!();
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let profile = profile!("test_profile");
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name));
let profile_dir = ProfileDir::from((&peace_app_dir, &profile));
let profile_history_dir = ProfileHistoryDir::from(&profile_dir);
let mut path = Path::new(".").to_path_buf();
path.push(&**app_name!());
path.push("test_profile");
path.push(".history");
assert_eq!(path, &*profile_history_dir);
}
#[test]
pub fn into_inner_returns_path_buf() {
let profile_history_dir = ProfileHistoryDir::new(Path::new(".").to_path_buf());
assert_eq!(
Path::new(".").to_path_buf(),
profile_history_dir.into_inner()
);
}
#[test]
pub fn as_ref_os_str() {
let profile_history_dir = ProfileHistoryDir::new(Path::new(".").to_path_buf());
assert_eq!(
OsStr::new("."),
<ProfileHistoryDir as AsRef<OsStr>>::as_ref(&profile_history_dir)
);
}
#[test]
pub fn as_ref_path() {
let profile_history_dir = ProfileHistoryDir::new(Path::new(".").to_path_buf());
assert_eq!(
Path::new("."),
<ProfileHistoryDir as AsRef<Path>>::as_ref(&profile_history_dir)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir/states_current_file.rs | workspace_tests/src/resource_rt/dir/states_current_file.rs | use std::{
ffi::OsStr,
path::{Path, PathBuf},
};
use peace::{
cfg::{app_name, profile},
flow_model::flow_id,
resource_rt::paths::{FlowDir, PeaceAppDir, PeaceDir, ProfileDir, StatesCurrentFile},
};
#[test]
pub fn debug() {
let states_current_file = StatesCurrentFile::from(Path::new("test_states.yaml").to_path_buf());
assert_eq!(
r#"StatesCurrentFile("test_states.yaml")"#,
format!("{states_current_file:?}")
);
}
#[test]
pub fn partial_eq() {
let states_current_file_0 =
StatesCurrentFile::from(Path::new("test_states.yaml").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let states_current_file_1 = states_current_file_0.clone();
assert_eq!(states_current_file_0, states_current_file_1);
}
#[test]
pub fn from_path_buf() {
let states_current_file = StatesCurrentFile::from(Path::new("test_states.yaml").to_path_buf());
assert_eq!(Path::new("test_states.yaml"), &*states_current_file);
}
#[test]
pub fn from_flow_dir_relative() {
let app_name = app_name!();
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let profile = profile!("test_profile");
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name));
let profile_dir = ProfileDir::from((&peace_app_dir, &profile));
let flow_dir = FlowDir::from((&profile_dir, &flow_id!("test_flow")));
let states_current_file = StatesCurrentFile::from(&flow_dir);
let path = PathBuf::from_iter([
".",
&**app_name!(),
"test_profile",
"test_flow",
"states_current.yaml",
]);
assert_eq!(path, &*states_current_file);
}
#[test]
pub fn into_inner_returns_path_buf() {
let states_current_file = StatesCurrentFile::new(Path::new("test_states.yaml").to_path_buf());
assert_eq!(
Path::new("test_states.yaml").to_path_buf(),
states_current_file.into_inner()
);
}
#[test]
pub fn as_ref_os_str() {
let states_current_file = StatesCurrentFile::new(Path::new("test_states.yaml").to_path_buf());
assert_eq!(
OsStr::new("test_states.yaml"),
<StatesCurrentFile as AsRef<OsStr>>::as_ref(&states_current_file)
);
}
#[test]
pub fn as_ref_path() {
let states_current_file = StatesCurrentFile::new(Path::new("test_states.yaml").to_path_buf());
assert_eq!(
Path::new("test_states.yaml"),
<StatesCurrentFile as AsRef<Path>>::as_ref(&states_current_file)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir/workspace_dir.rs | workspace_tests/src/resource_rt/dir/workspace_dir.rs | use std::{ffi::OsStr, path::Path};
use peace::resource_rt::paths::WorkspaceDir;
#[test]
pub fn debug() {
let workspace_dir = WorkspaceDir::from(Path::new(".").to_path_buf());
assert_eq!(r#"WorkspaceDir(".")"#, format!("{workspace_dir:?}"));
}
#[test]
pub fn partial_eq() {
let workspace_dir_0 = WorkspaceDir::from(Path::new(".").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let workspace_dir_1 = workspace_dir_0.clone();
assert_eq!(workspace_dir_0, workspace_dir_1);
}
#[test]
pub fn from_path_buf() {
let workspace_dir = WorkspaceDir::from(Path::new(".").to_path_buf());
assert_eq!(Path::new("."), &*workspace_dir);
}
#[test]
pub fn into_inner_returns_path_buf() {
let workspace_dir = WorkspaceDir::new(Path::new(".").to_path_buf());
assert_eq!(Path::new(".").to_path_buf(), workspace_dir.into_inner());
}
#[test]
pub fn as_ref_os_str() {
let workspace_dir = WorkspaceDir::new(Path::new(".").to_path_buf());
assert_eq!(
OsStr::new("."),
<WorkspaceDir as AsRef<OsStr>>::as_ref(&workspace_dir)
);
}
#[test]
pub fn as_ref_path() {
let workspace_dir = WorkspaceDir::new(Path::new(".").to_path_buf());
assert_eq!(
Path::new("."),
<WorkspaceDir as AsRef<Path>>::as_ref(&workspace_dir)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir/peace_dir.rs | workspace_tests/src/resource_rt/dir/peace_dir.rs | use std::{ffi::OsStr, path::Path};
use peace::resource_rt::paths::{PeaceDir, WorkspaceDir};
#[test]
pub fn debug() {
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
assert_eq!(r#"PeaceDir(".")"#, format!("{peace_dir:?}"));
}
#[test]
pub fn partial_eq() {
let peace_dir_0 = PeaceDir::from(Path::new(".").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let peace_dir_1 = peace_dir_0.clone();
assert_eq!(peace_dir_0, peace_dir_1);
}
#[test]
pub fn from_path_buf() {
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
assert_eq!(Path::new("."), &*peace_dir);
}
#[test]
pub fn from_workspace_dir_relative() {
let workspace_dir = WorkspaceDir::from(Path::new(".").to_path_buf());
let peace_dir = PeaceDir::from(&workspace_dir);
let mut path = Path::new(".").to_path_buf();
path.push(PeaceDir::NAME);
assert_eq!(path, &*peace_dir);
}
#[test]
pub fn from_workspace_dir_blank() {
let workspace_dir = WorkspaceDir::from(Path::new("").to_path_buf());
let peace_dir = PeaceDir::from(&workspace_dir);
assert_eq!(Path::new(PeaceDir::NAME), &*peace_dir);
}
#[test]
pub fn into_inner_returns_path_buf() {
let peace_dir = PeaceDir::new(Path::new(".").to_path_buf());
assert_eq!(Path::new(".").to_path_buf(), peace_dir.into_inner());
}
#[test]
pub fn as_ref_os_str() {
let peace_dir = PeaceDir::new(Path::new(".").to_path_buf());
assert_eq!(
OsStr::new("."),
<PeaceDir as AsRef<OsStr>>::as_ref(&peace_dir)
);
}
#[test]
pub fn as_ref_path() {
let peace_dir = PeaceDir::new(Path::new(".").to_path_buf());
assert_eq!(
Path::new("."),
<PeaceDir as AsRef<Path>>::as_ref(&peace_dir)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir/profile_dir.rs | workspace_tests/src/resource_rt/dir/profile_dir.rs | use std::{ffi::OsStr, path::Path};
use peace::{
cfg::{app_name, profile},
resource_rt::paths::{PeaceAppDir, PeaceDir, ProfileDir},
};
#[test]
pub fn debug() {
let profile_dir = ProfileDir::from(Path::new(".").to_path_buf());
assert_eq!(r#"ProfileDir(".")"#, format!("{profile_dir:?}"));
}
#[test]
pub fn partial_eq() {
let profile_dir_0 = ProfileDir::from(Path::new(".").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let profile_dir_1 = profile_dir_0.clone();
assert_eq!(profile_dir_0, profile_dir_1);
}
#[test]
pub fn from_path_buf() {
let profile_dir = ProfileDir::from(Path::new(".").to_path_buf());
assert_eq!(Path::new("."), &*profile_dir);
}
#[test]
pub fn from_peace_dir_relative() {
let app_name = app_name!();
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let profile = profile!("test_profile");
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name));
let profile_dir = ProfileDir::from((&peace_app_dir, &profile));
let mut path = Path::new(".").to_path_buf();
path.push(&**app_name!());
path.push("test_profile");
assert_eq!(path, &*profile_dir);
}
#[test]
pub fn into_inner_returns_path_buf() {
let profile_dir = ProfileDir::new(Path::new(".").to_path_buf());
assert_eq!(Path::new(".").to_path_buf(), profile_dir.into_inner());
}
#[test]
pub fn as_ref_os_str() {
let profile_dir = ProfileDir::new(Path::new(".").to_path_buf());
assert_eq!(
OsStr::new("."),
<ProfileDir as AsRef<OsStr>>::as_ref(&profile_dir)
);
}
#[test]
pub fn as_ref_path() {
let profile_dir = ProfileDir::new(Path::new(".").to_path_buf());
assert_eq!(
Path::new("."),
<ProfileDir as AsRef<Path>>::as_ref(&profile_dir)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/dir/states_goal_file.rs | workspace_tests/src/resource_rt/dir/states_goal_file.rs | use std::{
ffi::OsStr,
path::{Path, PathBuf},
};
use peace::{
cfg::{app_name, profile},
flow_model::flow_id,
resource_rt::paths::{FlowDir, PeaceAppDir, PeaceDir, ProfileDir, StatesGoalFile},
};
#[test]
pub fn debug() {
let states_goal_file = StatesGoalFile::from(Path::new("test_states_goal.yaml").to_path_buf());
assert_eq!(
r#"StatesGoalFile("test_states_goal.yaml")"#,
format!("{states_goal_file:?}")
);
}
#[test]
pub fn partial_eq() {
let states_goal_file_0 = StatesGoalFile::from(Path::new("test_states_goal.yaml").to_path_buf());
#[allow(clippy::redundant_clone)] // https://github.com/rust-lang/rust-clippy/issues/9011
let states_goal_file_1 = states_goal_file_0.clone();
assert_eq!(states_goal_file_0, states_goal_file_1);
}
#[test]
pub fn from_path_buf() {
let states_goal_file = StatesGoalFile::from(Path::new("test_states_goal.yaml").to_path_buf());
assert_eq!(Path::new("test_states_goal.yaml"), &*states_goal_file);
}
#[test]
pub fn from_flow_dir_relative() {
let app_name = app_name!();
let peace_dir = PeaceDir::from(Path::new(".").to_path_buf());
let profile = profile!("test_profile");
let peace_app_dir = PeaceAppDir::from((&peace_dir, &app_name));
let profile_dir = ProfileDir::from((&peace_app_dir, &profile));
let flow_dir = FlowDir::from((&profile_dir, &flow_id!("test_flow")));
let states_goal_file = StatesGoalFile::from(&flow_dir);
let path = PathBuf::from_iter([
".",
&**app_name!(),
"test_profile",
"test_flow",
"states_goal.yaml",
]);
assert_eq!(path, &*states_goal_file);
}
#[test]
pub fn into_inner_returns_path_buf() {
let states_goal_file = StatesGoalFile::new(Path::new("test_states_goal.yaml").to_path_buf());
assert_eq!(
Path::new("test_states_goal.yaml").to_path_buf(),
states_goal_file.into_inner()
);
}
#[test]
pub fn as_ref_os_str() {
let states_goal_file = StatesGoalFile::new(Path::new("test_states_goal.yaml").to_path_buf());
assert_eq!(
OsStr::new("test_states_goal.yaml"),
<StatesGoalFile as AsRef<OsStr>>::as_ref(&states_goal_file)
);
}
#[test]
pub fn as_ref_path() {
let states_goal_file = StatesGoalFile::new(Path::new("test_states_goal.yaml").to_path_buf());
assert_eq!(
Path::new("test_states_goal.yaml"),
<StatesGoalFile as AsRef<Path>>::as_ref(&states_goal_file)
);
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_previous.rs | workspace_tests/src/resource_rt/states/states_previous.rs | use peace::resource_rt::states::{StatesCurrent, StatesPrevious};
#[test]
fn from_states_current() {
let _states_previous = StatesPrevious::from(StatesCurrent::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_ensured.rs | workspace_tests/src/resource_rt/states/states_ensured.rs | use peace::resource_rt::states::{StatesCurrent, StatesEnsured};
#[test]
fn from_states_current() {
let _states_ensured = StatesEnsured::from(StatesCurrent::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_goal.rs | workspace_tests/src/resource_rt/states/states_goal.rs | use peace::resource_rt::states::{StatesGoal, StatesGoalStored};
#[test]
fn from_states_goal_stored() {
let _states_goal = StatesGoal::from(StatesGoalStored::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_current_stored.rs | workspace_tests/src/resource_rt/states/states_current_stored.rs | use peace::resource_rt::states::{StatesCurrent, StatesCurrentStored};
#[test]
fn from_states_current() {
let _states_current_stored = StatesCurrentStored::from(StatesCurrent::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/ts.rs | workspace_tests/src/resource_rt/states/ts.rs | mod debug {
use peace::resource_rt::states::ts::{
Clean, Cleaned, CleanedDry, Current, CurrentStored, Ensured, EnsuredDry, Goal, GoalStored,
Previous,
};
#[test]
fn states_clean() {
assert_eq!("Clean", format!("{Clean:?}"))
}
#[test]
fn states_current_stored() {
assert_eq!("CurrentStored", format!("{CurrentStored:?}"))
}
#[test]
fn states_current() {
assert_eq!("Current", format!("{Current:?}"))
}
#[test]
fn states_goal_stored() {
assert_eq!("GoalStored", format!("{GoalStored:?}"))
}
#[test]
fn states_goal() {
assert_eq!("Goal", format!("{Goal:?}"))
}
#[test]
fn states_ensured() {
assert_eq!("Ensured", format!("{Ensured:?}"))
}
#[test]
fn states_ensured_dry() {
assert_eq!("EnsuredDry", format!("{EnsuredDry:?}"))
}
#[test]
fn states_cleaned() {
assert_eq!("Cleaned", format!("{Cleaned:?}"))
}
#[test]
fn states_cleaned_dry() {
assert_eq!("CleanedDry", format!("{CleanedDry:?}"))
}
#[test]
fn states_previous() {
assert_eq!("Previous", format!("{Previous:?}"))
}
}
mod serde {
use peace::resource_rt::states::ts::{
Clean, Cleaned, CleanedDry, Current, CurrentStored, Ensured, EnsuredDry, Goal, GoalStored,
Previous,
};
#[test]
fn clean() {
let s = serde_yaml::to_string(&Clean).unwrap();
assert!(serde_yaml::from_str::<Clean>(&s).is_ok());
}
#[test]
fn current_stored() {
let s = serde_yaml::to_string(&CurrentStored).unwrap();
assert!(serde_yaml::from_str::<CurrentStored>(&s).is_ok());
}
#[test]
fn current() {
let s = serde_yaml::to_string(&Current).unwrap();
assert!(serde_yaml::from_str::<Current>(&s).is_ok());
}
#[test]
fn goal_stored() {
let s = serde_yaml::to_string(&GoalStored).unwrap();
assert!(serde_yaml::from_str::<GoalStored>(&s).is_ok());
}
#[test]
fn goal() {
let s = serde_yaml::to_string(&Goal).unwrap();
assert!(serde_yaml::from_str::<Goal>(&s).is_ok());
}
#[test]
fn ensured() {
let s = serde_yaml::to_string(&Ensured).unwrap();
assert!(serde_yaml::from_str::<Ensured>(&s).is_ok());
}
#[test]
fn ensured_dry() {
let s = serde_yaml::to_string(&EnsuredDry).unwrap();
assert!(serde_yaml::from_str::<EnsuredDry>(&s).is_ok());
}
#[test]
fn cleaned() {
let s = serde_yaml::to_string(&Cleaned).unwrap();
assert!(serde_yaml::from_str::<Cleaned>(&s).is_ok());
}
#[test]
fn cleaned_dry() {
let s = serde_yaml::to_string(&CleanedDry).unwrap();
assert!(serde_yaml::from_str::<CleanedDry>(&s).is_ok());
}
#[test]
fn previous() {
let s = serde_yaml::to_string(&Previous).unwrap();
assert!(serde_yaml::from_str::<Previous>(&s).is_ok());
}
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_goal_stored.rs | workspace_tests/src/resource_rt/states/states_goal_stored.rs | use peace::resource_rt::states::{StatesGoal, StatesGoalStored};
#[test]
fn from_states_goal() {
let _states_goal_stored = StatesGoalStored::from(StatesGoal::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_ensured_dry.rs | workspace_tests/src/resource_rt/states/states_ensured_dry.rs | use peace::resource_rt::states::{StatesCurrent, StatesEnsuredDry};
#[test]
fn from_states_current() {
let _states_ensured_dry = StatesEnsuredDry::from(StatesCurrent::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_current.rs | workspace_tests/src/resource_rt/states/states_current.rs | use peace::resource_rt::states::{StatesCurrent, StatesCurrentStored};
#[test]
fn from_states_current_stored() {
let _states_current = StatesCurrent::from(StatesCurrentStored::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_cleaned.rs | workspace_tests/src/resource_rt/states/states_cleaned.rs | use peace::resource_rt::states::{StatesCleaned, StatesCurrent};
#[test]
fn from_states_current() {
let _states_cleaned = StatesCleaned::from(StatesCurrent::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/resource_rt/states/states_cleaned_dry.rs | workspace_tests/src/resource_rt/states/states_cleaned_dry.rs | use peace::resource_rt::states::{StatesCleanedDry, StatesCurrent};
#[test]
fn from_states_current() {
let _states_cleaned_dry = StatesCleanedDry::from(StatesCurrent::new());
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/flow_model/item_info.rs | workspace_tests/src/flow_model/item_info.rs | use peace::{flow_model::ItemInfo, item_model::item_id};
#[test]
fn clone() {
let item_info = ItemInfo::new(item_id!("item_id"));
assert_eq!(item_info, Clone::clone(&item_info));
}
#[test]
fn debug() {
let item_info = ItemInfo::new(item_id!("item_id"));
assert_eq!(
"ItemInfo { item_id: ItemId(\"item_id\") }",
format!("{item_info:?}")
);
}
#[test]
fn serialize() -> Result<(), serde_yaml::Error> {
let item_info = ItemInfo::new(item_id!("item_id"));
assert_eq!("item_id: item_id\n", serde_yaml::to_string(&item_info)?);
Ok(())
}
#[test]
fn deserialize() -> Result<(), serde_yaml::Error> {
let item_info = ItemInfo::new(item_id!("item_id"));
assert_eq!(item_info, serde_yaml::from_str("item_id: item_id\n")?);
Ok(())
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
azriel91/peace | https://github.com/azriel91/peace/blob/5e2c43f2c0b18672749d0902d2285c703e24de97/workspace_tests/src/flow_model/flow_spec_info.rs | workspace_tests/src/flow_model/flow_spec_info.rs | use peace::{
data::fn_graph::{Edge, WouldCycle},
flow_model::{
dot_ix::{
self,
model::{
common::{Edges, NodeHierarchy, NodeNames},
edge_id,
info_graph::{GraphDir, GraphStyle, InfoGraph},
node_id,
},
},
flow_id, FlowSpecInfo,
},
flow_rt::{Flow, ItemGraph, ItemGraphBuilder},
item_model::item_id,
};
use peace_items::blank::BlankItem;
use crate::PeaceTestError;
#[test]
fn to_progress_info_graph() -> Result<(), Box<dyn std::error::Error>> {
let flow_spec_info = flow_spec_info()?;
let info_graph = flow_spec_info.to_progress_info_graph();
let info_graph_expected = {
let mut node_hierarchy = NodeHierarchy::new();
node_hierarchy.insert(node_id!("a"), NodeHierarchy::new());
node_hierarchy.insert(node_id!("b"), NodeHierarchy::new());
node_hierarchy.insert(node_id!("c"), NodeHierarchy::new());
node_hierarchy.insert(node_id!("d"), NodeHierarchy::new());
node_hierarchy.insert(node_id!("e"), NodeHierarchy::new());
node_hierarchy.insert(node_id!("f"), NodeHierarchy::new());
let mut edges = Edges::new();
edges.insert(edge_id!("a__b"), [node_id!("a"), node_id!("b")]);
edges.insert(edge_id!("a__c"), [node_id!("a"), node_id!("c")]);
edges.insert(edge_id!("b__e"), [node_id!("b"), node_id!("e")]);
edges.insert(edge_id!("c__d"), [node_id!("c"), node_id!("d")]);
edges.insert(edge_id!("d__e"), [node_id!("d"), node_id!("e")]);
edges.insert(edge_id!("f__e"), [node_id!("f"), node_id!("e")]);
let mut node_names = NodeNames::new();
node_names.insert(node_id!("a"), String::from("a"));
node_names.insert(node_id!("b"), String::from("b"));
node_names.insert(node_id!("c"), String::from("c"));
node_names.insert(node_id!("d"), String::from("d"));
node_names.insert(node_id!("e"), String::from("e"));
node_names.insert(node_id!("f"), String::from("f"));
InfoGraph::default()
.with_graph_style(GraphStyle::Circle)
.with_direction(GraphDir::Vertical)
.with_hierarchy(node_hierarchy)
.with_node_names(node_names)
.with_edges(edges)
};
assert_eq!(info_graph_expected, info_graph);
Ok(())
}
#[test]
fn clone() -> Result<(), Box<dyn std::error::Error>> {
let flow_spec_info = flow_spec_info()?;
assert_eq!(flow_spec_info, Clone::clone(&flow_spec_info));
Ok(())
}
#[test]
fn debug() -> Result<(), Box<dyn std::error::Error>> {
let flow_spec_info = flow_spec_info()?;
assert_eq!(
"FlowSpecInfo { \
flow_id: FlowId(\"flow_id\"), \
graph_info: GraphInfo { \
graph: Dag { graph: Graph { Ty: \"Directed\", node_count: 6, edge_count: 9, edges: (0, 1), (0, 2), (1, 4), (2, 3), (3, 4), (5, 4), (1, 2), (5, 1), (0, 5), node weights: {0: ItemSpecInfo { item_id: ItemId(\"a\") }, 1: ItemSpecInfo { item_id: ItemId(\"b\") }, 2: ItemSpecInfo { item_id: ItemId(\"c\") }, 3: ItemSpecInfo { item_id: ItemId(\"d\") }, 4: ItemSpecInfo { item_id: ItemId(\"e\") }, 5: ItemSpecInfo { item_id: ItemId(\"f\") }}, edge weights: {0: Contains, 1: Logic, 2: Logic, 3: Contains, 4: Logic, 5: Logic, 6: Data, 7: Data, 8: Data} }, cycle_state: DfsSpace { dfs: Dfs { stack: [], discovered: FixedBitSet { data: 0x10, capacity: 0, length: 0 } } } } \
} \
}",
format!("{flow_spec_info:?}")
);
Ok(())
}
#[test]
fn serialize() -> Result<(), Box<dyn std::error::Error>> {
let flow_spec_info = flow_spec_info()?;
assert_eq!(
r#"flow_id: flow_id
graph_info:
graph:
nodes:
- item_id: a
- item_id: b
- item_id: c
- item_id: d
- item_id: e
- item_id: f
node_holes: []
edge_property: directed
edges:
- - 0
- 1
- Contains
- - 0
- 2
- Logic
- - 1
- 4
- Logic
- - 2
- 3
- Contains
- - 3
- 4
- Logic
- - 5
- 4
- Logic
- - 1
- 2
- Data
- - 5
- 1
- Data
- - 0
- 5
- Data
"#,
serde_yaml::to_string(&flow_spec_info)?
);
Ok(())
}
#[test]
fn deserialize() -> Result<(), Box<dyn std::error::Error>> {
let flow_spec_info = flow_spec_info()?;
assert_eq!(
flow_spec_info,
serde_yaml::from_str(
r#"flow_id: flow_id
graph_info:
graph:
nodes:
- item_id: a
- item_id: b
- item_id: c
- item_id: d
- item_id: e
- item_id: f
node_holes: []
edge_property: directed
edges:
- [0, 1, Contains]
- [0, 2, Logic]
- [1, 4, Logic]
- [2, 3, Contains]
- [3, 4, Logic]
- [5, 4, Logic]
- [1, 2, Data]
- [5, 1, Data]
- [0, 5, Data]
"#
)?
);
Ok(())
}
fn flow_spec_info() -> Result<FlowSpecInfo, WouldCycle<Edge>> {
let flow_spec_info: FlowSpecInfo = {
let flow = Flow::new(flow_id!("flow_id"), complex_graph()?);
flow.flow_spec_info()
};
Ok(flow_spec_info)
}
fn complex_graph() -> Result<ItemGraph<PeaceTestError>, WouldCycle<Edge>> {
// Progress:
//
// ```text
// a - b --------- e
// \ / /
// '-- c - d /
// /
// f --------'
// ```
//
// Outcome:
//
// ```text
// .-a---. .-e-.
// |.-b-.| '---'
// |'---'| .-c---.
// '-----' |.-d-.|
// |'---'|
// .-f-. '-----'
// '---'
// ```
let mut item_graph_builder = ItemGraphBuilder::new();
let [fn_id_a, fn_id_b, fn_id_c, fn_id_d, fn_id_e, fn_id_f] = item_graph_builder.add_fns([
BlankItem::<()>::new(item_id!("a")).into(),
BlankItem::<()>::new(item_id!("b")).into(),
BlankItem::<()>::new(item_id!("c")).into(),
BlankItem::<()>::new(item_id!("d")).into(),
BlankItem::<()>::new(item_id!("e")).into(),
BlankItem::<()>::new(item_id!("f")).into(),
]);
item_graph_builder.add_contains_edge(fn_id_a, fn_id_b)?;
item_graph_builder.add_logic_edge(fn_id_a, fn_id_c)?;
item_graph_builder.add_logic_edge(fn_id_b, fn_id_e)?;
item_graph_builder.add_contains_edge(fn_id_c, fn_id_d)?;
item_graph_builder.add_logic_edge(fn_id_d, fn_id_e)?;
item_graph_builder.add_logic_edge(fn_id_f, fn_id_e)?;
let item_graph = item_graph_builder.build();
Ok(item_graph)
}
| rust | Apache-2.0 | 5e2c43f2c0b18672749d0902d2285c703e24de97 | 2026-01-04T20:22:52.922300Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.