state-res: Move tests/utils.rs to src/test_utils.rs

crates/ruma-state-res/src/lib.rs

@@ -20,6 +20,8 @@ mod error;
 pub mod event_auth;
 pub mod room_version;
 mod state_event;
+#[doc(hidden)]
+pub mod test_utils;
 
 pub use error::{Error, Result};
 pub use event_auth::{auth_check, auth_types_for_event};

crates/ruma-state-res/src/test_utils.rs

@@ -1,7 +1,5 @@
-#![allow(dead_code)]
-
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, HashMap, HashSet},
     convert::{TryFrom, TryInto},
     sync::{
         atomic::{AtomicU64, Ordering::SeqCst},
@@ -10,7 +8,6 @@ use std::{
 };
 
 use js_int::uint;
-use maplit::{btreemap, hashset};
 use ruma_common::MilliSecondsSinceUnixEpoch;
 use ruma_events::{
     pdu::{EventHash, Pdu, RoomV3Pdu},
@@ -21,10 +18,10 @@ use ruma_events::{
     EventType,
 };
 use ruma_identifiers::{EventId, RoomId, RoomVersionId, UserId};
-use ruma_state_res::{self as state_res, auth_types_for_event, Error, Event, Result, StateMap};
 use serde_json::{json, Value as JsonValue};
 use tracing::info;
-use tracing_subscriber as tracer;
+
+use crate::{self as state_res, auth_types_for_event, Error, Event, Result, StateMap};
 
 pub use event::StateEvent;
 
@@ -54,7 +51,7 @@ pub fn do_check(
     // Create the DB of events that led up to this point
     // TODO maybe clean up some of these clones it is just tests but...
     for ev in init_events.values().chain(events) {
-        graph.insert(ev.event_id().clone(), hashset![]);
+        graph.insert(ev.event_id().clone(), HashSet::new());
         fake_event_map.insert(ev.event_id().clone(), ev.clone());
     }
 
@@ -280,6 +277,86 @@ impl<E: Event> TestStore<E> {
     }
 }
 
+// A StateStore implementation for testing
+impl TestStore<StateEvent> {
+    pub fn set_up(&mut self) -> (StateMap<EventId>, StateMap<EventId>, StateMap<EventId>) {
+        let create_event = to_pdu_event::<EventId>(
+            "CREATE",
+            alice(),
+            EventType::RoomCreate,
+            Some(""),
+            json!({ "creator": alice() }),
+            &[],
+            &[],
+        );
+        let cre = create_event.event_id().clone();
+        self.0.insert(cre.clone(), Arc::clone(&create_event));
+
+        let alice_mem = to_pdu_event(
+            "IMA",
+            alice(),
+            EventType::RoomMember,
+            Some(alice().to_string().as_str()),
+            member_content_join(),
+            &[cre.clone()],
+            &[cre.clone()],
+        );
+        self.0.insert(alice_mem.event_id().clone(), Arc::clone(&alice_mem));
+
+        let join_rules = to_pdu_event(
+            "IJR",
+            alice(),
+            EventType::RoomJoinRules,
+            Some(""),
+            json!({ "join_rule": JoinRule::Public }),
+            &[cre.clone(), alice_mem.event_id().clone()],
+            &[alice_mem.event_id().clone()],
+        );
+        self.0.insert(join_rules.event_id().clone(), join_rules.clone());
+
+        // Bob and Charlie join at the same time, so there is a fork
+        // this will be represented in the state_sets when we resolve
+        let bob_mem = to_pdu_event(
+            "IMB",
+            bob(),
+            EventType::RoomMember,
+            Some(bob().to_string().as_str()),
+            member_content_join(),
+            &[cre.clone(), join_rules.event_id().clone()],
+            &[join_rules.event_id().clone()],
+        );
+        self.0.insert(bob_mem.event_id().clone(), bob_mem.clone());
+
+        let charlie_mem = to_pdu_event(
+            "IMC",
+            charlie(),
+            EventType::RoomMember,
+            Some(charlie().to_string().as_str()),
+            member_content_join(),
+            &[cre, join_rules.event_id().clone()],
+            &[join_rules.event_id().clone()],
+        );
+        self.0.insert(charlie_mem.event_id().clone(), charlie_mem.clone());
+
+        let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem]
+            .iter()
+            .map(|e| ((e.event_type(), e.state_key()), e.event_id().clone()))
+            .collect::<StateMap<_>>();
+
+        let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem]
+            .iter()
+            .map(|e| ((e.event_type(), e.state_key()), e.event_id().clone()))
+            .collect::<StateMap<_>>();
+
+        let expected = [&create_event, &alice_mem, &join_rules, &bob_mem, &charlie_mem]
+            .iter()
+            .map(|e| ((e.event_type(), e.state_key()), e.event_id().clone()))
+            .collect::<StateMap<_>>();
+
+        (state_at_bob, state_at_charlie, expected)
+    }
+}
+
 pub fn event_id(id: &str) -> EventId {
     if id.contains('$') {
         return EventId::try_from(id).unwrap();
@@ -336,14 +413,14 @@ pub fn to_init_pdu_event(
             kind: ev_type,
             content,
             redacts: None,
-            unsigned: btreemap! {},
+            unsigned: BTreeMap::new(),
             #[cfg(not(feature = "unstable-pre-spec"))]
             origin: "foo".into(),
             auth_events: vec![],
             prev_events: vec![],
             depth: uint!(0),
             hashes: EventHash::new("".to_owned()),
-            signatures: btreemap! {},
+            signatures: BTreeMap::new(),
         }),
     })
 }
@@ -376,14 +453,14 @@ where
             kind: ev_type,
             content,
             redacts: None,
-            unsigned: btreemap! {},
+            unsigned: BTreeMap::new(),
             #[cfg(not(feature = "unstable-pre-spec"))]
             origin: "foo".into(),
             auth_events,
             prev_events,
             depth: uint!(0),
             hashes: EventHash::new("".to_owned()),
-            signatures: btreemap! {},
+            signatures: BTreeMap::new(),
         }),
     })
 }
@@ -391,10 +468,6 @@ where
 // all graphs start with these input events
 #[allow(non_snake_case)]
 pub fn INITIAL_EVENTS() -> HashMap<EventId, Arc<StateEvent>> {
-    // this is always called so we can init the logger here
-    let _ = LOGGER
-        .call_once(|| tracer::fmt().with_env_filter(tracer::EnvFilter::from_default_env()).init());
-
     vec![
         to_pdu_event::<EventId>(
             "CREATE",
@@ -496,10 +569,11 @@ pub mod event {
         EventId, RoomId, RoomVersionId, ServerName, ServerSigningKeyId, UserId,
     };
     use ruma_serde::CanonicalJsonObject;
-    use ruma_state_res::Event;
     use serde::{Deserialize, Serialize};
     use serde_json::Value as JsonValue;
 
+    use crate::Event;
+
     impl Event for StateEvent {
         fn event_id(&self) -> &EventId {
             self.event_id()
@@ -715,7 +789,7 @@ pub mod event {
             &self,
         ) -> BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, String>> {
             match &self.rest {
-                Pdu::RoomV1Pdu(_) => maplit::btreemap! {},
+                Pdu::RoomV1Pdu(_) => BTreeMap::new(),
                 Pdu::RoomV3Pdu(ev) => ev.signatures.clone(),
                 #[cfg(not(feature = "unstable-exhaustive-types"))]
                 _ => unreachable!("new PDU version"),

crates/ruma-state-res/tests/event_auth.rs

@@ -1,13 +1,15 @@
 use std::sync::Arc;
 
 use ruma_events::EventType;
-use ruma_state_res::{event_auth::valid_membership_change, StateMap};
+use ruma_state_res::{
-
+    event_auth::valid_membership_change,
-mod utils;
+    test_utils::{alice, charlie, event_id, member_content_ban, to_pdu_event, INITIAL_EVENTS},
-use utils::{alice, charlie, event_id, member_content_ban, to_pdu_event, INITIAL_EVENTS};
+    StateMap,
+};
 
 #[test]
 fn test_ban_pass() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
     let events = INITIAL_EVENTS();
 
     let prev = events.values().find(|ev| ev.event_id().as_str().contains("IMC")).map(Arc::clone);
@@ -40,6 +42,7 @@ fn test_ban_pass() {
 
 #[test]
 fn test_ban_fail() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
     let events = INITIAL_EVENTS();
 
     let prev = events.values().find(|ev| ev.event_id().as_str().contains("IMC")).map(Arc::clone);

crates/ruma-state-res/tests/event_sorting.rs

@@ -5,12 +5,13 @@ use std::{
 
 use rand::seq::SliceRandom;
 use ruma_events::EventType;
-use ruma_state_res::{self as state_res, is_power_event, room_version::RoomVersion, StateMap};
+use ruma_state_res::{
-
+    self as state_res, is_power_event, room_version::RoomVersion, test_utils::INITIAL_EVENTS,
-mod utils;
+    StateMap,
-use utils::INITIAL_EVENTS;
+};
 
 fn test_event_sort() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
     let events = INITIAL_EVENTS();
 
     let event_map = events

crates/ruma-state-res/tests/res_with_auth_ids.rs

@@ -4,18 +4,20 @@ use std::{collections::HashMap, sync::Arc};
 
 use ruma_events::EventType;
 use ruma_identifiers::{EventId, RoomVersionId};
-use ruma_state_res::{self as state_res, EventMap, StateMap};
+use ruma_state_res::{
+    self as state_res,
+    test_utils::{
+        alice, bob, do_check, ella, event_id, member_content_ban, member_content_join, room_id,
+        to_pdu_event, zara, StateEvent, TestStore, INITIAL_EVENTS,
+    },
+    EventMap, StateMap,
+};
 use serde_json::json;
 use tracing::debug;
 
-mod utils;
-use utils::{
-    alice, bob, do_check, ella, event_id, member_content_ban, member_content_join, room_id,
-    to_pdu_event, zara, StateEvent, TestStore, INITIAL_EVENTS,
-};
-
 #[test]
 fn ban_with_auth_chains() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
     let ban = BAN_STATE_SET();
 
     let edges = vec![vec!["END", "MB", "PA", "START"], vec!["END", "IME", "MB"]]
@@ -30,6 +32,7 @@ fn ban_with_auth_chains() {
 
 #[test]
 fn ban_with_auth_chains2() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
     let init = INITIAL_EVENTS();
     let ban = BAN_STATE_SET();
 

crates/ruma-state-res/tests/state_res.rs

@@ -4,19 +4,21 @@ use js_int::uint;
 use maplit::{hashmap, hashset};
 use ruma_common::MilliSecondsSinceUnixEpoch;
 use ruma_events::{room::join_rules::JoinRule, EventType};
-use ruma_identifiers::{EventId, RoomVersionId};
+use ruma_identifiers::RoomVersionId;
-use ruma_state_res::{self as state_res, EventMap, StateMap};
+use ruma_state_res::{
-use serde_json::json;
+    self as state_res,
-use tracing_subscriber as tracer;
+    test_utils::{
-
-mod utils;
-use utils::{
         alice, bob, charlie, do_check, ella, event_id, member_content_ban, member_content_join,
-    room_id, to_init_pdu_event, to_pdu_event, zara, StateEvent, TestStore, LOGGER,
+        room_id, to_init_pdu_event, zara, StateEvent, TestStore,
+    },
+    EventMap,
 };
+use serde_json::json;
 
 #[test]
 fn ban_vs_power_level() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let events = &[
         to_init_pdu_event(
             "PA",
@@ -60,6 +62,8 @@ fn ban_vs_power_level() {
 
 #[test]
 fn topic_basic() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let events = &[
         to_init_pdu_event("T1", alice(), EventType::RoomTopic, Some(""), json!({})),
         to_init_pdu_event(
@@ -100,6 +104,8 @@ fn topic_basic() {
 
 #[test]
 fn topic_reset() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let events = &[
         to_init_pdu_event("T1", alice(), EventType::RoomTopic, Some(""), json!({})),
         to_init_pdu_event(
@@ -131,6 +137,8 @@ fn topic_reset() {
 
 #[test]
 fn join_rule_evasion() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let events = &[
         to_init_pdu_event(
             "JR",
@@ -160,6 +168,8 @@ fn join_rule_evasion() {
 
 #[test]
 fn offtopic_power_level() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let events = &[
         to_init_pdu_event(
             "PA",
@@ -196,6 +206,8 @@ fn offtopic_power_level() {
 
 #[test]
 fn topic_setting() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let events = &[
         to_init_pdu_event("T1", alice(), EventType::RoomTopic, Some(""), json!({})),
         to_init_pdu_event(
@@ -240,12 +252,7 @@ fn topic_setting() {
 
 #[test]
 fn test_event_map_none() {
-    // This is the only test that does not use `do_check` so we
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
-    // have to start the logger if this is what we're running.
-    //
-    // to activate logging use `RUST_LOG=debug cargo t one_test_only`
-    let _ = LOGGER
-        .call_once(|| tracer::fmt().with_env_filter(tracer::EnvFilter::from_default_env()).init());
 
     let mut store = TestStore::<StateEvent>(hashmap! {});
 
@@ -277,6 +284,8 @@ fn test_event_map_none() {
 
 #[test]
 fn test_lexicographical_sort() {
+    let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
+
     let graph = hashmap! {
         event_id("l") => hashset![event_id("o")],
         event_id("m") => hashset![event_id("n"), event_id("o")],
@@ -298,85 +307,3 @@ fn test_lexicographical_sort() {
             .collect::<Vec<_>>()
     )
 }
-
-// A StateStore implementation for testing
-//
-//
-impl TestStore<StateEvent> {
-    pub fn set_up(&mut self) -> (StateMap<EventId>, StateMap<EventId>, StateMap<EventId>) {
-        let create_event = to_pdu_event::<EventId>(
-            "CREATE",
-            alice(),
-            EventType::RoomCreate,
-            Some(""),
-            json!({ "creator": alice() }),
-            &[],
-            &[],
-        );
-        let cre = create_event.event_id().clone();
-        self.0.insert(cre.clone(), Arc::clone(&create_event));
-
-        let alice_mem = to_pdu_event(
-            "IMA",
-            alice(),
-            EventType::RoomMember,
-            Some(alice().to_string().as_str()),
-            member_content_join(),
-            &[cre.clone()],
-            &[cre.clone()],
-        );
-        self.0.insert(alice_mem.event_id().clone(), Arc::clone(&alice_mem));
-
-        let join_rules = to_pdu_event(
-            "IJR",
-            alice(),
-            EventType::RoomJoinRules,
-            Some(""),
-            json!({ "join_rule": JoinRule::Public }),
-            &[cre.clone(), alice_mem.event_id().clone()],
-            &[alice_mem.event_id().clone()],
-        );
-        self.0.insert(join_rules.event_id().clone(), join_rules.clone());
-
-        // Bob and Charlie join at the same time, so there is a fork
-        // this will be represented in the state_sets when we resolve
-        let bob_mem = to_pdu_event(
-            "IMB",
-            bob(),
-            EventType::RoomMember,
-            Some(bob().to_string().as_str()),
-            member_content_join(),
-            &[cre.clone(), join_rules.event_id().clone()],
-            &[join_rules.event_id().clone()],
-        );
-        self.0.insert(bob_mem.event_id().clone(), bob_mem.clone());
-
-        let charlie_mem = to_pdu_event(
-            "IMC",
-            charlie(),
-            EventType::RoomMember,
-            Some(charlie().to_string().as_str()),
-            member_content_join(),
-            &[cre, join_rules.event_id().clone()],
-            &[join_rules.event_id().clone()],
-        );
-        self.0.insert(charlie_mem.event_id().clone(), charlie_mem.clone());
-
-        let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem]
-            .iter()
-            .map(|e| ((e.event_type(), e.state_key()), e.event_id().clone()))
-            .collect::<StateMap<_>>();
-
-        let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem]
-            .iter()
-            .map(|e| ((e.event_type(), e.state_key()), e.event_id().clone()))
-            .collect::<StateMap<_>>();
-
-        let expected = [&create_event, &alice_mem, &join_rules, &bob_mem, &charlie_mem]
-            .iter()
-            .map(|e| ((e.event_type(), e.state_key()), e.event_id().clone()))
-            .collect::<StateMap<_>>();
-
-        (state_at_bob, state_at_charlie, expected)
-    }
-}