forked from MirrorHub/synapse
Update test_typing to use HomeserverTestCase. (#4771)
This commit is contained in:
parent
3064952939
commit
2c3548d9d8
5 changed files with 176 additions and 179 deletions
1
changelog.d/4771.misc
Normal file
1
changelog.d/4771.misc
Normal file
|
@ -0,0 +1 @@
|
|||
Update test_typing to use HomeserverTestCase.
|
|
@ -24,13 +24,17 @@ from synapse.api.errors import AuthError
|
|||
from synapse.types import UserID
|
||||
|
||||
from tests import unittest
|
||||
from tests.utils import register_federation_servlets
|
||||
|
||||
from ..utils import (
|
||||
DeferredMockCallable,
|
||||
MockClock,
|
||||
MockHttpResource,
|
||||
setup_test_homeserver,
|
||||
)
|
||||
# Some local users to test with
|
||||
U_APPLE = UserID.from_string("@apple:test")
|
||||
U_BANANA = UserID.from_string("@banana:test")
|
||||
|
||||
# Remote user
|
||||
U_ONION = UserID.from_string("@onion:farm")
|
||||
|
||||
# Test room id
|
||||
ROOM_ID = "a-room"
|
||||
|
||||
|
||||
def _expect_edu_transaction(edu_type, content, origin="test"):
|
||||
|
@ -46,30 +50,21 @@ def _make_edu_transaction_json(edu_type, content):
|
|||
return json.dumps(_expect_edu_transaction(edu_type, content)).encode('utf8')
|
||||
|
||||
|
||||
class TypingNotificationsTestCase(unittest.TestCase):
|
||||
"""Tests typing notifications to rooms."""
|
||||
class TypingNotificationsTestCase(unittest.HomeserverTestCase):
|
||||
servlets = [register_federation_servlets]
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def setUp(self):
|
||||
self.clock = MockClock()
|
||||
def make_homeserver(self, reactor, clock):
|
||||
# we mock out the keyring so as to skip the authentication check on the
|
||||
# federation API call.
|
||||
mock_keyring = Mock(spec=["verify_json_for_server"])
|
||||
mock_keyring.verify_json_for_server.return_value = defer.succeed(True)
|
||||
|
||||
self.mock_http_client = Mock(spec=[])
|
||||
self.mock_http_client.put_json = DeferredMockCallable()
|
||||
# we mock out the federation client too
|
||||
mock_federation_client = Mock(spec=["put_json"])
|
||||
mock_federation_client.put_json.return_value = defer.succeed((200, "OK"))
|
||||
|
||||
self.mock_federation_resource = MockHttpResource()
|
||||
|
||||
mock_notifier = Mock()
|
||||
self.on_new_event = mock_notifier.on_new_event
|
||||
|
||||
self.auth = Mock(spec=[])
|
||||
self.state_handler = Mock()
|
||||
|
||||
hs = yield setup_test_homeserver(
|
||||
self.addCleanup,
|
||||
"test",
|
||||
auth=self.auth,
|
||||
clock=self.clock,
|
||||
datastore=Mock(
|
||||
hs = self.setup_test_homeserver(
|
||||
datastore=(Mock(
|
||||
spec=[
|
||||
# Bits that Federation needs
|
||||
"prep_send_transaction",
|
||||
|
@ -82,16 +77,21 @@ class TypingNotificationsTestCase(unittest.TestCase):
|
|||
"get_user_directory_stream_pos",
|
||||
"get_current_state_deltas",
|
||||
]
|
||||
),
|
||||
state_handler=self.state_handler,
|
||||
handlers=Mock(),
|
||||
notifier=mock_notifier,
|
||||
resource_for_client=Mock(),
|
||||
resource_for_federation=self.mock_federation_resource,
|
||||
http_client=self.mock_http_client,
|
||||
keyring=Mock(),
|
||||
)),
|
||||
notifier=Mock(),
|
||||
http_client=mock_federation_client,
|
||||
keyring=mock_keyring,
|
||||
)
|
||||
|
||||
return hs
|
||||
|
||||
def prepare(self, reactor, clock, hs):
|
||||
# the tests assume that we are starting at unix time 1000
|
||||
reactor.pump((1000, ))
|
||||
|
||||
mock_notifier = hs.get_notifier()
|
||||
self.on_new_event = mock_notifier.on_new_event
|
||||
|
||||
self.handler = hs.get_typing_handler()
|
||||
|
||||
self.event_source = hs.get_event_sources().sources["typing"]
|
||||
|
@ -109,13 +109,12 @@ class TypingNotificationsTestCase(unittest.TestCase):
|
|||
|
||||
self.datastore.get_received_txn_response = get_received_txn_response
|
||||
|
||||
self.room_id = "a-room"
|
||||
|
||||
self.room_members = []
|
||||
|
||||
def check_joined_room(room_id, user_id):
|
||||
if user_id not in [u.to_string() for u in self.room_members]:
|
||||
raise AuthError(401, "User is not in the room")
|
||||
hs.get_auth().check_joined_room = check_joined_room
|
||||
|
||||
def get_joined_hosts_for_room(room_id):
|
||||
return set(member.domain for member in self.room_members)
|
||||
|
@ -124,8 +123,7 @@ class TypingNotificationsTestCase(unittest.TestCase):
|
|||
|
||||
def get_current_user_in_room(room_id):
|
||||
return set(str(u) for u in self.room_members)
|
||||
|
||||
self.state_handler.get_current_user_in_room = get_current_user_in_room
|
||||
hs.get_state_handler().get_current_user_in_room = get_current_user_in_room
|
||||
|
||||
self.datastore.get_user_directory_stream_pos.return_value = (
|
||||
# we deliberately return a non-None stream pos to avoid doing an initial_spam
|
||||
|
@ -134,230 +132,208 @@ class TypingNotificationsTestCase(unittest.TestCase):
|
|||
|
||||
self.datastore.get_current_state_deltas.return_value = None
|
||||
|
||||
self.auth.check_joined_room = check_joined_room
|
||||
|
||||
self.datastore.get_to_device_stream_token = lambda: 0
|
||||
self.datastore.get_new_device_msgs_for_remote = lambda *args, **kargs: ([], 0)
|
||||
self.datastore.delete_device_msgs_for_remote = lambda *args, **kargs: None
|
||||
|
||||
# Some local users to test with
|
||||
self.u_apple = UserID.from_string("@apple:test")
|
||||
self.u_banana = UserID.from_string("@banana:test")
|
||||
|
||||
# Remote user
|
||||
self.u_onion = UserID.from_string("@onion:farm")
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_started_typing_local(self):
|
||||
self.room_members = [self.u_apple, self.u_banana]
|
||||
self.room_members = [U_APPLE, U_BANANA]
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 0)
|
||||
|
||||
yield self.handler.started_typing(
|
||||
target_user=self.u_apple,
|
||||
auth_user=self.u_apple,
|
||||
room_id=self.room_id,
|
||||
self.successResultOf(self.handler.started_typing(
|
||||
target_user=U_APPLE,
|
||||
auth_user=U_APPLE,
|
||||
room_id=ROOM_ID,
|
||||
timeout=20000,
|
||||
)
|
||||
))
|
||||
|
||||
self.on_new_event.assert_has_calls(
|
||||
[call('typing_key', 1, rooms=[self.room_id])]
|
||||
[call('typing_key', 1, rooms=[ROOM_ID])]
|
||||
)
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 1)
|
||||
events = yield self.event_source.get_new_events(
|
||||
room_ids=[self.room_id], from_key=0
|
||||
events = self.event_source.get_new_events(
|
||||
room_ids=[ROOM_ID], from_key=0
|
||||
)
|
||||
self.assertEquals(
|
||||
events[0],
|
||||
[
|
||||
{
|
||||
"type": "m.typing",
|
||||
"room_id": self.room_id,
|
||||
"content": {"user_ids": [self.u_apple.to_string()]},
|
||||
"room_id": ROOM_ID,
|
||||
"content": {"user_ids": [U_APPLE.to_string()]},
|
||||
}
|
||||
],
|
||||
)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_started_typing_remote_send(self):
|
||||
self.room_members = [self.u_apple, self.u_onion]
|
||||
self.room_members = [U_APPLE, U_ONION]
|
||||
|
||||
put_json = self.mock_http_client.put_json
|
||||
put_json.expect_call_and_return(
|
||||
call(
|
||||
"farm",
|
||||
path="/_matrix/federation/v1/send/1000000/",
|
||||
data=_expect_edu_transaction(
|
||||
"m.typing",
|
||||
content={
|
||||
"room_id": self.room_id,
|
||||
"user_id": self.u_apple.to_string(),
|
||||
"typing": True,
|
||||
},
|
||||
),
|
||||
json_data_callback=ANY,
|
||||
long_retries=True,
|
||||
backoff_on_404=True,
|
||||
),
|
||||
defer.succeed((200, "OK")),
|
||||
)
|
||||
|
||||
yield self.handler.started_typing(
|
||||
target_user=self.u_apple,
|
||||
auth_user=self.u_apple,
|
||||
room_id=self.room_id,
|
||||
self.successResultOf(self.handler.started_typing(
|
||||
target_user=U_APPLE,
|
||||
auth_user=U_APPLE,
|
||||
room_id=ROOM_ID,
|
||||
timeout=20000,
|
||||
))
|
||||
|
||||
put_json = self.hs.get_http_client().put_json
|
||||
put_json.assert_called_once_with(
|
||||
"farm",
|
||||
path="/_matrix/federation/v1/send/1000000/",
|
||||
data=_expect_edu_transaction(
|
||||
"m.typing",
|
||||
content={
|
||||
"room_id": ROOM_ID,
|
||||
"user_id": U_APPLE.to_string(),
|
||||
"typing": True,
|
||||
},
|
||||
),
|
||||
json_data_callback=ANY,
|
||||
long_retries=True,
|
||||
backoff_on_404=True,
|
||||
)
|
||||
|
||||
yield put_json.await_calls()
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_started_typing_remote_recv(self):
|
||||
self.room_members = [self.u_apple, self.u_onion]
|
||||
self.room_members = [U_APPLE, U_ONION]
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 0)
|
||||
|
||||
(code, response) = yield self.mock_federation_resource.trigger(
|
||||
(request, channel) = self.make_request(
|
||||
"PUT",
|
||||
"/_matrix/federation/v1/send/1000000/",
|
||||
_make_edu_transaction_json(
|
||||
"m.typing",
|
||||
content={
|
||||
"room_id": self.room_id,
|
||||
"user_id": self.u_onion.to_string(),
|
||||
"room_id": ROOM_ID,
|
||||
"user_id": U_ONION.to_string(),
|
||||
"typing": True,
|
||||
},
|
||||
),
|
||||
federation_auth_origin=b'farm',
|
||||
)
|
||||
self.render(request)
|
||||
self.assertEqual(channel.code, 200)
|
||||
|
||||
self.on_new_event.assert_has_calls(
|
||||
[call('typing_key', 1, rooms=[self.room_id])]
|
||||
[call('typing_key', 1, rooms=[ROOM_ID])]
|
||||
)
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 1)
|
||||
events = yield self.event_source.get_new_events(
|
||||
room_ids=[self.room_id], from_key=0
|
||||
events = self.event_source.get_new_events(
|
||||
room_ids=[ROOM_ID], from_key=0
|
||||
)
|
||||
self.assertEquals(
|
||||
events[0],
|
||||
[
|
||||
{
|
||||
"type": "m.typing",
|
||||
"room_id": self.room_id,
|
||||
"content": {"user_ids": [self.u_onion.to_string()]},
|
||||
"room_id": ROOM_ID,
|
||||
"content": {"user_ids": [U_ONION.to_string()]},
|
||||
}
|
||||
],
|
||||
)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_stopped_typing(self):
|
||||
self.room_members = [self.u_apple, self.u_banana, self.u_onion]
|
||||
|
||||
put_json = self.mock_http_client.put_json
|
||||
put_json.expect_call_and_return(
|
||||
call(
|
||||
"farm",
|
||||
path="/_matrix/federation/v1/send/1000000/",
|
||||
data=_expect_edu_transaction(
|
||||
"m.typing",
|
||||
content={
|
||||
"room_id": self.room_id,
|
||||
"user_id": self.u_apple.to_string(),
|
||||
"typing": False,
|
||||
},
|
||||
),
|
||||
json_data_callback=ANY,
|
||||
long_retries=True,
|
||||
backoff_on_404=True,
|
||||
),
|
||||
defer.succeed((200, "OK")),
|
||||
)
|
||||
self.room_members = [U_APPLE, U_BANANA, U_ONION]
|
||||
|
||||
# Gut-wrenching
|
||||
from synapse.handlers.typing import RoomMember
|
||||
|
||||
member = RoomMember(self.room_id, self.u_apple.to_string())
|
||||
member = RoomMember(ROOM_ID, U_APPLE.to_string())
|
||||
self.handler._member_typing_until[member] = 1002000
|
||||
self.handler._room_typing[self.room_id] = set([self.u_apple.to_string()])
|
||||
self.handler._room_typing[ROOM_ID] = set([U_APPLE.to_string()])
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 0)
|
||||
|
||||
yield self.handler.stopped_typing(
|
||||
target_user=self.u_apple, auth_user=self.u_apple, room_id=self.room_id
|
||||
)
|
||||
self.successResultOf(self.handler.stopped_typing(
|
||||
target_user=U_APPLE, auth_user=U_APPLE, room_id=ROOM_ID
|
||||
))
|
||||
|
||||
self.on_new_event.assert_has_calls(
|
||||
[call('typing_key', 1, rooms=[self.room_id])]
|
||||
[call('typing_key', 1, rooms=[ROOM_ID])]
|
||||
)
|
||||
|
||||
yield put_json.await_calls()
|
||||
put_json = self.hs.get_http_client().put_json
|
||||
put_json.assert_called_once_with(
|
||||
"farm",
|
||||
path="/_matrix/federation/v1/send/1000000/",
|
||||
data=_expect_edu_transaction(
|
||||
"m.typing",
|
||||
content={
|
||||
"room_id": ROOM_ID,
|
||||
"user_id": U_APPLE.to_string(),
|
||||
"typing": False,
|
||||
},
|
||||
),
|
||||
json_data_callback=ANY,
|
||||
long_retries=True,
|
||||
backoff_on_404=True,
|
||||
)
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 1)
|
||||
events = yield self.event_source.get_new_events(
|
||||
room_ids=[self.room_id], from_key=0
|
||||
events = self.event_source.get_new_events(
|
||||
room_ids=[ROOM_ID], from_key=0
|
||||
)
|
||||
self.assertEquals(
|
||||
events[0],
|
||||
[
|
||||
{
|
||||
"type": "m.typing",
|
||||
"room_id": self.room_id,
|
||||
"room_id": ROOM_ID,
|
||||
"content": {"user_ids": []},
|
||||
}
|
||||
],
|
||||
)
|
||||
|
||||
@defer.inlineCallbacks
|
||||
def test_typing_timeout(self):
|
||||
self.room_members = [self.u_apple, self.u_banana]
|
||||
self.room_members = [U_APPLE, U_BANANA]
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 0)
|
||||
|
||||
yield self.handler.started_typing(
|
||||
target_user=self.u_apple,
|
||||
auth_user=self.u_apple,
|
||||
room_id=self.room_id,
|
||||
self.successResultOf(self.handler.started_typing(
|
||||
target_user=U_APPLE,
|
||||
auth_user=U_APPLE,
|
||||
room_id=ROOM_ID,
|
||||
timeout=10000,
|
||||
)
|
||||
))
|
||||
|
||||
self.on_new_event.assert_has_calls(
|
||||
[call('typing_key', 1, rooms=[self.room_id])]
|
||||
[call('typing_key', 1, rooms=[ROOM_ID])]
|
||||
)
|
||||
self.on_new_event.reset_mock()
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 1)
|
||||
events = yield self.event_source.get_new_events(
|
||||
room_ids=[self.room_id], from_key=0
|
||||
events = self.event_source.get_new_events(
|
||||
room_ids=[ROOM_ID], from_key=0
|
||||
)
|
||||
self.assertEquals(
|
||||
events[0],
|
||||
[
|
||||
{
|
||||
"type": "m.typing",
|
||||
"room_id": self.room_id,
|
||||
"content": {"user_ids": [self.u_apple.to_string()]},
|
||||
"room_id": ROOM_ID,
|
||||
"content": {"user_ids": [U_APPLE.to_string()]},
|
||||
}
|
||||
],
|
||||
)
|
||||
|
||||
self.clock.advance_time(16)
|
||||
self.reactor.pump([16, ])
|
||||
|
||||
self.on_new_event.assert_has_calls(
|
||||
[call('typing_key', 2, rooms=[self.room_id])]
|
||||
[call('typing_key', 2, rooms=[ROOM_ID])]
|
||||
)
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 2)
|
||||
events = yield self.event_source.get_new_events(
|
||||
room_ids=[self.room_id], from_key=1
|
||||
events = self.event_source.get_new_events(
|
||||
room_ids=[ROOM_ID], from_key=1
|
||||
)
|
||||
self.assertEquals(
|
||||
events[0],
|
||||
[
|
||||
{
|
||||
"type": "m.typing",
|
||||
"room_id": self.room_id,
|
||||
"room_id": ROOM_ID,
|
||||
"content": {"user_ids": []},
|
||||
}
|
||||
],
|
||||
|
@ -365,29 +341,29 @@ class TypingNotificationsTestCase(unittest.TestCase):
|
|||
|
||||
# SYN-230 - see if we can still set after timeout
|
||||
|
||||
yield self.handler.started_typing(
|
||||
target_user=self.u_apple,
|
||||
auth_user=self.u_apple,
|
||||
room_id=self.room_id,
|
||||
self.successResultOf(self.handler.started_typing(
|
||||
target_user=U_APPLE,
|
||||
auth_user=U_APPLE,
|
||||
room_id=ROOM_ID,
|
||||
timeout=10000,
|
||||
)
|
||||
))
|
||||
|
||||
self.on_new_event.assert_has_calls(
|
||||
[call('typing_key', 3, rooms=[self.room_id])]
|
||||
[call('typing_key', 3, rooms=[ROOM_ID])]
|
||||
)
|
||||
self.on_new_event.reset_mock()
|
||||
|
||||
self.assertEquals(self.event_source.get_current_key(), 3)
|
||||
events = yield self.event_source.get_new_events(
|
||||
room_ids=[self.room_id], from_key=0
|
||||
events = self.event_source.get_new_events(
|
||||
room_ids=[ROOM_ID], from_key=0
|
||||
)
|
||||
self.assertEquals(
|
||||
events[0],
|
||||
[
|
||||
{
|
||||
"type": "m.typing",
|
||||
"room_id": self.room_id,
|
||||
"content": {"user_ids": [self.u_apple.to_string()]},
|
||||
"room_id": ROOM_ID,
|
||||
"content": {"user_ids": [U_APPLE.to_string()]},
|
||||
}
|
||||
],
|
||||
)
|
||||
|
|
|
@ -137,6 +137,7 @@ def make_request(
|
|||
access_token=None,
|
||||
request=SynapseRequest,
|
||||
shorthand=True,
|
||||
federation_auth_origin=None,
|
||||
):
|
||||
"""
|
||||
Make a web request using the given method and path, feed it the
|
||||
|
@ -150,9 +151,11 @@ def make_request(
|
|||
a dict.
|
||||
shorthand: Whether to try and be helpful and prefix the given URL
|
||||
with the usual REST API path, if it doesn't contain it.
|
||||
federation_auth_origin (bytes|None): if set to not-None, we will add a fake
|
||||
Authorization header pretenting to be the given server name.
|
||||
|
||||
Returns:
|
||||
A synapse.http.site.SynapseRequest.
|
||||
Tuple[synapse.http.site.SynapseRequest, channel]
|
||||
"""
|
||||
if not isinstance(method, bytes):
|
||||
method = method.encode('ascii')
|
||||
|
@ -184,6 +187,11 @@ def make_request(
|
|||
b"Authorization", b"Bearer " + access_token.encode('ascii')
|
||||
)
|
||||
|
||||
if federation_auth_origin is not None:
|
||||
req.requestHeaders.addRawHeader(
|
||||
b"Authorization", b"X-Matrix origin=%s,key=,sig=" % (federation_auth_origin,)
|
||||
)
|
||||
|
||||
if content:
|
||||
req.requestHeaders.addRawHeader(b"Content-Type", b"application/json")
|
||||
|
||||
|
@ -288,9 +296,6 @@ def setup_test_homeserver(cleanup_func, *args, **kwargs):
|
|||
**kwargs
|
||||
)
|
||||
|
||||
pool.runWithConnection = runWithConnection
|
||||
pool.runInteraction = runInteraction
|
||||
|
||||
class ThreadPool:
|
||||
"""
|
||||
Threadless thread pool.
|
||||
|
@ -316,8 +321,12 @@ def setup_test_homeserver(cleanup_func, *args, **kwargs):
|
|||
return d
|
||||
|
||||
clock.threadpool = ThreadPool()
|
||||
pool.threadpool = ThreadPool()
|
||||
pool.running = True
|
||||
|
||||
if pool:
|
||||
pool.runWithConnection = runWithConnection
|
||||
pool.runInteraction = runInteraction
|
||||
pool.threadpool = ThreadPool()
|
||||
pool.running = True
|
||||
return d
|
||||
|
||||
|
||||
|
|
|
@ -262,6 +262,7 @@ class HomeserverTestCase(TestCase):
|
|||
access_token=None,
|
||||
request=SynapseRequest,
|
||||
shorthand=True,
|
||||
federation_auth_origin=None,
|
||||
):
|
||||
"""
|
||||
Create a SynapseRequest at the path using the method and containing the
|
||||
|
@ -275,15 +276,18 @@ class HomeserverTestCase(TestCase):
|
|||
a dict.
|
||||
shorthand: Whether to try and be helpful and prefix the given URL
|
||||
with the usual REST API path, if it doesn't contain it.
|
||||
federation_auth_origin (bytes|None): if set to not-None, we will add a fake
|
||||
Authorization header pretenting to be the given server name.
|
||||
|
||||
Returns:
|
||||
A synapse.http.site.SynapseRequest.
|
||||
Tuple[synapse.http.site.SynapseRequest, channel]
|
||||
"""
|
||||
if isinstance(content, dict):
|
||||
content = json.dumps(content).encode('utf8')
|
||||
|
||||
return make_request(
|
||||
self.reactor, method, path, content, access_token, request, shorthand
|
||||
self.reactor, method, path, content, access_token, request, shorthand,
|
||||
federation_auth_origin,
|
||||
)
|
||||
|
||||
def render(self, request):
|
||||
|
|
|
@ -29,7 +29,7 @@ from twisted.internet import defer, reactor
|
|||
from synapse.api.constants import EventTypes, RoomVersions
|
||||
from synapse.api.errors import CodeMessageException, cs_error
|
||||
from synapse.config.server import ServerConfig
|
||||
from synapse.federation.transport import server
|
||||
from synapse.federation.transport import server as federation_server
|
||||
from synapse.http.server import HttpServer
|
||||
from synapse.server import HomeServer
|
||||
from synapse.storage import DataStore
|
||||
|
@ -200,6 +200,9 @@ def setup_test_homeserver(
|
|||
Args:
|
||||
cleanup_func : The function used to register a cleanup routine for
|
||||
after the test.
|
||||
|
||||
Calling this method directly is deprecated: you should instead derive from
|
||||
HomeserverTestCase.
|
||||
"""
|
||||
if reactor is None:
|
||||
from twisted.internet import reactor
|
||||
|
@ -351,23 +354,27 @@ def setup_test_homeserver(
|
|||
|
||||
fed = kargs.get("resource_for_federation", None)
|
||||
if fed:
|
||||
server.register_servlets(
|
||||
hs,
|
||||
resource=fed,
|
||||
authenticator=server.Authenticator(hs),
|
||||
ratelimiter=FederationRateLimiter(
|
||||
hs.get_clock(),
|
||||
window_size=hs.config.federation_rc_window_size,
|
||||
sleep_limit=hs.config.federation_rc_sleep_limit,
|
||||
sleep_msec=hs.config.federation_rc_sleep_delay,
|
||||
reject_limit=hs.config.federation_rc_reject_limit,
|
||||
concurrent_requests=hs.config.federation_rc_concurrent,
|
||||
),
|
||||
)
|
||||
register_federation_servlets(hs, fed)
|
||||
|
||||
defer.returnValue(hs)
|
||||
|
||||
|
||||
def register_federation_servlets(hs, resource):
|
||||
federation_server.register_servlets(
|
||||
hs,
|
||||
resource=resource,
|
||||
authenticator=federation_server.Authenticator(hs),
|
||||
ratelimiter=FederationRateLimiter(
|
||||
hs.get_clock(),
|
||||
window_size=hs.config.federation_rc_window_size,
|
||||
sleep_limit=hs.config.federation_rc_sleep_limit,
|
||||
sleep_msec=hs.config.federation_rc_sleep_delay,
|
||||
reject_limit=hs.config.federation_rc_reject_limit,
|
||||
concurrent_requests=hs.config.federation_rc_concurrent,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def get_mock_call_args(pattern_func, mock_func):
|
||||
""" Return the arguments the mock function was called with interpreted
|
||||
by the pattern functions argument list.
|
||||
|
|
Loading…
Reference in a new issue