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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

mod common;
use kaji::client::KeycloakClient;
use kaji::plan::components::{check_keys_drift, plan_components_or_keys};
use kaji::plan::{PlanContext, PlanOptions};
use kaji::utils::ui::DialoguerUi;
use std::sync::Arc;
use tempfile::tempdir;
use tokio::fs;

#[tokio::test]
async fn test_plan_components_no_dir() {
    let client = KeycloakClient::new("http://localhost:8080".to_string());
    let dir = tempdir().unwrap();
    let workspace_dir = dir.path();
    let resolver = Arc::new(kaji::utils::secrets::EnvResolver::new(
        std::collections::HashMap::new(),
    )) as Arc<dyn kaji::utils::secrets::SecretResolver>;
    let ui = DialoguerUi::new();

    let options = PlanOptions {
        changes_only: false,
        interactive: false,
    };

    let ctx = PlanContext {
        client: &client,
        workspace_dir,
        options,
        resolver,
        realm_name: "master",
        ui: &ui,
        profile: None,
    };

    // Should not fail if directory doesn't exist
    let res = plan_components_or_keys(&ctx, "non-existent").await;
    assert!(res.is_ok());
}

#[tokio::test]
async fn test_check_keys_drift_fail() {
    // Client that will fail to connect
    let client = KeycloakClient::new("http://localhost:1".to_string());
    let options = PlanOptions {
        changes_only: true,
        interactive: false,
    };
    let res = check_keys_drift(&client, options, "master").await;
    // check_keys_drift ignores error if not available
    assert!(res.is_ok());
}

#[tokio::test]
async fn test_plan_components_with_invalid_yaml() {
    let client = KeycloakClient::new("http://localhost:8080".to_string());
    let dir = tempdir().unwrap();
    let workspace_dir = dir.path();
    let components_dir = workspace_dir.join("components");
    fs::create_dir_all(&components_dir).await.unwrap();
    fs::write(components_dir.join("bad.yaml"), "invalid: [ :")
        .await
        .unwrap();

    let resolver = Arc::new(kaji::utils::secrets::EnvResolver::new(
        std::collections::HashMap::new(),
    )) as Arc<dyn kaji::utils::secrets::SecretResolver>;
    let ui = DialoguerUi::new();

    let options = PlanOptions {
        changes_only: false,
        interactive: false,
    };

    let ctx = PlanContext {
        client: &client,
        workspace_dir,
        options,
        resolver,
        realm_name: "master",
        ui: &ui,
        profile: None,
    };

    let res = plan_components_or_keys(&ctx, "components").await;
    assert!(res.is_err());
}

#[tokio::test]
async fn test_check_keys_drift_warning() {
    let mock_url = common::start_mock_server().await;
    let mut client = KeycloakClient::new(mock_url);
    client.set_target_realm("test-realm".to_string());

    let options = PlanOptions {
        changes_only: true,
        interactive: false,
    };

    // This should run and print a warning (we can't easily assert on stdout here without more effort,
    // but we can ensure it doesn't crash and hits the logic)
    let res = check_keys_drift(&client, options, "test-realm").await;
    assert!(res.is_ok());
}

#[tokio::test]
async fn test_plan_components_no_identity() {
    let client = KeycloakClient::new("http://localhost:8080".to_string());
    let dir = tempdir().unwrap();
    let workspace_dir = dir.path();
    let resolver = Arc::new(kaji::utils::secrets::EnvResolver::new(
        std::collections::HashMap::new(),
    )) as Arc<dyn kaji::utils::secrets::SecretResolver>;
    let ui = DialoguerUi::new();

    let options = PlanOptions {
        changes_only: false,
        interactive: false,
    };

    let ctx = PlanContext {
        client: &client,
        workspace_dir,
        options,
        resolver,
        realm_name: "master",
        ui: &ui,
        profile: None,
    };

    let components_dir = workspace_dir.join("components");
    fs::create_dir_all(&components_dir).await.unwrap();
    // Component with NO name and NO id (missing both)
    fs::write(components_dir.join("empty.yaml"), "providerId: ldap\n")
        .await
        .unwrap();

    let res = plan_components_or_keys(&ctx, "components").await;
    // It should fail to get identity
    assert!(res.is_err());
}