File: test_web_middleware.py

package info (click to toggle)
python-aiohttp 0.17.2-1~bpo8%2B1
  • links: PTS, VCS
  • area: main
  • in suites: jessie-backports
  • size: 2,368 kB
  • sloc: python: 19,899; makefile: 205
file content (122 lines) | stat: -rw-r--r-- 4,120 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import asyncio
import socket
import unittest
from aiohttp import web, request


class TestWebMiddlewareFunctional(unittest.TestCase):

    def setUp(self):
        self.handler = None
        self.loop = asyncio.new_event_loop()
        asyncio.set_event_loop(None)

    def tearDown(self):
        if self.handler:
            self.loop.run_until_complete(self.handler.finish_connections())
        self.loop.close()

    def find_unused_port(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.bind(('127.0.0.1', 0))
        port = s.getsockname()[1]
        s.close()
        return port

    @asyncio.coroutine
    def create_server(self, method, path, handler, *middlewares):
        app = web.Application(loop=self.loop, middlewares=middlewares)
        app.router.add_route(method, path, handler)

        port = self.find_unused_port()
        self.handler = app.make_handler(debug=True)
        srv = yield from self.loop.create_server(self.handler, '127.0.0.1',
                                                 port)

        url = "http://127.0.0.1:{}".format(port) + path
        self.addCleanup(srv.close)
        return app, srv, url

    def test_middleware_modifies_response(self):

        @asyncio.coroutine
        def handler(request):
            return web.Response(body=b'OK')

        @asyncio.coroutine
        def middleware_factory(app, handler):
            def middleware(request):
                resp = yield from handler(request)
                self.assertEqual(200, resp.status)
                resp.set_status(201)
                resp.text = resp.text + '[MIDDLEWARE]'
                return resp
            return middleware

        @asyncio.coroutine
        def go():
            _, _, url = yield from self.create_server('GET', '/', handler,
                                                      middleware_factory)
            resp = yield from request('GET', url, loop=self.loop)
            self.assertEqual(201, resp.status)
            txt = yield from resp.text()
            self.assertEqual('OK[MIDDLEWARE]', txt)
        self.loop.run_until_complete(go())

    def test_middleware_handles_exception(self):

        @asyncio.coroutine
        def handler(request):
            raise RuntimeError('Error text')

        @asyncio.coroutine
        def middleware_factory(app, handler):
            def middleware(request):
                with self.assertRaises(RuntimeError) as ctx:
                    yield from handler(request)
                return web.Response(status=501,
                                    text=str(ctx.exception) + '[MIDDLEWARE]')

            return middleware

        @asyncio.coroutine
        def go():
            _, _, url = yield from self.create_server('GET', '/', handler,
                                                      middleware_factory)
            resp = yield from request('GET', url, loop=self.loop)
            self.assertEqual(501, resp.status)
            txt = yield from resp.text()
            self.assertEqual('Error text[MIDDLEWARE]', txt)

        self.loop.run_until_complete(go())

    def test_middleware_chain(self):

        @asyncio.coroutine
        def handler(request):
            return web.Response(text='OK')

        def make_factory(num):

            @asyncio.coroutine
            def factory(app, handler):

                def middleware(request):
                    resp = yield from handler(request)
                    resp.text = resp.text + '[{}]'.format(num)
                    return resp

                return middleware
            return factory

        @asyncio.coroutine
        def go():
            _, _, url = yield from self.create_server('GET', '/', handler,
                                                      make_factory(1),
                                                      make_factory(2))
            resp = yield from request('GET', url, loop=self.loop)
            self.assertEqual(200, resp.status)
            txt = yield from resp.text()
            self.assertEqual('OK[2][1]', txt)

        self.loop.run_until_complete(go())