phoenix
68e6c4e025
All checks were successful
Release Tagging / release (push) Successful in 31s
Rust Build / Check (push) Successful in 26s
Rust Build / Test Suite (push) Successful in 27s
Rust Build / Rustfmt (push) Successful in 24s
Rust Build / Clippy (push) Successful in 26s
Rust Build / build (push) Successful in 30s
Rust Build / Check (pull_request) Successful in 27s
Rust Build / Test Suite (pull_request) Successful in 29s
Rust Build / Rustfmt (pull_request) Successful in 25s
Rust Build / Clippy (pull_request) Successful in 27s
Rust Build / build (pull_request) Successful in 33s
Reviewed-on: #30 Co-authored-by: phoenix <kundeng00@pm.me> Co-committed-by: phoenix <kundeng00@pm.me>
1262 lines
50 KiB
Rust
1262 lines
50 KiB
Rust
pub mod coverart {
|
|
|
|
use lofty::{file::AudioFile, ogg::OggPictureStorage};
|
|
|
|
pub fn set_coverart(
|
|
song_filepath: &String,
|
|
coverart_filepath: &String,
|
|
) -> Result<Vec<u8>, std::io::Error> {
|
|
let coverart_path = std::path::Path::new(coverart_filepath);
|
|
|
|
match std::fs::File::open(song_filepath) {
|
|
Ok(mut file) => {
|
|
match lofty::flac::FlacFile::read_from(
|
|
&mut file,
|
|
lofty::config::ParseOptions::new(),
|
|
) {
|
|
Ok(mut flac_file) => {
|
|
let mut coverart_file = std::fs::File::open(coverart_path).unwrap();
|
|
match lofty::picture::Picture::from_reader(&mut coverart_file) {
|
|
Ok(pic) => {
|
|
match lofty::picture::PictureInformation::from_picture(&pic) {
|
|
Ok(info) => {
|
|
flac_file.set_picture(0, pic.clone(), info);
|
|
Ok(pic.into_data())
|
|
}
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn get_coverart(song_filepath: &String) -> Result<Vec<u8>, std::io::Error> {
|
|
match std::fs::File::open(song_filepath) {
|
|
Ok(mut file) => {
|
|
match lofty::flac::FlacFile::read_from(
|
|
&mut file,
|
|
lofty::config::ParseOptions::new(),
|
|
) {
|
|
Ok(flac_file) => {
|
|
let pictures = flac_file.pictures();
|
|
let res = pictures.to_vec();
|
|
if !res.is_empty() {
|
|
let picture = &res[0];
|
|
Ok(picture.clone().0.into_data())
|
|
} else {
|
|
Ok(Vec::new())
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn contains_coverart(song_filepath: &String) -> Result<(bool, usize), std::io::Error> {
|
|
match std::fs::File::open(song_filepath) {
|
|
Ok(mut file) => {
|
|
match lofty::flac::FlacFile::read_from(
|
|
&mut file,
|
|
lofty::config::ParseOptions::new(),
|
|
) {
|
|
Ok(flac_file) => {
|
|
let pictures = flac_file.pictures();
|
|
if pictures.is_empty() {
|
|
Ok((false, 0))
|
|
} else {
|
|
let res = pictures.to_vec();
|
|
if res.is_empty() {
|
|
Ok((false, 0))
|
|
} else {
|
|
Ok((true, res.len()))
|
|
}
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn remove_coverart(song_filepath: &String) -> Result<Vec<u8>, std::io::Error> {
|
|
match std::fs::File::open(song_filepath) {
|
|
Ok(mut file) => {
|
|
match lofty::flac::FlacFile::read_from(
|
|
&mut file,
|
|
lofty::config::ParseOptions::new(),
|
|
) {
|
|
Ok(mut flac_file) => {
|
|
let pictures = flac_file.pictures();
|
|
let res = pictures.to_vec();
|
|
if !res.is_empty() {
|
|
let picture = &res[0];
|
|
flac_file.remove_picture(0);
|
|
Ok(picture.clone().0.into_data())
|
|
} else {
|
|
Err(std::io::Error::new(
|
|
std::io::ErrorKind::NotFound,
|
|
"No pictures found",
|
|
))
|
|
}
|
|
}
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub mod metadata {
|
|
use lofty::file::AudioFile;
|
|
use lofty::tag::Accessor;
|
|
use lofty::tag::TagExt;
|
|
|
|
use crate::types;
|
|
|
|
pub fn get_meta(t: types::Type, filepath: &String) -> Result<String, std::io::Error> {
|
|
match std::fs::File::open(filepath) {
|
|
Ok(mut content) => {
|
|
match lofty::flac::FlacFile::read_from(
|
|
&mut content,
|
|
lofty::config::ParseOptions::new(),
|
|
) {
|
|
Ok(flac_file) => match flac_file.vorbis_comments() {
|
|
Some(vb) => {
|
|
let type_str: String = types::access::get_type(t).unwrap();
|
|
match vb.get(&type_str) {
|
|
Some(val) => Ok(val.to_owned()),
|
|
None => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
"Could not get tag data",
|
|
)),
|
|
}
|
|
}
|
|
None => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
"No tags found",
|
|
)),
|
|
},
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn set_meta(
|
|
t: types::Type,
|
|
filepath: &String,
|
|
value: &String,
|
|
) -> Result<String, std::io::Error> {
|
|
match std::fs::File::open(filepath) {
|
|
Ok(mut content) => {
|
|
match lofty::flac::FlacFile::read_from(
|
|
&mut content,
|
|
lofty::config::ParseOptions::new(),
|
|
) {
|
|
Ok(mut flac_file) => match flac_file.vorbis_comments_mut() {
|
|
Some(vb) => {
|
|
let pre_value = value.clone();
|
|
match t {
|
|
types::Type::Album => {
|
|
vb.set_album(pre_value);
|
|
}
|
|
types::Type::AlbumArtist => {
|
|
vb.insert(types::access::get_type(t).unwrap(), pre_value);
|
|
}
|
|
types::Type::Artist => {
|
|
vb.set_artist(pre_value);
|
|
}
|
|
types::Type::Date => {
|
|
vb.insert(types::access::get_type(t).unwrap(), pre_value);
|
|
}
|
|
types::Type::Disc => {
|
|
vb.set_disk(pre_value.parse().unwrap());
|
|
}
|
|
types::Type::Genre => {
|
|
vb.set_genre(pre_value);
|
|
}
|
|
types::Type::Title => {
|
|
vb.set_title(pre_value);
|
|
}
|
|
types::Type::Track => {
|
|
vb.set_track(pre_value.parse().unwrap());
|
|
}
|
|
types::Type::TrackCount => {
|
|
vb.set_track_total(pre_value.parse().unwrap());
|
|
}
|
|
types::Type::DiscCount => {
|
|
vb.set_disk_total(pre_value.parse().unwrap());
|
|
}
|
|
};
|
|
|
|
match vb.save_to_path(filepath, lofty::config::WriteOptions::default())
|
|
{
|
|
Ok(_) => Ok(value.to_owned()),
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
None => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
"No tags found",
|
|
)),
|
|
},
|
|
Err(err) => Err(std::io::Error::new(
|
|
std::io::ErrorKind::InvalidData,
|
|
err.to_string(),
|
|
)),
|
|
}
|
|
}
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn parse_value(value: types::MetadataType) -> String {
|
|
match value {
|
|
types::MetadataType::String(val) => val,
|
|
types::MetadataType::Int(val) => val.to_string(),
|
|
}
|
|
}
|
|
|
|
pub fn set_meta_value(
|
|
t: types::Type,
|
|
filepath: &String,
|
|
value: types::MetadataType,
|
|
) -> Result<String, std::io::Error> {
|
|
let parsed_val = parse_value(value);
|
|
|
|
set_meta(t, filepath, &parsed_val)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use util::{file_exists, get_full_path};
|
|
|
|
use super::*;
|
|
|
|
mod util {
|
|
|
|
use std::io::{self, Write};
|
|
|
|
// Function to save a Vec<u8> to a file
|
|
pub fn save_bytes_to_file(bytes: &[u8], file_path: &String) -> io::Result<()> {
|
|
let file = std::path::Path::new(file_path);
|
|
let mut file = std::fs::File::create(file)?;
|
|
|
|
match file.write_all(bytes) {
|
|
Ok(_res) => Ok(()),
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
pub fn get_full_path(
|
|
directory: &String,
|
|
filename: &String,
|
|
) -> Result<String, std::io::Error> {
|
|
match path_buf(directory, filename) {
|
|
Ok(pf) => Ok(pf.display().to_string()),
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn copy_file(
|
|
source_path: &String,
|
|
destination_path: &String,
|
|
) -> Result<u64, std::io::Error> {
|
|
let src_path = std::path::Path::new(source_path);
|
|
let dest_path = std::path::Path::new(destination_path);
|
|
|
|
match std::fs::copy(src_path, dest_path) {
|
|
Ok(bytes) => Ok(bytes),
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
pub fn file_exists(directory: &String, filename: &String) -> Result<bool, std::io::Error> {
|
|
match path_buf(directory, filename) {
|
|
Ok(pf) => Ok(pf.exists()),
|
|
Err(err) => Err(err),
|
|
}
|
|
}
|
|
|
|
fn path_buf(
|
|
directory: &String,
|
|
filename: &String,
|
|
) -> Result<std::path::PathBuf, std::io::Error> {
|
|
let dir_path = std::path::Path::new(&directory);
|
|
Ok(dir_path.join(filename))
|
|
}
|
|
|
|
pub const TESTFILEDIRECTORY: &str = "tests/sample_tracks3";
|
|
|
|
pub fn get_filename(track: i32) -> String {
|
|
let mut filename = String::from("track");
|
|
|
|
if track < 10 {
|
|
filename += "0";
|
|
filename += &track.to_string();
|
|
} else {
|
|
filename += &track.to_string();
|
|
}
|
|
|
|
filename += ".flac";
|
|
|
|
filename
|
|
}
|
|
}
|
|
|
|
mod get {
|
|
use super::metadata::get_meta;
|
|
use super::*;
|
|
use crate::types;
|
|
|
|
#[test]
|
|
fn test_get_title() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Title, &filepath) {
|
|
Ok(title) => {
|
|
let found = title == "Just roll it";
|
|
assert!(found, "Meta information was not found {:?}", title);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_artist() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Artist, &filepath) {
|
|
Ok(artist) => {
|
|
let found = artist == "KD";
|
|
assert!(found, "Meta information was not found {:?}", artist);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_album() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Album, &filepath) {
|
|
Ok(album) => {
|
|
let found = album == "Sample Tracks 3";
|
|
assert!(found, "Meta information was not found {:?}", album);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_album_artist() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::AlbumArtist, &filepath) {
|
|
Ok(album_artist) => {
|
|
let found = album_artist == "KD";
|
|
assert!(found, "Meta information was not found {:?}", album_artist);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_genre() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Genre, &filepath) {
|
|
Ok(genre) => {
|
|
let found = genre == "Metal";
|
|
assert!(found, "Meta information was not found {:?}", genre);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
#[test]
|
|
fn test_get_year() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Date, &filepath) {
|
|
Ok(date) => {
|
|
let found = date == "2025-04-11";
|
|
assert!(found, "Meta information was not found {:?}", date);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_track() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Track, &filepath) {
|
|
Ok(track) => {
|
|
let found = track == "1";
|
|
assert!(found, "Meta information was not found {:?}", track);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_disc() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::Disc, &filepath) {
|
|
Ok(disc) => {
|
|
let found = disc == "1";
|
|
assert!(found, "Meta information was not found {:?}", disc);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_track_total() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::TrackCount, &filepath) {
|
|
Ok(track_total) => {
|
|
let found = track_total == "3";
|
|
assert!(found, "Meta information was not found {:?}", track_total);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_disc_total() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match get_meta(types::Type::DiscCount, &filepath) {
|
|
Ok(disc_total) => {
|
|
let found = disc_total == "1";
|
|
assert!(found, "Meta information was not found {:?}", disc_total);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
mod set {
|
|
use super::metadata::{get_meta, set_meta};
|
|
use super::*;
|
|
use crate::types;
|
|
|
|
#[test]
|
|
fn test_set_title() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Title, &filepath) {
|
|
Ok(title) => {
|
|
let found = title == "Just roll it";
|
|
assert!(found, "Meta information was not found {:?}", title);
|
|
let new_title = String::from("The wind burned her");
|
|
|
|
match set_meta(types::Type::Title, &new_filepath, &new_title) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_title, m,
|
|
"New title does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_artist() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Artist, &filepath) {
|
|
Ok(artist) => {
|
|
let found = artist == "KD";
|
|
assert!(found, "Meta information was not found {:?}", artist);
|
|
let new_artist = String::from("Pilot");
|
|
|
|
match set_meta(types::Type::Artist, &new_filepath, &new_artist) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_artist, m,
|
|
"New artist does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_album() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Album, &filepath) {
|
|
Ok(title) => {
|
|
let found = title == "Sample Tracks 3";
|
|
assert!(found, "Meta information was not found {:?}", title);
|
|
let new_album = String::from("Sample Tracks 3 Remastered");
|
|
|
|
match set_meta(types::Type::Album, &new_filepath, &new_album) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_album, m,
|
|
"New album does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
#[test]
|
|
fn test_set_album_artist() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::AlbumArtist, &filepath) {
|
|
Ok(album_artist) => {
|
|
let found = album_artist == "KD";
|
|
assert!(found, "Meta information was not found {:?}", album_artist);
|
|
let new_album_artist = String::from("Bob");
|
|
|
|
match set_meta(
|
|
types::Type::AlbumArtist,
|
|
&new_filepath,
|
|
&new_album_artist,
|
|
) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_album_artist, m,
|
|
"New album artist does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
#[test]
|
|
fn test_set_date() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Date, &filepath) {
|
|
Ok(date) => {
|
|
let found = date == "2025-04-11";
|
|
assert!(found, "Meta information was not found {:?}", date);
|
|
let new_date = String::from("2025-02-01");
|
|
|
|
match set_meta(types::Type::Date, &new_filepath, &new_date) {
|
|
Ok(m) => {
|
|
assert_eq!(new_date, m, "New date does not match {:?}", m);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
#[test]
|
|
fn test_set_track() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Track, &filepath) {
|
|
Ok(track) => {
|
|
let found = track == "1";
|
|
assert!(found, "Meta information was not found {:?}", track);
|
|
let new_track = String::from("5");
|
|
|
|
match set_meta(types::Type::Track, &new_filepath, &new_track) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_track, m,
|
|
"New track does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
#[test]
|
|
fn test_set_disc() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Disc, &filepath) {
|
|
Ok(disc) => {
|
|
let found = disc == "1";
|
|
assert!(found, "Meta information was not found {:?}", disc);
|
|
let new_disc = String::from("2");
|
|
|
|
match set_meta(types::Type::Disc, &new_filepath, &new_disc) {
|
|
Ok(m) => {
|
|
assert_eq!(new_disc, m, "New disc does not match {:?}", m);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_track_total() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::TrackCount, &filepath) {
|
|
Ok(track_total) => {
|
|
let found = track_total == "3";
|
|
assert!(found, "Meta information was not found {:?}", track_total);
|
|
let new_track_total = String::from("5");
|
|
|
|
match set_meta(
|
|
types::Type::TrackCount,
|
|
&new_filepath,
|
|
&new_track_total,
|
|
) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_track_total, m,
|
|
"New track does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_disc_total() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::DiscCount, &filepath) {
|
|
Ok(disc_total) => {
|
|
let found = disc_total == "1";
|
|
assert!(found, "Meta information was not found {:?}", disc_total);
|
|
let new_disc_total = String::from("2");
|
|
|
|
match set_meta(
|
|
types::Type::DiscCount,
|
|
&new_filepath,
|
|
&new_disc_total,
|
|
) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_disc_total, m,
|
|
"New disc_total does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_genre() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track08.flac");
|
|
let new_filepath = test_dir + "/" + &test_filename;
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match get_meta(types::Type::Genre, &filepath) {
|
|
Ok(genre) => {
|
|
let found = genre == "Metal";
|
|
assert!(found, "Meta information was not found {:?}", genre);
|
|
let new_genre = String::from("Blues");
|
|
|
|
match set_meta(types::Type::Genre, &new_filepath, &new_genre) {
|
|
Ok(m) => {
|
|
assert_eq!(
|
|
new_genre, m,
|
|
"New genre does not match {:?}",
|
|
m
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(
|
|
false,
|
|
"Error: {:?} source {:?} destination {:?}",
|
|
err, filepath, new_filepath
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
mod pictures {
|
|
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_get_picture() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match coverart::get_coverart(&filepath) {
|
|
Ok(coverart) => {
|
|
let is_empty = coverart.is_empty();
|
|
assert_eq!(is_empty, false, "Should not be empty");
|
|
|
|
let mut new_coverart_path: String = test_dir.clone();
|
|
new_coverart_path += &String::from("/newcovvv.png");
|
|
let _ = util::save_bytes_to_file(&coverart, &new_coverart_path);
|
|
let created_file = std::path::Path::new(&new_coverart_path);
|
|
assert!(
|
|
created_file.exists(),
|
|
"Error: {:?} has not been created",
|
|
new_coverart_path
|
|
);
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err.to_string());
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_set_picture() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let new_coverart = String::from("Sample Tracks 3 - Other one.png");
|
|
let new_cover_art_path = get_full_path(&dir, &new_coverart).unwrap();
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match coverart::set_coverart(&filepath, &new_cover_art_path) {
|
|
Ok(bytes) => {
|
|
assert_eq!(false, bytes.is_empty(), "This should not be empty");
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_picture_exists() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match coverart::contains_coverart(&filepath) {
|
|
Ok((exists, pictures)) => {
|
|
assert!(exists, "File should have a cover art");
|
|
assert!((pictures > 0), "No cover art was found in the file");
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn test_remove_picture() {
|
|
let filename = util::get_filename(1);
|
|
let dir = String::from(util::TESTFILEDIRECTORY);
|
|
|
|
let temp_file = tempfile::tempdir().expect("Could not create test directory");
|
|
let test_dir = String::from(temp_file.path().to_str().unwrap());
|
|
let test_filename = String::from("track09.flac");
|
|
let new_filepath = get_full_path(&test_dir, &test_filename).unwrap();
|
|
|
|
match file_exists(&dir, &filename) {
|
|
Ok(_) => {
|
|
let filepath = get_full_path(&dir, &filename).unwrap();
|
|
|
|
match util::copy_file(&filepath, &new_filepath) {
|
|
Ok(_o) => match coverart::remove_coverart(&new_filepath) {
|
|
Ok(bytes) => {
|
|
assert_eq!(false, bytes.is_empty(), "This should not be empty");
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
},
|
|
Err(err) => {
|
|
assert!(false, "Error: {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
assert!(false, "Error: File does not exist {:?}", err.to_string());
|
|
}
|
|
};
|
|
}
|
|
}
|
|
}
|