Make tests compatible with PyPy3.5-5.8.0 (#152)

* Add PyPy3.5-5.8.0 test env

* Move 3.6-dev + nightly to normal matrix in Travis

* Don't install mypy under PyPy implementation

* Don't run mypy under PyPy

* Exclude cython-specific tests under PyPy env

* Explicitly check for PyPy implementation

* Convert test_copy to be PyPy-dependent

* Tell flake8 to ignore E402 in certain cases

* PyPy-se test_guard

* Adjust test_pickle for PyPy

* Suppress flake8 E402 for test_guard

* Refactor cpython enabling logic w/ compat module

* Pick up _compat.USE_CYTHON within test modules

* Fix flake8 complaints about line length

.travis.yml

@@ -6,14 +6,20 @@ python:
 - 3.4
 - 3.5
 - &mainstream_python 3.6
+- 3.6-dev
+- nightly
 
 install:
 - &upgrade_python_toolset pip install --upgrade pip wheel setuptools
 - pip install -r requirements/ci.txt
 
 script:
 - flake8 multidict tests
-- make mypy
+- |
+    if python -c "import platform, sys; sys.exit(platform.python_implementation() == 'PyPy')"
+    then
+        make mypy
+    fi
 - pytest --cov=multidict tests
 - python setup.py check -rm
 - if python -c "import sys; sys.exit(sys.version_info < (3,6))"; then
@@ -58,13 +64,11 @@ os: linux
 
 jobs:
   fast_finish: true
-  allow_failures:
-  - python: 3.6-dev
-  - python: nightly
 
   include:
-  - python: 3.6-dev
-  - python: nightly
+  - python: pypy3.5-5.8.0
+    env:
+    - MULTIDICT_NO_EXTENSIONS=X
 
   - <<: *_doc_base
     script:

multidict/__init__.py

@@ -5,30 +5,26 @@
 several values for the same key.
 """
 
-import os
+from ._compat import USE_CYTHON_EXTENSIONS
+
 
 __all__ = ('MultiDictProxy', 'CIMultiDictProxy',
            'MultiDict', 'CIMultiDict', 'upstr', 'istr')
 
 __version__ = '3.2.0'
 
 
-if bool(os.environ.get('MULTIDICT_NO_EXTENSIONS')):
+try:
+    if not USE_CYTHON_EXTENSIONS:
+        raise ImportError
+    from ._multidict import (MultiDictProxy,
+                             CIMultiDictProxy,
+                             MultiDict,
+                             CIMultiDict,
+                             upstr, istr)
+except ImportError:  # pragma: no cover
     from ._multidict_py import (MultiDictProxy,
                                 CIMultiDictProxy,
                                 MultiDict,
                                 CIMultiDict,
                                 upstr, istr)
-else:
-    try:
-        from ._multidict import (MultiDictProxy,
-                                 CIMultiDictProxy,
-                                 MultiDict,
-                                 CIMultiDict,
-                                 upstr, istr)
-    except ImportError:  # pragma: no cover
-        from ._multidict_py import (MultiDictProxy,
-                                    CIMultiDictProxy,
-                                    MultiDict,
-                                    CIMultiDict,
-                                    upstr, istr)

multidict/_compat.py

@@ -0,0 +1,9 @@
+import os
+import platform
+
+
+NO_EXTENSIONS = bool(os.environ.get('MULTIDICT_NO_EXTENSIONS'))
+
+PYPY = platform.python_implementation() == 'PyPy'
+
+USE_CYTHON_EXTENSIONS = USE_CYTHON = not NO_EXTENSIONS and not PYPY

requirements/ci.txt

@@ -7,7 +7,7 @@ sphinx==1.6.4
 alabaster>=0.6.2
 pytest-cov==2.5.1
 pygments==2.2.0
-mypy==0.521; python_version>="3.5" or platform_system != "Windows"
+mypy==0.521; (python_version>="3.5" or platform_system != "Windows") and platform_python_implementation != "PyPy"
 git+git://github.com/python/mypy.git@b6bcdc0; python_version<"3.5" and platform_system == "Windows"
 -e .
 

tests/test_copy.py

@@ -1,28 +1,75 @@
 import copy
+
 import pytest
 
-from multidict._multidict import (MultiDict, CIMultiDict,
-                                  MultiDictProxy, CIMultiDictProxy)
-from multidict._multidict_py import (MultiDict as PyMultiDict,
+from multidict._compat import USE_CYTHON
+
+if USE_CYTHON:
+    from multidict._multidict import (MultiDict, CIMultiDict,
+                                      MultiDictProxy, CIMultiDictProxy)
+
+from multidict._multidict_py import (MultiDict as PyMultiDict,  # noqa: E402
                                      CIMultiDict as PyCIMultiDict,
                                      MultiDictProxy as PyMultiDictProxy,
                                      CIMultiDictProxy as PyCIMultiDictProxy)
 
 
-@pytest.fixture(params=[MultiDict, PyMultiDict,
-                        CIMultiDict, PyCIMultiDict],
-                ids=['MultiDict', 'PyMultiDict',
-                     'CIMultiDict', 'PyCIMultiDict'])
+@pytest.fixture(
+    params=(
+        [
+            MultiDict,
+            CIMultiDict,
+        ]
+        if USE_CYTHON else
+        []
+    ) +
+    [
+        PyMultiDict,
+        PyCIMultiDict
+    ],
+    ids=(
+        [
+            'MultiDict',
+            'CIMultiDict',
+        ]
+        if USE_CYTHON else
+        []
+    ) +
+    [
+        'PyMultiDict',
+        'PyCIMultiDict'
+    ]
+)
 def cls(request):
     return request.param
 
 
-@pytest.fixture(params=[(MultiDictProxy, MultiDict),
-                        (PyMultiDictProxy, PyMultiDict),
-                        (CIMultiDictProxy, CIMultiDict),
-                        (PyCIMultiDictProxy, PyCIMultiDict)],
-                ids=['MultiDictProxy', 'PyMultiDictProxy',
-                     'CIMultiDictProxy', 'PyCIMultiDictProxy'])
+@pytest.fixture(
+    params=(
+        [
+            (MultiDictProxy, MultiDict),
+            (CIMultiDictProxy, CIMultiDict),
+        ]
+        if USE_CYTHON else
+        []
+    ) +
+    [
+        (PyMultiDictProxy, PyMultiDict),
+        (PyCIMultiDictProxy, PyCIMultiDict),
+    ],
+    ids=(
+        [
+            'MultiDictProxy',
+            'CIMultiDictProxy',
+        ]
+        if USE_CYTHON else
+        []
+    ) +
+    [
+        'PyMultiDictProxy',
+        'PyCIMultiDictProxy'
+    ]
+)
 def proxy_classes(request):
     return request.param
 

tests/test_guard.py

@@ -1,11 +1,15 @@
 import pytest
 
-from multidict._multidict import MultiDict
-from multidict._multidict_py import MultiDict as PyMultiDict
+from multidict._compat import USE_CYTHON
 
+if USE_CYTHON:
+    from multidict._multidict import MultiDict
 
-@pytest.fixture(params=[MultiDict, PyMultiDict],
-                ids=['MultiDict', 'PyMultiDict'])
+from multidict._multidict_py import MultiDict as PyMultiDict  # noqa: E402
+
+
+@pytest.fixture(params=([MultiDict] if USE_CYTHON else []) + [PyMultiDict],
+                ids=(['MultiDict'] if USE_CYTHON else []) + ['PyMultiDict'])
 def cls(request):
     return request.param
 

tests/test_istr.py

@@ -1,9 +1,15 @@
-from multidict._multidict import istr
-from multidict._multidict_py import istr as _istr
 import gc
 import sys
+
 import psutil
 
+from multidict._compat import USE_CYTHON
+
+if USE_CYTHON:
+    from multidict._multidict import istr
+
+from multidict._multidict_py import istr as _istr  # noqa: E402
+
 
 class IStrMixin:
 
@@ -79,5 +85,6 @@ def test_leak(self):
             assert rss_diff == 0
 
 
-class TestIStr(IStrMixin):
-    cls = istr
+if USE_CYTHON:
+    class TestIStr(IStrMixin):
+        cls = istr

tests/test_multidict.py

@@ -2,16 +2,25 @@
 import unittest
 
 import multidict
-from multidict._multidict import (MultiDictProxy,
-                                  MultiDict,
-                                  CIMultiDictProxy,
-                                  CIMultiDict,
-                                  istr)
-from multidict._multidict_py import (MultiDictProxy as _MultiDictProxy,
-                                     MultiDict as _MultiDict,
-                                     CIMultiDictProxy as _CIMultiDictProxy,
-                                     CIMultiDict as _CIMultiDict,
-                                     istr as _istr)
+
+from multidict._compat import USE_CYTHON
+
+if USE_CYTHON:
+    from multidict._multidict import (
+        MultiDictProxy,
+        MultiDict,
+        CIMultiDictProxy,
+        CIMultiDict,
+        istr
+    )
+
+from multidict._multidict_py import (  # noqa: E402
+    MultiDictProxy as _MultiDictProxy,
+    MultiDict as _MultiDict,
+    CIMultiDictProxy as _CIMultiDictProxy,
+    CIMultiDict as _CIMultiDict,
+    istr as _istr
+)
 
 
 class _Root:
@@ -616,10 +625,11 @@ def test_nonstr_key(self):
         with self.assertRaises(TypeError):
             d[1] = 'val'
 
-    def test_istr_key(self):
-        d = self.make_dict()
-        d[istr('1')] = 'val'
-        self.assertIs(type(list(d.keys())[0]), str)
+    if USE_CYTHON:
+        def test_istr_key(self):
+            d = self.make_dict()
+            d[istr('1')] = 'val'
+            self.assertIs(type(list(d.keys())[0]), str)
 
     def test_str_derived_key(self):
         class A(str):
@@ -835,20 +845,22 @@ def test_update(self):
 
         self.assertEqual([('Key', 'val'), ('key2', 'val3')], list(d.items()))
 
-    def test_update_istr(self):
-        d = self.make_dict()
-        d.add(istr('KEY'), 'val1')
-        d.add('key', 'val2')
-        d.add('key2', 'val3')
+    if USE_CYTHON:
+        def test_update_istr(self):
+            d = self.make_dict()
+            d.add(istr('KEY'), 'val1')
+            d.add('key', 'val2')
+            d.add('key2', 'val3')
 
-        d.update({istr('key'): 'val'})
+            d.update({istr('key'): 'val'})
 
-        self.assertEqual([('Key', 'val'), ('key2', 'val3')], list(d.items()))
+            self.assertEqual([('Key', 'val'), ('key2', 'val3')],
+                             list(d.items()))
 
-    def test_copy_istr(self):
-        d = self.make_dict({istr('Foo'): 'bar'})
-        d2 = d.copy()
-        self.assertEqual(d, d2)
+        def test_copy_istr(self):
+            d = self.make_dict({istr('Foo'): 'bar'})
+            d2 = d.copy()
+            self.assertEqual(d, d2)
 
     def test_eq(self):
         d1 = self.make_dict(Key='val')
@@ -887,34 +899,39 @@ class PyCIMutableMultiDictTests(_CIMutableMultiDictTests, _NonProxyCIMultiDict,
     key_cls = istr_cls
 
 
-class TestMultiDictProxy(_TestProxy, unittest.TestCase):
+if USE_CYTHON:
+    class TestMultiDictProxy(_TestProxy, unittest.TestCase):
 
-    cls = MultiDict
-    proxy_cls = MultiDictProxy
-    key_cls = str
+        cls = MultiDict
+        proxy_cls = MultiDictProxy
+        key_cls = str
 
 
-class TestCIMultiDictProxy(_TestCIProxy, unittest.TestCase):
+if USE_CYTHON:
+    class TestCIMultiDictProxy(_TestCIProxy, unittest.TestCase):
 
-    cls = CIMultiDict
-    proxy_cls = CIMultiDictProxy
-    key_cls = istr
+        cls = CIMultiDict
+        proxy_cls = CIMultiDictProxy
+        key_cls = istr
 
 
-class MutableMultiDictTests(_BaseMutableMultiDictTests, unittest.TestCase):
+if USE_CYTHON:
+    class MutableMultiDictTests(_BaseMutableMultiDictTests, unittest.TestCase):
 
-    cls = MultiDict
-    proxy_cls = MultiDictProxy
-    key_cls = str
+        cls = MultiDict
+        proxy_cls = MultiDictProxy
+        key_cls = str
 
 
-class CIMutableMultiDictTests(_CIMutableMultiDictTests, _NonProxyCIMultiDict,
-                              unittest.TestCase):
+if USE_CYTHON:
+    class CIMutableMultiDictTests(_CIMutableMultiDictTests,
+                                  _NonProxyCIMultiDict,
+                                  unittest.TestCase):
 
-    cls = CIMultiDict
-    istr_cls = istr
-    proxy_cls = CIMultiDictProxy
-    key_cls = istr_cls
+        cls = CIMultiDict
+        istr_cls = istr
+        proxy_cls = CIMultiDictProxy
+        key_cls = istr_cls
 
 
 class TypesMixin:
@@ -974,9 +991,10 @@ class TestPyTypes(TypesMixin, unittest.TestCase):
     cimdict = _CIMultiDict
 
 
-class TestTypes(TypesMixin, unittest.TestCase):
+if USE_CYTHON:
+    class TestTypes(TypesMixin, unittest.TestCase):
 
-    proxy = MultiDictProxy
-    ciproxy = CIMultiDictProxy
-    mdict = MultiDict
-    cimdict = CIMultiDict
+        proxy = MultiDictProxy
+        ciproxy = CIMultiDictProxy
+        mdict = MultiDict
+        cimdict = CIMultiDict