test: add comprehensive sheet management test suite

- Add test_sheet_creation_management_and_persistence with 3 test functions:
  - Main test covering sheet creation, input/mapping management, persistence, and deletion
  - Error condition testing for invalid operations
  - Serialization testing through vault operations
- Test coverage includes:
  - Sheet creation with member validation
  - Input package addition and removal
  - Mapping entry management
  - File persistence and reloading
  - Safe deletion to trash and restoration
  - Permanent deletion
  - Error handling for invalid operations
- Follows existing test patterns and uses proper getter methods for private fields

2 files changed, 263 insertions, 0 deletions

diff --git a/crates/vcs/vcs_test/src/lib.rs b/crates/vcs/vcs_test/src/lib.rs
index d9e6f94..8ad03e1 100644
--- a/crates/vcs/vcs_test/src/lib.rs
+++ b/crates/vcs/vcs_test/src/lib.rs
@@ -11,6 +11,9 @@ pub mod test_virtual_file_creation_and_update;
 #[cfg(test)]
 pub mod test_local_workspace_setup_and_account_management;
 
+#[cfg(test)]
+pub mod test_sheet_creation_management_and_persistence;
+
 pub async fn get_test_dir(area: &str) -> Result<PathBuf, std::io::Error> {
     let dir = current_dir()?.join(".temp").join("test").join(area);
     if !dir.exists() {
diff --git a/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs b/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs
new file mode 100644
index 0000000..7fe6955
--- /dev/null
+++ b/crates/vcs/vcs_test/src/test_sheet_creation_management_and_persistence.rs
@@ -0,0 +1,260 @@
+use std::io::Error;
+
+use cfg_file::config::ConfigFile;
+use vcs::{
+    constants::{SERVER_FILE_SHEET, SERVER_FILE_VAULT},
+    data::{
+        member::{Member, MemberId},
+        sheet::{InputRelativePathBuf, SheetName},
+        vault::{Vault, config::VaultConfig, virtual_file::VirtualFileId},
+    },
+};
+
+use crate::get_test_dir;
+
+#[tokio::test]
+async fn test_sheet_creation_management_and_persistence() -> Result<(), std::io::Error> {
+    let dir = get_test_dir("sheet_management").await?;
+
+    // Setup vault
+    Vault::setup_vault(dir.clone()).await?;
+
+    // Get vault
+    let config = VaultConfig::read_from(dir.join(SERVER_FILE_VAULT)).await?;
+    let Some(vault) = Vault::init(config, &dir) else {
+        return Err(Error::new(std::io::ErrorKind::NotFound, "Vault not found!"));
+    };
+
+    // Add a member to use as sheet holder
+    let member_id: MemberId = "test_member".to_string();
+    vault
+        .register_member_to_vault(Member::new(&member_id))
+        .await?;
+
+    // Test 1: Create a new sheet
+    let sheet_name: SheetName = "test_sheet".to_string();
+    let sheet = vault.create_sheet(&sheet_name, &member_id).await?;
+
+    // Verify sheet properties
+    assert_eq!(sheet.holder(), &member_id);
+    assert_eq!(sheet.holder(), &member_id);
+    assert!(sheet.inputs().is_empty());
+    assert!(sheet.mapping().is_empty());
+
+    // Verify sheet file was created
+    const SHEET_NAME_PARAM: &str = "{sheet-name}";
+    let sheet_path = dir.join(SERVER_FILE_SHEET.replace(SHEET_NAME_PARAM, &sheet_name));
+    assert!(sheet_path.exists());
+
+    // Test 2: Add input packages to the sheet
+    let input_name = "source_files".to_string();
+    let files = vec![
+        (
+            InputRelativePathBuf::from("src/main.rs"),
+            VirtualFileId::new(),
+        ),
+        (
+            InputRelativePathBuf::from("src/lib.rs"),
+            VirtualFileId::new(),
+        ),
+    ];
+
+    // Need to get a mutable reference to the sheet
+    let mut sheet = vault.sheet(&sheet_name).await?;
+    sheet.add_input(input_name.clone(), files.clone());
+
+    // Verify input was added
+    assert_eq!(sheet.inputs().len(), 1);
+    let added_input = &sheet.inputs()[0];
+    assert_eq!(added_input.name, input_name);
+    assert_eq!(added_input.files.len(), 2);
+    assert_eq!(
+        added_input.files[0].0,
+        InputRelativePathBuf::from("src/main.rs")
+    );
+    assert_eq!(
+        added_input.files[1].0,
+        InputRelativePathBuf::from("src/lib.rs")
+    );
+
+    // Test 3: Add mapping entries
+    let mapping_path = vcs::data::sheet::SheetPathBuf::from("output/build.exe");
+    let virtual_file_id = VirtualFileId::new();
+    sheet.add_mapping(mapping_path.clone(), virtual_file_id.clone());
+
+    // Verify mapping was added
+    assert_eq!(sheet.mapping().len(), 1);
+    assert_eq!(sheet.mapping().get(&mapping_path), Some(&virtual_file_id));
+
+    // Test 4: Persist sheet to disk
+    sheet.persist().await?;
+
+    // Verify persistence by reloading the sheet
+    let reloaded_sheet = vault.sheet(&sheet_name).await?;
+    assert_eq!(reloaded_sheet.holder(), &member_id);
+    assert_eq!(reloaded_sheet.inputs().len(), 1);
+    assert_eq!(reloaded_sheet.mapping().len(), 1);
+
+    // Test 5: Remove input package
+    let mut sheet_for_removal = vault.sheet(&sheet_name).await?;
+    let removed_input = sheet_for_removal.remove_input(&input_name);
+    assert!(removed_input.is_some());
+    let removed_input = removed_input.unwrap();
+    assert_eq!(removed_input.name, input_name);
+    assert_eq!(removed_input.files.len(), 2);
+    assert_eq!(sheet_for_removal.inputs().len(), 0);
+
+    // Test 6: Remove mapping entry
+    let removed_virtual_file_id = sheet_for_removal.remove_mapping(&mapping_path);
+    assert_eq!(removed_virtual_file_id, Some(virtual_file_id));
+    assert_eq!(sheet_for_removal.mapping().len(), 0);
+
+    // Test 7: List all sheets in vault
+    let sheet_names = vault.sheet_names()?;
+    assert_eq!(sheet_names.len(), 1);
+    assert_eq!(sheet_names[0], sheet_name);
+
+    let all_sheets = vault.sheets().await?;
+    assert_eq!(all_sheets.len(), 1);
+    assert_eq!(all_sheets[0].holder(), &member_id);
+
+    // Test 8: Safe deletion (move to trash)
+    vault.delete_sheet_safely(&sheet_name).await?;
+
+    // Verify sheet is not in normal listing but can be restored
+    let sheet_names_after_deletion = vault.sheet_names()?;
+    assert_eq!(sheet_names_after_deletion.len(), 0);
+
+    // Test 9: Restore sheet from trash
+    let restored_sheet = vault.sheet(&sheet_name).await?;
+    assert_eq!(restored_sheet.holder(), &member_id);
+    assert_eq!(restored_sheet.holder(), &member_id);
+
+    // Verify sheet is back in normal listing
+    let sheet_names_after_restore = vault.sheet_names()?;
+    assert_eq!(sheet_names_after_restore.len(), 1);
+
+    // Test 10: Permanent deletion
+    vault.delete_sheet(&sheet_name).await?;
+
+    // Verify sheet is permanently gone
+    let sheet_names_final = vault.sheet_names()?;
+    assert_eq!(sheet_names_final.len(), 0);
+
+    // Attempt to access deleted sheet should fail
+    let result = vault.sheet(&sheet_name).await;
+    assert!(result.is_err());
+
+    // Clean up: Remove member
+    vault.remove_member_from_vault(&member_id)?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_sheet_error_conditions() -> Result<(), std::io::Error> {
+    let dir = get_test_dir("sheet_error_conditions").await?;
+
+    // Setup vault
+    Vault::setup_vault(dir.clone()).await?;
+
+    // Get vault
+    let config = VaultConfig::read_from(dir.join(SERVER_FILE_VAULT)).await?;
+    let Some(vault) = Vault::init(config, &dir) else {
+        return Err(Error::new(std::io::ErrorKind::NotFound, "Vault not found!"));
+    };
+
+    // Test 1: Create sheet with non-existent member should fail
+    let non_existent_member: MemberId = "non_existent_member".to_string();
+    let sheet_name: SheetName = "test_sheet".to_string();
+
+    let result = vault.create_sheet(&sheet_name, &non_existent_member).await;
+    assert!(result.is_err());
+
+    // Add a member first
+    let member_id: MemberId = "test_member".to_string();
+    vault
+        .register_member_to_vault(Member::new(&member_id))
+        .await?;
+
+    // Test 2: Create duplicate sheet should fail
+    vault.create_sheet(&sheet_name, &member_id).await?;
+    let result = vault.create_sheet(&sheet_name, &member_id).await;
+    assert!(result.is_err());
+
+    // Test 3: Delete non-existent sheet should fail
+    let non_existent_sheet: SheetName = "non_existent_sheet".to_string();
+    let result = vault.delete_sheet(&non_existent_sheet).await;
+    assert!(result.is_err());
+
+    // Test 4: Safe delete non-existent sheet should fail
+    let result = vault.delete_sheet_safely(&non_existent_sheet).await;
+    assert!(result.is_err());
+
+    // Test 5: Restore non-existent sheet from trash should fail
+    let result = vault.restore_sheet(&non_existent_sheet).await;
+    assert!(result.is_err());
+
+    // Clean up
+    vault.remove_member_from_vault(&member_id)?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_sheet_data_serialization() -> Result<(), std::io::Error> {
+    let dir = get_test_dir("sheet_serialization").await?;
+
+    // Test serialization by creating a sheet through the vault
+    // Setup vault
+    Vault::setup_vault(dir.clone()).await?;
+
+    // Get vault
+    let config = VaultConfig::read_from(dir.join(SERVER_FILE_VAULT)).await?;
+    let Some(vault) = Vault::init(config, &dir) else {
+        return Err(Error::new(std::io::ErrorKind::NotFound, "Vault not found!"));
+    };
+
+    // Add a member
+    let member_id: MemberId = "test_member".to_string();
+    vault
+        .register_member_to_vault(Member::new(&member_id))
+        .await?;
+
+    // Create a sheet
+    let sheet_name: SheetName = "test_serialization_sheet".to_string();
+    let mut sheet = vault.create_sheet(&sheet_name, &member_id).await?;
+
+    // Add some inputs
+    let input_name = "source_files".to_string();
+    let files = vec![
+        (
+            InputRelativePathBuf::from("src/main.rs"),
+            VirtualFileId::new(),
+        ),
+        (
+            InputRelativePathBuf::from("src/lib.rs"),
+            VirtualFileId::new(),
+        ),
+    ];
+    sheet.add_input(input_name, files);
+
+    // Add some mappings
+    sheet.add_mapping(
+        vcs::data::sheet::SheetPathBuf::from("output/build.exe"),
+        VirtualFileId::new(),
+    );
+
+    // Persist the sheet
+    sheet.persist().await?;
+
+    // Verify the sheet file was created
+    const SHEET_NAME_PARAM: &str = "{sheet-name}";
+    let sheet_path = dir.join(SERVER_FILE_SHEET.replace(SHEET_NAME_PARAM, &sheet_name));
+    assert!(sheet_path.exists());
+
+    // Clean up
+    vault.remove_member_from_vault(&member_id)?;
+
+    Ok(())
+}