/// Test making of records
#[test(tokio::test)]
async fn test_making_records() {
let TestState {
mut state,
mut tasks,
mut fs_watch_task,
initial_change_len,
id: _,
repo,
} = setup_state().await;
let repo_path = repo.dir.path();
// _________________________________________________________________________
// Case: start -> edit -> save
// Add an untracked file
let file_to_record = "funky.rs";
fs::write(repo_path.join(file_to_record), "music")
.await
.unwrap();
// Wait for the FS watch to pick it up
let msg = await_next_msg(&mut fs_watch_task).await;
assert_matches!(
&msg,
Msg::View(app::Msg::ToRepo(
repo::MsgIn::RefreshChangedAndUntrackedFiles
))
);
// Update the state with it to send it to repo
let _task = update(&mut state, msg);
// Wait for response from repo
let msg = await_next_msg(&mut tasks).await;
assert_matches!(&msg, Msg::FromRepo(repo::MsgOut::Refreshed(_)));
let _task = update(&mut state, msg);
// Select it
state.cursor.selection = Some(cursor::Selection::UntrackedFile {
ix: 0,
path: file_to_record.to_string(),
});
// Add it to tracked files
let _task = update(&mut state, Msg::AddUntrackedFile);
// Wait for it to be added
let msg = task::await_next_msg(&mut tasks).await;
assert_matches!(
&msg,
Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path }) if path == file_to_record
);
// Start a record
let _task = start_record(&mut state);
assert!(state.record_msg.is_some());
// Edit the record msg
let record_msg = "Added funky music";
edit_record_msg(
&mut state,
text_editor::Action::Edit(text_editor::Edit::Paste(Arc::new(
record_msg.to_string(),
))),
);
assert!(state.record_msg.is_some());
assert_matches!(
state.record_msg.as_ref().unwrap(),
app::RecordMsg::Typing(_)
);
if let app::RecordMsg::Typing(content) = state.record_msg.as_ref().unwrap()
{
assert_eq!(&content.text(), record_msg);
}
// Save the record
let _task = save_record(&mut state);
let msg = task::await_next_msg(&mut tasks).await;
assert_matches!(&msg, Msg::FromRepo(repo::MsgOut::Recorded(_)));
let _task = update(&mut state, msg);
// Check the log
dbg!(&state.repo.as_ref().unwrap().log);
assert_eq!(
state.repo.as_ref().unwrap().log.len(),
initial_change_len + 1
);
// _________________________________________________________________________
// Case: start -> edit -> abandon -> start
// _________________________________________________________________________
// Case: start -> edit -> defer -> start
}
async fn setup_state() -> TestState {
let id = setup_pijul_id();
let repo = setup_pijul_repo();
let repo_path = repo.dir.path();
let (mut state, mut tasks) = init(repo_path.to_path_buf());
// Wait for the first 3 msgs:
// - Msg::WindowOpened
// - Msg::LoadedId
// - Msg::FromRepo(repo::MsgOut::Init)
let mut fs_watch_task: Task<Msg> = Task::none();
for _ in 0..3 {
let msg = task::await_next_msg(&mut tasks).await;
// Upate state with the msg received from task to init the repo
let task = update(&mut state, msg.clone());
if matches!(&msg, Msg::FromRepo(repo::MsgOut::Init(_))) {
fs_watch_task = task;
}
}
assert!(state.repo.is_some());
// Select and record the default ".ignore" file
let file_to_record = ".ignore";
state.cursor.selection = Some(cursor::Selection::UntrackedFile {
ix: 0,
path: file_to_record.to_string(),
});
// Add it to tracked files
let _task = update(&mut state, Msg::AddUntrackedFile);
// Wait for it to be added
let msg = task::await_next_msg(&mut tasks).await;
assert_matches!(
&msg,
Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path }) if path == file_to_record
);
// Make the initial record to add project root: Start a record
let _task = start_record(&mut state);
assert!(state.record_msg.is_some());
// Edit the record msg
let record_msg = "Initialized";
edit_record_msg(
&mut state,
text_editor::Action::Edit(text_editor::Edit::Paste(Arc::new(
record_msg.to_string(),
))),
);
assert!(state.record_msg.is_some());
assert_matches!(
state.record_msg.as_ref().unwrap(),
app::RecordMsg::Typing(_)
);
if let app::RecordMsg::Typing(content) = state.record_msg.as_ref().unwrap()
{
assert_eq!(&content.text(), record_msg);
}
// Save the record
let _task = save_record(&mut state);
let msg = task::await_next_msg(&mut tasks).await;
assert_matches!(&msg, Msg::FromRepo(repo::MsgOut::Recorded(_)));
let _task = update(&mut state, msg);
// Expect 2 changes in the log:
// - Add root
// - Add ".ignore" file
let initial_change_len = 2;
let log = &state.repo.as_ref().unwrap().log;
assert_eq!(log.len(), initial_change_len);
assert_eq!(log[0].file_paths, [file_to_record]);
assert_eq!(log[1].file_paths, ["/"]);
TestState {
state,
tasks,
fs_watch_task,
initial_change_len,
id,
repo,
}
}
#[derive(Derivative)]
#[derivative(Debug)]
struct TestState {
pub state: State,
#[derivative(Debug = "ignore")]
pub tasks: Task<Msg>,
#[derivative(Debug = "ignore")]
pub fs_watch_task: Task<Msg>,
initial_change_len: usize,
pub id: PijulId,
pub repo: PijulRepo,
}