.gitignore

@@ -1 +1,2 @@
 /target
+Cargo.lock

Cargo.toml

@@ -9,3 +9,4 @@ license = "MIT"
 serde = { version = "1.0.218", features = ["derive"] }
 serde_json = { version = "1.0.139" }
 rand = { version = "0.9" }
+tempfile = { version = "3.19.1" }

src/song.rs

@@ -64,7 +64,6 @@ fn is_dur_not_set(num: &i32) -> bool {
     *num == 0
 }
 
-/*
 impl Default for Song {
     fn default() -> Self {
         Song {
@@ -93,7 +92,6 @@ impl Default for Song {
         }
     }
 }
-*/
 
 impl Song {
     pub fn to_metadata_json(&self, pretty: bool) -> Result<String, serde_json::Error> {

tests/song_tests.rs

@@ -0,0 +1,166 @@
+// 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);
+        }
+    }
+}