Merge pull request #245 from KeepSafe/multidict-error

Fix multidict error

Author: asvetlov

aiohttp/_multidict.pyx

@@ -198,22 +198,31 @@ cdef class MultiDict(_Base):
                             " ({} given)".format(name, len(args)))
 
         if args:
-            if hasattr(args[0], 'items'):
-                for item in args[0].items():
-                    key, value = item
-                    key = self._upper(key)
+            arg = args[0]
+            if isinstance(arg, _Base):
+                for item in (<_Base>arg)._items:
+                    key = self._upper(item[0])
+                    value = item[1]
+                    if do_add:
+                        self._add(key, value)
+                    else:
+                        self._replace(key, value)
+            elif hasattr(arg, 'items'):
+                for item in arg.items():
+                    key = self._upper(item[0])
+                    value = item[1]
                     if do_add:
                         self._add(key, value)
                     else:
                         self._replace(key, value)
             else:
-                for arg in args[0]:
-                    if not len(arg) == 2:
+                for i in arg:
+                    if not len(i) == 2:
                         raise TypeError(
                             "{} takes either dict or list of (key, value) "
                             "tuples".format(name))
-                    key, value = arg
-                    key = self._upper(key)
+                    key = self._upper(i[0])
+                    value = i[1]
                     if do_add:
                         self._add(key, value)
                     else:

aiohttp/errors.py

@@ -9,7 +9,7 @@
 
     'ClientError', 'ClientHttpProcessingError', 'ClientConnectionError',
     'ClientOSError', 'ClientTimeoutError', 'ProxyConnectionError',
-    'ClientRequestError', 'ClientResponseError', 'WebSocketDisconnectedError']
+    'ClientRequestError', 'ClientResponseError', 'WSClientDisconnectedError']
 
 from asyncio import TimeoutError
 
@@ -26,8 +26,8 @@ class ServerDisconnectedError(DisconnectedError):
     """Server disconnected."""
 
 
-class WebSocketDisconnectedError(ClientDisconnectedError):
-    """Raised on closing websocket by peer."""
+class WSClientDisconnectedError(ClientDisconnectedError):
+    """Raised on closing server websocket."""
 
     def __init__(self, code=None, message=None):
         super().__init__(code, message)

aiohttp/multidict.py

@@ -174,20 +174,26 @@ def _extend(self, args, kwargs, name, method):
             raise TypeError("{} takes at most 1 positional argument"
                             " ({} given)".format(name, len(args)))
         if args:
+            arg = args[0]
             if isinstance(args[0], _MultiDictProxy):
-                items = args[0].items()
+                items = arg._items
             elif isinstance(args[0], _MultiDict):
-                items = args[0].items()
-            elif hasattr(args[0], 'items'):
-                items = args[0].items()
+                items = arg._items
+            elif hasattr(arg, 'items'):
+                items = arg.items()
             else:
-                items = args[0]
-
-            for item in items:
-                method(*item)
-
-        for item in kwargs.items():
-            method(*item)
+                for item in arg:
+                    if not len(item) == 2:
+                        raise TypeError(
+                            "{} takes either dict or list of (key, value) "
+                            "tuples".format(name))
+                items = arg
+
+            for key, value in items:
+                method(key, value)
+
+        for key, value in kwargs.items():
+            method(key, value)
 
     def clear(self):
         """Remove all items from MultiDict"""

aiohttp/web.py

@@ -25,11 +25,11 @@
 from .server import ServerHttpProtocol
 from .streams import EOF_MARKER
 from .websocket import do_handshake, MSG_BINARY, MSG_CLOSE, MSG_PING, MSG_TEXT
-from .errors import HttpProcessingError, WebSocketDisconnectedError
+from .errors import HttpProcessingError, WSClientDisconnectedError
 
 
 __all__ = [
-    'WebSocketDisconnectedError',
+    'WSClientDisconnectedError',
     'Application',
     'HttpVersion',
     'RequestHandler',
@@ -831,14 +831,14 @@ def receive_msg(self):
 
             if msg.tp == MSG_CLOSE:
                 if self._closing:
-                    exc = WebSocketDisconnectedError(msg.data, msg.extra)
+                    exc = WSClientDisconnectedError(msg.data, msg.extra)
                     self._closing_fut.set_exception(exc)
                     raise exc
                 else:
                     self._closing = True
                     self._writer.close(msg.data, msg.extra)
                     yield from self.drain()
-                    exc = WebSocketDisconnectedError(msg.data, msg.extra)
+                    exc = WSClientDisconnectedError(msg.data, msg.extra)
                     self._closing_fut.set_exception(exc)
                     raise exc
             elif not self._closing:

examples/web_ws.py

@@ -5,7 +5,7 @@
 import asyncio
 import os
 from aiohttp.web import (Application, Response,
-                         WebSocketResponse, WebSocketDisconnectedError)
+                         WebSocketResponse, WSClientDisconnectedError)
 
 WS_FILE = os.path.join(os.path.dirname(__file__), 'websocket.html')
 
@@ -31,7 +31,7 @@ def wshandler(request):
             for ws in request.app['sockets']:
                 if ws is not resp:
                     ws.send_str(msg)
-    except WebSocketDisconnectedError:
+    except WSClientDisconnectedError:
         if resp not in request.app['sockets']:
             return resp
         request.app['sockets'].remove(resp)

tests/test_multidict.py

@@ -25,6 +25,8 @@ class _Root:
 
     proxy_cls = None
 
+    upstr_cls = None
+
     def test_exposed_names(self):
         name = self.cls.__name__
         while name.startswith('_'):
@@ -282,6 +284,16 @@ def test_get(self):
         self.assertEqual(1, d['a'])
 
 
+class _NonProxyCIMultiDict(_CIMultiDictTests):
+
+    def test_extend_with_upstr(self):
+        us = self.upstr_cls('a')
+        d = self.make_dict()
+
+        d.extend([(us, 'val')])
+        self.assertEqual([('A', 'val')], list(d.items()))
+
+
 class _TestProxy(_MultiDictTests):
 
     def make_dict(self, *args, **kwargs):
@@ -671,9 +683,11 @@ class PyMutableMultiDictTests(_BaseMutableMultiDictTests, unittest.TestCase):
     proxy_cls = _MultiDictProxy
 
 
-class PyCIMutableMultiDictTests(_CIMutableMultiDictTests, unittest.TestCase):
+class PyCIMutableMultiDictTests(_CIMutableMultiDictTests, _NonProxyCIMultiDict,
+                                unittest.TestCase):
 
     cls = _CIMultiDict
+    upstr_cls = _upstr
     proxy_cls = _CIMultiDictProxy
 
 
@@ -683,7 +697,7 @@ class TestMultiDictProxy(_TestProxy, unittest.TestCase):
     proxy_cls = MultiDictProxy
 
 
-class TestCIMultiDictProxt(_TestCIProxy, unittest.TestCase):
+class TestCIMultiDictProxy(_TestCIProxy, unittest.TestCase):
 
     cls = CIMultiDict
     proxy_cls = CIMultiDictProxy
@@ -695,9 +709,11 @@ class MutableMultiDictTests(_BaseMutableMultiDictTests, unittest.TestCase):
     proxy_cls = MultiDictProxy
 
 
-class CIMutableMultiDictTests(_CIMutableMultiDictTests, unittest.TestCase):
+class CIMutableMultiDictTests(_CIMutableMultiDictTests, _NonProxyCIMultiDict,
+                              unittest.TestCase):
 
     cls = CIMultiDict
+    upstr_cls = upstr
     proxy_cls = CIMultiDictProxy
 
 

tests/test_web_response.py

@@ -173,7 +173,7 @@ def test_force_compression_no_accept(self, ResponseImpl):
     def test_compression(self, ResponseImpl):
         req = self.make_request(
             'GET', '/',
-            headers=CIMultiDict({str(hdrs.ACCEPT_ENCODING): 'gzip, deflate'}))
+            headers=CIMultiDict({hdrs.ACCEPT_ENCODING: 'gzip, deflate'}))
         resp = StreamResponse()
         self.assertFalse(resp.chunked)
 

tests/test_web_websocket.py

@@ -3,7 +3,7 @@
 from unittest import mock
 from aiohttp import CIMultiDict
 from aiohttp.web import (Request, WebSocketResponse,
-                         WebSocketDisconnectedError,
+                         WSClientDisconnectedError,
                          HTTPMethodNotAllowed, HTTPBadRequest)
 from aiohttp.protocol import RawRequestMessage, HttpVersion11
 from aiohttp import websocket
@@ -145,7 +145,7 @@ def test_nested_exception(self):
 
         @asyncio.coroutine
         def a():
-            raise WebSocketDisconnectedError()
+            raise WSClientDisconnectedError()
 
         @asyncio.coroutine
         def b():
@@ -155,7 +155,7 @@ def b():
         def c():
             yield from b()
 
-        with self.assertRaises(WebSocketDisconnectedError):
+        with self.assertRaises(WSClientDisconnectedError):
             self.loop.run_until_complete(c())
 
     def test_can_start_ok(self):

tests/test_web_websocket_functional.py

@@ -92,7 +92,7 @@ def handler(request):
             ws.close()
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed.set_result(None)
             return ws
 
@@ -155,7 +155,7 @@ def handler(request):
 
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError as exc:
+            except web.WSClientDisconnectedError as exc:
                 self.assertEqual(1, exc.code)
                 self.assertEqual(b'exit message', exc.message)
                 closed.set_result(None)
@@ -185,7 +185,7 @@ def handler(request):
             ws.ping('data')
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError as exc:
+            except web.WSClientDisconnectedError as exc:
                 self.assertEqual(2, exc.code)
                 self.assertEqual(b'exit message', exc.message)
                 closed.set_result(None)
@@ -215,7 +215,7 @@ def handler(request):
 
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed.set_result(None)
                 raise
 
@@ -245,7 +245,7 @@ def handler(request):
             ws.pong('data')
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError as exc:
+            except web.WSClientDisconnectedError as exc:
                 self.assertEqual(2, exc.code)
                 self.assertEqual(b'exit message', exc.message)
                 closed.set_result(None)
@@ -318,7 +318,7 @@ def handler(request):
             ws.close()
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed.set_result(None)
             return ws
 
@@ -344,7 +344,7 @@ def handler(request):
             ws.start(request)
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed.set_result(None)
             return ws
 
@@ -370,7 +370,7 @@ def closer(ws):
             ws.close()
             try:
                 yield from ws.wait_closed()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed2.set_result(None)
 
         @asyncio.coroutine
@@ -380,7 +380,7 @@ def handler(request):
             asyncio.async(closer(ws), loop=request.app.loop)
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed.set_result(None)
             return ws
 
@@ -407,7 +407,7 @@ def handler(request):
             ws.close()
             try:
                 yield from ws.receive_str()
-            except web.WebSocketDisconnectedError:
+            except web.WSClientDisconnectedError:
                 closed.set_result(None)
             return ws