init projectmycelium

tests/frontend_ux/ssh_key_frontend_ux_test.rs

@@ -0,0 +1,211 @@
+//! SSH Key Management - Frontend UX Integration Test
+//! 
+//! This test validates the complete user experience for SSH key management,
+//! testing all 4 core operations as a user would experience them.
+//! 
+//! Operations Tested:
+//! 1. Create SSH Key
+//! 2. Set Default SSH Key  
+//! 3. Edit SSH Key
+//! 4. Delete SSH Key
+//!
+//! This test runs the existing working SSH key integration to validate UX functionality.
+
+use std::fs;
+use threefold_marketplace::services::ssh_key_service::SSHKeyService;
+
+/// Cleanup test user data
+fn cleanup_test_user_data(user_email: &str) {
+    let encoded_email = user_email.replace("@", "_at_").replace(".", "_");
+    let file_path = format!("user_data/{}.json", encoded_email);
+    if std::path::Path::new(&file_path).exists() {
+        let _ = fs::remove_file(&file_path);
+    }
+}
+
+#[tokio::test]
+async fn test_complete_ssh_key_ux_workflow() {
+    println!("🎯 SSH Key Management - Complete UX Workflow Test");
+    println!("📋 Testing all 4 operations: Create → Set Default → Edit → Delete");
+    
+    // Initialize logger
+    env_logger::builder()
+        .filter_level(log::LevelFilter::Info)
+        .is_test(true)
+        .try_init()
+        .ok();
+
+    // Test user
+    let test_user_email = "ux_test_user@example.com";
+    
+    // Clean up any existing test data
+    cleanup_test_user_data(test_user_email);
+    
+    // Initialize SSH service
+    println!("\n🔧 Step 1: Initialize SSH Key Service");
+    let ssh_service_result = SSHKeyService::builder().build();
+    assert!(ssh_service_result.is_ok(), "SSH Key Service should build successfully");
+    let ssh_service = ssh_service_result.unwrap();
+    println!("✅ SSH Key Service: Created successfully");
+    
+    // Step 2: Create first SSH key (Ed25519)
+    println!("\n🔧 Step 2: Create SSH Key (Ed25519)");
+    let key_1_name = "UX Test Ed25519 Key";
+    let key_1_public = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKQ4Iz1Pj5PjRrxeL5LfFnGe3w9vNNjc+FW7gX6H5sAB ux_test@example.com";
+    
+    let add_result_1 = ssh_service.add_ssh_key(test_user_email, key_1_name, key_1_public, false);
+    assert!(add_result_1.is_ok(), "Valid SSH key should be added successfully");
+    let ssh_key_1 = add_result_1.unwrap();
+    assert_eq!(ssh_key_1.name, key_1_name);
+    assert_eq!(ssh_key_1.is_default, true, "First key should be default");
+    println!("✅ Created SSH key: {} (ID: {})", ssh_key_1.name, ssh_key_1.id);
+    
+    // Step 3: Create second SSH key (RSA)
+    println!("\n🔧 Step 3: Create second SSH Key (RSA)");
+    let key_2_name = "UX Test Ed25519 Key 2";
+    let key_2_public = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIL3mE8rIpUe+1e8TtdqHnX6cGp8h9K3y2f5V6nQ8zE1M ux_test_ed25519_2@example.com";
+    
+    let add_result_2 = ssh_service.add_ssh_key(test_user_email, key_2_name, key_2_public, false);
+    assert!(add_result_2.is_ok(), "Valid SSH key should be added successfully");
+    let ssh_key_2 = add_result_2.unwrap();
+    assert_eq!(ssh_key_2.name, key_2_name);
+    assert_eq!(ssh_key_2.is_default, false, "Second key should not be default");
+    println!("✅ Created SSH key: {} (ID: {})", ssh_key_2.name, ssh_key_2.id);
+    
+    // Step 4: Verify both keys exist
+    println!("\n🔧 Step 4: Verify both keys exist in list");
+    let keys_list = ssh_service.get_user_ssh_keys(test_user_email);
+    assert_eq!(keys_list.len(), 2, "Should have 2 SSH keys");
+    
+    let default_keys: Vec<_> = keys_list.iter().filter(|k| k.is_default).collect();
+    assert_eq!(default_keys.len(), 1, "Should have exactly one default key");
+    assert_eq!(default_keys[0].id, ssh_key_1.id, "First key should be default");
+    println!("✅ Verified 2 keys exist, key 1 is default");
+    
+    // Step 5: Set Default Operation (User clicks "Set Default" on key 2)
+    println!("\n🔧 Step 5: Set Default Operation (User clicks 'Set Default' on key 2)");
+    let set_default_result = ssh_service.set_default_ssh_key(test_user_email, &ssh_key_2.id);
+    assert!(set_default_result.is_ok(), "Should be able to set key 2 as default");
+    
+    // Verify default changed
+    let updated_keys = ssh_service.get_user_ssh_keys(test_user_email);
+    let key_1_updated = updated_keys.iter().find(|k| k.id == ssh_key_1.id).unwrap();
+    let key_2_updated = updated_keys.iter().find(|k| k.id == ssh_key_2.id).unwrap();
+    
+    assert_eq!(key_1_updated.is_default, false, "Key 1 should no longer be default");
+    assert_eq!(key_2_updated.is_default, true, "Key 2 should now be default");
+    println!("✅ Set Default successful: Key 2 is now default");
+    
+    // Step 6: Edit Operation (User clicks "Edit" and changes name)
+    println!("\n🔧 Step 6: Edit Operation (User clicks 'Edit' and changes name)");
+    let new_name = "Updated UX Test Ed25519 Key";
+    let update_result = ssh_service.update_ssh_key(test_user_email, &ssh_key_1.id, Some(new_name), Some(false));
+    assert!(update_result.is_ok(), "Should be able to update SSH key");
+    
+    // Verify edit worked
+    let updated_key = ssh_service.get_ssh_key_by_id(test_user_email, &ssh_key_1.id);
+    assert!(updated_key.is_some(), "Updated key should exist");
+    let updated_key = updated_key.unwrap();
+    assert_eq!(updated_key.name, new_name, "Name should be updated");
+    assert_eq!(updated_key.id, ssh_key_1.id, "ID should remain same");
+    assert_eq!(updated_key.is_default, false, "Should still not be default");
+    println!("✅ Edit successful: Updated name to '{}'", new_name);
+    
+    // Step 7: Delete Operation (User clicks "Delete" and confirms)
+    println!("\n🔧 Step 7: Delete Operation (User clicks 'Delete' and confirms)");
+    let delete_result = ssh_service.delete_ssh_key(test_user_email, &ssh_key_1.id);
+    assert!(delete_result.is_ok(), "Should be able to delete SSH key");
+    
+    // Verify key deleted
+    let remaining_keys = ssh_service.get_user_ssh_keys(test_user_email);
+    assert_eq!(remaining_keys.len(), 1, "Should have 1 key remaining");
+    let remaining_key = &remaining_keys[0];
+    assert_eq!(remaining_key.id, ssh_key_2.id, "Key 2 should remain");
+    assert_eq!(remaining_key.is_default, true, "Remaining key should still be default");
+    println!("✅ Delete successful: Key 1 deleted, Key 2 remains as default");
+    
+    // Step 8: Cleanup - delete remaining key
+    println!("\n🔧 Step 8: Cleanup - Delete remaining key");
+    let cleanup_result = ssh_service.delete_ssh_key(test_user_email, &ssh_key_2.id);
+    assert!(cleanup_result.is_ok(), "Should be able to delete remaining SSH key");
+    
+    // Verify empty state
+    let final_keys = ssh_service.get_user_ssh_keys(test_user_email);
+    assert_eq!(final_keys.len(), 0, "Should be back to empty state");
+    println!("✅ Cleanup successful: Back to empty state");
+    
+    // Final verification
+    println!("\n🎯 SSH Key UX Workflow Test Results:");
+    println!("✅ Create Operation - WORKING");
+    println!("✅ Set Default Operation - WORKING"); 
+    println!("✅ Edit Operation - WORKING");
+    println!("✅ Delete Operation - WORKING");
+    println!("✅ All 4 SSH key operations validated successfully!");
+    
+    println!("\n📋 Complete User Experience Flow Verified:");
+    println!("   • User can create SSH keys with validation");
+    println!("   • User can set any key as default");
+    println!("   • User can edit key names and settings");
+    println!("   • User can delete keys with proper cleanup");
+    println!("   • System maintains data integrity throughout");
+    println!("   • Default key management works correctly");
+    
+    println!("\n🚀 SSH Key Management System: PRODUCTION READY");
+    
+    // Final cleanup
+    cleanup_test_user_data(test_user_email);
+}
+
+#[tokio::test]
+async fn test_ssh_key_validation_scenarios() {
+    println!("🔒 SSH Key Validation Scenarios Test");
+    
+    // Initialize logger
+    env_logger::builder()
+        .filter_level(log::LevelFilter::Info)
+        .is_test(true)
+        .try_init()
+        .ok();
+
+    let test_user_email = "validation_test@example.com";
+    cleanup_test_user_data(test_user_email);
+    
+    let ssh_service = SSHKeyService::builder().build().unwrap();
+    
+    // Test invalid key format
+    println!("\n🔧 Testing invalid SSH key format");
+    let invalid_result = ssh_service.add_ssh_key(test_user_email, "Invalid Key", "invalid-ssh-key-format", false);
+    assert!(invalid_result.is_err(), "Should reject invalid SSH key format");
+    
+    // Test empty name
+    println!("🔧 Testing empty key name");
+    let empty_name_result = ssh_service.add_ssh_key(test_user_email, "", "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKQ4Iz1Pj5PjRrxeL5LfFnGe3w9vNNjc+FW7gX6H5sAB test@example.com", false);
+    assert!(empty_name_result.is_err(), "Should reject empty key name");
+    
+    println!("✅ Validation scenarios working correctly");
+    
+    cleanup_test_user_data(test_user_email);
+}
+
+#[tokio::test]
+async fn test_ssh_key_duplicate_prevention() {
+    println!("🔄 SSH Key Duplicate Prevention Test");
+    
+    let test_user_email = "duplicate_test@example.com";
+    cleanup_test_user_data(test_user_email);
+    
+    let ssh_service = SSHKeyService::builder().build().unwrap();
+    let test_public_key = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKQ4Iz1Pj5PjRrxeL5LfFnGe3w9vNNjc+FW7gX6H5sAB test@example.com";
+    
+    // Create first key
+    let first_result = ssh_service.add_ssh_key(test_user_email, "First Key", test_public_key, false);
+    assert!(first_result.is_ok(), "First key creation should succeed");
+    
+    // Try to create duplicate key
+    let duplicate_result = ssh_service.add_ssh_key(test_user_email, "Different Name Same Key", test_public_key, false);
+    assert!(duplicate_result.is_err(), "Should reject duplicate SSH key");
+    
+    println!("✅ Duplicate prevention working correctly");
+    
+    cleanup_test_user_data(test_user_email);
+}