vikarti.anatra/polaris-mirror
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clean up browser tests

Browse source
This commit is contained in:
Antoine Gersant 2024-08-09 17:22:41 -07:00
parent 310e3b6c4d
commit 6b5c291cb7
2 changed files with 96 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

171
src/app/index/browser.rs
View file

@ -88,7 +88,7 @@ impl Browser {
return Err(Error::DirectoryNotFound(virtual_path.as_ref().to_owned())); return Err(Error::DirectoryNotFound(virtual_path.as_ref().to_owned()));
} }
Ok(self let mut files = self
.flattened .flattened
.predictive_search(path_components) .predictive_search(path_components)
.map(|c: TinyVec<[_; 8]>| -> PathBuf { .map(|c: TinyVec<[_; 8]>| -> PathBuf {
@ -98,7 +98,11 @@ impl Browser {
.join(std::path::MAIN_SEPARATOR_STR) .join(std::path::MAIN_SEPARATOR_STR)
.into() .into()
}) })
.collect::<Vec<_>>()) .collect::<Vec<_>>();
files.sort();
Ok(files)
} }
} }
@ -110,12 +114,13 @@ pub struct Builder {
impl Builder { impl Builder {
pub fn add_directory(&mut self, strings: &mut Rodeo, directory: scanner::Directory) { pub fn add_directory(&mut self, strings: &mut Rodeo, directory: scanner::Directory) {
let Some(virtual_path) = directory.virtual_path.get_or_intern(strings) else { let Some(virtual_path) = (&directory.virtual_path).get_or_intern(strings) else {
return; return;
}; };
let Some(virtual_parent) = directory let Some(virtual_parent) = directory
.virtual_parent .virtual_path
.parent()
.and_then(|p| p.get_or_intern(strings)) .and_then(|p| p.get_or_intern(strings))
else { else {
return; return;
@ -161,103 +166,117 @@ impl Builder {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use std::path::{Path, PathBuf}; use std::collections::HashSet;
use std::path::PathBuf;
use super::*; use super::*;
use crate::app::test;
use crate::test_name;
const TEST_MOUNT_NAME: &str = "root"; fn setup_test(songs: HashSet<PathBuf>) -> (Browser, RodeoReader) {
let mut strings = Rodeo::new();
let mut builder = Builder::default();
let directories = songs
.iter()
.flat_map(|k| k.parent().unwrap().ancestors())
.collect::<HashSet<_>>();
for directory in directories {
builder.add_directory(
&mut strings,
scanner::Directory {
virtual_path: directory.to_owned(),
},
);
}
for path in songs {
let mut song = scanner::Song::default();
song.virtual_path = path.clone();
song.virtual_parent = path.parent().unwrap().to_owned();
builder.add_song(&mut strings, &song);
}
let browser = builder.build();
let strings = strings.into_reader();
(browser, strings)
}
#[tokio::test] #[tokio::test]
async fn can_browse_top_level() { async fn can_browse_top_level() {
let mut ctx = test::ContextBuilder::new(test_name!()) let song_a = PathBuf::from_iter(["Music", "Iron Maiden", "Moonchild.mp3"]);
.mount(TEST_MOUNT_NAME, "test-data/small-collection") let (browser, strings) = setup_test(HashSet::from([song_a]));
.build() let files = browser.browse(&strings, PathBuf::new()).unwrap();
.await;
ctx.scanner.update().await.unwrap();
let root_path = Path::new(TEST_MOUNT_NAME);
let files = ctx.index_manager.browse(PathBuf::new()).await.unwrap();
assert_eq!(files.len(), 1); assert_eq!(files.len(), 1);
match files[0] { assert_eq!(files[0], File::Directory(PathBuf::from_iter(["Music"])));
File::Directory(ref d) => {
assert_eq!(d, &root_path)
}
_ => panic!("Expected directory"),
}
} }
#[tokio::test] #[tokio::test]
async fn can_browse_directory() { async fn can_browse_directory() {
let khemmis_path: PathBuf = [TEST_MOUNT_NAME, "Khemmis"].iter().collect(); let artist_directory = PathBuf::from_iter(["Music", "Iron Maiden"]);
let tobokegao_path: PathBuf = [TEST_MOUNT_NAME, "Tobokegao"].iter().collect();
let mut ctx = test::ContextBuilder::new(test_name!()) let (browser, strings) = setup_test(HashSet::from([
.mount(TEST_MOUNT_NAME, "test-data/small-collection") artist_directory.join("Infinite Dreams.mp3"),
.build() artist_directory.join("Moonchild.mp3"),
.await; ]));
ctx.scanner.update().await.unwrap();
let files = ctx let files = browser.browse(&strings, artist_directory.clone()).unwrap();
.index_manager
.browse(PathBuf::from(TEST_MOUNT_NAME))
.await
.unwrap();
assert_eq!(files.len(), 2); assert_eq!(
match files[0] { files,
File::Directory(ref d) => { [
assert_eq!(d, &khemmis_path) File::Song(artist_directory.join("Infinite Dreams.mp3")),
} File::Song(artist_directory.join("Moonchild.mp3"))
_ => panic!("Expected directory"), ]
} );
match files[1] {
File::Directory(ref d) => {
assert_eq!(d, &tobokegao_path)
}
_ => panic!("Expected directory"),
}
} }
#[tokio::test] #[tokio::test]
async fn can_flatten_root() { async fn can_flatten_root() {
let mut ctx = test::ContextBuilder::new(test_name!()) let song_a = PathBuf::from_iter(["Music", "Electronic", "Papua New Guinea.mp3"]);
.mount(TEST_MOUNT_NAME, "test-data/small-collection") let song_b = PathBuf::from_iter(["Music", "Metal", "Destiny.mp3"]);
.build() let song_c = PathBuf::from_iter(["Music", "Metal", "No Turning Back.mp3"]);
.await;
ctx.scanner.update().await.unwrap(); let (browser, strings) = setup_test(HashSet::from([
let songs = ctx song_a.clone(),
.index_manager song_b.clone(),
.flatten(PathBuf::from(TEST_MOUNT_NAME)) song_c.clone(),
.await ]));
.unwrap();
assert_eq!(songs.len(), 13); let files = browser.flatten(&strings, PathBuf::new()).unwrap();
assert_eq!(songs[0], Path::new("FIX ME"));
assert_eq!(files, [song_a, song_b, song_c]);
} }
#[tokio::test] #[tokio::test]
async fn can_flatten_directory() { async fn can_flatten_directory() {
let mut ctx = test::ContextBuilder::new(test_name!()) let electronic = PathBuf::from_iter(["Music", "Electronic"]);
.mount(TEST_MOUNT_NAME, "test-data/small-collection") let song_a = electronic.join(PathBuf::from_iter(["FSOL", "Papua New Guinea.mp3"]));
.build() let song_b = electronic.join(PathBuf::from_iter(["Kraftwerk", "Autobahn.mp3"]));
.await; let song_c = PathBuf::from_iter(["Music", "Metal", "Destiny.mp3"]);
ctx.scanner.update().await.unwrap();
let path: PathBuf = [TEST_MOUNT_NAME, "Tobokegao"].iter().collect(); let (browser, strings) = setup_test(HashSet::from([
let songs = ctx.index_manager.flatten(path).await.unwrap(); song_a.clone(),
assert_eq!(songs.len(), 8); song_b.clone(),
song_c.clone(),
]));
let files = browser.flatten(&strings, electronic).unwrap();
assert_eq!(files, [song_a, song_b]);
} }
#[tokio::test] #[tokio::test]
async fn can_flatten_directory_with_shared_prefix() { async fn can_flatten_directory_with_shared_prefix() {
let mut ctx = test::ContextBuilder::new(test_name!()) let directory_a = PathBuf::from_iter(["Music", "Therion", "Leviathan II"]);
.mount(TEST_MOUNT_NAME, "test-data/small-collection") let directory_b = PathBuf::from_iter(["Music", "Therion", "Leviathan III"]);
.build() let song_a = directory_a.join("Pazuzu.mp3");
.await; let song_b = directory_b.join("Ninkigal.mp3");
ctx.scanner.update().await.unwrap();
let path: PathBuf = [TEST_MOUNT_NAME, "Tobokegao", "Picnic"].iter().collect(); // Prefix of '(Picnic Remixes)' let (browser, strings) = setup_test(HashSet::from([song_a.clone(), song_b.clone()]));
let songs = ctx.index_manager.flatten(path).await.unwrap();
assert_eq!(songs.len(), 7); let files = browser.flatten(&strings, directory_a).unwrap();
assert_eq!(files, [song_a]);
} }
} }

4
src/app/scanner.rs
View file

@ -16,10 +16,9 @@ use crate::app::{formats, index, settings, vfs, Error};
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq)]
pub struct Directory { pub struct Directory {
pub virtual_path: PathBuf, pub virtual_path: PathBuf,
pub virtual_parent: Option<PathBuf>,
} }
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, Default, PartialEq, Eq)]
pub struct Song { pub struct Song {
pub path: PathBuf, pub path: PathBuf,
pub virtual_path: PathBuf, pub virtual_path: PathBuf,
@ -317,7 +316,6 @@ fn process_directory<P: AsRef<Path>, Q: AsRef<Path>>(
directories_output directories_output
.send(Directory { .send(Directory {
virtual_path: virtual_path.as_ref().to_owned(), virtual_path: virtual_path.as_ref().to_owned(),
virtual_parent: virtual_path.as_ref().parent().map(Path::to_owned),
}) })
.ok(); .ok();
} }