Added tests for Trees

Cargo.toml

@@ -1,10 +1,9 @@
 [package]
 name = "vault_vcs"
-version = "1.2.2"
+version = "1.2.3"
 edition = "2021"
 author = "Shubham singh	<github: github.com/shubhexists>"
 description = "A simplified version control system built in Rust for local files, quite similar to how git functions."
-license = "MIT"
 license-file = "LICENSE"
 repository = "https://github.com/shubhexists/vault"
 categories = ["cli", "version-control", "git","developer-utility"]

src/core/tests/blob_test.rs

@@ -2,7 +2,7 @@ use crate::core::{blob::Blob, types::FileTypes};
 
 #[test]
 fn get_content_of_blob_utf8() {
-    let blob = Blob {
+    let blob: Blob = Blob {
         content_size: 10,
         content: String::from("Hello!"),
         is_utf8: FileTypes::Utf8,
@@ -14,20 +14,20 @@ fn get_content_of_blob_utf8() {
 
 #[test]
 fn get_content_of_blob_non_utf8() {
-    let blob = Blob {
+    let blob: Blob = Blob {
         content_size: 8,
         content: String::from("Binary\x00"),
         is_utf8: FileTypes::NonUTF8,
     };
 
-    let expected_content = "blob \0NonUTF\08\0Binary\x00";
+    let expected_content: &str = "blob \0NonUTF\08\0Binary\x00";
     assert_eq!(blob.get_content_of_blob(), expected_content);
 }
 
 #[test]
 fn get_blob_from_content_utf8() {
-    let blob_content = "blob \0UTF\012\0Hello, Rust!";
-    let expected_blob = Blob {
+    let blob_content: &str = "blob \0UTF\012\0Hello, Rust!";
+    let expected_blob: Blob = Blob {
         content_size: 12,
         content: String::from("Hello, Rust!"),
         is_utf8: FileTypes::Utf8,
@@ -41,8 +41,8 @@ fn get_blob_from_content_utf8() {
 
 #[test]
 fn get_blob_from_content_non_utf8() {
-    let blob_content = "blob \0NonUTF\05\0Binary";
-    let expected_blob = Blob {
+    let blob_content: &str = "blob \0NonUTF\05\0Binary";
+    let expected_blob: Blob = Blob {
         content_size: 5,
         content: String::from("Binary"),
         is_utf8: FileTypes::NonUTF8,
@@ -57,6 +57,6 @@ fn get_blob_from_content_non_utf8() {
 #[test]
 #[should_panic(expected = "Invalid Blob Content")]
 fn get_blob_from_content_invalid_content() {
-    let invalid_blob_content = "invalid_content";
+    let invalid_blob_content: &str = "invalid_content";
     Blob::get_blob_from_content(&invalid_blob_content.to_string());
 }

src/core/tests/mod.rs

@@ -1,2 +1,3 @@
+mod blob_test;
 mod commit_test;
-mod blob_test;
+mod tree_tests;

src/core/tests/tree_tests.rs

@@ -0,0 +1,142 @@
+use crate::core::{
+    tree::{Tree, TreeEntry},
+    types::GitObject,
+};
+
+#[test]
+fn test_make_tree_with_blob_entry() {
+    let blob_entry: TreeEntry = TreeEntry {
+        name: String::from("fileA.txt"),
+        object: GitObject::Blob,
+        hashed_path: String::from("0123456789abcdef0123456789abcdef01234567"),
+    };
+    let tree: Tree = Tree::make_tree(vec![blob_entry.clone()]);
+    let expected_content: &str = "blob \0fileA.txt\00123456789abcdef0123456789abcdef01234567\n";
+    assert_eq!(tree.content, expected_content);
+    assert_eq!(tree.content_size, expected_content.len() as i32);
+    assert_eq!(tree.entries.len(), 1);
+    assert_eq!(tree.entries[0], blob_entry);
+}
+
+#[test]
+fn test_make_tree_with_tree_entry() {
+    let tree_entry: TreeEntry = TreeEntry {
+        name: String::from("folderA"),
+        object: GitObject::Tree,
+        hashed_path: String::from("ab89abcdef0123456789abcdef0123456789ab"),
+    };
+    let tree: Tree = Tree::make_tree(vec![tree_entry.clone()]);
+    let expected_content: &str = "tree \0folderA\0ab89abcdef0123456789abcdef0123456789ab\n";
+    assert_eq!(tree.content, expected_content);
+    assert_eq!(tree.content_size, expected_content.len() as i32);
+    assert_eq!(tree.entries.len(), 1);
+    assert_eq!(tree.entries[0], tree_entry);
+}
+
+#[test]
+fn test_get_tree_from_content_with_blob_entry() {
+    let blob_entry_content: &str = "blob \0fileA.txt\00123456789abcdef0123456789abcdef01234567";
+    let tree_content: String = format!("{}\n", blob_entry_content);
+
+    let expected_tree_entry: TreeEntry = TreeEntry {
+        name: String::from("fileA.txt"),
+        object: GitObject::Blob,
+        hashed_path: String::from("0123456789abcdef0123456789abcdef01234567"),
+    };
+    let expected_tree: Tree = Tree {
+        entries: vec![expected_tree_entry.clone()],
+        content: tree_content.clone(),
+        content_size: tree_content.len() as i32,
+    };
+    assert_eq!(Tree::get_tree_from_content(&tree_content), expected_tree);
+}
+
+#[test]
+fn test_get_tree_from_content_with_tree_entry() {
+    let tree_entry_content: &str = "tree \0folderA\0ab89abcdef0123456789abcdef0123456789ab";
+    let tree_content: String = format!("{}\n", tree_entry_content);
+    let expected_tree_entry: TreeEntry = TreeEntry {
+        name: String::from("folderA"),
+        object: GitObject::Tree,
+        hashed_path: String::from("ab89abcdef0123456789abcdef0123456789ab"),
+    };
+    let expected_tree: Tree = Tree {
+        entries: vec![expected_tree_entry.clone()],
+        content: tree_content.clone(),
+        content_size: tree_content.len() as i32,
+    };
+    assert_eq!(Tree::get_tree_from_content(&tree_content), expected_tree);
+}
+
+#[test]
+#[should_panic]
+fn test_get_tree_from_content_invalid_content() {
+    let invalid_content: &str = "invalid_content";
+    println!(
+        "{:?}",
+        Tree::get_tree_from_content(&invalid_content.to_string())
+    );
+}
+
+#[test]
+fn test_check_valid_tree_entry_with_valid_blob() {
+    let valid_blob_entry: Vec<&str> = vec![
+        "blob ",
+        "fileA.txt",
+        "0123456789abcdef0123456789abcdef01234567",
+    ];
+    assert_eq!(TreeEntry::check_valid_tree_entry(&valid_blob_entry), true);
+}
+
+// #[test]
+// fn test_check_valid_tree_entry_invalid_content() {
+//     let valid_blob_entry: Vec<&str> = vec!["invalid content"];
+//     assert_eq!(TreeEntry::check_valid_tree_entry(&valid_blob_entry), false);
+// }
+
+#[test]
+fn test_check_valid_tree_entry_with_valid_tree() {
+    let valid_tree_entry: Vec<&str> =
+        vec!["tree ", "folderA", "ab89abcdef0123456789abcdef0123456789ab"];
+    assert_eq!(TreeEntry::check_valid_tree_entry(&valid_tree_entry), true);
+}
+
+#[test]
+fn test_check_valid_tree_entry_with_invalid_entry() {
+    let invalid_entry: Vec<&str> = vec!["invalid_entry"];
+    assert_eq!(TreeEntry::check_valid_tree_entry(&invalid_entry), false);
+}
+
+#[test]
+fn test_parse_tree_entry_contents_with_blob() {
+    let blob_entry_content: Vec<&str> = vec![
+        "blob ",
+        "fileA.txt",
+        "0123456789abcdef0123456789abcdef01234567",
+    ];
+    let expected_blob_entry: TreeEntry = TreeEntry {
+        name: String::from("fileA.txt"),
+        object: GitObject::Blob,
+        hashed_path: String::from("0123456789abcdef0123456789abcdef01234567"),
+    };
+
+    assert_eq!(
+        TreeEntry::parse_tree_entry_contents(&blob_entry_content),
+        expected_blob_entry
+    );
+}
+
+#[test]
+fn test_parse_tree_entry_contents_with_tree() {
+    let tree_entry_content: Vec<&str> =
+        vec!["tree ", "folderA", "ab89abcdef0123456789abcdef0123456789ab"];
+    let expected_tree_entry: TreeEntry = TreeEntry {
+        name: String::from("folderA"),
+        object: GitObject::Tree,
+        hashed_path: String::from("ab89abcdef0123456789abcdef0123456789ab"),
+    };
+    assert_eq!(
+        TreeEntry::parse_tree_entry_contents(&tree_entry_content),
+        expected_tree_entry
+    );
+}

src/core/tree.rs

@@ -6,14 +6,14 @@ blob \0fileA.txt\0123456789abcdef0123456789abcdef01234567
 tree \0folderA\0ab89abcdef0123456789abcdef0123456789ab
  */
 
-#[derive(Debug)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Tree {
     pub entries: Vec<TreeEntry>,
     pub content: String,
     pub content_size: i32,
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct TreeEntry {
     pub name: String,
     pub object: GitObject,
@@ -55,11 +55,12 @@ impl Tree {
 
     pub fn get_tree_from_content(tree_content: &String) -> Tree {
         let content_size: i32 = tree_content.chars().count() as i32;
-        let break_: Vec<&str> = tree_content.split("\n").collect();
-        let break_by_new_line: &[&str] = &break_[..break_.len() - 1];
+        let mut break_new_line: Vec<&str> = tree_content.split("\n").collect::<Vec<&str>>();
+        break_new_line.pop();
         let mut tree_entry_contents: Vec<TreeEntry> = Vec::new();
-        for item in break_by_new_line {
+        for item in break_new_line {
             let tree_entry_content: Vec<&str> = item.split("\0").collect();
+            println!("{:?}", tree_entry_content);
             let is_valid_tree_entry: bool = TreeEntry::check_valid_tree_entry(&tree_entry_content);
             if is_valid_tree_entry {
                 let tree_entry_object: TreeEntry =

src/core/types.rs

@@ -1,4 +1,4 @@
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum GitObject {
     Blob,
     Tree,