601 lines
22 KiB
Rust
601 lines
22 KiB
Rust
//! Module that handles all the logic related to votes within an application.
|
|
//!
|
|
//! This module provides the necessary structures and traits to manage events and their corresponding votes. It includes:
|
|
//!
|
|
//! - Structs: `Event`, `Vote`, `PendingEvents`, and `OngoingEvents`.
|
|
//! - Traits: None at this time.
|
|
//! - Enums: `EventStatus` that represents different states an event can be in.
|
|
//!
|
|
//! Note:
|
|
//! - The types `UserDataType`, `VoteValueType`, and some fields are marked as deprecated and should not be used.
|
|
//! They are placeholders for the actual data structures which need to be defined correctly.
|
|
#![allow(deprecated)]
|
|
|
|
use std::{
|
|
collections::HashMap,
|
|
fmt::Display,
|
|
sync::{LazyLock, Mutex},
|
|
};
|
|
|
|
use chrono::NaiveDateTime;
|
|
use serde::{Deserialize, Serialize};
|
|
use uuid::Uuid;
|
|
|
|
use crate::{date::date_tools::NaiveDateList, error_handling::IdleError};
|
|
|
|
// Helper functions, user facing
|
|
// Helper functions, user facing
|
|
|
|
/// Adds a parsed vote to the list of planned events.
|
|
///
|
|
/// This function will use the `PendingEvents` instance to store the provided event.
|
|
/// The structure of the input parameter `event` is expected to be a correctly formatted parsed vote.
|
|
///
|
|
/// ## Parameters:
|
|
/// - `event`: A `ParsedVote` struct representing the details of the event to be scheduled.
|
|
///
|
|
/// ## Example:
|
|
/// ```rust
|
|
/// # use idlefox::votes::{add_pending_event, ParsedVote};
|
|
/// let parsed_vote = ParsedVote::default();
|
|
///
|
|
/// let id = add_pending_event(parsed_vote).unwrap();
|
|
/// ```
|
|
pub fn add_pending_event(event: ParsedVote) -> Result<Uuid, IdleError> {
|
|
PENDING_EVENTS
|
|
.lock()
|
|
.unwrap()
|
|
// .map_err(|_| IdleError::MutexError)?
|
|
.add_pending_event(event)
|
|
}
|
|
|
|
/// Launches a pending event by transferring it from the pending to ongoing events list.
|
|
///
|
|
/// This function identifies an event by its UUID and moves it from the planned (pending) events to the ongoing events. If the event is successfully launched, it returns `Ok(())`. Otherwise, it returns an error of type `IdleError`.
|
|
///
|
|
/// ## Parameters:
|
|
/// - `uuid`: A `Uuid` that uniquely identifies the event to be launched.
|
|
///
|
|
/// ## Example:
|
|
/// ```rust
|
|
/// # use idlefox::votes::{add_pending_event, make_into_ongoing_event, ParsedVote};
|
|
/// let id = add_pending_event(ParsedVote::default()).unwrap();
|
|
///
|
|
/// make_into_ongoing_event(id).unwrap()
|
|
/// ```
|
|
pub fn make_into_ongoing_event(uuid: Uuid) -> Result<(), IdleError> {
|
|
PENDING_EVENTS
|
|
.lock()
|
|
.unwrap()
|
|
// .map_err(|_| IdleError::MutexError)?
|
|
.launch(uuid)
|
|
}
|
|
|
|
/// Manually adds an ongoing event.
|
|
///
|
|
/// This function is intended for internal use and directly adds an event
|
|
/// to the list of ongoing events. It expects a UUID and a parsed vote as inputs,
|
|
/// using which it updates the `OngoingEvents` instance.
|
|
///
|
|
/// ## Parameters:
|
|
/// - `uuid`: A `Uuid` that uniquely identifies the event to be added.
|
|
/// - `event`: A `ParsedVote` struct representing the details of the ongoing event to be added.
|
|
///
|
|
/// ## Example:
|
|
/// ```rust
|
|
/// # use uuid::Uuid;
|
|
/// # use idlefox::votes::{add_ongoing_event, ParsedVote};
|
|
/// let uuid = Uuid::new_v4(); // A new id
|
|
/// let parsed_vote = ParsedVote::default(); // A very legit event
|
|
///
|
|
/// add_ongoing_event(uuid, parsed_vote).unwrap();
|
|
/// ```
|
|
pub fn add_ongoing_event(uuid: Uuid, event: ParsedVote) -> Result<(), IdleError> {
|
|
ONGOING_EVENTS
|
|
.lock()
|
|
.unwrap()
|
|
// .map_err(|_| IdleError::MutexError)?
|
|
.add_event(uuid, event)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Destroy an event without closing it and officially ending it
|
|
///
|
|
/// This function removes an ongoing event from the list of ongoing events.
|
|
/// It expects a UUID as input and returns a `Result` containing either a `ParsedVote`
|
|
/// struct representing the details of the removed event or an `IdleError`.
|
|
///
|
|
/// ## Example:
|
|
/// ```rust
|
|
/// # use idlefox::votes::{
|
|
/// # add_pending_event, del_ongoing_event, make_into_ongoing_event, ParsedVote,
|
|
/// # };
|
|
/// let id = add_pending_event(ParsedVote::default()).unwrap();
|
|
/// make_into_ongoing_event(id).unwrap();
|
|
///
|
|
/// del_ongoing_event(id).unwrap();
|
|
/// ```
|
|
pub fn del_ongoing_event(uuid: Uuid) -> Result<ParsedVote, IdleError> {
|
|
ONGOING_EVENTS
|
|
.lock()
|
|
.unwrap()
|
|
// .map_err(|_| IdleError::MutexError)?
|
|
.del_event(uuid)
|
|
}
|
|
|
|
/// Destroy a pending event without closing it
|
|
///
|
|
/// This function removes a pending event from the list of pending events.
|
|
/// It expects a UUID as input and returns a `Result` containing either a `ParsedVote`
|
|
/// struct representing the details of the removed event or an `IdleError`.
|
|
///
|
|
/// ## Example:
|
|
/// ```rust
|
|
/// # use idlefox::votes::{
|
|
/// # add_pending_event, del_pending_event, make_into_ongoing_event, ParsedVote,
|
|
/// # };
|
|
/// let id = add_pending_event(ParsedVote::default()).unwrap();
|
|
/// del_pending_event(id).unwrap();
|
|
/// ```
|
|
pub fn del_pending_event(uuid: Uuid) -> Result<ParsedVote, IdleError> {
|
|
PENDING_EVENTS
|
|
.lock()
|
|
.unwrap()
|
|
// .map_err(|_| IdleError::MutexError)?
|
|
.del_event(uuid)
|
|
}
|
|
|
|
/// This function is used to close an ongoing event and return the parsed vote associated with it. If the closure is successful, the owned event is returned for post-treatment.
|
|
/// # Arguments
|
|
///
|
|
/// * `uuid` - A Uuid representing the identifier of the event that is to be closed.
|
|
///
|
|
/// ## Example:
|
|
/// ```rust
|
|
/// # use idlefox::votes::{
|
|
/// # add_pending_event, close_ongoing_event, make_into_ongoing_event, ParsedVote,
|
|
/// # };
|
|
/// let id = add_pending_event(ParsedVote::default()).unwrap();
|
|
/// make_into_ongoing_event(id).unwrap();
|
|
/// close_ongoing_event(id).unwrap();
|
|
/// ```
|
|
pub fn close_ongoing_event(uuid: Uuid) -> Result<ParsedVote, IdleError> {
|
|
ONGOING_EVENTS
|
|
.lock()
|
|
.unwrap()
|
|
// .map_err(|_| IdleError::MutexError)?
|
|
.close_event(uuid)
|
|
}
|
|
|
|
/// Placeholder datatype
|
|
///
|
|
/// Links to an event, active or planned
|
|
type EventDataType = Uuid;
|
|
|
|
/// Placeholder user data type
|
|
///
|
|
/// Links back to an user
|
|
#[deprecated(note = "This is an incorrect type to define an user")]
|
|
type UserDataType = String;
|
|
|
|
/// What an user voted for
|
|
#[deprecated(note = "This is an incorrect type to define a voting ballot")]
|
|
type VoteValueType = String;
|
|
|
|
/// A vote, represents a user interraction towards an event
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
#[cfg_attr(test, derive(Clone))]
|
|
pub(crate) struct Ballot {
|
|
/// The event the vote refers to
|
|
linked_event: EventDataType,
|
|
/// The user casting the vote
|
|
user_handle: UserDataType,
|
|
/// What the user voted for
|
|
vote_value: VoteValueType,
|
|
}
|
|
|
|
/// The global status of the event
|
|
#[derive(Serialize, Deserialize, Default, Debug, Clone, Copy)]
|
|
pub(crate) enum EventStatus {
|
|
#[default]
|
|
/// The event exists but wasn't started yet
|
|
Pending,
|
|
/// The event was started but the finish date wasn't reached yet
|
|
Started,
|
|
/// The event was started and the date finish date was reached without being closed
|
|
Finished,
|
|
/// The event was closed and the outcome was made public
|
|
Closed,
|
|
/// The event was cancelled
|
|
Cancelled,
|
|
}
|
|
// impl EventStatus {
|
|
// /// Check if the event isn't closed, remove this abreration when you add another CLOSED_EVENT struct
|
|
// fn not_closed(&self) -> bool {
|
|
// matches!(self, EventStatus::Closed)
|
|
// }
|
|
// }
|
|
|
|
/// An event, wether ongoing or planned
|
|
#[derive(Debug, Serialize, Deserialize, Default)]
|
|
#[cfg_attr(test, derive(Clone))]
|
|
pub struct ParsedVote {
|
|
/// The title of the even
|
|
title: String,
|
|
/// Description of the event
|
|
description: String,
|
|
/// The global status of the vote
|
|
status: EventStatus,
|
|
/// Date at which to autostart the vote process
|
|
launch_date: NaiveDateTime,
|
|
/// Date at which to autoclose the vote process
|
|
close_date: NaiveDateTime,
|
|
/// Date at which to autodelete the vote process
|
|
auto_delete_date: NaiveDateTime,
|
|
/// The inner list of votes cast
|
|
votes: Vec<Ballot>,
|
|
/// The list of values to vote for, this list all the valid dates to vote for
|
|
list_candidates: NaiveDateList,
|
|
// / The vote type
|
|
}
|
|
|
|
impl ParsedVote {
|
|
// #[allow(dead_code, unused_variables)]
|
|
// pub(crate) fn new(
|
|
// title: String,
|
|
// description: String,
|
|
// status: EventStatus,
|
|
// launch_date: NaiveDateTime,
|
|
// close_date: NaiveDateTime,
|
|
// // ballots: Vec<Ballot>,
|
|
// list_candidates: NaiveDateList,
|
|
// ) -> Self {
|
|
// // Have a rather smart close date if not specified
|
|
// todo!()
|
|
// }
|
|
|
|
/// All the logic behind a vote becoming live
|
|
fn launch(&mut self) -> Result<(), IdleError> {
|
|
// TODO: Define this
|
|
self.status = EventStatus::Started;
|
|
// Maybe send a message ? the bot will need the Uuid of the event to be able to add reaction
|
|
// TODO: This is a vkypoint, as this method will need an IO interaction
|
|
Ok(())
|
|
}
|
|
|
|
/// Close the event
|
|
fn close(&mut self) {
|
|
self.status = EventStatus::Closed;
|
|
}
|
|
}
|
|
|
|
// impl From<VoteContainer> for ParsedVote {
|
|
// fn from(value: VoteContainer) -> Self {
|
|
// todo!()
|
|
// }
|
|
// }
|
|
|
|
impl Display for ParsedVote {
|
|
/// A display for a vote, it is exactly what the discord bot will send
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
// TODO: Complete this (vky)
|
|
write!(f, "{:?}", self)
|
|
}
|
|
}
|
|
|
|
// This split in two differents structs conceptually represents
|
|
// the fact that very differents actions will be performed for each struct
|
|
type EventListType = HashMap<Uuid, ParsedVote>;
|
|
|
|
// The list of pending events, not yet started
|
|
///
|
|
/// This struct represents the collection of events that have been scheduled but have not yet begun.
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct PendingEvents {
|
|
/// The list of pending events
|
|
pending_events: EventListType,
|
|
}
|
|
|
|
impl PendingEvents {
|
|
/// Create a new empty list of events, called in case of a first initialization.
|
|
///
|
|
/// However, a deserialization will always be performed if possible.
|
|
fn new() -> Self {
|
|
Self {
|
|
pending_events: EventListType::new(),
|
|
}
|
|
}
|
|
|
|
/// Add a new event to the list of upcoming events.
|
|
///
|
|
/// This function generates a new UUID for the event before adding it to the list.
|
|
fn add_pending_event(&mut self, event: ParsedVote) -> Result<Uuid, IdleError> {
|
|
let id = Uuid::new_v4();
|
|
self.pending_events.insert(id, event);
|
|
Ok(id)
|
|
}
|
|
|
|
/// Process and activate all upcoming events if the auto-launch time has been reached.
|
|
///
|
|
/// Returns an `IdleError` if there's an issue launching any event or adding it to the ongoing list.
|
|
pub fn process_upcoming(&mut self, current_time: NaiveDateTime) -> Result<(), IdleError> {
|
|
self.find_upcoming(current_time)
|
|
.iter()
|
|
.try_for_each(|uuid| {
|
|
self.launch(*uuid)?;
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Launch the specified event by moving it from pending events to ongoing events.
|
|
///
|
|
/// Returns an `IdleError` if the event cannot be found in pending events.
|
|
fn launch(&mut self, uuid: Uuid) -> Result<(), IdleError> {
|
|
let event = self
|
|
.pending_events
|
|
.remove(&uuid)
|
|
.ok_or(IdleError::EventLaunch(uuid))?;
|
|
add_ongoing_event(uuid, event)?;
|
|
// make_into_ongoing_event(uuid)?;
|
|
Ok(())
|
|
}
|
|
|
|
/// Find all events that are scheduled to start after the given date.
|
|
///
|
|
/// Returns a vector of UUIDs corresponding to the upcoming events.
|
|
fn find_upcoming(&self, current_time: NaiveDateTime) -> Vec<Uuid> {
|
|
self.pending_events
|
|
.iter()
|
|
.filter(|&(_, e)| e.launch_date <= current_time)
|
|
.map(|(k, _v)| (*k))
|
|
.collect()
|
|
}
|
|
/// delete the event without launching it
|
|
pub fn del_event(&mut self, uuid: Uuid) -> Result<ParsedVote, IdleError> {
|
|
self.pending_events
|
|
.remove(&uuid)
|
|
.ok_or(IdleError::DeleteEvent(uuid))
|
|
}
|
|
|
|
// TODO: maybe add an update_upcoming(date) ?
|
|
}
|
|
|
|
/// The list of ongoing events, not yet closed
|
|
///
|
|
/// This struct represents the collection of events that have been initiated but have not yet concluded.
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct OngoingEvents {
|
|
/// The list of ongoing events
|
|
ongoing_events: EventListType,
|
|
}
|
|
|
|
#[allow(dead_code, unused_variables)]
|
|
impl OngoingEvents {
|
|
/// Create a new empty list of ongoing events, called in case of a first initialization.
|
|
///
|
|
/// However, a deserialization will always be performed if possible.
|
|
fn new() -> Self {
|
|
Self {
|
|
ongoing_events: EventListType::new(),
|
|
}
|
|
}
|
|
|
|
/// Remove all outdated votes for the current user
|
|
///
|
|
/// This function is expected to be called periodically by the watchdog.
|
|
pub(crate) fn prune_old(&mut self, current_time: NaiveDateTime) -> Result<(), IdleError> {
|
|
let mut failure = Vec::new();
|
|
for uuid in self.find_old(current_time) {
|
|
if self.ongoing_events.remove(&uuid).is_none() {
|
|
failure.push(uuid);
|
|
}
|
|
}
|
|
match failure.is_empty() {
|
|
true => Ok(()),
|
|
false => Err(IdleError::EventPrune(failure)),
|
|
}
|
|
}
|
|
/// Remove all outdated votes for the current user
|
|
///
|
|
/// This function is expected to be called periodically by the watchdog.
|
|
pub(crate) fn autoclose(&mut self, current_time: NaiveDateTime) -> Result<(), IdleError> {
|
|
let failure = Vec::new();
|
|
for uuid in self.find_autoclose(current_time) {
|
|
self.ongoing_events
|
|
.get_mut(&uuid)
|
|
.ok_or(IdleError::EventLaunch(uuid))?
|
|
.close()
|
|
}
|
|
match failure.is_empty() {
|
|
true => Ok(()),
|
|
false => Err(IdleError::EventPrune(failure)),
|
|
}
|
|
}
|
|
|
|
/// Find all events that are scheduled to be autoclosed.
|
|
///
|
|
/// Returns a vector of UUIDs corresponding to the old events.
|
|
fn find_autoclose(&mut self, current_time: NaiveDateTime) -> Vec<Uuid> {
|
|
self.ongoing_events
|
|
.iter()
|
|
// TODO: Remove this when you do the sensible thing and add a CLOSED_EVENT structure
|
|
.filter(|(_, e)| {
|
|
e.close_date <= current_time && !matches!(e.status, EventStatus::Closed)
|
|
})
|
|
.map(|(k, _)| *k)
|
|
.collect()
|
|
}
|
|
|
|
/// Find all events that are too old and supposed to be pruned.
|
|
///
|
|
/// Returns a vector of UUIDs corresponding to the old events.
|
|
fn find_old(&mut self, current_time: NaiveDateTime) -> Vec<Uuid> {
|
|
self.ongoing_events
|
|
.iter()
|
|
.filter(|(_, e)| e.auto_delete_date <= current_time)
|
|
.map(|(k, _)| *k)
|
|
.collect()
|
|
}
|
|
|
|
/// Add a new event to the list of ongoing events.
|
|
///
|
|
/// This function also launch the event based and adds a callback with the Uuid of the original caller.
|
|
pub(crate) fn add_event(&mut self, id: Uuid, mut event: ParsedVote) -> Result<(), IdleError> {
|
|
event.launch()?;
|
|
self.ongoing_events.insert(id, event);
|
|
Ok(())
|
|
}
|
|
/// delete the event without launching it
|
|
pub fn del_event(&mut self, uuid: Uuid) -> Result<ParsedVote, IdleError> {
|
|
self.ongoing_events
|
|
.remove(&uuid)
|
|
.ok_or(IdleError::DeleteEvent(uuid))
|
|
}
|
|
|
|
/// Close an event removing it from the ongoing event list
|
|
pub fn close_event(&mut self, uuid: Uuid) -> Result<ParsedVote, IdleError> {
|
|
// TODO: Another vkypoint, as we cant continue without knowing how to send a message
|
|
let event = self
|
|
.ongoing_events
|
|
.remove(&uuid)
|
|
.ok_or(IdleError::LaunchingEvent(uuid))?;
|
|
let str_event = event.to_string();
|
|
// TODO: Do something with this string
|
|
Ok(event)
|
|
}
|
|
// TODO: maybe add an update_ongoing(date) ?
|
|
}
|
|
|
|
/// The thread safe list of pending events
|
|
pub static PENDING_EVENTS: LazyLock<Mutex<PendingEvents>> =
|
|
LazyLock::new(|| Mutex::new(PendingEvents::new()));
|
|
/// The thread safe list of ongoing events
|
|
pub static ONGOING_EVENTS: LazyLock<Mutex<OngoingEvents>> =
|
|
LazyLock::new(|| Mutex::new(OngoingEvents::new()));
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use chrono::{Days, Local};
|
|
|
|
use super::*;
|
|
macro_rules! gimme {
|
|
($ev: ident) => {
|
|
$ev.lock().unwrap()
|
|
};
|
|
}
|
|
|
|
// Test all structs can be safely initialized
|
|
#[test]
|
|
fn init_test() {
|
|
let _e = PendingEvents::new();
|
|
let _o = OngoingEvents::new();
|
|
assert!(PENDING_EVENTS.lock().is_ok());
|
|
assert!(ONGOING_EVENTS.lock().is_ok());
|
|
|
|
assert!(gimme!(PENDING_EVENTS)
|
|
.process_upcoming(Local::now().naive_local())
|
|
.is_ok());
|
|
assert!(gimme!(ONGOING_EVENTS)
|
|
.prune_old(Local::now().naive_local())
|
|
.is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn test_base_vote_handling() {
|
|
// assert!(ParsedVote::default().launch(Uuid::new_v4()).is_ok());
|
|
let ev = ParsedVote::default();
|
|
|
|
// Can we add a vote ?
|
|
let id = add_pending_event(ev.clone()).unwrap();
|
|
assert!(gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // Is the vote present ?
|
|
del_pending_event(id).unwrap();
|
|
assert!(!gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // Is the vote now deleted
|
|
|
|
let id = add_pending_event(ev.clone()).unwrap();
|
|
make_into_ongoing_event(id).unwrap(); // Launching this event
|
|
assert!(!gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // Is the vote now not pending
|
|
assert!(gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // Is the vote now ongoing
|
|
|
|
close_ongoing_event(id).unwrap();
|
|
assert!(!gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // Is the vote now not ongoing
|
|
|
|
let id = add_pending_event(ev.clone()).unwrap();
|
|
make_into_ongoing_event(id).unwrap(); // Launching this event
|
|
del_ongoing_event(id).unwrap();
|
|
assert!(!gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // Is the vote now not ongoing
|
|
}
|
|
|
|
#[test]
|
|
fn test_upcomming_events() {
|
|
let now = Local::now().naive_local();
|
|
let later = now.checked_add_days(Days::new(1)).unwrap();
|
|
let very_later = now.checked_add_days(Days::new(3)).unwrap();
|
|
let very_very_later = now.checked_add_days(Days::new(7)).unwrap();
|
|
let event = ParsedVote {
|
|
launch_date: later,
|
|
close_date: very_later,
|
|
auto_delete_date: very_very_later,
|
|
..Default::default()
|
|
};
|
|
assert!(now < later);
|
|
assert!(later < very_later);
|
|
|
|
let id = add_pending_event(event).unwrap();
|
|
assert!(gimme!(PENDING_EVENTS).find_upcoming(now).is_empty()); // no upcomming events
|
|
assert!(gimme!(ONGOING_EVENTS).find_old(now).is_empty()); // no old events
|
|
assert!(gimme!(ONGOING_EVENTS).find_autoclose(now).is_empty()); // no old events
|
|
gimme!(PENDING_EVENTS).process_upcoming(now).unwrap(); // nothing should be processed
|
|
gimme!(ONGOING_EVENTS).prune_old(now).unwrap(); // nothing should be processed
|
|
gimme!(ONGOING_EVENTS).autoclose(now).unwrap(); // nothing should be processed
|
|
assert!(gimme!(PENDING_EVENTS).find_upcoming(now).is_empty()); // no upcomming events
|
|
assert!(gimme!(ONGOING_EVENTS).find_old(now).is_empty()); // no old events
|
|
assert!(gimme!(ONGOING_EVENTS).find_autoclose(now).is_empty()); // no old events
|
|
assert!(gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // it's still here
|
|
assert!(!gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // it's wasn't processed
|
|
|
|
// Now some time passed
|
|
assert_eq!(gimme!(PENDING_EVENTS).find_upcoming(later), vec![id]); // one upcomming event
|
|
assert!(gimme!(ONGOING_EVENTS).find_old(later).is_empty()); // no old events
|
|
assert!(gimme!(ONGOING_EVENTS).find_autoclose(later).is_empty()); // no old events
|
|
gimme!(PENDING_EVENTS).process_upcoming(later).unwrap(); // one event should be processed
|
|
gimme!(ONGOING_EVENTS).prune_old(later).unwrap(); // nothing should be processed
|
|
gimme!(ONGOING_EVENTS).autoclose(later).unwrap(); // nothing should be processed
|
|
assert!(!gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // it's not here anymore
|
|
assert!(gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // it was processed
|
|
|
|
// More time passed
|
|
assert!(gimme!(PENDING_EVENTS).find_upcoming(very_later).is_empty()); // one upcomming event
|
|
assert_eq!(gimme!(ONGOING_EVENTS).find_autoclose(very_later), vec![id]); // one old event
|
|
assert!(gimme!(ONGOING_EVENTS).find_old(very_later).is_empty()); // no old events
|
|
gimme!(PENDING_EVENTS).process_upcoming(very_later).unwrap(); // no event should be processed
|
|
gimme!(ONGOING_EVENTS).prune_old(very_later).unwrap(); // nothing should be processed
|
|
gimme!(ONGOING_EVENTS).autoclose(very_later).unwrap(); // nothing should be processed
|
|
assert!(!gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // it's not here anymore
|
|
assert!(gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // it was processed
|
|
|
|
// More more time passed
|
|
assert!(gimme!(PENDING_EVENTS)
|
|
.find_upcoming(very_very_later)
|
|
.is_empty()); // one upcomming event
|
|
assert_eq!(gimme!(ONGOING_EVENTS).find_old(very_very_later), vec![id]); // one old event
|
|
assert!(gimme!(ONGOING_EVENTS)
|
|
.find_autoclose(very_very_later)
|
|
.is_empty()); // no old events
|
|
gimme!(PENDING_EVENTS)
|
|
.process_upcoming(very_very_later)
|
|
.unwrap(); // no event should be processed
|
|
gimme!(ONGOING_EVENTS).prune_old(very_very_later).unwrap(); // nothing should be processed
|
|
gimme!(ONGOING_EVENTS).autoclose(very_very_later).unwrap(); // nothing should be processed
|
|
assert!(!gimme!(PENDING_EVENTS).pending_events.contains_key(&id)); // it's not here anymore
|
|
assert!(!gimme!(ONGOING_EVENTS).ongoing_events.contains_key(&id)); // it was processed
|
|
|
|
// TODO: Check the status at several points
|
|
}
|
|
|
|
// #[test]
|
|
// #[ignore]
|
|
// fn test_ongoing_events() {
|
|
// unimplemented!()
|
|
// }
|
|
}
|