Remove examples and legacy code, update .gitignore

- Delete examples directory and its example action system
- Rename actions/ to legacy_actions/ and data/ to legacy_data/
- Update Cargo.toml license file reference
- Move setup scripts to scripts/dev/ directory
- Add todo.txt patterns to .gitignore

6 files changed, 0 insertions, 1413 deletions

diff --git a/data/tests/src/lib.rs b/data/tests/src/lib.rs
deleted file mode 100644
index ced2d3d..0000000
--- a/data/tests/src/lib.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use std::{env::current_dir, path::PathBuf};
-
-use tokio::fs;
-
-#[cfg(test)]
-pub mod test_vault_setup_and_member_register;
-
-#[cfg(test)]
-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;
-
-#[cfg(test)]
-pub mod test_sheet_share_creation_and_management;
-
-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() {
-        std::fs::create_dir_all(&dir)?;
-    } else {
-        // Regenerate existing directory
-        fs::remove_dir_all(&dir).await?;
-        fs::create_dir_all(&dir).await?;
-    }
-    Ok(dir)
-}
diff --git a/data/tests/src/test_local_workspace_setup_and_account_management.rs b/data/tests/src/test_local_workspace_setup_and_account_management.rs
deleted file mode 100644
index edb9295..0000000
--- a/data/tests/src/test_local_workspace_setup_and_account_management.rs
+++ /dev/null
@@ -1,248 +0,0 @@
-use std::io::Error;
-
-use cfg_file::config::ConfigFile;
-use vcs_data::{
-    constants::{CLIENT_FILE_TODOLIST, CLIENT_FILE_WORKSPACE, USER_FILE_KEY, USER_FILE_MEMBER},
-    data::{
-        local::{LocalWorkspace, workspace_config::LocalConfig},
-        member::Member,
-        user::UserDirectory,
-    },
-};
-
-use crate::get_test_dir;
-
-#[tokio::test]
-async fn test_local_workspace_setup_and_account_management() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("local_workspace_account_management").await?;
-
-    // Setup local workspace
-    LocalWorkspace::setup_local_workspace(dir.clone()).await?;
-
-    // Check if the following files are created in `dir`:
-    // Files: CLIENT_FILE_WORKSPACE, CLIENT_FILE_README
-    assert!(dir.join(CLIENT_FILE_WORKSPACE).exists());
-    assert!(dir.join(CLIENT_FILE_TODOLIST).exists());
-
-    // Get local workspace
-    let config = LocalConfig::read_from(dir.join(CLIENT_FILE_WORKSPACE)).await?;
-    let Some(_local_workspace) = LocalWorkspace::init(config, &dir) else {
-        return Err(Error::new(
-            std::io::ErrorKind::NotFound,
-            "Local workspace not found!",
-        ));
-    };
-
-    // Create user directory from workspace path
-    let Some(user_directory) = UserDirectory::from_path(&dir) else {
-        return Err(Error::new(
-            std::io::ErrorKind::NotFound,
-            "User directory not found!",
-        ));
-    };
-
-    // Test account registration
-    let member_id = "test_account";
-    let member = Member::new(member_id);
-
-    // Register account
-    user_directory.register_account(member.clone()).await?;
-
-    // Check if the account config file exists
-    assert!(
-        dir.join(USER_FILE_MEMBER.replace("{self_id}", member_id))
-            .exists()
-    );
-
-    // Test account retrieval
-    let retrieved_member = user_directory.account(&member_id.to_string()).await?;
-    assert_eq!(retrieved_member.id(), member.id());
-
-    // Test account IDs listing
-    let account_ids = user_directory.account_ids()?;
-    assert!(account_ids.contains(&member_id.to_string()));
-
-    // Test accounts listing
-    let accounts = user_directory.accounts().await?;
-    assert_eq!(accounts.len(), 1);
-    assert_eq!(accounts[0].id(), member.id());
-
-    // Test account existence check
-    assert!(user_directory.account_cfg(&member_id.to_string()).is_some());
-
-    // Test private key check (should be false initially)
-    assert!(!user_directory.has_private_key(&member_id.to_string()));
-
-    // Test account update
-    let mut updated_member = member.clone();
-    updated_member.set_metadata("email", "test@example.com");
-    user_directory
-        .update_account(updated_member.clone())
-        .await?;
-
-    // Verify update
-    let updated_retrieved = user_directory.account(&member_id.to_string()).await?;
-    assert_eq!(
-        updated_retrieved.metadata("email"),
-        Some(&"test@example.com".to_string())
-    );
-
-    // Test account removal
-    user_directory.remove_account(&member_id.to_string())?;
-
-    // Check if the account config file no longer exists
-    assert!(
-        !dir.join(USER_FILE_MEMBER.replace("{self_id}", member_id))
-            .exists()
-    );
-
-    // Check if account is no longer in the list
-    let account_ids_after_removal = user_directory.account_ids()?;
-    assert!(!account_ids_after_removal.contains(&member_id.to_string()));
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_account_private_key_management() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("account_private_key_management").await?;
-
-    // Create user directory
-    let Some(user_directory) = UserDirectory::from_path(&dir) else {
-        return Err(Error::new(
-            std::io::ErrorKind::NotFound,
-            "User directory not found!",
-        ));
-    };
-
-    // Register account
-    let member_id = "test_account_with_key";
-    let member = Member::new(member_id);
-    user_directory.register_account(member).await?;
-
-    // Create a dummy private key file for testing
-    let private_key_path = dir.join(USER_FILE_KEY.replace("{self_id}", member_id));
-    std::fs::create_dir_all(private_key_path.parent().unwrap())?;
-    std::fs::write(&private_key_path, "dummy_private_key_content")?;
-
-    // Test private key existence check
-    assert!(user_directory.has_private_key(&member_id.to_string()));
-
-    // Test private key path retrieval
-    assert!(
-        user_directory
-            .account_private_key(&member_id.to_string())
-            .is_some()
-    );
-
-    // Remove account (should also remove private key)
-    user_directory.remove_account(&member_id.to_string())?;
-
-    // Check if private key file is also removed
-    assert!(!private_key_path.exists());
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_multiple_account_management() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("multiple_account_management").await?;
-
-    // Create user directory
-    let Some(user_directory) = UserDirectory::from_path(&dir) else {
-        return Err(Error::new(
-            std::io::ErrorKind::NotFound,
-            "User directory not found!",
-        ));
-    };
-
-    // Register multiple accounts
-    let account_names = vec!["alice", "bob", "charlie"];
-
-    for name in &account_names {
-        user_directory.register_account(Member::new(*name)).await?;
-    }
-
-    // Test account IDs listing
-    let account_ids = user_directory.account_ids()?;
-    assert_eq!(account_ids.len(), 3);
-
-    for name in &account_names {
-        assert!(account_ids.contains(&name.to_string()));
-    }
-
-    // Test accounts listing
-    let accounts = user_directory.accounts().await?;
-    assert_eq!(accounts.len(), 3);
-
-    // Remove one account
-    user_directory.remove_account(&"bob".to_string())?;
-
-    // Verify removal
-    let account_ids_after_removal = user_directory.account_ids()?;
-    assert_eq!(account_ids_after_removal.len(), 2);
-    assert!(!account_ids_after_removal.contains(&"bob".to_string()));
-    assert!(account_ids_after_removal.contains(&"alice".to_string()));
-    assert!(account_ids_after_removal.contains(&"charlie".to_string()));
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_account_registration_duplicate_prevention() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("account_duplicate_prevention").await?;
-
-    // Create user directory
-    let Some(user_directory) = UserDirectory::from_path(&dir) else {
-        return Err(Error::new(
-            std::io::ErrorKind::NotFound,
-            "User directory not found!",
-        ));
-    };
-
-    // Register account
-    let member_id = "duplicate_test";
-    user_directory
-        .register_account(Member::new(member_id))
-        .await?;
-
-    // Try to register same account again - should fail
-    let result = user_directory
-        .register_account(Member::new(member_id))
-        .await;
-    assert!(result.is_err());
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_nonexistent_account_operations() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("nonexistent_account_operations").await?;
-
-    // Create user directory
-    let Some(user_directory) = UserDirectory::from_path(&dir) else {
-        return Err(Error::new(
-            std::io::ErrorKind::NotFound,
-            "User directory not found!",
-        ));
-    };
-
-    // Try to read non-existent account - should fail
-    let result = user_directory.account(&"nonexistent".to_string()).await;
-    assert!(result.is_err());
-
-    // Try to update non-existent account - should fail
-    let result = user_directory
-        .update_account(Member::new("nonexistent"))
-        .await;
-    assert!(result.is_err());
-
-    // Try to remove non-existent account - should succeed (idempotent)
-    let result = user_directory.remove_account(&"nonexistent".to_string());
-    assert!(result.is_ok());
-
-    // Check private key for non-existent account - should be false
-    assert!(!user_directory.has_private_key(&"nonexistent".to_string()));
-
-    Ok(())
-}
diff --git a/data/tests/src/test_sheet_creation_management_and_persistence.rs b/data/tests/src/test_sheet_creation_management_and_persistence.rs
deleted file mode 100644
index adff1bd..0000000
--- a/data/tests/src/test_sheet_creation_management_and_persistence.rs
+++ /dev/null
@@ -1,275 +0,0 @@
-use std::io::Error;
-
-use cfg_file::config::ConfigFile;
-use vcs_data::{
-    constants::{SERVER_FILE_SHEET, SERVER_FILE_VAULT},
-    data::{
-        member::{Member, MemberId},
-        sheet::SheetName,
-        vault::{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(), "TestVault").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(), Some(&member_id));
-    assert_eq!(sheet.holder(), Some(&member_id));
-    assert!(sheet.mapping().is_empty());
-
-    // Verify sheet file was created
-    let sheet_path = dir.join(SERVER_FILE_SHEET.replace("{sheet_name}", &sheet_name));
-    assert!(sheet_path.exists());
-
-    // Test 2: Add mapping entries to the sheet
-    let mut sheet = vault.sheet(&sheet_name).await?;
-
-    // Add mapping entries for the files
-    let main_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/main.rs");
-    let lib_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/lib.rs");
-    let main_rs_id = VirtualFileId::new();
-    let lib_rs_id = VirtualFileId::new();
-
-    sheet
-        .add_mapping(
-            main_rs_path.clone(),
-            main_rs_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-    sheet
-        .add_mapping(lib_rs_path.clone(), lib_rs_id.clone(), "1.0.0".to_string())
-        .await?;
-
-    // Verify mappings were added
-    assert_eq!(sheet.mapping().len(), 2);
-
-    // Test 3: Add more mapping entries
-    let mapping_path = vcs_data::data::sheet::SheetPathBuf::from("output/build.exe");
-    let virtual_file_id = VirtualFileId::new();
-
-    sheet
-        .add_mapping(
-            mapping_path.clone(),
-            virtual_file_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    // Verify mapping was added
-    assert_eq!(sheet.mapping().len(), 3);
-    assert_eq!(
-        sheet.mapping().get(&mapping_path).map(|meta| &meta.id),
-        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(), Some(&member_id));
-    assert_eq!(reloaded_sheet.mapping().len(), 3);
-
-    // Test 5: Remove mapping entry
-    let mut sheet_for_removal = vault.sheet(&sheet_name).await?;
-    let _removed_virtual_file_id = sheet_for_removal.remove_mapping(&mapping_path).await;
-    // Don't check the return value since it depends on virtual file existence
-    assert_eq!(sheet_for_removal.mapping().len(), 2);
-
-    // Test 6: List all sheets in vault
-    let sheet_names = vault.sheet_names()?;
-    assert_eq!(sheet_names.len(), 2);
-    assert!(sheet_names.contains(&sheet_name));
-    assert!(sheet_names.contains(&"ref".to_string()));
-
-    let all_sheets = vault.sheets().await?;
-    assert_eq!(all_sheets.len(), 2);
-    // One sheet should be the test sheet, the other should be the ref sheet with host as holder
-    let test_sheet_holder = all_sheets
-        .iter()
-        .find(|s| s.holder() == Some(&member_id))
-        .map(|s| s.holder())
-        .unwrap();
-    let ref_sheet_holder = all_sheets
-        .iter()
-        .find(|s| s.holder() == Some(&"host".to_string()))
-        .map(|s| s.holder())
-        .unwrap();
-    assert_eq!(test_sheet_holder, Some(&member_id));
-    assert_eq!(ref_sheet_holder, Some(&"host".to_string()));
-
-    // Test 7: 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(), 1);
-    assert_eq!(sheet_names_after_deletion[0], "ref");
-
-    // Test 8: Restore sheet from trash
-    let restored_sheet = vault.sheet(&sheet_name).await?;
-    assert_eq!(restored_sheet.holder(), Some(&member_id));
-    assert_eq!(restored_sheet.holder(), Some(&member_id));
-
-    // Verify sheet is back in normal listing
-    let sheet_names_after_restore = vault.sheet_names()?;
-    assert_eq!(sheet_names_after_restore.len(), 2);
-    assert!(sheet_names_after_restore.contains(&sheet_name));
-    assert!(sheet_names_after_restore.contains(&"ref".to_string()));
-
-    // Test 9: 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(), 1);
-    assert_eq!(sheet_names_final[0], "ref");
-
-    // 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(), "TestVault").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(), "TestVault").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 mappings
-    let main_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/main.rs");
-    let lib_rs_path = vcs_data::data::sheet::SheetPathBuf::from("src/lib.rs");
-    let main_rs_id = VirtualFileId::new();
-    let lib_rs_id = VirtualFileId::new();
-
-    sheet
-        .add_mapping(
-            main_rs_path.clone(),
-            main_rs_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-    sheet
-        .add_mapping(lib_rs_path.clone(), lib_rs_id.clone(), "1.0.0".to_string())
-        .await?;
-
-    // Add more mappings
-    let build_exe_id = VirtualFileId::new();
-
-    sheet
-        .add_mapping(
-            vcs_data::data::sheet::SheetPathBuf::from("output/build.exe"),
-            build_exe_id,
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    // Persist the sheet
-    sheet.persist().await?;
-
-    // Verify the sheet file was created
-    let sheet_path = dir.join(SERVER_FILE_SHEET.replace("{sheet_name}", &sheet_name));
-    assert!(sheet_path.exists());
-
-    // Clean up
-    vault.remove_member_from_vault(&member_id)?;
-
-    Ok(())
-}
diff --git a/data/tests/src/test_sheet_share_creation_and_management.rs b/data/tests/src/test_sheet_share_creation_and_management.rs
deleted file mode 100644
index 5123360..0000000
--- a/data/tests/src/test_sheet_share_creation_and_management.rs
+++ /dev/null
@@ -1,631 +0,0 @@
-use std::io::Error;
-
-use cfg_file::config::ConfigFile;
-use vcs_data::{
-    constants::SERVER_FILE_VAULT,
-    data::{
-        member::{Member, MemberId},
-        sheet::{SheetName, SheetPathBuf},
-        vault::{
-            Vault,
-            mapping_share::{Share, ShareMergeMode, SheetShareId},
-            vault_config::VaultConfig,
-            virtual_file::VirtualFileId,
-        },
-    },
-};
-
-use crate::get_test_dir;
-
-#[tokio::test]
-async fn test_share_creation_and_retrieval() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("share_creation").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").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 members
-    let sharer_id: MemberId = "sharer_member".to_string();
-    let target_member_id: MemberId = "target_member".to_string();
-
-    vault
-        .register_member_to_vault(Member::new(&sharer_id))
-        .await?;
-    vault
-        .register_member_to_vault(Member::new(&target_member_id))
-        .await?;
-
-    // Create source sheet for sharer
-    let source_sheet_name: SheetName = "source_sheet".to_string();
-    let _source_sheet = vault.create_sheet(&source_sheet_name, &sharer_id).await?;
-
-    // Create target sheet for target member
-    let target_sheet_name: SheetName = "target_sheet".to_string();
-    let _target_sheet = vault
-        .create_sheet(&target_sheet_name, &target_member_id)
-        .await?;
-
-    // Add mappings to source sheet
-    let mut source_sheet = vault.sheet(&source_sheet_name).await?;
-
-    let main_rs_path = SheetPathBuf::from("src/main.rs");
-    let lib_rs_path = SheetPathBuf::from("src/lib.rs");
-    let main_rs_id = VirtualFileId::from("main_rs_id_1");
-    let lib_rs_id = VirtualFileId::from("lib_rs_id_1");
-
-    source_sheet
-        .add_mapping(
-            main_rs_path.clone(),
-            main_rs_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-    source_sheet
-        .add_mapping(lib_rs_path.clone(), lib_rs_id.clone(), "1.0.0".to_string())
-        .await?;
-
-    // Persist source sheet
-    source_sheet.persist().await?;
-
-    // Test 1: Share mappings from source sheet to target sheet
-    let description = "Test share of main.rs and lib.rs".to_string();
-    // Need to get the sheet again after persist
-    let source_sheet = vault.sheet(&source_sheet_name).await?;
-
-    source_sheet
-        .share_mappings(
-            &target_sheet_name,
-            vec![main_rs_path.clone(), lib_rs_path.clone()],
-            &sharer_id,
-            description.clone(),
-        )
-        .await?;
-
-    // Test 2: Get shares from target sheet
-    let target_sheet = vault.sheet(&target_sheet_name).await?;
-
-    let shares = target_sheet.get_shares().await?;
-
-    assert_eq!(shares.len(), 1, "Expected 1 share, found {}", shares.len());
-    let share = &shares[0];
-
-    assert_eq!(share.sharer, sharer_id);
-    assert_eq!(share.description, description);
-    assert_eq!(share.from_sheet, source_sheet_name);
-    assert_eq!(share.mappings.len(), 2);
-    assert!(share.mappings.contains_key(&main_rs_path));
-    assert!(share.mappings.contains_key(&lib_rs_path));
-    assert!(share.path.is_some());
-
-    // Test 3: Get specific share by ID
-    let share_id = Share::gen_share_id(&sharer_id);
-    let _specific_share = target_sheet.get_share(&share_id).await;
-
-    // Note: The share ID might not match exactly due to random generation,
-    // but we can verify the share exists by checking the shares list
-    assert!(shares.iter().any(|s| s.sharer == sharer_id));
-
-    // Clean up
-    vault.remove_member_from_vault(&sharer_id)?;
-    vault.remove_member_from_vault(&target_member_id)?;
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_share_merge_modes() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("share_merge_modes").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").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 members
-    let sharer_id: MemberId = "sharer".to_string();
-    let target_member_id: MemberId = "target".to_string();
-
-    vault
-        .register_member_to_vault(Member::new(&sharer_id))
-        .await?;
-    vault
-        .register_member_to_vault(Member::new(&target_member_id))
-        .await?;
-
-    // Create source and target sheets
-    let source_sheet_name: SheetName = "source".to_string();
-    let target_sheet_name: SheetName = "target".to_string();
-
-    let _source_sheet = vault.create_sheet(&source_sheet_name, &sharer_id).await?;
-    let _target_sheet = vault
-        .create_sheet(&target_sheet_name, &target_member_id)
-        .await?;
-
-    // Add mappings to source sheet
-    let mut source_sheet = vault.sheet(&source_sheet_name).await?;
-
-    let file1_path = SheetPathBuf::from("src/file1.rs");
-    let file2_path = SheetPathBuf::from("src/file2.rs");
-    let file1_id = VirtualFileId::from("file1_id_1");
-    let file2_id = VirtualFileId::from("file2_id_1");
-
-    source_sheet
-        .add_mapping(file1_path.clone(), file1_id.clone(), "1.0.0".to_string())
-        .await?;
-    source_sheet
-        .add_mapping(file2_path.clone(), file2_id.clone(), "1.0.0".to_string())
-        .await?;
-
-    source_sheet.persist().await?;
-
-    // Share mappings
-    // Need to get the sheet again after persist
-    let source_sheet = vault.sheet(&source_sheet_name).await?;
-    source_sheet
-        .share_mappings(
-            &target_sheet_name,
-            vec![file1_path.clone(), file2_path.clone()],
-            &sharer_id,
-            "Test share".to_string(),
-        )
-        .await?;
-
-    // Get the share
-    let target_sheet = vault.sheet(&target_sheet_name).await?;
-    let shares = target_sheet.get_shares().await?;
-    assert_eq!(shares.len(), 1);
-    let share = shares[0].clone();
-
-    // Test 4: Safe mode merge (should succeed with no conflicts)
-    let result = target_sheet
-        .merge_share(share.clone(), ShareMergeMode::Safe)
-        .await;
-
-    assert!(
-        result.is_ok(),
-        "Safe mode should succeed with no conflicts "
-    );
-
-    // Verify mappings were added to target sheet
-    let updated_target_sheet = vault.sheet(&target_sheet_name).await?;
-    assert_eq!(updated_target_sheet.mapping().len(), 2);
-    assert!(updated_target_sheet.mapping().contains_key(&file1_path));
-    assert!(updated_target_sheet.mapping().contains_key(&file2_path));
-
-    // Clean up
-    vault.remove_member_from_vault(&sharer_id)?;
-    vault.remove_member_from_vault(&target_member_id)?;
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_share_merge_conflicts() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("share_conflicts").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").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 members
-    let sharer_id: MemberId = "sharer".to_string();
-    let target_member_id: MemberId = "target".to_string();
-
-    vault
-        .register_member_to_vault(Member::new(&sharer_id))
-        .await?;
-    vault
-        .register_member_to_vault(Member::new(&target_member_id))
-        .await?;
-
-    // Create source and target sheets
-    let source_sheet_name: SheetName = "source".to_string();
-    let target_sheet_name: SheetName = "target".to_string();
-
-    let _source_sheet = vault.create_sheet(&source_sheet_name, &sharer_id).await?;
-    let _target_sheet = vault
-        .create_sheet(&target_sheet_name, &target_member_id)
-        .await?;
-
-    // Add conflicting mappings to both sheets
-    let mut source_sheet = vault.sheet(&source_sheet_name).await?;
-    let mut target_sheet_mut = vault.sheet(&target_sheet_name).await?;
-
-    let conflicting_path = SheetPathBuf::from("src/conflicting.rs");
-    let source_file_id = VirtualFileId::from("source_file_id_1");
-    let target_file_id = VirtualFileId::from("target_file_id_1");
-
-    // Add same path with different IDs to both sheets (conflict)
-    source_sheet
-        .add_mapping(
-            conflicting_path.clone(),
-            source_file_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    target_sheet_mut
-        .add_mapping(
-            conflicting_path.clone(),
-            target_file_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    source_sheet.persist().await?;
-    target_sheet_mut.persist().await?;
-
-    // Share the conflicting mapping
-    // Need to get the sheet again after persist
-    let source_sheet = vault.sheet(&source_sheet_name).await?;
-    source_sheet
-        .share_mappings(
-            &target_sheet_name,
-            vec![conflicting_path.clone()],
-            &sharer_id,
-            "Conflicting share".to_string(),
-        )
-        .await?;
-
-    // Get the share
-    let target_sheet = vault.sheet(&target_sheet_name).await?;
-    let shares = target_sheet.get_shares().await?;
-    assert_eq!(shares.len(), 1);
-    let share = shares[0].clone();
-
-    // Test 5: Safe mode merge with conflict (should fail)
-    let target_sheet_clone = vault.sheet(&target_sheet_name).await?;
-    let result = target_sheet_clone
-        .merge_share(share.clone(), ShareMergeMode::Safe)
-        .await;
-
-    assert!(result.is_err(), "Safe mode should fail with conflicts");
-
-    // Test 6: Overwrite mode merge with conflict (should succeed)
-    let target_sheet_clone = vault.sheet(&target_sheet_name).await?;
-    let result = target_sheet_clone
-        .merge_share(share.clone(), ShareMergeMode::Overwrite)
-        .await;
-
-    assert!(
-        result.is_ok(),
-        "Overwrite mode should succeed with conflicts"
-    );
-
-    // Verify the mapping was overwritten
-    let updated_target_sheet = vault.sheet(&target_sheet_name).await?;
-    let mapping = updated_target_sheet.mapping().get(&conflicting_path);
-    assert!(mapping.is_some());
-    assert_eq!(mapping.unwrap().id, source_file_id); // Should be source's ID, not target's
-
-    // Clean up
-    vault.remove_member_from_vault(&sharer_id)?;
-    vault.remove_member_from_vault(&target_member_id)?;
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_share_skip_mode() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("share_skip_mode").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").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 members
-    let sharer_id: MemberId = "sharer".to_string();
-    let target_member_id: MemberId = "target".to_string();
-
-    vault
-        .register_member_to_vault(Member::new(&sharer_id))
-        .await?;
-    vault
-        .register_member_to_vault(Member::new(&target_member_id))
-        .await?;
-
-    // Create source and target sheets
-    let source_sheet_name: SheetName = "source".to_string();
-    let target_sheet_name: SheetName = "target".to_string();
-
-    let _source_sheet = vault.create_sheet(&source_sheet_name, &sharer_id).await?;
-    let _target_sheet = vault
-        .create_sheet(&target_sheet_name, &target_member_id)
-        .await?;
-
-    // Add mappings to both sheets
-    let mut source_sheet = vault.sheet(&source_sheet_name).await?;
-    let mut target_sheet_mut = vault.sheet(&target_sheet_name).await?;
-
-    let conflicting_path = SheetPathBuf::from("src/conflicting.rs");
-    let non_conflicting_path = SheetPathBuf::from("src/non_conflicting.rs");
-
-    let source_file_id = VirtualFileId::from("source_file_id_2");
-    let target_file_id = VirtualFileId::from("target_file_id_2");
-    let non_conflicting_id = VirtualFileId::from("non_conflicting_id_1");
-
-    // Add conflicting mapping to both sheets
-    source_sheet
-        .add_mapping(
-            conflicting_path.clone(),
-            source_file_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    target_sheet_mut
-        .add_mapping(
-            conflicting_path.clone(),
-            target_file_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    // Add non-conflicting mapping only to source
-    source_sheet
-        .add_mapping(
-            non_conflicting_path.clone(),
-            non_conflicting_id.clone(),
-            "1.0.0".to_string(),
-        )
-        .await?;
-
-    source_sheet.persist().await?;
-    target_sheet_mut.persist().await?;
-
-    // Share both mappings
-    // Need to get the sheet again after persist
-    let source_sheet = vault.sheet(&source_sheet_name).await?;
-    source_sheet
-        .share_mappings(
-            &target_sheet_name,
-            vec![conflicting_path.clone(), non_conflicting_path.clone()],
-            &sharer_id,
-            "Mixed share".to_string(),
-        )
-        .await?;
-
-    // Get the share
-    let target_sheet = vault.sheet(&target_sheet_name).await?;
-    let shares = target_sheet.get_shares().await?;
-    assert_eq!(shares.len(), 1);
-    let share = shares[0].clone();
-
-    // Test 7: Skip mode merge with conflict (should skip conflicting, add non-conflicting)
-    let result = target_sheet
-        .merge_share(share.clone(), ShareMergeMode::Skip)
-        .await;
-
-    assert!(result.is_ok(), "Skip mode should succeed");
-
-    // Verify only non-conflicting mapping was added
-    let updated_target_sheet = vault.sheet(&target_sheet_name).await?;
-
-    // Conflicting mapping should still have target's ID
-    let conflicting_mapping = updated_target_sheet.mapping().get(&conflicting_path);
-    assert!(conflicting_mapping.is_some());
-    assert_eq!(conflicting_mapping.unwrap().id, target_file_id);
-
-    // Non-conflicting mapping should be added
-    let non_conflicting_mapping = updated_target_sheet.mapping().get(&non_conflicting_path);
-    assert!(non_conflicting_mapping.is_some());
-    assert_eq!(non_conflicting_mapping.unwrap().id, non_conflicting_id);
-
-    // Clean up
-    vault.remove_member_from_vault(&sharer_id)?;
-    vault.remove_member_from_vault(&target_member_id)?;
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_share_removal() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("share_removal").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").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 members
-    let sharer_id: MemberId = "sharer".to_string();
-    let target_member_id: MemberId = "target".to_string();
-
-    vault
-        .register_member_to_vault(Member::new(&sharer_id))
-        .await?;
-    vault
-        .register_member_to_vault(Member::new(&target_member_id))
-        .await?;
-
-    // Create source and target sheets
-    let source_sheet_name: SheetName = "source".to_string();
-    let target_sheet_name: SheetName = "target".to_string();
-
-    let _source_sheet = vault.create_sheet(&source_sheet_name, &sharer_id).await?;
-    let _target_sheet = vault
-        .create_sheet(&target_sheet_name, &target_member_id)
-        .await?;
-
-    // Add mapping to source sheet
-    let mut source_sheet = vault.sheet(&source_sheet_name).await?;
-
-    let file_path = SheetPathBuf::from("src/file.rs");
-    let file_id = VirtualFileId::from("file_id_1");
-
-    source_sheet
-        .add_mapping(file_path.clone(), file_id.clone(), "1.0.0".to_string())
-        .await?;
-
-    source_sheet.persist().await?;
-
-    // Need to get the sheet again after persist
-    let source_sheet = vault.sheet(&source_sheet_name).await?;
-    // Share mapping
-    source_sheet
-        .share_mappings(
-            &target_sheet_name,
-            vec![file_path.clone()],
-            &sharer_id,
-            "Test share for removal".to_string(),
-        )
-        .await?;
-
-    // Get the share
-    let target_sheet = vault.sheet(&target_sheet_name).await?;
-    let shares = target_sheet.get_shares().await?;
-    assert_eq!(shares.len(), 1);
-    let share = shares[0].clone();
-
-    // Test 8: Remove share
-    let result = share.remove().await;
-
-    // Check if removal succeeded or failed gracefully
-    match result {
-        Ok(_) => {
-            // Share was successfully removed
-            let shares_after_removal = target_sheet.get_shares().await?;
-            assert_eq!(shares_after_removal.len(), 0);
-        }
-        Err((returned_share, _error)) => {
-            // Share removal failed, but we got the share backZ
-            // Error message may vary, just check that we got an error
-            // The share should be returned in the error
-            assert_eq!(returned_share.sharer, sharer_id);
-        }
-    }
-
-    // Clean up
-    vault.remove_member_from_vault(&sharer_id)?;
-    vault.remove_member_from_vault(&target_member_id)?;
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_share_error_conditions() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("share_errors").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").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 member
-    let sharer_id: MemberId = "sharer".to_string();
-    vault
-        .register_member_to_vault(Member::new(&sharer_id))
-        .await?;
-
-    // Create source sheet
-    let source_sheet_name: SheetName = "source".to_string();
-    let _source_sheet = vault.create_sheet(&source_sheet_name, &sharer_id).await?;
-
-    // Add mapping to source sheet
-    let mut source_sheet = vault.sheet(&source_sheet_name).await?;
-
-    let file_path = SheetPathBuf::from("src/file.rs");
-    let file_id = VirtualFileId::from("file_id_2");
-
-    source_sheet
-        .add_mapping(file_path.clone(), file_id.clone(), "1.0.0".to_string())
-        .await?;
-
-    source_sheet.persist().await?;
-
-    // Test 9: Share to non-existent sheet should fail
-    let non_existent_sheet: SheetName = "non_existent".to_string();
-    // Need to get the sheet again after persist
-    let source_sheet = vault.sheet(&source_sheet_name).await?;
-    let result = source_sheet
-        .share_mappings(
-            &non_existent_sheet,
-            vec![file_path.clone()],
-            &sharer_id,
-            "Test".to_string(),
-        )
-        .await;
-
-    assert!(result.is_err());
-
-    // Test 10: Share non-existent mapping should fail
-    let target_sheet_name: SheetName = "target".to_string();
-    let _target_sheet = vault.create_sheet(&target_sheet_name, &sharer_id).await?;
-
-    let non_existent_path = SheetPathBuf::from("src/non_existent.rs");
-    let result = source_sheet
-        .share_mappings(
-            &target_sheet_name,
-            vec![non_existent_path],
-            &sharer_id,
-            "Test".to_string(),
-        )
-        .await;
-
-    assert!(result.is_err());
-
-    // Test 11: Merge non-existent share should fail
-    let target_sheet = vault.sheet(&target_sheet_name).await?;
-    let non_existent_share_id: SheetShareId = "non_existent_share".to_string();
-    let result = target_sheet
-        .merge_share_by_id(&non_existent_share_id, ShareMergeMode::Safe)
-        .await;
-
-    assert!(result.is_err());
-
-    // Clean up
-    vault.remove_member_from_vault(&sharer_id)?;
-
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_share_id_generation() -> Result<(), std::io::Error> {
-    // Test 12: Share ID generation
-    let sharer_id: MemberId = "test_sharer".to_string();
-
-    // Generate multiple IDs to ensure they're different
-    let id1 = Share::gen_share_id(&sharer_id);
-    let id2 = Share::gen_share_id(&sharer_id);
-    let id3 = Share::gen_share_id(&sharer_id);
-
-    // IDs should be different due to random component
-    assert_ne!(id1, id2);
-    assert_ne!(id1, id3);
-    assert_ne!(id2, id3);
-
-    // IDs should start with sharer name
-    assert!(id1.starts_with(&format!("test_sharer@")));
-    assert!(id2.starts_with(&format!("test_sharer@")));
-    assert!(id3.starts_with(&format!("test_sharer@")));
-
-    Ok(())
-}
diff --git a/data/tests/src/test_vault_setup_and_member_register.rs b/data/tests/src/test_vault_setup_and_member_register.rs
deleted file mode 100644
index d34e48e..0000000
--- a/data/tests/src/test_vault_setup_and_member_register.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use std::io::Error;
-
-use cfg_file::config::ConfigFile;
-use vcs_data::{
-    constants::{
-        SERVER_FILE_MEMBER_INFO, SERVER_FILE_README, SERVER_FILE_VAULT, SERVER_PATH_MEMBER_PUB,
-        SERVER_PATH_MEMBERS, SERVER_PATH_SHEETS, SERVER_PATH_VF_ROOT,
-    },
-    data::{
-        member::Member,
-        vault::{Vault, vault_config::VaultConfig},
-    },
-};
-
-use crate::get_test_dir;
-
-#[tokio::test]
-async fn test_vault_setup_and_member_register() -> Result<(), std::io::Error> {
-    let dir = get_test_dir("member_register").await?;
-
-    // Setup vault
-    Vault::setup_vault(dir.clone(), "TestVault").await?;
-
-    // Check if the following files and directories are created in `dir`:
-    // Files: SERVER_FILE_VAULT, SERVER_FILE_README
-    // Directories: SERVER_PATH_SHEETS,
-    //              SERVER_PATH_MEMBERS,
-    //              SERVER_PATH_MEMBER_PUB,
-    //              SERVER_PATH_VIRTUAL_FILE_ROOT
-    assert!(dir.join(SERVER_FILE_VAULT).exists());
-    assert!(dir.join(SERVER_FILE_README).exists());
-    assert!(dir.join(SERVER_PATH_SHEETS).exists());
-    assert!(dir.join(SERVER_PATH_MEMBERS).exists());
-    assert!(dir.join(SERVER_PATH_MEMBER_PUB).exists());
-    assert!(dir.join(SERVER_PATH_VF_ROOT).exists());
-
-    // 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 member
-    let member_id = "test_member";
-    vault
-        .register_member_to_vault(Member::new(member_id))
-        .await?;
-
-    const ID_PARAM: &str = "{member_id}";
-
-    // Check if the member info file exists
-    assert!(
-        dir.join(SERVER_FILE_MEMBER_INFO.replace(ID_PARAM, member_id))
-            .exists()
-    );
-
-    // Remove member
-    vault.remove_member_from_vault(&member_id.to_string())?;
-
-    // Check if the member info file not exists
-    assert!(
-        !dir.join(SERVER_FILE_MEMBER_INFO.replace(ID_PARAM, member_id))
-            .exists()
-    );
-
-    Ok(())
-}
diff --git a/data/tests/src/test_virtual_file_creation_and_update.rs b/data/tests/src/test_virtual_file_creation_and_update.rs
deleted file mode 100644
index a09f7dc..0000000
--- a/data/tests/src/test_virtual_file_creation_and_update.rs
+++ /dev/null
@@ -1,162 +0,0 @@
-use std::time::Duration;
-
-use cfg_file::config::ConfigFile;
-use tcp_connection_test::{
-    handle::{ClientHandle, ServerHandle},
-    target::TcpServerTarget,
-    target_configure::ServerTargetConfig,
-};
-use tokio::{
-    join,
-    time::{sleep, timeout},
-};
-use vcs_data::{
-    constants::SERVER_FILE_VAULT,
-    data::{
-        member::Member,
-        vault::{Vault, vault_config::VaultConfig, virtual_file::VirtualFileVersionDescription},
-    },
-};
-
-use crate::get_test_dir;
-
-struct VirtualFileCreateClientHandle;
-struct VirtualFileCreateServerHandle;
-
-impl ClientHandle<VirtualFileCreateServerHandle> for VirtualFileCreateClientHandle {
-    async fn process(mut instance: tcp_connection::instance::ConnectionInstance) {
-        let dir = get_test_dir("virtual_file_creation_and_update_2")
-            .await
-            .unwrap();
-        // Create first test file for virtual file creation
-        let test_content_1 = b"Test file content for virtual file creation";
-        let temp_file_path_1 = dir.join("test_virtual_file_1.txt");
-
-        tokio::fs::write(&temp_file_path_1, test_content_1)
-            .await
-            .unwrap();
-
-        // Send the first file to server for virtual file creation
-        instance.write_file(&temp_file_path_1).await.unwrap();
-
-        // Create second test file for virtual file update
-        let test_content_2 = b"Updated test file content for virtual file";
-        let temp_file_path_2 = dir.join("test_virtual_file_2.txt");
-
-        tokio::fs::write(&temp_file_path_2, test_content_2)
-            .await
-            .unwrap();
-
-        // Send the second file to server for virtual file update
-        instance.write_file(&temp_file_path_2).await.unwrap();
-    }
-}
-
-impl ServerHandle<VirtualFileCreateClientHandle> for VirtualFileCreateServerHandle {
-    async fn process(mut instance: tcp_connection::instance::ConnectionInstance) {
-        let dir = get_test_dir("virtual_file_creation_and_update")
-            .await
-            .unwrap();
-
-        // Setup vault
-        Vault::setup_vault(dir.clone(), "TestVault").await.unwrap();
-
-        // Read vault
-        let Some(vault) = Vault::init(
-            VaultConfig::read_from(dir.join(SERVER_FILE_VAULT))
-                .await
-                .unwrap(),
-            &dir,
-        ) else {
-            panic!("No vault found!");
-        };
-
-        // Register member
-        let member_id = "test_member";
-        vault
-            .register_member_to_vault(Member::new(member_id))
-            .await
-            .unwrap();
-
-        // Create visual file
-        let virtual_file_id = vault
-            .create_virtual_file_from_connection(&mut instance, &member_id.to_string())
-            .await
-            .unwrap();
-
-        // Grant edit right to member
-        vault
-            .grant_virtual_file_edit_right(&member_id.to_string(), &virtual_file_id)
-            .await
-            .unwrap();
-
-        // Update visual file
-        vault
-            .update_virtual_file_from_connection(
-                &mut instance,
-                &member_id.to_string(),
-                &virtual_file_id,
-                &"2".to_string(),
-                VirtualFileVersionDescription {
-                    creator: member_id.to_string(),
-                    description: "Update".to_string(),
-                },
-            )
-            .await
-            .unwrap();
-    }
-}
-
-#[tokio::test]
-async fn test_virtual_file_creation_and_update() -> Result<(), std::io::Error> {
-    let host = "localhost:5009";
-
-    // Server setup
-    let Ok(server_target) = TcpServerTarget::<
-        VirtualFileCreateClientHandle,
-        VirtualFileCreateServerHandle,
-    >::from_domain(host)
-    .await
-    else {
-        panic!("Test target built failed from a domain named `{}`", host);
-    };
-
-    // Client setup
-    let Ok(client_target) = TcpServerTarget::<
-        VirtualFileCreateClientHandle,
-        VirtualFileCreateServerHandle,
-    >::from_domain(host)
-    .await
-    else {
-        panic!("Test target built failed from a domain named `{}`", host);
-    };
-
-    let future_server = async move {
-        // Only process once
-        let configured_server = server_target.server_cfg(ServerTargetConfig::default().once());
-
-        // Listen here
-        let _ = configured_server.listen().await;
-    };
-
-    let future_client = async move {
-        // Wait for server start
-        let _ = sleep(Duration::from_secs_f32(1.5)).await;
-
-        // Connect here
-        let _ = client_target.connect().await;
-    };
-
-    let test_timeout = Duration::from_secs(15);
-
-    timeout(test_timeout, async { join!(future_client, future_server) })
-        .await
-        .map_err(|_| {
-            std::io::Error::new(
-                std::io::ErrorKind::TimedOut,
-                format!("Test timed out after {:?}", test_timeout),
-            )
-        })?;
-
-    Ok(())
-}