feat(api): move title folders on root path change
Changing a root's path rewrote the row and moved nothing, so every title under it was mislocated at once. It now reuses the #228 mover: plan every rename, refuse a destination that already exists, rewrite the media_files rows in the same transaction as the row change. The move is all or nothing. A root row carries one path, so a half-moved library would have to describe both places; instead one folder that cannot move puts back the ones that already did and leaves the root's path alone, and the same request is the retry. just ci ran clean through the gate: 498 tests passed.
This commit is contained in:
+450
-23
@@ -172,26 +172,74 @@ pub async fn update(
|
||||
let input = parsed(body)?;
|
||||
input.validate().map_err(ApiError::Invalid)?;
|
||||
input.policy_exists(&state).await?;
|
||||
let current = load_root(&state, id).await?;
|
||||
let path = input.path.trim().to_owned();
|
||||
let result = sqlx::query!(
|
||||
r#"UPDATE roots SET kind = ?, audience = ?, path = ?, policy_id = ?,
|
||||
updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
|
||||
WHERE id = ?"#,
|
||||
input.kind,
|
||||
input.audience,
|
||||
path,
|
||||
input.policy_id,
|
||||
id,
|
||||
)
|
||||
.execute(pool(&state)?)
|
||||
.await
|
||||
.map_err(root_conflict)?;
|
||||
if result.rows_affected() == 0 {
|
||||
return Err(ApiError::RootNotFound);
|
||||
// A path change moves every §7.4 title folder under this root with the
|
||||
// row (issue #236), the same way changing a title's root moves one
|
||||
// (#228). Disk first, row second: a failed rename leaves the root row
|
||||
// alone, so the operator sees the library where its files actually are
|
||||
// and can retry. A path already taken is refused before any of it, since
|
||||
// the write would fail afterwards anyway.
|
||||
let relocation = if path == current.path {
|
||||
None
|
||||
} else {
|
||||
path_is_free(&state, id, &path).await?;
|
||||
Some(crate::relocate::relocate_root(&state, id, ¤t.path, &path).await?)
|
||||
};
|
||||
let mut transaction = pool(&state)?.begin().await?;
|
||||
let written: Result<(), sqlx::Error> = async {
|
||||
sqlx::query!(
|
||||
r#"UPDATE roots SET kind = ?, audience = ?, path = ?, policy_id = ?,
|
||||
updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
|
||||
WHERE id = ?"#,
|
||||
input.kind,
|
||||
input.audience,
|
||||
path,
|
||||
input.policy_id,
|
||||
id,
|
||||
)
|
||||
.execute(&mut *transaction)
|
||||
.await?;
|
||||
if let Some(relocation) = &relocation {
|
||||
relocation.rewrite_rows(&mut transaction).await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
.await;
|
||||
let committed = match written {
|
||||
Ok(()) => transaction.commit().await.map_err(root_conflict),
|
||||
Err(error) => Err(root_conflict(error)),
|
||||
};
|
||||
if let Err(error) = committed {
|
||||
if let Some(relocation) = &relocation {
|
||||
relocation.undo().await;
|
||||
}
|
||||
return Err(error);
|
||||
}
|
||||
if relocation
|
||||
.as_ref()
|
||||
.is_some_and(crate::relocate::Relocation::moved_files)
|
||||
{
|
||||
crate::relocate::refresh_jellyfin(&state).await;
|
||||
}
|
||||
Ok(Json(load_root(&state, id).await?))
|
||||
}
|
||||
|
||||
/// The unique index on `path` would catch this after the move; catching it
|
||||
/// first keeps a doomed write from touching the disk at all.
|
||||
async fn path_is_free(state: &AppState, id: i64, path: &str) -> Result<(), ApiError> {
|
||||
let taken: Option<i64> =
|
||||
sqlx::query_scalar!("SELECT id FROM roots WHERE path = ? AND id <> ?", path, id)
|
||||
.fetch_optional(pool(state)?)
|
||||
.await?;
|
||||
if taken.is_some() {
|
||||
return Err(ApiError::Conflict(
|
||||
"a root with this path already exists".into(),
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// A duplicate path or a duplicate (kind, audience) pair is a settings
|
||||
/// mistake the operator can fix, not a server fault.
|
||||
fn root_conflict(error: sqlx::Error) -> ApiError {
|
||||
@@ -258,7 +306,7 @@ mod tests {
|
||||
use crate::{router, AppState, Upstreams};
|
||||
use axum::http::StatusCode;
|
||||
|
||||
async fn application() -> (tempfile::TempDir, String) {
|
||||
async fn application() -> (tempfile::TempDir, AppState, String) {
|
||||
let dir = tempfile::tempdir().expect("tempdir");
|
||||
let database = arr_db::Db::connect(dir.path().join("arr.db"))
|
||||
.await
|
||||
@@ -274,14 +322,14 @@ mod tests {
|
||||
.await
|
||||
.expect("bind");
|
||||
let address = listener.local_addr().expect("address");
|
||||
let app = router(state);
|
||||
let app = router(state.clone());
|
||||
tokio::spawn(async move { axum::serve(listener, app).await.expect("serve") });
|
||||
(dir, format!("http://{address}"))
|
||||
(dir, state, format!("http://{address}"))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn roots_carry_their_policy_name() {
|
||||
let (_dir, base) = application().await;
|
||||
let (_dir, _state, base) = application().await;
|
||||
let roots: Vec<serde_json::Value> = reqwest::get(format!("{base}/api/roots"))
|
||||
.await
|
||||
.expect("roots")
|
||||
@@ -325,7 +373,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_root_round_trips_through_create_and_update() {
|
||||
let (_dir, base) = application().await;
|
||||
let (_dir, _state, base) = application().await;
|
||||
let policy_ids = first_policy_ids(&base).await;
|
||||
let roots: Vec<serde_json::Value> = reqwest::get(format!("{base}/api/roots"))
|
||||
.await
|
||||
@@ -399,7 +447,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn an_unknown_kind_or_policy_is_a_422_naming_the_field() {
|
||||
let (_dir, base) = application().await;
|
||||
let (_dir, _state, base) = application().await;
|
||||
let policy_ids = first_policy_ids(&base).await;
|
||||
|
||||
for (mut payload, field) in [
|
||||
@@ -428,7 +476,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_duplicate_path_or_pair_conflicts() {
|
||||
let (_dir, base) = application().await;
|
||||
let (_dir, _state, base) = application().await;
|
||||
let mut path = root_input(1);
|
||||
path["audience"] = serde_json::json!("kids");
|
||||
path["path"] = serde_json::json!("/mnt/media/movies/kids");
|
||||
@@ -454,7 +502,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_root_with_titles_refuses_to_die() {
|
||||
let (_dir, base) = application().await;
|
||||
let (_dir, _state, base) = application().await;
|
||||
let roots: Vec<serde_json::Value> = reqwest::get(format!("{base}/api/roots"))
|
||||
.await
|
||||
.expect("roots")
|
||||
@@ -495,4 +543,383 @@ mod tests {
|
||||
.expect("delete empty root");
|
||||
assert_eq!(response.status(), StatusCode::NO_CONTENT);
|
||||
}
|
||||
|
||||
async fn point_root_at(state: &AppState, root_id: i64, path: &std::path::Path) {
|
||||
sqlx::query("UPDATE roots SET path = ? WHERE id = ?")
|
||||
.bind(path.to_str().expect("utf-8 root"))
|
||||
.bind(root_id)
|
||||
.execute(state.database().expect("database").pool())
|
||||
.await
|
||||
.expect("point the root at the tempdir");
|
||||
}
|
||||
|
||||
async fn add_movie(base: &str, tmdb_id: i64, title: &str, root_id: i64) -> i64 {
|
||||
let created: serde_json::Value = reqwest::Client::new()
|
||||
.post(format!("{base}/api/movies"))
|
||||
.json(&serde_json::json!({
|
||||
"tmdb_id": tmdb_id, "title": title, "year": 2024,
|
||||
"original_language": "en", "root_id": root_id,
|
||||
}))
|
||||
.send()
|
||||
.await
|
||||
.expect("create movie")
|
||||
.json()
|
||||
.await
|
||||
.expect("movie json");
|
||||
created["id"].as_i64().expect("movie id")
|
||||
}
|
||||
|
||||
/// One movie's §7.4 folder on disk with a feature in it, and the
|
||||
/// `media_files` row that points at the feature.
|
||||
async fn library_folder(
|
||||
state: &AppState,
|
||||
movie_id: i64,
|
||||
root: &std::path::Path,
|
||||
folder: &str,
|
||||
) -> std::path::PathBuf {
|
||||
let folder = root.join(folder);
|
||||
tokio::fs::create_dir_all(&folder)
|
||||
.await
|
||||
.expect("create title folder");
|
||||
let feature = folder.join("feature.mkv");
|
||||
tokio::fs::write(&feature, b"feature").await.expect("write");
|
||||
sqlx::query(
|
||||
"INSERT INTO media_files (owner_kind, owner_id, path, size) VALUES ('movie', ?, ?, 7)",
|
||||
)
|
||||
.bind(movie_id)
|
||||
.bind(feature.to_str().expect("utf-8 path"))
|
||||
.execute(state.database().expect("database").pool())
|
||||
.await
|
||||
.expect("media file");
|
||||
folder
|
||||
}
|
||||
|
||||
async fn root_payload(base: &str, id: i64, path: &str) -> serde_json::Value {
|
||||
let root: serde_json::Value = reqwest::get(format!("{base}/api/roots/{id}"))
|
||||
.await
|
||||
.expect("root")
|
||||
.json()
|
||||
.await
|
||||
.expect("root json");
|
||||
serde_json::json!({
|
||||
"kind": root["kind"],
|
||||
"audience": root["audience"],
|
||||
"path": path,
|
||||
"policy_id": root["policy_id"],
|
||||
})
|
||||
}
|
||||
|
||||
async fn file_paths(state: &AppState) -> Vec<String> {
|
||||
sqlx::query_scalar("SELECT path FROM media_files ORDER BY id")
|
||||
.fetch_all(state.database().expect("database").pool())
|
||||
.await
|
||||
.expect("media files")
|
||||
}
|
||||
|
||||
async fn stored_path(base: &str, id: i64) -> String {
|
||||
let root: serde_json::Value = reqwest::get(format!("{base}/api/roots/{id}"))
|
||||
.await
|
||||
.expect("root")
|
||||
.json()
|
||||
.await
|
||||
.expect("root json");
|
||||
root["path"].as_str().expect("path").to_owned()
|
||||
}
|
||||
|
||||
/// Issue #236: changing a root's path renames every §7.4 title folder
|
||||
/// under it into the new path and rewrites the `media_files` rows in the
|
||||
/// same write. Titles under other roots are not this root's business.
|
||||
#[tokio::test]
|
||||
async fn changing_a_root_path_moves_every_title_under_it() {
|
||||
let (_dir, state, base) = application().await;
|
||||
let old = tempfile::tempdir().expect("old root");
|
||||
let other = tempfile::tempdir().expect("other root");
|
||||
point_root_at(&state, 1, old.path()).await;
|
||||
point_root_at(&state, 2, other.path()).await;
|
||||
|
||||
let mut folders = Vec::new();
|
||||
for (tmdb_id, title) in [(100, "Dune"), (101, "Arrival"), (102, "Sicario")] {
|
||||
let id = add_movie(&base, tmdb_id, title, 1).await;
|
||||
folders.push(library_folder(&state, id, old.path(), title).await);
|
||||
}
|
||||
let elsewhere = add_movie(&base, 200, "Prisoners", 2).await;
|
||||
let untouched = library_folder(&state, elsewhere, other.path(), "Prisoners").await;
|
||||
|
||||
// The new path need not exist yet — pointing a root somewhere fresh
|
||||
// is the ordinary case.
|
||||
let new = old.path().parent().expect("parent").join("relocated-main");
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/1"))
|
||||
.json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("move the root");
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
|
||||
for folder in &folders {
|
||||
assert!(!folder.exists(), "{} left the old path", folder.display());
|
||||
}
|
||||
for title in ["Dune", "Arrival", "Sicario"] {
|
||||
assert!(
|
||||
new.join(title).join("feature.mkv").exists(),
|
||||
"{title} arrived under the new path"
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
untouched.join("feature.mkv").exists(),
|
||||
"a title under another root is untouched"
|
||||
);
|
||||
|
||||
let paths = file_paths(&state).await;
|
||||
for path in paths.iter().take(3) {
|
||||
assert!(
|
||||
std::path::Path::new(path).starts_with(&new),
|
||||
"the row follows the file: {path}"
|
||||
);
|
||||
assert!(
|
||||
std::path::Path::new(path).exists(),
|
||||
"the rewritten path describes the disk: {path}"
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
std::path::Path::new(&paths[3]).starts_with(other.path()),
|
||||
"the other root's row is untouched: {}",
|
||||
paths[3]
|
||||
);
|
||||
assert_eq!(stored_path(&base, 1).await, new.to_str().expect("utf-8"));
|
||||
|
||||
tokio::fs::remove_dir_all(&new).await.expect("clean up");
|
||||
}
|
||||
|
||||
/// Issue #236: a root with nothing under it changes path with no
|
||||
/// filesystem work at all — the new path is not even created.
|
||||
#[tokio::test]
|
||||
async fn an_empty_root_changes_path_with_no_filesystem_work() {
|
||||
let (_dir, state, base) = application().await;
|
||||
let home = tempfile::tempdir().expect("home");
|
||||
let new = home.path().join("nothing-here");
|
||||
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/1"))
|
||||
.json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("move the root");
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
assert_eq!(stored_path(&base, 1).await, new.to_str().expect("utf-8"));
|
||||
assert!(!new.exists(), "nothing was created on disk");
|
||||
assert!(file_paths(&state).await.is_empty());
|
||||
}
|
||||
|
||||
/// Issue #236: a destination already holding a folder of that name is a
|
||||
/// conflict, not an overwrite, and it is caught before anything moves.
|
||||
#[tokio::test]
|
||||
async fn a_squatted_destination_refuses_the_whole_move() {
|
||||
let (_dir, state, base) = application().await;
|
||||
let old = tempfile::tempdir().expect("old root");
|
||||
let new = tempfile::tempdir().expect("new root");
|
||||
point_root_at(&state, 1, old.path()).await;
|
||||
|
||||
let first = add_movie(&base, 100, "Dune", 1).await;
|
||||
let second = add_movie(&base, 101, "Arrival", 1).await;
|
||||
let dune = library_folder(&state, first, old.path(), "Dune").await;
|
||||
let arrival = library_folder(&state, second, old.path(), "Arrival").await;
|
||||
tokio::fs::create_dir_all(new.path().join("Arrival"))
|
||||
.await
|
||||
.expect("squatter");
|
||||
|
||||
let before = file_paths(&state).await;
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/1"))
|
||||
.json(&root_payload(&base, 1, new.path().to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("move the root");
|
||||
assert_eq!(response.status(), StatusCode::CONFLICT);
|
||||
|
||||
assert!(dune.exists(), "not even the first folder moved");
|
||||
assert!(arrival.exists());
|
||||
assert_eq!(file_paths(&state).await, before, "the rows are untouched");
|
||||
assert_eq!(
|
||||
stored_path(&base, 1).await,
|
||||
old.path().to_str().expect("utf-8"),
|
||||
"the root still points where the files are"
|
||||
);
|
||||
}
|
||||
|
||||
/// Issue #236: the move is all or nothing. A folder that cannot be
|
||||
/// renamed part-way through takes the whole change down: what had already
|
||||
/// moved is moved back, the root row keeps the old path, and the rows
|
||||
/// still describe the disk, so the operator can fix the folder and send
|
||||
/// the same request again.
|
||||
#[cfg(unix)]
|
||||
#[tokio::test]
|
||||
async fn one_folder_that_cannot_move_puts_the_others_back() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
let (_dir, state, base) = application().await;
|
||||
let old = tempfile::tempdir().expect("old root");
|
||||
let home = tempfile::tempdir().expect("home of the new path");
|
||||
let new = home.path().join("relocated-main");
|
||||
point_root_at(&state, 1, old.path()).await;
|
||||
|
||||
let mut folders = Vec::new();
|
||||
for (tmdb_id, title) in [(100, "Dune"), (101, "Arrival"), (102, "Sicario")] {
|
||||
let id = add_movie(&base, tmdb_id, title, 1).await;
|
||||
folders.push(library_folder(&state, id, old.path(), title).await);
|
||||
}
|
||||
// Moving a directory to another parent rewrites its `..`, which needs
|
||||
// write permission on the directory itself: the second title cannot
|
||||
// move, the first already has.
|
||||
let stuck = folders[1].clone();
|
||||
tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o555))
|
||||
.await
|
||||
.expect("freeze the second title folder");
|
||||
|
||||
let before = file_paths(&state).await;
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/1"))
|
||||
.json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("move the root");
|
||||
assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
|
||||
let body: serde_json::Value = response.json().await.expect("error body");
|
||||
assert!(
|
||||
body["error"]
|
||||
.as_str()
|
||||
.expect("text")
|
||||
.contains(stuck.to_str().expect("utf-8")),
|
||||
"the error names the folder that stopped the move: {body}"
|
||||
);
|
||||
|
||||
tokio::fs::set_permissions(&stuck, std::fs::Permissions::from_mode(0o755))
|
||||
.await
|
||||
.expect("thaw the second title folder");
|
||||
for folder in &folders {
|
||||
assert!(
|
||||
folder.join("feature.mkv").exists(),
|
||||
"{} is back where the row says it is",
|
||||
folder.display()
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
new.exists(),
|
||||
"the move reached the disk: the new path was created for it"
|
||||
);
|
||||
assert!(
|
||||
!new.join("Dune").exists(),
|
||||
"the folder that had already moved was moved back"
|
||||
);
|
||||
assert_eq!(file_paths(&state).await, before, "the rows are untouched");
|
||||
assert_eq!(
|
||||
stored_path(&base, 1).await,
|
||||
old.path().to_str().expect("utf-8"),
|
||||
"the root still points where the files are"
|
||||
);
|
||||
|
||||
// The same request again, with the folder fixed, is the retry path.
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/1"))
|
||||
.json(&root_payload(&base, 1, new.to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("retry the move");
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
for title in ["Dune", "Arrival", "Sicario"] {
|
||||
assert!(new.join(title).join("feature.mkv").exists());
|
||||
}
|
||||
}
|
||||
|
||||
/// Issue #236: a TV root carries series folders, whose files hang off
|
||||
/// episodes rather than off the title row. They move with the root too.
|
||||
#[tokio::test]
|
||||
async fn a_tv_root_moves_its_series_folders() {
|
||||
let (_dir, state, base) = application().await;
|
||||
let old = tempfile::tempdir().expect("old root");
|
||||
let home = tempfile::tempdir().expect("home of the new path");
|
||||
let new = home.path().join("relocated-tv");
|
||||
point_root_at(&state, 3, old.path()).await;
|
||||
|
||||
let pool = state.database().expect("database").pool();
|
||||
sqlx::query(
|
||||
"INSERT INTO series (id, tmdb_id, title, year, original_language, root_id)
|
||||
VALUES (1, 82728, 'Bluey', 2018, 'en', 3)",
|
||||
)
|
||||
.execute(pool)
|
||||
.await
|
||||
.expect("series");
|
||||
sqlx::query("INSERT INTO seasons (id, series_id, number) VALUES (1, 1, 1)")
|
||||
.execute(pool)
|
||||
.await
|
||||
.expect("season");
|
||||
sqlx::query(
|
||||
"INSERT INTO episodes (id, season_id, number, title) VALUES (1, 1, 2, 'Hospital')",
|
||||
)
|
||||
.execute(pool)
|
||||
.await
|
||||
.expect("episode");
|
||||
let season = old
|
||||
.path()
|
||||
.join("Bluey (2018) [tmdbid-82728]")
|
||||
.join("Season 01");
|
||||
tokio::fs::create_dir_all(&season)
|
||||
.await
|
||||
.expect("create season folder");
|
||||
let episode = season.join("Bluey - S01E02.mkv");
|
||||
tokio::fs::write(&episode, b"episode").await.expect("write");
|
||||
sqlx::query(
|
||||
"INSERT INTO media_files (owner_kind, owner_id, path, size) VALUES ('episode', 1, ?, 9)",
|
||||
)
|
||||
.bind(episode.to_str().expect("utf-8 path"))
|
||||
.execute(pool)
|
||||
.await
|
||||
.expect("media file");
|
||||
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/3"))
|
||||
.json(&root_payload(&base, 3, new.to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("move the root");
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
|
||||
assert!(
|
||||
new.join("Bluey (2018) [tmdbid-82728]")
|
||||
.join("Season 01")
|
||||
.join("Bluey - S01E02.mkv")
|
||||
.exists(),
|
||||
"the whole series folder moved, season layout intact"
|
||||
);
|
||||
let paths = file_paths(&state).await;
|
||||
assert!(
|
||||
std::path::Path::new(&paths[0]).starts_with(&new)
|
||||
&& std::path::Path::new(&paths[0]).exists(),
|
||||
"the episode row follows the file: {}",
|
||||
paths[0]
|
||||
);
|
||||
}
|
||||
|
||||
/// Issue #236: a path another root already holds is refused before the
|
||||
/// disk is touched at all.
|
||||
#[tokio::test]
|
||||
async fn a_path_another_root_holds_is_refused_before_any_move() {
|
||||
let (_dir, state, base) = application().await;
|
||||
let old = tempfile::tempdir().expect("old root");
|
||||
let taken = tempfile::tempdir().expect("taken root");
|
||||
point_root_at(&state, 1, old.path()).await;
|
||||
point_root_at(&state, 2, taken.path()).await;
|
||||
let id = add_movie(&base, 100, "Dune", 1).await;
|
||||
let folder = library_folder(&state, id, old.path(), "Dune").await;
|
||||
|
||||
let response = reqwest::Client::new()
|
||||
.put(format!("{base}/api/roots/1"))
|
||||
.json(&root_payload(&base, 1, taken.path().to_str().expect("utf-8")).await)
|
||||
.send()
|
||||
.await
|
||||
.expect("move the root");
|
||||
assert_eq!(response.status(), StatusCode::CONFLICT);
|
||||
assert!(folder.exists(), "nothing moved");
|
||||
assert!(!taken.path().join("Dune").exists());
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user