Improve testkit for faking random result

Author: DogLooksGood

api/src/effect.rs

@@ -498,7 +498,7 @@ impl Effect {
         Ok(())
     }
 
-    /// List the sub games to launch, deserialize the , 
+    /// List the sub games to launch with their init account data.
     pub fn list_sub_game_data<D: BorshDeserialize>(&self) -> HandleResult<Vec<D>> {
         self.launch_sub_games.iter().map(|sub_game| {
             let data = D::try_from_slice(&sub_game.init_account.data)?;

core/src/context.rs

@@ -590,6 +590,12 @@ impl GameContext {
         &self.dispatch
     }
 
+    pub fn take_dispatch(&mut self) -> Option<DispatchEvent> {
+        let mut dispatch = None;
+        std::mem::swap(&mut dispatch, &mut self.dispatch);
+        dispatch
+    }
+
     pub fn cancel_dispatch(&mut self) {
         self.dispatch = None;
     }

examples/raffle/src/lib.rs

@@ -40,7 +40,7 @@ struct Player {
     /// The deposit, since the ticket is fixed in this game
     /// Every player has the same `balance`.
     pub balance: u64,
-    /// Wether this player is eligible for raffle.
+    /// whether this player is eligible for raffle.
     pub status: PlayerStatus,
 }
 
@@ -224,6 +224,7 @@ impl Raffle {
 
 #[cfg(test)]
 mod tests {
+    use std::collections::HashMap;
     use race_test::prelude::*;
     use super::*;
 
@@ -250,15 +251,21 @@ mod tests {
         // After enough players joined, we expect there's a waiting timeout event being dispatched
         assert_eq!(dispatch, Some(DispatchEvent::new(Event::WaitingTimeout, DRAW_TIMEOUT)));
 
-        ctx.handle_dispatch_until_no_events(vec![&mut alice, &mut bob, &mut tx])?;
+        // We handle the dispatched event and all events after it, stop right before the SecretsReady
+        let (secrets_ready, _) = ctx.handle_dispatch_until(vec![&mut alice, &mut bob, &mut tx], |e| matches!(e, Some(&Event::SecretsReady {..})))?;
 
+        let random_id = ctx.state().random_id;
+
+        // Before process the dispatching events, we set a faked random result
+        // We select bob as the winner.
+        ctx.set_random_result(random_id, HashMap::from([(0, alice.id().to_string())]));
+
+        ctx.handle_event_until_no_events(&secrets_ready.unwrap(), vec![&mut alice, &mut bob, &mut tx])?;
         {
             let state = ctx.state();
-
-            assert!(state.winner_player_id.is_some());
+            assert_eq!(state.winner_player_id, Some(alice.id()));
         }
 
-
         Ok(())
     }
 }

test/src/context_helpers.rs

@@ -46,32 +46,96 @@ impl<H: GameHandler> TestContext<H> {
         (Event::Join { players }, Event::Deposit{ deposits })
     }
 
+    /// Handle one event and return the effects.
     pub fn handle_event(&mut self, event: &Event) -> Result<EventEffects> {
         self.handler.handle_event(&mut self.context, event)
     }
 
-    pub fn handle_multiple_events(&mut self, events: &[Event]) -> Result<EventEffects> {
-        let mut e = EventEffects::default();
-        for event in events {
-            e = self.handle_event(event)?;
+    /// Handle one event and all events generated after it, until the next event satisfies
+    /// the prediction.  Return the next event and the last effects.
+    pub fn handle_event_until(
+        &mut self,
+        event: &Event,
+        mut clients: Vec<&mut TestClient>,
+        event_pred: impl for<'a> Fn(Option<&'a Event>) -> bool,
+    ) -> Result<(Option<Event>, EventEffects)> {
+        let mut events_queue = vec![event.clone()];
+        let mut effects = EventEffects::default();
+
+        while !event_pred(events_queue.first()) {
+            let this_event = &events_queue.remove(0);
+            println!("* Handle event: {}", this_event);
+
+            effects = self.handler.handle_event(&mut self.context, this_event)?;
+
+            // Handle the following dispatched event and clients events.
+            if let Some(dispatch) = self.take_dispatch() {
+                if dispatch.timeout == self.context.get_timestamp() {
+                    events_queue.push(dispatch.event);
+                }
+            }
+
+            // Handle the following clients event.
+            for client in clients.iter_mut() {
+                let client_events = client.handle_updated_context(&mut self.context)?;
+                events_queue.extend_from_slice(&client_events);
+                if effects.checkpoint.is_some() {
+                    client.flush_secret_state();
+                }
+            }
         }
-        Ok(e)
+
+        let next_event = if events_queue.is_empty() {
+            None
+        } else {
+            Some(events_queue.remove(0))
+        };
+        Ok((next_event, effects))
     }
 
-    pub fn handle_dispatch_event(&mut self) -> Result<EventEffects> {
-        self.handler.handle_dispatch_event(&mut self.context)
+    /// Handle one event and all events generated after it, until there's no more event.
+    /// Return the last effects.
+    pub fn handle_event_until_no_events(
+        &mut self,
+        event: &Event,
+        clients: Vec<&mut TestClient>,
+    ) -> Result<EventEffects> {
+        let (_, effects) = self.handle_event_until(&event, clients, |e|{ e.is_none() })?;
+        Ok(effects)
     }
 
-    pub fn handle_until_no_events(&mut self, clients: Vec<&mut TestClient>) -> Result<EventEffects> {
-        self.handler.handle_until_no_events(&mut self.context, clients)
+    /// Like `handle_event` but pass in the current dispatched event.
+    pub fn handle_dispatch(&mut self) -> Result<EventEffects> {
+        let event = &self.take_dispatch().expect("No dispatch event").event;
+        self.handle_event(event)
     }
 
+    /// Like `handle_event_until_no_events` but start with the current dispatched event.
     pub fn handle_dispatch_until_no_events(
         &mut self,
         clients: Vec<&mut TestClient>,
     ) -> Result<EventEffects> {
-        self.handler
-            .handle_dispatch_until_no_events(&mut self.context, clients)
+        let event = &self.take_dispatch().expect("No dispatch event").event;
+        self.handle_event_until_no_events(event, clients)
+    }
+
+    /// Like `handle_event_until` but start with the current dispatched event.
+    pub fn handle_dispatch_until(
+        &mut self,
+        clients: Vec<&mut TestClient>,
+        event_pred: impl for<'a> Fn(Option<&'a Event>) -> bool,
+    ) -> Result<(Option<Event>, EventEffects)> {
+        let event = &self.take_dispatch().expect("No dispatch event").event;
+        self.handle_event_until(event, clients, event_pred)
+    }
+
+    /// Handle multiple events and return the effects of the last event.
+    pub fn handle_multiple_events(&mut self, events: &[Event]) -> Result<EventEffects> {
+        let mut e = EventEffects::default();
+        for event in events {
+            e = self.handle_event(event)?;
+        }
+        Ok(e)
     }
 
     pub fn init_account(&self) -> Result<InitAccount> {
@@ -94,6 +158,14 @@ impl<H: GameHandler> TestContext<H> {
         self.context.get_random_state_mut(random_id)
     }
 
+    pub fn set_random_result(&mut self, random_id: usize, result: HashMap<usize, String>) {
+        self.handler.set_random_result(random_id, result);
+    }
+
+    pub fn take_dispatch(&mut self) -> Option<DispatchEvent> {
+        self.context.take_dispatch()
+    }
+
     pub fn current_dispatch(&self) -> Option<DispatchEvent> {
         self.context.get_dispatch().clone()
     }

test/src/handler_helpers.rs

@@ -1,14 +1,14 @@
 use std::mem::swap;
+use std::collections::HashMap;
 
 use race_api::engine::GameHandler;
 use race_api::event::Event;
+use race_api::types::RandomId;
 use race_core::context::{EventEffects, GameContext};
 use race_core::engine::general_handle_event;
 use race_core::error::Result;
 use race_encryptor::Encryptor;
 
-use crate::client_helpers::TestClient;
-
 // Some event has special handling in event loop.
 fn patch_handle_event_effects(context: &mut GameContext, event_effects: &EventEffects) {
     if event_effects.start_game {
@@ -23,6 +23,7 @@ where
     H: GameHandler,
 {
     handler: H,
+    random_results: HashMap<RandomId, HashMap<usize, String>>,
 }
 
 impl<H: GameHandler> TestHandler<H> {
@@ -32,9 +33,10 @@ impl<H: GameHandler> TestHandler<H> {
         let mut effect = new_context.derive_effect(true);
         let handler = H::init_state(&mut effect, init_account)?;
         let event_effects = new_context.apply_effect(effect)?;
+        let random_results = HashMap::default();
         patch_handle_event_effects(&mut new_context, &event_effects);
         swap(context, &mut new_context);
-        Ok((Self { handler }, event_effects))
+        Ok((Self { handler, random_results }, event_effects))
     }
 
     pub fn handle_event(
@@ -46,125 +48,19 @@ impl<H: GameHandler> TestHandler<H> {
         let encryptor = Encryptor::default();
         general_handle_event(&mut new_context, event, &encryptor)?;
         let mut effect = new_context.derive_effect(false);
+        // patch the fake random result if we have
+        if !self.random_results.is_empty() {
+            effect.revealed = self.random_results.clone();
+        }
         self.handler.handle_event(&mut effect, event.to_owned())?;
         let event_effects = new_context.apply_effect(effect)?;
         patch_handle_event_effects(&mut new_context, &event_effects);
         swap(context, &mut new_context);
         Ok(event_effects)
     }
 
-    /// Find the event which is going to be disptached in the context, then process it.
-    /// In real cases, the disptached event will be handled by an event loop.
-    /// We use this function to simulate such cases, since we don't have an event loop in tests.
-    pub fn handle_dispatch_event(&mut self, context: &mut GameContext) -> Result<EventEffects> {
-        let evt = context
-            .get_dispatch()
-            .as_ref()
-            .expect("No dispatch event")
-            .event
-            .clone();
-        context.cancel_dispatch();
-        println!("* Dispatch event: {}", evt);
-        self.handle_event(context, &evt)
-    }
-
-    pub fn handle_dispatch_until_no_events(
-        &mut self,
-        context: &mut GameContext,
-        clients: Vec<&mut TestClient>,
-    ) -> Result<EventEffects> {
-        let evt = context
-            .get_dispatch()
-            .as_ref()
-            .expect("No dispatch event")
-            .event
-            .clone();
-        context.cancel_dispatch();
-        println!("* Dispatch event: {}", evt);
-        self.handle_event_until_no_events(context, &evt, clients)
-    }
-
-    // Handle both client events and dispatch event, until there's no more.
-    pub fn handle_until_no_events(
-        &mut self,
-        context: &mut GameContext,
-        mut clients: Vec<&mut TestClient>,
-    ) -> Result<EventEffects> {
-        let mut evts: Vec<Event> = vec![];
-        let mut event_effects = EventEffects::default();
-
-        loop {
-            if let Some(ctx_evt) = context.get_dispatch() {
-                if ctx_evt.timeout == context.get_timestamp() {
-                    evts.push(ctx_evt.event.clone());
-                    context.cancel_dispatch();
-                }
-            }
-
-            for c in clients.iter_mut() {
-                let cli_evts = c.handle_updated_context(context)?;
-                evts.extend_from_slice(&cli_evts);
-                if event_effects.checkpoint.is_some() {
-                    c.flush_secret_state();
-                }
-            }
-
-            if let Some(evt) = evts.first() {
-                event_effects = self.handle_event(context, evt)?;
-                evts.remove(0);
-            } else {
-                break;
-            }
-        }
-        Ok(event_effects)
-    }
-
-    /// This fn keeps handling events of the following two types, until there is none:
-    /// 1. Event dispatched from within the (updated) context: context.dispatch
-    /// 2. Event dispatched by clients after they see the updated context
-    pub fn handle_event_until_no_events(
-        &mut self,
-        context: &mut GameContext,
-        event: &Event,
-        mut clients: Vec<&mut TestClient>,
-    ) -> Result<EventEffects> {
-        // 1. Process the `event'(arg) --> context updated
-        // 2. context may dispatch --> take care those with timeout == current timestamp
-        // 3. iter clients to syn with updated context --> a couple of events
-        // 4. handle these client/trans events
-        let mut evts: Vec<Event> = vec![event.clone()]; // keep handling events in this vec
-        let mut event_effects = EventEffects::default();
-
-        while !evts.is_empty() {
-            let evt = &evts[0];
-            println!("* Received event: {}", evt);
-
-            event_effects = self.handle_event(context, evt)?;
-            if evts.len() == 1 {
-                evts.clear();
-            } else {
-                evts = evts.iter().skip(1).map(|e| e.clone()).collect();
-            }
-            if let Some(ctx_evt) = context.get_dispatch() {
-                if ctx_evt.timeout == context.get_timestamp() {
-                    evts.push(ctx_evt.event.clone());
-                    context.cancel_dispatch();
-                }
-            }
-
-            for c in clients.iter_mut() {
-                let cli_evts = c.handle_updated_context(context)?;
-                evts.extend_from_slice(&cli_evts);
-                if event_effects.checkpoint.is_some() {
-                    c.flush_secret_state();
-                }
-            }
-
-            if let Some(dispatch) = context.get_dispatch() {
-                println!("* Context dispatch: {:?}", dispatch);
-            }
-        }
-        Ok(event_effects)
+    pub fn set_random_result(&mut self, random_id: RandomId, result: HashMap<usize, String>) {
+        self.random_results.insert(random_id, result);
     }
 
     pub fn state(&self) -> &H {