Increment version to v2.1.0 and add Python2.x deprecation warning (#458)

* Increment version and add Python2.x deprecation warning

Change test to actually test no warnings when on python3

flake8 compliant

* fix development status classifier

.codecov.yml

@@ -0,0 +1,7 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 75
+        # Allow 0% coverage regression
+        threshold: 0

.gitignore

@@ -1,9 +1,13 @@
 *.pyc
 .tox
+.cache
+.pytest_cache/
 build/
 dist/
 *.egg/
 .coverage
+coverage.xml
+htmlcov/
 *.egg-info/
 pytestdebug.log
 

.travis.yml

@@ -1,48 +1,62 @@
 language: python
-sudo: false
 before_install: openssl version
 env:
-  global:
-    - secure: AifoKzwhjV94cmcQZrdQmqRu/9rkZZvWpwBv1daeAQpLOKFPGsOm3D+x2cSw9+iCfkgDZDfqQVv1kCaFVxTll8v8jTq5SJdqEY0NmGWbj/UkNtShh609oRDsuzLxAEwtVKYjf/h8K2BRea+bl1tGkwZ2vtmYS6dxNlAijjWOfds=
-    - secure: LBSEg/gMj4u4Hrpo3zs6Y/1mTpd2RtcN49mZIFgTdbJ9IhpiNPqcEt647Lz94F9Eses2x2WbNuKqZKZZReY7QLbEzU1m0nN5jlaKrjcG5NR5clNABfFFyhgc0jBikyS4abAG8jc2efeaTrFuQwdoF4sE8YiVrkiVj2X5Xoi6sBk=
+  # global:
+    # - secure: AifoKzwhjV94cmcQZrdQmqRu/9rkZZvWpwBv1daeAQpLOKFPGsOm3D+x2cSw9+iCfkgDZDfqQVv1kCaFVxTll8v8jTq5SJdqEY0NmGWbj/UkNtShh609oRDsuzLxAEwtVKYjf/h8K2BRea+bl1tGkwZ2vtmYS6dxNlAijjWOfds=
+    # - secure: LBSEg/gMj4u4Hrpo3zs6Y/1mTpd2RtcN49mZIFgTdbJ9IhpiNPqcEt647Lz94F9Eses2x2WbNuKqZKZZReY7QLbEzU1m0nN5jlaKrjcG5NR5clNABfFFyhgc0jBikyS4abAG8jc2efeaTrFuQwdoF4sE8YiVrkiVj2X5Xoi6sBk=
   matrix:
     - TOX_SUFFIX="flakes"
-    - TOX_SUFFIX="requests22"
-    - TOX_SUFFIX="requests23"
-    - TOX_SUFFIX="requests24"
-    - TOX_SUFFIX="requests25"
-    - TOX_SUFFIX="requests26"
-    - TOX_SUFFIX="requests27"
-    - TOX_SUFFIX="requests1"
+    - TOX_SUFFIX="requests"
     - TOX_SUFFIX="httplib2"
-    - TOX_SUFFIX="boto"
-    - TOX_SUFFIX="urllib317"
-    - TOX_SUFFIX="urllib319"
-    - TOX_SUFFIX="urllib3110"
-    - TOX_SUFFIX="tornado3"
+    - TOX_SUFFIX="boto3"
+    - TOX_SUFFIX="urllib3"
     - TOX_SUFFIX="tornado4"
+    - TOX_SUFFIX="aiohttp"
 matrix:
+  include:
+    - env: TOX_SUFFIX="flakes"
+      python: 3.7
+      dist: xenial
+    - env: TOX_SUFFIX="requests"
+      python: 3.7
+      dist: xenial
+    - env: TOX_SUFFIX="httplib2"
+      python: 3.7
+      dist: xenial
+    - env: TOX_SUFFIX="urllib3"
+      python: 3.7
+      dist: xenial
+    - env: TOX_SUFFIX="tornado4"
+      python: 3.7
+      dist: xenial
+    - env: TOX_SUFFIX="aiohttp"
+      python: 3.7
+      dist: xenial
   allow_failures:
-    - env: TOX_SUFFIX="boto"
+    - env: TOX_SUFFIX="aiohttp"
+      python: "pypy3.5-5.9.0"
   exclude:
-    - env: TOX_SUFFIX="boto"
-      python: 3.3
-    - env: TOX_SUFFIX="boto"
-      python: 3.4
-    - env: TOX_SUFFIX="requests1"
-      python: 3.4
-    - env: TOX_SUFFIX="requests1"
+    # Only run flakes on a single Python 2.x and a single 3.x
+    - env: TOX_SUFFIX="flakes"
       python: 3.5
+    - env: TOX_SUFFIX="flakes"
+      python: pypy
+    - env: TOX_SUFFIX="flakes"
+      python: "pypy3.5-5.9.0"
+    - env: TOX_SUFFIX="aiohttp"
+      python: 2.7
+    - env: TOX_SUFFIX="aiohttp"
+      python: pypy
 python:
-- 2.6
 - 2.7
-- 3.3
-- 3.4
 - 3.5
+- 3.6
 - pypy
-- pypy3
+- "pypy3.5-5.9.0"
 install:
-- pip install tox-travis
+- pip install tox-travis codecov
 - if [[ $TOX_SUFFIX != 'flakes' ]]; then python setup.py install ; fi
 script:
 - tox -e "${TOX_SUFFIX}"
+after_success:
+  - codecov

README.rst

@@ -1,4 +1,4 @@
-|PyPI| |Build Status| |Waffle Ready| |Gitter|
+|PyPI| |Python versions| |Build Status| |CodeCov| |Gitter| 
 
 VCR.py
 ======
@@ -13,7 +13,7 @@ Source code
   https://github.com/kevin1024/vcrpy
 
 Documentation
-  https://vcrpy.readthedocs.org/
+  https://vcrpy.readthedocs.io/
 
 Rationale
 ---------
@@ -48,11 +48,15 @@ This library uses the MIT license. See `LICENSE.txt <LICENSE.txt>`__ for
 more details
 
 .. |PyPI| image:: https://img.shields.io/pypi/v/vcrpy.svg
-   :target: https://pypi.python.org/pypi/vcrpy-unittest
-.. |Build Status| image:: https://secure.travis-ci.org/kevin1024/vcrpy.png?branch=master
+   :target: https://pypi.python.org/pypi/vcrpy
+.. |Python versions| image:: https://img.shields.io/pypi/pyversions/vcrpy.svg
+   :target: https://pypi.python.org/pypi/vcrpy
+.. |Build Status| image:: https://secure.travis-ci.org/kevin1024/vcrpy.svg?branch=master
    :target: http://travis-ci.org/kevin1024/vcrpy
-.. |Waffle Ready| image:: https://badge.waffle.io/kevin1024/vcrpy.png?label=ready&title=waffle
-   :target: https://waffle.io/kevin1024/vcrpy
 .. |Gitter| image:: https://badges.gitter.im/Join%20Chat.svg
    :alt: Join the chat at https://gitter.im/kevin1024/vcrpy
    :target: https://gitter.im/kevin1024/vcrpy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+.. |CodeCov| image:: https://codecov.io/gh/kevin1024/vcrpy/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/kevin1024/vcrpy
+   :alt: Code Coverage Status
+   

docs/advanced.rst

@@ -97,8 +97,12 @@ Create your own method with the following signature
 
     def my_matcher(r1, r2):
 
-Your method receives the two requests and must return ``True`` if they
-match, ``False`` if they don't.
+Your method receives the two requests and can return :
+
+- Use an ``assert`` statement in the matcher, then we have ``None`` if they match, raise an `AssertionError`` if they don't.
+- A boolean, ``True`` if they match, ``False`` if they don't.
+
+Note : You should use an ``assert`` statement in order to have feedback when a matcher is failing.
 
 Finally, register your method with VCR to use your new request matcher.
 
@@ -107,7 +111,7 @@ Finally, register your method with VCR to use your new request matcher.
     import vcr
 
     def jurassic_matcher(r1, r2):
-        return r1.uri == r2.uri and 'JURASSIC PARK' in r1.body
+        assert r1.uri == r2.uri and 'JURASSIC PARK' in r1.body
 
     my_vcr = vcr.VCR()
     my_vcr.register_matcher('jurassic', jurassic_matcher)
@@ -122,6 +126,27 @@ Finally, register your method with VCR to use your new request matcher.
     with my_vcr.use_cassette('test.yml'):
         # your http here
 
+Register your own cassette persister
+------------------------------------
+
+Create your own persistence class, see the :ref:`persister_example`.
+
+Your custom persister must implement both ``load_cassette`` and ``save_cassette``
+methods.  The ``load_cassette`` method must return a deserialized cassette or raise
+ ``ValueError`` if no cassette is found.
+
+Once the persister class is defined, register with VCR like so...
+
+.. code:: python
+
+    import vcr
+    my_vcr = vcr.VCR()
+
+    class CustomerPersister(object):
+        # implement Persister methods...
+
+    my_vcr.register_persister(CustomPersister)
+
 Filter sensitive data from the request
 --------------------------------------
 
@@ -200,24 +225,25 @@ Custom Request filtering
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 If none of these covers your request filtering needs, you can register a
-callback that will manipulate the HTTP request before adding it to the
-cassette. Use the ``before_record`` configuration option to so this.
-Here is an example that will never record requests to the /login
-endpoint.
+callback with the ``before_record_request`` configuration option to
+manipulate the HTTP request before adding it to the cassette, or return
+``None`` to ignore it entirely. Here is an example that will never record
+requests to the ``'/login'`` path:
 
 .. code:: python
 
     def before_record_cb(request):
-        if request.path != '/login':
-            return request
+        if request.path == '/login':
+            return None
+        return request
 
     my_vcr = vcr.VCR(
-        before_record = before_record_cb,
+        before_record_request=before_record_cb,
     )
     with my_vcr.use_cassette('test.yml'):
         # your http code here
 
-You can also mutate the response using this callback. For example, you
+You can also mutate the request using this callback. For example, you
 could remove all query parameters from any requests to the ``'/login'``
 path.
 
@@ -225,11 +251,11 @@ path.
 
     def scrub_login_request(request):
         if request.path == '/login':
-            request.uri, _ =  urllib.splitquery(response.uri)
+            request.uri, _ =  urllib.splitquery(request.uri)
         return request
 
     my_vcr = vcr.VCR(
-        before_record=scrub_login_request,
+        before_record_request=scrub_login_request,
     )
     with my_vcr.use_cassette('test.yml'):
         # your http code here
@@ -237,9 +263,12 @@ path.
 Custom Response Filtering
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-VCR.py also suports response filtering with the
-``before_record_response`` keyword argument. It's usage is similar to
-that of ``before_record``:
+You can also do response filtering with the
+``before_record_response`` configuration option. Its usage is
+similar to the above ``before_record_request`` - you can
+mutate the response, or return ``None`` to avoid recording
+the request and response altogether. For example to hide
+sensitive data from the request body:
 
 .. code:: python
 
@@ -281,8 +310,8 @@ in a few ways:
    or 0.0.0.0.
 -  Set the ``ignore_hosts`` configuration option to a list of hosts to
    ignore
--  Add a ``before_record`` callback that returns None for requests you
-   want to ignore
+-  Add a ``before_record_request`` or ``before_record_response`` callback
+   that returns ``None`` for requests you want to ignore (see above).
 
 Requests that are ignored by VCR will not be saved in a cassette, nor
 played back from a cassette. VCR will completely ignore those requests
@@ -343,3 +372,16 @@ cassette names, use ``VCR.ensure_suffix`` as follows:
 
     @my_vcr.use_cassette
     def my_test_function():
+
+Rewind Cassette
+---------------
+
+VCR.py allows to rewind a cassette in order to replay it inside the same function/test.
+
+.. code:: python
+
+    with vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml') as cass:
+        response = urllib2.urlopen('http://www.zombo.com/').read()
+        assert cass.all_played
+        a.rewind()
+        assert not cass.all_played

docs/changelog.rst

@@ -1,5 +1,44 @@
 Changelog
 ---------
+-  2.1.1 (UNRELEASED)
+-  2.1.0 - Add a `rewind` method to reset a cassette (thanks @khamidou)
+   New error message with more details on why the cassette failed to play a request (thanks @arthurHamon2, @neozenith)
+   Handle connect tunnel URI (thanks @jeking3)
+   Add code coverage to the project (thanks @neozenith)
+   Drop support to python 3.4
+   Add deprecation warning on python 2.7, next major release will drop python 2.7 support
+   Fix build problems on requests tests (thanks to @dunossauro)
+   Fix matching on 'body' failing when Unicode symbols are present in them (thanks @valgur)
+   Fix bugs on aiohttp integration (thanks @graingert, @steinnes, @stj, @lamenezes, @lmazuel)
+   Fix Biopython incompatibility (thanks @rishab121)
+   Fix Boto3 integration (thanks @1oglop1, @arthurHamon2)
+-  2.0.1 - Fix bug when using vcrpy with python 3.4
+-  2.0.0 - Support python 3.7 (fix httplib2 and urllib2, thanks @felixonmars)
+   [#356] Fixes `before_record_response` so the original response isn't changed (thanks @kgraves)
+   Fix requests stub when using proxy (thanks @samuelfekete @daneoshiga)
+   (only for aiohttp stub) Drop support to python 3.4 asyncio.coroutine (aiohttp doesn't support python it anymore)
+   Fix aiohttp stub to work with aiohttp client (thanks @stj)
+   Fix aiohttp stub to accept content type passed
+   Improve docs (thanks @adamchainz)
+-  1.13.0 - Fix support to latest aiohttp version (3.3.2). Fix content-type bug in aiohttp stub. Save URL with query params properly when using aiohttp.
+-  1.12.0 - Fix support to latest aiohttp version (3.2.1), Adapted setup to PEP508, Support binary responses on aiohttp, Dropped support for EOL python versions (2.6 and 3.3)
+-  1.11.1 Fix compatibility with newest requests and urllib3 releases
+-  1.11.0 Allow injection of persistence methods + bugfixes (thanks @j-funk and @IvanMalison),
+   Support python 3.6 + CI tests (thanks @derekbekoe and @graingert),
+   Support pytest-asyncio coroutines (thanks @graingert)
+-  1.10.5 Added a fix to httplib2 (thanks @carlosds730), Fix an issue with
+   aiohttp (thanks @madninja), Add missing requirement yarl (thanks @lamenezes),
+   Remove duplicate mock triple (thanks @FooBarQuaxx)
+-  1.10.4 Fix an issue with asyncio aiohttp (thanks @madninja)
+-  1.10.3 Fix some issues with asyncio and params (thanks @anovikov1984 and
+   @lamenezes), Fix some issues with cassette serialize / deserialize and empty
+   response bodies (thanks @gRoussac and @dz0ny)
+-  1.10.2 Fix 1.10.1 release - add aiohttp support back in
+-  1.10.1 [bad release] Fix build for Fedora package + python2 (thanks @puiterwijk and @lamenezes)
+-  1.10.0 Add support for aiohttp (thanks @lamenezes)
+-  1.9.0 Add support for boto3 (thanks @desdm, @foorbarna). Fix deepcopy issue
+   for response headers when `decode_compressed_response` is enabled (thanks
+   @nickdirienzo)
 -  1.8.0 Fix for Serialization errors with JSON adapter (thanks
    @aliaksandrb). Avoid concatenating bytes with strings (thanks
    @jaysonsantos). Exclude __pycache__ dirs & compiled files in sdist

docs/conf.py

@@ -110,7 +110,7 @@ todo_include_todos = False
 # -- Options for HTML output ----------------------------------------------
 
 # The theme to use for HTML and HTML Help pages.
-# https://read-the-docs.readthedocs.org/en/latest/theme.html#how-do-i-use-this-locally-and-on-read-the-docs
+# https://read-the-docs.readthedocs.io/en/latest/theme.html#how-do-i-use-this-locally-and-on-read-the-docs
 if 'READTHEDOCS' not in os.environ:
     import sphinx_rtd_theme
     html_theme = 'sphinx_rtd_theme'

docs/contributing.rst

@@ -11,7 +11,10 @@ yourself using `py.test <http://pytest.org/>`__ and
 all environments VCR.py supports. The test suite is pretty big and slow,
 but you can tell tox to only run specific tests like this::
 
-    tox -e py27requests -- -v -k "'test_status_code or test_gzip'"
+    tox -e {pyNN}-{HTTP_LIBRARY} -- <pytest flags passed through>
+
+    tox -e py27-requests -- -v -k "'test_status_code or test_gzip'"
+    tox -e py37-requests -- -v --last-failed
 
 This will run only tests that look like ``test_status_code`` or
 ``test_gzip`` in the test suite, and only in the python 2.7 environment
@@ -19,7 +22,28 @@ that has ``requests`` installed.
 
 Also, in order for the boto tests to run, you will need an AWS key.
 Refer to the `boto
-documentation <http://boto.readthedocs.org/en/latest/getting_started.html>`__
+documentation <https://boto.readthedocs.io/en/latest/getting_started.html>`__
 for how to set this up. I have marked the boto tests as optional in
 Travis so you don't have to worry about them failing if you submit a
 pull request.
+
+
+Troubleshooting on MacOSX
+-------------------------
+
+If you have this kind of error when running tox :
+
+.. code:: python
+
+    __main__.ConfigurationError: Curl is configured to use SSL, but we have
+    not been able to determine which SSL backend it is using. Please see PycURL documentation for how to specify the SSL backend manually.
+
+Then you need to define some environment variables:
+
+.. code:: bash
+
+    export PYCURL_SSL_LIBRARY=openssl
+    export LDFLAGS=-L/usr/local/opt/openssl/lib
+    export CPPFLAGS=-I/usr/local/opt/openssl/include
+
+Reference : `stackoverflow issue <https://stackoverflow.com/questions/51019622/curl-is-configured-to-use-ssl-but-we-have-not-been-able-to-determine-which-ssl>`__

docs/debugging.rst

@@ -29,3 +29,29 @@ The second time, you will see::
 If you set the loglevel to DEBUG, you will also get information about
 which matchers didn't match. This can help you with debugging custom
 matchers.
+
+CannotOverwriteExistingCassetteException
+========================================
+
+When a request failed to be found in an existing cassette,
+VCR.py tries to get the request(s) that may be similar to the one being searched.
+The goal is to see which matcher(s) failed and understand what part of the failed request may have changed.
+It can return multiple similar requests with :
+
+- the matchers that have succeeded
+- the matchers that have failed
+- for each failed matchers, why it has failed with an assertion message
+
+CannotOverwriteExistingCassetteException message example :
+
+.. code:: python
+
+    CannotOverwriteExistingCassetteException: Can't overwrite existing cassette ('cassette.yaml') in your current record mode ('once').
+    No match for the request (<Request (GET) https://www.googleapis.com/?alt=json&maxResults=200>) was found.
+    Found 1 similar requests with 1 different matchers :
+
+    1 - (<Request (GET) https://www.googleapis.com/?alt=json&maxResults=500>).
+    Matchers succeeded : ['method', 'scheme', 'host', 'port', 'path']
+    Matchers failed :
+    query - assertion failure :
+    [('alt', 'json'), ('maxResults', '200')] != [('alt', 'json'), ('maxResults', '500')]

docs/installation.rst

@@ -9,18 +9,20 @@ with pip::
 Compatibility
 -------------
 
-VCR.py supports Python 2.6 and 2.7, 3.3, 3.4, and
+VCR.py supports Python 2.7 and 3.5+, and
 `pypy <http://pypy.org>`__.
 
-The following http libraries are supported:
+The following HTTP libraries are supported:
 
--  urllib2
--  urllib3
--  http.client (python3)
--  requests (both 1.x and 2.x versions)
--  httplib2
--  boto
--  Tornado's AsyncHTTPClient
+-  ``aiohttp``
+-  ``boto``
+-  ``boto3``
+-  ``http.client``
+-  ``httplib2``
+-  ``requests`` (both 1.x and 2.x versions)
+-  ``tornado.httpclient``
+-  ``urllib2``
+-  ``urllib3``
 
 Speed
 -----
@@ -40,7 +42,7 @@ rebuilding pyyaml.
 
      brew install libyaml         # Mac with Homebrew
      apt-get install libyaml-dev  # Ubuntu
-     dnf install libyaml-dev      # Fedora
+     dnf install libyaml-devel      # Fedora
 
 3. Rebuild pyyaml with libyaml::
 

docs/usage.rst

@@ -11,7 +11,7 @@ Usage
         assert 'Example domains' in response
 
 Run this test once, and VCR.py will record the HTTP request to
-``fixtures/vcr_cassettes/synopsis.yml``. Run it again, and VCR.py will
+``fixtures/vcr_cassettes/synopsis.yaml``. Run it again, and VCR.py will
 replay the response from iana.org when the http request is made. This
 test is now fast (no real HTTP requests are made anymore), deterministic
 (the test will continue to pass, even if you are offline, or iana.org
@@ -57,7 +57,7 @@ once
    file.
 
 It is similar to the new\_episodes record mode, but will prevent new,
-unexpected requests from being made (i.e. because the request URI
+unexpected requests from being made (e.g. because the request URI
 changed).
 
 once is the default record mode, used when you do not set one.
@@ -95,3 +95,9 @@ Unittest Integration
 While it's possible to use the context manager or decorator forms with unittest,
 there's also a ``VCRTestCase`` provided separately by `vcrpy-unittest
 <https://github.com/agriffis/vcrpy-unittest>`__.
+
+Pytest Integration
+------------------
+
+A Pytest plugin is available here : `pytest-vcr
+<https://github.com/ktosiek/pytest-vcr>`__.

runtests.sh

@@ -1,3 +1,7 @@
 #!/bin/bash
 
-REQUESTS_CA_BUNDLE=`python -m pytest_httpbin.certs` py.test $1
+# https://blog.ionelmc.ro/2015/04/14/tox-tricks-and-patterns/#when-it-inevitably-leads-to-shell-scripts
+# If you are getting an INVOCATION ERROR for this script then there is 
+# a good chance you are running on Windows.
+# You can and should use WSL for running tox on Windows when it calls bash scripts.
+REQUESTS_CA_BUNDLE=`python -m pytest_httpbin.certs` py.test $*

setup.py

@@ -1,11 +1,9 @@
 #!/usr/bin/env python
 
 import sys
-import logging
 
 from setuptools import setup, find_packages
 from setuptools.command.test import test as TestCommand
-import pkg_resources
 
 long_description = open('README.rst', 'r').read()
 
@@ -24,34 +22,22 @@ class PyTest(TestCommand):
         sys.exit(errno)
 
 
-install_requires = ['PyYAML', 'wrapt', 'six>=1.5']
-
-
-extras_require = {
-    ':python_version in "2.4, 2.5, 2.6"':
-        ['contextlib2', 'backport_collections', 'mock'],
-    ':python_version in "2.7, 3.1, 3.2"': ['contextlib2', 'mock'],
-}
-
-
-try:
-    if 'bdist_wheel' not in sys.argv:
-        for key, value in extras_require.items():
-            if key.startswith(':') and pkg_resources.evaluate_marker(key[1:]):
-                install_requires.extend(value)
-except Exception:
-    logging.getLogger(__name__).exception(
-        'Something went wrong calculating platform specific dependencies, so '
-        "you're getting them all!"
-    )
-    for key, value in extras_require.items():
-        if key.startswith(':'):
-            install_requires.extend(value)
+install_requires = [
+    'PyYAML',
+    'wrapt',
+    'six>=1.5',
+    'contextlib2; python_version=="2.7"',
+    'mock; python_version=="2.7"',
+    'yarl; python_version>="3.5"',
+]
 
+excluded_packages = ["tests*"]
+if sys.version_info[0] == 2:
+    excluded_packages.append("vcr.stubs.aiohttp_stubs")
 
 setup(
     name='vcrpy',
-    version='1.8.0',
+    version='2.1.0',
     description=(
         "Automatically mock your HTTP interactions to simplify and "
         "speed up testing"
@@ -60,17 +46,24 @@ setup(
     author='Kevin McCarthy',
     author_email='me@kevinmccarthy.org',
     url='https://github.com/kevin1024/vcrpy',
-    packages=find_packages(exclude=("tests*",)),
+    packages=find_packages(exclude=excluded_packages),
+    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*',
     install_requires=install_requires,
-    extras_require=extras_require,
     license='MIT',
     tests_require=['pytest', 'mock', 'pytest-httpbin'],
     classifiers=[
-        'Development Status :: 4 - Beta',
+        'Development Status :: 5 - Production/Stable',
         'Environment :: Console',
         'Intended Audience :: Developers',
         'Programming Language :: Python',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: Implementation :: CPython',
+        'Programming Language :: Python :: Implementation :: PyPy',
         'Topic :: Software Development :: Testing',
         'Topic :: Internet :: WWW/HTTP',
         'License :: OSI Approved :: MIT License',

tests/fixtures/migration/new_cassette.yaml

@@ -9,7 +9,7 @@ interactions:
     method: GET
     uri: http://httpbin.org/ip
   response:
-    body: {string: !!python/unicode "{\n  \"origin\": \"217.122.164.194\"\n}"}
+    body: {string: "{\n  \"origin\": \"217.122.164.194\"\n}"}
     headers:
       access-control-allow-origin: ['*']
       content-type: [application/json]

tests/integration/aiohttp_utils.py

@@ -0,0 +1,43 @@
+# flake8: noqa
+import asyncio
+
+import aiohttp
+from aiohttp.test_utils import TestClient
+
+
+async def aiohttp_request(loop, method, url, output='text', encoding='utf-8', content_type=None, **kwargs):
+    session = aiohttp.ClientSession(loop=loop)
+    response_ctx = session.request(method, url, **kwargs)
+
+    response = await response_ctx.__aenter__()
+    if output == 'text':
+        content = await response.text()
+    elif output == 'json':
+        content_type = content_type or 'application/json'
+        content = await response.json(encoding=encoding, content_type=content_type)
+    elif output == 'raw':
+        content = await response.read()
+    elif output == 'stream':
+        content = await response.content.read()
+
+    response_ctx._resp.close()
+    await session.close()
+
+    return response, content
+
+
+def aiohttp_app():
+    async def hello(request):
+        return aiohttp.web.Response(text='hello')
+
+    async def json(request):
+        return aiohttp.web.json_response({})
+
+    async def json_empty_body(request):
+        return aiohttp.web.json_response()
+
+    app = aiohttp.web.Application()
+    app.router.add_get('/', hello)
+    app.router.add_get('/json', json)
+    app.router.add_get('/json/empty', json_empty_body)
+    return app

tests/integration/test_aiohttp.py

@@ -0,0 +1,264 @@
+import contextlib
+import logging
+
+import pytest
+asyncio = pytest.importorskip("asyncio")
+aiohttp = pytest.importorskip("aiohttp")
+
+import vcr  # noqa: E402
+from .aiohttp_utils import aiohttp_app, aiohttp_request  # noqa: E402
+
+
+def run_in_loop(fn):
+    with contextlib.closing(asyncio.new_event_loop()) as loop:
+        asyncio.set_event_loop(loop)
+        task = loop.create_task(fn(loop))
+        return loop.run_until_complete(task)
+
+
+def request(method, url, output='text', **kwargs):
+    def run(loop):
+        return aiohttp_request(loop, method, url, output=output, **kwargs)
+
+    return run_in_loop(run)
+
+
+def get(url, output='text', **kwargs):
+    return request('GET', url, output=output, **kwargs)
+
+
+def post(url, output='text', **kwargs):
+    return request('POST', url, output='text', **kwargs)
+
+
+@pytest.fixture(params=["https", "http"])
+def scheme(request):
+    '''Fixture that returns both http and https.'''
+    return request.param
+
+
+def test_status(tmpdir, scheme):
+    url = scheme + '://httpbin.org'
+    with vcr.use_cassette(str(tmpdir.join('status.yaml'))):
+        response, _ = get(url)
+
+    with vcr.use_cassette(str(tmpdir.join('status.yaml'))) as cassette:
+        cassette_response, _ = get(url)
+        assert cassette_response.status == response.status
+        assert cassette.play_count == 1
+
+
+@pytest.mark.parametrize("auth", [None, aiohttp.BasicAuth("vcrpy", "test")])
+def test_headers(tmpdir, scheme, auth):
+    url = scheme + '://httpbin.org'
+    with vcr.use_cassette(str(tmpdir.join('headers.yaml'))):
+        response, _ = get(url, auth=auth)
+
+    with vcr.use_cassette(str(tmpdir.join('headers.yaml'))) as cassette:
+        if auth is not None:
+            request = cassette.requests[0]
+            assert "AUTHORIZATION" in request.headers
+        cassette_response, _ = get(url, auth=auth)
+        assert dict(cassette_response.headers) == dict(response.headers)
+        assert cassette.play_count == 1
+        assert 'istr' not in cassette.data[0]
+        assert 'yarl.URL' not in cassette.data[0]
+
+
+def test_case_insensitive_headers(tmpdir, scheme):
+    url = scheme + '://httpbin.org'
+    with vcr.use_cassette(str(tmpdir.join('whatever.yaml'))):
+        _, _ = get(url)
+
+    with vcr.use_cassette(str(tmpdir.join('whatever.yaml'))) as cassette:
+        cassette_response, _ = get(url)
+        assert "Content-Type" in cassette_response.headers
+        assert "content-type" in cassette_response.headers
+        assert cassette.play_count == 1
+
+
+def test_text(tmpdir, scheme):
+    url = scheme + '://httpbin.org'
+    with vcr.use_cassette(str(tmpdir.join('text.yaml'))):
+        _, response_text = get(url)
+
+    with vcr.use_cassette(str(tmpdir.join('text.yaml'))) as cassette:
+        _, cassette_response_text = get(url)
+        assert cassette_response_text == response_text
+        assert cassette.play_count == 1
+
+
+def test_json(tmpdir, scheme):
+    url = scheme + '://httpbin.org/get'
+    headers = {'Content-Type': 'application/json'}
+
+    with vcr.use_cassette(str(tmpdir.join('json.yaml'))):
+        _, response_json = get(url, output='json', headers=headers)
+
+    with vcr.use_cassette(str(tmpdir.join('json.yaml'))) as cassette:
+        _, cassette_response_json = get(url, output='json', headers=headers)
+        assert cassette_response_json == response_json
+        assert cassette.play_count == 1
+
+
+def test_binary(tmpdir, scheme):
+    url = scheme + '://httpbin.org/image/png'
+    with vcr.use_cassette(str(tmpdir.join('binary.yaml'))):
+        _, response_binary = get(url, output='raw')
+
+    with vcr.use_cassette(str(tmpdir.join('binary.yaml'))) as cassette:
+        _, cassette_response_binary = get(url, output='raw')
+        assert cassette_response_binary == response_binary
+        assert cassette.play_count == 1
+
+
+def test_stream(tmpdir, scheme):
+    url = scheme + '://httpbin.org/get'
+
+    with vcr.use_cassette(str(tmpdir.join('stream.yaml'))):
+        resp, body = get(url, output='raw')  # Do not use stream here, as the stream is exhausted by vcr
+
+    with vcr.use_cassette(str(tmpdir.join('stream.yaml'))) as cassette:
+        cassette_resp, cassette_body = get(url, output='stream')
+        assert cassette_body == body
+        assert cassette.play_count == 1
+
+
+@pytest.mark.parametrize('body', ['data', 'json'])
+def test_post(tmpdir, scheme, body, caplog):
+    caplog.set_level(logging.INFO)
+    data = {'key1': 'value1', 'key2': 'value2'}
+    url = scheme + '://httpbin.org/post'
+    with vcr.use_cassette(str(tmpdir.join('post.yaml'))):
+        _, response_json = post(url, **{body: data})
+
+    with vcr.use_cassette(str(tmpdir.join('post.yaml'))) as cassette:
+        request = cassette.requests[0]
+        assert request.body == data
+        _, cassette_response_json = post(url, **{body: data})
+        assert cassette_response_json == response_json
+        assert cassette.play_count == 1
+
+    assert next(
+        (
+            log
+            for log in caplog.records
+            if log.getMessage()
+            == '<Request (POST) {}> not in cassette, sending to real server'.format(url)
+        ),
+        None,
+    ), 'Log message not found.'
+
+
+def test_params(tmpdir, scheme):
+    url = scheme + '://httpbin.org/get'
+    headers = {'Content-Type': 'application/json'}
+    params = {'a': 1, 'b': False, 'c': 'c'}
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        _, response_json = get(url, output='json', params=params, headers=headers)
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        _, cassette_response_json = get(url, output='json', params=params, headers=headers)
+        assert cassette_response_json == response_json
+        assert cassette.play_count == 1
+
+
+def test_params_same_url_distinct_params(tmpdir, scheme):
+    url = scheme + '://httpbin.org/get'
+    headers = {'Content-Type': 'application/json'}
+    params = {'a': 1, 'b': False, 'c': 'c'}
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        _, response_json = get(url, output='json', params=params, headers=headers)
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        _, cassette_response_json = get(url, output='json', params=params, headers=headers)
+        assert cassette_response_json == response_json
+        assert cassette.play_count == 1
+
+    other_params = {'other': 'params'}
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        response, cassette_response_text = get(url, output='text', params=other_params)
+        assert 'No match for the request' in cassette_response_text
+        assert response.status == 599
+
+
+def test_params_on_url(tmpdir, scheme):
+    url = scheme + '://httpbin.org/get?a=1&b=foo'
+    headers = {'Content-Type': 'application/json'}
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        _, response_json = get(url, output='json', headers=headers)
+        request = cassette.requests[0]
+        assert request.url == url
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        _, cassette_response_json = get(url, output='json', headers=headers)
+        request = cassette.requests[0]
+        assert request.url == url
+        assert cassette_response_json == response_json
+        assert cassette.play_count == 1
+
+
+def test_aiohttp_test_client(aiohttp_client, tmpdir):
+    loop = asyncio.get_event_loop()
+    app = aiohttp_app()
+    url = '/'
+    client = loop.run_until_complete(aiohttp_client(app))
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))):
+        response = loop.run_until_complete(client.get(url))
+
+    assert response.status == 200
+    response_text = loop.run_until_complete(response.text())
+    assert response_text == 'hello'
+    response_text = loop.run_until_complete(response.text(errors='replace'))
+    assert response_text == 'hello'
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        response = loop.run_until_complete(client.get(url))
+
+    request = cassette.requests[0]
+    assert request.url == str(client.make_url(url))
+    response_text = loop.run_until_complete(response.text())
+    assert response_text == 'hello'
+    assert cassette.play_count == 1
+
+
+def test_aiohttp_test_client_json(aiohttp_client, tmpdir):
+    loop = asyncio.get_event_loop()
+    app = aiohttp_app()
+    url = '/json/empty'
+    client = loop.run_until_complete(aiohttp_client(app))
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))):
+        response = loop.run_until_complete(client.get(url))
+
+    assert response.status == 200
+    response_json = loop.run_until_complete(response.json())
+    assert response_json is None
+
+    with vcr.use_cassette(str(tmpdir.join('get.yaml'))) as cassette:
+        response = loop.run_until_complete(client.get(url))
+
+    request = cassette.requests[0]
+    assert request.url == str(client.make_url(url))
+    response_json = loop.run_until_complete(response.json())
+    assert response_json is None
+    assert cassette.play_count == 1
+
+
+def test_redirect(aiohttp_client, tmpdir):
+    url = 'https://httpbin.org/redirect/2'
+
+    with vcr.use_cassette(str(tmpdir.join('redirect.yaml'))):
+        response, _ = get(url)
+
+    with vcr.use_cassette(str(tmpdir.join('redirect.yaml'))) as cassette:
+        cassette_response, _ = get(url)
+
+        assert cassette_response.status == response.status
+        assert len(cassette_response.history) == len(response.history)
+        assert len(cassette) == 3
+        assert cassette.play_count == 3

tests/integration/test_boto.py

@@ -5,8 +5,12 @@ import boto  # NOQA
 import boto.iam  # NOQA
 from boto.s3.connection import S3Connection  # NOQA
 from boto.s3.key import Key  # NOQA
-from ConfigParser import DuplicateSectionError  # NOQA
 import vcr  # NOQA
+try:  # NOQA
+    from ConfigParser import DuplicateSectionError  # NOQA
+except ImportError:  # NOQA
+    # python3
+    from configparser import DuplicateSectionError  # NOQA
 
 
 def test_boto_stubs(tmpdir):

tests/integration/test_boto3.py

@@ -0,0 +1,117 @@
+import pytest
+import os
+
+boto3 = pytest.importorskip("boto3")
+
+import boto3  # NOQA
+import botocore  # NOQA
+import vcr  # NOQA
+
+try:
+    from botocore import awsrequest  # NOQA
+
+    botocore_awsrequest = True
+except ImportError:
+    botocore_awsrequest = False
+
+# skip tests if boto does not use vendored requests anymore
+# https://github.com/boto/botocore/pull/1495
+boto3_skip_vendored_requests = pytest.mark.skipif(
+    botocore_awsrequest,
+    reason='botocore version {ver} does not use vendored requests anymore.'.format(
+        ver=botocore.__version__))
+
+boto3_skip_awsrequest = pytest.mark.skipif(
+    not botocore_awsrequest,
+    reason='botocore version {ver} still uses vendored requests.'.format(
+        ver=botocore.__version__))
+
+IAM_USER_NAME = "vcrpy"
+
+
+@pytest.fixture
+def iam_client():
+    def _iam_client(boto3_session=None):
+        if boto3_session is None:
+            boto3_session = boto3.Session(
+                aws_access_key_id=os.environ.get('AWS_ACCESS_KEY_ID', "default"),
+                aws_secret_access_key=os.environ.get('AWS_SECRET_ACCESS_KEY', "default"),
+                aws_session_token=None,
+                region_name=os.environ.get('AWS_DEFAULT_REGION', "default"),
+            )
+        return boto3_session.client('iam')
+    return _iam_client
+
+
+@pytest.fixture
+def get_user(iam_client):
+    def _get_user(client=None, user_name=IAM_USER_NAME):
+        if client is None:
+            # Default client set with fixture `iam_client`
+            client = iam_client()
+        return client.get_user(UserName=user_name)
+    return _get_user
+
+
+@boto3_skip_vendored_requests
+def test_boto_vendored_stubs(tmpdir):
+    with vcr.use_cassette(str(tmpdir.join('boto3-stubs.yml'))):
+        # Perform the imports within the patched context so that
+        # HTTPConnection, VerifiedHTTPSConnection refers to the patched version.
+        from botocore.vendored.requests.packages.urllib3.connectionpool import \
+            HTTPConnection, VerifiedHTTPSConnection
+        from vcr.stubs.boto3_stubs import VCRRequestsHTTPConnection, VCRRequestsHTTPSConnection
+        # Prove that the class was patched by the stub and that we can instantiate it.
+        assert issubclass(HTTPConnection, VCRRequestsHTTPConnection)
+        assert issubclass(VerifiedHTTPSConnection, VCRRequestsHTTPSConnection)
+        HTTPConnection('hostname.does.not.matter')
+        VerifiedHTTPSConnection('hostname.does.not.matter')
+
+
+@pytest.mark.skipif(
+    os.environ.get("TRAVIS_PULL_REQUEST") != "false",
+    reason="Encrypted Environment Variables from Travis Repository Settings"
+    " are disabled on PRs from forks. "
+    "https://docs.travis-ci.com/user/pull-requests/#pull-requests-and-security-restrictions"
+)
+def test_boto_medium_difficulty(tmpdir, get_user):
+
+    with vcr.use_cassette(str(tmpdir.join('boto3-medium.yml'))):
+        response = get_user()
+        assert response['User']['UserName'] == IAM_USER_NAME
+
+    with vcr.use_cassette(str(tmpdir.join('boto3-medium.yml'))) as cass:
+        response = get_user()
+        assert response['User']['UserName'] == IAM_USER_NAME
+        assert cass.all_played
+
+
+@pytest.mark.skipif(
+    os.environ.get("TRAVIS_PULL_REQUEST") != "false",
+    reason="Encrypted Environment Variables from Travis Repository Settings"
+    " are disabled on PRs from forks. "
+    "https://docs.travis-ci.com/user/pull-requests/#pull-requests-and-security-restrictions"
+)
+def test_boto_hardcore_mode(tmpdir, iam_client, get_user):
+    with vcr.use_cassette(str(tmpdir.join('boto3-hardcore.yml'))):
+        ses = boto3.Session(
+            aws_access_key_id=os.environ.get('AWS_ACCESS_KEY_ID'),
+            aws_secret_access_key=os.environ.get('AWS_SECRET_ACCESS_KEY'),
+            region_name=os.environ.get('AWS_DEFAULT_REGION'),
+        )
+        client = iam_client(ses)
+        response = get_user(client=client)
+        assert response['User']['UserName'] == IAM_USER_NAME
+
+    with vcr.use_cassette(str(tmpdir.join('boto3-hardcore.yml'))) as cass:
+        ses = boto3.Session(
+            aws_access_key_id=os.environ.get('AWS_ACCESS_KEY_ID'),
+            aws_secret_access_key=os.environ.get('AWS_SECRET_ACCESS_KEY'),
+            aws_session_token=None,
+            region_name=os.environ.get('AWS_DEFAULT_REGION'),
+        )
+
+        client = iam_client(ses)
+        response = get_user(client=client)
+        assert response['User']['UserName'] == IAM_USER_NAME
+        assert cass.all_played

tests/integration/test_http

@@ -0,0 +1,22 @@
+interactions:
+- request:
+    body: null
+    headers: {}
+    method: GET
+    uri: https://httpbin.org/get?ham=spam
+  response:
+    body: {string: "{\n  \"args\": {\n    \"ham\": \"spam\"\n  }, \n  \"headers\"\
+        : {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\": \"gzip, deflate\"\
+        , \n    \"Connection\": \"close\", \n    \"Host\": \"httpbin.org\", \n   \
+        \ \"User-Agent\": \"Python/3.5 aiohttp/2.0.1\"\n  }, \n  \"origin\": \"213.86.221.35\"\
+        , \n  \"url\": \"https://httpbin.org/get?ham=spam\"\n}\n"}
+    headers: {Access-Control-Allow-Credentials: 'true', Access-Control-Allow-Origin: '*',
+      Connection: keep-alive, Content-Length: '299', Content-Type: application/json,
+      Date: 'Wed, 22 Mar 2017 20:08:29 GMT', Server: gunicorn/19.7.1, Via: 1.1 vegur}
+    status: {code: 200, message: OK}
+    url: !!python/object/new:yarl.URL
+      state: !!python/tuple
+      - !!python/object/new:urllib.parse.SplitResult [https, httpbin.org, /get, ham=spam,
+        '']
+      - false
+version: 1

tests/integration/test_httplib2.py

@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
 '''Integration tests with httplib2'''
 
-# External imports
+import sys
+
 from six.moves.urllib_parse import urlencode
 import pytest
 import pytest_httpbin.certs
 
-# Internal imports
 import vcr
 
 from assertions import assert_cassette_has_one_response
@@ -19,7 +19,12 @@ def http():
     Returns an httplib2 HTTP instance
     with the certificate replaced by the httpbin one.
     """
-    return httplib2.Http(ca_certs=pytest_httpbin.certs.where())
+    kwargs = {
+        'ca_certs': pytest_httpbin.certs.where()
+    }
+    if sys.version_info[:2] in [(2, 7), (3, 7)]:
+        kwargs['disable_ssl_certificate_validation'] = True
+    return httplib2.Http(**kwargs)
 
 
 def test_response_code(tmpdir, httpbin_both):

tests/integration/test_ignore.py

@@ -26,9 +26,9 @@ def test_ignore_localhost(tmpdir, httpbin):
     with overridden_dns({'httpbin.org': '127.0.0.1'}):
         cass_file = str(tmpdir.join('filter_qs.yaml'))
         with vcr.use_cassette(cass_file, ignore_localhost=True) as cass:
-            urlopen('http://localhost:{0}/'.format(httpbin.port))
+            urlopen('http://localhost:{}/'.format(httpbin.port))
             assert len(cass) == 0
-            urlopen('http://httpbin.org:{0}/'.format(httpbin.port))
+            urlopen('http://httpbin.org:{}/'.format(httpbin.port))
             assert len(cass) == 1
 
 
@@ -39,9 +39,9 @@ def test_ignore_httpbin(tmpdir, httpbin):
             cass_file,
             ignore_hosts=['httpbin.org']
         ) as cass:
-            urlopen('http://httpbin.org:{0}/'.format(httpbin.port))
+            urlopen('http://httpbin.org:{}/'.format(httpbin.port))
             assert len(cass) == 0
-            urlopen('http://localhost:{0}/'.format(httpbin.port))
+            urlopen('http://localhost:{}/'.format(httpbin.port))
             assert len(cass) == 1
 
 
@@ -53,8 +53,8 @@ def test_ignore_localhost_and_httpbin(tmpdir, httpbin):
             ignore_hosts=['httpbin.org'],
             ignore_localhost=True
         ) as cass:
-            urlopen('http://httpbin.org:{0}'.format(httpbin.port))
-            urlopen('http://localhost:{0}'.format(httpbin.port))
+            urlopen('http://httpbin.org:{}'.format(httpbin.port))
+            urlopen('http://localhost:{}'.format(httpbin.port))
             assert len(cass) == 0
 
 
@@ -62,12 +62,12 @@ def test_ignore_localhost_twice(tmpdir, httpbin):
     with overridden_dns({'httpbin.org': '127.0.0.1'}):
         cass_file = str(tmpdir.join('filter_qs.yaml'))
         with vcr.use_cassette(cass_file, ignore_localhost=True) as cass:
-            urlopen('http://localhost:{0}'.format(httpbin.port))
+            urlopen('http://localhost:{}'.format(httpbin.port))
             assert len(cass) == 0
-            urlopen('http://httpbin.org:{0}'.format(httpbin.port))
+            urlopen('http://httpbin.org:{}'.format(httpbin.port))
             assert len(cass) == 1
         with vcr.use_cassette(cass_file, ignore_localhost=True) as cass:
             assert len(cass) == 1
-            urlopen('http://localhost:{0}'.format(httpbin.port))
-            urlopen('http://httpbin.org:{0}'.format(httpbin.port))
+            urlopen('http://localhost:{}'.format(httpbin.port))
+            urlopen('http://httpbin.org:{}'.format(httpbin.port))
             assert len(cass) == 1

tests/integration/test_proxy.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+'''Test using a proxy.'''
+
+# External imports
+import multiprocessing
+import pytest
+
+from six.moves import socketserver, SimpleHTTPServer
+from six.moves.urllib.request import urlopen
+
+# Internal imports
+import vcr
+
+# Conditional imports
+requests = pytest.importorskip("requests")
+
+
+class Proxy(SimpleHTTPServer.SimpleHTTPRequestHandler):
+    '''
+    Simple proxy server.
+
+    (Inspired by: http://effbot.org/librarybook/simplehttpserver.htm).
+    '''
+    def do_GET(self):
+        upstream_response = urlopen(self.path)
+        try:
+            status = upstream_response.status
+            headers = upstream_response.headers.items()
+        except AttributeError:
+            # In Python 2 the response is an addinfourl instance.
+            status = upstream_response.code
+            headers = upstream_response.info().items()
+        self.send_response(status, upstream_response.msg)
+        for header in headers:
+            self.send_header(*header)
+        self.end_headers()
+        self.copyfile(upstream_response, self.wfile)
+
+
+@pytest.yield_fixture(scope='session')
+def proxy_server():
+    httpd = socketserver.ThreadingTCPServer(('', 0), Proxy)
+    proxy_process = multiprocessing.Process(
+        target=httpd.serve_forever,
+    )
+    proxy_process.start()
+    yield 'http://{}:{}'.format(*httpd.server_address)
+    proxy_process.terminate()
+
+
+def test_use_proxy(tmpdir, httpbin, proxy_server):
+    '''Ensure that it works with a proxy.'''
+    with vcr.use_cassette(str(tmpdir.join('proxy.yaml'))):
+        response = requests.get(httpbin.url, proxies={'http': proxy_server})
+
+    with vcr.use_cassette(str(tmpdir.join('proxy.yaml'))) as cassette:
+        cassette_response = requests.get(httpbin.url, proxies={'http': proxy_server})
+
+    assert cassette_response.headers == response.headers
+    assert cassette.play_count == 1

tests/integration/test_register_persister.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+'''Tests for cassettes with custom persistence'''
+
+# External imports
+import os
+from six.moves.urllib.request import urlopen
+
+# Internal imports
+import vcr
+from vcr.persisters.filesystem import FilesystemPersister
+
+
+class CustomFilesystemPersister(object):
+    '''Behaves just like default FilesystemPersister but adds .test extension
+       to the cassette file'''
+    @staticmethod
+    def load_cassette(cassette_path, serializer):
+        cassette_path += '.test'
+        return FilesystemPersister.load_cassette(cassette_path, serializer)
+
+    @staticmethod
+    def save_cassette(cassette_path, cassette_dict, serializer):
+        cassette_path += '.test'
+        FilesystemPersister.save_cassette(cassette_path, cassette_dict,
+                                          serializer)
+
+
+def test_save_cassette_with_custom_persister(tmpdir, httpbin):
+    '''Ensure you can save a cassette using custom persister'''
+    my_vcr = vcr.VCR()
+    my_vcr.register_persister(CustomFilesystemPersister)
+
+    # Check to make sure directory doesnt exist
+    assert not os.path.exists(str(tmpdir.join('nonexistent')))
+
+    # Run VCR to create dir and cassette file using new save_cassette callback
+    with my_vcr.use_cassette(str(tmpdir.join('nonexistent', 'cassette.yml'))):
+        urlopen(httpbin.url).read()
+
+    # Callback should have made the file and the directory
+    assert os.path.exists(str(tmpdir.join('nonexistent', 'cassette.yml.test')))
+
+
+def test_load_cassette_with_custom_persister(tmpdir, httpbin):
+    '''
+    Ensure you can load a cassette using custom persister
+    '''
+    my_vcr = vcr.VCR()
+    my_vcr.register_persister(CustomFilesystemPersister)
+
+    test_fixture = str(tmpdir.join('synopsis.json.test'))
+
+    with my_vcr.use_cassette(test_fixture, serializer='json'):
+        response = urlopen(httpbin.url).read()
+        assert b'difficult sometimes' in response

tests/integration/test_requests.py

@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
 '''Test requests' interaction with vcr'''
+import platform
 import pytest
+import sys
 import vcr
 from assertions import assert_cassette_empty, assert_is_json
 
-
 requests = pytest.importorskip("requests")
+from requests.exceptions import ConnectionError  # noqa E402
 
 
 def test_status_code(httpbin_both, tmpdir):
@@ -38,6 +40,18 @@ def test_body(tmpdir, httpbin_both):
         assert content == requests.get(url).content
 
 
+def test_get_empty_content_type_json(tmpdir, httpbin_both):
+    '''Ensure GET with application/json content-type and empty request body doesn't crash'''
+    url = httpbin_both + '/status/200'
+    headers = {'Content-Type': 'application/json'}
+
+    with vcr.use_cassette(str(tmpdir.join('get_empty_json.yaml')), match_on=('body',)):
+        status = requests.get(url, headers=headers).status_code
+
+    with vcr.use_cassette(str(tmpdir.join('get_empty_json.yaml')), match_on=('body',)):
+        assert status == requests.get(url, headers=headers).status_code
+
+
 def test_effective_url(tmpdir, httpbin_both):
     '''Ensure that the effective_url is captured'''
     url = httpbin_both.url + '/redirect-to?url=/html'
@@ -88,11 +102,29 @@ def test_post(tmpdir, httpbin_both):
     assert req1 == req2
 
 
-def test_post_chunked_binary(tmpdir, httpbin_both):
+def test_post_chunked_binary(tmpdir, httpbin):
     '''Ensure that we can send chunked binary without breaking while trying to concatenate bytes with str.'''
     data1 = iter([b'data', b'to', b'send'])
     data2 = iter([b'data', b'to', b'send'])
-    url = httpbin_both.url + '/post'
+    url = httpbin.url + '/post'
+    with vcr.use_cassette(str(tmpdir.join('requests.yaml'))):
+        req1 = requests.post(url, data1).content
+
+    with vcr.use_cassette(str(tmpdir.join('requests.yaml'))):
+        req2 = requests.post(url, data2).content
+
+    assert req1 == req2
+
+
+@pytest.mark.skipif('sys.version_info >= (3, 6)', strict=True, raises=ConnectionError)
+@pytest.mark.skipif((3, 5) < sys.version_info < (3, 6) and
+                    platform.python_implementation() == 'CPython',
+                    reason='Fails on CPython 3.5')
+def test_post_chunked_binary_secure(tmpdir, httpbin_secure):
+    '''Ensure that we can send chunked binary without breaking while trying to concatenate bytes with str.'''
+    data1 = iter([b'data', b'to', b'send'])
+    data2 = iter([b'data', b'to', b'send'])
+    url = httpbin_secure.url + '/post'
     with vcr.use_cassette(str(tmpdir.join('requests.yaml'))):
         req1 = requests.post(url, data1).content
         print(req1)
@@ -222,10 +254,8 @@ def test_nested_cassettes_with_session_created_before_nesting(httpbin_both, tmpd
 def test_post_file(tmpdir, httpbin_both):
     '''Ensure that we handle posting a file.'''
     url = httpbin_both + '/post'
-    with vcr.use_cassette(str(tmpdir.join('post_file.yaml'))) as cass:
-        # Don't use 2.7+ only style ',' separated with here because we support python 2.6
-        with open('tox.ini') as f:
-            original_response = requests.post(url, f).content
+    with vcr.use_cassette(str(tmpdir.join('post_file.yaml'))) as cass, open('tox.ini', 'rb') as f:
+        original_response = requests.post(url, f).content
 
     # This also tests that we do the right thing with matching the body when they are files.
     with vcr.use_cassette(str(tmpdir.join('post_file.yaml')),
@@ -252,3 +282,17 @@ def test_filter_post_params(tmpdir, httpbin_both):
         requests.post(url, data={'key': 'value'})
     with vcr.use_cassette(cass_loc, filter_post_data_parameters=['key']) as cass:
         assert b'key=value' not in cass.requests[0].body
+
+
+def test_post_unicode_match_on_body(tmpdir, httpbin_both):
+    '''Ensure that matching on POST body that contains Unicode characters works.'''
+    data = {'key1': 'value1', '●‿●': '٩(●̮̮̃•̃)۶'}
+    url = httpbin_both + '/post'
+
+    with vcr.use_cassette(str(tmpdir.join('requests.yaml')), additional_matchers=('body',)):
+        req1 = requests.post(url, data).content
+
+    with vcr.use_cassette(str(tmpdir.join('requests.yaml')), additional_matchers=('body',)):
+        req2 = requests.post(url, data).content
+
+    assert req1 == req2

tests/integration/test_stubs.py

@@ -1,6 +1,10 @@
 import vcr
+import zlib
+import json
 import six.moves.http_client as httplib
 
+from assertions import assert_is_json
+
 
 def _headers_are_case_insensitive(host, port):
     conn = httplib.HTTPConnection(host, port)
@@ -44,3 +48,86 @@ def test_multiple_headers(tmpdir, httpbin):
         inside = _multiple_header_value(httpbin)
 
     assert outside == inside
+
+
+def test_original_decoded_response_is_not_modified(tmpdir, httpbin):
+    testfile = str(tmpdir.join('decoded_response.yml'))
+    host, port = httpbin.host, httpbin.port
+
+    conn = httplib.HTTPConnection(host, port)
+    conn.request('GET', '/gzip')
+    outside = conn.getresponse()
+
+    with vcr.use_cassette(testfile, decode_compressed_response=True):
+        conn = httplib.HTTPConnection(host, port)
+        conn.request('GET', '/gzip')
+        inside = conn.getresponse()
+
+        # Assert that we do not modify the original response while appending
+        # to the casssette.
+        assert 'gzip' == inside.headers['content-encoding']
+
+        # They should effectively be the same response.
+        inside_headers = (h for h in inside.headers.items() if h[0].lower() != 'date')
+        outside_headers = (h for h in outside.getheaders() if h[0].lower() != 'date')
+        assert set(inside_headers) == set(outside_headers)
+        inside = zlib.decompress(inside.read(), 16+zlib.MAX_WBITS)
+        outside = zlib.decompress(outside.read(), 16+zlib.MAX_WBITS)
+        assert inside == outside
+
+    # Even though the above are raw bytes, the JSON data should have been
+    # decoded and saved to the cassette.
+    with vcr.use_cassette(testfile):
+        conn = httplib.HTTPConnection(host, port)
+        conn.request('GET', '/gzip')
+        inside = conn.getresponse()
+
+        assert 'content-encoding' not in inside.headers
+        assert_is_json(inside.read())
+
+
+def _make_before_record_response(fields, replacement='[REDACTED]'):
+    def before_record_response(response):
+        string_body = response['body']['string'].decode('utf8')
+        body = json.loads(string_body)
+
+        for field in fields:
+            if field in body:
+                body[field] = replacement
+
+        response['body']['string'] = json.dumps(body).encode()
+        return response
+    return before_record_response
+
+
+def test_original_response_is_not_modified_by_before_filter(tmpdir, httpbin):
+    testfile = str(tmpdir.join('sensitive_data_scrubbed_response.yml'))
+    host, port = httpbin.host, httpbin.port
+    field_to_scrub = 'url'
+    replacement = '[YOU_CANT_HAVE_THE_MANGO]'
+
+    conn = httplib.HTTPConnection(host, port)
+    conn.request('GET', '/get')
+    outside = conn.getresponse()
+
+    callback = _make_before_record_response([field_to_scrub], replacement)
+    with vcr.use_cassette(testfile, before_record_response=callback):
+        conn = httplib.HTTPConnection(host, port)
+        conn.request('GET', '/get')
+        inside = conn.getresponse()
+
+        # The scrubbed field should be the same, because no cassette existed.
+        # Furthermore, the responses should be identical.
+        inside_body = json.loads(inside.read().decode('utf-8'))
+        outside_body = json.loads(outside.read().decode('utf-8'))
+        assert not inside_body[field_to_scrub] == replacement
+        assert inside_body[field_to_scrub] == outside_body[field_to_scrub]
+
+    # Ensure that when a cassette exists, the scrubbed response is returned.
+    with vcr.use_cassette(testfile, before_record_response=callback):
+        conn = httplib.HTTPConnection(host, port)
+        conn.request('GET', '/get')
+        inside = conn.getresponse()
+
+        inside_body = json.loads(inside.read().decode('utf-8'))
+        assert inside_body[field_to_scrub] == replacement

tests/integration/test_urllib2.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 '''Integration tests with urllib2'''
 
+import ssl
 from six.moves.urllib.request import urlopen
 from six.moves.urllib_parse import urlencode
 import pytest_httpbin.certs
@@ -12,7 +13,9 @@ from assertions import assert_cassette_has_one_response
 
 
 def urlopen_with_cafile(*args, **kwargs):
-    kwargs['cafile'] = pytest_httpbin.certs.where()
+    context = ssl.create_default_context(cafile=pytest_httpbin.certs.where())
+    context.check_hostname = False
+    kwargs['context'] = context
     try:
         return urlopen(*args, **kwargs)
     except TypeError:

tests/integration/test_urllib3.py

@@ -5,6 +5,7 @@
 import pytest
 import pytest_httpbin
 import vcr
+from vcr.patch import force_reset
 from assertions import assert_cassette_empty, assert_is_json
 urllib3 = pytest.importorskip("urllib3")
 
@@ -19,7 +20,7 @@ def verify_pool_mgr():
 
 @pytest.fixture(scope='module')
 def pool_mgr():
-    return urllib3.PoolManager()
+    return urllib3.PoolManager(cert_reqs='CERT_NONE')
 
 
 def test_status_code(httpbin_both, tmpdir, verify_pool_mgr):
@@ -55,7 +56,7 @@ def test_body(tmpdir, httpbin_both, verify_pool_mgr):
 def test_auth(tmpdir, httpbin_both, verify_pool_mgr):
     '''Ensure that we can handle basic auth'''
     auth = ('user', 'passwd')
-    headers = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(*auth))
+    headers = urllib3.util.make_headers(basic_auth='{}:{}'.format(*auth))
     url = httpbin_both.url + '/basic-auth/user/passwd'
     with vcr.use_cassette(str(tmpdir.join('auth.yaml'))):
         one = verify_pool_mgr.request('GET', url, headers=headers)
@@ -69,7 +70,7 @@ def test_auth(tmpdir, httpbin_both, verify_pool_mgr):
 def test_auth_failed(tmpdir, httpbin_both, verify_pool_mgr):
     '''Ensure that we can save failed auth statuses'''
     auth = ('user', 'wrongwrongwrong')
-    headers = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(*auth))
+    headers = urllib3.util.make_headers(basic_auth='{}:{}'.format(*auth))
     url = httpbin_both.url + '/basic-auth/user/passwd'
     with vcr.use_cassette(str(tmpdir.join('auth-failed.yaml'))) as cass:
         # Ensure that this is empty to begin with
@@ -138,3 +139,21 @@ def test_gzip(tmpdir, httpbin_both, verify_pool_mgr):
 def test_https_with_cert_validation_disabled(tmpdir, httpbin_secure, pool_mgr):
     with vcr.use_cassette(str(tmpdir.join('cert_validation_disabled.yaml'))):
         pool_mgr.request('GET', httpbin_secure.url)
+
+
+def test_urllib3_force_reset():
+    cpool = urllib3.connectionpool
+    http_original = cpool.HTTPConnection
+    https_original = cpool.HTTPSConnection
+    verified_https_original = cpool.VerifiedHTTPSConnection
+    with vcr.use_cassette(path='test'):
+        first_cassette_HTTPConnection = cpool.HTTPConnection
+        first_cassette_HTTPSConnection = cpool.HTTPSConnection
+        first_cassette_VerifiedHTTPSConnection = cpool.VerifiedHTTPSConnection
+        with force_reset():
+            assert cpool.HTTPConnection is http_original
+            assert cpool.HTTPSConnection is https_original
+            assert cpool.VerifiedHTTPSConnection is verified_https_original
+        assert cpool.HTTPConnection is first_cassette_HTTPConnection
+        assert cpool.HTTPSConnection is first_cassette_HTTPSConnection
+        assert cpool.VerifiedHTTPSConnection is first_cassette_VerifiedHTTPSConnection

tests/integration/test_wild.py

@@ -1,5 +1,6 @@
+import multiprocessing
 import pytest
-from six.moves import xmlrpc_client
+from six.moves import xmlrpc_client, xmlrpc_server
 
 requests = pytest.importorskip("requests")
 
@@ -58,7 +59,7 @@ def test_flickr_multipart_upload(httpbin, tmpdir):
 def test_flickr_should_respond_with_200(tmpdir):
     testfile = str(tmpdir.join('flickr.yml'))
     with vcr.use_cassette(testfile):
-        r = requests.post("http://api.flickr.com/services/upload")
+        r = requests.post("https://api.flickr.com/services/upload", verify=False)
         assert r.status_code == 200
 
 
@@ -76,17 +77,38 @@ def test_amazon_doctype(tmpdir):
     # amazon gzips its homepage.  For some reason, in requests 2.7, it's not
     # getting gunzipped.
     with vcr.use_cassette(str(tmpdir.join('amz.yml'))):
-        r = requests.get('http://www.amazon.com')
+        r = requests.get('http://www.amazon.com', verify=False)
     assert 'html' in r.text
 
 
-def test_xmlrpclib(tmpdir):
+def start_rpc_server(q):
+    httpd = xmlrpc_server.SimpleXMLRPCServer(('127.0.0.1', 0))
+    httpd.register_function(pow)
+    q.put('http://{}:{}'.format(*httpd.server_address))
+    httpd.serve_forever()
+
+
+@pytest.yield_fixture(scope='session')
+def rpc_server():
+    q = multiprocessing.Queue()
+    proxy_process = multiprocessing.Process(
+        target=start_rpc_server,
+        args=(q,)
+    )
+    try:
+        proxy_process.start()
+        yield q.get()
+    finally:
+        proxy_process.terminate()
+
+
+def test_xmlrpclib(tmpdir, rpc_server):
     with vcr.use_cassette(str(tmpdir.join('xmlrpcvideo.yaml'))):
-        roundup_server = xmlrpc_client.ServerProxy('http://bugs.python.org/xmlrpc', allow_none=True)
-        original_schema = roundup_server.schema()
+        roundup_server = xmlrpc_client.ServerProxy(rpc_server, allow_none=True)
+        original_schema = roundup_server.pow(2, 4)
 
     with vcr.use_cassette(str(tmpdir.join('xmlrpcvideo.yaml'))):
-        roundup_server = xmlrpc_client.ServerProxy('http://bugs.python.org/xmlrpc', allow_none=True)
-        second_schema = roundup_server.schema()
+        roundup_server = xmlrpc_client.ServerProxy(rpc_server, allow_none=True)
+        second_schema = roundup_server.pow(2, 4)
 
     assert original_schema == second_schema

tests/unit/test_cassettes.py

@@ -83,7 +83,8 @@ def make_get_request():
 
 
 @mock.patch('vcr.cassette.requests_match', return_value=True)
-@mock.patch('vcr.cassette.load_cassette', lambda *args, **kwargs: (('foo',), (mock.MagicMock(),)))
+@mock.patch('vcr.cassette.FilesystemPersister.load_cassette',
+            classmethod(lambda *args, **kwargs: (('foo',), (mock.MagicMock(),))))
 @mock.patch('vcr.cassette.Cassette.can_play_response_for', return_value=True)
 @mock.patch('vcr.stubs.VCRHTTPResponse')
 def test_function_decorated_with_use_cassette_can_be_invoked_multiple_times(*args):
@@ -132,6 +133,17 @@ def test_cassette_all_played():
     assert a.all_played
 
 
+@mock.patch('vcr.cassette.requests_match', _mock_requests_match)
+def test_cassette_rewound():
+    a = Cassette('test')
+    a.append('foo', 'bar')
+    a.play_response('foo')
+    assert a.all_played
+
+    a.rewind()
+    assert not a.all_played
+
+
 def test_before_record_response():
     before_record_response = mock.Mock(return_value='mutated')
     cassette = Cassette('test', before_record_response=before_record_response)
@@ -305,3 +317,51 @@ def test_use_as_decorator_on_generator():
         yield 2
 
     assert list(test_function()) == [1, 2]
+
+
+@mock.patch("vcr.cassette.get_matchers_results")
+def test_find_requests_with_most_matches_one_similar_request(mock_get_matchers_results):
+    mock_get_matchers_results.side_effect = [
+        (["method"], [("path", "failed : path"), ("query", "failed : query")]),
+        (["method", "path"], [("query", "failed : query")]),
+        ([], [("method", "failed : method"), ("path", "failed : path"), ("query", "failed : query")]),
+    ]
+
+    cassette = Cassette("test")
+    for request in range(1, 4):
+        cassette.append(request, 'response')
+    result = cassette.find_requests_with_most_matches("fake request")
+    assert result == [(2, ["method", "path"], [("query", "failed : query")])]
+
+
+@mock.patch("vcr.cassette.get_matchers_results")
+def test_find_requests_with_most_matches_no_similar_requests(mock_get_matchers_results):
+    mock_get_matchers_results.side_effect = [
+        ([], [("path", "failed : path"), ("query", "failed : query")]),
+        ([], [("path", "failed : path"), ("query", "failed : query")]),
+        ([], [("path", "failed : path"), ("query", "failed : query")]),
+    ]
+
+    cassette = Cassette("test")
+    for request in range(1, 4):
+        cassette.append(request, 'response')
+    result = cassette.find_requests_with_most_matches("fake request")
+    assert result == []
+
+
+@mock.patch("vcr.cassette.get_matchers_results")
+def test_find_requests_with_most_matches_many_similar_requests(mock_get_matchers_results):
+    mock_get_matchers_results.side_effect = [
+        (["method", "path"], [("query", "failed : query")]),
+        (["method"], [("path", "failed : path"), ("query", "failed : query")]),
+        (["method", "path"], [("query", "failed : query")]),
+    ]
+
+    cassette = Cassette("test")
+    for request in range(1, 4):
+        cassette.append(request, 'response')
+    result = cassette.find_requests_with_most_matches("fake request")
+    assert result == [
+        (1, ["method", "path"], [("query", "failed : query")]),
+        (3, ["method", "path"], [("query", "failed : query")])
+    ]

tests/unit/test_errors.py

@@ -0,0 +1,73 @@
+import pytest
+
+from vcr.compat import mock
+from vcr import errors
+from vcr.cassette import Cassette
+
+
+@mock.patch("vcr.cassette.Cassette.find_requests_with_most_matches")
+@pytest.mark.parametrize(
+    "most_matches, expected_message",
+    [
+        # No request match found
+        (
+            [],
+            "No similar requests, that have not been played, found."
+        ),
+        # One matcher failed
+        (
+            [("similar request", ["method", "path"], [("query", "failed : query")])],
+            "Found 1 similar requests with 1 different matcher(s) :\n"
+            "\n1 - ('similar request').\n"
+            "Matchers succeeded : ['method', 'path']\n"
+            "Matchers failed :\n"
+            "query - assertion failure :\n"
+            "failed : query\n"
+
+        ),
+        # Multiple failed matchers
+        (
+            [("similar request", ["method"], [("query", "failed : query"), ("path", "failed : path")])],
+            "Found 1 similar requests with 2 different matcher(s) :\n"
+            "\n1 - ('similar request').\n"
+            "Matchers succeeded : ['method']\n"
+            "Matchers failed :\n"
+            "query - assertion failure :\n"
+            "failed : query\n"
+            "path - assertion failure :\n"
+            "failed : path\n"
+
+        ),
+        # Multiple similar requests
+        (
+            [
+                ("similar request", ["method"], [("query", "failed : query")]),
+                ("similar request 2", ["method"], [("query", "failed : query 2")])
+            ],
+            "Found 2 similar requests with 1 different matcher(s) :\n"
+            "\n1 - ('similar request').\n"
+            "Matchers succeeded : ['method']\n"
+            "Matchers failed :\n"
+            "query - assertion failure :\n"
+            "failed : query\n"
+            "\n2 - ('similar request 2').\n"
+            "Matchers succeeded : ['method']\n"
+            "Matchers failed :\n"
+            "query - assertion failure :\n"
+            "failed : query 2\n"
+
+        ),
+    ]
+)
+def test_CannotOverwriteExistingCassetteException_get_message(
+        mock_find_requests_with_most_matches, most_matches, expected_message):
+    mock_find_requests_with_most_matches.return_value = most_matches
+    cassette = Cassette("path")
+    failed_request = "request"
+    exception_message = errors.CannotOverwriteExistingCassetteException._get_message(
+        cassette, "request"
+    )
+    expected = "Can't overwrite existing cassette (%r) in your current record mode (%r).\n" \
+               "No match for the request (%r) was found.\n" \
+               "%s" % (cassette._path, cassette.record_mode, failed_request, expected_message)
+    assert exception_message == expected

tests/unit/test_matchers.py

@@ -1,4 +1,5 @@
 import itertools
+from vcr.compat import mock
 
 import pytest
 
@@ -21,20 +22,22 @@ REQUESTS = {
 def assert_matcher(matcher_name):
     matcher = getattr(matchers, matcher_name)
     for k1, k2 in itertools.permutations(REQUESTS, 2):
-        matched = matcher(REQUESTS[k1], REQUESTS[k2])
-        if matcher_name in set((k1, k2)):
-            assert not matched
+        expecting_assertion_error = matcher_name in {k1, k2}
+        if expecting_assertion_error:
+            with pytest.raises(AssertionError):
+                matcher(REQUESTS[k1], REQUESTS[k2])
         else:
-            assert matched
+            assert matcher(REQUESTS[k1], REQUESTS[k2]) is None
 
 
 def test_uri_matcher():
     for k1, k2 in itertools.permutations(REQUESTS, 2):
-        matched = matchers.uri(REQUESTS[k1], REQUESTS[k2])
-        if set((k1, k2)) != set(('base', 'method')):
-            assert not matched
+        expecting_assertion_error = {k1, k2} != {"base", "method"}
+        if expecting_assertion_error:
+            with pytest.raises(AssertionError):
+                matchers.uri(REQUESTS[k1], REQUESTS[k2])
         else:
-            assert matched
+            assert matchers.uri(REQUESTS[k1], REQUESTS[k2]) is None
 
 
 req1_body = (b"<?xml version='1.0'?><methodCall><methodName>test</methodName>"
@@ -107,7 +110,7 @@ req2_body = (b"<?xml version='1.0'?><methodCall><methodName>test</methodName>"
     )
 ])
 def test_body_matcher_does_match(r1, r2):
-    assert matchers.body(r1, r2)
+    assert matchers.body(r1, r2) is None
 
 
 @pytest.mark.parametrize("r1, r2", [
@@ -135,25 +138,128 @@ def test_body_matcher_does_match(r1, r2):
     )
 ])
 def test_body_match_does_not_match(r1, r2):
-    assert not matchers.body(r1, r2)
+    with pytest.raises(AssertionError):
+        matchers.body(r1, r2)
 
 
 def test_query_matcher():
-    req1 = request.Request('GET', 'http://host.com/?a=b&c=d', '', {})
-    req2 = request.Request('GET', 'http://host.com/?c=d&a=b', '', {})
-    assert matchers.query(req1, req2)
+    req1 = request.Request("GET", "http://host.com/?a=b&c=d", "", {})
+    req2 = request.Request("GET", "http://host.com/?c=d&a=b", "", {})
+    assert matchers.query(req1, req2) is None
 
-    req1 = request.Request('GET', 'http://host.com/?a=b&a=b&c=d', '', {})
-    req2 = request.Request('GET', 'http://host.com/?a=b&c=d&a=b', '', {})
-    req3 = request.Request('GET', 'http://host.com/?c=d&a=b&a=b', '', {})
-    assert matchers.query(req1, req2)
-    assert matchers.query(req1, req3)
+    req1 = request.Request("GET", "http://host.com/?a=b&a=b&c=d", "", {})
+    req2 = request.Request("GET", "http://host.com/?a=b&c=d&a=b", "", {})
+    req3 = request.Request("GET", "http://host.com/?c=d&a=b&a=b", "", {})
+    assert matchers.query(req1, req2) is None
+    assert matchers.query(req1, req3) is None
 
 
-def test_metchers():
-    assert_matcher('method')
-    assert_matcher('scheme')
-    assert_matcher('host')
-    assert_matcher('port')
-    assert_matcher('path')
-    assert_matcher('query')
+def test_matchers():
+    assert_matcher("method")
+    assert_matcher("scheme")
+    assert_matcher("host")
+    assert_matcher("port")
+    assert_matcher("path")
+    assert_matcher("query")
+
+
+def test_evaluate_matcher_does_match():
+    def bool_matcher(r1, r2):
+        return True
+
+    def assertion_matcher(r1, r2):
+        assert 1 == 1
+
+    r1, r2 = None, None
+    for matcher in [bool_matcher, assertion_matcher]:
+        match, assertion_msg = matchers._evaluate_matcher(matcher, r1, r2)
+        assert match is True
+        assert assertion_msg is None
+
+
+def test_evaluate_matcher_does_not_match():
+    def bool_matcher(r1, r2):
+        return False
+
+    def assertion_matcher(r1, r2):
+        # This is like the "assert" statement preventing pytest to recompile it
+        raise AssertionError()
+
+    r1, r2 = None, None
+    for matcher in [bool_matcher, assertion_matcher]:
+        match, assertion_msg = matchers._evaluate_matcher(matcher, r1, r2)
+        assert match is False
+        assert not assertion_msg
+
+
+def test_evaluate_matcher_does_not_match_with_assert_message():
+    def assertion_matcher(r1, r2):
+        # This is like the "assert" statement preventing pytest to recompile it
+        raise AssertionError("Failing matcher")
+
+    r1, r2 = None, None
+    match, assertion_msg = matchers._evaluate_matcher(assertion_matcher, r1, r2)
+    assert match is False
+    assert assertion_msg == "Failing matcher"
+
+
+def test_get_assertion_message():
+    assert matchers.get_assertion_message(None) is None
+    assert matchers.get_assertion_message("") == ""
+
+
+def test_get_assertion_message_with_details():
+    assertion_msg = "q1=1 != q2=1"
+    expected = assertion_msg
+    assert matchers.get_assertion_message(assertion_msg) == expected
+
+
+@pytest.mark.parametrize(
+    "r1, r2, expected_successes, expected_failures",
+    [
+        (
+            request.Request("GET", "http://host.com/p?a=b", "", {}),
+            request.Request("GET", "http://host.com/p?a=b", "", {}),
+            ["method", "path"],
+            [],
+        ),
+        (
+            request.Request("GET", "http://host.com/p?a=b", "", {}),
+            request.Request("POST", "http://host.com/p?a=b", "", {}),
+            ["path"],
+            ["method"],
+        ),
+        (
+            request.Request("GET", "http://host.com/p?a=b", "", {}),
+            request.Request("POST", "http://host.com/path?a=b", "", {}),
+            [],
+            ["method", "path"],
+        ),
+    ],
+)
+def test_get_matchers_results(r1, r2, expected_successes, expected_failures):
+    successes, failures = matchers.get_matchers_results(
+        r1, r2, [matchers.method, matchers.path]
+    )
+    assert successes == expected_successes
+    assert len(failures) == len(expected_failures)
+    for i, expected_failure in enumerate(expected_failures):
+        assert failures[i][0] == expected_failure
+        assert failures[i][1] is not None
+
+
+@mock.patch("vcr.matchers.get_matchers_results")
+@pytest.mark.parametrize(
+    "successes, failures, expected_match",
+    [
+        (["method", "path"], [], True),
+        (["method"], ["path"], False),
+        ([], ["method", "path"], False),
+    ],
+)
+def test_requests_match(mock_get_matchers_results, successes, failures, expected_match):
+    mock_get_matchers_results.return_value = (successes, failures)
+    r1 = request.Request("GET", "http://host.com/p?a=b", "", {})
+    r2 = request.Request("GET", "http://host.com/p?a=b", "", {})
+    match = matchers.requests_match(r1, r2, [matchers.method, matchers.path])
+    assert match is expected_match

tests/unit/test_migration.py

@@ -5,6 +5,12 @@ import yaml
 
 import vcr.migration
 
+# Use the libYAML versions if possible
+try:
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader
+
 
 def test_try_migrate_with_json(tmpdir):
     cassette = tmpdir.join('cassette.json').strpath
@@ -22,9 +28,9 @@ def test_try_migrate_with_yaml(tmpdir):
     shutil.copy('tests/fixtures/migration/old_cassette.yaml', cassette)
     assert vcr.migration.try_migrate(cassette)
     with open('tests/fixtures/migration/new_cassette.yaml', 'r') as f:
-        expected_yaml = yaml.load(f)
+        expected_yaml = yaml.load(f, Loader=Loader)
     with open(cassette, 'r') as f:
-        actual_yaml = yaml.load(f)
+        actual_yaml = yaml.load(f, Loader=Loader)
     assert actual_yaml == expected_yaml
 
 

tests/unit/test_persist.py

@@ -1,6 +1,6 @@
 import pytest
 
-import vcr.persist
+from vcr.persisters.filesystem import FilesystemPersister
 from vcr.serializers import jsonserializer, yamlserializer
 
 
@@ -10,7 +10,7 @@ from vcr.serializers import jsonserializer, yamlserializer
 ])
 def test_load_cassette_with_old_cassettes(cassette_path, serializer):
     with pytest.raises(ValueError) as excinfo:
-        vcr.persist.load_cassette(cassette_path, serializer)
+        FilesystemPersister.load_cassette(cassette_path, serializer)
     assert "run the migration script" in excinfo.exconly()
 
 
@@ -20,5 +20,5 @@ def test_load_cassette_with_old_cassettes(cassette_path, serializer):
 ])
 def test_load_cassette_with_invalid_cassettes(cassette_path, serializer):
     with pytest.raises(Exception) as excinfo:
-        vcr.persist.load_cassette(cassette_path, serializer)
+        FilesystemPersister.load_cassette(cassette_path, serializer)
     assert "run the migration script" not in excinfo.exconly()

tests/unit/test_request.py

@@ -3,9 +3,13 @@ import pytest
 from vcr.request import Request, HeadersDict
 
 
-def test_str():
-    req = Request('GET', 'http://www.google.com/', '', {})
-    str(req) == '<Request (GET) http://www.google.com/>'
+@pytest.mark.parametrize("method, uri, expected_str", [
+    ('GET', 'http://www.google.com/', '<Request (GET) http://www.google.com/>'),
+    ('OPTIONS', '*', '<Request (OPTIONS) *>'),
+    ('CONNECT', 'host.some.where:1234', '<Request (CONNECT) host.some.where:1234>')
+])
+def test_str(method, uri, expected_str):
+    assert str(Request(method, uri, '', {})) == expected_str
 
 
 def test_headers():
@@ -29,18 +33,21 @@ def test_add_header_deprecated():
     ('https://go.com/', 443),
     ('https://go.com:443/', 443),
     ('https://go.com:3000/', 3000),
+    ('*', None)
 ])
 def test_port(uri, expected_port):
     req = Request('GET', uri, '', {})
     assert req.port == expected_port
 
 
-def test_uri():
-    req = Request('GET', 'http://go.com/', '', {})
-    assert req.uri == 'http://go.com/'
-
-    req = Request('GET', 'http://go.com:80/', '', {})
-    assert req.uri == 'http://go.com:80/'
+@pytest.mark.parametrize("method, uri", [
+    ('GET', 'http://go.com/'),
+    ('GET', 'http://go.com:80/'),
+    ('CONNECT', 'localhost:1234'),
+    ('OPTIONS', '*')
+])
+def test_uri(method, uri):
+    assert Request(method, uri, '', {}).uri == uri
 
 
 def test_HeadersDict():

tests/unit/test_response.py

@@ -1,4 +1,9 @@
 # coding: UTF-8
+import io
+import unittest
+
+import six
+
 from vcr.stubs import VCRHTTPResponse
 
 
@@ -66,3 +71,52 @@ def test_response_headers_should_have_correct_values():
 
     assert response.headers.get('content-length') == "10806"
     assert response.headers.get('date') == "Fri, 24 Oct 2014 18:35:37 GMT"
+
+
+@unittest.skipIf(six.PY2, "Regression test for Python3 only")
+def test_response_parses_correctly_and_fp_attribute_error_is_not_thrown():
+    """
+    Regression test for https://github.com/kevin1024/vcrpy/issues/440
+    :return:
+    """
+    recorded_response = {
+        "status": {
+            "message": "OK",
+            "code": 200
+        },
+        "headers": {
+            "content-length": ["0"],
+            "server": ["gunicorn/18.0"],
+            "connection": ["Close"],
+            "access-control-allow-credentials": ["true"],
+            "date": ["Fri, 24 Oct 2014 18:35:37 GMT"],
+            "access-control-allow-origin": ["*"],
+            "content-type": ["text/html; charset=utf-8"],
+        },
+        "body": {
+            "string": b"\nPMID- 19416910\nOWN - NLM\nSTAT- MEDLINE\nDA  - 20090513\nDCOM- "
+                      b"20090622\nLR  - "
+                      b"20141209\nIS  - 1091-6490 (Electronic)\nIS  - 0027-8424 (Linking)\nVI  - "
+                      b"106\nIP  - "
+                      b"19\nDP  - 2009 May 12\nTI  - Genetic dissection of histone deacetylase "
+                      b"requirement in "
+                      b"tumor cells.\nPG  - 7751-5\nLID - 10.1073/pnas.0903139106 [doi]\nAB  - "
+                      b"Histone "
+                      b"deacetylase inhibitors (HDACi) represent a new group of drugs currently\n "
+                      b"     being "
+                      b"tested in a wide variety of clinical applications. They are especially\n  "
+                      b"    effective "
+                      b"in preclinical models of cancer where they show antiproliferative\n      "
+                      b"action in many "
+                      b"different types of cancer cells. Recently, the first HDACi was\n      "
+                      b"approved for the "
+                      b"treatment of cutaneous T cell lymphomas. Most HDACi currently in\n      "
+                      b"clinical "
+
+        }
+    }
+    vcr_response = VCRHTTPResponse(recorded_response)
+    handle = io.TextIOWrapper(io.BufferedReader(vcr_response), encoding='utf-8')
+    handle = iter(handle)
+    articles = [line for line in handle]
+    assert len(articles) > 1

tests/unit/test_serialize.py

@@ -4,7 +4,7 @@ import pytest
 from vcr.compat import mock
 from vcr.request import Request
 from vcr.serialize import deserialize, serialize
-from vcr.serializers import yamlserializer, jsonserializer
+from vcr.serializers import yamlserializer, jsonserializer, compat
 
 
 def test_deserialize_old_yaml_cassette():
@@ -131,3 +131,9 @@ def test_serialize_binary_request():
         )
     except (UnicodeDecodeError, TypeError) as exc:
         assert msg in str(exc)
+
+
+def test_deserialize_no_body_string():
+    data = {'body': {'string': None}}
+    output = compat.convert_to_bytes(data)
+    assert data == output

tests/unit/test_stubs.py

@@ -1,4 +1,6 @@
 from vcr.stubs import VCRHTTPSConnection
+from vcr.compat import mock
+from vcr.cassette import Cassette
 
 
 class TestVCRConnection(object):
@@ -7,3 +9,10 @@ class TestVCRConnection(object):
         vcr_connection = VCRHTTPSConnection('www.examplehost.com')
         vcr_connection.ssl_version = 'example_ssl_version'
         assert vcr_connection.real_connection.ssl_version == 'example_ssl_version'
+
+    @mock.patch('vcr.cassette.Cassette.can_play_response_for', return_value=False)
+    def testing_connect(*args):
+        vcr_connection = VCRHTTPSConnection('www.google.com')
+        vcr_connection.cassette = Cassette('test', record_mode='all')
+        vcr_connection.real_connection.connect()
+        assert vcr_connection.real_connection.sock is not None

tests/unit/test_vcr.py

@@ -94,7 +94,7 @@ def test_vcr_before_record_response_iterable():
     response = object()  # just can't be None
 
     # Prevent actually saving the cassette
-    with mock.patch('vcr.cassette.save_cassette'):
+    with mock.patch('vcr.cassette.FilesystemPersister.save_cassette'):
 
         # Baseline: non-iterable before_record_response should work
         mock_filter = mock.Mock()
@@ -118,7 +118,7 @@ def test_before_record_response_as_filter():
     response = object()  # just can't be None
 
     # Prevent actually saving the cassette
-    with mock.patch('vcr.cassette.save_cassette'):
+    with mock.patch('vcr.cassette.FilesystemPersister.save_cassette'):
 
         filter_all = mock.Mock(return_value=None)
         vcr = VCR(before_record_response=filter_all)
@@ -132,7 +132,7 @@ def test_vcr_path_transformer():
     # Regression test for #199
 
     # Prevent actually saving the cassette
-    with mock.patch('vcr.cassette.save_cassette'):
+    with mock.patch('vcr.cassette.FilesystemPersister.save_cassette'):
 
         # Baseline: path should be unchanged
         vcr = VCR()
@@ -147,7 +147,7 @@ def test_vcr_path_transformer():
         # and it should still work with cassette_library_dir
         vcr = VCR(cassette_library_dir='/foo')
         with vcr.use_cassette('test') as cassette:
-            assert cassette._path == '/foo/test'
+            assert os.path.abspath(cassette._path) == os.path.abspath('/foo/test')
 
 
 @pytest.fixture
@@ -319,11 +319,11 @@ def test_additional_matchers():
 
     @vcr.use_cassette
     def function_defaults(cassette):
-        assert set(cassette._match_on) == set([vcr.matchers['uri']])
+        assert set(cassette._match_on) == {vcr.matchers['uri']}
 
     @vcr.use_cassette(additional_matchers=('body',))
     def function_additional(cassette):
-        assert set(cassette._match_on) == set([vcr.matchers['uri'], vcr.matchers['body']])
+        assert set(cassette._match_on) == {vcr.matchers['uri'], vcr.matchers['body']}
 
     function_defaults()
     function_additional()

tests/unit/test_vcr_import.py

@@ -0,0 +1,16 @@
+import sys
+
+
+def test_vcr_import_deprecation(recwarn):
+
+    if 'vcr' in sys.modules:
+        # Remove imported module entry if already loaded in another test
+        del sys.modules['vcr']
+
+    import vcr  # noqa: F401
+
+    if sys.version_info[0] == 2:
+        assert len(recwarn) == 1
+        assert issubclass(recwarn[0].category, DeprecationWarning)
+    else:
+        assert len(recwarn) == 0

tox.ini

@@ -1,40 +1,62 @@
 [tox]
-envlist = {py26,py27,py33,py34,pypy,pypy3}-{flakes,requests27,requests26,requests25,requests24,requests23,requests22,requests1,httplib2,urllib317,urllib319,urllib3110,tornado3,tornado4,boto}
+skip_missing_interpreters=true
+envlist = cov-clean,{py27,py35,py36,py37,pypy}-{flakes,requests,httplib2,urllib3,tornado4,boto3},{py35,py36,py37}-{aiohttp},cov-report
+
+
+# Coverage environment tasks: cov-clean and cov-report
+# https://pytest-cov.readthedocs.io/en/latest/tox.html
+[testenv:cov-clean]
+deps = coverage
+skip_install=true
+commands = coverage erase
+
+[testenv:cov-report]
+deps = coverage
+skip_install=true
+commands = 
+  coverage html
+  coverage report --fail-under=75
 
 [testenv:flakes]
 skipsdist = True
 commands =
     flake8 --version
-    flake8 --exclude="./docs/conf.py"
+    flake8 --exclude=./docs/conf.py,./.tox/
     pyflakes ./docs/conf.py
 deps = flake8
 
 [testenv]
+# Need to use develop install so that paths
+# for aggregate code coverage combine
+usedevelop=true
 commands =
-    ./runtests.sh {posargs}
+    ./runtests.sh --cov=./vcr --cov-branch --cov-report=xml --cov-append {posargs}
 deps =
+    Flask
     mock
     pytest
     pytest-httpbin
+    pytest-cov
     PyYAML
-    requests1: requests==1.2.3
-    requests27: requests==2.7.0
-    requests26: requests==2.6.0
-    requests25: requests==2.5.0
-    requests24: requests==2.4.0
-    requests23: requests==2.3.0
-    requests22: requests==2.2.1
+    ipaddress
+    requests: requests>=2.22.0
     httplib2: httplib2
-    urllib317: urllib3==1.7.1
-    urllib319: urllib3==1.9.1
-    urllib3110: urllib3==1.10.2
-    {py26,py27,py33,py34,pypy}-tornado3: tornado>=3,<4
-    {py26,py27,py33,py34,pypy}-tornado4: tornado>=4,<5
-    {py26,py27,py33,py34,pypy}-tornado3: pytest-tornado
-    {py26,py27,py33,py34,pypy}-tornado4: pytest-tornado
-    {py26,py27,py33,py34}-tornado3: pycurl
-    {py26,py27,py33,py34}-tornado4: pycurl
-    boto: boto
+    urllib3: urllib3
+    {py27,py35,py36,pypy}-tornado4: tornado>=4,<5
+    {py27,py35,py36,pypy}-tornado4: pytest-tornado
+    {py27,py35,py36}-tornado4: pycurl
+    boto3: boto3
+    boto3: urllib3
+    aiohttp: aiohttp
+    aiohttp: pytest-asyncio
+    aiohttp: pytest-aiohttp
+depends = 
+  {py27,py35,py36,py37,pypy}-{flakes,requests,httplib2,urllib3,tornado4,boto3},{py35,py36,py37}-{aiohttp}: cov-clean
+  cov-report: {py27,py35,py36,py37,pypy}-{flakes,requests,httplib2,urllib3,tornado4,boto3},{py35,py36,py37}-{aiohttp}
+passenv =
+    AWS_ACCESS_KEY_ID
+    AWS_DEFAULT_REGION
+    AWS_SECRET_ACCESS_KEY
 
 [flake8]
 max_line_length = 110

vcr/__init__.py

@@ -1,4 +1,6 @@
 import logging
+import warnings
+import sys
 from .config import VCR
 
 # Set default logging handler to avoid "No handler found" warnings.
@@ -9,6 +11,11 @@ except ImportError:
         def emit(self, record):
             pass
 
+if sys.version_info[0] == 2:
+    warnings.warn(
+        "Python 2.x support of vcrpy is deprecated and will be removed in an upcoming major release.",
+        DeprecationWarning
+    )
 
 logging.getLogger(__name__).addHandler(NullHandler())
 

vcr/_handle_coroutine.py

@@ -0,0 +1,3 @@
+async def handle_coroutine(vcr, fn):  # noqa: E999
+    with vcr as cassette:
+        return (await fn(cassette))  # noqa: E999

vcr/cassette.py

@@ -1,17 +1,31 @@
+import collections
+import copy
 import sys
 import inspect
 import logging
 
 import wrapt
 
-from .compat import contextlib, collections
+from .compat import contextlib
 from .errors import UnhandledHTTPRequestError
-from .matchers import requests_match, uri, method
+from .matchers import requests_match, uri, method, get_matchers_results
 from .patch import CassettePatcherBuilder
-from .persist import load_cassette, save_cassette
 from .serializers import yamlserializer
+from .persisters.filesystem import FilesystemPersister
 from .util import partition_dict
 
+try:
+    from asyncio import iscoroutinefunction
+except ImportError:
+    def iscoroutinefunction(*args, **kwargs):
+        return False
+
+if sys.version_info[:2] >= (3, 5):
+    from ._handle_coroutine import handle_coroutine
+else:
+    def handle_coroutine(*args, **kwags):
+        raise NotImplementedError('Not implemented on Python 2')
+
 
 log = logging.getLogger(__name__)
 
@@ -96,18 +110,25 @@ class CassetteContextDecorator(object):
         )
 
     def _execute_function(self, function, args, kwargs):
-        if inspect.isgeneratorfunction(function):
-            handler = self._handle_coroutine
-        else:
-            handler = self._handle_function
-        return handler(function, args, kwargs)
+        def handle_function(cassette):
+            if cassette.inject:
+                return function(cassette, *args, **kwargs)
+            else:
+                return function(*args, **kwargs)
 
-    def _handle_coroutine(self, function, args, kwargs):
-        """Wraps a coroutine so that we're inside the cassette context for the
-        duration of the coroutine.
+        if iscoroutinefunction(function):
+            return handle_coroutine(vcr=self, fn=handle_function)
+        if inspect.isgeneratorfunction(function):
+            return self._handle_generator(fn=handle_function)
+
+        return self._handle_function(fn=handle_function)
+
+    def _handle_generator(self, fn):
+        """Wraps a generator so that we're inside the cassette context for the
+        duration of the generator.
         """
         with self as cassette:
-            coroutine = self.__handle_function(cassette, function, args, kwargs)
+            coroutine = fn(cassette)
             # We don't need to catch StopIteration. The caller (Tornado's
             # gen.coroutine, for example) will handle that.
             to_yield = next(coroutine)
@@ -117,17 +138,14 @@ class CassetteContextDecorator(object):
                 except Exception:
                     to_yield = coroutine.throw(*sys.exc_info())
                 else:
-                    to_yield = coroutine.send(to_send)
+                    try:
+                        to_yield = coroutine.send(to_send)
+                    except StopIteration:
+                        break
 
-    def __handle_function(self, cassette, function, args, kwargs):
-        if cassette.inject:
-            return function(cassette, *args, **kwargs)
-        else:
-            return function(*args, **kwargs)
-
-    def _handle_function(self, function, args, kwargs):
+    def _handle_function(self, fn):
         with self as cassette:
-            return self.__handle_function(cassette, function, args, kwargs)
+            return fn(cassette)
 
     @staticmethod
     def get_function_name(function):
@@ -163,15 +181,16 @@ class Cassette(object):
     def use(cls, **kwargs):
         return CassetteContextDecorator.from_args(cls, **kwargs)
 
-    def __init__(self, path, serializer=yamlserializer, record_mode='once',
+    def __init__(self, path, serializer=None, persister=None, record_mode='once',
                  match_on=(uri, method), before_record_request=None,
                  before_record_response=None, custom_patches=(),
                  inject=False):
-
+        self._persister = persister or FilesystemPersister
         self._path = path
-        self._serializer = serializer
+        self._serializer = serializer or yamlserializer
         self._match_on = match_on
         self._before_record_request = before_record_request or (lambda x: x)
+        log.info(self._before_record_request)
         self._before_record_response = before_record_response or (lambda x: x)
         self.inject = inject
         self.record_mode = record_mode
@@ -207,9 +226,13 @@ class Cassette(object):
 
     def append(self, request, response):
         """Add a request, response pair to this cassette"""
+        log.info("Appending request %s and response %s", request, response)
         request = self._before_record_request(request)
         if not request:
             return
+        # Deepcopy is here because mutation of `response` will corrupt the
+        # real response.
+        response = copy.deepcopy(response)
         response = self._before_record_response(response)
         if response is None:
             return
@@ -266,33 +289,72 @@ class Cassette(object):
             % (self._path, request)
         )
 
+    def rewind(self):
+        self.play_counts = collections.Counter()
+
+    def find_requests_with_most_matches(self, request):
+        """
+        Get the most similar request(s) stored in the cassette
+        of a given request as a list of tuples like this:
+        - the request object
+        - the successful matchers as string
+        - the failed matchers and the related assertion message with the difference details as strings tuple
+
+        This is useful when a request failed to be found,
+        we can get the similar request(s) in order to know what have changed in the request parts.
+        """
+        best_matches = []
+        request = self._before_record_request(request)
+        for index, (stored_request, response) in enumerate(self.data):
+            successes, fails = get_matchers_results(request, stored_request, self._match_on)
+            best_matches.append((len(successes), stored_request, successes, fails))
+        best_matches.sort(key=lambda t: t[0], reverse=True)
+        # Get the first best matches (multiple if equal matches)
+        final_best_matches = []
+
+        if not best_matches:
+            return final_best_matches
+
+        previous_nb_success = best_matches[0][0]
+        for best_match in best_matches:
+            nb_success = best_match[0]
+            # Do not keep matches that have 0 successes,
+            # it means that the request is totally different from
+            # the ones stored in the cassette
+            if nb_success < 1 or previous_nb_success != nb_success:
+                break
+            previous_nb_success = nb_success
+            final_best_matches.append(best_match[1:])
+
+        return final_best_matches
+
     def _as_dict(self):
         return {"requests": self.requests, "responses": self.responses}
 
     def _save(self, force=False):
         if force or self.dirty:
-            save_cassette(
+            self._persister.save_cassette(
                 self._path,
                 self._as_dict(),
-                serializer=self._serializer
+                serializer=self._serializer,
             )
             self.dirty = False
 
     def _load(self):
         try:
-            requests, responses = load_cassette(
+            requests, responses = self._persister.load_cassette(
                 self._path,
-                serializer=self._serializer
+                serializer=self._serializer,
             )
             for request, response in zip(requests, responses):
                 self.append(request, response)
             self.dirty = False
             self.rewound = True
-        except IOError:
+        except ValueError:
             pass
 
     def __str__(self):
-        return "<Cassette containing {0} recorded response(s)>".format(
+        return "<Cassette containing {} recorded response(s)>".format(
             len(self)
         )
 

vcr/compat.py

@@ -11,8 +11,4 @@ else:
     if not hasattr(contextlib, 'ExitStack'):
         import contextlib2 as contextlib
 
-import collections
-if not hasattr(collections, 'Counter'):
-    import backport_collections as collections
-
-__all__ = ['mock', 'contextlib', 'collections']
+__all__ = ['mock', 'contextlib']

vcr/config.py

@@ -1,4 +1,8 @@
 import copy
+try:
+    from collections import abc as collections_abc  # only works on python 3.3+
+except ImportError:
+    import collections as collections_abc
 import functools
 import inspect
 import os
@@ -6,9 +10,9 @@ import types
 
 import six
 
-from .compat import collections
 from .cassette import Cassette
 from .serializers import yamlserializer, jsonserializer
+from .persisters.filesystem import FilesystemPersister
 from .util import compose, auto_decorate
 from . import matchers
 from . import filters
@@ -57,6 +61,7 @@ class VCR(object):
             'raw_body': matchers.raw_body,
             'body': matchers.body,
         }
+        self.persister = FilesystemPersister
         self.record_mode = record_mode
         self.filter_headers = filter_headers
         self.filter_query_parameters = filter_query_parameters
@@ -76,7 +81,7 @@ class VCR(object):
             serializer = self.serializers[serializer_name]
         except KeyError:
             raise KeyError(
-                "Serializer {0} doesn't exist or isn't registered".format(
+                "Serializer {} doesn't exist or isn't registered".format(
                     serializer_name
                 )
             )
@@ -89,7 +94,7 @@ class VCR(object):
                 matchers.append(self.matchers[m])
         except KeyError:
             raise KeyError(
-                "Matcher {0} doesn't exist or isn't registered".format(m)
+                "Matcher {} doesn't exist or isn't registered".format(m)
             )
         return matchers
 
@@ -143,6 +148,7 @@ class VCR(object):
 
         merged_config = {
             'serializer': self._get_serializer(serializer_name),
+            'persister': self.persister,
             'match_on': self._get_matchers(
                 tuple(matcher_names) + tuple(additional_matchers)
             ),
@@ -172,7 +178,7 @@ class VCR(object):
         if decode_compressed_response:
             filter_functions.append(filters.decode_response)
         if before_record_response:
-            if not isinstance(before_record_response, collections.Iterable):
+            if not isinstance(before_record_response, collections_abc.Iterable):
                 before_record_response = (before_record_response,)
             filter_functions.extend(before_record_response)
 
@@ -238,7 +244,7 @@ class VCR(object):
             filter_functions.append(self._build_ignore_hosts(hosts_to_ignore))
 
         if before_record_request:
-            if not isinstance(before_record_request, collections.Iterable):
+            if not isinstance(before_record_request, collections_abc.Iterable):
                 before_record_request = (before_record_request,)
             filter_functions.extend(before_record_request)
 
@@ -270,6 +276,10 @@ class VCR(object):
     def register_matcher(self, name, matcher):
         self.matchers[name] = matcher
 
+    def register_persister(self, persister):
+        # Singleton, no name required
+        self.persister = persister
+
     def test_case(self, predicate=None):
         predicate = predicate or self.is_test_method
         return six.with_metaclass(auto_decorate(self.use_cassette, predicate))

vcr/errors.py

@@ -1,5 +1,38 @@
 class CannotOverwriteExistingCassetteException(Exception):
-    pass
+    def __init__(self, *args, **kwargs):
+        self.cassette = kwargs["cassette"]
+        self.failed_request = kwargs["failed_request"]
+        message = self._get_message(kwargs["cassette"], kwargs["failed_request"])
+        super(CannotOverwriteExistingCassetteException, self).__init__(message)
+
+    @staticmethod
+    def _get_message(cassette, failed_request):
+        """Get the final message related to the exception"""
+        # Get the similar requests in the cassette that
+        # have match the most with the request.
+        best_matches = cassette.find_requests_with_most_matches(failed_request)
+        if best_matches:
+            # Build a comprehensible message to put in the exception.
+            best_matches_msg = "Found {} similar requests with {} different matcher(s) :\n".format(
+                len(best_matches), len(best_matches[0][2]))
+
+            for idx, best_match in enumerate(best_matches, start=1):
+                request, succeeded_matchers, failed_matchers_assertion_msgs = best_match
+                best_matches_msg += "\n%s - (%r).\n" \
+                                    "Matchers succeeded : %s\n" \
+                                    "Matchers failed :\n" % (idx, request, succeeded_matchers)
+                for failed_matcher, assertion_msg in failed_matchers_assertion_msgs:
+                    best_matches_msg += "%s - assertion failure :\n" \
+                                        "%s\n" % (failed_matcher, assertion_msg)
+        else:
+            best_matches_msg = "No similar requests, that have not been played, found."
+        return (
+            "Can't overwrite existing cassette (%r) in "
+            "your current record mode (%r).\n"
+            "No match for the request (%r) was found.\n"
+            "%s"
+            % (cassette._path, cassette.record_mode, failed_request, best_matches_msg)
+        )
 
 
 class UnhandledHTTPRequestError(KeyError):

vcr/filters.py

@@ -146,9 +146,11 @@ def decode_response(response):
         else:  # encoding == 'deflate'
             return zlib.decompress(body)
 
+    # Deepcopy here in case `headers` contain objects that could
+    # be mutated by a shallow copy and corrupt the real response.
+    response = copy.deepcopy(response)
     headers = CaseInsensitiveDict(response['headers'])
     if is_compressed(headers):
-        response = copy.deepcopy(response)
         encoding = headers['content-encoding'][0]
         headers['content-encoding'].remove(encoding)
         if not headers['content-encoding']:

vcr/matchers.py

@@ -8,35 +8,47 @@ log = logging.getLogger(__name__)
 
 
 def method(r1, r2):
-    return r1.method == r2.method
+    assert r1.method == r2.method, "{} != {}".format(r1.method, r2.method)
 
 
 def uri(r1, r2):
-    return r1.uri == r2.uri
+    assert r1.uri == r2.uri, "{} != {}".format(r1.uri, r2.uri)
 
 
 def host(r1, r2):
-    return r1.host == r2.host
+    assert r1.host == r2.host, "{} != {}".format(r1.host, r2.host)
 
 
 def scheme(r1, r2):
-    return r1.scheme == r2.scheme
+    assert r1.scheme == r2.scheme, "{} != {}".format(r1.scheme, r2.scheme)
 
 
 def port(r1, r2):
-    return r1.port == r2.port
+    assert r1.port == r2.port, "{} != {}".format(r1.port, r2.port)
 
 
 def path(r1, r2):
-    return r1.path == r2.path
+    assert r1.path == r2.path, "{} != {}".format(r1.path, r2.path)
 
 
 def query(r1, r2):
-    return r1.query == r2.query
+    assert r1.query == r2.query, "{} != {}".format(r1.query, r2.query)
 
 
 def raw_body(r1, r2):
-    return read_body(r1) == read_body(r2)
+    assert read_body(r1) == read_body(r2)
+
+
+def body(r1, r2):
+    transformer = _get_transformer(r1)
+    r2_transformer = _get_transformer(r2)
+    if transformer != r2_transformer:
+        transformer = _identity
+    assert transformer(read_body(r1)) == transformer(read_body(r2))
+
+
+def headers(r1, r2):
+    assert r1.headers == r2.headers, "{} != {}".format(r1.headers, r2.headers)
 
 
 def _header_checker(value, header='Content-Type'):
@@ -49,15 +61,19 @@ def _transform_json(body):
     # Request body is always a byte string, but json.loads() wants a text
     # string. RFC 7159 says the default encoding is UTF-8 (although UTF-16
     # and UTF-32 are also allowed: hmmmmm).
-    return json.loads(body.decode('utf-8'))
+    if body:
+        return json.loads(body.decode('utf-8'))
 
 
 _xml_header_checker = _header_checker('text/xml')
 _xmlrpc_header_checker = _header_checker('xmlrpc', header='User-Agent')
 _checker_transformer_pairs = (
-    (_header_checker('application/x-www-form-urlencoded'), urllib.parse.parse_qs),
-    (_header_checker('application/json'), _transform_json),
-    (lambda request: _xml_header_checker(request) and _xmlrpc_header_checker(request), xmlrpc_client.loads),
+    (_header_checker('application/x-www-form-urlencoded'),
+        lambda body: urllib.parse.parse_qs(body.decode('ascii'))),
+    (_header_checker('application/json'),
+        _transform_json),
+    (lambda request: _xml_header_checker(request) and _xmlrpc_header_checker(request),
+        xmlrpc_client.loads),
 )
 
 
@@ -73,28 +89,54 @@ def _get_transformer(request):
         return _identity
 
 
-def body(r1, r2):
-    transformer = _get_transformer(r1)
-    r2_transformer = _get_transformer(r2)
-    if transformer != r2_transformer:
-        transformer = _identity
-    return transformer(read_body(r1)) == transformer(read_body(r2))
-
-
-def headers(r1, r2):
-    return r1.headers == r2.headers
-
-
-def _log_matches(r1, r2, matches):
-    differences = [m for m in matches if not m[0]]
-    if differences:
-        log.debug(
-            "Requests {0} and {1} differ according to "
-            "the following matchers: {2}".format(r1, r2, differences)
-        )
-
-
 def requests_match(r1, r2, matchers):
-    matches = [(m(r1, r2), m) for m in matchers]
-    _log_matches(r1, r2, matches)
-    return all([m[0] for m in matches])
+    successes, failures = get_matchers_results(r1, r2, matchers)
+    if failures:
+        log.debug(
+            "Requests {} and {} differ.\n"
+            "Failure details:\n"
+            "{}".format(r1, r2, failures)
+        )
+    return len(failures) == 0
+
+
+def _evaluate_matcher(matcher_function, *args):
+    """
+    Evaluate the result of a given matcher as a boolean with an assertion error message if any.
+    It handles two types of matcher :
+    - a matcher returning a boolean value.
+    - a matcher that only makes an assert, returning None or raises an assertion error.
+    """
+    assertion_message = None
+    try:
+        match = matcher_function(*args)
+        match = True if match is None else match
+    except AssertionError as e:
+        match = False
+        assertion_message = str(e)
+    return match, assertion_message
+
+
+def get_matchers_results(r1, r2, matchers):
+    """
+    Get the comparison results of two requests as two list.
+    The first returned list represents the matchers names that passed.
+    The second list is the failed matchers as a string with failed assertion details if any.
+    """
+    matches_success, matches_fails = [], []
+    for m in matchers:
+        matcher_name = m.__name__
+        match, assertion_message = _evaluate_matcher(m, r1, r2)
+        if match:
+            matches_success.append(matcher_name)
+        else:
+            assertion_message = get_assertion_message(assertion_message)
+            matches_fails.append((matcher_name, assertion_message))
+    return matches_success, matches_fails
+
+
+def get_assertion_message(assertion_details):
+    """
+    Get a detailed message about the failing matcher.
+    """
+    return assertion_details

vcr/migration.py

@@ -59,7 +59,7 @@ def build_uri(**parts):
     port = parts['port']
     scheme = parts['protocol']
     default_port = {'https': 443, 'http': 80}[scheme]
-    parts['port'] = ':{0}'.format(port) if port != default_port else ''
+    parts['port'] = ':{}'.format(port) if port != default_port else ''
     return "{protocol}://{host}{port}{path}".format(**parts)
 
 
@@ -68,7 +68,7 @@ def _migrate(data):
     for item in data:
         req = item['request']
         res = item['response']
-        uri = dict((k, req.pop(k)) for k in PARTS)
+        uri = {k: req.pop(k) for k in PARTS}
         req['uri'] = build_uri(**uri)
         # convert headers to dict of lists
         headers = req['headers']
@@ -100,7 +100,7 @@ def migrate_json(in_fp, out_fp):
 
 
 def _list_of_tuples_to_dict(fs):
-    return dict((k, v) for k, v in fs[0])
+    return {k: v for k, v in fs[0]}
 
 
 def _already_migrated(data):
@@ -159,10 +159,11 @@ def main():
                  for (root, dirs, files) in os.walk(path)
                  for name in files)
     for file_path in files:
-            migrated = try_migrate(file_path)
-            status = 'OK' if migrated else 'FAIL'
-            sys.stderr.write("[{0}] {1}\n".format(status, file_path))
+        migrated = try_migrate(file_path)
+        status = 'OK' if migrated else 'FAIL'
+        sys.stderr.write("[{}] {}\n".format(status, file_path))
     sys.stderr.write("Done.\n")
 
+
 if __name__ == '__main__':
     main()

vcr/patch.py

@@ -6,15 +6,34 @@ from .compat import contextlib, mock
 from .stubs import VCRHTTPConnection, VCRHTTPSConnection
 from six.moves import http_client as httplib
 
+import logging
 
+log = logging.getLogger(__name__)
 # Save some of the original types for the purposes of unpatching
 _HTTPConnection = httplib.HTTPConnection
 _HTTPSConnection = httplib.HTTPSConnection
 
-
-# Try to save the original types for requests
+# Try to save the original types for boto3
 try:
-    import requests.packages.urllib3.connectionpool as cpool
+    from botocore.awsrequest import AWSHTTPSConnection, AWSHTTPConnection
+except ImportError:
+    try:
+        import botocore.vendored.requests.packages.urllib3.connectionpool as cpool
+    except ImportError:  # pragma: no cover
+        pass
+    else:
+        _Boto3VerifiedHTTPSConnection = cpool.VerifiedHTTPSConnection
+        _cpoolBoto3HTTPConnection = cpool.HTTPConnection
+        _cpoolBoto3HTTPSConnection = cpool.HTTPSConnection
+else:
+    _Boto3VerifiedHTTPSConnection = AWSHTTPSConnection
+    _cpoolBoto3HTTPConnection = AWSHTTPConnection
+    _cpoolBoto3HTTPSConnection = AWSHTTPSConnection
+
+cpool = None
+# Try to save the original types for urllib3
+try:
+    import urllib3.connectionpool as cpool
 except ImportError:  # pragma: no cover
     pass
 else:
@@ -22,15 +41,16 @@ else:
     _cpoolHTTPConnection = cpool.HTTPConnection
     _cpoolHTTPSConnection = cpool.HTTPSConnection
 
-
-# Try to save the original types for urllib3
+# Try to save the original types for requests
 try:
-    import urllib3
+    if not cpool:
+        import requests.packages.urllib3.connectionpool as cpool
 except ImportError:  # pragma: no cover
     pass
 else:
-    _VerifiedHTTPSConnection = urllib3.connectionpool.VerifiedHTTPSConnection
-
+    _VerifiedHTTPSConnection = cpool.VerifiedHTTPSConnection
+    _cpoolHTTPConnection = cpool.HTTPConnection
+    _cpoolHTTPSConnection = cpool.HTTPSConnection
 
 # Try to save the original types for httplib2
 try:
@@ -42,7 +62,6 @@ else:
     _HTTPSConnectionWithTimeout = httplib2.HTTPSConnectionWithTimeout
     _SCHEME_TO_CONNECTION = httplib2.SCHEME_TO_CONNECTION
 
-
 # Try to save the original types for boto
 try:
     import boto.https_connection
@@ -51,7 +70,6 @@ except ImportError:  # pragma: no cover
 else:
     _CertValidatingHTTPSConnection = boto.https_connection.CertValidatingHTTPSConnection
 
-
 # Try to save the original types for Tornado
 try:
     import tornado.simple_httpclient
@@ -61,7 +79,6 @@ else:
     _SimpleAsyncHTTPClient_fetch_impl = \
         tornado.simple_httpclient.SimpleAsyncHTTPClient.fetch_impl
 
-
 try:
     import tornado.curl_httpclient
 except ImportError:  # pragma: no cover
@@ -70,6 +87,13 @@ else:
     _CurlAsyncHTTPClient_fetch_impl = \
         tornado.curl_httpclient.CurlAsyncHTTPClient.fetch_impl
 
+try:
+    import aiohttp.client
+except ImportError:  # pragma: no cover
+    pass
+else:
+    _AiohttpClientSessionRequest = aiohttp.client.ClientSession._request
+
 
 class CassettePatcherBuilder(object):
 
@@ -79,6 +103,7 @@ class CassettePatcherBuilder(object):
             return self._build_patchers_from_mock_triples(
                 function(self, *args, **kwargs)
             )
+
         return wrapped
 
     def __init__(self, cassette):
@@ -87,8 +112,8 @@ class CassettePatcherBuilder(object):
 
     def build(self):
         return itertools.chain(
-            self._httplib(), self._requests(), self._urllib3(),
-            self._httplib2(), self._boto(), self._tornado(),
+            self._httplib(), self._requests(), self._boto3(), self._urllib3(),
+            self._httplib2(), self._boto(), self._tornado(), self._aiohttp(),
             self._build_patchers_from_mock_triples(
                 self._cassette.custom_patches
             ),
@@ -149,7 +174,7 @@ class CassettePatcherBuilder(object):
         bases = (base_class,)
         if not issubclass(base_class, object):  # Check for old style class
             bases += (object,)
-        return type('{0}{1}'.format(base_class.__name__, self._cassette._path),
+        return type('{}{}'.format(base_class.__name__, self._cassette._path),
                     bases, dict(cassette=self._cassette))
 
     @_build_patchers_from_mock_triples_decorator
@@ -159,12 +184,32 @@ class CassettePatcherBuilder(object):
 
     def _requests(self):
         try:
-            import requests.packages.urllib3.connectionpool as cpool
+            from .stubs import requests_stubs
         except ImportError:  # pragma: no cover
             return ()
-        from .stubs import requests_stubs
         return self._urllib3_patchers(cpool, requests_stubs)
 
+    @_build_patchers_from_mock_triples_decorator
+    def _boto3(self):
+
+        try:
+            # botocore using awsrequest
+            import botocore.awsrequest as cpool
+        except ImportError:  # pragma: no cover
+            try:
+                # botocore using vendored requests
+                import botocore.vendored.requests.packages.urllib3.connectionpool as cpool
+            except ImportError:  # pragma: no cover
+                pass
+            else:
+                from .stubs import boto3_stubs
+                yield self._urllib3_patchers(cpool, boto3_stubs)
+        else:
+            from .stubs import boto3_stubs
+            log.debug("Patching boto3 cpool with %s", cpool)
+            yield cpool.AWSHTTPConnectionPool, 'ConnectionCls', boto3_stubs.VCRRequestsHTTPConnection
+            yield cpool.AWSHTTPSConnectionPool, 'ConnectionCls', boto3_stubs.VCRRequestsHTTPSConnection
+
     def _patched_get_conn(self, connection_pool_class, connection_class_getter):
         get_conn = connection_pool_class._get_conn
 
@@ -255,6 +300,19 @@ class CassettePatcherBuilder(object):
             )
             yield curl.CurlAsyncHTTPClient, 'fetch_impl', new_fetch_impl
 
+    @_build_patchers_from_mock_triples_decorator
+    def _aiohttp(self):
+        try:
+            import aiohttp.client as client
+        except ImportError:  # pragma: no cover
+            pass
+        else:
+            from .stubs.aiohttp_stubs import vcr_request
+            new_request = vcr_request(
+                self._cassette, _AiohttpClientSessionRequest
+            )
+            yield client.ClientSession, '_request', new_request
+
     def _urllib3_patchers(self, cpool, stubs):
         http_connection_remover = ConnectionRemover(
             self._get_cassette_subclass(stubs.VCRRequestsHTTPConnection)
@@ -263,7 +321,6 @@ class CassettePatcherBuilder(object):
             self._get_cassette_subclass(stubs.VCRRequestsHTTPSConnection)
         )
         mock_triples = (
-            (cpool, 'VerifiedHTTPSConnection', stubs.VCRRequestsHTTPSConnection),
             (cpool, 'VerifiedHTTPSConnection', stubs.VCRRequestsHTTPSConnection),
             (cpool, 'HTTPConnection', stubs.VCRRequestsHTTPConnection),
             (cpool, 'HTTPSConnection', stubs.VCRRequestsHTTPSConnection),
@@ -323,8 +380,22 @@ class ConnectionRemover(object):
 def reset_patchers():
     yield mock.patch.object(httplib, 'HTTPConnection', _HTTPConnection)
     yield mock.patch.object(httplib, 'HTTPSConnection', _HTTPSConnection)
+
     try:
-        import requests.packages.urllib3.connectionpool as cpool
+        import requests
+        if requests.__build__ < 0x021603:
+            # Avoid double unmock if requests 2.16.3
+            # First, this is pointless, requests.packages.urllib3 *IS* urllib3 (see packages.py)
+            # Second, this is unmocking twice the same classes with different namespaces
+            # and is creating weird issues and bugs:
+            # > AssertionError: assert <class 'urllib3.connection.HTTPConnection'>
+            # >   is <class 'requests.packages.urllib3.connection.HTTPConnection'>
+            # This assert should work!!!
+            # Note that this also means that now, requests.packages is never imported
+            # if requests 2.16.3 or greater is used with VCRPy.
+            import requests.packages.urllib3.connectionpool as cpool
+        else:
+            raise ImportError("Skip requests not vendored anymore")
     except ImportError:  # pragma: no cover
         pass
     else:
@@ -347,11 +418,43 @@ def reset_patchers():
         pass
     else:
         yield mock.patch.object(cpool, 'VerifiedHTTPSConnection', _VerifiedHTTPSConnection)
-        yield mock.patch.object(cpool, 'HTTPConnection', _HTTPConnection)
-        yield mock.patch.object(cpool, 'HTTPSConnection', _HTTPSConnection)
+        yield mock.patch.object(cpool, 'HTTPConnection', _cpoolHTTPConnection)
+        yield mock.patch.object(cpool, 'HTTPSConnection', _cpoolHTTPSConnection)
         if hasattr(cpool.HTTPConnectionPool, 'ConnectionCls'):
-            yield mock.patch.object(cpool.HTTPConnectionPool, 'ConnectionCls', _HTTPConnection)
-            yield mock.patch.object(cpool.HTTPSConnectionPool, 'ConnectionCls', _HTTPSConnection)
+            yield mock.patch.object(cpool.HTTPConnectionPool, 'ConnectionCls', _cpoolHTTPConnection)
+            yield mock.patch.object(cpool.HTTPSConnectionPool, 'ConnectionCls', _cpoolHTTPSConnection)
+
+    try:
+        # unpatch botocore with awsrequest
+        import botocore.awsrequest as cpool
+    except ImportError:  # pragma: no cover
+        try:
+            # unpatch botocore with vendored requests
+            import botocore.vendored.requests.packages.urllib3.connectionpool as cpool
+        except ImportError:  # pragma: no cover
+            pass
+        else:
+            # unpatch requests v1.x
+            yield mock.patch.object(cpool, 'VerifiedHTTPSConnection', _Boto3VerifiedHTTPSConnection)
+            yield mock.patch.object(cpool, 'HTTPConnection', _cpoolBoto3HTTPConnection)
+            # unpatch requests v2.x
+            if hasattr(cpool.HTTPConnectionPool, 'ConnectionCls'):
+                yield mock.patch.object(cpool.HTTPConnectionPool, 'ConnectionCls',
+                                        _cpoolBoto3HTTPConnection)
+                yield mock.patch.object(cpool.HTTPSConnectionPool, 'ConnectionCls',
+                                        _cpoolBoto3HTTPSConnection)
+
+            if hasattr(cpool, 'HTTPSConnection'):
+                yield mock.patch.object(cpool, 'HTTPSConnection', _cpoolBoto3HTTPSConnection)
+    else:
+        if hasattr(cpool.AWSHTTPConnectionPool, 'ConnectionCls'):
+            yield mock.patch.object(cpool.AWSHTTPConnectionPool, 'ConnectionCls',
+                                    _cpoolBoto3HTTPConnection)
+            yield mock.patch.object(cpool.AWSHTTPSConnectionPool, 'ConnectionCls',
+                                    _cpoolBoto3HTTPSConnection)
+
+        if hasattr(cpool, 'AWSHTTPSConnection'):
+            yield mock.patch.object(cpool, 'AWSHTTPSConnection', _cpoolBoto3HTTPSConnection)
 
     try:
         import httplib2 as cpool

vcr/persist.py

@@ -1,14 +0,0 @@
-from .persisters.filesystem import FilesystemPersister
-from .serialize import serialize, deserialize
-
-
-def load_cassette(cassette_path, serializer):
-    with open(cassette_path) as f:
-        cassette_content = f.read()
-        cassette = deserialize(cassette_content, serializer)
-        return cassette
-
-
-def save_cassette(cassette_path, cassette_dict, serializer):
-    data = serialize(cassette_dict, serializer)
-    FilesystemPersister.write(cassette_path, data)

vcr/persisters/filesystem.py

@@ -1,9 +1,24 @@
+# .. _persister_example:
+
 import os
+from ..serialize import serialize, deserialize
 
 
 class FilesystemPersister(object):
+
     @classmethod
-    def write(cls, cassette_path, data):
+    def load_cassette(cls, cassette_path, serializer):
+        try:
+            with open(cassette_path) as f:
+                cassette_content = f.read()
+        except IOError:
+            raise ValueError('Cassette not found.')
+        cassette = deserialize(cassette_content, serializer)
+        return cassette
+
+    @staticmethod
+    def save_cassette(cassette_path, cassette_dict, serializer):
+        data = serialize(cassette_dict, serializer)
         dirname, filename = os.path.split(cassette_path)
         if dirname and not os.path.exists(dirname):
             os.makedirs(dirname)

vcr/request.py

@@ -2,6 +2,9 @@ import warnings
 from six import BytesIO, text_type
 from six.moves.urllib.parse import urlparse, parse_qsl
 from .util import CaseInsensitiveDict
+import logging
+
+log = logging.getLogger(__name__)
 
 
 class Request(object):
@@ -18,6 +21,7 @@ class Request(object):
         else:
             self.body = body
         self.headers = headers
+        log.debug("Invoking Request %s", self.uri)
 
     @property
     def headers(self):
@@ -58,7 +62,10 @@ class Request(object):
         parse_uri = urlparse(self.uri)
         port = parse_uri.port
         if port is None:
-            port = {'https': 443, 'http': 80}[parse_uri.scheme]
+            try:
+                port = {'https': 443, 'http': 80}[parse_uri.scheme]
+            except KeyError:
+                pass
         return port
 
     @property
@@ -81,7 +88,7 @@ class Request(object):
         return self.scheme
 
     def __str__(self):
-        return "<Request ({0}) {1}>".format(self.method, self.uri)
+        return "<Request ({}) {}>".format(self.method, self.uri)
 
     def __repr__(self):
         return self.__str__()
@@ -91,7 +98,7 @@ class Request(object):
             'method': self.method,
             'uri': self.uri,
             'body': self.body,
-            'headers': dict(((k, [v]) for k, v in self.headers.items())),
+            'headers': {k: [v] for k, v in self.headers.items()},
         }
 
     @classmethod
@@ -112,7 +119,7 @@ class HeadersDict(CaseInsensitiveDict):
     In addition, some servers sometimes send the same header more than once,
     and httplib *can* deal with this situation.
 
-    Futhermore, I wanted to keep the request and response cassette format as
+    Furthermore, I wanted to keep the request and response cassette format as
     similar as possible.
 
     For this reason, in cassettes I keep a dict with lists as keys, but once

vcr/serializers/compat.py

@@ -24,7 +24,7 @@ def convert_body_to_bytes(resp):
     http://pyyaml.org/wiki/PyYAMLDocumentation#Python3support
     """
     try:
-        if not isinstance(resp['body']['string'], six.binary_type):
+        if resp['body']['string'] is not None and not isinstance(resp['body']['string'], six.binary_type):
             resp['body']['string'] = resp['body']['string'].encode('utf-8')
     except (KeyError, TypeError, UnicodeEncodeError):
         # The thing we were converting either wasn't a dictionary or didn't

vcr/serializers/jsonserializer.py

@@ -25,5 +25,5 @@ def serialize(cassette_dict):
             original.end,
             original.args[-1] + error_message
         )
-    except TypeError as original:  # py3
+    except TypeError:  # py3
         raise TypeError(error_message)

vcr/stubs/__init__.py

@@ -18,7 +18,7 @@ log = logging.getLogger(__name__)
 class VCRFakeSocket(object):
     """
     A socket that doesn't do anything!
-    Used when playing back casssettes, when there
+    Used when playing back cassettes, when there
     is no actual open socket.
     """
 
@@ -60,9 +60,10 @@ def serialize_headers(response):
 
 class VCRHTTPResponse(HTTPResponse):
     """
-    Stub reponse class that gets returned instead of a HTTPResponse
+    Stub response class that gets returned instead of a HTTPResponse
     """
     def __init__(self, recorded_response):
+        self.fp = None
         self.recorded_response = recorded_response
         self.reason = recorded_response['status']['message']
         self.status = self.code = recorded_response['status']['code']
@@ -93,9 +94,30 @@ class VCRHTTPResponse(HTTPResponse):
     def read(self, *args, **kwargs):
         return self._content.read(*args, **kwargs)
 
+    def readall(self):
+        return self._content.readall()
+
+    def readinto(self, *args, **kwargs):
+        return self._content.readinto(*args, **kwargs)
+
     def readline(self, *args, **kwargs):
         return self._content.readline(*args, **kwargs)
 
+    def readlines(self, *args, **kwargs):
+        return self._content.readlines(*args, **kwargs)
+
+    def seekable(self):
+        return self._content.seekable()
+
+    def tell(self):
+        return self._content.tell()
+
+    def isatty(self):
+        return self._content.isatty()
+
+    def seek(self, *args, **kwargs):
+        return self._content.seek(*args, **kwargs)
+
     def close(self):
         self._closed = True
         return True
@@ -121,6 +143,9 @@ class VCRHTTPResponse(HTTPResponse):
         else:
             return default
 
+    def readable(self):
+        return self._content.readable()
+
 
 class VCRConnection(object):
     # A reference to the cassette that's currently being patched in
@@ -132,28 +157,32 @@ class VCRConnection(object):
         """
         port = self.real_connection.port
         default_port = {'https': 443, 'http': 80}[self._protocol]
-        return ':{0}'.format(port) if port != default_port else ''
+        return ':{}'.format(port) if port != default_port else ''
 
     def _uri(self, url):
         """Returns request absolute URI"""
-        uri = "{0}://{1}{2}{3}".format(
+        if url and not url.startswith('/'):
+            # Then this must be a proxy request.
+            return url
+        uri = "{}://{}{}{}".format(
             self._protocol,
             self.real_connection.host,
             self._port_postfix(),
             url,
         )
+        log.debug("Absolute URI: %s", uri)
         return uri
 
     def _url(self, uri):
         """Returns request selector url from absolute URI"""
-        prefix = "{0}://{1}{2}".format(
+        prefix = "{}://{}{}".format(
             self._protocol,
             self.real_connection.host,
             self._port_postfix(),
         )
         return uri.replace(prefix, '', 1)
 
-    def request(self, method, url, body=None, headers=None):
+    def request(self, method, url, body=None, headers=None, *args, **kwargs):
         '''Persist the request metadata in self._vcr_request'''
         self._vcr_request = Request(
             method=method,
@@ -161,13 +190,15 @@ class VCRConnection(object):
             body=body,
             headers=headers or {}
         )
-        log.debug('Got {0}'.format(self._vcr_request))
+        log.debug('Got {}'.format(self._vcr_request))
 
         # Note: The request may not actually be finished at this point, so
         # I'm not sending the actual request until getresponse().  This
         # allows me to compare the entire length of the response to see if it
         # exists in the cassette.
 
+        self._sock = VCRFakeSocket()
+
     def putrequest(self, method, url, *args, **kwargs):
         """
         httplib gives you more than one way to do it.  This is a way
@@ -180,7 +211,7 @@ class VCRConnection(object):
             body="",
             headers={}
         )
-        log.debug('Got {0}'.format(self._vcr_request))
+        log.debug('Got {}'.format(self._vcr_request))
 
     def putheader(self, header, *values):
         self._vcr_request.headers[header] = values
@@ -214,7 +245,7 @@ class VCRConnection(object):
         # then return it
         if self.cassette.can_play_response_for(self._vcr_request):
             log.info(
-                "Playing response for {0} from cassette".format(
+                "Playing response for {} from cassette".format(
                     self._vcr_request
                 )
             )
@@ -225,18 +256,15 @@ class VCRConnection(object):
                 self._vcr_request
             ):
                 raise CannotOverwriteExistingCassetteException(
-                    "No match for the request (%r) was found. "
-                    "Can't overwrite existing cassette (%r) in "
-                    "your current record mode (%r)."
-                    % (self._vcr_request, self.cassette._path,
-                       self.cassette.record_mode)
+                    cassette=self.cassette,
+                    failed_request=self._vcr_request
                 )
 
             # Otherwise, we should send the request, then get the response
             # and return it.
 
             log.info(
-                "{0} not in cassette, sending to real server".format(
+                "{} not in cassette, sending to real server".format(
                     self._vcr_request
                 )
             )
@@ -287,13 +315,17 @@ class VCRConnection(object):
             # Cassette is write-protected, don't actually connect
             return
 
-        return self.real_connection.connect(*args, **kwargs)
+        from vcr.patch import force_reset
+        with force_reset():
+            return self.real_connection.connect(*args, **kwargs)
+
+        self._sock = VCRFakeSocket()
 
     @property
     def sock(self):
         if self.real_connection.sock:
             return self.real_connection.sock
-        return VCRFakeSocket()
+        return self._sock
 
     @sock.setter
     def sock(self, value):
@@ -311,6 +343,8 @@ class VCRConnection(object):
         with force_reset():
             self.real_connection = self._baseclass(*args, **kwargs)
 
+        self._sock = None
+
     def __setattr__(self, name, value):
         """
         We need to define this because any attributes that are set on the
@@ -332,6 +366,23 @@ class VCRConnection(object):
 
         super(VCRConnection, self).__setattr__(name, value)
 
+    def __getattr__(self, name):
+        """
+        Send requests for weird attributes up to the real connection
+        (counterpart to __setattr above)
+        """
+        if self.__dict__.get('real_connection'):
+            # check in case real_connection has not been set yet, such as when
+            # we're setting the real_connection itself for the first time
+            return getattr(self.real_connection, name)
+
+        return super(VCRConnection, self).__getattr__(name)
+
+
+for k, v in HTTPConnection.__dict__.items():
+    if isinstance(v, staticmethod):
+        setattr(VCRConnection, k, v)
+
 
 class VCRHTTPConnection(VCRConnection):
     '''A Mocked class for HTTP requests'''

vcr/stubs/aiohttp_stubs/__init__.py

@@ -0,0 +1,147 @@
+'''Stubs for aiohttp HTTP clients'''
+from __future__ import absolute_import
+
+import asyncio
+import functools
+import logging
+import json
+
+from aiohttp import ClientResponse, streams
+from multidict import CIMultiDict, CIMultiDictProxy
+from yarl import URL
+
+from vcr.request import Request
+
+log = logging.getLogger(__name__)
+
+
+class MockStream(asyncio.StreamReader, streams.AsyncStreamReaderMixin):
+    pass
+
+
+class MockClientResponse(ClientResponse):
+    def __init__(self, method, url):
+        super().__init__(
+            method=method,
+            url=url,
+            writer=None,
+            continue100=None,
+            timer=None,
+            request_info=None,
+            traces=None,
+            loop=asyncio.get_event_loop(),
+            session=None,
+        )
+
+    async def json(self, *, encoding='utf-8', loads=json.loads, **kwargs):  # NOQA: E999
+        stripped = self._body.strip()
+        if not stripped:
+            return None
+
+        return loads(stripped.decode(encoding))
+
+    async def text(self, encoding='utf-8', errors='strict'):
+        return self._body.decode(encoding, errors=errors)
+
+    async def read(self):
+        return self._body
+
+    def release(self):
+        pass
+
+    @property
+    def content(self):
+        s = MockStream()
+        s.feed_data(self._body)
+        s.feed_eof()
+        return s
+
+
+def build_response(vcr_request, vcr_response, history):
+    response = MockClientResponse(vcr_request.method, URL(vcr_response.get('url')))
+    response.status = vcr_response['status']['code']
+    response._body = vcr_response['body'].get('string', b'')
+    response.reason = vcr_response['status']['message']
+    response._headers = CIMultiDictProxy(CIMultiDict(vcr_response['headers']))
+    response._history = tuple(history)
+
+    response.close()
+    return response
+
+
+def play_responses(cassette, vcr_request):
+    history = []
+    vcr_response = cassette.play_response(vcr_request)
+    response = build_response(vcr_request, vcr_response, history)
+
+    while cassette.can_play_response_for(vcr_request):
+        history.append(response)
+        vcr_response = cassette.play_response(vcr_request)
+        response = build_response(vcr_request, vcr_response, history)
+
+    return response
+
+
+async def record_response(cassette, vcr_request, response, past=False):
+    body = {} if past else {'string': (await response.read())}
+    headers = {str(key): value for key, value in response.headers.items()}
+
+    vcr_response = {
+        'status': {
+            'code': response.status,
+            'message': response.reason,
+        },
+        'headers': headers,
+        'body': body,  # NOQA: E999
+        'url': str(response.url),
+    }
+    cassette.append(vcr_request, vcr_response)
+
+
+async def record_responses(cassette, vcr_request, response):
+    for past_response in response.history:
+        await record_response(cassette, vcr_request, past_response, past=True)
+
+    await record_response(cassette, vcr_request, response)
+
+
+def vcr_request(cassette, real_request):
+    @functools.wraps(real_request)
+    async def new_request(self, method, url, **kwargs):
+        headers = kwargs.get('headers')
+        auth = kwargs.get('auth')
+        headers = self._prepare_headers(headers)
+        data = kwargs.get('data', kwargs.get('json'))
+        params = kwargs.get('params')
+
+        if auth is not None:
+            headers['AUTHORIZATION'] = auth.encode()
+
+        request_url = URL(url)
+        if params:
+            for k, v in params.items():
+                params[k] = str(v)
+            request_url = URL(url).with_query(params)
+
+        vcr_request = Request(method, str(request_url), data, headers)
+
+        if cassette.can_play_response_for(vcr_request):
+            return play_responses(cassette, vcr_request)
+
+        if cassette.write_protected and cassette.filter_request(vcr_request):
+            response = MockClientResponse(method, URL(url))
+            response.status = 599
+            msg = ("No match for the request {!r} was found. Can't overwrite "
+                   "existing cassette {!r} in your current record mode {!r}.")
+            msg = msg.format(vcr_request, cassette._path, cassette.record_mode)
+            response._body = msg.encode()
+            response.close()
+            return response
+
+        log.info('%s not in cassette, sending to real server', vcr_request)
+
+        response = await real_request(self, method, url, **kwargs)  # NOQA: E999
+        await record_responses(cassette, vcr_request, response)
+        return response
+
+    return new_request

vcr/stubs/boto3_stubs.py

@@ -0,0 +1,43 @@
+"""Stubs for boto3"""
+import six
+
+try:
+    # boto using awsrequest
+    from botocore.awsrequest import AWSHTTPConnection as HTTPConnection
+    from botocore.awsrequest import AWSHTTPSConnection as VerifiedHTTPSConnection
+
+except ImportError:  # pragma: nocover
+    # boto using vendored requests
+    # urllib3 defines its own HTTPConnection classes, which boto3 goes ahead and assumes
+    # you're using.  It includes some polyfills for newer features missing in older pythons.
+    try:
+        from urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
+    except ImportError:  # pragma: nocover
+        from requests.packages.urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
+
+from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
+
+
+class VCRRequestsHTTPConnection(VCRHTTPConnection, HTTPConnection):
+    _baseclass = HTTPConnection
+
+
+class VCRRequestsHTTPSConnection(VCRHTTPSConnection, VerifiedHTTPSConnection):
+    _baseclass = VerifiedHTTPSConnection
+
+    def __init__(self, *args, **kwargs):
+        if six.PY3:
+            kwargs.pop('strict', None)  # apparently this is gone in py3
+
+        # need to temporarily reset here because the real connection
+        # inherits from the thing that we are mocking out.  Take out
+        # the reset if you want to see what I mean :)
+        from vcr.patch import force_reset
+        with force_reset():
+            self.real_connection = self._baseclass(*args, **kwargs)
+            # Make sure to set those attributes as it seems `AWSHTTPConnection` does not
+            # set them, making the connection to fail !
+            self.real_connection.assert_hostname = kwargs.get("assert_hostname", False)
+            self.real_connection.cert_reqs = kwargs.get("cert_reqs", 'CERT_NONE')
+
+        self._sock = None

vcr/stubs/httplib2_stubs.py

@@ -13,9 +13,7 @@ class VCRHTTPConnectionWithTimeout(VCRHTTPConnection,
         HTTPConnection.__init__.'''
 
         # Delete the keyword arguments that HTTPConnection would not recognize
-        safe_keys = set(
-            ('host', 'port', 'strict', 'timeout', 'source_address')
-        )
+        safe_keys = {'host', 'port', 'strict', 'timeout', 'source_address'}
         unknown_keys = set(kwargs.keys()) - safe_keys
         safe_kwargs = kwargs.copy()
         for kw in unknown_keys:
@@ -33,7 +31,7 @@ class VCRHTTPSConnectionWithTimeout(VCRHTTPSConnection,
     def __init__(self, *args, **kwargs):
 
         # Delete the keyword arguments that HTTPSConnection would not recognize
-        safe_keys = set((
+        safe_keys = {
             'host',
             'port',
             'key_file',
@@ -42,7 +40,8 @@ class VCRHTTPSConnectionWithTimeout(VCRHTTPSConnection,
             'timeout',
             'source_address',
             'ca_certs',
-        ))
+            'disable_ssl_certificate_validation',
+        }
         unknown_keys = set(kwargs.keys()) - safe_keys
         safe_kwargs = kwargs.copy()
         for kw in unknown_keys:

vcr/stubs/requests_stubs.py

@@ -1,9 +1,9 @@
 '''Stubs for requests'''
 
 try:
-    from requests.packages.urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
-except ImportError:
     from urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
+except ImportError:
+    from requests.packages.urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
 
 from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
 

vcr/stubs/tornado_stubs.py

@@ -75,10 +75,8 @@ def vcr_fetch_impl(cassette, real_fetch_impl):
                     request,
                     599,
                     error=CannotOverwriteExistingCassetteException(
-                        "No match for the request (%r) was found. "
-                        "Can't overwrite existing cassette (%r) in "
-                        "your current record mode (%r)."
-                        % (vcr_request, cassette._path, cassette.record_mode)
+                        cassette=cassette,
+                        failed_request=vcr_request
                     ),
                     request_time=self.io_loop.time() - request.start_time,
                 )

vcr/util.py

@@ -1,13 +1,17 @@
-import collections
 import types
 
+try:
+    from collections.abc import Mapping, MutableMapping
+except ImportError:
+    from collections import Mapping, MutableMapping
+
 
 # Shamelessly stolen from https://github.com/kennethreitz/requests/blob/master/requests/structures.py
-class CaseInsensitiveDict(collections.MutableMapping):
+class CaseInsensitiveDict(MutableMapping):
     """
     A case-insensitive ``dict``-like object.
     Implements all methods and operations of
-    ``collections.MutableMapping`` as well as dict's ``copy``. Also
+    ``collections.abc.MutableMapping`` as well as dict's ``copy``. Also
     provides ``lower_items``.
     All keys are expected to be strings. The structure remembers the
     case of the last key to be set, and ``iter(instance)``,
@@ -57,7 +61,7 @@ class CaseInsensitiveDict(collections.MutableMapping):
         )
 
     def __eq__(self, other):
-        if isinstance(other, collections.Mapping):
+        if isinstance(other, Mapping):
             other = CaseInsensitiveDict(other)
         else:
             return NotImplemented
@@ -114,10 +118,10 @@ def auto_decorate(
             )
 
         def __new__(cls, name, bases, attributes_dict):
-            new_attributes_dict = dict(
-                (attribute, maybe_decorate(attribute, value))
+            new_attributes_dict = {
+                attribute: maybe_decorate(attribute, value)
                 for attribute, value in attributes_dict.items()
-            )
+            }
             return super(DecorateAll, cls).__new__(
                 cls, name, bases, new_attributes_dict
             )