infisical-api 0.1.1

A rust API wrapper for the open source Infisical secret manager API
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

use std::vec;

use infisical_api::{api::models::SecretToCreate, utils::aes256gcm::encrypt};
use tokio;
mod common;

#[tokio::test]
async fn get_decrypted_project_secrets() {
    let env_vars = common::setup().unwrap();

    let infisical_client = infisical_api::Client::new(&env_vars.api_key).unwrap();

    let private_key = infisical_client
        .get_user_decrypted_private_key(&env_vars.secret)
        .await
        .unwrap();

    let project_key = infisical_client
        .get_decrypted_project_key(&env_vars.workspace_id, &private_key)
        .await
        .unwrap();

    let _decrypted_keys = infisical_client
        .get_decrypted_project_secrets(&env_vars.workspace_id, &env_vars.environment, &project_key)
        .await
        .unwrap();
}

#[tokio::test]
async fn add_secret() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let private_key = client
        .get_user_decrypted_private_key(&env_vars.secret)
        .await
        .unwrap();
    let project_key = client
        .get_decrypted_project_key(&env_vars.workspace_id, &private_key)
        .await
        .unwrap();

    let secret = SecretToCreate {
        key: encrypt("EXTRA_SPECIAL_SECRET", &project_key)
            .unwrap()
            .into(),
        value: encrypt("THIS IS THE VALUE OF THE SECRET", &project_key)
            .unwrap()
            .into(),
        comment: encrypt("This is my comment for the secret", &project_key)
            .unwrap()
            .into(),
        secret_type: "shared".to_string(),
    };

    let _result = client
        .create_project_secrets(&env_vars.workspace_id, &env_vars.environment, vec![secret])
        .await
        .unwrap();
}

#[tokio::test]
async fn get_my_user() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _user = client.get_user().await.unwrap();
}

#[tokio::test]
async fn get_my_organizations() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _orgs = client.get_my_organizations().await.unwrap();
}

#[tokio::test]
async fn get_organization_projects() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _projects = client
        .get_organization_projects(&env_vars.organization_id)
        .await
        .unwrap();
}

#[tokio::test]
async fn get_organization_memberships() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _memberships = client
        .get_organization_memberships(&env_vars.organization_id)
        .await
        .unwrap();
}

#[tokio::test]
async fn get_project_memberships() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _proj_memberships = client
        .get_project_memberships(&env_vars.workspace_id)
        .await
        .unwrap();
}

#[tokio::test]
async fn get_project_snapshots() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _snapshots = client
        .get_project_snapshots(&env_vars.workspace_id, "0", "25")
        .await
        .unwrap();
}

#[tokio::test]
async fn get_project_logs() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    let _logs = client.get_project_logs(&env_vars.workspace_id, "", "0", "25", "", "");
}

#[tokio::test]
async fn get_secret_versions() {
    let env_vars = common::setup().unwrap();

    let client = infisical_api::Client::new(&env_vars.api_key).unwrap();
    // let _versions = client.get
}