batch-mode-batch-triple 0.2.1

Manages batch file triples (input, output, error, metadata) in batch processing systems, including file validation, error handling, and file movement.
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

// ---------------- [ File: batch-mode-batch-triple/src/batch_file_state.rs ]
crate::ix!();

/// Represents the state of batch files based on the presence of input, output, and error files.
#[derive(Debug, PartialEq, Eq)]
pub enum BatchFileState {
    InputOnly,           // Only input file is present.
    InputOutput,         // Input and output files are present.
    InputError,          // Input and error files are present.
    InputOutputError,    // All three files are present.
}

impl From<&BatchFileTriple> for BatchFileState {

    /// Determines the state of the batch files.
    fn from(triple: &BatchFileTriple) -> BatchFileState {

        let has_input  = triple.input().is_some();
        let has_error  = triple.error().is_some();
        let has_output = triple.output().is_some();

        match (has_input, has_output, has_error) {
            (true, true, true)   => BatchFileState::InputOutputError,
            (true, true, false)  => BatchFileState::InputOutput,
            (true, false, true)  => BatchFileState::InputError,
            (true, false, false) => BatchFileState::InputOnly,
            _ => unreachable!("Input file must be present at this point"),
        }
    }
}

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

    #[traced_test]
    fn from_triple_with_input_only_yields_input_only() {
        trace!("===== BEGIN TEST: from_triple_with_input_only_yields_input_only =====");
        let triple = BatchFileTriple::new_direct(
            &BatchIndex::new(),
            Some(PathBuf::from("in.json")),
            None, None, None,
            Arc::new(MockBatchWorkspace::default())
        );
        let state = BatchFileState::from(&triple);
        debug!("Computed state: {:?}", state);
        pretty_assert_eq!(state, BatchFileState::InputOnly, "Expected InputOnly");
        trace!("===== END TEST: from_triple_with_input_only_yields_input_only =====");
    }

    #[traced_test]
    fn from_triple_with_input_output_yields_input_output() {
        trace!("===== BEGIN TEST: from_triple_with_input_output_yields_input_output =====");
        let triple = BatchFileTriple::new_direct(
            &BatchIndex::new(),
            Some(PathBuf::from("in.json")),
            Some(PathBuf::from("out.json")),
            None,
            None,
            Arc::new(MockBatchWorkspace::default())
        );
        let state = BatchFileState::from(&triple);
        debug!("Computed state: {:?}", state);
        pretty_assert_eq!(state, BatchFileState::InputOutput, "Expected InputOutput");
        trace!("===== END TEST: from_triple_with_input_output_yields_input_output =====");
    }

    #[traced_test]
    fn from_triple_with_input_error_yields_input_error() {
        trace!("===== BEGIN TEST: from_triple_with_input_error_yields_input_error =====");
        let triple = BatchFileTriple::new_direct(
            &BatchIndex::new(),
            Some(PathBuf::from("in.json")),
            None,
            Some(PathBuf::from("err.json")),
            None,
            Arc::new(MockBatchWorkspace::default())
        );
        let state = BatchFileState::from(&triple);
        debug!("Computed state: {:?}", state);
        pretty_assert_eq!(state, BatchFileState::InputError, "Expected InputError");
        trace!("===== END TEST: from_triple_with_input_error_yields_input_error =====");
    }

    #[traced_test]
    fn from_triple_with_all_three_files_yields_input_output_error() {
        trace!("===== BEGIN TEST: from_triple_with_all_three_files_yields_input_output_error =====");
        let triple = BatchFileTriple::new_direct(
            &BatchIndex::new(),
            Some(PathBuf::from("in.json")),
            Some(PathBuf::from("out.json")),
            Some(PathBuf::from("err.json")),
            None,
            Arc::new(MockBatchWorkspace::default())
        );
        let state = BatchFileState::from(&triple);
        debug!("Computed state: {:?}", state);
        pretty_assert_eq!(state, BatchFileState::InputOutputError, "Expected InputOutputError");
        trace!("===== END TEST: from_triple_with_all_three_files_yields_input_output_error =====");
    }
}