test load repo

[?]

Jun 3, 2025, 11:26 AM

UF5NJKASGMZSZMBUKSUI67B2GIMQFX5SNNQEHHGUBNDBQ2QZZWSAC

Dependencies

[2] 6YZAVBWU Initial commit
[3] KLR5FRIB add fs state read/write of repos
[4] SWWE2R6M display basic repo stuff
[5] W7IUT3ZV start recording impl
[6] YBJRDOTC make all repo actions async
[7] A5YBC77V record!
[8] JE44NYHM display log files diffs
[9] ONRCENKT rm unnecessary state from repo's internal state
[10] CALXOZXA flatten crates dir
[11] VCNKFNUF app init test
[12] I56UGW7U make record test, fix log update
[13] YYKXNBFL test: add untracked file
[14] OQ6HSAWH show record log
[15] 4WO3ZJM2 show untracked files' contents
[16] ESMM3FEL test selection reindexing
[17] 5CYU7UT7 test: rm added file
[18] KMB6FND3 test view update fn rather than direct fn calls
[19] TSFQFCB2 test got repo change
[20] EC3TVL4X add untracked files

Change contents

edit in libflorescence/src/testing.rs at line 7

[11.177]

[11.177]

use std::path::{Path, PathBuf};
edit in libflorescence/src/testing.rs at line 10

[11.178]

[11.178]

/// Get the path to the repo
pub fn repo_path(repo: &PijulRepo) -> PathBuf {
let PijulRepo {
rootdir: dir,
subdir,
} = repo;
if let Some(subdir) = subdir {
dir.path().join(subdir)
} else {
dir.path().to_path_buf()
}
}
replacement in libflorescence/src/testing.rs at line 58

[11.1403]→[11.1403:1437](∅→∅)

let dir = tempdir().unwrap();

[11.1403]

[11.1437]

setup_pijul_repo_in_subdir("")
}
replacement in libflorescence/src/testing.rs at line 61

[11.1438]→[11.1438:1532](∅→∅)

let repo =
Repository::init(Some(dir.path().to_path_buf()), None, None).unwrap();

[11.1438]

[11.1532]

/// Setup an empty Pijul repo inside a given subdir in a temp dir
pub fn setup_pijul_repo_in_subdir<P: AsRef<Path>>(subdir: P) -> PijulRepo {
let rootdir = tempdir().unwrap();

let repo = Repository::init(Some(rootdir.path().join(&subdir)), None, None)
.unwrap();
replacement in libflorescence/src/testing.rs at line 73

[11.1857]→[11.1857:1879](∅→∅)

PijulRepo { dir }

[11.1857]

[11.1879]

PijulRepo {
rootdir,
subdir: if subdir.as_ref().as_os_str().is_empty() {
None
} else {
Some(subdir.as_ref().to_path_buf())
},
}
replacement in libflorescence/src/testing.rs at line 93

[11.2067]→[11.2067:2089](∅→∅)

pub dir: TempDir,

[11.2067]

[11.2089]

pub rootdir: TempDir,
pub subdir: Option<PathBuf>,
edit in libflorescence/src/repo.rs at line 1

[4.7]

[7.7]

#[cfg(test)]
mod test;
edit in libflorescence/src/repo.rs at line 179

[8.263]

[6.791]

#[derive(Debug)]
pub enum LoadError {
DoesntExist,
NotPijulRepo,
Inaccessible(std::io::Error),
}
replacement in libflorescence/src/repo.rs at line 193

[6.1027]→[9.90:187](∅→∅),[9.187]→[6.1098:1130](∅→∅),[6.1098]→[6.1098:1130](∅→∅)

let (mut internal_state, state) =
spawn_blocking(move || load(path)).await.unwrap();
// dbg!(diff(&state.repo));

[6.1027]

[4.529]

match spawn_blocking(move || load(path)).await.unwrap() {
Ok((mut internal_state, state)) => {
// dbg!(diff(&state.repo));
replacement in libflorescence/src/repo.rs at line 197

[4.530]→[9.188:238](∅→∅)

let _ = msg_out_tx.send(MsgOut::Init(state));

[4.530]

[6.1485]

let _ = msg_out_tx.send(MsgOut::Init(state));
replacement in libflorescence/src/repo.rs at line 199

[6.1486]→[7.554:647](∅→∅),[7.647]→[9.239:312](∅→∅)

while let Some(msg) = msg_in_rx.recv().await {
info!("Repo received msg {msg}");
internal_state = update(internal_state, msg, &msg_out_tx).await;

[6.1486]

[4.589]

while let Some(msg) = msg_in_rx.recv().await {
info!("Repo received msg {msg}");
internal_state = update(internal_state, msg, &msg_out_tx).await;
}
}
Err(_err) => {
// let _ = msg_out_tx.send(MsgOut::CannotLoad{err, msg_in_rx}));
}
replacement in libflorescence/src/repo.rs at line 276

[4.663]→[9.1393:1444](∅→∅),[9.1444]→[5.151:217](∅→∅),[6.3101]→[5.151:217](∅→∅),[4.701]→[5.151:217](∅→∅)

fn load(path: PathBuf) -> (InternalState, State) {
let repo = pijul::Repository::find_root(Some(path)).unwrap();

[4.663]

[9.1445]

fn load(path: PathBuf) -> Result<(InternalState, State), LoadError> {
match std::fs::exists(&path) {
Ok(true) => {}
Ok(false) => return Err(LoadError::DoesntExist),
Err(e) => return Err(LoadError::Inaccessible(e)),
}
let repo = pijul::Repository::find_root(Some(path))
.map_err(|_e| LoadError::NotPijulRepo)?;
replacement in libflorescence/src/repo.rs at line 286

[9.1538]→[9.1538:1566](∅→∅)

(internal_state, state)

[9.1538]

[9.1566]

Ok((internal_state, state))
edit in libflorescence/src/repo.rs at line 300

[9.1931]→[12.834:850](∅→∅)

dbg!(&log);
file addition: repo (d--r------)

[10.31]
file addition: test.rs (----------)

[0.1941]

use crate::repo;
use crate::testing::{repo_path, setup_pijul_repo, setup_pijul_repo_in_subdir};

use assert_matches::assert_matches;
use tempfile::tempdir;

#[test]
fn test_load_repo() {
// Handle a non-existent path gracefully
let dir = tempdir().unwrap();
let result =
repo::load(dir.path().join("howdoyouopensomethingthatdoesntexist"));
assert!(result.is_err());
assert_matches!(result.unwrap_err(), repo::LoadError::DoesntExist);

// Handle a path without a pijul repo gracefully
let dir = tempdir().unwrap();
let result = repo::load(dir.path().to_path_buf());
assert!(result.is_err());
assert_matches!(result.unwrap_err(), repo::LoadError::NotPijulRepo);

#[cfg(unix)]
{
// Handle an inaccessible path due to permissions gracefully
let subdir = "inaccessible";
let repo = setup_pijul_repo_in_subdir(subdir);
let repo_path = repo_path(&repo);
// Make the dir inaccessible
std::fs::set_permissions(repo.rootdir.path(), <std::fs::Permissions as std::os::unix::fs::PermissionsExt>::from_mode(0o000)).unwrap();
assert!(std::fs::exists(&repo_path).is_err());

let result = repo::load(repo.rootdir.path().join(subdir).to_path_buf());
assert!(result.is_err());
assert_matches!(result.unwrap_err(), repo::LoadError::Inaccessible(_));
}

// A valid path with a repo
let repo = setup_pijul_repo();
let repo_path = repo_path(&repo);
let (_internal, state) = repo::load(repo_path.clone()).unwrap();
let repo::State {
dir_name,
channel,
untracked_files,
changed_files,
log,
} = state;
assert_eq!(
&dir_name,
&repo_path
.components()
.last()
.unwrap()
.as_os_str()
.to_string_lossy()
);
assert_eq!(&channel, libpijul::DEFAULT_CHANNEL);
assert_eq!(untracked_files.len(), 1);
assert!(untracked_files.contains(".ignore"));
assert!(changed_files.is_empty());
assert!(log.is_empty());
}
edit in libflorescence/Cargo.toml at line 77

[11.2409]

[11.2409]

[dev-dependencies.assert_matches]
workspace = true
replacement in inflorescence/src/test.rs at line 10

[12.1520]→[12.1520:1578](∅→∅)

setup_pijul_id, setup_pijul_repo, PijulId, PijulRepo,

[12.1520]

[12.1578]

repo_path, setup_pijul_id, setup_pijul_repo, PijulId, PijulRepo,
replacement in inflorescence/src/test.rs at line 27

[11.2749]→[11.2749:2786](∅→∅)

let repo_path = repo.dir.path();

[11.2749]

[11.2786]

let repo_path = repo_path(&repo);
replacement in inflorescence/src/test.rs at line 76

[12.2157]→[12.2157:2194](∅→∅)

let repo_path = repo.dir.path();

[12.2157]

[13.88]

let repo_path = repo_path(&repo);
replacement in inflorescence/src/test.rs at line 278

[13.388]→[13.388:425](∅→∅)

let repo_path = repo.dir.path();

[13.388]

[13.425]

let repo_path = repo_path(&repo);
replacement in inflorescence/src/test.rs at line 721

[12.4851]→[12.4851:4888](∅→∅)

let repo_path = repo.dir.path();

[12.4851]

[12.4888]

let repo_path = repo_path(&repo);
edit in Cargo.lock at line 3057

[2.44936]

[3.7656]

"assert_matches",