duck-template 0.1.9

A cli tool for generating files from a template just with a json file
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

// src/parse_commands/__test__.rs

#[cfg(test)]
mod tests {
  use std::collections::HashMap;

  use crate::parse_commands::{
    Command, get_commands,
    get_flag_value::{find_command, find_flag, get_command_value},
  };

  #[test]
  fn test_find_command_valid() {
    let cmd = find_command("init");
    assert!(cmd.is_some());
    assert_eq!(cmd.unwrap().command, "init");
  }

  #[test]
  fn test_find_command_invalid() {
    assert!(find_command("nonexistent").is_none());
  }

  #[test]
  fn test_find_flag_by_long() {
    let cmd = find_command("init").unwrap();
    let flag = find_flag(cmd.flags, "--name");
    assert!(flag.is_some());
    assert_eq!(flag.unwrap().long, "--name");
  }

  #[test]
  fn test_find_flag_by_short() {
    let cmd = find_command("init").unwrap();
    let flag = find_flag(cmd.flags, "-n");
    assert!(flag.is_some());
    assert_eq!(flag.unwrap().short, "-n");
  }

  #[test]
  fn test_find_flag_invalid() {
    let cmd = find_command("init").unwrap();
    let flag = find_flag(cmd.flags, "--notreal");
    assert!(flag.is_none());
  }

  #[test]
  fn test_get_command_value_long() {
    let mut args = HashMap::new();
    args.insert("--name".to_string(), "test".to_string());
    assert_eq!(get_command_value("--name", "-n", &args), "test");
  }

  #[test]
  fn test_get_command_value_short() {
    let mut args = HashMap::new();
    args.insert("-n".to_string(), "short".to_string());
    assert_eq!(get_command_value("--name", "-n", &args), "short");
  }

  #[test]
  fn test_get_command_value_empty() {
    let args: HashMap<String, String> = HashMap::new();
    assert_eq!(get_command_value("--name", "-n", &args), "");
  }

  #[test]
  fn test_get_commands_help() {
    let result = get_commands(vec!["--help".into()]);
    assert_eq!(result.len(), 1);
    matches!(result[0], Command::Help);
  }

  #[test]
  fn test_get_commands_version() {
    let result = get_commands(vec!["--version".into()]);
    assert_eq!(result.len(), 1);
    matches!(result[0], Command::Version);
  }

  #[test]
  fn test_get_commands_init_args() {
    let result = get_commands(vec!["init".into(), "--name".into(), "myproject".into()]);
    assert_eq!(result.len(), 1);
    if let Command::Init(init) = &result[0] {
      assert_eq!(init.name, "myproject");
    } else {
      panic!("Expected Init command");
    }
  }

  #[test]
  fn test_get_commands_create_variant() {
    let result = get_commands(vec![
      "create-variant".into(),
      "--name".into(),
      "variant1".into(),
    ]);
    assert_eq!(result.len(), 1);
    if let Command::CreateVariant(cv) = &result[0] {
      assert_eq!(cv.name, "variant1");
    } else {
      panic!("Expected CreateVariant command");
    }
  }

  #[test]
  fn test_get_commands_unknown() {
    let result = get_commands(vec!["unknown-cmd".into()]);
    assert!(result.is_empty() || matches!(result[0], Command::Unknown(_)));
  }

  #[test]
  fn test_get_commands_missing_value() {
    let result = get_commands(vec!["init".into(), "--name".into()]);
    assert_eq!(result.len(), 1);
    // name should be empty due to missing value
    if let Command::Init(init) = &result[0] {
      assert_eq!(init.name, "");
    }
  }
}