oxihuman-core 0.1.2

Core data structures, algorithms, and asset management for OxiHuman
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

// Copyright (C) 2026 COOLJAPAN OU (Team KitaSan)
// SPDX-License-Identifier: Apache-2.0
#![allow(dead_code)]

pub struct DddCommand {
    pub name: String,
    pub payload: String,
}

pub struct CommandLog {
    pub commands: Vec<DddCommand>,
}

pub fn new_ddd_command(name: &str, payload: &str) -> DddCommand {
    DddCommand {
        name: name.to_string(),
        payload: payload.to_string(),
    }
}

pub fn new_command_log() -> CommandLog {
    CommandLog {
        commands: Vec::new(),
    }
}

pub fn log_dispatch(l: &mut CommandLog, cmd: DddCommand) {
    l.commands.push(cmd);
}

pub fn log_command_count(l: &CommandLog) -> usize {
    l.commands.len()
}

pub fn log_commands_by_name<'a>(l: &'a CommandLog, name: &str) -> Vec<&'a DddCommand> {
    l.commands.iter().filter(|c| c.name == name).collect()
}

pub fn log_clear(l: &mut CommandLog) {
    l.commands.clear();
}

pub fn log_last_command(l: &CommandLog) -> Option<&DddCommand> {
    l.commands.last()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_dispatch_and_count() {
        /* dispatch adds command and increments count */
        let mut l = new_command_log();
        log_dispatch(&mut l, new_ddd_command("Create", "{}"));
        assert_eq!(log_command_count(&l), 1);
    }

    #[test]
    fn test_commands_by_name() {
        /* filter commands by name */
        let mut l = new_command_log();
        log_dispatch(&mut l, new_ddd_command("Create", "a"));
        log_dispatch(&mut l, new_ddd_command("Delete", "b"));
        log_dispatch(&mut l, new_ddd_command("Create", "c"));
        assert_eq!(log_commands_by_name(&l, "Create").len(), 2);
    }

    #[test]
    fn test_log_clear() {
        /* clear removes all commands */
        let mut l = new_command_log();
        log_dispatch(&mut l, new_ddd_command("X", ""));
        log_clear(&mut l);
        assert_eq!(log_command_count(&l), 0);
    }

    #[test]
    fn test_log_last_command() {
        /* last command returned correctly */
        let mut l = new_command_log();
        log_dispatch(&mut l, new_ddd_command("First", ""));
        log_dispatch(&mut l, new_ddd_command("Last", ""));
        let last = log_last_command(&l).expect("should succeed");
        assert_eq!(last.name, "Last");
    }

    #[test]
    fn test_empty_log() {
        /* empty log has no last command */
        let l = new_command_log();
        assert!(log_last_command(&l).is_none());
    }

    #[test]
    fn test_new_command_fields() {
        /* command fields set correctly */
        let cmd = new_ddd_command("Update", "data");
        assert_eq!(cmd.name, "Update");
        assert_eq!(cmd.payload, "data");
    }

    #[test]
    fn test_commands_by_name_none() {
        /* no match returns empty */
        let l = new_command_log();
        assert!(log_commands_by_name(&l, "X").is_empty());
    }
}