use crate::Client;
use crate::handlers::HandlerId;
impl Client {
pub fn remove_handler(&self, handler: HandlerId) -> bool {
self.0.handlers.remove(handler)
}
}
#[cfg(test)]
mod tests {
use tokio::sync::mpsc;
use crate::Client;
use crate::raw::{Serializable, base, types};
use crate::session::{Incoming, UpdatesRx};
use crate::storage::UpdateState;
use crate::types::RawUpdate;
#[tokio::test]
async fn a_removed_handler_gets_no_more_updates() {
let me = vec![base::User::UserEmpty(types::UserEmpty { id: 1 })];
let empty = base::updates::Difference::DifferenceEmpty(types::updates::DifferenceEmpty { date: 2, seq: 3 });
let (client, _sent) = Client::scripted(vec![Ok(me.to_bytes()), Ok(empty.to_bytes())]);
*client.0.state.lock().unwrap() = Some(UpdateState { pts: 10, date: 1, ..Default::default() });
let (updates, rx) = UpdatesRx::channel();
*client.0.updates.lock().await = rx;
let (tx, mut seen) = mpsc::unbounded_channel();
let handler = |name: &'static str| {
let tx = tx.clone();
move |_: Client, _: RawUpdate| {
let _ = tx.send(name);
async { Ok(()) }
}
};
let a = client.on_raw_update(handler("a")).id();
client.on_raw_update(handler("b"));
assert!(client.remove_handler(a));
let run = tokio::spawn({
let client = client.clone();
async move { client.run().await }
});
let status = types::UpdateUserStatus { user_id: 7, status: base::UserStatus::UserStatusEmpty };
let update = types::UpdateShort { update: base::Update::UpdateUserStatus(Box::new(status)), date: 2 };
updates
.send(Incoming { updates: base::Updates::UpdateShort(Box::new(update)), from_request: false })
.await
.unwrap();
assert_eq!(seen.recv().await, Some("b"));
client.stop();
assert!(run.await.unwrap().is_ok());
assert!(seen.try_recv().is_err(), "the removed handler ran");
}
#[test]
fn removing_twice_returns_false() {
let client = Client::offline();
let id = client.on_raw_update(|_, _| async { Ok(()) }).id();
assert!(client.remove_handler(id));
assert!(!client.remove_handler(id));
}
#[test]
fn raw_handlers_can_be_removed() {
let client = Client::offline();
let id = client.on_raw_update(|_, _| async { Ok(()) }).id();
let generation = client.0.handlers.generation();
assert!(client.remove_handler(id));
assert!(client.0.handlers.current().raw.is_empty());
assert!(client.0.handlers.generation() > generation, "a running dispatcher would keep the old router");
}
#[tokio::test]
async fn next_step_handlers_can_be_removed() {
let client = Client::offline();
let ran = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
let flag = ran.clone();
let id = client
.register_next_step_handler(move |_: crate::types::Message| {
flag.store(true, std::sync::atomic::Ordering::Relaxed);
async { Ok(()) }
})
.await
.unwrap();
let generation = client.0.handlers.generation();
assert!(client.remove_handler(id));
assert!(!client.remove_handler(id));
assert_eq!(client.0.handlers.generation(), generation, "a listener removal needs no new router");
crate::dispatcher::listeners::tests::dispatch(&client, crate::dispatcher::listeners::tests::new_message(1, 7));
for _ in 0..20 {
tokio::task::yield_now().await;
}
assert!(!ran.load(std::sync::atomic::Ordering::Relaxed), "the removed next step ran");
}
}