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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
use anyhow::Error;
use crate::{
input::Event,
process::{exit_status::ExitStatus, process_result::ProcessResult, state::State},
};
fn format_process_result(
event: Option<Event>,
state: Option<State>,
exit_status: Option<ExitStatus>,
error: &Option<Error>,
external_command: &Option<(String, Vec<String>)>,
) -> String {
format!(
"ExitStatus({}), State({}), Event({}), Error({}), ExternalCommand({})",
exit_status.map_or("None", |exit_status| {
match exit_status {
ExitStatus::Abort => "Abort",
ExitStatus::ConfigError => "ConfigError",
ExitStatus::FileReadError => "FileReadError",
ExitStatus::FileWriteError => "FileWriteError",
ExitStatus::Good => "Good",
ExitStatus::StateError => "StateError",
ExitStatus::Kill => "Kill",
}
}),
state.map_or("None", |state| {
match state {
State::ConfirmAbort => "ConfirmAbort",
State::ConfirmRebase => "ConfirmRebase",
State::Error => "Error",
State::ExternalEditor => "ExternalEditor",
State::Insert => "Insert",
State::List => "List",
State::ShowCommit => "ShowCommit",
State::WindowSizeError => "WindowSizeError",
}
}),
event.map_or(String::from("None"), |evt| format!("{:?}", evt)),
error
.as_ref()
.map_or(String::from("None"), |error| format!("{:#}", error)),
external_command.as_ref().map_or(String::from("None"), |command| {
format!("{} {}", command.0, command.1.join(","))
})
)
}
pub fn _assert_process_result(
actual: &ProcessResult,
event: Option<Event>,
state: Option<State>,
exit_status: Option<ExitStatus>,
error: &Option<Error>,
external_command: &Option<(String, Vec<String>)>,
) {
let error_compare_fn = |expected| {
actual
.error
.as_ref()
.map_or(false, |actual| format!("{:#}", expected) == format!("{:#}", actual))
};
let external_command_compare_fn = |expected| {
actual
.external_command
.as_ref()
.map_or(false, |actual| actual == expected)
};
if !(exit_status.map_or(actual.exit_status.is_none(), |expected| {
actual.exit_status.map_or(false, |actual| expected == actual)
}) && state.map_or(actual.state.is_none(), |expected| {
actual.state.map_or(false, |actual| expected == actual)
}) && event.map_or(actual.event.is_none(), |expected| {
actual.event.map_or(false, |actual| expected == actual)
}) && error.as_ref().map_or(actual.error.is_none(), error_compare_fn)
&& external_command
.as_ref()
.map_or(actual.external_command.is_none(), external_command_compare_fn))
{
panic!(
"{}",
vec![
"\n",
"ProcessResult does not match",
"==========",
"Expected State:",
format_process_result(event, state, exit_status, error, external_command).as_str(),
"Actual:",
format_process_result(
actual.event,
actual.state,
actual.exit_status,
&actual.error,
&actual.external_command
)
.as_str(),
"==========\n"
]
.join("\n")
);
}
}
#[macro_export]
macro_rules! assert_process_result {
($actual:expr) => {
crate::process::testutil::_assert_process_result(&$actual, None, None, None, &None, &None)
};
($actual:expr, error = $error:expr, exit_status = $exit_status:expr) => {
crate::process::testutil::_assert_process_result(&$actual, None, None, Some($exit_status), &Some($error), &None)
};
($actual:expr, state = $state:expr) => {
crate::process::testutil::_assert_process_result(&$actual, None, Some($state), None, &None, &None)
};
($actual:expr, state = $state:expr, external_command = $external_command:expr) => {
crate::process::testutil::_assert_process_result(
&$actual,
None,
Some($state),
None,
&None,
&Some($external_command),
)
};
($actual:expr, state = $state:expr, error = $error:expr) => {
crate::process::testutil::_assert_process_result(&$actual, None, Some($state), None, &Some($error), &None)
};
($actual:expr, event = $event:expr) => {
crate::process::testutil::_assert_process_result(&$actual, Some($event), None, None, &None, &None)
};
($actual:expr, event = $event:expr, state = $state:expr) => {
crate::process::testutil::_assert_process_result(&$actual, Some($event), Some($state), None, &None, &None)
};
($actual:expr, event = $event:expr, exit_status = $exit_status:expr) => {
crate::process::testutil::_assert_process_result(&$actual, Some($event), None, Some($exit_status), &None, &None)
};
($actual:expr, event = $event:expr, external_command = $external_command:expr) => {
crate::process::testutil::_assert_process_result(
&$actual,
Some($event),
None,
None,
&None,
&Some($external_command),
)
};
($actual:expr, external_command = $external_command:expr) => {
crate::process::testutil::_assert_process_result(&$actual, None, None, None, &None, &Some($external_command))
};
}
|
