Rename `env` to `vcs`

4 files changed, 272 insertions, 0 deletions

diff --git a/crates/vcs/vcs_test/Cargo.toml b/crates/vcs/vcs_test/Cargo.toml
new file mode 100644
index 0000000..0ed51d8
--- /dev/null
+++ b/crates/vcs/vcs_test/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "vcs_test"
+edition = "2024"
+version.workspace = true
+
+[dependencies]
+tcp_connection = { path = "../../utils/tcp_connection" }
+cfg_file = { path = "../../utils/cfg_file", features = ["default"] }
+vcs = { path = "../../vcs" }
+
+# Async & Networking
+tokio = { version = "1.46.1", features = ["full"] }
diff --git a/crates/vcs/vcs_test/src/lib.rs b/crates/vcs/vcs_test/src/lib.rs
new file mode 100644
index 0000000..357ea3f
--- /dev/null
+++ b/crates/vcs/vcs_test/src/lib.rs
@@ -0,0 +1,21 @@
+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;
+
+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/crates/vcs/vcs_test/src/test_vault_setup_and_member_register.rs b/crates/vcs/vcs_test/src/test_vault_setup_and_member_register.rs
new file mode 100644
index 0000000..e84a411
--- /dev/null
+++ b/crates/vcs/vcs_test/src/test_vault_setup_and_member_register.rs
@@ -0,0 +1,69 @@
+use std::io::Error;
+
+use cfg_file::config::ConfigFile;
+use env::{
+    constants::{
+        SERVER_FILE_MEMBER_INFO, SERVER_FILE_README, SERVER_FILE_VAULT, SERVER_PATH_MEMBER_PUB,
+        SERVER_PATH_MEMBERS, SERVER_PATH_SHEETS, SERVER_PATH_VIRTUAL_FILE_ROOT,
+    },
+    workspace::{
+        member::Member,
+        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()).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_VIRTUAL_FILE_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_eq!(
+        dir.join(SERVER_FILE_MEMBER_INFO.replace(ID_PARAM, member_id))
+            .exists(),
+        true
+    );
+
+    // Remove member
+    vault.remove_member_from_vault(&member_id.to_string())?;
+
+    // Check if the member info file not exists
+    assert_eq!(
+        dir.join(SERVER_FILE_MEMBER_INFO.replace(ID_PARAM, member_id))
+            .exists(),
+        false
+    );
+
+    Ok(())
+}
diff --git a/crates/vcs/vcs_test/src/test_virtual_file_creation_and_update.rs b/crates/vcs/vcs_test/src/test_virtual_file_creation_and_update.rs
new file mode 100644
index 0000000..7da2bef
--- /dev/null
+++ b/crates/vcs/vcs_test/src/test_virtual_file_creation_and_update.rs
@@ -0,0 +1,170 @@
+use std::time::Duration;
+
+use cfg_file::config::ConfigFile;
+use env::{
+    constants::SERVER_FILE_VAULT,
+    workspace::{
+        member::Member,
+        vault::{Vault, config::VaultConfig, virtual_file::VirtualFileVersionDescription},
+    },
+};
+use tcp_connection::{
+    handle::{ClientHandle, ServerHandle},
+    target::TcpServerTarget,
+    target_configure::ServerTargetConfig,
+};
+use tokio::{
+    join,
+    time::{sleep, timeout},
+};
+
+use crate::get_test_dir;
+
+struct VirtualFileCreateClientHandle;
+struct VirtualFileCreateServerHandle;
+
+impl ClientHandle<VirtualFileCreateServerHandle> for VirtualFileCreateClientHandle {
+    fn process(
+        mut instance: tcp_connection::instance::ConnectionInstance,
+    ) -> impl Future<Output = ()> + Send {
+        async move {
+            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 {
+    fn process(
+        mut instance: tcp_connection::instance::ConnectionInstance,
+    ) -> impl Future<Output = ()> + Send {
+        async move {
+            let dir = get_test_dir("virtual_file_creation_and_update")
+                .await
+                .unwrap();
+
+            // Setup vault
+            Vault::setup_vault(dir.clone()).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(())
+}