#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::indexing_slicing,
clippy::as_conversions,
clippy::cast_possible_truncation
)]
use std::net::Ipv4Addr;
use std::path::{Path, PathBuf};
use std::sync::{Arc, RwLock};
use prolink::consume::{DbClient, DbConfig, NfsClient};
use prolink::serve::dbserver::{DbServer, DbServerConfig};
use prolink::serve::nfs::{NfsConfig as ServerNfsConfig, NfsServer};
use prolink::serve::{Medium, ServedSlot, Vfs};
use prolink::{BrowsableDeviceNumber, Slot};
use prolink_proto::dbserver::{
CamelotKey, Drill, ItemType, MediaInfo, MenuTarget, MessageKind, SortOrder, TrackType,
};
use prolink_rekordbox::Library;
const LOOPBACK: Ipv4Addr = Ipv4Addr::LOCALHOST;
fn export_pdb() -> Vec<u8> {
let path = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../testdata/export.pdb");
std::fs::read(path).expect("the committed rekordbox export")
}
fn library() -> Library {
Library::parse(&export_pdb()).expect("it parses")
}
fn device(number: u8) -> BrowsableDeviceNumber {
BrowsableDeviceNumber::new(number).expect("a browsable device number")
}
async fn serve_usb() -> (DbServer, u16) {
let medium = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "TEST STICK"));
let server = DbServer::start(
DbServerConfig {
device: device(4),
address: LOOPBACK,
port: 0,
query_port: None,
},
[medium],
)
.await
.expect("the dbserver starts");
let port = server.port();
(server, port)
}
async fn client(port: u16) -> DbClient {
DbClient::connect_at(LOOPBACK, port, device(2), DbConfig::default())
.await
.expect("the client connects and introduces itself")
}
#[tokio::test]
async fn a_client_sees_the_root_menu_a_deck_would_see() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let root = client.root_menu(Slot::USB).await.expect("the root menu");
let labels: Vec<&str> = root
.iter()
.filter_map(|item| prolink_proto::dbserver::unwrap_menu_label(&item.label1))
.collect();
for expected in ["ARTIST", "ALBUM", "TRACK", "GENRE", "KEY", "PLAYLIST"] {
assert!(labels.contains(&expected), "no {expected} in {labels:?}");
}
assert!(
root.iter().all(|item| item.flags == 0),
"a category is not openable as a track"
);
assert!(
root.iter().all(|item| item.label1.starts_with('\u{fffa}')),
"labels must be wrapped, or a deck renders them and then declines to open them (F26)",
);
}
#[tokio::test]
async fn a_client_can_list_every_track() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let tracks = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the track list");
assert_eq!(
tracks.len(),
library().tracks.len(),
"every track, paged 64 at a time"
);
assert!(
tracks.iter().all(|item| !item.label1.is_empty()),
"every row has a title"
);
}
#[tokio::test]
async fn the_sort_order_selects_the_second_column() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let by_artist = client
.tracks(Slot::USB, SortOrder::ARTIST)
.await
.expect("sorted by artist");
let first = by_artist.first().expect("a first row");
assert_eq!(first.item_type.0 & 0xff, 0x04);
assert_eq!(
first.item_type.0 >> 8,
ItemType::ARTIST.0,
"column 2 is the artist"
);
let by_bpm = client
.tracks(Slot::USB, SortOrder::BPM)
.await
.expect("sorted by BPM");
let first = by_bpm.first().expect("a first row");
assert_eq!(
first.item_type.0 >> 8,
ItemType::TEMPO.0,
"column 2 is the tempo"
);
assert!(
first.label2.is_empty(),
"a numeric column sends an empty label and the raw number in argument 0; the deck \
formats it",
);
let tempos: Vec<u32> = by_bpm.iter().map(|item| item.argument0).collect();
assert!(
tempos.windows(2).all(|pair| pair[0] <= pair[1]),
"and it really is sorted"
);
}
#[tokio::test]
async fn a_client_can_drill_from_a_category_to_tracks() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let artists = client
.category(Slot::USB, MessageKind::MENU_ARTIST, SortOrder::DEFAULT)
.await
.expect("the artists");
assert!(!artists.is_empty());
let artist = artists
.iter()
.find(|item| item.id != prolink_proto::dbserver::FILTER_ALL);
let artist = artist.expect("a real artist, not the ALL row");
let one_level_into_artist = Drill {
depth: 1,
category: u8::try_from(MessageKind::MENU_ARTIST.0 & 0xff).expect("a category byte"),
};
let albums = client
.drill(
Slot::USB,
one_level_into_artist,
SortOrder::DEFAULT,
&[artist.id],
)
.await
.expect("that artist's albums");
assert!(
!albums.is_empty(),
"an artist with no albums would not be listed"
);
}
#[tokio::test]
async fn searching_finds_a_track_that_is_there_and_none_that_is_not() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let library = library();
let sample = library
.tracks
.values()
.find(|track| track.title.len() > 4)
.expect("a track");
let term: String = sample.title.chars().take(4).collect();
let found = client
.search(Slot::USB, &term, SortOrder::DEFAULT)
.await
.expect("a search");
assert!(!found.is_empty(), "searching for {term:?} found nothing");
let missing = client
.search(Slot::USB, "zzzzz no such track zzzzz", SortOrder::DEFAULT)
.await
.expect("a search that matches nothing is still an answer");
assert!(missing.is_empty());
}
#[tokio::test]
async fn metadata_and_track_info_describe_the_same_track() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let library = library();
let track = library
.tracks
.values()
.find(|track| !track.title.is_empty() && !track.file_path.is_empty())
.expect("a track with a title and a path");
let metadata = client
.metadata(Slot::USB, track.id)
.await
.expect("its metadata");
assert_eq!(metadata.title, track.title);
assert_eq!(metadata.artist, track.artist);
assert_eq!(metadata.album, track.album);
assert_eq!(metadata.tempo_centibpm, track.tempo);
let info = client
.track_info(Slot::USB, track.id)
.await
.expect("its track info");
assert_eq!(info.path, track.file_path);
assert_eq!(
info.size,
u64::from(track.file_size),
"argument 0 of the path item is the size"
);
assert_eq!(info.container, u32::from(track.container.0));
}
#[tokio::test]
async fn a_dip_into_metadata_does_not_lose_the_list_being_scrolled() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let all = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the track list");
let victim = all.get(5).expect("a sixth row").id;
let _ = client
.metadata(Slot::USB, victim)
.await
.expect("a dip into metadata");
let again = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the list again");
assert_eq!(again.len(), all.len(), "the list survived the dip");
}
#[tokio::test]
async fn a_list_being_scrolled_survives_a_minute_of_metadata_polling() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let all = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the track list");
let ids: Vec<u32> = all.iter().take(40).map(|item| item.id).collect();
assert!(ids.len() >= 40, "need enough tracks to overflow the table");
for (polls, id) in ids.iter().enumerate() {
let _ = client
.metadata(Slot::USB, *id)
.await
.expect("a metadata dip");
if polls % 4 == 0 {
let again = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the list must still be there");
assert_eq!(
again.len(),
all.len(),
"the list vanished after {polls} metadata polls",
);
}
}
let after = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the list must still be there");
assert_eq!(
after.len(),
all.len(),
"the list did not survive the polling"
);
assert_eq!(
after.first().map(|item| item.id),
all.first().map(|item| item.id),
"and it is the same list, not another menu served in its place",
);
}
#[tokio::test]
async fn a_deck_asking_to_describe_the_medium_gets_a_description() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let descriptor = client.descriptor(Slot::USB, MenuTarget::BINARY, TrackType::REKORDBOX);
let request = prolink_proto::dbserver::Message::new(
0x0380_0001,
MessageKind::GET_MEDIA_INFO,
[prolink_proto::dbserver::Field::U32(descriptor.to_raw())],
);
let reply = client.request(request).await.expect("a reply");
assert_eq!(
reply.kind,
MessageKind::MEDIA_INFO,
"a bare SUCCESS here is what broke a real deck",
);
let body = reply.blob(3).expect("the 148-byte body");
assert_eq!(body.len(), MediaInfo::LEN);
let info = MediaInfo::parse(body).expect("it parses");
assert_eq!(info.volume_name, "TEST STICK");
assert_eq!(
info.track_count, 651,
"the true count, the same one the UDP media query is answered with",
);
}
#[tokio::test]
async fn every_track_row_carries_its_key_for_the_matching_indicator() {
let (_server, port) = serve_usb().await;
let mut client = client(port).await;
let rows = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the track list");
let library = library();
let mut checked = 0;
for row in &rows {
let Some(track) = library.tracks.get(&row.id) else {
continue;
};
let expected = CamelotKey::parse(&track.key).map_or(0, CamelotKey::index);
assert_eq!(
row.key_index, expected,
"track {} in key {:?}",
row.id, track.key
);
if expected != 0 {
checked += 1;
}
}
assert!(
checked > 100,
"only {checked} rows carried a key; the fixture should have plenty"
);
let indices: std::collections::BTreeSet<u32> = rows
.iter()
.map(|row| row.key_index)
.filter(|index| *index != 0)
.collect();
assert!(
indices.iter().all(|index| (1..=24).contains(index)),
"off the wheel: {indices:?}"
);
}
#[tokio::test]
async fn two_media_are_told_apart_by_the_descriptor_alone() {
let usb = Arc::new(Medium::synthetic(ServedSlot::USB, library(), "USB"));
let mut sd_library = library();
sd_library.tracks.retain(|id, _| *id % 2 == 0);
let sd = Arc::new(Medium::synthetic(ServedSlot::SD, sd_library, "SD"));
let server = DbServer::start(
DbServerConfig {
device: device(4),
address: LOOPBACK,
port: 0,
query_port: None,
},
[usb, sd],
)
.await
.expect("a two-slot dbserver");
let mut client = client(server.port()).await;
let from_usb = client
.tracks(Slot::USB, SortOrder::DEFAULT)
.await
.expect("the USB");
let from_sd = client
.tracks(Slot::SD, SortOrder::DEFAULT)
.await
.expect("the SD");
assert_eq!(from_usb.len(), library().tracks.len());
assert!(
from_sd.len() < from_usb.len(),
"the two slots really are different libraries"
);
assert!(!from_sd.is_empty());
}
fn fake_medium(test: &str) -> PathBuf {
let root = std::env::temp_dir().join(format!("prolink-loopback-{test}"));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("PIONEER/rekordbox")).expect("a temp medium");
std::fs::create_dir_all(root.join("Contents/GESAFFELSTEIN")).expect("a contents directory");
std::fs::write(root.join("PIONEER/rekordbox/export.pdb"), export_pdb()).expect("the database");
let audio: Vec<u8> = (0..40_960u32).map(|byte| byte as u8).collect();
std::fs::write(root.join("Contents/GESAFFELSTEIN/track.mp3"), &audio).expect("a track");
root
}
async fn serve_files(root: &Path) -> (NfsServer, u16) {
let mut tree = Vfs::new();
tree.mount(ServedSlot::USB.vfs_prefix(), root)
.expect("mounting the medium");
let server = NfsServer::start(
Arc::new(RwLock::new(tree)),
ServerNfsConfig {
interface: None,
portmap_port: 0,
mount_port: 0,
nfs_port: 0,
},
)
.await
.expect("the file servers start");
let portmap = server.ports().portmap;
(server, portmap)
}
#[tokio::test]
async fn a_client_pulls_the_database_back_byte_for_byte() {
let root = fake_medium("pull");
let (_server, portmap) = serve_files(&root).await;
let mut client = NfsClient::connect_with(
LOOPBACK,
None,
prolink::consume::NfsConfig {
portmap_port: portmap,
..Default::default()
},
)
.await
.expect("portmap discovery finds mountd and nfsd");
let mounted = client.mount_slot(Slot::USB).await.expect("mounting /C/");
let file = client
.open(&mounted, prolink::consume::nfs::EXPORT_PDB)
.await
.expect("walking to export.pdb");
let expected = export_pdb();
assert_eq!(file.size(), expected.len() as u64);
let pulled = client.read_file(&file).await.expect("the whole file");
assert_eq!(
pulled, expected,
"an export.pdb that differs by a byte is a different library"
);
let parsed = Library::parse(&pulled).expect("the pulled database parses");
assert_eq!(parsed.tracks.len(), library().tracks.len());
client
.unmount(&mounted)
.await
.expect("a real player unmounts, once per slot");
std::fs::remove_dir_all(&root).ok();
}
#[tokio::test]
async fn a_client_reads_a_track_in_ranges_the_way_a_deck_streams_one() {
let root = fake_medium("stream");
let (_server, portmap) = serve_files(&root).await;
let mut client = NfsClient::connect_with(
LOOPBACK,
None,
prolink::consume::NfsConfig {
portmap_port: portmap,
..Default::default()
},
)
.await
.expect("connecting");
let mounted = client.mount_slot(Slot::USB).await.expect("mounting");
let file = client
.open(&mounted, "/Contents/Gesaffelstein/track.mp3")
.await
.expect("a path whose case does not match the directory's");
assert_eq!(file.size(), 40_960);
let tail = client
.read_range(&file, 40_000, 960)
.await
.expect("a read near the end");
assert_eq!(tail.len(), 960);
assert_eq!(tail[0], 40_000_u32 as u8);
let middle = client
.read_range(&file, 16_384, 8_192)
.await
.expect("a read in the middle");
assert_eq!(middle.len(), 8_192);
assert_eq!(middle[0], 16_384_u32 as u8);
let past = client
.read_range(&file, 40_960, 4_096)
.await
.expect("a read past the end");
assert!(past.is_empty());
std::fs::remove_dir_all(&root).ok();
}
#[tokio::test]
async fn a_handle_whose_tail_a_cdj_rewrote_still_resolves() {
let root = fake_medium("handle");
let (_server, portmap) = serve_files(&root).await;
let mut client = NfsClient::connect_with(
LOOPBACK,
None,
prolink::consume::NfsConfig {
portmap_port: portmap,
..Default::default()
},
)
.await
.expect("connecting");
let mounted = client.mount_slot(Slot::USB).await.expect("mounting");
let file = client
.open(&mounted, prolink::consume::nfs::EXPORT_PDB)
.await
.expect("walking to the database");
let mut rewritten = file.handle();
rewritten.0[12..].copy_from_slice(&[
0x03, 0x01, 0x2d, 0x00, 0x00, 0x00, 0x1b, 0x58, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x01,
0x00, 0x00, 0x00, 0x01, 0x62,
]);
assert_ne!(rewritten, file.handle(), "the bytes really did change");
let attributes = client
.attributes(rewritten)
.await
.expect("the server must still know it");
assert_eq!(u64::from(attributes.size), file.size());
std::fs::remove_dir_all(&root).ok();
}
fn track_bytes() -> Vec<u8> {
(0..40_960u32).map(|byte| byte as u8).collect()
}
async fn open_track(root: &Path, portmap: u16) -> (NfsClient, prolink::consume::nfs::RemoteFile) {
let mut client = NfsClient::connect_with(
LOOPBACK,
None,
prolink::consume::NfsConfig {
portmap_port: portmap,
..Default::default()
},
)
.await
.expect("portmap discovery");
let _ = root;
let mounted = client.mount_slot(Slot::USB).await.expect("mounting");
let file = client
.open(&mounted, "/Contents/GESAFFELSTEIN/track.mp3")
.await
.expect("walking to the track");
(client, file)
}
#[tokio::test]
async fn a_range_read_returns_exactly_that_range() {
let root = fake_medium("range-exact");
let (_server, portmap) = serve_files(&root).await;
let (mut client, file) = open_track(&root, portmap).await;
let expected = track_bytes();
for (offset, len) in [
(0u64, 1u64),
(0, 8192),
(1, 8191),
(8191, 2),
(12_345, 1_000),
] {
let got = client
.read_range(&file, offset, len)
.await
.expect("a range read");
let want =
&expected[usize::try_from(offset).unwrap()..usize::try_from(offset + len).unwrap()];
assert_eq!(
got,
want,
"range {offset}..{} came back wrong",
offset + len
);
}
}
#[tokio::test]
async fn a_range_read_past_the_end_is_clamped_rather_than_failing() {
let root = fake_medium("range-clamp");
let (_server, portmap) = serve_files(&root).await;
let (mut client, file) = open_track(&root, portmap).await;
let got = client
.read_range(&file, 40_000, 10_000)
.await
.expect("a read that overruns the end");
assert_eq!(got.len(), 960, "clamped to what is actually there");
assert_eq!(got, &track_bytes()[40_000..]);
}
#[tokio::test]
async fn a_range_read_entirely_past_the_end_is_empty() {
let root = fake_medium("range-past");
let (_server, portmap) = serve_files(&root).await;
let (mut client, file) = open_track(&root, portmap).await;
let got = client
.read_range(&file, 40_960, 1_000)
.await
.expect("a read starting at the end");
assert!(got.is_empty());
}
#[tokio::test]
async fn the_tail_is_readable_before_the_middle_has_been_touched() {
let root = fake_medium("range-tail-first");
let (_server, portmap) = serve_files(&root).await;
let (mut client, file) = open_track(&root, portmap).await;
let expected = track_bytes();
let head = client.read_range(&file, 0, 4_096).await.expect("the head");
assert_eq!(head, &expected[..4_096]);
let tail = client
.read_range(&file, 40_960 - 256, 256)
.await
.expect("the tail, out of order");
assert_eq!(tail, &expected[40_960 - 256..]);
}
#[tokio::test]
async fn executing_a_plan_reconstructs_the_file_byte_for_byte() {
let root = fake_medium("range-plan");
let (_server, portmap) = serve_files(&root).await;
let (mut client, file) = open_track(&root, portmap).await;
let expected = track_bytes();
let plan = prolink::consume::nfs::progressive_plan(file.size(), 4_096, 256, 8_192);
assert!(plan.len() > 3, "a 40 KB file should take several steps");
let mut assembled = vec![0u8; usize::try_from(file.size()).unwrap()];
for step in &plan {
let bytes = client
.read_range(&file, step.offset, step.len)
.await
.unwrap_or_else(|error| panic!("fetching {step:?}: {error}"));
assert_eq!(
bytes.len() as u64,
step.len,
"{step:?} came back short, which would leave a hole"
);
let start = usize::try_from(step.offset).unwrap();
assembled[start..start + bytes.len()].copy_from_slice(&bytes);
}
assert_eq!(assembled, expected);
}
#[tokio::test]
async fn a_plan_over_a_tiny_file_still_reconstructs_it() {
let root = fake_medium("range-tiny");
std::fs::write(root.join("Contents/GESAFFELSTEIN/track.mp3"), b"short").expect("a tiny track");
let (_server, portmap) = serve_files(&root).await;
let (mut client, file) = open_track(&root, portmap).await;
assert_eq!(file.size(), 5);
let plan = prolink::consume::nfs::progressive_plan(file.size(), 4_096, 256, 8_192);
let mut assembled = Vec::new();
for step in &plan {
assembled.extend(
client
.read_range(&file, step.offset, step.len)
.await
.expect("a step"),
);
}
assert_eq!(assembled, b"short");
}
fn tagged_wav() -> Vec<u8> {
fn chunk(id: [u8; 4], body: &[u8]) -> Vec<u8> {
let mut out = id.to_vec();
out.extend_from_slice(&(body.len() as u32).to_le_bytes());
out.extend_from_slice(body);
if body.len() % 2 == 1 {
out.push(0);
}
out
}
let mut format = Vec::new();
for word in [1u16, 2] {
format.extend_from_slice(&word.to_le_bytes());
}
format.extend_from_slice(&44_100u32.to_le_bytes());
format.extend_from_slice(&(44_100u32 * 4).to_le_bytes());
format.extend_from_slice(&4u16.to_le_bytes());
format.extend_from_slice(&16u16.to_le_bytes());
let mut info = b"INFO".to_vec();
for (id, text) in [
(b"INAM", "Title Tag"),
(b"IART", "Artist Tag"),
(b"IGNR", "Techno"),
(b"ICMT", "A comment"),
] {
let mut value = text.as_bytes().to_vec();
value.push(0);
info.extend(chunk(*id, &value));
}
let mut body = b"WAVE".to_vec();
body.extend(chunk(*b"fmt ", &format));
body.extend(chunk(*b"LIST", &info));
body.extend(chunk(*b"data", &vec![0u8; 44_100 * 4 * 2]));
chunk(*b"RIFF", &body)
}
fn plain_stick(test: &str) -> PathBuf {
let root = std::env::temp_dir().join(format!("prolink-loopback-plain-{test}"));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("Music")).expect("a folder");
std::fs::write(root.join("Music/Tagged.wav"), tagged_wav()).expect("a WAV");
std::fs::write(
root.join("Music/cover.jpg"),
[0xff, 0xd8, 0xff, 0xe0, 1, 2, 3],
)
.expect("a cover");
std::fs::write(root.join("Untagged.mp3"), [0x55u8; 4096]).expect("an untagged file");
root
}
#[tokio::test]
async fn a_plain_stick_is_browsed_and_read_the_way_a_cdj_reads_one() {
let root = plain_stick("browse");
let medium = Arc::new(Medium::from_folders(&root, ServedSlot::USB).expect("a plain medium"));
assert!(medium.is_plain());
let server = DbServer::start(
DbServerConfig {
device: device(4),
address: LOOPBACK,
port: 0,
query_port: None,
},
[Arc::clone(&medium)],
)
.await
.expect("the dbserver starts");
let mut db = client(server.port()).await;
let root_menu = db.root_menu(Slot::USB).await.expect("the root menu");
assert_eq!(root_menu.len(), 1);
assert_eq!(root_menu[0].item_type, ItemType::MENU_FOLDER);
let top = db
.folder(Slot::USB, prolink_proto::dbserver::FILTER_ALL)
.await
.expect("the top of the stick");
let labels: Vec<&str> = top.iter().map(|row| row.label1.as_str()).collect();
assert_eq!(labels, ["Music", "Untagged.mp3"]);
assert_eq!(top[0].item_type, ItemType::FOLDER);
let music = db.folder(Slot::USB, top[0].id).await.expect("Music");
assert_eq!(music.len(), 1);
let wav = music[0].id;
assert_eq!(
music[0].label1, "Tagged.wav",
"a file row shows its file name"
);
let metadata = db
.generic_metadata(Slot::USB, wav)
.await
.expect("its metadata");
assert_eq!(metadata.title, "Title Tag");
assert_eq!(metadata.artist, "Artist Tag");
assert_eq!(metadata.genre, "Techno");
assert_eq!(metadata.comment, "A comment");
assert_eq!(metadata.duration_seconds, 2);
assert_eq!(metadata.bitrate, 1411);
assert_eq!(metadata.artwork_id, wav);
let untagged = db
.generic_metadata(Slot::USB, top[1].id)
.await
.expect("an untagged file's");
assert_eq!(untagged.title, "Untagged.mp3", "named by its file name");
let cover = db.plain_artwork(Slot::USB, wav).await.expect("its cover");
assert_eq!(cover, [0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]);
let info = db
.plain_track_info(Slot::USB, wav)
.await
.expect("its track info");
assert!(info.path.is_empty());
assert_eq!(info.container, 11, "WAV");
let (folder, entry) = info.plain_lookup.expect("the numbers");
assert_eq!(info.size, tagged_wav().len() as u64);
let mut tree = Vfs::new();
tree.mount_medium(&medium).expect("mounting the stick");
let files = NfsServer::start(
Arc::new(RwLock::new(tree)),
ServerNfsConfig {
interface: None,
portmap_port: 0,
mount_port: 0,
nfs_port: 0,
},
)
.await
.expect("the file servers start");
let mut nfs = NfsClient::connect_with(
LOOPBACK,
None,
prolink::consume::NfsConfig {
portmap_port: files.ports().portmap,
..Default::default()
},
)
.await
.expect("connecting");
let mounted = nfs.mount_slot(Slot::USB).await.expect("mounting /C/");
let file = nfs
.open_plain(&mounted, folder, entry)
.await
.expect("the file, by its two numbers");
assert_eq!(file.size(), info.size);
let head = nfs.read_range(&file, 0, 12).await.expect("its head");
assert_eq!(&head[..4], b"RIFF");
assert_eq!(&head[8..12], b"WAVE");
assert!(
nfs.open_plain(&mounted, folder, entry + 1).await.is_err(),
"another entry of that folder is no file"
);
std::fs::remove_dir_all(&root).ok();
}