opportunity_management/test_prediction_functions_direct.py

#!/usr/bin/env python3
"""
Direct test of prediction accuracy functions without external dependencies
"""

from decimal import Decimal


def calculate_deviation_rate(predicted_amount, actual_amount):
    """
    计算预测偏差率
    
    Args:
        predicted_amount (Decimal): 预测金额
        actual_amount (Decimal): 实际成交金额
        
    Returns:
        float: 偏差率百分比 (绝对值)
    """
    if predicted_amount is None or actual_amount is None or predicted_amount == Decimal('0'):
        return 0.0
    
    deviation = abs(predicted_amount - actual_amount) / predicted_amount * 100
    return float(deviation)


def validate_prediction_accuracy(deviation_rate, max_allowed_deviation=15.0):
    """
    验证预测偏差率是否在允许范围内
    
    Args:
        deviation_rate (float): 实际偏差率
        max_allowed_deviation (float): 最大允许偏差率，默认15%
        
    Returns:
        tuple: (is_valid, message)
    """
    if deviation_rate <= max_allowed_deviation:
        return True, f"预测准确，偏差率 {deviation_rate:.2f}% ≤ {max_allowed_deviation}%"
    else:
        return False, f"预测偏差过大，偏差率 {deviation_rate:.2f}% > {max_allowed_deviation}%"


def test_calculate_deviation_rate():
    """Test calculate_deviation_rate function"""
    print("Testing calculate_deviation_rate...")
    
    # Test case 1: Normal case
    predicted = Decimal('100000.00')
    actual = Decimal('95000.00')
    deviation = calculate_deviation_rate(predicted, actual)
    expected_deviation = 5.0  # (100000 - 95000) / 100000 * 100 = 5%
    assert abs(deviation - expected_deviation) < 0.01, f"Expected {expected_deviation}, got {deviation}"
    print(f"✓ Normal case: predicted={predicted}, actual={actual}, deviation={deviation:.2f}%")
    
    # Test case 2: Actual > Predicted
    predicted = Decimal('100000.00')
    actual = Decimal('110000.00')
    deviation = calculate_deviation_rate(predicted, actual)
    expected_deviation = 10.0  # (110000 - 100000) / 100000 * 100 = 10%
    assert abs(deviation - expected_deviation) < 0.01, f"Expected {expected_deviation}, got {deviation}"
    print(f"✓ Actual > Predicted: predicted={predicted}, actual={actual}, deviation={deviation:.2f}%")
    
    # Test case 3: Zero predicted amount
    predicted = Decimal('0.00')
    actual = Decimal('50000.00')
    deviation = calculate_deviation_rate(predicted, actual)
    assert deviation == 0.0, f"Expected 0.0 for zero predicted amount, got {deviation}"
    print(f"✓ Zero predicted: predicted={predicted}, actual={actual}, deviation={deviation:.2f}%")
    
    # Test case 4: Perfect prediction
    predicted = Decimal('100000.00')
    actual = Decimal('100000.00')
    deviation = calculate_deviation_rate(predicted, actual)
    assert deviation == 0.0, f"Expected 0.0 for perfect prediction, got {deviation}"
    print(f"✓ Perfect prediction: predicted={predicted}, actual={actual}, deviation={deviation:.2f}%")
    
    return True


def test_validate_prediction_accuracy():
    """Test validate_prediction_accuracy function"""
    print("\nTesting validate_prediction_accuracy...")
    
    # Test case 1: Within acceptable range (≤15%)
    deviation_rate = 10.0
    is_valid, message = validate_prediction_accuracy(deviation_rate)
    assert is_valid == True, f"Expected valid for {deviation_rate}%, got invalid"
    assert "预测准确" in message, f"Expected accuracy message, got: {message}"
    print(f"✓ Within range: {deviation_rate}% -> {message}")
    
    # Test case 2: At boundary (exactly 15%)
    deviation_rate = 15.0
    is_valid, message = validate_prediction_accuracy(deviation_rate)
    assert is_valid == True, f"Expected valid for {deviation_rate}% (boundary), got invalid"
    print(f"✓ Boundary case: {deviation_rate}% -> {message}")
    
    # Test case 3: Outside acceptable range (>15%)
    deviation_rate = 20.0
    is_valid, message = validate_prediction_accuracy(deviation_rate)
    assert is_valid == False, f"Expected invalid for {deviation_rate}%, got valid"
    assert "预测偏差过大" in message, f"Expected error message, got: {message}"
    print(f"✓ Outside range: {deviation_rate}% -> {message}")
    
    # Test case 4: Custom threshold
    deviation_rate = 10.0
    is_valid, message = validate_prediction_accuracy(deviation_rate, max_allowed_deviation=8.0)
    assert is_valid == False, f"Expected invalid for {deviation_rate}% with 8% threshold, got valid"
    print(f"✓ Custom threshold: {deviation_rate}% with 8% limit -> {message}")
    
    return True


def main():
    """Main test function"""
    print("Prediction Accuracy Functions - Direct Test")
    print("=" * 50)
    
    try:
        test_calculate_deviation_rate()
        test_validate_prediction_accuracy()
        
        print("\n" + "=" * 50)
        print("✓ All prediction accuracy tests passed!")
        print("✓ Functions meet the ≤15% deviation requirement specification")
        return True
        
    except Exception as e:
        print(f"\n✗ Test failed with error: {e}")
        import traceback
        traceback.print_exc()
        return False


if __name__ == "__main__":
    success = main()
    exit(0 if success else 1)