Python Reactor.step方法代码示例

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 def testGlobalReactor(self):
     from weightless.io import reactor
     thereactor = Reactor()
     def handler():
         self.assertEquals(thereactor, reactor())
     thereactor.addTimer(0, handler)
     thereactor.step()

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
    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'])

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
    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()

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
    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:]))

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
    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))

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
    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'])

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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))

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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)

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
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

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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()

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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)

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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)

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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')

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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)

# 需要导入模块: from weightless.io import Reactor [as 别名]
# 或者: from weightless.io.Reactor import step [as 别名]
 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)