kaji 0.0.1

Steer your Keycloak configuration to a stable, declared state.
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

mod common;
use anyhow::Result;
use kaji::args::{Cli, Commands};
use kaji::{init_client, init_secrets, load_profile};
use std::fs;
use tempfile::tempdir;

#[tokio::test]
async fn test_profile_loading() -> Result<()> {
    let dir = tempdir().unwrap();
    let workspace = dir.path();
    let profiles_dir = workspace.join("profiles");
    fs::create_dir(&profiles_dir)?;

    let profile_content = r#"
server_url: "https://mock.prod.example.com"
client_id: "prod-cli"
client_secret: "prod-secret"
user: "prod-admin"
password: "prod-password"
secrets_file: ".secrets.prod"
"#;
    fs::write(profiles_dir.join("prod.yaml"), profile_content)?;

    // Test load_profile
    let profile = load_profile(workspace, "prod").await?;
    assert_eq!(profile.server_url, "https://mock.prod.example.com");
    assert_eq!(profile.client_id, Some("prod-cli".to_string()));
    assert_eq!(profile.user, Some("prod-admin".to_string()));

    Ok(())
}

#[tokio::test]
async fn test_init_client_with_profile() -> Result<()> {
    use common::start_mock_server;
    let mock_url = start_mock_server().await;

    let dir = tempdir().unwrap();
    let workspace = dir.path();
    let profiles_dir = workspace.join("profiles");
    fs::create_dir(&profiles_dir)?;

    let profile_content = format!(
        r#"
server_url: "{}"
client_id: "admin-cli"
client_secret: "secret"
"#,
        mock_url
    );
    fs::write(profiles_dir.join("test.yaml"), profile_content)?;

    let cli = Cli {
        command: Commands::Drift {
            workspace: workspace.to_path_buf(),
        },
        server: None, // Required unless profile is present
        realms: vec![],
        user: None,
        password: None,
        client_id: "ignored".to_string(),
        client_secret: None,
        profile: Some("test".to_string()),
        vault_addr: None,
        vault_token: None,
    };

    let profile = load_profile(workspace, "test").await?;
    let client = init_client(&cli, Some(&profile)).await?;
    assert_eq!(client.get_base_url(), mock_url);

    Ok(())
}

#[tokio::test]
async fn test_init_secrets_with_profile() -> Result<()> {
    let dir = tempdir().unwrap();
    let workspace = dir.path();

    // Create profile-specific secrets file
    fs::write(
        workspace.join(".secrets.prod"),
        "KEYCLOAK_PROD_API_KEY=supersecret",
    )?;

    let profile = kaji::Profile {
        server_url: "http://localhost:8080".to_string(),
        client_id: None,
        client_secret: None,
        user: None,
        password: None,
        secrets_file: Some(".secrets.prod".to_string()),
        vault_addr: None,
        vault_token: None,
    };

    let cli = Cli {
        command: Commands::Validate {
            workspace: workspace.to_path_buf(),
        },
        server: None,
        realms: vec![],
        user: None,
        password: None,
        client_id: "admin-cli".to_string(),
        client_secret: None,
        profile: Some("prod".to_string()),
        vault_addr: None,
        vault_token: None,
    };

    let resolver = init_secrets(&cli, workspace, Some(&profile)).await?;
    let resolved = resolver.resolve("KEYCLOAK_PROD_API_KEY").await?;
    assert_eq!(resolved, Some("supersecret".to_string()));

    Ok(())
}