wami 0.10.0

Who Am I - Multicloud Identity, IAM, STS, and SSO operations library for Rust
Documentation 
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

//! Application Service
//!
//! Orchestrates application operations.

use crate::error::Result;
use crate::provider::{AwsProvider, CloudProvider};
use crate::store::traits::ApplicationStore;
use crate::wami::sso_admin::application::Application;
use std::sync::{Arc, RwLock};

/// Service for managing applications
pub struct ApplicationService<S> {
    store: Arc<RwLock<S>>,
    #[allow(dead_code)]
    provider: Arc<dyn CloudProvider>,
}

impl<S: ApplicationStore> ApplicationService<S> {
    /// Create a new ApplicationService with default AWS provider
    pub fn new(store: Arc<RwLock<S>>) -> Self {
        Self {
            store,
            provider: Arc::new(AwsProvider::new()),
        }
    }

    /// Returns a new service instance with different provider
    pub fn with_provider(&self, provider: Arc<dyn CloudProvider>) -> Self {
        Self {
            store: self.store.clone(),
            provider,
        }
    }

    /// Create a new application
    pub async fn create_application(&self, application: Application) -> Result<Application> {
        self.store
            .write()
            .unwrap()
            .create_application(application)
            .await
    }

    /// Get an application by ARN
    pub async fn get_application(&self, application_arn: &str) -> Result<Option<Application>> {
        self.store
            .read()
            .unwrap()
            .get_application(application_arn)
            .await
    }

    /// List applications for an instance
    pub async fn list_applications(&self, instance_arn: &str) -> Result<Vec<Application>> {
        self.store
            .read()
            .unwrap()
            .list_applications(instance_arn)
            .await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::store::memory::InMemoryWamiStore;
    use chrono::Utc;

    fn setup_service() -> ApplicationService<InMemoryWamiStore> {
        let store = Arc::new(RwLock::new(InMemoryWamiStore::default()));
        ApplicationService::new(store)
    }

    fn create_test_application(name: &str, instance_arn: &str) -> Application {
        Application {
            application_arn: format!("arn:aws:sso:::application/{}/app-{}", instance_arn, name),
            name: name.to_string(),
            description: Some(format!("Test app {}", name)),
            instance_arn: instance_arn.to_string(),
            application_provider_arn: None,
            status: "ACTIVE".to_string(),
            created_date: Utc::now(),
            portal_url: Some(format!("https://{}.example.com", name)),
            wami_arn: format!("arn:wami:sso:::application/{}/app-{}", instance_arn, name),
            providers: vec![],
        }
    }

    #[tokio::test]
    async fn test_create_and_get_application() {
        let service = setup_service();
        let application = create_test_application("webapp", "instance-1");

        let created = service
            .create_application(application.clone())
            .await
            .unwrap();
        assert_eq!(created.name, "webapp");

        let retrieved = service
            .get_application(&application.application_arn)
            .await
            .unwrap();
        assert!(retrieved.is_some());
    }

    #[tokio::test]
    async fn test_list_applications() {
        let service = setup_service();
        let instance_arn = "instance-1";

        service
            .create_application(create_test_application("app1", instance_arn))
            .await
            .unwrap();
        service
            .create_application(create_test_application("app2", instance_arn))
            .await
            .unwrap();

        let applications = service.list_applications(instance_arn).await.unwrap();
        assert_eq!(applications.len(), 2);
    }
}