use crate::{MachineBuilder, MachineInner, MachineInstance, StateError, Transition, Transitions};
use std::sync::Arc;
#[derive(Debug, PartialEq, Eq)]
pub struct Machine {
pub(crate) inner: Arc<MachineInner>,
}
impl Machine {
pub(crate) fn new(transitions: Transitions) -> Self {
let inner = MachineInner::new(transitions);
Self {
inner: Arc::new(inner),
}
}
pub(crate) fn from_inner(inner: Arc<MachineInner>) -> Self {
Self { inner }
}
pub fn builder() -> MachineBuilder {
MachineBuilder::new()
}
pub fn instance(&self, initial: &str) -> Result<MachineInstance, StateError> {
MachineInstance::try_new(Arc::clone(&self.inner), initial.to_owned())
}
pub fn can_transition(&self, from: &str, to: &str) -> bool {
self.inner.can_transition(from, to)
}
pub fn validate_transition(&self, from: &str, to: &str) -> Result<(), StateError> {
self.inner.validate_transition(from, to)
}
pub fn transition_count(&self) -> usize {
self.inner.transition_count()
}
pub fn contains_state(&self, state: &str) -> bool {
self.inner.contains_state(state)
}
#[deprecated(since = "0.2.0", note = "use `targets_from` instead")]
pub fn targets(&self, from: &str) -> Option<impl Iterator<Item = &str>> {
let mut targets = self.targets_from(from).peekable();
if targets.peek().is_none() {
None
} else {
Some(targets)
}
}
pub fn targets_from(&self, from: &str) -> impl Iterator<Item = &str> {
self.inner.targets_from(from)
}
pub fn sources(&self) -> impl Iterator<Item = &str> {
self.inner.sources()
}
pub fn states(&self) -> impl Iterator<Item = &str> {
self.inner.states()
}
pub fn transitions(&self) -> impl Iterator<Item = &Transition> {
self.inner.transitions()
}
pub fn is_terminal(&self, state: &str) -> bool {
self.inner.is_terminal(state)
}
}
#[cfg(test)]
mod tests {
use super::*;
mod validate_transition {
use super::*;
#[test]
fn validate_transition_accepts_configured_transition() -> Result<(), StateError> {
let builder = Machine::builder()
.try_allow("start", "finish")?
.try_allow("1", "2")?;
let m = builder.build()?;
assert!(m.validate_transition("start", "finish").is_ok());
Ok(())
}
#[test]
fn validate_transition_not_exists_returns_invalid_error() -> Result<(), StateError> {
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
assert_eq!(
m.validate_transition("start", "invalid"),
Err(StateError::InvalidTransition {
from: "start".to_string(),
to: "invalid".to_string(),
})
);
Ok(())
}
}
mod transition_count {
use super::*;
#[test]
fn transition_count_counts_transitions() -> Result<(), StateError> {
let builder = Machine::builder()
.try_allow("start", "finish")?
.try_allow("1", "2")?;
let m = builder.build()?;
assert_eq!(m.transition_count(), 2);
Ok(())
}
}
mod can_transition {
use super::*;
#[test]
fn can_transition_exists_returns_true() -> Result<(), StateError> {
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
assert!(m.can_transition("start", "finish"));
Ok(())
}
#[test]
fn can_transition_not_exists_returns_false() -> Result<(), StateError> {
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
assert!(!m.can_transition("start", "invalid"));
Ok(())
}
}
mod contains_state {
use super::*;
#[test]
fn contains_state_finds_target_only_state() -> Result<(), StateError> {
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
assert!(m.contains_state("finish"));
Ok(())
}
#[test]
fn contains_state_rejects_unknown_state() -> Result<(), StateError> {
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
assert!(!m.contains_state("other"));
Ok(())
}
#[test]
fn contains_state_finds_source_state() -> Result<(), StateError> {
let builder = Machine::builder()
.try_allow("start", "end")?
.try_allow("rest", "finish")?;
let m = builder.build()?;
assert!(m.contains_state("rest"));
Ok(())
}
}
mod targets_from {
use super::*;
#[test]
fn targets_from_one_transition_key_does_not_exist_returns_empty() -> Result<(), StateError>
{
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
let collected: Vec<_> = m.targets_from("other").collect();
assert!(collected.is_empty());
Ok(())
}
#[test]
fn targets_from_one_transition_one_value() -> Result<(), StateError> {
let builder = Machine::builder().try_allow("start", "finish")?;
let m = builder.build()?;
let collected: Vec<_> = m.targets_from("start").collect();
assert_eq!(collected, vec!["finish"]);
Ok(())
}
}
mod targets {
use super::*;
#[allow(deprecated)]
#[test]
fn targets_returns_none_when_source_has_no_outgoing_transitions() -> Result<(), StateError>
{
let machine = Machine::builder().try_allow("start", "finish")?.build()?;
assert!(machine.targets("finish").is_none());
assert!(machine.targets("unknown").is_none());
Ok(())
}
#[allow(deprecated)]
#[test]
fn targets_returns_some_when_source_has_outgoing_transitions() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("start", "finish")?.build()?;
assert!(machine.targets("start").is_some());
Ok(())
}
}
mod sources {
use super::*;
#[test]
fn returns_all_source_states() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "0")?
.try_allow("2", "0")?
.try_allow("3", "0")?
.build()?;
let mut sources: Vec<_> = machine.sources().collect();
sources.sort();
assert_eq!(sources, vec!["1", "2", "3"]);
Ok(())
}
}
mod states {
use super::*;
#[test]
fn returns_unique_source_and_target_states() -> Result<(), StateError> {
let machine = Machine::builder()
.try_allow("1", "2")?
.try_allow("1", "3")?
.try_allow("2", "3")?
.try_allow("3", "4")?
.build()?;
let mut states: Vec<_> = machine.states().collect();
states.sort();
assert_eq!(states, vec!["1", "2", "3", "4"]);
Ok(())
}
}
mod transitions {
use super::*;
#[test]
fn one_transition_returns_matching_fields() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let transitions: Vec<_> = machine.transitions().collect();
assert_eq!(transitions[0].source(), "1");
assert_eq!(transitions[0].target(), "2");
Ok(())
}
#[test]
fn one_transition_returns_one_item() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
let transitions: Vec<_> = machine.transitions().collect();
assert_eq!(transitions.len(), 1);
Ok(())
}
}
mod is_terminal {
use super::*;
#[test]
fn source_is_not_terminal() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
assert!(!machine.is_terminal("1"));
Ok(())
}
#[test]
fn target_with_no_outgoing_source_is_terminal() -> Result<(), StateError> {
let machine = Machine::builder().try_allow("1", "2")?.build()?;
assert!(machine.is_terminal("2"));
Ok(())
}
}
mod equality {
use super::*;
#[test]
fn similar_machines_are_equal() -> Result<(), StateError> {
let machine1 = Machine::builder().try_allow("1", "2")?.build()?;
let machine2 = Machine::builder().try_allow("1", "2")?.build()?;
assert_eq!(machine1, machine2);
Ok(())
}
#[test]
fn different_machines_are_not_equal() -> Result<(), StateError> {
let machine1 = Machine::builder().try_allow("1", "2")?.build()?;
let machine2 = Machine::builder().try_allow("1", "3")?.build()?;
assert_ne!(machine1, machine2);
Ok(())
}
}
}