use rand::distributions::uniform::SampleUniform;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use uuid::Uuid;
#[derive(Debug, Clone)]
pub struct WorkflowRand {
workflow_id: String,
step_counter: Arc<AtomicU64>,
}
impl WorkflowRand {
pub fn new(workflow_id: impl Into<String>) -> Self {
Self {
workflow_id: workflow_id.into(),
step_counter: Arc::new(AtomicU64::new(0)),
}
}
fn next_rng(&self) -> StdRng {
let counter = self.step_counter.fetch_add(1, Ordering::SeqCst);
let seed = self.compute_seed(counter);
StdRng::seed_from_u64(seed)
}
fn compute_seed(&self, counter: u64) -> u64 {
let mut hasher = DefaultHasher::new();
self.workflow_id.hash(&mut hasher);
counter.hash(&mut hasher);
hasher.finish()
}
pub fn uuid(&self) -> Uuid {
let mut rng = self.next_rng();
let random_u128 = rng.gen();
Uuid::from_u128(random_u128)
}
pub fn random(&self) -> f64 {
let mut rng = self.next_rng();
rng.gen()
}
pub fn random_range<T, R>(&self, range: R) -> T
where
T: SampleUniform,
R: rand::distributions::uniform::SampleRange<T>,
{
let mut rng = self.next_rng();
rng.gen_range(range)
}
pub fn bool(&self) -> bool {
let mut rng = self.next_rng();
rng.gen()
}
pub fn choose<'a, T>(&self, items: &'a [T]) -> Option<&'a T> {
if items.is_empty() {
return None;
}
let mut rng = self.next_rng();
let index = rng.gen_range(0..items.len());
Some(&items[index])
}
pub fn shuffle<T>(&self, items: &mut [T]) {
use rand::seq::SliceRandom;
let mut rng = self.next_rng();
items.shuffle(&mut rng);
}
pub fn choose_multiple<T: Clone>(&self, items: &[T], count: usize) -> Vec<T> {
use rand::seq::SliceRandom;
if items.is_empty() {
return vec![];
}
let mut rng = self.next_rng();
let actual_count = count.min(items.len());
items
.choose_multiple(&mut rng, actual_count)
.cloned()
.collect()
}
pub fn step_count(&self) -> u64 {
self.step_counter.load(Ordering::SeqCst)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_workflow_rand_uuid_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let uuid1 = rand1.uuid();
let uuid2 = rand2.uuid();
assert_eq!(uuid1, uuid2);
}
#[test]
fn test_workflow_rand_uuid_different_workflows() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-456");
let uuid1 = rand1.uuid();
let uuid2 = rand2.uuid();
assert_ne!(uuid1, uuid2);
}
#[test]
fn test_workflow_rand_uuid_sequence() {
let rand = WorkflowRand::new("wf-123");
let uuid1 = rand.uuid();
let uuid2 = rand.uuid();
let uuid3 = rand.uuid();
assert_ne!(uuid1, uuid2);
assert_ne!(uuid2, uuid3);
assert_ne!(uuid1, uuid3);
}
#[test]
fn test_workflow_rand_random_in_range() {
let rand = WorkflowRand::new("wf-123");
for _ in 0..100 {
let value = rand.random();
assert!((0.0..1.0).contains(&value));
}
}
#[test]
fn test_workflow_rand_random_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let value1 = rand1.random();
let value2 = rand2.random();
assert_eq!(value1, value2);
}
#[test]
fn test_workflow_rand_random_range() {
let rand = WorkflowRand::new("wf-123");
for _ in 0..100 {
let value = rand.random_range(10..20);
assert!((10..20).contains(&value));
}
}
#[test]
fn test_workflow_rand_random_range_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let value1 = rand1.random_range(5..15);
let value2 = rand2.random_range(5..15);
assert_eq!(value1, value2);
}
#[test]
fn test_workflow_rand_bool() {
let rand = WorkflowRand::new("wf-123");
let mut true_count = 0;
let mut false_count = 0;
for _ in 0..100 {
if rand.bool() {
true_count += 1;
} else {
false_count += 1;
}
}
assert!(true_count > 0);
assert!(false_count > 0);
}
#[test]
fn test_workflow_rand_bool_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let value1 = rand1.bool();
let value2 = rand2.bool();
assert_eq!(value1, value2);
}
#[test]
fn test_workflow_rand_choose() {
let rand = WorkflowRand::new("wf-123");
let items = vec!["a", "b", "c"];
let choice = rand.choose(&items);
assert!(choice.is_some());
assert!(items.contains(choice.unwrap()));
}
#[test]
fn test_workflow_rand_choose_empty() {
let rand = WorkflowRand::new("wf-123");
let items: Vec<&str> = vec![];
let choice = rand.choose(&items);
assert!(choice.is_none());
}
#[test]
fn test_workflow_rand_choose_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let items = vec!["a", "b", "c"];
let choice1 = rand1.choose(&items);
let choice2 = rand2.choose(&items);
assert_eq!(choice1, choice2);
}
#[test]
fn test_workflow_rand_shuffle() {
let rand = WorkflowRand::new("wf-123");
let mut items1 = vec![1, 2, 3, 4, 5];
let items2 = items1.clone();
rand.shuffle(&mut items1);
let same_order = items1.iter().zip(items2.iter()).all(|(a, b)| a == b);
assert!(!same_order || items1.len() <= 1);
}
#[test]
fn test_workflow_rand_shuffle_deterministic() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = WorkflowRand::new("wf-123");
let mut items1 = vec![1, 2, 3, 4, 5];
let mut items2 = vec![1, 2, 3, 4, 5];
rand1.shuffle(&mut items1);
rand2.shuffle(&mut items2);
assert_eq!(items1, items2);
}
#[test]
fn test_workflow_rand_shuffle_empty() {
let rand = WorkflowRand::new("wf-123");
let mut items: Vec<i32> = vec![];
rand.shuffle(&mut items);
assert_eq!(items.len(), 0);
}
#[test]
fn test_workflow_rand_shuffle_single() {
let rand = WorkflowRand::new("wf-123");
let mut items = vec![42];
rand.shuffle(&mut items);
assert_eq!(items, vec![42]);
}
#[test]
fn test_workflow_rand_choose_multiple() {
let rand = WorkflowRand::new("wf-123");
let items = vec![1, 2, 3, 4, 5];
let chosen = rand.choose_multiple(&items, 3);
assert_eq!(chosen.len(), 3);
for item in &chosen {
assert!(items.contains(item));
}
let mut sorted = chosen.clone();
sorted.sort();
sorted.dedup();
assert_eq!(sorted.len(), chosen.len());
}
#[test]
fn test_workflow_rand_choose_multiple_more_than_available() {
let rand = WorkflowRand::new("wf-123");
let items = vec![1, 2, 3];
let chosen = rand.choose_multiple(&items, 10);
assert_eq!(chosen.len(), 3); }
#[test]
fn test_workflow_rand_choose_multiple_empty() {
let rand = WorkflowRand::new("wf-123");
let items: Vec<i32> = vec![];
let chosen = rand.choose_multiple(&items, 5);
assert_eq!(chosen.len(), 0);
}
#[test]
fn test_workflow_rand_clone() {
let rand1 = WorkflowRand::new("wf-123");
let rand2 = rand1.clone();
let uuid1 = rand1.uuid();
let uuid2 = rand2.uuid();
assert_ne!(uuid1, uuid2);
let rand3 = WorkflowRand::new("wf-123");
let rand4 = WorkflowRand::new("wf-123");
let uuid3 = rand3.uuid();
let uuid4 = rand4.uuid();
assert_eq!(uuid3, uuid4);
}
#[test]
fn test_workflow_rand_compute_seed_consistency() {
let rand = WorkflowRand::new("wf-123");
let seed1 = rand.compute_seed(0);
let seed2 = rand.compute_seed(0);
assert_eq!(seed1, seed2);
}
#[test]
fn test_workflow_rand_compute_seed_different_counters() {
let rand = WorkflowRand::new("wf-123");
let seed1 = rand.compute_seed(0);
let seed2 = rand.compute_seed(1);
assert_ne!(seed1, seed2);
}
#[test]
fn test_workflow_rand_step_count() {
let rand = WorkflowRand::new("wf-123");
assert_eq!(rand.step_count(), 0);
rand.uuid();
assert_eq!(rand.step_count(), 1);
rand.random();
assert_eq!(rand.step_count(), 2);
rand.random_range(1..10);
assert_eq!(rand.step_count(), 3);
rand.bool();
assert_eq!(rand.step_count(), 4);
}
}