chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Jonas Platte 2021-09-03 22:08:33 +02:00
parent 6b1f027b88
commit 0a93780e83
No known key found for this signature in database
GPG Key ID: CC154DE0E30B7C67
6 changed files with 139 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
crates/ruma-state-res/src/lib.rs
View File

@ -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};

108
crates/ruma-state-res/tests/utils.rs → crates/ruma-state-res/src/test_utils.rs
View File

@ -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"),

11
crates/ruma-state-res/tests/event_auth.rs
View File

@ -1,13 +1,15 @@
use std::sync::Arc;
use ruma_events::EventType;
use ruma_state_res::{event_auth::valid_membership_change, StateMap};
mod utils;
use utils::{alice, charlie, event_id, member_content_ban, to_pdu_event, INITIAL_EVENTS};
use ruma_state_res::{
event_auth::valid_membership_change,
test_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);

9
crates/ruma-state-res/tests/event_sorting.rs
View File

@ -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};
mod utils;
use utils::INITIAL_EVENTS;
use ruma_state_res::{
self as state_res, is_power_event, room_version::RoomVersion, test_utils::INITIAL_EVENTS,
StateMap,
};
fn test_event_sort() {
let _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
let events = INITIAL_EVENTS();
let event_map = events

17
crates/ruma-state-res/tests/res_with_auth_ids.rs
View File

@ -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();

121
crates/ruma-state-res/tests/state_res.rs
View File

@ -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_state_res::{self as state_res, EventMap, StateMap};
use serde_json::json;
use tracing_subscriber as tracer;
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,
use ruma_identifiers::RoomVersionId;
use ruma_state_res::{
self as state_res,
test_utils::{
alice, bob, charlie, do_check, ella, event_id, member_content_ban, member_content_join,
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
// 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 _ = tracing::subscriber::set_default(tracing_subscriber::fmt().with_test_writer().finish());
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)
}
}