def testPostMethodReadsBody(self):
self.requestData = None
def handler(**kwargs):
self.requestData = kwargs
reactor = Reactor()
server = HttpServer(reactor, self.port, handler, timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send(
'POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 8\r\n\r\nbodydata'
)
while not self.requestData:
reactor.step()
self.assertEquals(dict, type(self.requestData))
self.assertTrue('Headers' in self.requestData)
headers = self.requestData['Headers']
self.assertEquals('POST', self.requestData['Method'])
self.assertEquals('application/x-www-form-urlencoded',
headers['Content-Type'])
self.assertEquals(8, int(headers['Content-Length']))
self.assertTrue('Body' in self.requestData)
self.assertEquals('bodydata', self.requestData['Body'])
def testPostMethodDeCompressesDeflatedBody_unrecognizedEncoding(self):
self.requestData = None
def handler(**kwargs):
self.requestData = kwargs
return
yield
reactor = Reactor()
server = HttpServer(reactor, self.port, handler, timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
bodyData = 'bodydatabodydata'
bodyDataCompressed = compress(bodyData)
contentLengthCompressed = len(bodyDataCompressed)
sok.send((
'POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: unknown\r\n\r\n'
% contentLengthCompressed) + bodyDataCompressed)
while select([sok], [], [], 0) != ([sok], [], []):
reactor.step()
self.assertTrue(sok.recv(4096).startswith('HTTP/1.0 400 Bad Request'))
self.assertEquals(None, self.requestData)
def testConnect(self):
self.req = False
serverResponse = 'Hello World'
def onRequest(**kwargs):
yield 'HTTP/1.0 200 OK\r\n\r\n' + serverResponse
self.req = True
port = randint(15000, 16000)
reactor = Reactor()
try:
server = HttpsServer(reactor, port, onRequest, keyfile='ssl/server.pkey', certfile='ssl/server.cert')
server.listen()
p = Popen('wget -O - --no-check-certificate --quiet https://localhost:%s' % port, shell=True, stdout=PIPE)
popenStdout = []
def readPopenStdout():
popenStdout.append(p.stdout.read())
reactor.addReader(p.stdout, readPopenStdout)
while not self.req:
reactor.step()
reactor.step()
self.assertEquals(1, len(popenStdout))
self.assertEquals(serverResponse, popenStdout[0])
finally:
server.shutdown()
def testPostMethodDeCompressesDeflatedBody_deflate(self):
self.requestData = None
def handler(**kwargs):
self.requestData = kwargs
reactor = Reactor()
server = HttpServer(reactor, self.port, handler, timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
bodyData = 'bodydatabodydata'
bodyDataCompressed = compress(bodyData)
contentLengthCompressed = len(bodyDataCompressed)
sok.send((
'POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: deflate\r\n\r\n'
% contentLengthCompressed) + bodyDataCompressed)
while not self.requestData:
reactor.step()
self.assertEquals(dict, type(self.requestData))
self.assertTrue('Headers' in self.requestData)
headers = self.requestData['Headers']
self.assertEquals('POST', self.requestData['Method'])
self.assertEquals('application/x-www-form-urlencoded',
headers['Content-Type'])
self.assertEquals(contentLengthCompressed,
int(headers['Content-Length'])
) # TS: is this correct?, maybe decompressed length?
self.assertTrue('Body' in self.requestData)
self.assertEquals('bodydatabodydata', self.requestData['Body'])
def testPostMethodDeCompressesDeflatedBody_gzip(self):
self.requestData = None
def handler(**kwargs):
self.requestData = kwargs
reactor = Reactor()
server = HttpServer(reactor, self.port, handler, timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
bodyData = 'bodydatabodydata'
_sio = StringIO()
_gzFileObj = GzipFile(filename=None, mode='wb', compresslevel=6, fileobj=_sio)
_gzFileObj.write(bodyData); _gzFileObj.close()
compressedBodyData = _sio.getvalue()
bodyDataCompressed = compress(bodyData)
contentLengthCompressed = len(bodyDataCompressed)
sok.send(('POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: gzip\r\n\r\n' % contentLengthCompressed) + bodyDataCompressed)
while not self.requestData:
reactor.step()
self.assertEquals(dict, type(self.requestData))
self.assertTrue('Headers' in self.requestData)
headers = self.requestData['Headers']
self.assertEquals('POST', self.requestData['Method'])
self.assertEquals('application/x-www-form-urlencoded', headers['Content-Type'])
self.assertEquals(contentLengthCompressed, int(headers['Content-Length']))
self.assertTrue('Body' in self.requestData)
self.assertEquals('bodydatabodydata', self.requestData['Body'])
def testGlobalReactor(self):
from weightless.io import reactor
thereactor = Reactor()
def handler():
self.assertEquals(thereactor, reactor())
thereactor.addTimer(0, handler)
thereactor.step()
def testGetRidOfBadFileDescriptors(self):
reactor = Reactor()
class BadSocket(object):
def fileno(self):
return 88
def close(self):
raise Exception('hell breaks loose')
self.timeout = False
def timeout():
self.timeout = True
reactor.addReader(99, lambda: None) # broken
reactor.addWriter(99, lambda: None) # broken
reactor.addReader(BadSocket(), lambda: None) # even more broken
reactor.addTimer(0.01, timeout)
with self.stderr_replaced() as s:
for i in range(10):
if self.timeout:
break
reactor.step()
self.assertTrue("Bad file descriptor" in s.getvalue(),
s.getvalue())
self.assertTrue(self.timeout)
self.assertEquals({}, reactor._readers)
self.assertEquals({}, reactor._writers)
self.assertEquals([], reactor._timers)
def testReaderOrWriterDoesNotMaskKeyboardInterrupt(self):
fd, path = mkstemp()
reactor = Reactor()
def raiser():
raise KeyboardInterrupt('Ctrl-C')
reactor.addReader(sok=fd, sink=raiser)
self.assertEquals([raiser],
[c.callback for c in reactor._readers.values()])
try:
reactor.step()
self.fail('step() must raise KeyboardInterrupt')
except KeyboardInterrupt:
self.assertEquals([],
[c.callback for c in reactor._readers.values()])
fd, path = mkstemp()
reactor = Reactor()
reactor.addWriter(sok=fd, source=raiser)
try:
reactor.step()
self.fail('step() must raise KeyboardInterrupt')
except KeyboardInterrupt:
self.assertEquals([],
[c.callback for c in reactor._readers.values()])
def testTimeoutOnServerGoingSilentAfterHeaders(self):
port = randint(2**10, 2**16)
reactor = Reactor()
expectedrequest = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
serverThread = server(port,
"HTTP/1.1 200 OK\r\n\r\n",
expectedrequest,
delay=1)
errorArgs = []
class Handler:
def send(self, data):
pass
def throw(self, exception):
errorArgs.append(exception)
def error(exception):
errorArgs.append(exception)
reader = HttpReader(reactor,
Connector(reactor, 'localhost', port),
Handler(),
"GET",
"localhost",
"/",
timeout=0.01)
reactor.addTimer(0.2, lambda: self.fail("Test Stuck"))
while not errorArgs:
reactor.step()
serverThread.join()
self.assertEquals('timeout while receiving data', str(errorArgs[0]))
def testSmallFragmentsWhileSendingResponse(self):
def response(**kwargs):
yield 'some text that is longer than '
yield 'the lenght of fragments sent'
reactor = Reactor()
server = HttpServer(reactor, self.port, response, recvSize=3)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send(
'GET /path/here HTTP/1.0\r\nConnection: close\r\nApe-Nut: Mies\r\n\r\n'
)
while not reactor._writers:
reactor.step()
serverSok, handler = reactor._writers.items()[0]
originalSend = serverSok.send
def sendOnlyManagesToActuallySendThreeBytesPerSendCall(data, *options):
originalSend(data[:3], *options)
return 3
serverSok.send = sendOnlyManagesToActuallySendThreeBytesPerSendCall
for i in range(21):
reactor.step()
fragment = sok.recv(4096)
self.assertEquals(
'some text that is longer than the lenght of fragments sent',
fragment)
def testSendHeader(self):
self.kwargs = None
def response(**kwargs):
self.kwargs = kwargs
yield 'nosense'
reactor = Reactor()
server = HttpServer(reactor, self.port, response)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send(
'GET /path/here HTTP/1.0\r\nConnection: close\r\nApe-Nut: Mies\r\n\r\n'
)
while not self.kwargs:
reactor.step()
self.assertEquals(
{
'Body': '',
'RequestURI': '/path/here',
'HTTPVersion': '1.0',
'Method': 'GET',
'Headers': {
'Connection': 'close',
'Ape-Nut': 'Mies'
},
'Client': ('127.0.0.1', MATCHALL)
}, self.kwargs)
def testPostMethodTimesOutOnBadBody(self):
self.requestData = None
def handler(**kwargs):
self.requestData = kwargs
done = []
def onDone():
fromServer = sok.recv(1024)
self.assertTrue('HTTP/1.0 400 Bad Request' in fromServer)
done.append(True)
reactor = Reactor()
server = HttpServer(reactor, self.port, handler, timeout=0.01)
server.listen()
reactor.addTimer(0.02, onDone)
sok = socket()
sok.connect(('localhost', self.port))
sok.send(
'POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: 8\r\n\r\n'
)
while not done:
reactor.step()
def testReadChunkedAndCompressedPost(self):
postData = 'AhjBeehCeehAhjBeehCeehAhjBeehCeehAhjBeehCeeh'
postDataCompressed = compress(postData)
self.assertEquals(20, len(postDataCompressed))
self.assertEquals(15, len(postDataCompressed[:15]))
self.assertEquals(5, len(postDataCompressed[15:]))
self.requestData = {}
def handler(**kwargs):
self.requestData = kwargs
reactor = Reactor()
server = HttpServer(reactor,
self.port,
handler,
timeout=0.01,
recvSize=3)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
postString = 'POST / HTTP/1.1\r\nContent-Type: application/x-www-form-urlencoded\r\nTransfer-Encoding: chunked\r\nContent-Encoding: deflate\r\n\r\nf\r\n%s\r\n5\r\n%s\r\n0\r\n' % (
postDataCompressed[:15], postDataCompressed[15:])
sok.send(postString)
reactor.addTimer(0.2, lambda: self.fail("Test Stuck"))
while self.requestData.get('Body', None) != postData:
reactor.step()
def testPost(self):
port = randint(2048, 4096)
reactor = Reactor()
request = "POST / HTTP/1.1\r\nHost: localhost\r\nTransfer-Encoding: chunked\r\nSOAPAction: blah\r\nUser-Agent: Weightless/v%s\r\n\r\n1\r\nA\r\n1\r\nB\r\n1\r\nC\r\n0\r\n\r\n" % WlVersion
serverThread = server(port, "HTTP/1.1 200 OK\r\n\r\nresponse", request, loop=9)
sentData = []
done = []
def send(data):
sentData.append(data)
def throw(exception):
if isinstance(exception, StopIteration):
done.append(True)
def next():
yield "A"
yield "B"
yield "C"
yield None
reader = HttpReaderFacade(reactor, "http://localhost:%s" % port, send, errorHandler=throw, timeout=0.5, headers={'SOAPAction': 'blah'}, bodyHandler=next)
reactor.addTimer(3.0, lambda: self.fail("Test Stuck"))
while not done:
reactor.step()
self.assertEquals(['response'], sentData[1:])
self.assertEquals('200', sentData[0]['StatusCode'])
expected = 'POST / HTTP/1.1\r\nHost: localhost\r\nTransfer-Encoding: chunked\r\nSOAPAction: blah\r\nUser-Agent: Weightless/v%s\r\n\r\n' % WlVersion + '1\r\nA\r\n' + '1\r\nB\r\n' + '1\r\nC\r\n' + '0\r\n\r\n'
self.assertEquals(expected, "".join(request))
def testSelfModifyingLoopSkipsEverySecondTimerAndDeletesTheWrongOneBUG(
self):
done = []
reactor = Reactor()
def callback1():
self.assertEquals([], done)
done.append(1)
self.assertEquals([timer2, timer3], reactor._timers)
def callback2():
self.assertEquals([1], done)
done.append(2)
self.assertEquals([timer3], reactor._timers)
def callback3():
self.assertEquals([1, 2], done)
done.append(3)
self.assertEquals([], reactor._timers)
timer1 = reactor.addTimer(0.0001, callback1)
timer2 = reactor.addTimer(0.0002, callback2)
timer3 = reactor.addTimer(0.0003, callback3)
self.assertEquals([timer1, timer2, timer3], reactor._timers)
sleep(0.04)
reactor.step()
self.assertEquals([1, 2, 3], done)
self.assertEquals([], reactor._timers)
def testReaderOrWriterDoesNotMaskSystemExit(self):
fd, path = mkstemp()
reactor = Reactor()
def raiser():
raise SystemExit('shutdown...')
reactor.addReader(sok=fd, sink=raiser)
self.assertEquals([raiser],
[c.callback for c in reactor._readers.values()])
try:
reactor.step()
self.fail('step() must raise SystemExit')
except SystemExit:
self.assertEquals([],
[c.callback for c in reactor._readers.values()])
fd, path = mkstemp()
reactor = Reactor()
reactor.addWriter(sok=fd, source=raiser)
try:
reactor.step()
self.fail('step() must raise SystemExit')
except SystemExit:
self.assertEquals([],
[c.callback for c in reactor._readers.values()])
def testClearTimer(self):
port = randint(2**10, 2**16)
reactor = Reactor()
expectedrequest = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
serverThread = server(port, "HTTP/1.1 200 OK\r\n\r\nresponse",
expectedrequest)
self.exception = None
sentData = []
def send(data):
sentData.append(data)
def throw(exception):
self.exception = exception
reader = HttpReaderFacade(reactor,
"http://localhost:%s" % port,
send,
throw,
timeout=0.01,
recvSize=3)
while not self.exception:
reactor.step()
sleep(0.02) # 2 * timeout, just to be sure
self.assertTrue(isinstance(self.exception, StopIteration))
def testDealWithChunkedResponse(self):
port = randint(2048, 4096)
reactor = Reactor()
sentData = []
done = []
expectedrequest = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
serverThread = server(port, "\r\n".join("""HTTP/1.1 302 Found
Date: Fri, 26 Oct 2007 07:23:26 GMT
Server: Apache/2.2.3 (Debian) mod_python/3.2.10 Python/2.4.4 mod_ssl/2.2.3 OpenSSL/0.9.8c
Location: /page/softwarestudio.page/show
Transfer-Encoding: chunked
Content-Type: text/html; charset=utf-8
4F
<p>The document has moved <a href="/page/softwarestudio.page/show">here</a></p>
0
""".split("\n")), expectedrequest)
class Handler:
def send(self, data):
sentData.append(data)
def throw(self, exception):
if isinstance(exception, StopIteration):
done.append(True)
reader = HttpReader(reactor, Connector(reactor, 'localhost', int(port)), Handler(), 'GET', 'localhost', '/', recvSize=5)
reactor.addTimer(0.2, lambda: self.fail("Test Stuck"))
while not done:
reactor.step()
self.assertEquals("""<p>The document has moved <a href="/page/softwarestudio.page/show">here</a></p>""", "".join(sentData[1:]))
def testPostMethodDeCompressesDeflatedBody_deflate(self):
self.requestData = None
def handler(**kwargs):
self.requestData = kwargs
reactor = Reactor()
server = HttpServer(reactor, self.port, handler, timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
bodyData = 'bodydatabodydata'
bodyDataCompressed = compress(bodyData)
contentLengthCompressed = len(bodyDataCompressed)
sok.send(('POST / HTTP/1.0\r\nContent-Type: application/x-www-form-urlencoded\r\nContent-Length: %d\r\nContent-Encoding: deflate\r\n\r\n' % contentLengthCompressed) + bodyDataCompressed)
while not self.requestData:
reactor.step()
self.assertEquals(dict, type(self.requestData))
self.assertTrue('Headers' in self.requestData)
headers = self.requestData['Headers']
self.assertEquals('POST', self.requestData['Method'])
self.assertEquals('application/x-www-form-urlencoded', headers['Content-Type'])
self.assertEquals(contentLengthCompressed, int(headers['Content-Length'])) # TS: is this correct?, maybe decompressed length?
self.assertTrue('Body' in self.requestData)
self.assertEquals('bodydatabodydata', self.requestData['Body'])
def testDoNotMaskOtherErrors(self):
def raiser(*args): raise Exception('oops')
reactor = Reactor(raiser)
try:
reactor.step()
self.fail('must raise oops')
except Exception, e:
self.assertEquals('oops', str(e))
def testTimerDoesNotMaskAssertionErrors(self):
reactor = Reactor()
reactor.addTimer(0, lambda: self.fail("Assertion Error"))
try:
reactor.step()
raise Exception('step() must raise AssertionError')
except AssertionError:
self.assertEquals([], reactor._timers)
def testTimerDoesNotMaskAssertionErrors(self):
reactor = Reactor()
reactor.addTimer(0, lambda: self.fail("Assertion Error"))
try:
reactor.step()
raise Exception('step() must raise AssertionError')
except AssertionError:
self.assertEquals([], reactor._timers)
def testGlobalReactor(self):
from weightless.io import reactor
thereactor = Reactor()
def handler():
self.assertEquals(thereactor, reactor())
thereactor.addTimer(0, handler)
thereactor.step()
def testEmptyPath(self):
port = randint(2**10, 2**16)
reactor = Reactor()
request = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
serverThread = server(port, "HTTP/1.1 200 OK\r\n\r\n", request)
reader = HttpReaderFacade(reactor, "http://localhost:%s" % port, lambda data: 'a')
reactor.step()
reactor.step()
serverThread.join()
class AsyncReaderTest(WeightlessTestCase):
def dispatch(self, *args, **kwargs):
return compose(self.handler(*args, **kwargs))
def setUp(self):
WeightlessTestCase.setUp(self)
self.reactor = Reactor()
self.port = randint(2**10, 2**16)
self.httpserver = HttpServer(self.reactor, self.port, self.dispatch)
self.httpserver.listen()
def tearDown(self):
self.httpserver.shutdown()
self.reactor.shutdown()
WeightlessTestCase.tearDown(self)
def testHttpRequest(self):
self.assertEquals('GET / HTTP/1.0\r\n', _httpRequest('GET', '/'))
self.assertEquals('POST / HTTP/1.0\r\n', _httpRequest('POST', '/'))
def testPassRequestThruToBackOfficeServer(self):
done = [False]
backofficeport = self.port + 1
def passthruhandler(*args, **kwargs):
request = kwargs['RequestURI']
response = yield httpget('localhost', backofficeport, request)
yield response
done[0] = True
self.handler = passthruhandler
expectedrequest = "GET /depot?arg=1&arg=2 HTTP/1.0\r\n\r\n"
responses = (i for i in ['hel', 'lo!'])
backofficeserver = testserver(backofficeport, responses, expectedrequest)
client = clientget('localhost', self.port, '/depot?arg=1&arg=2')
while not done[0]:
self.reactor.step()
response = client.recv(99)
self.assertEquals('hello!', response)
def testConnectFails(self):
exceptions = []
def failingserver(*args, **kwarg):
try:
response = yield httpget(*target)
except Exception, e:
exceptions.append(exc_info())
self.handler = failingserver
clientget('localhost', self.port, '/')
target = ('localhost', 'port', '/') # non-numeric port
try:
with self.stderr_replaced():
with self.loopingReactor():
while not exceptions:
pass
except Exception, e:
pass
def testDoNotMaskOtherErrors(self):
def raiser(*args):
raise Exception('oops')
reactor = Reactor(raiser)
try:
reactor.step()
self.fail('must raise oops')
except Exception, e:
self.assertEquals('oops', str(e))
def testTimerDoesNotMaskSystemExit(self):
reactor = Reactor()
def raiser():
raise SystemExit('shutdown...')
reactor.addTimer(0, raiser)
try:
reactor.step()
self.fail('step() must raise SystemExit')
except SystemExit:
self.assertEquals([], reactor._timers)
def testEmptyPath(self):
port = randint(2**10, 2**16)
reactor = Reactor()
request = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
serverThread = server(port, "HTTP/1.1 200 OK\r\n\r\n", request)
reader = HttpReaderFacade(reactor, "http://localhost:%s" % port,
lambda data: 'a')
reactor.step()
reactor.step()
serverThread.join()
def testTimerDoesNotMaskKeyboardInterrupt(self):
reactor = Reactor()
def raiser():
raise KeyboardInterrupt('Ctrl-C')
reactor.addTimer(0, raiser)
try:
reactor.step()
self.fail('step() must raise KeyboardInterrupt')
except KeyboardInterrupt:
self.assertEquals([], reactor._timers)
def testDoNotDieButLogOnProgrammingErrors(self):
reactor = Reactor()
reactor.addReader('not a sok', lambda: None)
try:
sys.stderr = StringIO()
reactor.step()
sys.stderr.seek(0)
self.assertTrue('TypeError: argument must be an int' in sys.stderr.getvalue())
sys.stderr = sys.__stderr__
except TypeError:
self.fail('must not fail')
def testWriteFollowsRead(self):
reactor = Reactor(lambda r,w,o,t: (r,w,o))
t = []
def read():
t.append('t1')
def write():
t.append('t2')
reactor.addWriter('sok1', write)
reactor.addReader('sok1', read)
reactor.step()
self.assertEquals(['t1', 't2'], t)
def testReadFollowsTimer(self):
reactor = Reactor(lambda r,w,o,t: (r,w,o))
t = []
def timer():
t.append('t1')
def read():
t.append('t2')
reactor.addTimer(0, timer)
reactor.addReader('sok1', read)
reactor.step()
self.assertEquals(['t1', 't2'], t)
def testTimerDoesNotMaskKeyboardInterrupt(self):
reactor = Reactor()
def raiser():
raise KeyboardInterrupt('Ctrl-C')
reactor.addTimer(0, raiser)
try:
reactor.step()
self.fail('step() must raise KeyboardInterrupt')
except KeyboardInterrupt:
self.assertEquals([], reactor._timers)
def testExceptionInTimeoutCallback(self):
sys.stderr = StringIO()
try:
def itsTime(): raise Exception('here is the exception')
reactor = Reactor()
token1 = reactor.addTimer(0.001, itsTime)
try:
reactor.step()
except:
self.fail('must not raise exception')
finally:
sys.stderr = sys.__stderr__
def testDoNotDieButLogOnProgrammingErrors(self):
reactor = Reactor()
reactor.addReader('not a sok', lambda: None)
try:
sys.stderr = StringIO()
reactor.step()
sys.stderr.seek(0)
self.assertTrue(
'TypeError: argument must be an int' in sys.stderr.getvalue())
sys.stderr = sys.__stderr__
except TypeError:
self.fail('must not fail')
def testValidRequestResetsTimer(self):
reactor = Reactor()
server = HttpServer(reactor, self.port, lambda **kwargs: ('a' for a in range(3)), timeout=0.01, recvSize=3)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('GET / HTTP/1.0\r\n\r\n')
sleep(0.02)
for i in range(11):
reactor.step()
response = sok.recv(4096)
self.assertEquals('aaa', response)
def testTimerDoesNotMaskSystemExit(self):
reactor = Reactor()
def raiser():
raise SystemExit('shutdown...')
reactor.addTimer(0, raiser)
try:
reactor.step()
self.fail('step() must raise SystemExit')
except SystemExit:
self.assertEquals([], reactor._timers)
def testMustRemoveToBeExecutedTimerNotTheFirstOne(self):
reactor = Reactor()
executed = []
def addNewTimer():
reactor.addTimer(0.001, lambda: executed.append('newTimer'))
sleep(0.15)
reactor.addTimer(0, lambda: (addNewTimer(), executed.append('zero')))
reactor.addTimer(0.1, lambda: executed.append('one'))
reactor.step()
reactor.step()
self.assertEquals(0, len(reactor._timers))
self.assertEquals(['zero', 'newTimer', 'one'], executed)
def testReadDeletesWrite(self):
reactor = Reactor(lambda r,w,o,t: (r,w,o))
self.read = self.write = False
def read():
self.read = True
reactor.removeWriter('sok1')
def write():
self.write = True
reactor.addWriter('sok1', write)
reactor.addReader('sok1', read)
reactor.step()
self.assertTrue(self.read)
self.assertFalse(self.write)
def testAssertionErrorInWRITECallback(self):
sys.stderr = StringIO()
try:
def callback(): raise AssertionError('here is the assertion')
reactor = Reactor(lambda r, w, o, t: (r,w,o))
reactor.addWriter(9, callback)
try:
reactor.step()
self.fail('must raise exception')
except AssertionError, e:
self.assertEquals('here is the assertion', str(e))
finally:
sys.stderr = sys.__stderr__
def testDuplicateTimerDoesNotCauseZeroTimeout(self):
itstime = []
def itsTime():
itstime.append(True)
reactor = Reactor()
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
while itstime != [True, True, True, True, True]:
reactor.step()
self.assertEquals([True, True, True, True, True], itstime)
def testTimerDeletesRead(self):
reactor = Reactor(lambda r,w,o,t: (r,w,o))
self.read = self.timer = False
def read():
self.read = True
def timer():
self.timer = True
reactor.removeReader('sok1')
reactor.addTimer(0, timer)
reactor.addReader('sok1', read)
reactor.step()
self.assertTrue(self.timer)
self.assertFalse(self.read)
def testTimeoutOnInvalidRequest(self):
port = randint(2**10, 2**16)
reactor = Reactor()
expectedrequest = "GET / HTTP/1.1\r\nHost: localhost\r\nUser-Agent: Weightless/v%s\r\n\r\n" % WlVersion
serverThread = server(port, "HTTP/1.1 *invalid reponse* 200 OK\r\n\r\n", expectedrequest)
errorArgs = []
def error(exception):
errorArgs.append(exception)
reader = HttpReaderFacade(reactor, "http://localhost:%s" % port, None, error, timeout=0.01)
while not errorArgs:
reactor.step()
serverThread.join()
self.assertEquals('timeout while receiving data', str(errorArgs[0]))
def testInvalidPOSTRequestStartsOnlyOneTimer(self):
# problem in found in OAS, timers not removed properly when whole body hasnt been read yet
_httpserver.RECVSIZE = 1
reactor = Reactor()
timers = []
orgAddTimer = reactor.addTimer
def addTimerInterceptor(*timer):
timers.append(timer)
return orgAddTimer(*timer)
reactor.addTimer = addTimerInterceptor
server = HttpServer(reactor,
self.port,
lambda **kwargs: (x for x in []),
timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('POST / HTTP/1.0\r\nContent-Length: 10\r\n\r\n')
reactor.step()
sok.send(".")
sleep(0.1)
reactor.step()
sok.send(".")
reactor.step()
sleep(0.1)
while select([sok], [], [], 0) != ([sok], [], []):
reactor.step()
self.assertEquals(2, len(timers))
def testSuspendProtocol(self):
reactor = Reactor(select_func=mockselect)
suspend = Suspend()
def handler(**httpvars):
yield 'before suspend'
yield suspend
yield "result = %s" % suspend.getResult()
yield 'after suspend'
listener = MyMockSocket()
port = 9
httpserver = HttpServer(reactor, port, handler, sok=listener)
httpserver.listen()
reactor.removeReader(listener) # avoid new connections
httpserver._acceptor._accept()
reactor.step()
reactor.step()
self.assertEquals(1, len(reactor._writers))
reactor.step()
self.assertEquals(reactor, suspend._reactor)
self.assertEquals(0, len(reactor._writers))
suspend.resume('RESPONSE')
reactor.step()
reactor.step()
reactor.step()
self.assertEquals(['before suspend', 'result = RESPONSE', 'after suspend'], listener.data)
def testWriteFollowsRead(self):
reactor = Reactor(lambda r, w, o, t: (r, w, o))
t = []
def read():
t.append('t1')
def write():
t.append('t2')
reactor.addWriter('sok1', write)
reactor.addReader('sok1', read)
reactor.step()
self.assertEquals(['t1', 't2'], t)
def testInvalidPOSTRequestStartsOnlyOneTimer(self):
# problem in found in OAS, timers not removed properly when whole body hasnt been read yet
_httpserver.RECVSIZE = 1
reactor = Reactor()
timers = []
orgAddTimer = reactor.addTimer
def addTimerInterceptor(*timer):
timers.append(timer)
return orgAddTimer(*timer)
reactor.addTimer = addTimerInterceptor
server = HttpServer(reactor, self.port, lambda **kwargs: (x for x in []), timeout=0.01)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('POST / HTTP/1.0\r\nContent-Length: 10\r\n\r\n')
reactor.step()
sok.send(".")
sleep(0.1)
reactor.step()
sok.send(".")
reactor.step()
sleep(0.1)
while select([sok],[], [], 0) != ([sok], [], []):
reactor.step()
self.assertEquals(2, len(timers))
def testSendHeader(self):
self.kwargs = None
def response(**kwargs):
self.kwargs = kwargs
yield 'nosense'
reactor = Reactor()
server = HttpServer(reactor, self.port, response)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('GET /path/here HTTP/1.0\r\nConnection: close\r\nApe-Nut: Mies\r\n\r\n')
while not self.kwargs:
reactor.step()
self.assertEquals({'Body': '', 'RequestURI': '/path/here', 'HTTPVersion': '1.0', 'Method': 'GET', 'Headers': {'Connection': 'close', 'Ape-Nut': 'Mies'}, 'Client': ('127.0.0.1', MATCHALL)}, self.kwargs)
def testWrongUseAfterSuspending(self):
reactor = Reactor(select_func=mockselect)
handle = ['initial value']
def callback():
handle[0] = reactor.suspend()
sok = MockSocket()
reactor.addWriter(sok, callback)
reactor.step()
self.assertEquals(sok, handle[0])
try:
reactor.addWriter(sok, callback)
self.fail("Exception not raised")
except ValueError, e:
self.assertEquals('Socket is suspended', str(e))
def testReadFollowsTimer(self):
reactor = Reactor(lambda r, w, o, t: (r, w, o))
t = []
def timer():
t.append('t1')
def read():
t.append('t2')
reactor.addTimer(0, timer)
reactor.addReader('sok1', read)
reactor.step()
self.assertEquals(['t1', 't2'], t)
def testInvalidRequestWithHalfHeader(self):
reactor = Reactor()
server = HttpServer(reactor, self.port, None, timeout=0.1)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('POST / HTTP/1.0\r\n')
sok.send('Expect: something\r\n')
sok.send('Content-Length: 5\r\n')
sok.send('\r\n1234')
sok.close()
with self.stderr_replaced() as s:
for i in range(4):
reactor.step()
self.assertEquals(1, len(reactor._readers))
def testConnect(self):
self.req = False
def onRequest(**kwargs):
self.req = True
yield 'nosens'
reactor = Reactor()
server = HttpServer(reactor, self.port, onRequest)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('GET / HTTP/1.0\r\n\r\n')
reactor.step() # connect/accept
reactor.step() # read GET request
reactor.step() # call onRequest for response data
self.assertEquals(True, self.req)
def testGetRidOfClosedSocket(self):
reactor = Reactor()
sok = socket()
sok.close()
callbacks = []
def callback():
callbacks.append(True)
reactor.addReader(sok, callback)
reactor.addWriter(sok, callback)
with self.stderr_replaced() as s:
reactor.step()
reactor.step()
self.assertTrue("Bad file descriptor" in s.getvalue(), s.getvalue())
self.assertEquals({}, reactor._readers)
self.assertEquals([True, True], callbacks)
def testExceptionInTimeoutCallback(self):
sys.stderr = StringIO()
try:
def itsTime():
raise Exception('here is the exception')
reactor = Reactor()
token1 = reactor.addTimer(0.001, itsTime)
try:
reactor.step()
except:
self.fail('must not raise exception')
finally:
sys.stderr = sys.__stderr__
def testDuplicateTimerDoesNotCauseZeroTimeout(self):
itstime = []
def itsTime():
itstime.append(True)
reactor = Reactor()
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
reactor.addTimer(0.05, itsTime)
while itstime != [True, True, True, True, True]:
reactor.step()
self.assertEquals([True, True, True, True, True], itstime)
def testReadFile(self):
reactor = Reactor()
fd, path = mkstemp()
os.write(fd, 'some data')
os.close(fd)
try:
f = open(path)
def readable():
self.readable = True
reactor.addReader(f, readable)
reactor.step()
self.assertTrue(self.readable)
finally:
f.close()
os.remove(path)
def testMustRemoveToBeExecutedTimerNotTheFirstOne(self):
reactor = Reactor()
executed = []
def addNewTimer():
reactor.addTimer(0.001, lambda: executed.append('newTimer'))
sleep(0.15)
reactor.addTimer(0, lambda: (addNewTimer(), executed.append('zero')))
reactor.addTimer(0.1, lambda: executed.append('one'))
reactor.step()
reactor.step()
self.assertEquals(0, len(reactor._timers))
self.assertEquals(['zero', 'newTimer', 'one'], executed)
def testValidRequestResetsTimer(self):
reactor = Reactor()
server = HttpServer(reactor,
self.port,
lambda **kwargs: ('a' for a in range(3)),
timeout=0.01,
recvSize=3)
server.listen()
sok = socket()
sok.connect(('localhost', self.port))
sok.send('GET / HTTP/1.0\r\n\r\n')
sleep(0.02)
for i in range(11):
reactor.step()
response = sok.recv(4096)
self.assertEquals('aaa', response)
