def test_call_POST_on_weird_content_type(self): req = self.make_request( 'POST', '/', headers=MultiDict({'CONTENT-TYPE': 'something/weird'})) ret = self.loop.run_until_complete(req.post()) self.assertEqual(MultiDict(), ret)
def __init__(self, host, message, req_body, *, session_factory=None, loop=None): if loop is None: loop = asyncio.get_event_loop() res = urlsplit(message.path) self._loop = loop self.version = message.version self.method = message.method.upper() self.host = message.headers.get('HOST', host) self.host_url = 'http://' + self.host self.path_qs = message.path self.path = res.path self.path_url = self.host_url + self.path self.url = self.host_url + self.path_qs self.query_string = res.query self.args = MultiDict(parse_qsl(res.query)) self.headers = message.headers self.matchdict = {} self._request_body = req_body self._response = Response() self._session_factory = session_factory self._session_fut = None self._json_body = None self._cookies = None self._on_response = []
def make_request(self, method='GET', path='/', headers=MultiDict()): self.app = mock.Mock() message = RawRequestMessage(method, path, HttpVersion11, headers, False, False) req = Request(self.app, message, self.payload, self.transport, self.writer, 15) return req
def test_init_headers_MultiDict(create_session): session = create_session( headers=MultiDict([("h1", "header1"), ("h2", "header2"), ("h3", "header3")])) assert (session._default_headers == CIMultiDict([("H1", "header1"), ("H2", "header2"), ("H3", "header3")]))
def make_request(self, method, path, headers=MultiDict()): self.app = mock.Mock() message = RawRequestMessage(method, path, HttpVersion11, headers, False, False) self.payload = mock.Mock() self.writer = mock.Mock() req = Request(self.app, message, self.payload, self.writer) return req
def test_request_cookie__set_item(self): headers = MultiDict(COOKIE='name=value') req = self.make_request('GET', '/', headers=headers) self.assertEqual(req.cookies, {'name': 'value'}) with self.assertRaises(TypeError): req.cookies['my'] = 'value'
def test_request_cookie(self): headers = MultiDict(COOKIE='cookie1=value1; cookie2=value2') req = self.make_request('GET', '/', headers=headers) self.assertEqual(req.cookies, { 'cookie1': 'value1', 'cookie2': 'value2', })
def go(): _, _, url = yield from self.create_server('POST', '/', handler) resp = yield from request('POST', url, data=MultiDict([('a', 1), ('a', 2)]), loop=self.loop) self.assertEqual(200, resp.status) txt = yield from resp.text() self.assertEqual('OK', txt)
def test_init_headers_MultiDict(self): session = ClientSession(headers=MultiDict([("h1", "header1"), ("h2", "header2"), ("h3", "header3")]), loop=self.loop) self.assertEqual( session._default_headers, CIMultiDict([("H1", "header1"), ("H2", "header2"), ("H3", "header3")])) session.close()
def make_request(self, method, path): self.app = mock.Mock() message = RawRequestMessage(method, path, HttpVersion(1, 1), MultiDict(), False, False) self.payload = mock.Mock() self.transport = mock.Mock() self.writer = mock.Mock() req = Request(self.app, message, self.payload, self.transport, self.writer, 15) return req
def check_wrapped_data(self, klass): schema = Schema(schemas.index) # Validate request should understand wrapped data base = {'name': TEST_NAME} wrapped = (klass(MultiDict(base)) if klass == MultiDictProxy else klass(base)) data = schema.validate_request(wrapped) self.assertEqual(data, base) self.assertIsInstance(data, klass) # Make response should understand wrapped data base = {'name': TEST_NAME, 'time': time.time()} wrapped = (klass(MultiDict(base)) if klass == MultiDictProxy else klass(base)) data = schema.make_response(wrapped) self.assertEqual(data, base) self.assertIsInstance(data, klass)
def test_merge_headers_with_multi_dict(self): session = ClientSession(headers={ "h1": "header1", "h2": "header2" }, loop=self.loop) headers = session._prepare_headers(MultiDict([("h1", "h1")])) self.assertIsInstance(headers, CIMultiDict) self.assertEqual(headers, CIMultiDict([("h2", "header2"), ("h1", "h1")])) session.close()
def cookies(self): """Return request cookies. A read-only dictionary-like object. """ if self._cookies is None: raw = self.headers.get('COOKIE', '') parsed = http.cookies.SimpleCookie(raw) self._cookies = MultiDict( {key: val.value for key, val in parsed.items()}) return self._cookies
def make_request(self, method, path, headers=MultiDict(), *, version=HttpVersion(1, 1), closing=False, keep_alive_timeout=15): self.app = mock.Mock() message = RawRequestMessage(method, path, version, headers, closing, False) self.payload = mock.Mock() self.transport = mock.Mock() self.writer = mock.Mock() req = Request(self.app, message, self.payload, self.transport, self.writer, keep_alive_timeout) return req
def test_ctor(self): req = self.make_request('GET', '/path/to?a=1&b=2') self.assertIs(self.app, req.app) self.assertEqual('GET', req.method) self.assertEqual(HttpVersion(1, 1), req.version) self.assertEqual(None, req.host) self.assertEqual('/path/to?a=1&b=2', req.path_qs) self.assertEqual('/path/to', req.path) self.assertEqual('a=1&b=2', req.query_string) self.assertEqual(MultiDict([('a', '1'), ('b', '2')]), req.GET) self.assertIs(self.payload, req.payload) self.assertTrue(req.keep_alive)
def test_handler_returns_not_response(self): app = web.Application(loop=self.loop) def handler(request): return 'abc' app.router.add_route('GET', '/', handler) h = app.make_handler()() message = RawRequestMessage('GET', '/', HttpVersion11, MultiDict(), False, False) payload = mock.Mock() with self.assertRaises(RuntimeError): self.loop.run_until_complete(h.handle_request(message, payload))
def test_HTTP_200_GET_MultiDict_PARAMS(self): with test_utils.run_server(self.loop, router=Functional) as httpd: r = self.loop.run_until_complete( client.request('get', httpd.url('method', 'get'), params=MultiDict([('q', 'test1'), ('q', 'test2')]), loop=self.loop)) content = self.loop.run_until_complete(r.content.read()) content = content.decode() self.assertIn('"query": "q=test1&q=test2"', content) self.assertEqual(r.status, 200) r.close()
def make_request(self, method, path, headers=MultiDict(), *, version=HttpVersion(1, 1), closing=False): self.app = mock.Mock() message = RawRequestMessage(method, path, version, headers, closing, False) self.payload = mock.Mock() self.writer = mock.Mock() req = Request(self.app, message, self.payload, self.writer) return req
def test_POST_MultiDict(self): with test_utils.run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') r = self.loop.run_until_complete( client.request('post', url, data=MultiDict([('q', 'test1'), ('q', 'test2')]), loop=self.loop)) self.assertEqual(r.status, 200) content = self.loop.run_until_complete(r.json()) self.assertEqual({'q': ['test1', 'test2']}, content['form']) self.assertEqual(r.status, 200) r.close()
def test_multidict_headers(self): with test_utils.run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') data = b'sample data' r = self.loop.run_until_complete( client.request( 'post', url, data=data, headers=MultiDict({'Content-Length': str(len(data))}), loop=self.loop)) content = self.loop.run_until_complete(r.json()) r.close() self.assertEqual(str(len(data)), content['headers']['Content-Length'])
def test_POST_FILES_IO_WITH_PARAMS(self): with test_utils.run_server(self.loop, router=Functional) as httpd: url = httpd.url('method', 'post') data = io.BytesIO(b'data') r = self.loop.run_until_complete( client.request('post', url, data=(('test', 'true'), MultiDict([('q', 't1'), ('q', 't2')]), data), loop=self.loop)) content = self.loop.run_until_complete(r.json()) self.assertEqual(4, len(content['multipart-data'])) self.assertEqual( { 'content-type': 'text/plain', 'data': 'true', 'name': 'test' }, content['multipart-data'][0]) self.assertEqual( { 'content-type': 'application/octet-stream', 'data': 'data', 'filename': 'unknown', 'filename*': "utf-8''unknown", 'name': 'unknown' }, content['multipart-data'][1]) self.assertEqual( { 'content-type': 'text/plain', 'data': 't1', 'name': 'q' }, content['multipart-data'][2]) self.assertEqual( { 'content-type': 'text/plain', 'data': 't2', 'name': 'q' }, content['multipart-data'][3]) self.assertEqual(r.status, 200) r.close()
def test_ctor(make_request, warning): req = make_request('GET', '/path/to?a=1&b=2') assert 'GET' == req.method assert HttpVersion(1, 1) == req.version assert req.host is None assert '/path/to?a=1&b=2' == req.path_qs assert '/path/to' == req.path assert 'a=1&b=2' == req.query_string get = req.GET assert MultiDict([('a', '1'), ('b', '2')]) == get # second call should return the same object assert get is req.GET with warning(DeprecationWarning): req.payload assert req.keep_alive
def test_ctor(self): req = self.make_request('GET', '/path/to?a=1&b=2') self.assertIs(self.app, req.app) self.assertEqual('GET', req.method) self.assertEqual(HttpVersion(1, 1), req.version) self.assertEqual(None, req.host) self.assertEqual('/path/to?a=1&b=2', req.path_qs) self.assertEqual('/path/to', req.path) self.assertEqual('a=1&b=2', req.query_string) get = req.GET self.assertEqual(MultiDict([('a', '1'), ('b', '2')]), get) # second call should return the same object self.assertIs(get, req.GET) self.assertIs(self.payload, req.payload) self.assertIs(self.transport, req.transport) self.assertTrue(req.keep_alive)
def handle_request(self, message, payload): response = aiohttp.Response( self.writer, 200, http_version=message.version) get_params = MultiDict(parse_qsl(urlparse(message.path).query)) if message.method == 'POST': post_params = yield from payload.read() else: post_params = None content = "<h1>It Works!</h1>" if get_params: content += "<h2>Get params</h2><p>" + str(get_params) + "</p>" if post_params: content += "<h2>Post params</h2><p>" + str(post_params) + "</p>" bcontent = content.encode('utf-8') response.add_header('Content-Type', 'text/html; charset=UTF-8') response.add_header('Content-Length', str(len(bcontent))) response.send_headers() response.write(bcontent) yield from response.write_eof()
def test_calc_content_type_on_getting_charset(self): req = self.make_request( 'Get', '/', MultiDict([('CONTENT-TYPE', 'text/html; charset=UTF-8')])) self.assertEqual('UTF-8', req.charset) self.assertEqual('text/html', req.content_type)
def test_merge_headers_with_multi_dict(create_session): session = create_session(headers={"h1": "header1", "h2": "header2"}) headers = session._prepare_headers(MultiDict([("h1", "h1")])) assert isinstance(headers, CIMultiDict) assert headers == CIMultiDict([("h2", "header2"), ("h1", "h1")])
def test_content_type_from_spec(self): req = self.make_request( 'Get', '/', MultiDict([('CONTENT-TYPE', 'application/json')])) self.assertEqual('application/json', req.content_type)
def test_content_type_from_spec_with_charset(self): req = self.make_request( 'Get', '/', MultiDict([('CONTENT-TYPE', 'text/html; charset=UTF-8')])) self.assertEqual('text/html', req.content_type) self.assertEqual('UTF-8', req.charset)
def test_content_length(self): req = self.make_request('Get', '/', MultiDict([('CONTENT-LENGTH', '123')])) self.assertEqual(123, req.content_length)
def make_dict(self, *args, **kwargs): return MultiDict(*args, **kwargs)