init projectmycelium

tests/tests_archive/test_staking_functionality.rs

@@ -0,0 +1,144 @@
+#[cfg(test)]
+mod tests {
+    use threefold_marketplace::services::farmer::FarmerService;
+    use threefold_marketplace::services::user_persistence::UserPersistence;
+    use threefold_marketplace::models::user::NodeStakingOptions;
+    use rust_decimal::Decimal;
+
+    #[test]
+    fn test_staking_end_to_end_flow() {
+        // Test the complete staking flow for user1
+        let user_email = "user1@example.com";
+        let farmer_service = FarmerService::builder().build().unwrap();
+        
+        // Clean up any existing staking data first
+        let user_data = UserPersistence::load_user_data(user_email);
+        assert!(user_data.is_some(), "User1 data should exist");
+        
+        let user_data = user_data.unwrap();
+        
+        // Unstake from all nodes to start with a clean state
+        for node in &user_data.nodes {
+            if let Some(staking_options) = &node.staking_options {
+                if staking_options.staking_enabled {
+                    let _ = farmer_service.unstake_from_node(user_email, &node.id);
+                }
+            }
+        }
+        
+        // Reload user data after cleanup
+        let user_data = UserPersistence::load_user_data(user_email).unwrap();
+        println!("Initial wallet balance: {}", user_data.wallet_balance_usd);
+        println!("Number of nodes: {}", user_data.nodes.len());
+        
+        // Verify user has sufficient balance (should be 11000 TFP)
+        assert!(user_data.wallet_balance_usd >= Decimal::from(100), "User should have at least 100 TFP");
+        
+        // Verify user has nodes to stake on
+        assert!(!user_data.nodes.is_empty(), "User should have nodes");
+        
+        let first_node = &user_data.nodes[0];
+        println!("First node ID: {}", first_node.id);
+        println!("First node name: {}", first_node.name);
+        
+        // Test staking 100 TFP on the first node
+        let staking_options = NodeStakingOptions {
+            staking_enabled: true,
+            staked_amount: Decimal::from(100),
+            staking_start_date: None, // Will be set by the service
+            staking_period_months: 12,
+            early_withdrawal_allowed: true,
+            early_withdrawal_penalty_percent: 5.0,
+        };
+        
+        // Perform staking
+        let stake_result = farmer_service.stake_on_node(user_email, &first_node.id, staking_options);
+        
+        match stake_result {
+            Ok(()) => {
+                println!("✅ Staking successful!");
+                
+                // Verify the staking was applied
+                let updated_data = UserPersistence::load_user_data(user_email).unwrap();
+                
+                // Check wallet balance decreased
+                let expected_balance = user_data.wallet_balance_usd - Decimal::from(100);
+                assert_eq!(updated_data.wallet_balance_usd, expected_balance, 
+                          "Wallet balance should decrease by staked amount");
+                
+                // Check node has staking options
+                let updated_node = updated_data.nodes.iter()
+                    .find(|n| n.id == first_node.id)
+                    .expect("Node should still exist");
+                
+                assert!(updated_node.staking_options.is_some(), "Node should have staking options");
+                let node_staking = updated_node.staking_options.as_ref().unwrap();
+                assert!(node_staking.staking_enabled, "Staking should be enabled");
+                assert_eq!(node_staking.staked_amount, Decimal::from(100), "Staked amount should be 100");
+                
+                println!("✅ All staking verifications passed!");
+                
+                // Test getting staking statistics
+                let stats = farmer_service.get_staking_statistics(user_email);
+                assert_eq!(stats.total_staked_amount, Decimal::from(100), "Total staked should be 100");
+                assert_eq!(stats.staked_nodes_count, 1, "Should have 1 staked node");
+                
+                println!("✅ Staking statistics correct!");
+                
+                // Test unstaking
+                let unstake_result = farmer_service.unstake_from_node(user_email, &first_node.id);
+                match unstake_result {
+                    Ok(returned_amount) => {
+                        println!("✅ Unstaking successful! Returned: {} TFP", returned_amount);
+                        
+                        // Verify unstaking
+                        let final_data = UserPersistence::load_user_data(user_email).unwrap();
+                        let final_node = final_data.nodes.iter()
+                            .find(|n| n.id == first_node.id)
+                            .expect("Node should still exist");
+                        
+                        assert!(final_node.staking_options.is_none(), "Node should not have staking options after unstaking");
+                        
+                        println!("✅ Complete staking flow test passed!");
+                    }
+                    Err(e) => {
+                        println!("❌ Unstaking failed: {}", e);
+                        panic!("Unstaking should succeed");
+                    }
+                }
+            }
+            Err(e) => {
+                println!("❌ Staking failed: {}", e);
+                panic!("Staking should succeed with sufficient balance");
+            }
+        }
+    }
+    
+    #[test]
+    fn test_insufficient_balance_staking() {
+        let user_email = "user1@example.com";
+        let farmer_service = FarmerService::builder().build().unwrap();
+        
+        let user_data = UserPersistence::load_user_data(user_email).unwrap();
+        let first_node = &user_data.nodes[0];
+        
+        // Try to stake more than available balance
+        let excessive_amount = user_data.wallet_balance_usd + Decimal::from(1000);
+        let staking_options = NodeStakingOptions {
+            staking_enabled: true,
+            staked_amount: excessive_amount,
+            staking_start_date: None,
+            staking_period_months: 12,
+            early_withdrawal_allowed: true,
+            early_withdrawal_penalty_percent: 5.0,
+        };
+        
+        let result = farmer_service.stake_on_node(user_email, &first_node.id, staking_options);
+        assert!(result.is_err(), "Staking should fail with insufficient balance");
+        
+        let error_msg = result.unwrap_err();
+        assert!(error_msg.contains("Insufficient balance"), "Error should mention insufficient balance");
+        
+        println!("✅ Insufficient balance test passed!");
+    }
+}