icarus_models/tests/tests.rs

mod song_tests {
// use std::fs::{self, File};
use std::fs;
use std::fs::File;
use std::io::{Read, Write};
use std::path::Path;

use tempfile::tempdir;

use icarus_models::song;
use icarus_models::types;

fn get_tests_directory() -> String {
    String::from(env!("CARGO_MANIFEST_DIR").to_owned() + "/tests/")
}

fn does_directory_exists(directory: &String) -> bool {
    let path = Path::new(directory);
    if let Ok(dir_i) = fs::metadata(path) {
        dir_i.is_dir()
    } else {
        false
    }
}

fn extract_data_from_file(filepath: &String) -> Result<Vec<u8>, std::io::Error> {
    match std::fs::File::open(filepath) {
        Ok(mut file) => {
            let mut buffer: Vec<u8> = Vec::new();
            let _ = file.read_to_end(&mut buffer);
            Ok(buffer)
        }
        Err(err) => {
            println!("Error: {}", err);
            // assert!(false, "Failed to open file: {:?}", err);
            // Err(4)
            Err(err)
        }
    }
}

#[test]
fn test_song_to_data() {
    println!("Test");
    let some_val = true;

    println!("Checking if some_val is true");
    assert_eq!(true, some_val);

    println!("Getting track");
    let mut song = song::Song::default();
    song.filename = String::from("track01.flac");
    song.id = 1;
    // println!("O ", song.id);

    // let temp_dir = tempdir().expect("Failed to create temp dir");

    println!("Getting directory");
    /*
    song.directory = match temp_dir.path().to_str() {
        Some(s) => String::from(s),
        None => { String::new() },
    };
    */
    song.directory = get_tests_directory();

    // assert_eq!(song.directory.is_empty(), false);
    assert!(
        does_directory_exists(&song.directory),
        "Directory does not exist"
    );

    println!("Directory: {}", song.directory);

    match song.song_path() {
        Ok(filepath) => {
            // let file_result = std::fs::File::open(filepath);
            // match file_result {
            match extract_data_from_file(&filepath) {
                Ok(buffer) => {
                    // let mut buffer: Vec<u8> = Vec::new();
                    // let _ = file.read_to_end(&mut buffer);
                    assert_eq!(buffer.is_empty(), false);

                    match song.to_data() {
                        Ok(song_data) => {
                            println!("Both files match");
                            assert_eq!(buffer, song_data);
                        }
                        Err(err) => {
                            assert!(false, "Error producing song data: {:?}", err);
                        }
                    };
                }
                Err(err) => {
                    println!("Error: {}", err);
                    assert!(false, "Failed to open file: {:?}", err);
                }
            }
        }
        Err(err) => {
            println!("Error: {}", err);
            assert!(false, "Could not get song path: {:?}", err);
        }
    }
}

#[test]
fn test_song_path_check() {
    let mut song = song::Song::default();
    song.directory = get_tests_directory();
    song.filename = String::from("track01.flac");

    assert!(
        does_directory_exists(&song.directory),
        "Directory does not exist"
    );
}

#[test]
fn test_song_generate_filename() {
    let mut song = song::Song::default();
    song.directory = get_tests_directory();
    song.filename = String::from("track01.flac");

    match song.song_path() {
        Ok(songpath) => match extract_data_from_file(&songpath) {
            Ok(buffer) => {
                let mut song_cpy = song.clone();
                let temp_dir = tempdir().expect("Failed to create temp dir");
                song_cpy.directory = match temp_dir.path().to_str() {
                    Some(s) => String::from(s),
                    None => String::new(),
                };

                assert_eq!(song.directory.is_empty(), false);
                // song_cpy.directory = String::from(temp_dir.path().to_str());
                song_cpy.filename = song.generate_filename(types::MusicTypes::FlacExtension, true);
                println!("Directory: {:?}", song_cpy.directory);
                println!("File to be created: {:?}", song_cpy.filename);

                let path = match song_cpy.song_path() {
                    Ok(s_path) => s_path,
                    Err(err) => {
                        assert!(false, "Error: {:?}", err);
                        String::new()
                    }
                };

                match File::create(path) {
                    Ok(mut file_cpy) => {
                        let _ = file_cpy.write_all(&buffer);
                    }
                    Err(err) => {
                        assert!(false, "Error: {:?}", err);
                    }
                };
            }
            Err(err) => {
                assert!(false, "Error: {:?}", err);
            }
        },
        Err(err) => {
            assert!(false, "Error extracting song data: {:?}", err);
        }
    }
}
}