use crate::{Machine, MachineInner, StateError};
use std::sync::Arc;
#[derive(Debug, PartialEq, Eq)]
pub struct MachineInstance {
machine: Arc<MachineInner>,
current: String,
}
impl MachineInstance {
pub(crate) fn try_new(machine: Arc<MachineInner>, initial: String) -> Result<Self, StateError> {
if !machine.contains_state(initial.as_str()) {
return Err(StateError::UnknownInitialState { state: initial });
}
Ok(Self {
machine,
current: initial,
})
}
pub fn state(&self) -> &str {
&self.current
}
pub fn can_transition_to(&self, target: &str) -> bool {
self.machine.can_transition(&self.current, target)
}
pub fn transition_to(&mut self, target: &str) -> Result<(), StateError> {
self.machine.validate_transition(&self.current, target)?;
self.current.clear();
self.current.push_str(target);
Ok(())
}
pub fn is_terminal(&self) -> bool {
self.machine.is_terminal(self.state())
}
pub fn machine(&self) -> Machine {
Machine::from_inner(Arc::clone(&self.machine))
}
}
#[cfg(test)]
mod tests {
use super::*;
mod construction {
use super::*;
#[test]
fn initial_known_source_state_succeeds() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("1");
assert!(instance.is_ok());
Ok(())
}
#[test]
fn initial_known_target_only_state_succeeds() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("2");
assert!(instance.is_ok());
Ok(())
}
#[test]
fn initial_unknown_state_fails() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("3");
assert!(instance.is_err());
Ok(())
}
#[test]
fn initial_unknown_state_fails_with_unknown_initial_state_error() -> Result<(), StateError>
{
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("3");
assert!(matches!(
instance,
Err(StateError::UnknownInitialState { ref state })
if state == "3"
));
Ok(())
}
#[test]
fn initial_exact_match_behavior_is_preserved() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance(" 1 ");
assert!(instance.is_err());
Ok(())
}
}
mod state {
use super::*;
#[test]
fn state_initial_state_matches() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("1")?;
assert_eq!(instance.state(), "1");
Ok(())
}
#[test]
fn state_changes_are_reflected() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
instance.transition_to("2")?;
assert_eq!(instance.state(), "2");
Ok(())
}
}
mod can_transition_to {
use super::*;
#[test]
fn can_transition_to_returns_true_on_valid_edge() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let instance = machine.instance("1")?;
assert!(instance.can_transition_to("2"));
Ok(())
}
#[test]
fn can_transition_to_returns_false_on_unknown_edge() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let instance = machine.instance("2")?;
assert!(!instance.can_transition_to("4"));
Ok(())
}
#[test]
fn can_transition_to_returns_false_on_terminal_state() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let instance = machine.instance("3")?;
assert!(!instance.can_transition_to("2"));
Ok(())
}
#[test]
fn can_transition_to_returns_false_when_edge_exists_from_disallowed_state()
-> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let instance = machine.instance("1")?;
assert!(!instance.can_transition_to("3"));
Ok(())
}
#[test]
fn can_transition_to_uses_current_state_after_transition() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
assert!(instance.can_transition_to("2"));
instance.transition_to("2")?;
assert!(instance.can_transition_to("3"));
assert!(!instance.can_transition_to("2"));
Ok(())
}
}
mod transition_to {
use super::*;
#[test]
fn transition_to_one_transition() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
assert_eq!(instance.state(), "1");
instance.transition_to("2")?;
assert_eq!(instance.state(), "2");
Ok(())
}
#[test]
fn transition_to_multiple_transitions() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.try_allow("3", "4")?
.build()?;
let mut instance = machine.instance("1")?;
assert_eq!(instance.state(), "1");
instance.transition_to("2")?;
instance.transition_to("3")?;
assert_eq!(instance.state(), "3");
Ok(())
}
#[test]
fn transition_to_failure_when_unknown() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let mut instance = machine.instance("1")?;
let result = instance.transition_to("4");
assert!(matches!(
result,
Err(StateError::InvalidTransition {
ref from,
ref to
}) if from == "1" && to == "4"
));
Ok(())
}
#[test]
fn transition_to_failure_when_not_reachable() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
let result = instance.transition_to("3");
assert!(matches!(
result,
Err(StateError::InvalidTransition {
ref from,
ref to
}) if from == "1" && to == "3"
));
Ok(())
}
#[test]
fn transition_to_failure_does_not_change_the_state() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let mut instance = machine.instance("1")?;
let result = instance.transition_to("4");
assert!(result.is_err());
assert_eq!(instance.state(), "1");
Ok(())
}
#[test]
fn transition_validation_uses_current_state_not_initial() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
assert_eq!(instance.state(), "1");
instance.transition_to("2")?;
assert_eq!(instance.state(), "2");
let result = instance.transition_to("4");
assert!(matches!(
result,
Err(StateError::InvalidTransition {
ref from,
ref to
}) if from == "2" && to == "4"
));
Ok(())
}
#[test]
fn transition_to_transitions_to_terminal_state() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let mut instance = machine.instance("1")?;
let result = instance.transition_to("2");
assert!(result.is_ok());
Ok(())
}
}
mod interdependence {
use super::*;
#[test]
fn two_instances_are_independent() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
let mut instance2 = machine.instance("1")?;
assert_eq!(instance.state(), "1");
assert_eq!(instance2.state(), "1");
instance.transition_to("2")?;
assert_eq!(instance.state(), "2");
assert_eq!(instance2.state(), "1");
instance.transition_to("3")?;
instance2.transition_to("2")?;
assert_eq!(instance.state(), "3");
assert_eq!(instance2.state(), "2");
Ok(())
}
#[test]
fn instance_functions_with_no_handle() -> Result<(), StateError> {
let mut instance = {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
machine.instance("1")?
};
assert!(instance.transition_to("2").is_ok());
Ok(())
}
}
mod is_terminal {
use super::*;
#[test]
fn is_terminal_on_initial_returns_false_on_source() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("1")?;
assert!(!instance.is_terminal());
Ok(())
}
#[test]
fn is_terminal_on_initial_returns_true_on_terminal_state() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("2")?;
assert!(instance.is_terminal());
Ok(())
}
#[test]
fn is_terminal_returns_false_after_transition_to_nonterminal_node() -> Result<(), StateError>
{
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("1")?;
instance.transition_to("2")?;
assert!(!instance.is_terminal());
Ok(())
}
#[test]
fn is_terminal_returns_true_after_transition_to_terminal_node() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let mut instance = machine.instance("2")?;
instance.transition_to("3")?;
assert!(instance.is_terminal());
Ok(())
}
}
mod partial_eq {
use super::*;
#[test]
fn instances_are_equal_when_machine_and_current_state_are_equal() -> Result<(), StateError>
{
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let first = machine.instance("1")?;
let second = machine.instance("1")?;
assert_eq!(first, second);
Ok(())
}
#[test]
fn instances_are_not_equal_when_machine_and_current_state_are_different()
-> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("2", "3")?
.build()?;
let first = machine.instance("1")?;
let second = machine.instance("2")?;
assert_ne!(first, second);
Ok(())
}
#[test]
fn instances_are_not_equal_when_machine_definitions_differ() -> Result<(), StateError> {
let first_machine = Machine::builder().try_allow("1", "2")?.build()?;
let second_machine = Machine::builder().try_allow("1", "3")?.build()?;
let first = first_machine.instance("1")?;
let second = second_machine.instance("1")?;
assert_ne!(first, second);
Ok(())
}
}
mod machine {
use super::*;
#[test]
fn machine_returns_handle_to_same_machine_inner() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let instance = machine.instance("1")?;
let returned = instance.machine();
assert!(Arc::ptr_eq(&machine.inner, &returned.inner));
Ok(())
}
}
}