rusticity_term/cfn/
mod.rs

1pub mod actions;
2
3use crate::common::{translate_column, ColumnId, UTC_TIMESTAMP_WIDTH};
4use crate::ui::cfn::DetailTab;
5use crate::ui::table::Column as TableColumn;
6use ratatui::prelude::*;
7use std::collections::HashMap;
8
9pub fn init(i18n: &mut HashMap<String, String>) {
10    for col in [
11        Column::Name,
12        Column::StackId,
13        Column::Status,
14        Column::CreatedTime,
15        Column::UpdatedTime,
16        Column::DeletedTime,
17        Column::DriftStatus,
18        Column::LastDriftCheckTime,
19        Column::StatusReason,
20        Column::Description,
21    ] {
22        i18n.entry(col.id().to_string())
23            .or_insert_with(|| col.default_name().to_string());
24    }
25    for col in crate::ui::cfn::ParameterColumn::all() {
26        i18n.entry(col.id().to_string())
27            .or_insert_with(|| col.default_name().to_string());
28    }
29    for col in crate::ui::cfn::OutputColumn::all() {
30        i18n.entry(col.id().to_string())
31            .or_insert_with(|| col.default_name().to_string());
32    }
33    for col in crate::ui::cfn::ResourceColumn::all() {
34        i18n.entry(col.id().to_string())
35            .or_insert_with(|| col.default_name().to_string());
36    }
37}
38
39pub fn console_url_stacks(region: &str) -> String {
40    format!(
41        "https://{}.console.aws.amazon.com/cloudformation/home?region={}#/stacks",
42        region, region
43    )
44}
45
46pub fn console_url_stack_detail(region: &str, stack_name: &str, stack_id: &str) -> String {
47    format!(
48        "https://{}.console.aws.amazon.com/cloudformation/home?region={}#/stacks/{}?filteringText=&filteringStatus=active&viewNested=true&stackId={}",
49        region, region, stack_name, stack_id
50    )
51}
52
53pub fn console_url_stack_detail_with_tab(region: &str, stack_id: &str, tab: &DetailTab) -> String {
54    let tab_path = match tab {
55        DetailTab::StackInfo => "stackinfo",
56        DetailTab::Events => "events",
57        DetailTab::Resources => "resources",
58        DetailTab::Outputs => "outputs",
59        DetailTab::Parameters => "parameters",
60        DetailTab::Template => "template",
61        DetailTab::ChangeSets => "changesets",
62        DetailTab::GitSync => "gitsync",
63    };
64    let encoded_arn = urlencoding::encode(stack_id);
65    // The ChangeSets tab requires the extra eventsView=graph query parameter
66    let extra = if matches!(tab, DetailTab::ChangeSets) {
67        "&eventsView=graph"
68    } else {
69        ""
70    };
71    format!(
72        "https://{}.console.aws.amazon.com/cloudformation/home?region={}#/stacks/{}?filteringText=&filteringStatus=active&viewNested=true&stackId={}{}",
73        region, region, tab_path, encoded_arn, extra
74    )
75}
76
77#[derive(Debug, Clone)]
78pub struct Stack {
79    pub name: String,
80    pub stack_id: String,
81    pub status: String,
82    pub created_time: String,
83    pub updated_time: String,
84    pub deleted_time: String,
85    pub drift_status: String,
86    pub last_drift_check_time: String,
87    pub status_reason: String,
88    pub description: String,
89    pub detailed_status: String,
90    pub root_stack: String,
91    pub parent_stack: String,
92    pub termination_protection: bool,
93    pub iam_role: String,
94    pub tags: Vec<(String, String)>,
95    pub stack_policy: String,
96    pub rollback_monitoring_time: String,
97    pub rollback_alarms: Vec<String>,
98    pub notification_arns: Vec<String>,
99}
100
101#[derive(Debug, Clone, Copy, PartialEq)]
102pub enum Column {
103    Name,
104    StackId,
105    Status,
106    CreatedTime,
107    UpdatedTime,
108    DeletedTime,
109    DriftStatus,
110    LastDriftCheckTime,
111    StatusReason,
112    Description,
113}
114
115impl Column {
116    const ID_NAME: &'static str = "column.cfn.stack.name";
117    const ID_STACK_ID: &'static str = "column.cfn.stack.stack_id";
118    const ID_STATUS: &'static str = "column.cfn.stack.status";
119    const ID_CREATED_TIME: &'static str = "column.cfn.stack.created_time";
120    const ID_UPDATED_TIME: &'static str = "column.cfn.stack.updated_time";
121    const ID_DELETED_TIME: &'static str = "column.cfn.stack.deleted_time";
122    const ID_DRIFT_STATUS: &'static str = "column.cfn.stack.drift_status";
123    const ID_LAST_DRIFT_CHECK_TIME: &'static str = "column.cfn.stack.last_drift_check_time";
124    const ID_STATUS_REASON: &'static str = "column.cfn.stack.status_reason";
125    const ID_DESCRIPTION: &'static str = "column.cfn.stack.description";
126
127    pub const fn id(&self) -> &'static str {
128        match self {
129            Column::Name => Self::ID_NAME,
130            Column::StackId => Self::ID_STACK_ID,
131            Column::Status => Self::ID_STATUS,
132            Column::CreatedTime => Self::ID_CREATED_TIME,
133            Column::UpdatedTime => Self::ID_UPDATED_TIME,
134            Column::DeletedTime => Self::ID_DELETED_TIME,
135            Column::DriftStatus => Self::ID_DRIFT_STATUS,
136            Column::LastDriftCheckTime => Self::ID_LAST_DRIFT_CHECK_TIME,
137            Column::StatusReason => Self::ID_STATUS_REASON,
138            Column::Description => Self::ID_DESCRIPTION,
139        }
140    }
141
142    pub const fn default_name(&self) -> &'static str {
143        match self {
144            Column::Name => "Stack Name",
145            Column::StackId => "Stack ID",
146            Column::Status => "Status",
147            Column::CreatedTime => "Created Time",
148            Column::UpdatedTime => "Updated Time",
149            Column::DeletedTime => "Deleted Time",
150            Column::DriftStatus => "Drift Status",
151            Column::LastDriftCheckTime => "Last Drift Check Time",
152            Column::StatusReason => "Status Reason",
153            Column::Description => "Description",
154        }
155    }
156
157    pub fn name(&self) -> String {
158        translate_column(self.id(), self.default_name())
159    }
160
161    pub fn from_id(id: &str) -> Option<Self> {
162        match id {
163            Self::ID_NAME => Some(Column::Name),
164            Self::ID_STACK_ID => Some(Column::StackId),
165            Self::ID_STATUS => Some(Column::Status),
166            Self::ID_CREATED_TIME => Some(Column::CreatedTime),
167            Self::ID_UPDATED_TIME => Some(Column::UpdatedTime),
168            Self::ID_DELETED_TIME => Some(Column::DeletedTime),
169            Self::ID_DRIFT_STATUS => Some(Column::DriftStatus),
170            Self::ID_LAST_DRIFT_CHECK_TIME => Some(Column::LastDriftCheckTime),
171            Self::ID_STATUS_REASON => Some(Column::StatusReason),
172            Self::ID_DESCRIPTION => Some(Column::Description),
173            _ => None,
174        }
175    }
176
177    pub fn all() -> [Column; 10] {
178        [
179            Column::Name,
180            Column::StackId,
181            Column::Status,
182            Column::CreatedTime,
183            Column::UpdatedTime,
184            Column::DeletedTime,
185            Column::DriftStatus,
186            Column::LastDriftCheckTime,
187            Column::StatusReason,
188            Column::Description,
189        ]
190    }
191
192    pub fn ids() -> Vec<ColumnId> {
193        Self::all().iter().map(|c| c.id()).collect()
194    }
195
196    pub fn to_column(&self) -> Box<dyn TableColumn<&Stack>> {
197        struct StackColumn {
198            variant: Column,
199        }
200
201        impl TableColumn<&Stack> for StackColumn {
202            fn name(&self) -> &str {
203                Box::leak(self.variant.name().into_boxed_str())
204            }
205
206            fn width(&self) -> u16 {
207                let translated = translate_column(self.variant.id(), self.variant.default_name());
208                translated.len().max(match self.variant {
209                    Column::Name => 30,
210                    Column::StackId => 20,
211                    Column::Status => 35,
212                    Column::CreatedTime
213                    | Column::UpdatedTime
214                    | Column::DeletedTime
215                    | Column::LastDriftCheckTime => UTC_TIMESTAMP_WIDTH as usize,
216                    Column::DriftStatus => 20,
217                    Column::StatusReason | Column::Description => 50,
218                }) as u16
219            }
220
221            fn render(&self, item: &&Stack) -> (String, Style) {
222                match self.variant {
223                    Column::Name => (item.name.clone(), Style::default()),
224                    Column::StackId => (item.stack_id.clone(), Style::default()),
225                    Column::Status => {
226                        let (formatted, color) = format_status(&item.status);
227                        (formatted, Style::default().fg(color))
228                    }
229                    Column::CreatedTime => (item.created_time.clone(), Style::default()),
230                    Column::UpdatedTime => (item.updated_time.clone(), Style::default()),
231                    Column::DeletedTime => (item.deleted_time.clone(), Style::default()),
232                    Column::DriftStatus => (item.drift_status.clone(), Style::default()),
233                    Column::LastDriftCheckTime => {
234                        (item.last_drift_check_time.clone(), Style::default())
235                    }
236                    Column::StatusReason => (item.status_reason.clone(), Style::default()),
237                    Column::Description => (item.description.clone(), Style::default()),
238                }
239            }
240        }
241
242        Box::new(StackColumn { variant: *self })
243    }
244}
245
246pub fn format_status(status: &str) -> (String, ratatui::style::Color) {
247    let (emoji, color) = match status {
248        "UPDATE_COMPLETE" | "CREATE_COMPLETE" | "DELETE_COMPLETE" | "IMPORT_COMPLETE" => {
249            ("✅ ", ratatui::style::Color::Green)
250        }
251        "ROLLBACK_COMPLETE"
252        | "UPDATE_ROLLBACK_COMPLETE"
253        | "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"
254        | "UPDATE_FAILED"
255        | "CREATE_FAILED"
256        | "DELETE_FAILED"
257        | "ROLLBACK_FAILED"
258        | "UPDATE_ROLLBACK_FAILED"
259        | "IMPORT_ROLLBACK_FAILED"
260        | "IMPORT_ROLLBACK_COMPLETE" => ("❌ ", ratatui::style::Color::Red),
261        "UPDATE_IN_PROGRESS"
262        | "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"
263        | "DELETE_IN_PROGRESS"
264        | "CREATE_IN_PROGRESS"
265        | "ROLLBACK_IN_PROGRESS"
266        | "UPDATE_ROLLBACK_IN_PROGRESS"
267        | "REVIEW_IN_PROGRESS"
268        | "IMPORT_IN_PROGRESS"
269        | "IMPORT_ROLLBACK_IN_PROGRESS" => ("ℹ️  ", ratatui::style::Color::Blue),
270        _ => ("", ratatui::style::Color::White),
271    };
272
273    (format!("{}{}", emoji, status), color)
274}
275
276#[cfg(test)]
277mod tests {
278    use super::*;
279    use crate::common::{CyclicEnum, SortDirection};
280    use crate::ui::cfn::{DetailTab, State, StatusFilter};
281
282    #[test]
283    fn test_state_default() {
284        let state = State::default();
285        assert_eq!(state.table.items.len(), 0);
286        assert_eq!(state.table.selected, 0);
287        assert!(!state.table.loading);
288        assert_eq!(state.table.filter, "");
289        assert_eq!(state.status_filter, StatusFilter::All);
290        assert!(!state.view_nested);
291        assert_eq!(state.table.expanded_item, None);
292        assert_eq!(state.current_stack, None);
293        assert_eq!(state.detail_tab, DetailTab::StackInfo);
294        assert_eq!(state.overview_scroll, 0);
295        assert_eq!(state.sort_column, Column::CreatedTime);
296        assert_eq!(state.sort_direction, SortDirection::Desc);
297    }
298
299    #[test]
300    fn test_status_filter_names() {
301        assert_eq!(StatusFilter::Active.name(), "Active");
302        assert_eq!(StatusFilter::Complete.name(), "Complete");
303        assert_eq!(StatusFilter::Failed.name(), "Failed");
304        assert_eq!(StatusFilter::Deleted.name(), "Deleted");
305        assert_eq!(StatusFilter::InProgress.name(), "In progress");
306    }
307
308    #[test]
309    fn test_status_filter_next() {
310        assert_eq!(StatusFilter::All.next(), StatusFilter::Active);
311        assert_eq!(StatusFilter::Active.next(), StatusFilter::Complete);
312        assert_eq!(StatusFilter::Complete.next(), StatusFilter::Failed);
313        assert_eq!(StatusFilter::Failed.next(), StatusFilter::Deleted);
314        assert_eq!(StatusFilter::Deleted.next(), StatusFilter::InProgress);
315        assert_eq!(StatusFilter::InProgress.next(), StatusFilter::All);
316    }
317
318    #[test]
319    fn test_status_filter_matches_active() {
320        let filter = StatusFilter::Active;
321        assert!(filter.matches("CREATE_IN_PROGRESS"));
322        assert!(filter.matches("UPDATE_IN_PROGRESS"));
323        assert!(!filter.matches("CREATE_COMPLETE"));
324        assert!(!filter.matches("DELETE_COMPLETE"));
325        assert!(!filter.matches("CREATE_FAILED"));
326    }
327
328    #[test]
329    fn test_status_filter_matches_complete() {
330        let filter = StatusFilter::Complete;
331        assert!(filter.matches("CREATE_COMPLETE"));
332        assert!(filter.matches("UPDATE_COMPLETE"));
333        assert!(!filter.matches("DELETE_COMPLETE"));
334        assert!(!filter.matches("CREATE_FAILED"));
335        assert!(!filter.matches("CREATE_IN_PROGRESS"));
336    }
337
338    #[test]
339    fn test_status_filter_matches_failed() {
340        let filter = StatusFilter::Failed;
341        assert!(filter.matches("CREATE_FAILED"));
342        assert!(filter.matches("UPDATE_FAILED"));
343        assert!(filter.matches("ROLLBACK_FAILED"));
344        assert!(!filter.matches("CREATE_COMPLETE"));
345        assert!(!filter.matches("DELETE_COMPLETE"));
346    }
347
348    #[test]
349    fn test_status_filter_matches_deleted() {
350        let filter = StatusFilter::Deleted;
351        assert!(filter.matches("DELETE_COMPLETE"));
352        assert!(filter.matches("DELETE_IN_PROGRESS"));
353        assert!(filter.matches("DELETE_FAILED"));
354        assert!(!filter.matches("CREATE_COMPLETE"));
355        assert!(!filter.matches("UPDATE_FAILED"));
356    }
357
358    #[test]
359    fn test_status_filter_matches_in_progress() {
360        let filter = StatusFilter::InProgress;
361        assert!(filter.matches("CREATE_IN_PROGRESS"));
362        assert!(filter.matches("UPDATE_IN_PROGRESS"));
363        assert!(filter.matches("DELETE_IN_PROGRESS"));
364        assert!(!filter.matches("CREATE_COMPLETE"));
365        assert!(!filter.matches("CREATE_FAILED"));
366    }
367
368    #[test]
369    fn test_detail_tab_names() {
370        assert_eq!(DetailTab::StackInfo.name(), "Stack info");
371        assert_eq!(DetailTab::Events.name(), "Events");
372        assert_eq!(DetailTab::Resources.name(), "Resources");
373        assert_eq!(DetailTab::Outputs.name(), "Outputs");
374        assert_eq!(DetailTab::Parameters.name(), "Parameters");
375        assert_eq!(DetailTab::Template.name(), "Template");
376        assert_eq!(DetailTab::ChangeSets.name(), "Change sets");
377        assert_eq!(DetailTab::GitSync.name(), "Git sync");
378    }
379
380    #[test]
381    fn test_detail_tab_next() {
382        assert_eq!(DetailTab::StackInfo.next(), DetailTab::Events);
383    }
384
385    #[test]
386    fn test_column_names() {
387        assert_eq!(Column::Name.name(), "Stack Name");
388        assert_eq!(Column::StackId.name(), "Stack ID");
389        assert_eq!(Column::Status.name(), "Status");
390        assert_eq!(Column::CreatedTime.name(), "Created Time");
391        assert_eq!(Column::UpdatedTime.name(), "Updated Time");
392        assert_eq!(Column::DeletedTime.name(), "Deleted Time");
393        assert_eq!(Column::DriftStatus.name(), "Drift Status");
394        assert_eq!(Column::LastDriftCheckTime.name(), "Last Drift Check Time");
395        assert_eq!(Column::StatusReason.name(), "Status Reason");
396        assert_eq!(Column::Description.name(), "Description");
397    }
398
399    #[test]
400    fn test_column_all() {
401        let columns = Column::ids();
402        assert_eq!(columns.len(), 10);
403        assert_eq!(columns[0], Column::Name.id());
404        assert_eq!(columns[9], Column::Description.id());
405    }
406
407    #[test]
408    fn test_format_status_complete_green() {
409        let (formatted, color) = format_status("UPDATE_COMPLETE");
410        assert_eq!(formatted, "✅ UPDATE_COMPLETE");
411        assert_eq!(color, ratatui::style::Color::Green);
412
413        let (formatted, color) = format_status("CREATE_COMPLETE");
414        assert_eq!(formatted, "✅ CREATE_COMPLETE");
415        assert_eq!(color, ratatui::style::Color::Green);
416
417        let (formatted, color) = format_status("DELETE_COMPLETE");
418        assert_eq!(formatted, "✅ DELETE_COMPLETE");
419        assert_eq!(color, ratatui::style::Color::Green);
420    }
421
422    #[test]
423    fn test_format_status_failed_red() {
424        let (formatted, color) = format_status("UPDATE_FAILED");
425        assert_eq!(formatted, "❌ UPDATE_FAILED");
426        assert_eq!(color, ratatui::style::Color::Red);
427
428        let (formatted, color) = format_status("CREATE_FAILED");
429        assert_eq!(formatted, "❌ CREATE_FAILED");
430        assert_eq!(color, ratatui::style::Color::Red);
431
432        let (formatted, color) = format_status("DELETE_FAILED");
433        assert_eq!(formatted, "❌ DELETE_FAILED");
434        assert_eq!(color, ratatui::style::Color::Red);
435
436        let (formatted, color) = format_status("ROLLBACK_FAILED");
437        assert_eq!(formatted, "❌ ROLLBACK_FAILED");
438        assert_eq!(color, ratatui::style::Color::Red);
439    }
440
441    #[test]
442    fn test_format_status_rollback_red() {
443        let (formatted, color) = format_status("ROLLBACK_COMPLETE");
444        assert_eq!(formatted, "❌ ROLLBACK_COMPLETE");
445        assert_eq!(color, ratatui::style::Color::Red);
446
447        let (formatted, color) = format_status("UPDATE_ROLLBACK_COMPLETE");
448        assert_eq!(formatted, "❌ UPDATE_ROLLBACK_COMPLETE");
449        assert_eq!(color, ratatui::style::Color::Red);
450
451        let (formatted, color) = format_status("UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS");
452        assert_eq!(formatted, "❌ UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS");
453        assert_eq!(color, ratatui::style::Color::Red);
454    }
455
456    #[test]
457    fn test_format_status_in_progress_blue() {
458        let (formatted, color) = format_status("UPDATE_IN_PROGRESS");
459        assert_eq!(formatted, "ℹ️  UPDATE_IN_PROGRESS");
460        assert_eq!(color, ratatui::style::Color::Blue);
461
462        let (formatted, color) = format_status("CREATE_IN_PROGRESS");
463        assert_eq!(formatted, "ℹ️  CREATE_IN_PROGRESS");
464        assert_eq!(color, ratatui::style::Color::Blue);
465
466        let (formatted, color) = format_status("DELETE_IN_PROGRESS");
467        assert_eq!(formatted, "ℹ️  DELETE_IN_PROGRESS");
468        assert_eq!(color, ratatui::style::Color::Blue);
469
470        let (formatted, color) = format_status("UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
471        assert_eq!(formatted, "ℹ️  UPDATE_COMPLETE_CLEANUP_IN_PROGRESS");
472        assert_eq!(color, ratatui::style::Color::Blue);
473
474        let (formatted, color) = format_status("ROLLBACK_IN_PROGRESS");
475        assert_eq!(formatted, "ℹ️  ROLLBACK_IN_PROGRESS");
476        assert_eq!(color, ratatui::style::Color::Blue);
477
478        let (formatted, color) = format_status("UPDATE_ROLLBACK_IN_PROGRESS");
479        assert_eq!(formatted, "ℹ️  UPDATE_ROLLBACK_IN_PROGRESS");
480        assert_eq!(color, ratatui::style::Color::Blue);
481    }
482
483    #[test]
484    fn test_format_status_unknown() {
485        let (formatted, color) = format_status("UNKNOWN_STATUS");
486        assert_eq!(formatted, "UNKNOWN_STATUS");
487        assert_eq!(color, ratatui::style::Color::White);
488    }
489
490    #[test]
491    fn test_format_status_emoji_spacing() {
492        // Verify emojis have proper spacing to avoid overlay
493        let (formatted, _) = format_status("CREATE_IN_PROGRESS");
494        assert!(formatted.starts_with("ℹ️ ")); // One space after info emoji
495
496        let (formatted, _) = format_status("CREATE_COMPLETE");
497        assert!(formatted.starts_with("✅ ")); // One space after checkmark
498
499        let (formatted, _) = format_status("CREATE_FAILED");
500        assert!(formatted.starts_with("❌ ")); // One space after cross
501    }
502
503    #[test]
504    fn test_all_aws_statuses_covered() {
505        // Test all documented CloudFormation stack statuses
506        let statuses = vec![
507            "CREATE_IN_PROGRESS",
508            "CREATE_FAILED",
509            "CREATE_COMPLETE",
510            "ROLLBACK_IN_PROGRESS",
511            "ROLLBACK_FAILED",
512            "ROLLBACK_COMPLETE",
513            "DELETE_IN_PROGRESS",
514            "DELETE_FAILED",
515            "DELETE_COMPLETE",
516            "UPDATE_IN_PROGRESS",
517            "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
518            "UPDATE_COMPLETE",
519            "UPDATE_FAILED",
520            "UPDATE_ROLLBACK_IN_PROGRESS",
521            "UPDATE_ROLLBACK_FAILED",
522            "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
523            "UPDATE_ROLLBACK_COMPLETE",
524            "REVIEW_IN_PROGRESS",
525            "IMPORT_IN_PROGRESS",
526            "IMPORT_COMPLETE",
527            "IMPORT_ROLLBACK_IN_PROGRESS",
528            "IMPORT_ROLLBACK_FAILED",
529            "IMPORT_ROLLBACK_COMPLETE",
530        ];
531
532        for status in statuses {
533            let (formatted, _) = format_status(status);
534            // Ensure all statuses get formatted (no panics) and contain some text
535            assert!(!formatted.is_empty());
536            assert!(formatted.len() > 2); // More than just emoji
537        }
538    }
539
540    #[test]
541    fn test_column_ids_have_correct_prefix() {
542        for col in Column::all() {
543            assert!(
544                col.id().starts_with("column.cfn.stack."),
545                "Column ID '{}' should start with 'column.cfn.stack.'",
546                col.id()
547            );
548        }
549    }
550}
rusticity_term/cfn/mod.rs

rusticity_term/cfn/
mod.rs
