blueprint-manager 0.4.0-alpha.3

Tangle Blueprint manager and Runner
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use super::provider_selector::{
    CloudProvider, ProviderPreferences, ProviderSelector, ResourceSpec,
};
use super::service::{RemoteDeploymentPolicy, RemoteDeploymentService};

#[tokio::test]
async fn test_provider_selection_integration() -> Result<(), Box<dyn std::error::Error>> {
    // Test GPU workload selection
    let selector = ProviderSelector::with_defaults();
    let gpu_spec = ResourceSpec {
        cpu: 4.0,
        memory_gb: 16.0,
        storage_gb: 100.0,
        gpu_count: Some(1),
        allow_spot: false,
        tee_required: false,
    };

    let provider = selector.select_provider(&gpu_spec)?;
    assert_eq!(
        provider,
        CloudProvider::RunPod,
        "GPU workloads should select RunPod first (decentralized marketplace > hyperscaler)"
    );

    // Test CPU-intensive workload selection
    let cpu_spec = ResourceSpec {
        cpu: 16.0,
        memory_gb: 32.0,
        storage_gb: 200.0,
        gpu_count: None,
        allow_spot: false,
        tee_required: false,
    };

    let provider = selector.select_provider(&cpu_spec)?;
    assert_eq!(
        provider,
        CloudProvider::Hetzner,
        "CPU-intensive workloads should select Hetzner first (cheapest dedicated cores)"
    );

    // Test cost-optimized workload selection
    let cost_spec = ResourceSpec {
        cpu: 2.0,
        memory_gb: 4.0,
        storage_gb: 20.0,
        gpu_count: None,
        allow_spot: true,
        tee_required: false,
    };

    let provider = selector.select_provider(&cost_spec)?;
    assert_eq!(
        provider,
        CloudProvider::VastAi,
        "Cost-optimized spot workloads should select VastAi first (cheapest spot marketplace)"
    );

    Ok(())
}

#[tokio::test]
async fn test_remote_deployment_service_integration() -> Result<(), Box<dyn std::error::Error>> {
    let policy = RemoteDeploymentPolicy {
        provider_preferences: ProviderPreferences::default(),
        max_hourly_cost: Some(10.0),
        prefer_spot: true,
        auto_terminate_hours: Some(2),
        tee_required: false,
        tee_backend: None,
    };

    let service = RemoteDeploymentService::new(policy).await?;

    // Test deployment registry initially empty
    let deployments = service.list_deployments().await;
    assert!(
        deployments.is_empty(),
        "Initial deployment registry should be empty"
    );

    // Test cleanup of expired deployments (should not error on empty registry)
    service.cleanup_expired_deployments().await?;

    Ok(())
}

#[tokio::test]
async fn test_custom_provider_preferences() -> Result<(), Box<dyn std::error::Error>> {
    let custom_preferences = ProviderPreferences {
        gpu_providers: vec![CloudProvider::AWS, CloudProvider::Azure],
        cpu_intensive: vec![CloudProvider::DigitalOcean, CloudProvider::GCP],
        memory_intensive: vec![CloudProvider::Azure, CloudProvider::Vultr],
        cost_optimized: vec![CloudProvider::DigitalOcean, CloudProvider::Vultr],
        tee_capable: vec![CloudProvider::Azure, CloudProvider::AWS],
    };

    let selector = ProviderSelector::new(custom_preferences);

    // Test custom GPU preference
    let gpu_spec = ResourceSpec {
        cpu: 4.0,
        memory_gb: 16.0,
        storage_gb: 100.0,
        gpu_count: Some(1),
        allow_spot: false,
        tee_required: false,
    };

    let provider = selector.select_provider(&gpu_spec)?;
    assert_eq!(
        provider,
        CloudProvider::AWS,
        "Custom GPU preferences should select AWS first"
    );

    Ok(())
}

#[tokio::test]
async fn test_fallback_providers() -> Result<(), Box<dyn std::error::Error>> {
    let selector = ProviderSelector::with_defaults();

    let gpu_spec = ResourceSpec {
        cpu: 4.0,
        memory_gb: 16.0,
        storage_gb: 100.0,
        gpu_count: Some(1),
        allow_spot: false,
        tee_required: false,
    };

    let fallbacks = selector.get_fallback_providers(&gpu_spec);

    // Should include CPU-intensive providers as fallback for GPU workloads
    assert!(
        fallbacks.contains(&CloudProvider::Vultr),
        "Should have Vultr as fallback"
    );
    assert!(
        fallbacks.contains(&CloudProvider::DigitalOcean),
        "Should have DigitalOcean as fallback"
    );

    // Should not include the primary selection (GCP)
    assert!(
        !fallbacks.contains(&CloudProvider::GCP),
        "Should not include primary provider in fallbacks"
    );

    Ok(())
}