alf_tui 0.5.0

A smolderingly-nimble Rust TUI to rediscover your custom shell.
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

//! Tests for EntryData (entry storage and visible index management)

use super::EntryData;
use crate::models::{AliasEntry, EntryType};
use std::path::PathBuf;

fn make_entry(name: &str) -> AliasEntry {
   AliasEntry {
      name: name.to_string(),
      entry_type: EntryType::Alias,
      value: "cmd".to_string(),
      comments: None,
      source_file: PathBuf::from("test.sh"),
   }
}

// ===== new =====

#[test]
fn test_new_stores_entries() {
   let data = EntryData::new(vec![make_entry("a"), make_entry("b")]);
   assert_eq!(data.entries().len(), 2);
}

#[test]
fn test_new_visible_indices_starts_empty() {
   let data = EntryData::new(vec![make_entry("a"), make_entry("b")]);
   assert_eq!(data.visible_indices().len(), 0);
}

// ===== visible_count / is_empty =====

#[test]
fn test_visible_count_is_zero_initially() {
   let data = EntryData::new(vec![make_entry("a")]);
   assert_eq!(data.visible_count(), 0);
}

#[test]
fn test_is_empty_true_initially() {
   let data = EntryData::new(vec![make_entry("a")]);
   assert!(data.is_empty());
}

#[test]
fn test_is_empty_false_after_adding_visible_index() {
   let mut data = EntryData::new(vec![make_entry("a")]);
   data.visible_indices_mut().push(0);
   assert!(!data.is_empty());
}

#[test]
fn test_visible_count_reflects_indices() {
   let mut data = EntryData::new(vec![make_entry("a"), make_entry("b"), make_entry("c")]);
   data.visible_indices_mut().extend([0, 1, 2]);
   assert_eq!(data.visible_count(), 3);
}

// ===== get_visible_entry =====

#[test]
fn test_get_visible_entry_returns_correct_entry() {
   let mut data = EntryData::new(vec![make_entry("alpha"), make_entry("beta"), make_entry("gamma")]);
   data.visible_indices_mut().push(2);
   let entry = data.get_visible_entry(0).unwrap();
   assert_eq!(entry.name, "gamma");
}

#[test]
fn test_get_visible_entry_out_of_range_returns_none() {
   let mut data = EntryData::new(vec![make_entry("a")]);
   data.visible_indices_mut().push(0);
   assert!(data.get_visible_entry(5).is_none());
}

#[test]
fn test_get_visible_entry_empty_visible_returns_none() {
   let data = EntryData::new(vec![make_entry("a")]);
   assert!(data.get_visible_entry(0).is_none());
}

// ===== sort_visible_indices =====

#[test]
fn test_sort_visible_indices_by_name_ascending() {
   let mut data = EntryData::new(vec![make_entry("charlie"), make_entry("alice"), make_entry("bob")]);
   data.visible_indices_mut().extend([0, 1, 2]);
   data.sort_visible_indices(|a, b| a.name.cmp(&b.name));
   assert_eq!(data.get_visible_entry(0).unwrap().name, "alice");
   assert_eq!(data.get_visible_entry(1).unwrap().name, "bob");
   assert_eq!(data.get_visible_entry(2).unwrap().name, "charlie");
}

#[test]
fn test_sort_visible_indices_by_name_descending() {
   let mut data = EntryData::new(vec![make_entry("charlie"), make_entry("alice"), make_entry("bob")]);
   data.visible_indices_mut().extend([0, 1, 2]);
   data.sort_visible_indices(|a, b| b.name.cmp(&a.name));
   assert_eq!(data.get_visible_entry(0).unwrap().name, "charlie");
   assert_eq!(data.get_visible_entry(1).unwrap().name, "bob");
   assert_eq!(data.get_visible_entry(2).unwrap().name, "alice");
}

#[test]
fn test_sort_visible_indices_subset_of_entries() {
   let mut data =
      EntryData::new(vec![make_entry("charlie"), make_entry("alice"), make_entry("bob"), make_entry("diana")]);
   data.visible_indices_mut().extend([0, 2]);
   data.sort_visible_indices(|a, b| a.name.cmp(&b.name));
   assert_eq!(data.get_visible_entry(0).unwrap().name, "bob");
   assert_eq!(data.get_visible_entry(1).unwrap().name, "charlie");
}