Fix multidict coverage

Author: asvetlov

.coveragerc

@@ -6,6 +6,7 @@ omit = site-packages
 [report]
 exclude_lines =
     @abc.
+    pragma: no cover
 
 [html]
 directory = coverage

aiohttp/_multidict.pyx

@@ -15,10 +15,8 @@ class upstr(str):
             val = str(val, encoding, errors)
         elif isinstance(val, str):
             pass
-        elif hasattr(val, '__str__'):
-            val = val.__str__()
         else:
-            val = repr(val)
+            val = str(val)
         val = val.upper()
         return str.__new__(cls, val)
 
@@ -109,53 +107,30 @@ cdef class _Base:
         body = ', '.join("'{}': {!r}".format(k, v) for k, v in self.items())
         return '<{} {{{}}}>'.format(self.__class__.__name__, body)
 
-
-
-
-
-cdef class MultiDictProxy(_Base):
-
-    def __init__(self, arg):
-        cdef MultiDict mdict
-        if not isinstance(arg, MultiDict):
-            raise TypeError(
-                'MultiDictProxy requires MultiDict instance, not {}'.format(
-                    type(arg)))
-
-        mdict = arg
-        self._items = mdict._items
-
-    def copy(self):
-        return MultiDict(self._items)
-
     def __richcmp__(self, other, op):
-        cdef MultiDictProxy typed_self = self
-        cdef MultiDictProxy typed_other
+        cdef _Base typed_self
+        cdef _Base typed_other
         cdef tuple item
         if op == 2:
-            if isinstance(other, MultiDictProxy):
-                typed_other = other
-                return typed_self._items == typed_other._items
-            elif isinstance(other, MultiDict):
+            if isinstance(self, _Base) and isinstance(other, _Base):
+                typed_self = self
                 typed_other = other
                 return typed_self._items == typed_other._items
             elif not isinstance(other, abc.Mapping):
                 return NotImplemented
-            for item in typed_self._items:
+            for item in self.items():
                 nv = other.get(item[0], _marker)
                 if item[1] != nv:
                     return False
             return True
         elif op != 2:
-            if isinstance(other, MultiDictProxy):
+            if isinstance(self, _Base) and isinstance(other, _Base):
+                typed_self = self
                 typed_other = other
                 return typed_self._items != typed_other._items
-            elif isinstance(other, MultiDict):
-                typed_other = other
-                return typed_self._items == typed_other._items
             elif not isinstance(other, abc.Mapping):
                 return NotImplemented
-            for item in typed_self._items:
+            for item in self.items():
                 nv = other.get(item[0], _marker)
                 if item[1] == nv:
                     return True
@@ -164,6 +139,21 @@ cdef class MultiDictProxy(_Base):
             return NotImplemented
 
 
+cdef class MultiDictProxy(_Base):
+
+    def __init__(self, arg):
+        cdef MultiDict mdict
+        if not isinstance(arg, MultiDict):
+            raise TypeError(
+                'MultiDictProxy requires MultiDict instance, not {}'.format(
+                    type(arg)))
+
+        mdict = arg
+        self._items = mdict._items
+
+    def copy(self):
+        return MultiDict(self._items)
+
 abc.Mapping.register(MultiDictProxy)
 
 
@@ -322,36 +312,6 @@ cdef class MultiDict(_Base):
     def update(self, *args, **kwargs):
         self._extend(args, kwargs, "update", 0)
 
-    def __richcmp__(self, other, op):
-        cdef MultiDict typed_self = self
-        cdef MultiDict typed_other
-        cdef tuple item
-        if op == 2:
-            if isinstance(other, MultiDict):
-                typed_other = other
-                return typed_self._items == typed_other._items
-            elif not isinstance(other, abc.Mapping):
-                return NotImplemented
-            for item in typed_self._items:
-                nv = other.get(item[0], _marker)
-                if item[1] != nv:
-                    return False
-            return True
-        elif op != 2:
-            if isinstance(other, MultiDict):
-                typed_other = other
-                return typed_self._items == typed_other._items
-            elif not isinstance(other, abc.Mapping):
-                return NotImplemented
-            for item in typed_self._items:
-                nv = other.get(item[0], _marker)
-                if item[1] == nv:
-                    return True
-            return False
-        else:
-            return NotImplemented
-
-
 
 abc.MutableMapping.register(MultiDict)
 

aiohttp/multidict.py

@@ -16,10 +16,8 @@ def __new__(cls, val='',
             val = str(val, encoding, errors)
         elif isinstance(val, str):
             pass
-        elif hasattr(val, '__str__'):
-            val = val.__str__()
         else:
-            val = repr(val)
+            val = str(val)
         val = val.upper()
         return str.__new__(cls, val)
 
@@ -79,9 +77,7 @@ def values(self):
     def __eq__(self, other):
         if not isinstance(other, abc.Mapping):
             return NotImplemented
-        if isinstance(other, _MultiDictProxy):
-            return self._items == other._items
-        elif isinstance(other, _MultiDict):
+        if isinstance(other, _Base):
             return self._items == other._items
         for k, v in self.items():
             nv = other.get(k, _marker)
@@ -200,11 +196,7 @@ def clear(self):
     # Mapping interface #
 
     def __setitem__(self, key, value):
-        try:
-            del self[key]
-        except KeyError:
-            pass
-        self._items.append((key, value))
+        self._replace(key, value)
 
     def __delitem__(self, key):
         items = self._items
@@ -327,7 +319,7 @@ def __iter__(self):
                              MultiDict,
                              CIMultiDict,
                              upstr)
-except ImportError:
+except ImportError:  # pragma: no cover
     MultiDictProxy = _MultiDictProxy
     CIMultiDictProxy = _CIMultiDictProxy
     MultiDict = _MultiDict

tests/test_multidict.py

@@ -395,6 +395,15 @@ def test_extend(self):
         with self.assertRaises(TypeError):
             d.extend('foo', 'bar')
 
+    def test_extend_from_proxy(self):
+        d = self.make_dict([('a', 'a'), ('b', 'b')])
+        proxy = self.proxy_cls(d)
+
+        d2 = self.make_dict()
+        d2.extend(proxy)
+
+        self.assertEqual([('a', 'a'), ('b', 'b')], list(d2.items()))
+
     def test_clear(self):
         d = self.make_dict([('key', 'one')], key='two', foo='bar')
 
@@ -564,6 +573,15 @@ def test_extend(self):
         with self.assertRaises(TypeError):
             d.extend('foo', 'bar')
 
+    def test_extend_from_proxy(self):
+        d = self.make_dict([('a', 'a'), ('b', 'b')])
+        proxy = self.proxy_cls(d)
+
+        d2 = self.make_dict()
+        d2.extend(proxy)
+
+        self.assertEqual([('A', 'a'), ('B', 'b')], list(d2.items()))
+
     def test_clear(self):
         d = self.make_dict([('KEY', 'one')], key='two', foo='bar')
 
@@ -650,11 +668,13 @@ class TestPyCIMultiDictProxy(_TestCIProxy, unittest.TestCase):
 class PyMutableMultiDictTests(_BaseMutableMultiDictTests, unittest.TestCase):
 
     cls = _MultiDict
+    proxy_cls = _MultiDictProxy
 
 
 class PyCIMutableMultiDictTests(_CIMutableMultiDictTests, unittest.TestCase):
 
     cls = _CIMultiDict
+    proxy_cls = _CIMultiDictProxy
 
 
 class TestMultiDictProxy(_TestProxy, unittest.TestCase):
@@ -672,11 +692,13 @@ class TestCIMultiDictProxt(_TestCIProxy, unittest.TestCase):
 class MutableMultiDictTests(_BaseMutableMultiDictTests, unittest.TestCase):
 
     cls = MultiDict
+    proxy_cls = MultiDictProxy
 
 
 class CIMutableMultiDictTests(_CIMutableMultiDictTests, unittest.TestCase):
 
     cls = CIMultiDict
+    proxy_cls = CIMultiDictProxy
 
 
 class _UpStrMixin:
@@ -707,14 +729,6 @@ def test_upper(self):
         s = self.cls('a')
         self.assertIs(s, s.upper())
 
-    def test_upstr_is_not_str(self):
-
-        class A:
-            def __repr__(self):
-                return '<A repr>'
-
-        self.assertEqual('<A REPR>', self.cls(A()))
-
 
 class TestPyUpStr(_UpStrMixin, unittest.TestCase):
 
@@ -742,6 +756,24 @@ def test_proxy_not_inherited_from_dict(self):
     def test_dict_not_inherited_from_proxy(self):
         self.assertFalse(issubclass(self.mdict, self.proxy))
 
+    def test_create_multidict_proxy_from_nonmultidict(self):
+        with self.assertRaises(TypeError):
+            self.proxy({})
+
+    def test_create_multidict_proxy_from_cimultidict(self):
+        d = self.cimdict(key='val')
+        p = self.proxy(d)
+        self.assertEqual(p, d)
+
+    def test_create_cimultidict_proxy_from_nonmultidict(self):
+        with self.assertRaises(TypeError):
+            self.ciproxy({})
+
+    def test_create_ci_multidict_proxy_from_multidict(self):
+        d = self.mdict(key='val')
+        with self.assertRaises(TypeError):
+            self.ciproxy(d)
+
 
 class TestPyTypes(TypesMixin, unittest.TestCase):