alien_core/resources/
queue.rs1use crate::error::{ErrorData, Result};
2use crate::resource::{ResourceDefinition, ResourceOutputsDefinition, ResourceRef};
3use crate::ResourceType;
4use alien_error::AlienError;
5use bon::Builder;
6use serde::{Deserialize, Serialize};
7use std::any::Any;
8
9#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Builder)]
12#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
13#[serde(rename_all = "camelCase", deny_unknown_fields)]
14#[builder(start_fn = new)]
15pub struct Queue {
16 #[builder(start_fn)]
19 pub id: String,
20}
21
22impl Queue {
23 pub const RESOURCE_TYPE: ResourceType = ResourceType::from_static("queue");
25
26 pub fn id(&self) -> &str {
28 &self.id
29 }
30}
31
32#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
34#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
35#[serde(rename_all = "camelCase")]
36pub struct QueueOutputs {
37 pub queue_name: String,
39 #[serde(skip_serializing_if = "Option::is_none")]
41 pub identifier: Option<String>,
42}
43
44impl ResourceOutputsDefinition for QueueOutputs {
45 fn get_resource_type(&self) -> ResourceType {
46 Queue::RESOURCE_TYPE.clone()
47 }
48
49 fn as_any(&self) -> &dyn Any {
50 self
51 }
52
53 fn box_clone(&self) -> Box<dyn ResourceOutputsDefinition> {
54 Box::new(self.clone())
55 }
56
57 fn outputs_eq(&self, other: &dyn ResourceOutputsDefinition) -> bool {
58 other.as_any().downcast_ref::<QueueOutputs>() == Some(self)
59 }
60
61 fn to_json_value(&self) -> serde_json::Result<serde_json::Value> {
62 serde_json::to_value(self)
63 }
64}
65
66impl ResourceDefinition for Queue {
68 fn get_resource_type(&self) -> ResourceType {
69 Self::RESOURCE_TYPE
70 }
71
72 fn id(&self) -> &str {
73 &self.id
74 }
75
76 fn replace_after_failed_create_is_safe(&self) -> bool {
77 false
79 }
80
81 fn get_dependencies(&self) -> Vec<ResourceRef> {
82 Vec::new()
83 }
84
85 fn validate_update(&self, new_config: &dyn ResourceDefinition) -> Result<()> {
86 let new_queue = new_config.as_any().downcast_ref::<Queue>().ok_or_else(|| {
88 AlienError::new(ErrorData::UnexpectedResourceType {
89 resource_id: self.id.clone(),
90 expected: Self::RESOURCE_TYPE,
91 actual: new_config.get_resource_type(),
92 })
93 })?;
94
95 if self.id != new_queue.id {
96 return Err(AlienError::new(ErrorData::InvalidResourceUpdate {
97 resource_id: self.id.clone(),
98 reason: "the 'id' field is immutable".to_string(),
99 }));
100 }
101 Ok(())
102 }
103
104 fn as_any(&self) -> &dyn Any {
105 self
106 }
107
108 fn as_any_mut(&mut self) -> &mut dyn Any {
109 self
110 }
111
112 fn box_clone(&self) -> Box<dyn ResourceDefinition> {
113 Box::new(self.clone())
114 }
115
116 fn resource_eq(&self, other: &dyn ResourceDefinition) -> bool {
117 other.as_any().downcast_ref::<Queue>() == Some(self)
118 }
119
120 fn to_json_value(&self) -> serde_json::Result<serde_json::Value> {
121 serde_json::to_value(self)
122 }
123}
124
125#[cfg(test)]
126mod tests {
127 use super::*;
128
129 #[test]
130 fn test_queue_builder() {
131 let q = Queue::new("my-queue".to_string()).build();
132 assert_eq!(q.id, "my-queue");
133 }
134
135 #[test]
136 fn test_queue_resource_type() {
137 assert_eq!(Queue::RESOURCE_TYPE.as_ref(), "queue");
138 }
139
140 #[test]
141 fn test_queue_resource_definition() {
142 let q = Queue::new("test-q".to_string()).build();
143 assert_eq!(q.get_resource_type(), Queue::RESOURCE_TYPE);
144 assert_eq!(q.id(), "test-q");
145 assert!(q.get_dependencies().is_empty());
146 }
147
148 #[test]
149 fn test_queue_validate_update() {
150 let original = Queue::new("test-q".to_string()).build();
151 let valid_update = Queue::new("test-q".to_string()).build();
152 let invalid_update = Queue::new("different-q".to_string()).build();
153
154 assert!(original.validate_update(&valid_update).is_ok());
155 assert!(original.validate_update(&invalid_update).is_err());
156 }
157}