use std::sync::{Arc, Mutex};
use std::time::Duration;
use runact::{Actor, ActorContext, ActorError, Runtime, TimerId};
struct TimerActor {
received: Arc<Mutex<Vec<String>>>,
}
#[derive(Clone)]
enum TimerMessage {
Ping(String),
GetCount,
}
impl Actor for TimerActor {
type Message = TimerMessage;
fn handle(&mut self, msg: TimerMessage, ctx: &mut ActorContext) -> Result<(), ActorError> {
match msg {
TimerMessage::Ping(text) => {
self.received.lock().unwrap().push(text);
}
TimerMessage::GetCount => {
let count = self.received.lock().unwrap().len();
let _ = ctx.reply(count);
}
}
Ok(())
}
}
#[test]
fn test_one_shot_timer() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let actor = runtime.spawn(TimerActor { received: received.clone() }).expect("Failed to spawn");
let _ = runtime.schedule_timer(
Duration::from_millis(50),
actor,
TimerMessage::Ping("timer-fired".to_string()),
);
std::thread::sleep(Duration::from_millis(100));
let handle = runtime.request(actor, TimerMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count = reply.downcast::<usize>().expect("Failed to downcast");
assert_eq!(*count, 1);
let msgs = received.lock().unwrap();
assert_eq!(msgs[0], "timer-fired");
}
#[test]
fn test_periodic_timer() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let actor = runtime.spawn(TimerActor { received: received.clone() }).expect("Failed to spawn");
let _ = runtime.schedule_interval(
Duration::from_millis(30),
actor,
TimerMessage::Ping("tick".to_string()),
);
std::thread::sleep(Duration::from_millis(100));
let handle = runtime.request(actor, TimerMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count = reply.downcast::<usize>().expect("Failed to downcast");
assert!(*count >= 2);
}
#[test]
fn test_timer_cancellation() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let actor = runtime.spawn(TimerActor { received: received.clone() }).expect("Failed to spawn");
let timer_id = runtime.schedule_timer(
Duration::from_millis(50),
actor,
TimerMessage::Ping("should-not-fire".to_string()),
);
runtime.cancel_timer(timer_id);
std::thread::sleep(Duration::from_millis(100));
let handle = runtime.request(actor, TimerMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count = reply.downcast::<usize>().expect("Failed to downcast");
assert_eq!(*count, 0);
}
#[test]
fn test_multiple_timers() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let actor = runtime.spawn(TimerActor { received: received.clone() }).expect("Failed to spawn");
let _ = runtime.schedule_timer(
Duration::from_millis(30),
actor,
TimerMessage::Ping("first".to_string()),
);
let _ = runtime.schedule_timer(
Duration::from_millis(60),
actor,
TimerMessage::Ping("second".to_string()),
);
std::thread::sleep(Duration::from_millis(100));
let handle = runtime.request(actor, TimerMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count = reply.downcast::<usize>().expect("Failed to downcast");
assert_eq!(*count, 2);
let msgs = received.lock().unwrap();
assert!(msgs.contains(&"first".to_string()));
assert!(msgs.contains(&"second".to_string()));
}
struct SelfTimerActor {
received: Arc<Mutex<Vec<String>>>,
}
#[derive(Clone)]
enum SelfTimerMessage {
Start,
Ping(String),
GetCount,
}
impl Actor for SelfTimerActor {
type Message = SelfTimerMessage;
fn handle(&mut self, msg: SelfTimerMessage, ctx: &mut ActorContext) -> Result<(), ActorError> {
match msg {
SelfTimerMessage::Start => {
let _ = ctx.schedule_timer(
Duration::from_millis(30),
SelfTimerMessage::Ping("self-timer".to_string()),
).expect("Failed to schedule timer");
}
SelfTimerMessage::Ping(text) => {
self.received.lock().unwrap().push(text);
}
SelfTimerMessage::GetCount => {
let count = self.received.lock().unwrap().len();
let _ = ctx.reply(count);
}
}
Ok(())
}
}
#[test]
fn test_actor_schedules_timer_from_handle() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let actor = runtime.spawn(SelfTimerActor { received: received.clone() }).expect("Failed to spawn");
runtime.send(actor, SelfTimerMessage::Start).expect("Failed to send");
std::thread::sleep(Duration::from_millis(100));
let handle = runtime.request(actor, SelfTimerMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count = reply.downcast::<usize>().expect("Failed to downcast");
assert_eq!(*count, 1);
let msgs = received.lock().unwrap();
assert_eq!(msgs[0], "self-timer");
}
struct SelfIntervalActor {
received: Arc<Mutex<Vec<String>>>,
timer_id: Arc<Mutex<Option<TimerId>>>,
}
#[derive(Clone)]
enum SelfIntervalMessage {
StartInterval,
Ping(String),
GetCount,
}
impl Actor for SelfIntervalActor {
type Message = SelfIntervalMessage;
fn handle(&mut self, msg: SelfIntervalMessage, ctx: &mut ActorContext) -> Result<(), ActorError> {
match msg {
SelfIntervalMessage::StartInterval => {
let id = ctx.schedule_interval(
Duration::from_millis(30),
SelfIntervalMessage::Ping("interval-tick".to_string()),
).expect("Failed to schedule interval");
*self.timer_id.lock().unwrap() = Some(id);
}
SelfIntervalMessage::Ping(text) => {
self.received.lock().unwrap().push(text);
}
SelfIntervalMessage::GetCount => {
let count = self.received.lock().unwrap().len();
let _ = ctx.reply(count);
}
}
Ok(())
}
}
#[test]
fn test_actor_schedules_interval_from_handle() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let timer_id = Arc::new(Mutex::new(None));
let actor = runtime.spawn(SelfIntervalActor { received: received.clone(), timer_id: timer_id.clone() }).expect("Failed to spawn");
runtime.send(actor, SelfIntervalMessage::StartInterval).expect("Failed to send");
std::thread::sleep(Duration::from_millis(100));
let handle = runtime.request(actor, SelfIntervalMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count = reply.downcast::<usize>().expect("Failed to downcast");
assert!(*count >= 2);
if let Some(id) = timer_id.lock().unwrap().take() {
runtime.cancel_timer(id);
}
}
#[test]
fn test_actor_cancels_interval_from_handle() {
let mut runtime = Runtime::new().expect("Failed to create runtime");
let received: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
let timer_id = Arc::new(Mutex::new(None));
let actor = runtime.spawn(SelfIntervalActor { received: received.clone(), timer_id: timer_id.clone() }).expect("Failed to spawn");
runtime.send(actor, SelfIntervalMessage::StartInterval).expect("Failed to send");
std::thread::sleep(Duration::from_millis(75));
let id = timer_id.lock().unwrap().take().expect("Timer ID not set");
runtime.cancel_timer(id);
std::thread::sleep(Duration::from_millis(50));
let handle = runtime.request(actor, SelfIntervalMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count_before = *reply.downcast::<usize>().expect("Failed to downcast");
std::thread::sleep(Duration::from_millis(200));
let handle = runtime.request(actor, SelfIntervalMessage::GetCount).expect("Failed to request");
let reply = handle.recv_timeout(Duration::from_secs(1)).expect("Failed to receive");
let count_after = *reply.downcast::<usize>().expect("Failed to downcast");
assert_eq!(count_before, count_after, "Timer should have stopped after cancellation");
}