Erik Johnston
před 9 roky
1 změnil soubory, kde provedl 176 přidání a 517 odebrání
-
+176 -517tests/test_state.py
+ 176
- 517
tests/test_state.py
Zobrazit soubor
| @@ -15,599 +15,258 @@ | |||
| from tests import unittest | |||
| from twisted.internet import defer | |||
| from twisted.python.log import PythonLoggingObserver | |||
| from synapse.state import StateHandler | |||
| from synapse.storage.pdu import PduEntry | |||
| from synapse.federation.pdu_codec import encode_event_id | |||
| from synapse.federation.units import Pdu | |||
| from collections import namedtuple | |||
| from mock import Mock | |||
| import mock | |||
| ReturnType = namedtuple( | |||
| "StateReturnType", ["new_branch", "current_branch"] | |||
| ) | |||
| def _gen_get_power_level(power_level_list): | |||
| def get_power_level(room_id, user_id): | |||
| return defer.succeed(power_level_list.get(user_id, None)) | |||
| return get_power_level | |||
| class StateTestCase(unittest.TestCase): | |||
| def setUp(self): | |||
| self.persistence = Mock(spec=[ | |||
| "get_unresolved_state_tree", | |||
| "update_current_state", | |||
| "get_latest_pdus_in_context", | |||
| "get_current_state_pdu", | |||
| "get_pdu", | |||
| "get_power_level", | |||
| ]) | |||
| self.replication = Mock(spec=["get_pdu"]) | |||
| hs = Mock(spec=["get_datastore", "get_replication_layer"]) | |||
| hs.get_datastore.return_value = self.persistence | |||
| hs.get_replication_layer.return_value = self.replication | |||
| hs.hostname = "bob.com" | |||
| self.state = StateHandler(hs) | |||
| @defer.inlineCallbacks | |||
| def test_new_state_key(self): | |||
| # We've never seen anything for this state before | |||
| new_pdu = new_fake_pdu("A", "test", "mem", "x", None, "u") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({}) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu], []), None) | |||
| ) | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| self.assertTrue(is_new) | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| @defer.inlineCallbacks | |||
| def test_direct_overwrite(self): | |||
| # We do a direct overwriting of the old state, i.e., the new state | |||
| # points to the old state. | |||
| old_pdu = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| new_pdu = new_fake_pdu("B", "test", "mem", "x", "A", "u2") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 5, | |||
| }) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu, old_pdu], [old_pdu]), None) | |||
| ) | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| self.assertTrue(is_new) | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| self.store = Mock( | |||
| spec_set=[ | |||
| "get_state_groups", | |||
| ] | |||
| ) | |||
| hs = Mock(spec=["get_datastore"]) | |||
| hs.get_datastore.return_value = self.store | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| self.state = StateHandler(hs) | |||
| self.event_id = 0 | |||
| @defer.inlineCallbacks | |||
| def test_overwrite(self): | |||
| old_pdu_1 = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| old_pdu_2 = new_fake_pdu("B", "test", "mem", "x", "A", "u2") | |||
| new_pdu = new_fake_pdu("C", "test", "mem", "x", "B", "u3") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 5, | |||
| "u3": 0, | |||
| }) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu, old_pdu_2, old_pdu_1], [old_pdu_1]), None) | |||
| ) | |||
| def test_annotate_with_old_message(self): | |||
| event = self.create_event(type="test_message", name="event") | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| old_state = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test1", state_key="2"), | |||
| self.create_event(type="test2", state_key=""), | |||
| ] | |||
| self.assertTrue(is_new) | |||
| yield self.state.annotate_state_groups(event, old_state=old_state) | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| ) | |||
| for k, v in event.old_state_events.items(): | |||
| type, state_key = k | |||
| self.assertEqual(type, v.type) | |||
| self.assertEqual(state_key, v.state_key) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertEqual(set(old_state), set(event.old_state_events.values())) | |||
| self.assertDictEqual(event.old_state_events, event.state_events) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| self.assertIsNone(event.state_group) | |||
| @defer.inlineCallbacks | |||
| def test_power_level_fail(self): | |||
| # We try to update the state based on an outdated state, and have a | |||
| # too low power level. | |||
| old_pdu_1 = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| old_pdu_2 = new_fake_pdu("B", "test", "mem", "x", None, "u2") | |||
| new_pdu = new_fake_pdu("C", "test", "mem", "x", "A", "u3") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 5, | |||
| }) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu, old_pdu_1], [old_pdu_2, old_pdu_1]), None) | |||
| ) | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| self.assertFalse(is_new) | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| ) | |||
| self.assertEqual(0, self.persistence.update_current_state.call_count) | |||
| def test_annotate_with_old_state(self): | |||
| event = self.create_event(type="state", state_key="", name="event") | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| @defer.inlineCallbacks | |||
| def test_power_level_succeed(self): | |||
| # We try to update the state based on an outdated state, but have | |||
| # sufficient power level to force the update. | |||
| old_pdu_1 = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| old_pdu_2 = new_fake_pdu("B", "test", "mem", "x", None, "u2") | |||
| new_pdu = new_fake_pdu("C", "test", "mem", "x", "A", "u3") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 15, | |||
| }) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu, old_pdu_1], [old_pdu_2, old_pdu_1]), None) | |||
| ) | |||
| old_state = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test1", state_key="2"), | |||
| self.create_event(type="test2", state_key=""), | |||
| ] | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| yield self.state.annotate_state_groups(event, old_state=old_state) | |||
| self.assertTrue(is_new) | |||
| for k, v in event.old_state_events.items(): | |||
| type, state_key = k | |||
| self.assertEqual(type, v.type) | |||
| self.assertEqual(state_key, v.state_key) | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| self.assertEqual( | |||
| set(old_state + [event]), | |||
| set(event.old_state_events.values()) | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertDictEqual(event.old_state_events, event.state_events) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| self.assertIsNone(event.state_group) | |||
| @defer.inlineCallbacks | |||
| def test_power_level_equal_same_len(self): | |||
| # We try to update the state based on an outdated state, the power | |||
| # levels are the same and so are the branch lengths | |||
| old_pdu_1 = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| old_pdu_2 = new_fake_pdu("B", "test", "mem", "x", None, "u2") | |||
| new_pdu = new_fake_pdu("C", "test", "mem", "x", "A", "u3") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 10, | |||
| }) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu, old_pdu_1], [old_pdu_2, old_pdu_1]), None) | |||
| ) | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| def test_trivial_annotate_message(self): | |||
| event = self.create_event(type="test_message", name="event") | |||
| event.prev_events = [] | |||
| old_state = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test1", state_key="2"), | |||
| self.create_event(type="test2", state_key=""), | |||
| ] | |||
| self.assertTrue(is_new) | |||
| group_name = "group_name_1" | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| ) | |||
| self.store.get_state_groups.return_value = { | |||
| group_name: old_state, | |||
| } | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| yield self.state.annotate_state_groups(event) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| for k, v in event.old_state_events.items(): | |||
| type, state_key = k | |||
| self.assertEqual(type, v.type) | |||
| self.assertEqual(state_key, v.state_key) | |||
| @defer.inlineCallbacks | |||
| def test_power_level_equal_diff_len(self): | |||
| # We try to update the state based on an outdated state, the power | |||
| # levels are the same but the branch length of the new one is longer. | |||
| old_pdu_1 = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| old_pdu_2 = new_fake_pdu("B", "test", "mem", "x", None, "u2") | |||
| old_pdu_3 = new_fake_pdu("C", "test", "mem", "x", "A", "u3") | |||
| new_pdu = new_fake_pdu("D", "test", "mem", "x", "C", "u4") | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 10, | |||
| "u4": 10, | |||
| }) | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| ( | |||
| ReturnType( | |||
| [new_pdu, old_pdu_3, old_pdu_1], | |||
| [old_pdu_2, old_pdu_1] | |||
| ), | |||
| None | |||
| ) | |||
| self.assertEqual( | |||
| set([e.event_id for e in old_state]), | |||
| set([e.event_id for e in event.old_state_events.values()]) | |||
| ) | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| self.assertTrue(is_new) | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| self.assertDictEqual( | |||
| { | |||
| k: v.event_id | |||
| for k, v in event.old_state_events.items() | |||
| }, | |||
| { | |||
| k: v.event_id | |||
| for k, v in event.state_events.items() | |||
| } | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| self.assertEqual(group_name, event.state_group) | |||
| @defer.inlineCallbacks | |||
| def test_missing_pdu(self): | |||
| # We try to update state against a PDU we haven't yet seen, | |||
| # triggering a get_pdu request | |||
| # The pdu we haven't seen | |||
| old_pdu_1 = new_fake_pdu( | |||
| "A", "test", "mem", "x", None, "u1", depth=0 | |||
| ) | |||
| old_pdu_2 = new_fake_pdu( | |||
| "B", "test", "mem", "x", "A", "u2", depth=1 | |||
| ) | |||
| new_pdu = new_fake_pdu( | |||
| "C", "test", "mem", "x", "A", "u3", depth=2 | |||
| ) | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 20, | |||
| }) | |||
| # The return_value of `get_unresolved_state_tree`, which changes after | |||
| # the call to get_pdu | |||
| tree_to_return = [(ReturnType([new_pdu], [old_pdu_2]), 0)] | |||
| def return_tree(p): | |||
| return tree_to_return[0] | |||
| def set_return_tree(destination, pdu_origin, pdu_id, outlier=False): | |||
| tree_to_return[0] = ( | |||
| ReturnType( | |||
| [new_pdu, old_pdu_1], [old_pdu_2, old_pdu_1] | |||
| ), | |||
| None | |||
| ) | |||
| return defer.succeed(None) | |||
| self.persistence.get_unresolved_state_tree.side_effect = return_tree | |||
| def test_trivial_annotate_state(self): | |||
| event = self.create_event(type="state", state_key="", name="event") | |||
| event.prev_events = [] | |||
| old_state = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test1", state_key="2"), | |||
| self.create_event(type="test2", state_key=""), | |||
| ] | |||
| self.replication.get_pdu.side_effect = set_return_tree | |||
| group_name = "group_name_1" | |||
| self.persistence.get_pdu.return_value = None | |||
| self.store.get_state_groups.return_value = { | |||
| group_name: old_state, | |||
| } | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| yield self.state.annotate_state_groups(event) | |||
| self.assertTrue(is_new) | |||
| for k, v in event.old_state_events.items(): | |||
| type, state_key = k | |||
| self.assertEqual(type, v.type) | |||
| self.assertEqual(state_key, v.state_key) | |||
| self.replication.get_pdu.assert_called_with( | |||
| destination=new_pdu.origin, | |||
| pdu_origin=old_pdu_1.origin, | |||
| pdu_id=old_pdu_1.pdu_id, | |||
| outlier=True | |||
| self.assertEqual( | |||
| set([e.event_id for e in old_state]), | |||
| set([e.event_id for e in event.old_state_events.values()]) | |||
| ) | |||
| self.persistence.get_unresolved_state_tree.assert_called_with( | |||
| new_pdu | |||
| self.assertEqual( | |||
| set([e.event_id for e in old_state] + [event.event_id]), | |||
| set([e.event_id for e in event.state_events.values()]) | |||
| ) | |||
| self.assertEquals( | |||
| 2, self.persistence.get_unresolved_state_tree.call_count | |||
| new_state = { | |||
| k: v.event_id | |||
| for k, v in event.state_events.items() | |||
| } | |||
| old_state = { | |||
| k: v.event_id | |||
| for k, v in event.old_state_events.items() | |||
| } | |||
| old_state[(event.type, event.state_key)] = event.event_id | |||
| self.assertDictEqual( | |||
| old_state, | |||
| new_state | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertIsNone(event.state_group) | |||
| @defer.inlineCallbacks | |||
| def test_missing_pdu_depth_1(self): | |||
| # We try to update state against a PDU we haven't yet seen, | |||
| # triggering a get_pdu request | |||
| # The pdu we haven't seen | |||
| old_pdu_1 = new_fake_pdu( | |||
| "A", "test", "mem", "x", None, "u1", depth=0 | |||
| ) | |||
| old_pdu_2 = new_fake_pdu( | |||
| "B", "test", "mem", "x", "A", "u2", depth=2 | |||
| ) | |||
| old_pdu_3 = new_fake_pdu( | |||
| "C", "test", "mem", "x", "B", "u3", depth=3 | |||
| ) | |||
| new_pdu = new_fake_pdu( | |||
| "D", "test", "mem", "x", "A", "u4", depth=4 | |||
| ) | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 10, | |||
| "u4": 20, | |||
| }) | |||
| # The return_value of `get_unresolved_state_tree`, which changes after | |||
| # the call to get_pdu | |||
| tree_to_return = [ | |||
| ( | |||
| ReturnType([new_pdu], [old_pdu_3]), | |||
| 0 | |||
| ), | |||
| ( | |||
| ReturnType( | |||
| [new_pdu, old_pdu_1], [old_pdu_3] | |||
| ), | |||
| 1 | |||
| ), | |||
| ( | |||
| ReturnType( | |||
| [new_pdu, old_pdu_1], [old_pdu_3, old_pdu_2, old_pdu_1] | |||
| ), | |||
| None | |||
| ), | |||
| def test_resolve_message_conflict(self): | |||
| event = self.create_event(type="test_message", name="event") | |||
| event.prev_events = [] | |||
| old_state_1 = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test1", state_key="2"), | |||
| self.create_event(type="test2", state_key=""), | |||
| ] | |||
| to_return = [0] | |||
| def return_tree(p): | |||
| return tree_to_return[to_return[0]] | |||
| def set_return_tree(destination, pdu_origin, pdu_id, outlier=False): | |||
| to_return[0] += 1 | |||
| return defer.succeed(None) | |||
| self.persistence.get_unresolved_state_tree.side_effect = return_tree | |||
| self.replication.get_pdu.side_effect = set_return_tree | |||
| self.persistence.get_pdu.return_value = None | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| old_state_2 = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test3", state_key="2"), | |||
| self.create_event(type="test4", state_key=""), | |||
| ] | |||
| self.assertTrue(is_new) | |||
| group_name_1 = "group_name_1" | |||
| group_name_2 = "group_name_2" | |||
| self.assertEqual(2, self.replication.get_pdu.call_count) | |||
| self.store.get_state_groups.return_value = { | |||
| group_name_1: old_state_1, | |||
| group_name_2: old_state_2, | |||
| } | |||
| self.replication.get_pdu.assert_has_calls( | |||
| [ | |||
| mock.call( | |||
| destination=new_pdu.origin, | |||
| pdu_origin=old_pdu_1.origin, | |||
| pdu_id=old_pdu_1.pdu_id, | |||
| outlier=True | |||
| ), | |||
| mock.call( | |||
| destination=old_pdu_3.origin, | |||
| pdu_origin=old_pdu_2.origin, | |||
| pdu_id=old_pdu_2.pdu_id, | |||
| outlier=True | |||
| ), | |||
| ] | |||
| ) | |||
| yield self.state.annotate_state_groups(event) | |||
| self.persistence.get_unresolved_state_tree.assert_called_with( | |||
| new_pdu | |||
| ) | |||
| self.assertEqual(len(event.old_state_events), 5) | |||
| self.assertEquals( | |||
| 3, self.persistence.get_unresolved_state_tree.call_count | |||
| self.assertEqual( | |||
| set([e.event_id for e in event.state_events.values()]), | |||
| set([e.event_id for e in event.old_state_events.values()]) | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertIsNone(event.state_group) | |||
| @defer.inlineCallbacks | |||
| def test_missing_pdu_depth_2(self): | |||
| # We try to update state against a PDU we haven't yet seen, | |||
| # triggering a get_pdu request | |||
| # The pdu we haven't seen | |||
| old_pdu_1 = new_fake_pdu( | |||
| "A", "test", "mem", "x", None, "u1", depth=0 | |||
| ) | |||
| old_pdu_2 = new_fake_pdu( | |||
| "B", "test", "mem", "x", "A", "u2", depth=2 | |||
| ) | |||
| old_pdu_3 = new_fake_pdu( | |||
| "C", "test", "mem", "x", "B", "u3", depth=3 | |||
| ) | |||
| new_pdu = new_fake_pdu( | |||
| "D", "test", "mem", "x", "A", "u4", depth=1 | |||
| ) | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 10, | |||
| "u2": 10, | |||
| "u3": 10, | |||
| "u4": 20, | |||
| }) | |||
| # The return_value of `get_unresolved_state_tree`, which changes after | |||
| # the call to get_pdu | |||
| tree_to_return = [ | |||
| ( | |||
| ReturnType([new_pdu], [old_pdu_3]), | |||
| 1, | |||
| ), | |||
| ( | |||
| ReturnType( | |||
| [new_pdu], [old_pdu_3, old_pdu_2] | |||
| ), | |||
| 0, | |||
| ), | |||
| ( | |||
| ReturnType( | |||
| [new_pdu, old_pdu_1], [old_pdu_3, old_pdu_2, old_pdu_1] | |||
| ), | |||
| None | |||
| ), | |||
| def test_resolve_state_conflict(self): | |||
| event = self.create_event(type="test4", state_key="", name="event") | |||
| event.prev_events = [] | |||
| old_state_1 = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test1", state_key="2"), | |||
| self.create_event(type="test2", state_key=""), | |||
| ] | |||
| to_return = [0] | |||
| def return_tree(p): | |||
| return tree_to_return[to_return[0]] | |||
| def set_return_tree(destination, pdu_origin, pdu_id, outlier=False): | |||
| to_return[0] += 1 | |||
| return defer.succeed(None) | |||
| self.persistence.get_unresolved_state_tree.side_effect = return_tree | |||
| self.replication.get_pdu.side_effect = set_return_tree | |||
| self.persistence.get_pdu.return_value = None | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| self.assertTrue(is_new) | |||
| self.assertEqual(2, self.replication.get_pdu.call_count) | |||
| self.replication.get_pdu.assert_has_calls( | |||
| [ | |||
| mock.call( | |||
| destination=old_pdu_3.origin, | |||
| pdu_origin=old_pdu_2.origin, | |||
| pdu_id=old_pdu_2.pdu_id, | |||
| outlier=True | |||
| ), | |||
| mock.call( | |||
| destination=new_pdu.origin, | |||
| pdu_origin=old_pdu_1.origin, | |||
| pdu_id=old_pdu_1.pdu_id, | |||
| outlier=True | |||
| ), | |||
| ] | |||
| ) | |||
| self.persistence.get_unresolved_state_tree.assert_called_with( | |||
| new_pdu | |||
| ) | |||
| self.assertEquals( | |||
| 3, self.persistence.get_unresolved_state_tree.call_count | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| @defer.inlineCallbacks | |||
| def test_no_common_ancestor(self): | |||
| # We do a direct overwriting of the old state, i.e., the new state | |||
| # points to the old state. | |||
| old_state_2 = [ | |||
| self.create_event(type="test1", state_key="1"), | |||
| self.create_event(type="test3", state_key="2"), | |||
| self.create_event(type="test4", state_key=""), | |||
| ] | |||
| old_pdu = new_fake_pdu("A", "test", "mem", "x", None, "u1") | |||
| new_pdu = new_fake_pdu("B", "test", "mem", "x", None, "u2") | |||
| group_name_1 = "group_name_1" | |||
| group_name_2 = "group_name_2" | |||
| self.persistence.get_power_level.side_effect = _gen_get_power_level({ | |||
| "u1": 5, | |||
| "u2": 10, | |||
| }) | |||
| self.store.get_state_groups.return_value = { | |||
| group_name_1: old_state_1, | |||
| group_name_2: old_state_2, | |||
| } | |||
| self.persistence.get_unresolved_state_tree.return_value = ( | |||
| (ReturnType([new_pdu], [old_pdu]), None) | |||
| ) | |||
| yield self.state.annotate_state_groups(event) | |||
| is_new = yield self.state.handle_new_state(new_pdu) | |||
| self.assertEqual(len(event.old_state_events), 5) | |||
| self.assertTrue(is_new) | |||
| expected_new = event.old_state_events | |||
| expected_new[(event.type, event.state_key)] = event | |||
| self.persistence.get_unresolved_state_tree.assert_called_once_with( | |||
| new_pdu | |||
| self.assertEqual( | |||
| set([e.event_id for e in expected_new.values()]), | |||
| set([e.event_id for e in event.state_events.values()]), | |||
| ) | |||
| self.assertEqual(1, self.persistence.update_current_state.call_count) | |||
| self.assertFalse(self.replication.get_pdu.called) | |||
| @defer.inlineCallbacks | |||
| def test_new_event(self): | |||
| event = Mock() | |||
| event.event_id = "12123123@test" | |||
| self.assertIsNone(event.state_group) | |||
| state_pdu = new_fake_pdu("C", "test", "mem", "x", "A", 20) | |||
| def create_event(self, name=None, type=None, state_key=None): | |||
| self.event_id += 1 | |||
| event_id = str(self.event_id) | |||
| snapshot = Mock() | |||
| snapshot.prev_state_pdu = state_pdu | |||
| event_id = "pdu_id@origin.com" | |||
| if not name: | |||
| if state_key is not None: | |||
| name = "<%s-%s>" % (type, state_key) | |||
| else: | |||
| name = "<%s>" % (type, ) | |||
| def fill_out_prev_events(event): | |||
| event.prev_events = [event_id] | |||
| event.depth = 6 | |||
| snapshot.fill_out_prev_events = fill_out_prev_events | |||
| event = Mock(name=name, spec=[]) | |||
| event.type = type | |||
| yield self.state.handle_new_event(event, snapshot) | |||
| self.assertLess(5, event.depth) | |||
| self.assertEquals(1, len(event.prev_events)) | |||
| prev_id = event.prev_events[0] | |||
| self.assertEqual(event_id, prev_id) | |||
| self.assertEqual( | |||
| encode_event_id(state_pdu.pdu_id, state_pdu.origin), | |||
| event.prev_state | |||
| ) | |||
| if state_key is not None: | |||
| event.state_key = state_key | |||
| event.event_id = event_id | |||
| event.user_id = "@user_id:example.com" | |||
| event.room_id = "!room_id:example.com" | |||
| def new_fake_pdu(pdu_id, context, pdu_type, state_key, prev_state_id, | |||
| user_id, depth=0): | |||
| new_pdu = Pdu( | |||
| pdu_id=pdu_id, | |||
| pdu_type=pdu_type, | |||
| state_key=state_key, | |||
| user_id=user_id, | |||
| prev_state_id=prev_state_id, | |||
| origin="example.com", | |||
| context="context", | |||
| origin_server_ts=1405353060021, | |||
| depth=depth, | |||
| content_json="{}", | |||
| unrecognized_keys="{}", | |||
| outlier=True, | |||
| is_state=True, | |||
| prev_state_origin="example.com", | |||
| have_processed=True, | |||
| content={}, | |||
| ) | |||
| return new_pdu | |||
| return event | |||