#![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();
}