markbase/markbase-core/tests/user_share_integration.rs

use std::path::PathBuf;
use markbase_core::provider::{DataProvider, User, SqliteProvider};

#[cfg(test)]
mod integration_tests {
    use super::*;

    fn create_test_provider() -> SqliteProvider {
        // Use existing auth database for testing (relative to project root)
        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
        let db_path = format!("{}/../data/auth.sqlite", manifest_dir);
        SqliteProvider::new(&db_path).unwrap()
    }

    #[tokio::test]
    async fn test_user_workflow() {
        let provider = create_test_provider();
        
        // Use unique username to avoid conflicts
        let unique_name = format!("testuser_{}", std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs());
        
        // 1. Create user
        let user = User {
            username: unique_name.clone(),
            password_hash: "".to_string(),
            home_dir: PathBuf::from("/tmp/testuser"),
            uid: 1000,
            gid: 1000,
            permissions: "read,write".to_string(),
            status: 1,
        };
        
        provider.create_user(&user, "testpassword123").unwrap();
        
        // 2. Check user exists
        let loaded_user = provider.get_user(&unique_name).unwrap().unwrap();
        assert_eq!(loaded_user.username, unique_name);
        assert_eq!(loaded_user.home_dir, PathBuf::from("/tmp/testuser"));
        assert_eq!(loaded_user.status, 1);
        
        // 3. Verify password
        assert!(provider.check_password(&unique_name, "testpassword123").unwrap());
        assert!(!provider.check_password(&unique_name, "wrongpassword").unwrap());
        
        // 4. Get home directory
        let home_dir = provider.get_home_dir(&unique_name).unwrap().unwrap();
        assert_eq!(home_dir, "/tmp/testuser");
        
        // 5. Update user
        let updated_user = User {
            username: unique_name.clone(),
            password_hash: "".to_string(),
            home_dir: PathBuf::from("/tmp/testuser_updated"),
            uid: 1001,
            gid: 1001,
            permissions: "read".to_string(),
            status: 1,
        };
        
        provider.update_user(&updated_user, None).unwrap();
        
        let loaded_user = provider.get_user(&unique_name).unwrap().unwrap();
        assert_eq!(loaded_user.home_dir, PathBuf::from("/tmp/testuser_updated"));
        assert_eq!(loaded_user.uid, 1001);
        
        // 6. Reset password
        provider.reset_password(&unique_name, "newpassword456").unwrap();
        assert!(provider.check_password(&unique_name, "newpassword456").unwrap());
        assert!(!provider.check_password(&unique_name, "testpassword123").unwrap());
        
        // 7. List users
        let users = provider.list_users().unwrap();
        assert!(users.len() >= 1);
        assert!(users.iter().any(|u| u.username == unique_name));
        
        // 8. Delete user
        provider.delete_user(&unique_name).unwrap();
        assert!(provider.get_user(&unique_name).unwrap().is_none());
    }

    #[tokio::test]
    async fn test_multiple_users() {
        let provider = create_test_provider();
        
        // Use unique usernames to avoid conflicts
        let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
        let users_data = vec![
            (format!("alice_{}", timestamp), "/tmp/alice_home", "alicepass"),
            (format!("bob_{}", timestamp), "/tmp/bob_home", "bobpass"),
            (format!("charlie_{}", timestamp), "/tmp/charlie_home", "charliepass"),
        ];
        
        for (username, home_dir, password) in &users_data {
            let user = User {
                username: username.clone(),
                password_hash: "".to_string(),
                home_dir: PathBuf::from(home_dir),
                uid: 1000,
                gid: 1000,
                permissions: "read,write".to_string(),
                status: 1,
            };
            
            provider.create_user(&user, password).unwrap();
        }
        
        // 2. List all users
        let loaded_users = provider.list_users().unwrap();
        assert!(loaded_users.len() >= 3);
        
        // 3. Verify each user
        for (username, home_dir, password) in &users_data {
            let user = provider.get_user(username).unwrap().unwrap();
            assert_eq!(user.home_dir, PathBuf::from(home_dir));
            assert!(provider.check_password(username, password).unwrap());
        }
        
        // 4. Cleanup
        for (username, _, _) in &users_data {
            provider.delete_user(username).unwrap();
        }
        
        let remaining_users = provider.list_users().unwrap();
        assert!(!remaining_users.iter().any(|u| users_data.iter().any(|(name, _, _)| name == &u.username)));
    }

    #[tokio::test]
    async fn test_user_permissions() {
        let provider = create_test_provider();
        
        // Use unique usernames to avoid conflicts
        let timestamp = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
        
        // 1. Create admin user
        let admin = User {
            username: format!("admin_{}", timestamp),
            password_hash: "".to_string(),
            home_dir: PathBuf::from("/tmp/admin_home"),
            uid: 1000,
            gid: 1000,
            permissions: "read,write,delete,admin".to_string(),
            status: 1,
        };
        
        provider.create_user(&admin, "adminpass").unwrap();
        
        // 2. Create regular user
        let regular = User {
            username: format!("regular_{}", timestamp),
            password_hash: "".to_string(),
            home_dir: PathBuf::from("/tmp/regular_home"),
            uid: 1001,
            gid: 1001,
            permissions: "read".to_string(),
            status: 1,
        };
        
        provider.create_user(&regular, "regularpass").unwrap();
        
        // 3. Verify permissions
        let admin_user = provider.get_user(&format!("admin_{}", timestamp)).unwrap().unwrap();
        assert!(admin_user.permissions.contains("admin"));
        
        let regular_user = provider.get_user(&format!("regular_{}", timestamp)).unwrap().unwrap();
        assert!(regular_user.permissions.contains("read"));
        assert!(!regular_user.permissions.contains("admin"));
        
        // 4. Update regular user permissions
        let updated_regular = User {
            username: format!("regular_{}", timestamp),
            password_hash: "".to_string(),
            home_dir: PathBuf::from("/tmp/regular_home"),
            uid: 1001,
            gid: 1001,
            permissions: "read,write".to_string(),
            status: 1,
        };
        
        provider.update_user(&updated_regular, None).unwrap();
        
        let regular_user = provider.get_user(&format!("regular_{}", timestamp)).unwrap().unwrap();
        assert!(regular_user.permissions.contains("write"));
        
        // 5. Cleanup
        provider.delete_user(&format!("admin_{}", timestamp)).unwrap();
        provider.delete_user(&format!("regular_{}", timestamp)).unwrap();
    }
}