Better testing framework for homeserver-using things (#3446)
Amber Brown
GitHub
parent
71ad43a8b5
commit
cd6bcdaf87
|
|
@ -0,0 +1,181 @@
|
|||
from io import BytesIO
|
||||
|
||||
import attr
|
||||
import json
|
||||
from six import text_type
|
||||
|
||||
from twisted.python.failure import Failure
|
||||
from twisted.internet.defer import Deferred
|
||||
from twisted.test.proto_helpers import MemoryReactorClock
|
||||
|
||||
from synapse.http.site import SynapseRequest
|
||||
from twisted.internet import threads
|
||||
from tests.utils import setup_test_homeserver as _sth
|
||||
|
||||
|
||||
@attr.s
|
||||
class FakeChannel(object):
|
||||
"""
|
||||
A fake Twisted Web Channel (the part that interfaces with the
|
||||
wire).
|
||||
"""
|
||||
|
||||
result = attr.ib(factory=dict)
|
||||
|
||||
@property
|
||||
def json_body(self):
|
||||
if not self.result:
|
||||
raise Exception("No result yet.")
|
||||
return json.loads(self.result["body"])
|
||||
|
||||
def writeHeaders(self, version, code, reason, headers):
|
||||
self.result["version"] = version
|
||||
self.result["code"] = code
|
||||
self.result["reason"] = reason
|
||||
self.result["headers"] = headers
|
||||
|
||||
def write(self, content):
|
||||
if "body" not in self.result:
|
||||
self.result["body"] = b""
|
||||
|
||||
self.result["body"] += content
|
||||
|
||||
def requestDone(self, _self):
|
||||
self.result["done"] = True
|
||||
|
||||
def getPeer(self):
|
||||
return None
|
||||
|
||||
def getHost(self):
|
||||
return None
|
||||
|
||||
@property
|
||||
def transport(self):
|
||||
return self
|
||||
|
||||
|
||||
class FakeSite:
|
||||
"""
|
||||
A fake Twisted Web Site, with mocks of the extra things that
|
||||
Synapse adds.
|
||||
"""
|
||||
|
||||
server_version_string = b"1"
|
||||
site_tag = "test"
|
||||
|
||||
@property
|
||||
def access_logger(self):
|
||||
class FakeLogger:
|
||||
def info(self, *args, **kwargs):
|
||||
pass
|
||||
|
||||
return FakeLogger()
|
||||
|
||||
|
||||
def make_request(method, path, content=b""):
|
||||
"""
|
||||
Make a web request using the given method and path, feed it the
|
||||
content, and return the Request and the Channel underneath.
|
||||
"""
|
||||
|
||||
if isinstance(content, text_type):
|
||||
content = content.encode('utf8')
|
||||
|
||||
site = FakeSite()
|
||||
channel = FakeChannel()
|
||||
|
||||
req = SynapseRequest(site, channel)
|
||||
req.process = lambda: b""
|
||||
req.content = BytesIO(content)
|
||||
req.requestReceived(method, path, b"1.1")
|
||||
|
||||
return req, channel
|
||||
|
||||
|
||||
def wait_until_result(clock, channel, timeout=100):
|
||||
"""
|
||||
Wait until the channel has a result.
|
||||
"""
|
||||
clock.run()
|
||||
x = 0
|
||||
|
||||
while not channel.result:
|
||||
x += 1
|
||||
|
||||
if x > timeout:
|
||||
raise Exception("Timed out waiting for request to finish.")
|
||||
|
||||
clock.advance(0.1)
|
||||
|
||||
|
||||
class ThreadedMemoryReactorClock(MemoryReactorClock):
|
||||
"""
|
||||
A MemoryReactorClock that supports callFromThread.
|
||||
"""
|
||||
def callFromThread(self, callback, *args, **kwargs):
|
||||
"""
|
||||
Make the callback fire in the next reactor iteration.
|
||||
"""
|
||||
d = Deferred()
|
||||
d.addCallback(lambda x: callback(*args, **kwargs))
|
||||
self.callLater(0, d.callback, True)
|
||||
return d
|
||||
|
||||
|
||||
def setup_test_homeserver(*args, **kwargs):
|
||||
"""
|
||||
Set up a synchronous test server, driven by the reactor used by
|
||||
the homeserver.
|
||||
"""
|
||||
d = _sth(*args, **kwargs).result
|
||||
|
||||
# Make the thread pool synchronous.
|
||||
clock = d.get_clock()
|
||||
pool = d.get_db_pool()
|
||||
|
||||
def runWithConnection(func, *args, **kwargs):
|
||||
return threads.deferToThreadPool(
|
||||
pool._reactor,
|
||||
pool.threadpool,
|
||||
pool._runWithConnection,
|
||||
func,
|
||||
*args,
|
||||
**kwargs
|
||||
)
|
||||
|
||||
def runInteraction(interaction, *args, **kwargs):
|
||||
return threads.deferToThreadPool(
|
||||
pool._reactor,
|
||||
pool.threadpool,
|
||||
pool._runInteraction,
|
||||
interaction,
|
||||
*args,
|
||||
**kwargs
|
||||
)
|
||||
|
||||
pool.runWithConnection = runWithConnection
|
||||
pool.runInteraction = runInteraction
|
||||
|
||||
class ThreadPool:
|
||||
"""
|
||||
Threadless thread pool.
|
||||
"""
|
||||
def start(self):
|
||||
pass
|
||||
|
||||
def callInThreadWithCallback(self, onResult, function, *args, **kwargs):
|
||||
def _(res):
|
||||
if isinstance(res, Failure):
|
||||
onResult(False, res)
|
||||
else:
|
||||
onResult(True, res)
|
||||
|
||||
d = Deferred()
|
||||
d.addCallback(lambda x: function(*args, **kwargs))
|
||||
d.addBoth(_)
|
||||
clock._reactor.callLater(0, d.callback, True)
|
||||
return d
|
||||
|
||||
clock.threadpool = ThreadPool()
|
||||
pool.threadpool = ThreadPool()
|
||||
return d
|
||||
|
|
@ -0,0 +1,128 @@
|
|||
import json
|
||||
import re
|
||||
|
||||
from twisted.internet.defer import Deferred
|
||||
from twisted.test.proto_helpers import MemoryReactorClock
|
||||
|
||||
from synapse.util import Clock
|
||||
from synapse.api.errors import Codes, SynapseError
|
||||
from synapse.http.server import JsonResource
|
||||
from tests import unittest
|
||||
from tests.server import make_request, setup_test_homeserver
|
||||
|
||||
|
||||
class JsonResourceTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.reactor = MemoryReactorClock()
|
||||
self.hs_clock = Clock(self.reactor)
|
||||
self.homeserver = setup_test_homeserver(
|
||||
http_client=None, clock=self.hs_clock, reactor=self.reactor
|
||||
)
|
||||
|
||||
def test_handler_for_request(self):
|
||||
"""
|
||||
JsonResource.handler_for_request gives correctly decoded URL args to
|
||||
the callback, while Twisted will give the raw bytes of URL query
|
||||
arguments.
|
||||
"""
|
||||
got_kwargs = {}
|
||||
|
||||
def _callback(request, **kwargs):
|
||||
got_kwargs.update(kwargs)
|
||||
return (200, kwargs)
|
||||
|
||||
res = JsonResource(self.homeserver)
|
||||
res.register_paths("GET", [re.compile("^/foo/(?P<room_id>[^/]*)$")], _callback)
|
||||
|
||||
request, channel = make_request(b"GET", b"/foo/%E2%98%83?a=%E2%98%83")
|
||||
request.render(res)
|
||||
|
||||
self.assertEqual(request.args, {b'a': [u"\N{SNOWMAN}".encode('utf8')]})
|
||||
self.assertEqual(got_kwargs, {u"room_id": u"\N{SNOWMAN}"})
|
||||
|
||||
def test_callback_direct_exception(self):
|
||||
"""
|
||||
If the web callback raises an uncaught exception, it will be translated
|
||||
into a 500.
|
||||
"""
|
||||
|
||||
def _callback(request, **kwargs):
|
||||
raise Exception("boo")
|
||||
|
||||
res = JsonResource(self.homeserver)
|
||||
res.register_paths("GET", [re.compile("^/foo$")], _callback)
|
||||
|
||||
request, channel = make_request(b"GET", b"/foo")
|
||||
request.render(res)
|
||||
|
||||
self.assertEqual(channel.result["code"], b'500')
|
||||
|
||||
def test_callback_indirect_exception(self):
|
||||
"""
|
||||
If the web callback raises an uncaught exception in a Deferred, it will
|
||||
be translated into a 500.
|
||||
"""
|
||||
|
||||
def _throw(*args):
|
||||
raise Exception("boo")
|
||||
|
||||
def _callback(request, **kwargs):
|
||||
d = Deferred()
|
||||
d.addCallback(_throw)
|
||||
self.reactor.callLater(1, d.callback, True)
|
||||
return d
|
||||
|
||||
res = JsonResource(self.homeserver)
|
||||
res.register_paths("GET", [re.compile("^/foo$")], _callback)
|
||||
|
||||
request, channel = make_request(b"GET", b"/foo")
|
||||
request.render(res)
|
||||
|
||||
# No error has been raised yet
|
||||
self.assertTrue("code" not in channel.result)
|
||||
|
||||
# Advance time, now there's an error
|
||||
self.reactor.advance(1)
|
||||
self.assertEqual(channel.result["code"], b'500')
|
||||
|
||||
def test_callback_synapseerror(self):
|
||||
"""
|
||||
If the web callback raises a SynapseError, it returns the appropriate
|
||||
status code and message set in it.
|
||||
"""
|
||||
|
||||
def _callback(request, **kwargs):
|
||||
raise SynapseError(403, "Forbidden!!one!", Codes.FORBIDDEN)
|
||||
|
||||
res = JsonResource(self.homeserver)
|
||||
res.register_paths("GET", [re.compile("^/foo$")], _callback)
|
||||
|
||||
request, channel = make_request(b"GET", b"/foo")
|
||||
request.render(res)
|
||||
|
||||
self.assertEqual(channel.result["code"], b'403')
|
||||
reply_body = json.loads(channel.result["body"])
|
||||
self.assertEqual(reply_body["error"], "Forbidden!!one!")
|
||||
self.assertEqual(reply_body["errcode"], "M_FORBIDDEN")
|
||||
|
||||
def test_no_handler(self):
|
||||
"""
|
||||
If there is no handler to process the request, Synapse will return 400.
|
||||
"""
|
||||
|
||||
def _callback(request, **kwargs):
|
||||
"""
|
||||
Not ever actually called!
|
||||
"""
|
||||
self.fail("shouldn't ever get here")
|
||||
|
||||
res = JsonResource(self.homeserver)
|
||||
res.register_paths("GET", [re.compile("^/foo$")], _callback)
|
||||
|
||||
request, channel = make_request(b"GET", b"/foobar")
|
||||
request.render(res)
|
||||
|
||||
self.assertEqual(channel.result["code"], b'400')
|
||||
reply_body = json.loads(channel.result["body"])
|
||||
self.assertEqual(reply_body["error"], "Unrecognized request")
|
||||
self.assertEqual(reply_body["errcode"], "M_UNRECOGNIZED")
|
||||
Loading…
Reference in New Issue