agent-deploy-contract 0.3.1

Transport-neutral deploy contracts for Agent Infra
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

use serde::{Deserialize, Serialize};

use crate::{CursorPage, GitLabVisibility, OwnerRef};

pub type RuntimeRepositoryRecordPage = CursorPage<RuntimeRepositoryRecord>;

#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum RuntimeRepositoryStatus {
    Importing,
    #[default]
    Ready,
    Failed,
}

impl RuntimeRepositoryStatus {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Importing => "importing",
            Self::Ready => "ready",
            Self::Failed => "failed",
        }
    }

    pub fn parse(value: &str) -> Self {
        match value.trim() {
            "importing" => Self::Importing,
            "failed" => Self::Failed,
            _ => Self::Ready,
        }
    }

    pub fn from_gitlab_import(import_status: Option<&str>, default_branch: Option<&str>) -> Self {
        match import_status.map(str::trim).unwrap_or_default() {
            "failed" => Self::Failed,
            "scheduled" | "started" => Self::Importing,
            "finished" => Self::Ready,
            "none" | "" if default_branch.is_some() => Self::Ready,
            _ => Self::Importing,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct RuntimeRepositoryRecord {
    pub id: String,
    pub tenant_id: String,
    pub project_id: String,
    pub template_id: String,
    pub owners: Vec<OwnerRef>,
    pub namespace: String,
    pub gitlab_project_id: u64,
    pub path_with_namespace: String,
    /// HTTPS clone URL derived from GitLab. Not an identity key; clients clone locally.
    pub repository_url: String,
    pub default_branch: Option<String>,
    #[serde(default)]
    pub status: RuntimeRepositoryStatus,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error_message: Option<String>,
    pub version: i64,
    pub created_at: String,
    pub updated_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct CreateRuntimeRepositoryRequest {
    pub template_id: String,
    pub project_name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub project_path: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub namespace: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default)]
    pub visibility: GitLabVisibility,
    #[serde(default)]
    pub owners: Vec<OwnerRef>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn gitlab_import_status_maps_to_repository_status() {
        assert_eq!(
            RuntimeRepositoryStatus::from_gitlab_import(Some("started"), None),
            RuntimeRepositoryStatus::Importing
        );
        assert_eq!(
            RuntimeRepositoryStatus::from_gitlab_import(Some("finished"), Some("master")),
            RuntimeRepositoryStatus::Ready
        );
        assert_eq!(
            RuntimeRepositoryStatus::from_gitlab_import(Some("none"), Some("master")),
            RuntimeRepositoryStatus::Ready
        );
        assert_eq!(
            RuntimeRepositoryStatus::from_gitlab_import(Some("none"), None),
            RuntimeRepositoryStatus::Importing
        );
        assert_eq!(
            RuntimeRepositoryStatus::from_gitlab_import(Some("failed"), None),
            RuntimeRepositoryStatus::Failed
        );
    }

    #[test]
    fn record_defaults_missing_status_to_ready() {
        let record: RuntimeRepositoryRecord = serde_json::from_value(serde_json::json!({
            "id": "rrepo-1",
            "tenantId": "local",
            "projectId": "default",
            "templateId": "rtpl-1",
            "owners": [],
            "namespace": "runtimes",
            "gitlabProjectId": 1,
            "pathWithNamespace": "runtimes/demo",
            "repositoryUrl": "https://git.test/runtimes/demo.git",
            "defaultBranch": "master",
            "version": 1,
            "createdAt": "t",
            "updatedAt": "t"
        }))
        .unwrap();
        assert_eq!(record.status, RuntimeRepositoryStatus::Ready);
        assert_eq!(record.error_message, None);
    }
}