mirror of
https://git.anonymousland.org/anonymousland/synapse.git
synced 2025-05-02 18:04:49 -04:00
Run black.
This commit is contained in:
black
Amber Brown
parent
b37c472419
commit
8b3d9b6b19
75 changed files with 1626 additions and 2277 deletions
|
|
@ -45,20 +45,20 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
self.room = RoomID.from_string("!abc123:test")
|
||||
|
||||
yield self.store.store_room(
|
||||
self.room.to_string(),
|
||||
room_creator_user_id="@creator:text",
|
||||
is_public=True
|
||||
self.room.to_string(), room_creator_user_id="@creator:text", is_public=True
|
||||
)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def inject_state_event(self, room, sender, typ, state_key, content):
|
||||
builder = self.event_builder_factory.new({
|
||||
"type": typ,
|
||||
"sender": sender.to_string(),
|
||||
"state_key": state_key,
|
||||
"room_id": room.to_string(),
|
||||
"content": content,
|
||||
})
|
||||
builder = self.event_builder_factory.new(
|
||||
{
|
||||
"type": typ,
|
||||
"sender": sender.to_string(),
|
||||
"state_key": state_key,
|
||||
"room_id": room.to_string(),
|
||||
"content": content,
|
||||
}
|
||||
)
|
||||
|
||||
event, context = yield self.event_creation_handler.create_new_client_event(
|
||||
builder
|
||||
|
|
@ -80,27 +80,31 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
# this defaults to a linear DAG as each new injection defaults to whatever
|
||||
# forward extremities are currently in the DB for this room.
|
||||
e1 = yield self.inject_state_event(
|
||||
self.room, self.u_alice, EventTypes.Create, '', {},
|
||||
self.room, self.u_alice, EventTypes.Create, '', {}
|
||||
)
|
||||
e2 = yield self.inject_state_event(
|
||||
self.room, self.u_alice, EventTypes.Name, '', {
|
||||
"name": "test room"
|
||||
},
|
||||
self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"}
|
||||
)
|
||||
e3 = yield self.inject_state_event(
|
||||
self.room, self.u_alice, EventTypes.Member, self.u_alice.to_string(), {
|
||||
"membership": Membership.JOIN
|
||||
},
|
||||
self.room,
|
||||
self.u_alice,
|
||||
EventTypes.Member,
|
||||
self.u_alice.to_string(),
|
||||
{"membership": Membership.JOIN},
|
||||
)
|
||||
e4 = yield self.inject_state_event(
|
||||
self.room, self.u_bob, EventTypes.Member, self.u_bob.to_string(), {
|
||||
"membership": Membership.JOIN
|
||||
},
|
||||
self.room,
|
||||
self.u_bob,
|
||||
EventTypes.Member,
|
||||
self.u_bob.to_string(),
|
||||
{"membership": Membership.JOIN},
|
||||
)
|
||||
e5 = yield self.inject_state_event(
|
||||
self.room, self.u_bob, EventTypes.Member, self.u_bob.to_string(), {
|
||||
"membership": Membership.LEAVE
|
||||
},
|
||||
self.room,
|
||||
self.u_bob,
|
||||
EventTypes.Member,
|
||||
self.u_bob.to_string(),
|
||||
{"membership": Membership.LEAVE},
|
||||
)
|
||||
|
||||
# check we get the full state as of the final event
|
||||
|
|
@ -110,65 +114,66 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
|
||||
self.assertIsNotNone(e4)
|
||||
|
||||
self.assertStateMapEqual({
|
||||
(e1.type, e1.state_key): e1,
|
||||
(e2.type, e2.state_key): e2,
|
||||
(e3.type, e3.state_key): e3,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5,
|
||||
}, state)
|
||||
self.assertStateMapEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1,
|
||||
(e2.type, e2.state_key): e2,
|
||||
(e3.type, e3.state_key): e3,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5,
|
||||
},
|
||||
state,
|
||||
)
|
||||
|
||||
# check we can filter to the m.room.name event (with a '' state key)
|
||||
state = yield self.store.get_state_for_event(
|
||||
e5.event_id, [(EventTypes.Name, '')], filtered_types=None
|
||||
)
|
||||
|
||||
self.assertStateMapEqual({
|
||||
(e2.type, e2.state_key): e2,
|
||||
}, state)
|
||||
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state)
|
||||
|
||||
# check we can filter to the m.room.name event (with a wildcard None state key)
|
||||
state = yield self.store.get_state_for_event(
|
||||
e5.event_id, [(EventTypes.Name, None)], filtered_types=None
|
||||
)
|
||||
|
||||
self.assertStateMapEqual({
|
||||
(e2.type, e2.state_key): e2,
|
||||
}, state)
|
||||
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state)
|
||||
|
||||
# check we can grab the m.room.member events (with a wildcard None state key)
|
||||
state = yield self.store.get_state_for_event(
|
||||
e5.event_id, [(EventTypes.Member, None)], filtered_types=None
|
||||
)
|
||||
|
||||
self.assertStateMapEqual({
|
||||
(e3.type, e3.state_key): e3,
|
||||
(e5.type, e5.state_key): e5,
|
||||
}, state)
|
||||
self.assertStateMapEqual(
|
||||
{(e3.type, e3.state_key): e3, (e5.type, e5.state_key): e5}, state
|
||||
)
|
||||
|
||||
# check we can use filter_types to grab a specific room member
|
||||
# without filtering out the other event types
|
||||
state = yield self.store.get_state_for_event(
|
||||
e5.event_id, [(EventTypes.Member, self.u_alice.to_string())],
|
||||
e5.event_id,
|
||||
[(EventTypes.Member, self.u_alice.to_string())],
|
||||
filtered_types=[EventTypes.Member],
|
||||
)
|
||||
|
||||
self.assertStateMapEqual({
|
||||
(e1.type, e1.state_key): e1,
|
||||
(e2.type, e2.state_key): e2,
|
||||
(e3.type, e3.state_key): e3,
|
||||
}, state)
|
||||
self.assertStateMapEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1,
|
||||
(e2.type, e2.state_key): e2,
|
||||
(e3.type, e3.state_key): e3,
|
||||
},
|
||||
state,
|
||||
)
|
||||
|
||||
# check that types=[], filtered_types=[EventTypes.Member]
|
||||
# doesn't return all members
|
||||
state = yield self.store.get_state_for_event(
|
||||
e5.event_id, [], filtered_types=[EventTypes.Member],
|
||||
e5.event_id, [], filtered_types=[EventTypes.Member]
|
||||
)
|
||||
|
||||
self.assertStateMapEqual({
|
||||
(e1.type, e1.state_key): e1,
|
||||
(e2.type, e2.state_key): e2,
|
||||
}, state)
|
||||
self.assertStateMapEqual(
|
||||
{(e1.type, e1.state_key): e1, (e2.type, e2.state_key): e2}, state
|
||||
)
|
||||
|
||||
#######################################################
|
||||
# _get_some_state_from_cache tests against a full cache
|
||||
|
|
@ -184,10 +189,13 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
)
|
||||
|
||||
self.assertEqual(is_all, True)
|
||||
self.assertDictEqual({
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
},
|
||||
state_dict,
|
||||
)
|
||||
|
||||
# test _get_some_state_from_cache correctly filters in members with wildcard types
|
||||
(state_dict, is_all) = yield self.store._get_some_state_from_cache(
|
||||
|
|
@ -195,25 +203,33 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
)
|
||||
|
||||
self.assertEqual(is_all, True)
|
||||
self.assertDictEqual({
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
},
|
||||
state_dict,
|
||||
)
|
||||
|
||||
# test _get_some_state_from_cache correctly filters in members with specific types
|
||||
(state_dict, is_all) = yield self.store._get_some_state_from_cache(
|
||||
group, [(EventTypes.Member, e5.state_key)], filtered_types=[EventTypes.Member]
|
||||
group,
|
||||
[(EventTypes.Member, e5.state_key)],
|
||||
filtered_types=[EventTypes.Member],
|
||||
)
|
||||
|
||||
self.assertEqual(is_all, True)
|
||||
self.assertDictEqual({
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
},
|
||||
state_dict,
|
||||
)
|
||||
|
||||
# test _get_some_state_from_cache correctly filters in members with specific types
|
||||
# and no filtered_types
|
||||
|
|
@ -222,24 +238,27 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
)
|
||||
|
||||
self.assertEqual(is_all, True)
|
||||
self.assertDictEqual({
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
|
||||
|
||||
#######################################################
|
||||
# deliberately remove e2 (room name) from the _state_group_cache
|
||||
|
||||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get(group)
|
||||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get(
|
||||
group
|
||||
)
|
||||
|
||||
self.assertEqual(is_all, True)
|
||||
self.assertEqual(known_absent, set())
|
||||
self.assertDictEqual(state_dict_ids, {
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
})
|
||||
self.assertDictEqual(
|
||||
state_dict_ids,
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e2.type, e2.state_key): e2.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
},
|
||||
)
|
||||
|
||||
state_dict_ids.pop((e2.type, e2.state_key))
|
||||
self.store._state_group_cache.invalidate(group)
|
||||
|
|
@ -252,22 +271,32 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
(e1.type, e1.state_key),
|
||||
(e3.type, e3.state_key),
|
||||
(e5.type, e5.state_key),
|
||||
)
|
||||
),
|
||||
)
|
||||
|
||||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get(group)
|
||||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get(
|
||||
group
|
||||
)
|
||||
|
||||
self.assertEqual(is_all, False)
|
||||
self.assertEqual(known_absent, set([
|
||||
(e1.type, e1.state_key),
|
||||
(e3.type, e3.state_key),
|
||||
(e5.type, e5.state_key),
|
||||
]))
|
||||
self.assertDictEqual(state_dict_ids, {
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
})
|
||||
self.assertEqual(
|
||||
known_absent,
|
||||
set(
|
||||
[
|
||||
(e1.type, e1.state_key),
|
||||
(e3.type, e3.state_key),
|
||||
(e5.type, e5.state_key),
|
||||
]
|
||||
),
|
||||
)
|
||||
self.assertDictEqual(
|
||||
state_dict_ids,
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
},
|
||||
)
|
||||
|
||||
############################################
|
||||
# test that things work with a partial cache
|
||||
|
|
@ -279,9 +308,7 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
)
|
||||
|
||||
self.assertEqual(is_all, False)
|
||||
self.assertDictEqual({
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual({(e1.type, e1.state_key): e1.event_id}, state_dict)
|
||||
|
||||
# test _get_some_state_from_cache correctly filters in members wildcard types
|
||||
(state_dict, is_all) = yield self.store._get_some_state_from_cache(
|
||||
|
|
@ -289,23 +316,31 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
)
|
||||
|
||||
self.assertEqual(is_all, False)
|
||||
self.assertDictEqual({
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e3.type, e3.state_key): e3.event_id,
|
||||
# e4 is overwritten by e5
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
},
|
||||
state_dict,
|
||||
)
|
||||
|
||||
# test _get_some_state_from_cache correctly filters in members with specific types
|
||||
(state_dict, is_all) = yield self.store._get_some_state_from_cache(
|
||||
group, [(EventTypes.Member, e5.state_key)], filtered_types=[EventTypes.Member]
|
||||
group,
|
||||
[(EventTypes.Member, e5.state_key)],
|
||||
filtered_types=[EventTypes.Member],
|
||||
)
|
||||
|
||||
self.assertEqual(is_all, False)
|
||||
self.assertDictEqual({
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual(
|
||||
{
|
||||
(e1.type, e1.state_key): e1.event_id,
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
},
|
||||
state_dict,
|
||||
)
|
||||
|
||||
# test _get_some_state_from_cache correctly filters in members with specific types
|
||||
# and no filtered_types
|
||||
|
|
@ -314,6 +349,4 @@ class StateStoreTestCase(tests.unittest.TestCase):
|
|||
)
|
||||
|
||||
self.assertEqual(is_all, True)
|
||||
self.assertDictEqual({
|
||||
(e5.type, e5.state_key): e5.event_id,
|
||||
}, state_dict)
|
||||
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue