use crate::error::{Availability, Error, Result};
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ManagerState {
Unknown,
Unsupported,
Unauthorized,
PoweredOff,
PoweredOn,
}
impl ManagerState {
pub fn availability(self) -> std::result::Result<(), Availability> {
match self {
Self::PoweredOn => Ok(()),
Self::PoweredOff => Err(Availability::PoweredOff),
Self::Unauthorized => Err(Availability::Unauthorized),
Self::Unsupported => Err(Availability::Unsupported),
Self::Unknown => Err(Availability::Unknown),
}
}
pub fn require_powered_on(self) -> Result<()> {
self.availability().map_err(Error::NotAvailable)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn only_powered_on_is_usable() {
assert!(ManagerState::PoweredOn.availability().is_ok());
for state in [
ManagerState::PoweredOff,
ManagerState::Unauthorized,
ManagerState::Unsupported,
ManagerState::Unknown,
] {
assert!(state.availability().is_err(), "{state:?} is not usable");
}
}
#[test]
fn the_reason_survives() {
assert_eq!(
ManagerState::PoweredOff.availability(),
Err(Availability::PoweredOff)
);
assert_eq!(
ManagerState::Unsupported.availability(),
Err(Availability::Unsupported)
);
assert!(matches!(
ManagerState::Unauthorized.require_powered_on(),
Err(Error::NotAvailable(Availability::Unauthorized))
));
}
}