545 lines
16 KiB
Rust
545 lines
16 KiB
Rust
// tests/mod.rs - or put this inside your crate's tests module
|
|
#![allow(unused_imports)]
|
|
|
|
use std::str::FromStr;
|
|
|
|
use crate::entity::{EffectApplication, EffectBounds, Entity, EntityDuration, EntityIdentifier};
|
|
use crate::epoch::epoch_traits::Diffable;
|
|
use crate::error::EpochError;
|
|
use crate::stats::{self, EntityType, MetaStats, Position, StatPair, TownId};
|
|
use std::io::Write;
|
|
|
|
use super::*;
|
|
use crate::Displayable;
|
|
use insta::assert_snapshot;
|
|
use uuid::Uuid;
|
|
|
|
#[test]
|
|
fn entity_duration_parses_permanent_and_done() {
|
|
assert_eq!(
|
|
EntityDuration::from_str("permanent").unwrap(),
|
|
EntityDuration::Permanent
|
|
);
|
|
assert_eq!(
|
|
EntityDuration::from_str("PERMANENT").unwrap(),
|
|
EntityDuration::Permanent
|
|
);
|
|
assert_eq!(
|
|
EntityDuration::from_str("perm").unwrap(),
|
|
EntityDuration::Permanent
|
|
);
|
|
assert_eq!(
|
|
EntityDuration::from_str("done").unwrap(),
|
|
EntityDuration::Done
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn entity_duration_parses_numeric_forms() {
|
|
// bare number
|
|
assert_eq!(
|
|
EntityDuration::from_str("5").unwrap(),
|
|
EntityDuration::Duration(5)
|
|
);
|
|
// with leading zeros
|
|
assert_eq!(
|
|
EntityDuration::from_str("0005").unwrap(),
|
|
EntityDuration::Duration(5)
|
|
);
|
|
// duration: prefix
|
|
assert_eq!(
|
|
EntityDuration::from_str("duration:10").unwrap(),
|
|
EntityDuration::Duration(10)
|
|
);
|
|
// case-insensitive prefix
|
|
assert_eq!(
|
|
EntityDuration::from_str("DurAtIoN:20").unwrap(),
|
|
EntityDuration::Duration(20)
|
|
);
|
|
// zero value
|
|
assert_eq!(
|
|
EntityDuration::from_str("duration:0").unwrap(),
|
|
EntityDuration::Duration(0)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn entity_duration_parses_with_surrounding_whitespace() {
|
|
assert_eq!(
|
|
EntityDuration::from_str(" 7 ").unwrap(),
|
|
EntityDuration::Duration(7)
|
|
);
|
|
assert_eq!(
|
|
EntityDuration::from_str(" PERMANENT ").unwrap(),
|
|
EntityDuration::Permanent
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn entity_duration_returns_error_on_invalid_inputs() {
|
|
// non-numeric bare string
|
|
let err = EntityDuration::from_str("10a").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingDuration(msg, val) => {
|
|
assert!(!msg.is_empty());
|
|
assert_eq!(val, "10a");
|
|
}
|
|
_ => panic!("Expected ParsingDuration error"),
|
|
}
|
|
|
|
// malformed duration: form
|
|
let err = EntityDuration::from_str("duration:invalid").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingDuration(msg, val) => {
|
|
assert!(!msg.is_empty());
|
|
assert_eq!(val, "invalid");
|
|
}
|
|
_ => panic!("Expected ParsingDuration error"),
|
|
}
|
|
|
|
// trailing spaces after the duration prefix - the numeric parser fails
|
|
let err = EntityDuration::from_str("duration: 5").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingDuration(msg, val) => {
|
|
assert_eq!(msg, "Invalid duration value");
|
|
assert_eq!(val, " 5");
|
|
}
|
|
_ => panic!("Expected ParsingDuration error"),
|
|
}
|
|
|
|
// empty string
|
|
let err = EntityDuration::from_str("").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingDuration(msg, val) => {
|
|
assert!(!msg.is_empty());
|
|
assert_eq!(val, "");
|
|
}
|
|
_ => panic!("Expected ParsingDuration error"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn effect_bounds_parses_colon_and_dash_separated_values() {
|
|
// colon
|
|
let eb = EffectBounds::from_str("1:5").unwrap();
|
|
assert_eq!(eb.min, 1);
|
|
assert_eq!(eb.max, 5);
|
|
|
|
// dash
|
|
let eb = EffectBounds::from_str("2-10").unwrap();
|
|
assert_eq!(eb.min, 2);
|
|
assert_eq!(eb.max, 10);
|
|
}
|
|
|
|
#[test]
|
|
fn effect_bounds_parses_with_whitespace_and_leading_zeros() {
|
|
let eb = EffectBounds::from_str(" 01 : 05 ").unwrap();
|
|
assert_eq!(eb.min, 1);
|
|
assert_eq!(eb.max, 5);
|
|
}
|
|
|
|
#[test]
|
|
fn effect_bounds_returns_error_on_invalid_inputs() {
|
|
// too many parts
|
|
let err = EffectBounds::from_str("1:5:7").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingBounds(msg, val) => {
|
|
assert_eq!(msg, "Invalid EffectBounds format");
|
|
assert_eq!(val, "1:5:7");
|
|
}
|
|
_ => panic!("Expected ParsingBounds error"),
|
|
}
|
|
|
|
// missing one side
|
|
let err = EffectBounds::from_str("1:").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingBounds(msg, val) => {
|
|
assert_eq!(msg, "Could not parse number");
|
|
assert_eq!(val, "1:");
|
|
}
|
|
_ => panic!("Expected ParsingBounds error"),
|
|
}
|
|
|
|
// non-numeric part
|
|
let err = EffectBounds::from_str("a:5").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingBounds(msg, val) => {
|
|
assert_eq!(msg, "Could not parse number");
|
|
assert_eq!(val, "a:5");
|
|
}
|
|
_ => panic!("Expected ParsingBounds error"),
|
|
}
|
|
|
|
// no delimiter
|
|
let err = EffectBounds::from_str("5").unwrap_err();
|
|
match err {
|
|
EpochError::ParsingBounds(msg, val) => {
|
|
assert_eq!(msg, "Invalid EffectBounds");
|
|
assert_eq!(val, "5");
|
|
}
|
|
_ => panic!("Expected ParsingBounds error"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn entity_identifier_parses_id_and_name() {
|
|
// id
|
|
let id = EntityIdentifier::from_str("@1234-5678-9012-3456-7890").unwrap();
|
|
match id {
|
|
EntityIdentifier::Id(uuid) => assert_eq!(uuid, "1234-5678-9012-3456-7890"),
|
|
_ => panic!("Expected Id variant"),
|
|
}
|
|
|
|
// name
|
|
let name = EntityIdentifier::from_str("my_entity").unwrap();
|
|
match name {
|
|
EntityIdentifier::Name(n) => assert_eq!(n, "my_entity"),
|
|
_ => panic!("Expected Name variant"),
|
|
}
|
|
|
|
// empty name is still a valid Name
|
|
let empty = EntityIdentifier::from_str("").unwrap();
|
|
match empty {
|
|
EntityIdentifier::Name(n) => assert_eq!(n, ""),
|
|
_ => panic!("Expected Name variant"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn entity_identifier_errors_on_invalid_id() {
|
|
// prefix with nothing after @
|
|
let err = EntityIdentifier::from_str("@").unwrap_err();
|
|
match err {
|
|
EpochError::EmptyIdentifier => {}
|
|
_ => panic!("Expected EmptyIdentifier error"),
|
|
}
|
|
|
|
// // prefix followed by whitespace only
|
|
// let err = EntityIdentifier::from_str("@ ").unwrap_err();
|
|
// match err {
|
|
// EpochError::EmptyIdentifier => {}
|
|
// _ => panic!("Expected EmptyIdentifier error"),
|
|
// }
|
|
}
|
|
|
|
fn init_snapshot_env() {
|
|
colored::control::set_override(false);
|
|
}
|
|
|
|
fn full_entity() -> Entity {
|
|
Entity {
|
|
id: Uuid::from_u128_le(12),
|
|
name: "Hero".into(),
|
|
entity_type: EntityType::Character,
|
|
metadata: MetaStats {
|
|
capital: Some(stats::TownId(Uuid::from_u128(121))),
|
|
governor: Some(stats::CharacterId(11)),
|
|
prestige: stats::GenericStat(3),
|
|
position: Position::from((2, 4)),
|
|
faction: Some(crate::stats::FactionId(2)),
|
|
links: vec![TownId(Uuid::from_u128(121))],
|
|
},
|
|
duration: EntityDuration::Duration(10),
|
|
effect_nature: EffectApplication::Recurring,
|
|
effect_bounds: EffectBounds::from((1, 5)),
|
|
stats: stats::OverallStats::default(),
|
|
temp_stats: Some(stats::OverallStats::default()),
|
|
description: String::from("Bob"),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn effect_bound_testing() {
|
|
let EffectBounds { min, max } = EffectBounds::from(0..1);
|
|
let EffectBounds {
|
|
min: min2,
|
|
max: max2,
|
|
} = EffectBounds::from((0, 1));
|
|
assert_eq!(min, min2);
|
|
assert_eq!(max, max2);
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_full_oneline_display() {
|
|
init_snapshot_env();
|
|
let e = full_entity();
|
|
assert_snapshot!(e.oneline_display());
|
|
assert_snapshot!(e.to_pretty_tree());
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_minimal_oneline_display() {
|
|
init_snapshot_env();
|
|
let e = Entity::default();
|
|
assert_snapshot!(e.oneline_display());
|
|
assert_snapshot!(e.to_pretty_tree());
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_print_full_output() {
|
|
init_snapshot_env();
|
|
|
|
let e = full_entity();
|
|
|
|
// Capture stdout into a buffer
|
|
let buffer = Vec::new();
|
|
{
|
|
// let stdout = std::io::stdout();
|
|
// let mut handle = stdout.lock();
|
|
|
|
// // Temporarily swap the real stdout for our buffer.
|
|
// let original = std::mem::replace(&mut handle, &mut buffer);
|
|
// Run the method we want to snapshot.
|
|
e.print_full();
|
|
// Restore the original stdout.
|
|
// std::mem::replace(&mut handle, original);
|
|
}
|
|
|
|
// Convert buffer → UTF-8 string and snapshot it.
|
|
let output = String::from_utf8_lossy(&buffer);
|
|
assert_snapshot!(output);
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_full_stats_no_temp() {
|
|
init_snapshot_env();
|
|
|
|
let mut e = full_entity();
|
|
e.temp_stats = None;
|
|
let table = e.full_stats_to_table().expect("table generation failed");
|
|
assert_snapshot!(format!("{}", table));
|
|
let table = e.stats_to_table().expect("table generation failed");
|
|
assert_snapshot!(format!("{}", table));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_full_stats_with_temp() {
|
|
init_snapshot_env();
|
|
|
|
let mut e = full_entity();
|
|
e.temp_stats = Some(OverallStats::default());
|
|
let table = e.full_stats_to_table().expect("table generation failed");
|
|
assert_snapshot!(format!("{}", table));
|
|
let table = e.stats_to_table().expect("table generation failed");
|
|
assert_snapshot!(format!("{}", table));
|
|
}
|
|
|
|
/// ------------------------------------------------------------------
|
|
/// 1. Helpers - `overwrite_stat` & `add_to_stat`
|
|
/// ------------------------------------------------------------------
|
|
#[test]
|
|
fn snapshot_overwrite_stat() {
|
|
init_snapshot_env();
|
|
|
|
let mut entity = Entity::default();
|
|
let stats = OverallStats::linear(0);
|
|
entity.stats = stats;
|
|
entity.change_stat(StatPair {
|
|
stat: stats::ListStats::Population,
|
|
value: stats::GenericStat(33),
|
|
});
|
|
|
|
assert_snapshot!(format!("{:#?}", entity.stats));
|
|
}
|
|
|
|
// #[test]
|
|
// fn snapshot_add_to_stat_saturating_add() {
|
|
// init_snapshot_env();
|
|
|
|
// let mut stats = stats_from_values(u32::MAX as i32 - 1, 20, 30);
|
|
// let pair = pair("health", 5);
|
|
|
|
// add_to_stat(&mut stats, pair);
|
|
|
|
// // The saturated addition should clamp to `u32::MAX`.
|
|
// assert_snapshot!(format!("{}\n", stats));
|
|
// }
|
|
|
|
/// ------------------------------------------------------------------
|
|
/// 2. `Diffable` - `Entity::delta`
|
|
/// ------------------------------------------------------------------
|
|
#[test]
|
|
fn snapshot_entity_delta() {
|
|
init_snapshot_env();
|
|
|
|
// Build two slightly different entities
|
|
let e1 = Entity {
|
|
id: uuid::Uuid::nil(),
|
|
name: "Alice".into(),
|
|
stats: OverallStats::linear(2),
|
|
temp_stats: None,
|
|
metadata: MetaStats {
|
|
position: Position::from((44, 666)),
|
|
capital: Some(stats::TownId(Uuid::from_u128(124))),
|
|
governor: Some(stats::CharacterId(2000)),
|
|
faction: Some(stats::FactionId(44)),
|
|
links: vec![TownId(Uuid::from_u128(141))],
|
|
prestige: stats::GenericStat(3),
|
|
},
|
|
entity_type: EntityType::Monster,
|
|
duration: EntityDuration::Permanent,
|
|
effect_nature: EffectApplication::Recurring,
|
|
effect_bounds: EffectBounds::from(0..33),
|
|
description: "Ello".to_string(),
|
|
};
|
|
|
|
let e2 = Entity {
|
|
id: uuid::Uuid::nil(),
|
|
name: "Bob".into(),
|
|
stats: OverallStats::linear(44),
|
|
temp_stats: Some(OverallStats::linear(4)),
|
|
metadata: MetaStats {
|
|
position: Position::from_str("33,4").unwrap(),
|
|
capital: Some(stats::TownId(Uuid::from_u128(121))),
|
|
governor: Some(stats::CharacterId(1500)),
|
|
faction: Some(stats::FactionId(5)),
|
|
links: vec![TownId(Uuid::from_u128(121))],
|
|
prestige: stats::GenericStat(5),
|
|
},
|
|
entity_type: EntityType::Town,
|
|
duration: EntityDuration::Permanent,
|
|
effect_nature: EffectApplication::Recurring,
|
|
effect_bounds: EffectBounds::from(0..3),
|
|
description: "Ilo".to_string(),
|
|
};
|
|
|
|
// Compute the delta
|
|
let mut delta = e1.delta(&e2);
|
|
let mut delta2 = e2.delta(&e2);
|
|
let mut delta3 = e2.delta(&e1);
|
|
delta.id = Uuid::nil();
|
|
delta2.id = Uuid::nil();
|
|
delta3.id = Uuid::nil();
|
|
assert_snapshot!(format!(
|
|
"{:#?}{}",
|
|
&delta,
|
|
delta.full_stats_to_table().unwrap()
|
|
));
|
|
assert_snapshot!(format!(
|
|
"{:#?}{}",
|
|
delta2,
|
|
delta2.full_stats_to_table().unwrap()
|
|
));
|
|
assert_snapshot!(format!(
|
|
"{:#?}{}",
|
|
delta3,
|
|
delta3.full_stats_to_table().unwrap()
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_option_stats_delta() {
|
|
init_snapshot_env();
|
|
|
|
let a = OverallStats::linear(32);
|
|
let b = OverallStats::linear(22);
|
|
|
|
let opt_a = Some(a.clone());
|
|
let opt_b = Some(b.clone());
|
|
|
|
// `delta` is commutative for the purpose of the snapshot
|
|
let delta = opt_a.delta(&opt_b);
|
|
let delta2 = None.delta(&opt_b);
|
|
let delta3 = opt_a.delta(&None);
|
|
let delta4 = None::<OverallStats>.delta(&None);
|
|
|
|
assert_snapshot!(format!("{:#?}", delta));
|
|
assert_snapshot!(format!("{:#?}", delta2));
|
|
assert_snapshot!(format!("{:#?}", delta3));
|
|
assert_snapshot!(format!("{:#?}", delta4));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_meta_stats_delta() {
|
|
init_snapshot_env();
|
|
|
|
let meta1 = MetaStats {
|
|
position: Position::from((1, 11)),
|
|
capital: Some(stats::TownId(Uuid::from_u128(1000))),
|
|
governor: Some(stats::CharacterId(500)),
|
|
faction: Some(stats::FactionId(1)),
|
|
links: vec![TownId(Uuid::from_u128(12))],
|
|
prestige: stats::GenericStat(3),
|
|
};
|
|
|
|
let meta2 = MetaStats {
|
|
position: Position::from((44, 555)),
|
|
capital: Some(stats::TownId(Uuid::from_u128(12))),
|
|
governor: Some(stats::CharacterId(400)),
|
|
faction: Some(stats::FactionId(33)),
|
|
links: vec![TownId::from(Uuid::from_u128(42))],
|
|
prestige: stats::GenericStat(1),
|
|
};
|
|
let meta3 = MetaStats {
|
|
position: Position::from((44, 555)),
|
|
capital: None,
|
|
governor: Some(stats::CharacterId(400)),
|
|
faction: Some(stats::FactionId(33)),
|
|
links: vec![TownId::from(Uuid::from_u128(2))],
|
|
prestige: stats::GenericStat(1),
|
|
};
|
|
|
|
let delta = meta1.delta(&meta2);
|
|
let delta2 = meta2.delta(&meta3);
|
|
let delta3 = meta3.delta(&meta3);
|
|
|
|
assert_snapshot!(format!("{:#?}", delta));
|
|
assert_snapshot!(format!("{:#?}", delta2));
|
|
assert_snapshot!(format!("{:#?}", delta3));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_delta_stat_positive() {
|
|
init_snapshot_env();
|
|
|
|
let mut e = Entity::default();
|
|
e.delta_stat(StatPair::from_str("health:4").unwrap());
|
|
e.id = Uuid::nil();
|
|
|
|
assert_snapshot!(format!("{:#?}", e));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_modify_duration() {
|
|
init_snapshot_env();
|
|
|
|
let mut e = Entity::default();
|
|
e.modify_duration(EntityDuration::Duration(33));
|
|
e.id = Uuid::nil();
|
|
|
|
assert_snapshot!(format!("{:#?}", e));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_modify_effect_application() {
|
|
init_snapshot_env();
|
|
|
|
let mut e = Entity::default();
|
|
e.modify_effect_application(EffectApplication::PermanentEffectApplied);
|
|
e.id = Uuid::nil();
|
|
|
|
assert_snapshot!(format!("{:#?}", e));
|
|
}
|
|
|
|
#[test]
|
|
fn snapshot_modify_effect_bounds() {
|
|
init_snapshot_env();
|
|
|
|
let mut e = Entity::default();
|
|
e.modify_effect_bounds(EffectBounds::from(33..33));
|
|
e.id = Uuid::nil();
|
|
|
|
assert_snapshot!(format!("{:#?}", e));
|
|
}
|
|
|
|
#[test]
|
|
fn test_rng() {
|
|
Entity::create_rng(&EntityType::Character, &crate::utils::RngLevel::Zero).unwrap();
|
|
Entity::create_rng(&EntityType::Player, &crate::utils::RngLevel::Low).unwrap();
|
|
Entity::create_rng(&EntityType::Town, &crate::utils::RngLevel::Med).unwrap();
|
|
Entity::create_rng(&EntityType::Monster, &crate::utils::RngLevel::High).unwrap();
|
|
Entity::create_rng(&EntityType::Blocker, &crate::utils::RngLevel::Legendary).unwrap();
|
|
Entity::create_rng(&EntityType::Event, &crate::utils::RngLevel::Mixed).unwrap();
|
|
Entity::create_rng(&EntityType::Event, &crate::utils::RngLevel::Flawed).unwrap();
|
|
}
|