Skip to main content

hoist_core/resources/
alias.rs

1//! Alias resource definition
2
3use serde::{Deserialize, Serialize};
4use serde_json::Value;
5
6use super::traits::{Resource, ResourceKind};
7
8/// Azure AI Search Alias definition
9///
10/// Aliases provide stable endpoint names that point to one or more indexes,
11/// enabling zero-downtime reindexing by swapping which index an alias points to.
12#[derive(Debug, Clone, Serialize, Deserialize)]
13#[serde(rename_all = "camelCase")]
14pub struct Alias {
15    pub name: String,
16    pub indexes: Vec<String>,
17    #[serde(flatten)]
18    pub extra: std::collections::HashMap<String, Value>,
19}
20
21impl Resource for Alias {
22    fn kind() -> ResourceKind {
23        ResourceKind::Alias
24    }
25
26    fn name(&self) -> &str {
27        &self.name
28    }
29
30    fn dependencies(&self) -> Vec<(ResourceKind, String)> {
31        self.indexes
32            .iter()
33            .map(|idx| (ResourceKind::Index, idx.clone()))
34            .collect()
35    }
36}
37
38#[cfg(test)]
39mod tests {
40    use super::*;
41    use serde_json::json;
42
43    #[test]
44    fn test_alias_kind() {
45        assert_eq!(Alias::kind(), ResourceKind::Alias);
46    }
47
48    #[test]
49    fn test_alias_default_volatile_fields() {
50        let fields = Alias::volatile_fields();
51        assert_eq!(fields, &["@odata.etag", "@odata.context"]);
52    }
53
54    #[test]
55    fn test_alias_identity_key() {
56        assert_eq!(Alias::identity_key(), "name");
57    }
58
59    #[test]
60    fn test_alias_deserialize() {
61        let val = json!({
62            "name": "my-alias",
63            "indexes": ["hotels-v1"]
64        });
65        let alias: Alias = serde_json::from_value(val).unwrap();
66        assert_eq!(alias.name, "my-alias");
67        assert_eq!(alias.indexes, vec!["hotels-v1"]);
68    }
69
70    #[test]
71    fn test_alias_dependencies() {
72        let alias = Alias {
73            name: "my-alias".to_string(),
74            indexes: vec!["index-a".to_string(), "index-b".to_string()],
75            extra: Default::default(),
76        };
77        let deps = alias.dependencies();
78        assert_eq!(deps.len(), 2);
79        assert_eq!(deps[0], (ResourceKind::Index, "index-a".to_string()));
80        assert_eq!(deps[1], (ResourceKind::Index, "index-b".to_string()));
81    }
82
83    #[test]
84    fn test_alias_roundtrip() {
85        let val = json!({
86            "name": "roundtrip-alias",
87            "indexes": ["idx-1", "idx-2"]
88        });
89        let alias: Alias = serde_json::from_value(val).unwrap();
90        let serialized = serde_json::to_string(&alias).unwrap();
91        let deserialized: Alias = serde_json::from_str(&serialized).unwrap();
92        assert_eq!(deserialized.name, "roundtrip-alias");
93        assert_eq!(deserialized.indexes, vec!["idx-1", "idx-2"]);
94    }
95}