1
0

unittest.py 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657
  1. # -*- coding: utf-8 -*-
  2. # Copyright 2014-2016 OpenMarket Ltd
  3. # Copyright 2018 New Vector
  4. # Copyright 2019 Matrix.org Federation C.I.C
  5. #
  6. # Licensed under the Apache License, Version 2.0 (the "License");
  7. # you may not use this file except in compliance with the License.
  8. # You may obtain a copy of the License at
  9. #
  10. # http://www.apache.org/licenses/LICENSE-2.0
  11. #
  12. # Unless required by applicable law or agreed to in writing, software
  13. # distributed under the License is distributed on an "AS IS" BASIS,
  14. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15. # See the License for the specific language governing permissions and
  16. # limitations under the License.
  17. import gc
  18. import hashlib
  19. import hmac
  20. import inspect
  21. import logging
  22. import time
  23. from typing import Optional, Tuple, Type, TypeVar, Union
  24. from mock import Mock
  25. from canonicaljson import json
  26. from twisted.internet.defer import Deferred, ensureDeferred, succeed
  27. from twisted.python.threadpool import ThreadPool
  28. from twisted.trial import unittest
  29. from synapse.api.constants import EventTypes, Membership
  30. from synapse.config.homeserver import HomeServerConfig
  31. from synapse.config.ratelimiting import FederationRateLimitConfig
  32. from synapse.federation.transport import server as federation_server
  33. from synapse.http.server import JsonResource
  34. from synapse.http.site import SynapseRequest, SynapseSite
  35. from synapse.logging.context import (
  36. SENTINEL_CONTEXT,
  37. LoggingContext,
  38. current_context,
  39. set_current_context,
  40. )
  41. from synapse.server import HomeServer
  42. from synapse.types import Requester, UserID, create_requester
  43. from synapse.util.ratelimitutils import FederationRateLimiter
  44. from tests.server import (
  45. FakeChannel,
  46. get_clock,
  47. make_request,
  48. render,
  49. setup_test_homeserver,
  50. )
  51. from tests.test_utils import event_injection
  52. from tests.test_utils.logging_setup import setup_logging
  53. from tests.utils import default_config, setupdb
  54. setupdb()
  55. setup_logging()
  56. def around(target):
  57. """A CLOS-style 'around' modifier, which wraps the original method of the
  58. given instance with another piece of code.
  59. @around(self)
  60. def method_name(orig, *args, **kwargs):
  61. return orig(*args, **kwargs)
  62. """
  63. def _around(code):
  64. name = code.__name__
  65. orig = getattr(target, name)
  66. def new(*args, **kwargs):
  67. return code(orig, *args, **kwargs)
  68. setattr(target, name, new)
  69. return _around
  70. T = TypeVar("T")
  71. class TestCase(unittest.TestCase):
  72. """A subclass of twisted.trial's TestCase which looks for 'loglevel'
  73. attributes on both itself and its individual test methods, to override the
  74. root logger's logging level while that test (case|method) runs."""
  75. def __init__(self, methodName, *args, **kwargs):
  76. super(TestCase, self).__init__(methodName, *args, **kwargs)
  77. method = getattr(self, methodName)
  78. level = getattr(method, "loglevel", getattr(self, "loglevel", None))
  79. @around(self)
  80. def setUp(orig):
  81. # if we're not starting in the sentinel logcontext, then to be honest
  82. # all future bets are off.
  83. if current_context():
  84. self.fail(
  85. "Test starting with non-sentinel logging context %s"
  86. % (current_context(),)
  87. )
  88. old_level = logging.getLogger().level
  89. if level is not None and old_level != level:
  90. @around(self)
  91. def tearDown(orig):
  92. ret = orig()
  93. logging.getLogger().setLevel(old_level)
  94. return ret
  95. logging.getLogger().setLevel(level)
  96. return orig()
  97. @around(self)
  98. def tearDown(orig):
  99. ret = orig()
  100. # force a GC to workaround problems with deferreds leaking logcontexts when
  101. # they are GCed (see the logcontext docs)
  102. gc.collect()
  103. set_current_context(SENTINEL_CONTEXT)
  104. return ret
  105. def assertObjectHasAttributes(self, attrs, obj):
  106. """Asserts that the given object has each of the attributes given, and
  107. that the value of each matches according to assertEquals."""
  108. for (key, value) in attrs.items():
  109. if not hasattr(obj, key):
  110. raise AssertionError("Expected obj to have a '.%s'" % key)
  111. try:
  112. self.assertEquals(attrs[key], getattr(obj, key))
  113. except AssertionError as e:
  114. raise (type(e))(e.message + " for '.%s'" % key)
  115. def assert_dict(self, required, actual):
  116. """Does a partial assert of a dict.
  117. Args:
  118. required (dict): The keys and value which MUST be in 'actual'.
  119. actual (dict): The test result. Extra keys will not be checked.
  120. """
  121. for key in required:
  122. self.assertEquals(
  123. required[key], actual[key], msg="%s mismatch. %s" % (key, actual)
  124. )
  125. def DEBUG(target):
  126. """A decorator to set the .loglevel attribute to logging.DEBUG.
  127. Can apply to either a TestCase or an individual test method."""
  128. target.loglevel = logging.DEBUG
  129. return target
  130. def INFO(target):
  131. """A decorator to set the .loglevel attribute to logging.INFO.
  132. Can apply to either a TestCase or an individual test method."""
  133. target.loglevel = logging.INFO
  134. return target
  135. class HomeserverTestCase(TestCase):
  136. """
  137. A base TestCase that reduces boilerplate for HomeServer-using test cases.
  138. Defines a setUp method which creates a mock reactor, and instantiates a homeserver
  139. running on that reactor.
  140. There are various hooks for modifying the way that the homeserver is instantiated:
  141. * override make_homeserver, for example by making it pass different parameters into
  142. setup_test_homeserver.
  143. * override default_config, to return a modified configuration dictionary for use
  144. by setup_test_homeserver.
  145. * On a per-test basis, you can use the @override_config decorator to give a
  146. dictionary containing additional configuration settings to be added to the basic
  147. config dict.
  148. Attributes:
  149. servlets (list[function]): List of servlet registration function.
  150. user_id (str): The user ID to assume if auth is hijacked.
  151. hijack_auth (bool): Whether to hijack auth to return the user specified
  152. in user_id.
  153. """
  154. servlets = []
  155. hijack_auth = True
  156. needs_threadpool = False
  157. def __init__(self, methodName, *args, **kwargs):
  158. super().__init__(methodName, *args, **kwargs)
  159. # see if we have any additional config for this test
  160. method = getattr(self, methodName)
  161. self._extra_config = getattr(method, "_extra_config", None)
  162. def setUp(self):
  163. """
  164. Set up the TestCase by calling the homeserver constructor, optionally
  165. hijacking the authentication system to return a fixed user, and then
  166. calling the prepare function.
  167. """
  168. self.reactor, self.clock = get_clock()
  169. self._hs_args = {"clock": self.clock, "reactor": self.reactor}
  170. self.hs = self.make_homeserver(self.reactor, self.clock)
  171. if self.hs is None:
  172. raise Exception("No homeserver returned from make_homeserver.")
  173. if not isinstance(self.hs, HomeServer):
  174. raise Exception("A homeserver wasn't returned, but %r" % (self.hs,))
  175. # Register the resources
  176. self.resource = self.create_test_json_resource()
  177. # create a site to wrap the resource.
  178. self.site = SynapseSite(
  179. logger_name="synapse.access.http.fake",
  180. site_tag="test",
  181. config={},
  182. resource=self.resource,
  183. server_version_string="1",
  184. )
  185. from tests.rest.client.v1.utils import RestHelper
  186. self.helper = RestHelper(self.hs, self.resource, getattr(self, "user_id", None))
  187. if hasattr(self, "user_id"):
  188. if self.hijack_auth:
  189. def get_user_by_access_token(token=None, allow_guest=False):
  190. return succeed(
  191. {
  192. "user": UserID.from_string(self.helper.auth_user_id),
  193. "token_id": 1,
  194. "is_guest": False,
  195. }
  196. )
  197. def get_user_by_req(request, allow_guest=False, rights="access"):
  198. return succeed(
  199. create_requester(
  200. UserID.from_string(self.helper.auth_user_id), 1, False, None
  201. )
  202. )
  203. self.hs.get_auth().get_user_by_req = get_user_by_req
  204. self.hs.get_auth().get_user_by_access_token = get_user_by_access_token
  205. self.hs.get_auth().get_access_token_from_request = Mock(
  206. return_value="1234"
  207. )
  208. if self.needs_threadpool:
  209. self.reactor.threadpool = ThreadPool()
  210. self.addCleanup(self.reactor.threadpool.stop)
  211. self.reactor.threadpool.start()
  212. if hasattr(self, "prepare"):
  213. self.prepare(self.reactor, self.clock, self.hs)
  214. def wait_on_thread(self, deferred, timeout=10):
  215. """
  216. Wait until a Deferred is done, where it's waiting on a real thread.
  217. """
  218. start_time = time.time()
  219. while not deferred.called:
  220. if start_time + timeout < time.time():
  221. raise ValueError("Timed out waiting for threadpool")
  222. self.reactor.advance(0.01)
  223. time.sleep(0.01)
  224. def make_homeserver(self, reactor, clock):
  225. """
  226. Make and return a homeserver.
  227. Args:
  228. reactor: A Twisted Reactor, or something that pretends to be one.
  229. clock (synapse.util.Clock): The Clock, associated with the reactor.
  230. Returns:
  231. A homeserver (synapse.server.HomeServer) suitable for testing.
  232. Function to be overridden in subclasses.
  233. """
  234. hs = self.setup_test_homeserver()
  235. return hs
  236. def create_test_json_resource(self):
  237. """
  238. Create a test JsonResource, with the relevant servlets registerd to it
  239. The default implementation calls each function in `servlets` to do the
  240. registration.
  241. Returns:
  242. JsonResource:
  243. """
  244. resource = JsonResource(self.hs)
  245. for servlet in self.servlets:
  246. servlet(self.hs, resource)
  247. return resource
  248. def default_config(self):
  249. """
  250. Get a default HomeServer config dict.
  251. """
  252. config = default_config("test")
  253. # apply any additional config which was specified via the override_config
  254. # decorator.
  255. if self._extra_config is not None:
  256. config.update(self._extra_config)
  257. return config
  258. def prepare(self, reactor, clock, homeserver):
  259. """
  260. Prepare for the test. This involves things like mocking out parts of
  261. the homeserver, or building test data common across the whole test
  262. suite.
  263. Args:
  264. reactor: A Twisted Reactor, or something that pretends to be one.
  265. clock (synapse.util.Clock): The Clock, associated with the reactor.
  266. homeserver (synapse.server.HomeServer): The HomeServer to test
  267. against.
  268. Function to optionally be overridden in subclasses.
  269. """
  270. def make_request(
  271. self,
  272. method: Union[bytes, str],
  273. path: Union[bytes, str],
  274. content: Union[bytes, dict] = b"",
  275. access_token: Optional[str] = None,
  276. request: Type[T] = SynapseRequest,
  277. shorthand: bool = True,
  278. federation_auth_origin: str = None,
  279. ) -> Tuple[T, FakeChannel]:
  280. """
  281. Create a SynapseRequest at the path using the method and containing the
  282. given content.
  283. Args:
  284. method (bytes/unicode): The HTTP request method ("verb").
  285. path (bytes/unicode): The HTTP path, suitably URL encoded (e.g.
  286. escaped UTF-8 & spaces and such).
  287. content (bytes or dict): The body of the request. JSON-encoded, if
  288. a dict.
  289. shorthand: Whether to try and be helpful and prefix the given URL
  290. with the usual REST API path, if it doesn't contain it.
  291. federation_auth_origin (bytes|None): if set to not-None, we will add a fake
  292. Authorization header pretenting to be the given server name.
  293. Returns:
  294. Tuple[synapse.http.site.SynapseRequest, channel]
  295. """
  296. if isinstance(content, dict):
  297. content = json.dumps(content).encode("utf8")
  298. return make_request(
  299. self.reactor,
  300. method,
  301. path,
  302. content,
  303. access_token,
  304. request,
  305. shorthand,
  306. federation_auth_origin,
  307. )
  308. def render(self, request):
  309. """
  310. Render a request against the resources registered by the test class's
  311. servlets.
  312. Args:
  313. request (synapse.http.site.SynapseRequest): The request to render.
  314. """
  315. render(request, self.resource, self.reactor)
  316. def setup_test_homeserver(self, *args, **kwargs):
  317. """
  318. Set up the test homeserver, meant to be called by the overridable
  319. make_homeserver. It automatically passes through the test class's
  320. clock & reactor.
  321. Args:
  322. See tests.utils.setup_test_homeserver.
  323. Returns:
  324. synapse.server.HomeServer
  325. """
  326. kwargs = dict(kwargs)
  327. kwargs.update(self._hs_args)
  328. if "config" not in kwargs:
  329. config = self.default_config()
  330. else:
  331. config = kwargs["config"]
  332. # Parse the config from a config dict into a HomeServerConfig
  333. config_obj = HomeServerConfig()
  334. config_obj.parse_config_dict(config, "", "")
  335. kwargs["config"] = config_obj
  336. async def run_bg_updates():
  337. with LoggingContext("run_bg_updates", request="run_bg_updates-1"):
  338. while not await stor.db.updates.has_completed_background_updates():
  339. await stor.db.updates.do_next_background_update(1)
  340. hs = setup_test_homeserver(self.addCleanup, *args, **kwargs)
  341. stor = hs.get_datastore()
  342. # Run the database background updates, when running against "master".
  343. if hs.__class__.__name__ == "TestHomeServer":
  344. self.get_success(run_bg_updates())
  345. return hs
  346. def pump(self, by=0.0):
  347. """
  348. Pump the reactor enough that Deferreds will fire.
  349. """
  350. self.reactor.pump([by] * 100)
  351. def get_success(self, d, by=0.0):
  352. if inspect.isawaitable(d):
  353. d = ensureDeferred(d)
  354. if not isinstance(d, Deferred):
  355. return d
  356. self.pump(by=by)
  357. return self.successResultOf(d)
  358. def get_failure(self, d, exc):
  359. """
  360. Run a Deferred and get a Failure from it. The failure must be of the type `exc`.
  361. """
  362. if inspect.isawaitable(d):
  363. d = ensureDeferred(d)
  364. if not isinstance(d, Deferred):
  365. return d
  366. self.pump()
  367. return self.failureResultOf(d, exc)
  368. def register_user(self, username, password, admin=False):
  369. """
  370. Register a user. Requires the Admin API be registered.
  371. Args:
  372. username (bytes/unicode): The user part of the new user.
  373. password (bytes/unicode): The password of the new user.
  374. admin (bool): Whether the user should be created as an admin
  375. or not.
  376. Returns:
  377. The MXID of the new user (unicode).
  378. """
  379. self.hs.config.registration_shared_secret = "shared"
  380. # Create the user
  381. request, channel = self.make_request("GET", "/_matrix/client/r0/admin/register")
  382. self.render(request)
  383. self.assertEqual(channel.code, 200, msg=channel.result)
  384. nonce = channel.json_body["nonce"]
  385. want_mac = hmac.new(key=b"shared", digestmod=hashlib.sha1)
  386. nonce_str = b"\x00".join([username.encode("utf8"), password.encode("utf8")])
  387. if admin:
  388. nonce_str += b"\x00admin"
  389. else:
  390. nonce_str += b"\x00notadmin"
  391. want_mac.update(nonce.encode("ascii") + b"\x00" + nonce_str)
  392. want_mac = want_mac.hexdigest()
  393. body = json.dumps(
  394. {
  395. "nonce": nonce,
  396. "username": username,
  397. "password": password,
  398. "admin": admin,
  399. "mac": want_mac,
  400. "inhibit_login": True,
  401. }
  402. )
  403. request, channel = self.make_request(
  404. "POST", "/_matrix/client/r0/admin/register", body.encode("utf8")
  405. )
  406. self.render(request)
  407. self.assertEqual(channel.code, 200, channel.json_body)
  408. user_id = channel.json_body["user_id"]
  409. return user_id
  410. def login(self, username, password, device_id=None):
  411. """
  412. Log in a user, and get an access token. Requires the Login API be
  413. registered.
  414. """
  415. body = {"type": "m.login.password", "user": username, "password": password}
  416. if device_id:
  417. body["device_id"] = device_id
  418. request, channel = self.make_request(
  419. "POST", "/_matrix/client/r0/login", json.dumps(body).encode("utf8")
  420. )
  421. self.render(request)
  422. self.assertEqual(channel.code, 200, channel.result)
  423. access_token = channel.json_body["access_token"]
  424. return access_token
  425. def create_and_send_event(
  426. self, room_id, user, soft_failed=False, prev_event_ids=None
  427. ):
  428. """
  429. Create and send an event.
  430. Args:
  431. soft_failed (bool): Whether to create a soft failed event or not
  432. prev_event_ids (list[str]|None): Explicitly set the prev events,
  433. or if None just use the default
  434. Returns:
  435. str: The new event's ID.
  436. """
  437. event_creator = self.hs.get_event_creation_handler()
  438. secrets = self.hs.get_secrets()
  439. requester = Requester(user, None, False, None, None)
  440. event, context = self.get_success(
  441. event_creator.create_event(
  442. requester,
  443. {
  444. "type": EventTypes.Message,
  445. "room_id": room_id,
  446. "sender": user.to_string(),
  447. "content": {"body": secrets.token_hex(), "msgtype": "m.text"},
  448. },
  449. prev_event_ids=prev_event_ids,
  450. )
  451. )
  452. if soft_failed:
  453. event.internal_metadata.soft_failed = True
  454. self.get_success(event_creator.send_nonmember_event(requester, event, context))
  455. return event.event_id
  456. def add_extremity(self, room_id, event_id):
  457. """
  458. Add the given event as an extremity to the room.
  459. """
  460. self.get_success(
  461. self.hs.get_datastore().db.simple_insert(
  462. table="event_forward_extremities",
  463. values={"room_id": room_id, "event_id": event_id},
  464. desc="test_add_extremity",
  465. )
  466. )
  467. self.hs.get_datastore().get_latest_event_ids_in_room.invalidate((room_id,))
  468. def attempt_wrong_password_login(self, username, password):
  469. """Attempts to login as the user with the given password, asserting
  470. that the attempt *fails*.
  471. """
  472. body = {"type": "m.login.password", "user": username, "password": password}
  473. request, channel = self.make_request(
  474. "POST", "/_matrix/client/r0/login", json.dumps(body).encode("utf8")
  475. )
  476. self.render(request)
  477. self.assertEqual(channel.code, 403, channel.result)
  478. def inject_room_member(self, room: str, user: str, membership: Membership) -> None:
  479. """
  480. Inject a membership event into a room.
  481. Deprecated: use event_injection.inject_room_member directly
  482. Args:
  483. room: Room ID to inject the event into.
  484. user: MXID of the user to inject the membership for.
  485. membership: The membership type.
  486. """
  487. event_injection.inject_member_event(self.hs, room, user, membership)
  488. class FederatingHomeserverTestCase(HomeserverTestCase):
  489. """
  490. A federating homeserver that authenticates incoming requests as `other.example.com`.
  491. """
  492. def prepare(self, reactor, clock, homeserver):
  493. class Authenticator(object):
  494. def authenticate_request(self, request, content):
  495. return succeed("other.example.com")
  496. ratelimiter = FederationRateLimiter(
  497. clock,
  498. FederationRateLimitConfig(
  499. window_size=1,
  500. sleep_limit=1,
  501. sleep_msec=1,
  502. reject_limit=1000,
  503. concurrent_requests=1000,
  504. ),
  505. )
  506. federation_server.register_servlets(
  507. homeserver, self.resource, Authenticator(), ratelimiter
  508. )
  509. return super().prepare(reactor, clock, homeserver)
  510. def override_config(extra_config):
  511. """A decorator which can be applied to test functions to give additional HS config
  512. For use
  513. For example:
  514. class MyTestCase(HomeserverTestCase):
  515. @override_config({"enable_registration": False, ...})
  516. def test_foo(self):
  517. ...
  518. Args:
  519. extra_config(dict): Additional config settings to be merged into the default
  520. config dict before instantiating the test homeserver.
  521. """
  522. def decorator(func):
  523. func._extra_config = extra_config
  524. return func
  525. return decorator