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

Update ruma depricated and use Option<String> for state_key

Browse Source
This commit is contained in:
Devin Ragotzy 2020-08-11 23:40:22 -04:00
parent 9a388fc813
commit 1509ef45c1
7 changed files with 75 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
benches/state_res_bench.rs
View File

@ -57,7 +57,7 @@ fn resolution_shallow_auth_chain(c: &mut Criterion) {
b.iter(|| { b.iter(|| {
let _resolved = match resolver.resolve( let _resolved = match resolver.resolve(
&room_id(), &room_id(),
&RoomVersionId::version_2(), &RoomVersionId::Version2,
&[state_at_bob.clone(), state_at_charlie.clone()], &[state_at_bob.clone(), state_at_charlie.clone()],
None, None,
&store, &store,
@ -91,13 +91,8 @@ fn resolve_deeper_event_set(c: &mut Criterion) {
inner.get(&event_id("PA")).unwrap(), inner.get(&event_id("PA")).unwrap(),
] ]
.iter() .iter()
.map(|ev| { .map(|ev| ((ev.kind(), ev.state_key()), ev.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(ev.kind(), ev.state_key().unwrap()),
ev.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
let state_set_b = [ let state_set_b = [
inner.get(&event_id("CREATE")).unwrap(), inner.get(&event_id("CREATE")).unwrap(),
@ -109,18 +104,13 @@ fn resolve_deeper_event_set(c: &mut Criterion) {
inner.get(&event_id("PA")).unwrap(), inner.get(&event_id("PA")).unwrap(),
] ]
.iter() .iter()
.map(|ev| { .map(|ev| ((ev.kind(), ev.state_key()), ev.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(ev.kind(), ev.state_key().unwrap()),
ev.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
b.iter(|| { b.iter(|| {
let _resolved = match resolver.resolve( let _resolved = match resolver.resolve(
&room_id(), &room_id(),
&RoomVersionId::version_2(), &RoomVersionId::Version2,
&[state_set_a.clone(), state_set_b.clone()], &[state_set_a.clone(), state_set_b.clone()],
Some(inner.clone()), Some(inner.clone()),
&store, &store,
@ -302,23 +292,13 @@ impl TestStore {
let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem] let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem]
.iter() .iter()
.map(|e| { .map(|e| ((e.kind(), e.state_key()), e.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(e.kind(), e.state_key().unwrap()),
e.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem] let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem]
.iter() .iter()
.map(|e| { .map(|e| ((e.kind(), e.state_key()), e.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(e.kind(), e.state_key().unwrap()),
e.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
let expected = [ let expected = [
&create_event, &create_event,
@ -328,13 +308,8 @@ impl TestStore {
&charlie_mem, &charlie_mem,
] ]
.iter() .iter()
.map(|e| { .map(|e| ((e.kind(), e.state_key()), e.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(e.kind(), e.state_key().unwrap()),
e.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
(state_at_bob, state_at_charlie, expected) (state_at_bob, state_at_charlie, expected)
} }

40
src/event_auth.rs
View File

@ -22,35 +22,35 @@ pub enum RedactAllowed {
No, No,
} }
pub fn auth_types_for_event(event: &StateEvent) -> Vec<(EventType, String)> { pub fn auth_types_for_event(event: &StateEvent) -> Vec<(EventType, Option<String>)> {
if event.kind() == EventType::RoomCreate { if event.kind() == EventType::RoomCreate {
return vec![]; return vec![];
} }
let mut auth_types = vec![ let mut auth_types = vec![
(EventType::RoomPowerLevels, "".to_string()), (EventType::RoomPowerLevels, Some("".to_string())),
(EventType::RoomMember, event.sender().to_string()), (EventType::RoomMember, Some(event.sender().to_string())),
(EventType::RoomCreate, "".to_string()), (EventType::RoomCreate, Some("".to_string())),
]; ];
if event.kind() == EventType::RoomMember { if event.kind() == EventType::RoomMember {
if let Ok(content) = event.deserialize_content::<room::member::MemberEventContent>() { if let Ok(content) = event.deserialize_content::<room::member::MemberEventContent>() {
if [MembershipState::Join, MembershipState::Invite].contains(&content.membership) { if [MembershipState::Join, MembershipState::Invite].contains(&content.membership) {
let key = (EventType::RoomJoinRules, "".into()); let key = (EventType::RoomJoinRules, Some("".into()));
if !auth_types.contains(&key) { if !auth_types.contains(&key) {
auth_types.push(key) auth_types.push(key)
} }
} }
// TODO what when we don't find a state_key // TODO what when we don't find a state_key
let key = (EventType::RoomMember, event.state_key().unwrap()); let key = (EventType::RoomMember, event.state_key());
if !auth_types.contains(&key) { if !auth_types.contains(&key) {
auth_types.push(key) auth_types.push(key)
} }
if content.membership == MembershipState::Invite { if content.membership == MembershipState::Invite {
if let Some(t_id) = content.third_party_invite { if let Some(t_id) = content.third_party_invite {
let key = (EventType::RoomThirdPartyInvite, t_id.signed.token); let key = (EventType::RoomThirdPartyInvite, Some(t_id.signed.token));
if !auth_types.contains(&key) { if !auth_types.contains(&key) {
auth_types.push(key) auth_types.push(key)
} }
@ -137,7 +137,7 @@ pub fn auth_check(
// 3. If event does not have m.room.create in auth_events reject. // 3. If event does not have m.room.create in auth_events reject.
if auth_events if auth_events
.get(&(EventType::RoomCreate, "".into())) .get(&(EventType::RoomCreate, Some("".into())))
.is_none() .is_none()
{ {
tracing::warn!("no m.room.create event in auth chain"); tracing::warn!("no m.room.create event in auth chain");
@ -238,7 +238,7 @@ pub fn auth_check(
// synapse has an `event: &StateEvent` param but it's never used // synapse has an `event: &StateEvent` param but it's never used
/// Can this room federate based on its m.room.create event. /// Can this room federate based on its m.room.create event.
fn can_federate(auth_events: &StateMap<StateEvent>) -> bool { fn can_federate(auth_events: &StateMap<StateEvent>) -> bool {
let creation_event = auth_events.get(&(EventType::RoomCreate, "".into())); let creation_event = auth_events.get(&(EventType::RoomCreate, Some("".into())));
if let Some(ev) = creation_event { if let Some(ev) = creation_event {
if let Some(fed) = ev.content().get("m.federate") { if let Some(fed) = ev.content().get("m.federate") {
fed == "true" fed == "true"
@ -263,7 +263,7 @@ fn is_membership_change_allowed(
// check if this is the room creator joining // check if this is the room creator joining
if event.prev_event_ids().len() == 1 && membership == MembershipState::Join { if event.prev_event_ids().len() == 1 && membership == MembershipState::Join {
if let Some(create) = auth_events.get(&(EventType::RoomCreate, "".into())) { if let Some(create) = auth_events.get(&(EventType::RoomCreate, Some("".into()))) {
if let Ok(create_ev) = create.deserialize_content::<room::create::CreateEventContent>() if let Ok(create_ev) = create.deserialize_content::<room::create::CreateEventContent>()
{ {
if event.state_key() == Some(create_ev.creator.to_string()) { if event.state_key() == Some(create_ev.creator.to_string()) {
@ -283,19 +283,19 @@ fn is_membership_change_allowed(
return Some(false); return Some(false);
} }
let key = (EventType::RoomMember, event.sender().to_string()); let key = (EventType::RoomMember, Some(event.sender().to_string()));
let caller = auth_events.get(&key); let caller = auth_events.get(&key);
let caller_in_room = caller.is_some() && check_membership(caller, MembershipState::Join); let caller_in_room = caller.is_some() && check_membership(caller, MembershipState::Join);
let caller_invited = caller.is_some() && check_membership(caller, MembershipState::Invite); let caller_invited = caller.is_some() && check_membership(caller, MembershipState::Invite);
let key = (EventType::RoomMember, target_user_id.to_string()); let key = (EventType::RoomMember, Some(target_user_id.to_string()));
let target = auth_events.get(&key); let target = auth_events.get(&key);
let target_in_room = target.is_some() && check_membership(target, MembershipState::Join); let target_in_room = target.is_some() && check_membership(target, MembershipState::Join);
let target_banned = target.is_some() && check_membership(target, MembershipState::Ban); let target_banned = target.is_some() && check_membership(target, MembershipState::Ban);
let key = (EventType::RoomJoinRules, "".to_string()); let key = (EventType::RoomJoinRules, Some("".to_string()));
let join_rules_event = auth_events.get(&key); let join_rules_event = auth_events.get(&key);
let mut join_rule = JoinRule::Invite; let mut join_rule = JoinRule::Invite;
@ -436,7 +436,7 @@ fn check_event_sender_in_room(
event: &StateEvent, event: &StateEvent,
auth_events: &StateMap<StateEvent>, auth_events: &StateMap<StateEvent>,
) -> Option<bool> { ) -> Option<bool> {
let mem = auth_events.get(&(EventType::RoomMember, event.sender().to_string()))?; let mem = auth_events.get(&(EventType::RoomMember, Some(event.sender().to_string())))?;
// TODO this is check_membership a helper fn in synapse but it does this // TODO this is check_membership a helper fn in synapse but it does this
Some( Some(
mem.deserialize_content::<room::member::MemberEventContent>() mem.deserialize_content::<room::member::MemberEventContent>()
@ -448,7 +448,7 @@ fn check_event_sender_in_room(
/// Is the user allowed to send a specific event. /// Is the user allowed to send a specific event.
fn can_send_event(event: &StateEvent, auth_events: &StateMap<StateEvent>) -> Option<bool> { fn can_send_event(event: &StateEvent, auth_events: &StateMap<StateEvent>) -> Option<bool> {
let ple = auth_events.get(&(EventType::RoomPowerLevels, "".into())); let ple = auth_events.get(&(EventType::RoomPowerLevels, Some("".into())));
let send_level = get_send_level(event.kind(), event.state_key(), ple); let send_level = get_send_level(event.kind(), event.state_key(), ple);
let user_level = get_user_power_level(event.sender(), auth_events); let user_level = get_user_power_level(event.sender(), auth_events);
@ -480,7 +480,7 @@ fn check_power_levels(
) -> Option<bool> { ) -> Option<bool> {
use itertools::Itertools; use itertools::Itertools;
let key = (power_event.kind(), power_event.state_key().unwrap()); let key = (power_event.kind(), power_event.state_key());
let current_state = if let Some(current_state) = auth_events.get(&key) { let current_state = if let Some(current_state) = auth_events.get(&key) {
current_state current_state
@ -629,7 +629,7 @@ fn check_redaction(
return Some(RedactAllowed::CanRedact); return Some(RedactAllowed::CanRedact);
} }
if room_version.is_version_1() { if let RoomVersionId::Version1 = room_version {
if redaction_event.event_id() == redaction_event.redacts() { if redaction_event.event_id() == redaction_event.redacts() {
return Some(RedactAllowed::OwnEvent); return Some(RedactAllowed::OwnEvent);
} }
@ -659,7 +659,7 @@ fn check_membership(member_event: Option<&StateEvent>, state: MembershipState) -
} }
fn get_named_level(auth_events: &StateMap<StateEvent>, name: &str, default: i64) -> i64 { fn get_named_level(auth_events: &StateMap<StateEvent>, name: &str, default: i64) -> i64 {
let power_level_event = auth_events.get(&(EventType::RoomPowerLevels, "".into())); let power_level_event = auth_events.get(&(EventType::RoomPowerLevels, Some("".into())));
if let Some(pl) = power_level_event { if let Some(pl) = power_level_event {
// TODO do this the right way and deserialize // TODO do this the right way and deserialize
if let Some(level) = pl.content().get(name) { if let Some(level) = pl.content().get(name) {
@ -673,7 +673,7 @@ fn get_named_level(auth_events: &StateMap<StateEvent>, name: &str, default: i64)
} }
fn get_user_power_level(user_id: &UserId, auth_events: &StateMap<StateEvent>) -> i64 { fn get_user_power_level(user_id: &UserId, auth_events: &StateMap<StateEvent>) -> i64 {
if let Some(pl) = auth_events.get(&(EventType::RoomPowerLevels, "".into())) { if let Some(pl) = auth_events.get(&(EventType::RoomPowerLevels, Some("".into()))) {
if let Ok(content) = pl.deserialize_content::<room::power_levels::PowerLevelsEventContent>() if let Ok(content) = pl.deserialize_content::<room::power_levels::PowerLevelsEventContent>()
{ {
if let Some(level) = content.users.get(user_id) { if let Some(level) = content.users.get(user_id) {
@ -686,7 +686,7 @@ fn get_user_power_level(user_id: &UserId, auth_events: &StateMap<StateEvent>) ->
} }
} else { } else {
// if no power level event found the creator gets 100 everyone else gets 0 // if no power level event found the creator gets 100 everyone else gets 0
let key = (EventType::RoomCreate, "".into()); let key = (EventType::RoomCreate, Some("".into()));
if let Some(create) = auth_events.get(&key) { if let Some(create) = auth_events.get(&key) {
if let Ok(c) = create.deserialize_content::<room::create::CreateEventContent>() { if let Ok(c) = create.deserialize_content::<room::create::CreateEventContent>() {
if &c.creator == user_id { if &c.creator == user_id {

8
src/lib.rs
View File

@ -34,7 +34,7 @@ pub enum ResolutionResult {
} }
/// A mapping of event type and state_key to some value `T`, usually an `EventId`. /// A mapping of event type and state_key to some value `T`, usually an `EventId`.
pub type StateMap<T> = BTreeMap<(EventType, String), T>; pub type StateMap<T> = BTreeMap<(EventType, Option<String>), T>;
/// A mapping of `EventId` to `T`, usually a `StateEvent`. /// A mapping of `EventId` to `T`, usually a `StateEvent`.
pub type EventMap<T> = BTreeMap<EventId, T>; pub type EventMap<T> = BTreeMap<EventId, T>;
@ -191,7 +191,7 @@ impl StateResolution {
.collect::<Vec<_>>() .collect::<Vec<_>>()
); );
let power_event = resolved.get(&(EventType::RoomPowerLevels, "".into())); let power_event = resolved.get(&(EventType::RoomPowerLevels, Some("".into())));
tracing::debug!("PL {:?}", power_event); tracing::debug!("PL {:?}", power_event);
@ -526,7 +526,7 @@ impl StateResolution {
if let Some(ev) = self._get_event(room_id, &aid, event_map, store) { if let Some(ev) = self._get_event(room_id, &aid, event_map, store) {
// TODO what to do when no state_key is found ?? // TODO what to do when no state_key is found ??
// TODO synapse check "rejected_reason", I'm guessing this is redacted_because for ruma ?? // TODO synapse check "rejected_reason", I'm guessing this is redacted_because for ruma ??
auth_events.insert((ev.kind(), ev.state_key().unwrap()), ev); auth_events.insert((ev.kind(), ev.state_key()), ev);
} else { } else {
tracing::warn!("auth event id for {} is missing {}", aid, event_id); tracing::warn!("auth event id for {} is missing {}", aid, event_id);
} }
@ -547,7 +547,7 @@ impl StateResolution {
.map_err(Error::TempString)? .map_err(Error::TempString)?
{ {
// add event to resolved state map // add event to resolved state map
resolved_state.insert((event.kind(), event.state_key().unwrap()), event_id.clone()); resolved_state.insert((event.kind(), event.state_key()), event_id.clone());
} else { } else {
// synapse passes here on AuthError. We do not add this event to resolved_state. // synapse passes here on AuthError. We do not add this event to resolved_state.
tracing::warn!( tracing::warn!(

34
src/room_version.rs
View File

@ -50,26 +50,20 @@ pub struct RoomVersion {
impl RoomVersion { impl RoomVersion {
pub fn new(version: &RoomVersionId) -> Self { pub fn new(version: &RoomVersionId) -> Self {
if version.is_version_1() { match version {
Self::version_1() RoomVersionId::Version1 => Self::version_1(),
} else if version.is_version_2() { RoomVersionId::Version2 => Self::version_2(),
Self::version_2() RoomVersionId::Version3 => Self::version_3(),
} else if version.is_version_3() { RoomVersionId::Version4 => Self::version_4(),
Self::version_3() RoomVersionId::Version5 => Self::version_5(),
} else if version.is_version_4() { RoomVersionId::Version6 => Self::version_6(),
Self::version_4() _ => panic!("unspec'ed room version"),
} else if version.is_version_5() {
Self::version_5()
} else if version.is_version_6() {
Self::version_6()
} else {
panic!("this crate needs to be updated with ruma")
} }
} }
fn version_1() -> Self { fn version_1() -> Self {
Self { Self {
version: RoomVersionId::version_1(), version: RoomVersionId::Version1,
disposition: RoomDisposition::Stable, disposition: RoomDisposition::Stable,
event_format: EventFormatVersion::V1, event_format: EventFormatVersion::V1,
state_res: StateResolutionVersion::V1, state_res: StateResolutionVersion::V1,
@ -82,7 +76,7 @@ impl RoomVersion {
fn version_2() -> Self { fn version_2() -> Self {
Self { Self {
version: RoomVersionId::version_2(), version: RoomVersionId::Version2,
disposition: RoomDisposition::Stable, disposition: RoomDisposition::Stable,
event_format: EventFormatVersion::V1, event_format: EventFormatVersion::V1,
state_res: StateResolutionVersion::V2, state_res: StateResolutionVersion::V2,
@ -95,7 +89,7 @@ impl RoomVersion {
fn version_3() -> Self { fn version_3() -> Self {
Self { Self {
version: RoomVersionId::version_3(), version: RoomVersionId::Version3,
disposition: RoomDisposition::Stable, disposition: RoomDisposition::Stable,
event_format: EventFormatVersion::V2, event_format: EventFormatVersion::V2,
state_res: StateResolutionVersion::V2, state_res: StateResolutionVersion::V2,
@ -108,7 +102,7 @@ impl RoomVersion {
fn version_4() -> Self { fn version_4() -> Self {
Self { Self {
version: RoomVersionId::version_4(), version: RoomVersionId::Version4,
disposition: RoomDisposition::Stable, disposition: RoomDisposition::Stable,
event_format: EventFormatVersion::V3, event_format: EventFormatVersion::V3,
state_res: StateResolutionVersion::V2, state_res: StateResolutionVersion::V2,
@ -121,7 +115,7 @@ impl RoomVersion {
fn version_5() -> Self { fn version_5() -> Self {
Self { Self {
version: RoomVersionId::version_5(), version: RoomVersionId::Version5,
disposition: RoomDisposition::Stable, disposition: RoomDisposition::Stable,
event_format: EventFormatVersion::V3, event_format: EventFormatVersion::V3,
state_res: StateResolutionVersion::V2, state_res: StateResolutionVersion::V2,
@ -134,7 +128,7 @@ impl RoomVersion {
fn version_6() -> Self { fn version_6() -> Self {
Self { Self {
version: RoomVersionId::version_6(), version: RoomVersionId::Version6,
disposition: RoomDisposition::Stable, disposition: RoomDisposition::Stable,
event_format: EventFormatVersion::V3, event_format: EventFormatVersion::V3,
state_res: StateResolutionVersion::V2, state_res: StateResolutionVersion::V2,

1
src/state_event.rs
View File

@ -101,6 +101,7 @@ impl StateEvent {
} }
} }
pub fn event_id(&self) -> Option<&EventId> { pub fn event_id(&self) -> Option<&EventId> {
println!("{:?}", self);
match self { match self {
Self::Full(ev) => match ev { Self::Full(ev) => match ev {
Pdu::RoomV1Pdu(ev) => Some(&ev.event_id), Pdu::RoomV1Pdu(ev) => Some(&ev.event_id),

34
tests/res_with_auth_ids.rs
View File

@ -102,14 +102,14 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
.iter() .iter()
.map(|map| map .map(|map| map
.iter() .iter()
.map(|((ty, key), id)| format!("(({}{}), {})", ty, key, id)) .map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
.collect::<Vec<_>>()) .collect::<Vec<_>>())
.collect::<Vec<_>>() .collect::<Vec<_>>()
); );
let resolved = resolver.resolve( let resolved = resolver.resolve(
&room_id(), &room_id(),
&RoomVersionId::version_1(), &RoomVersionId::Version1,
&state_sets, &state_sets,
Some(event_map.clone()), Some(event_map.clone()),
&store, &store,
@ -135,7 +135,7 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
if fake_event.state_key().is_some() { if fake_event.state_key().is_some() {
let ty = fake_event.kind().clone(); let ty = fake_event.kind().clone();
// we know there is a state_key unwrap OK // we know there is a state_key unwrap OK
let key = fake_event.state_key().unwrap().clone(); let key = fake_event.state_key().clone();
state_after.insert((ty, key), event_id.clone()); state_after.insert((ty, key), event_id.clone());
} }
@ -173,7 +173,7 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
event_map.insert(event_id.clone(), event); event_map.insert(event_id.clone(), event);
} }
let mut expected_state = BTreeMap::new(); let mut expected_state = StateMap::new();
for node in expected_state_ids { for node in expected_state_ids {
let ev = event_map.get(&node).expect(&format!( let ev = event_map.get(&node).expect(&format!(
"{} not found in {:?}", "{} not found in {:?}",
@ -184,7 +184,7 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
)); ));
let key = (ev.kind(), ev.state_key().unwrap()); let key = (ev.kind(), ev.state_key());
expected_state.insert(key, node); expected_state.insert(key, node);
} }
@ -573,7 +573,7 @@ fn base_with_auth_chains() {
let store = TestStore(RefCell::new(INITIAL_EVENTS())); let store = TestStore(RefCell::new(INITIAL_EVENTS()));
let resolved: BTreeMap<_, EventId> = let resolved: BTreeMap<_, EventId> =
match resolver.resolve(&room_id(), &RoomVersionId::version_2(), &[], None, &store) { match resolver.resolve(&room_id(), &RoomVersionId::Version2, &[], None, &store) {
Ok(ResolutionResult::Resolved(state)) => state, Ok(ResolutionResult::Resolved(state)) => state,
Err(e) => panic!("{}", e), Err(e) => panic!("{}", e),
_ => panic!("conflicted state left"), _ => panic!("conflicted state left"),
@ -627,12 +627,7 @@ fn ban_with_auth_chains2() {
inner.get(&event_id("PA")).unwrap(), inner.get(&event_id("PA")).unwrap(),
] ]
.iter() .iter()
.map(|ev| { .map(|ev| ((ev.kind(), ev.state_key()), ev.event_id().unwrap().clone()))
(
(ev.kind(), ev.state_key().unwrap()),
ev.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>(); .collect::<BTreeMap<_, _>>();
let state_set_b = [ let state_set_b = [
@ -645,17 +640,12 @@ fn ban_with_auth_chains2() {
inner.get(&event_id("PA")).unwrap(), inner.get(&event_id("PA")).unwrap(),
] ]
.iter() .iter()
.map(|ev| { .map(|ev| ((ev.kind(), ev.state_key()), ev.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(ev.kind(), ev.state_key().unwrap()),
ev.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
let resolved: BTreeMap<_, EventId> = match resolver.resolve( let resolved: StateMap<EventId> = match resolver.resolve(
&room_id(), &room_id(),
&RoomVersionId::version_2(), &RoomVersionId::Version2,
&[state_set_a, state_set_b], &[state_set_a, state_set_b],
None, None,
&store, &store,
@ -669,7 +659,7 @@ fn ban_with_auth_chains2() {
"{:#?}", "{:#?}",
resolved resolved
.iter() .iter()
.map(|((ty, key), id)| format!("(({}{}), {})", ty, key, id)) .map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
.collect::<Vec<_>>() .collect::<Vec<_>>()
); );

39
tests/state_res.rs
View File

@ -346,14 +346,14 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
.iter() .iter()
.map(|map| map .map(|map| map
.iter() .iter()
.map(|((ty, key), id)| format!("(({}{}), {})", ty, key, id)) .map(|((ty, key), id)| format!("(({}{:?}), {})", ty, key, id))
.collect::<Vec<_>>()) .collect::<Vec<_>>())
.collect::<Vec<_>>() .collect::<Vec<_>>()
); );
let resolved = resolver.resolve( let resolved = resolver.resolve(
&room_id(), &room_id(),
&RoomVersionId::version_1(), &RoomVersionId::Version1,
&state_sets, &state_sets,
Some(event_map.clone()), Some(event_map.clone()),
&store, &store,
@ -379,7 +379,7 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
if fake_event.state_key().is_some() { if fake_event.state_key().is_some() {
let ty = fake_event.kind().clone(); let ty = fake_event.kind().clone();
// we know there is a state_key unwrap OK // we know there is a state_key unwrap OK
let key = fake_event.state_key().unwrap().clone(); let key = fake_event.state_key().clone();
state_after.insert((ty, key), event_id.clone()); state_after.insert((ty, key), event_id.clone());
} }
@ -417,7 +417,7 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
event_map.insert(event_id.clone(), event); event_map.insert(event_id.clone(), event);
} }
let mut expected_state = BTreeMap::new(); let mut expected_state = StateMap::new();
for node in expected_state_ids { for node in expected_state_ids {
let ev = event_map.get(&node).expect(&format!( let ev = event_map.get(&node).expect(&format!(
"{} not found in {:?}", "{} not found in {:?}",
@ -428,7 +428,7 @@ fn do_check(events: &[StateEvent], edges: Vec<Vec<EventId>>, expected_state_ids:
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
)); ));
let key = (ev.kind(), ev.state_key().unwrap()); let key = (ev.kind(), ev.state_key());
expected_state.insert(key, node); expected_state.insert(key, node);
} }
@ -700,7 +700,7 @@ fn test_event_map_none() {
let resolved = match resolver.resolve( let resolved = match resolver.resolve(
&room_id(), &room_id(),
&RoomVersionId::version_2(), &RoomVersionId::Version2,
&[state_at_bob, state_at_charlie], &[state_at_bob, state_at_charlie],
None, None,
&store, &store,
@ -904,23 +904,13 @@ impl TestStore {
let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem] let state_at_bob = [&create_event, &alice_mem, &join_rules, &bob_mem]
.iter() .iter()
.map(|e| { .map(|e| ((e.kind(), e.state_key()), e.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(e.kind(), e.state_key().unwrap()),
e.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem] let state_at_charlie = [&create_event, &alice_mem, &join_rules, &charlie_mem]
.iter() .iter()
.map(|e| { .map(|e| ((e.kind(), e.state_key()), e.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(e.kind(), e.state_key().unwrap()),
e.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
let expected = [ let expected = [
&create_event, &create_event,
@ -930,13 +920,8 @@ impl TestStore {
&charlie_mem, &charlie_mem,
] ]
.iter() .iter()
.map(|e| { .map(|e| ((e.kind(), e.state_key()), e.event_id().unwrap().clone()))
( .collect::<StateMap<_>>();
(e.kind(), e.state_key().unwrap()),
e.event_id().unwrap().clone(),
)
})
.collect::<BTreeMap<_, _>>();
(state_at_bob, state_at_charlie, expected) (state_at_bob, state_at_charlie, expected)
} }