Release v4.3.0

Allow triggering CI manually

.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+
+updates:
+  - package-ecosystem: pip
+    directory: "/"
+    schedule:
+      interval: weekly
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: weekly

.github/workflows/main.yml

@@ -0,0 +1,40 @@
+name: Test
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11", "pypy-3.8"]
+
+    steps:
+      - name: Install libgnutls28-dev
+        run: |
+          sudo apt update -q
+          sudo apt install -q -y libgnutls28-dev libcurl4-gnutls-dev
+
+      - uses: actions/checkout@v3.5.2
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install project dependencies
+        run: |
+          pip install --upgrade pip
+          pip install codecov tox tox-gh-actions
+
+      - name: Run tests with tox
+        run: tox
+
+      - name: Run coverage
+        run: codecov

.travis.yml

@@ -1,32 +0,0 @@
-dist: xenial
-language: python
-before_install: openssl version
-env:
-  # global:
-    # - secure: AifoKzwhjV94cmcQZrdQmqRu/9rkZZvWpwBv1daeAQpLOKFPGsOm3D+x2cSw9+iCfkgDZDfqQVv1kCaFVxTll8v8jTq5SJdqEY0NmGWbj/UkNtShh609oRDsuzLxAEwtVKYjf/h8K2BRea+bl1tGkwZ2vtmYS6dxNlAijjWOfds=
-    # - secure: LBSEg/gMj4u4Hrpo3zs6Y/1mTpd2RtcN49mZIFgTdbJ9IhpiNPqcEt647Lz94F9Eses2x2WbNuKqZKZZReY7QLbEzU1m0nN5jlaKrjcG5NR5clNABfFFyhgc0jBikyS4abAG8jc2efeaTrFuQwdoF4sE8YiVrkiVj2X5Xoi6sBk=
-  matrix:
-    - TOX_SUFFIX="requests"
-    - TOX_SUFFIX="httplib2"
-    - TOX_SUFFIX="boto3"
-    - TOX_SUFFIX="urllib3"
-    - TOX_SUFFIX="tornado4"
-    - TOX_SUFFIX="aiohttp"
-matrix:
-  include:
-    # Only run lint on a single 3.x
-    - env: TOX_SUFFIX="lint"
-      python: "3.7"
-python:
-  - "3.5"
-  - "3.6"
-  - "3.7"
-  - "3.8"
-  - "pypy3"
-install:
-  - pip install tox-travis codecov
-  - if [[ $TOX_SUFFIX != 'lint' ]]; then python setup.py install ; fi
-script:
-  - tox -e "${TOX_SUFFIX}"
-after_success:
-  - codecov

README.rst

@@ -47,6 +47,11 @@ VCR.py will detect the absence of a cassette file and once again record
 all HTTP interactions, which will update them to correspond to the new
 API.
 
+Usage with Pytest
+-----------------
+
+There is a library to provide some pytest fixtures called pytest-recording https://github.com/kiwicom/pytest-recording
+
 License
 -------
 
@@ -57,8 +62,8 @@ more details
    :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
+.. |Build Status| image:: https://github.com/kevin1024/vcrpy/actions/workflows/main.yml/badge.svg
-   :target: http://travis-ci.org/kevin1024/vcrpy
+   :target: https://github.com/kevin1024/vcrpy/actions
 .. |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

docs/advanced.rst

@@ -33,6 +33,8 @@ consider part of the API. The fields are as follows:
    been played back.
 -  ``responses_of(request)``: Access the responses that match a given
    request
+-  ``allow_playback_repeats``: A boolean indicating whether responses
+   can be played back more than once.
 
 The ``Request`` object has the following properties:
 
@@ -269,7 +271,7 @@ You can also do response filtering with the
 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:
+sensitive data from the response body:
 
 .. code:: python
 
@@ -386,3 +388,41 @@ VCR.py allows to rewind a cassette in order to replay it inside the same functio
         assert cass.all_played
         cass.rewind()
         assert not cass.all_played
+
+Playback Repeats
+----------------
+
+By default, each response in a cassette can only be matched and played back
+once while the cassette is in use, unless the cassette is rewound.
+
+If you want to allow playback repeats without rewinding the cassette, use
+the Cassette ``allow_playback_repeats`` option.
+
+.. code:: python
+
+    with vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml', allow_playback_repeats=True) as cass:
+        for x in range(10):
+            response = urllib2.urlopen('http://www.zombo.com/').read()
+        assert cass.all_played
+
+Discards Cassette on Errors
+---------------------------
+
+By default VCR will save the cassette file even when there is any error inside
+the enclosing context/test.
+
+If you want to save the cassette only when the test succeeds, set the Cassette
+``record_on_exception`` option to ``False``.
+
+.. code:: python
+
+    try:
+        my_vcr = VCR(record_on_exception=False)
+        with my_vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml') as cass:
+            response = urllib2.urlopen('http://www.zombo.com/').read()
+            raise RuntimeError("Oops, something happened")
+    except RuntimeError:
+        pass
+
+    # Since there was an exception, the cassette file hasn't been created.
+    assert not os.path.exists('fixtures/vcr_cassettes/synopsis.yaml')

docs/changelog.rst

@@ -1,16 +1,45 @@
 Changelog
 ---------
 
-For a full list of triaged issues, bugs and PRs and what release they are targetted for please see the following link.
+For a full list of triaged issues, bugs and PRs and what release they are targeted for please see the following link.
 
 `ROADMAP MILESTONES <https://github.com/kevin1024/vcrpy/milestones>`_
 
 All help in providing PRs to close out bug issues is appreciated. Even if that is providing a repo that fully replicates issues. We have very generous contributors that have added these to bug issues which meant another contributor picked up the bug and closed it out.
 
--  UNRELEASED
+-  4.3.0
-    - ...
+    - Add support for Python 3.11 (Thanks @evgeni)
-
+    - Drop support for botocore <1.11.0 and requests <2.16.2 (thanks @hartwork)
-
+    - Bugfix: decode_compressed_response raises exception on empty responses. Thanks @CharString
+    - Don't save requests from decorated tests if decorated test fails (thanks @dan-passaro)
+    - Fix not calling all the exit stack when record_on_exception is False (thanks @Terseus)
+    - Various CI, documentation, testing, and formatting improvements (Thanks @jairhenrique, @dan-passaro, @hartwork, and Terseus)
+-  4.2.1
+    - Fix a bug where the first request in a redirect chain was not being recorded with aiohttp
+    - Various typos and small fixes, thanks @jairhenrique, @timgates42
+-  4.2.0
+    - Drop support for python < 3.7, thanks @jairhenrique, @IvanMalison, @AthulMuralidhar
+    - Various aiohtt bigfixes (thanks @pauloromeira and boechat107)
+    - Bugfix: filter_post_data_parameters not working with aiohttp.  Thank you @vprakashplanview, @scop, @jairhenrique, and @cinemascop89
+    - Bugfix: Some random misspellings (thanks @scop)
+    - Migrate the CI suite to Github Actions from Travis (thanks @jairhenrique and @cclauss)
+    - Various documentation and code misspelling fixes (thanks @scop and @Justintime50)
+    - Bugfix: httpx support (select between allow_redirects/follow_redirects) (thanks @immerrr)
+    - Bugfix: httpx support (select between allow_redirects/follow_redirects) (thanks @immerrr)
+-  4.1.1
+    - Fix HTTPX support for versions greater than 0.15 (thanks @jairhenrique)
+    - Include a trailing newline on json cassettes (thanks @AaronRobson)
+-  4.1.0
+    - Add support for httpx!! (thanks @herdigiorgi)
+    - Add the new `allow_playback_repeats` option (thanks @tysonholub)
+    - Several aiohttp improvements (cookie support, multiple headers with same key) (Thanks @pauloromeira)
+    - Use enums for record modes (thanks @aaronbannin)
+    - Bugfix: Do not redirect on 304 in aiohttp (Thanks @royjs)
+    - Bugfix: Fix test suite by switching to mockbin (thanks @jairhenrique)
+-  4.0.2
+    - Fix mock imports as reported in #504 by @llybin. Thank you.
+-  4.0.1 
+    - Fix logo alignment for PyPI 
 -  4.0.0
     - Remove Python2 support (@hugovk)
     - Add Python 3.8 TravisCI support (@neozenith)
@@ -90,7 +119,7 @@ All help in providing PRs to close out bug issues is appreciated. Even if that i
     - decode_compressed_response option and filter (thanks @jayvdb).
 -  1.7.4 [#217] 
     - Make use_cassette decorated functions actually return a value (thanks @bcen). 
-    - [#199] Fix path transfromation defaults.
+    - [#199] Fix path transformation defaults.
     - Better headers dictionary management.
 -  1.7.3 [#188] 
     - ``additional_matchers`` kwarg on ``use_cassette``.
@@ -193,7 +222,7 @@ All help in providing PRs to close out bug issues is appreciated. Even if that i
 -  0.3.4
     - Bugfix: close file before renaming it. This fixes an issue on Windows. Thanks @smallcode for the fix.
 -  0.3.3
-    - Bugfix for error message when an unreigstered custom matcher was used
+    - Bugfix for error message when an unregistered custom matcher was used
 -  0.3.2
     - Fix issue with new config syntax and the ``match_on`` parameter. Thanks, @chromy!
 -  0.3.1

docs/conf.py

@@ -94,7 +94,7 @@ version = release = find_version("..", "vcr", "__init__.py")
 #
 # This is also used if you do content translation via gettext catalogs.
 # Usually you set "language" from the command line for these cases.
-language = None
+language = "en"
 
 # There are two options for replacing |today|: either, you set today to some
 # non-false value, then it is used:

docs/configuration.rst

@@ -42,7 +42,8 @@ This can be configured by changing the ``match_on`` setting.
 The following options are available :
 
 -  method (for example, POST or GET)
--  uri (the full URI.)
+-  uri (the full URI)
+-  scheme (for example, HTTP or HTTPS)
 -  host (the hostname of the server receiving the request)
 -  port (the port of the server receiving the request)
 -  path (the path of the request)

docs/contributing.rst

@@ -96,11 +96,11 @@ The test suite is pretty big and slow, but you can tell tox to only run specific
 
     tox -e {pyNN}-{HTTP_LIBRARY} -- <pytest flags passed through>
 
-    tox -e py36-requests -- -v -k "'test_status_code or test_gzip'"
+    tox -e py37-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 3.6 environment
+``test_gzip`` in the test suite, and only in the python 3.7 environment
 that has ``requests`` installed.
 
 Also, in order for the boto tests to run, you will need an AWS key.
@@ -130,10 +130,10 @@ in this example::
     pip install tox tox-pyenv
 
     # Install supported versions (at time of writing), this does not activate them
-    pyenv install 3.5.9 3.6.9 3.7.5 3.8.0 pypy3.6-7.2.0
+    pyenv install 3.7.5 3.8.0 pypy3.8
 
     # This activates them
-    pyenv local 3.5.9 3.6.9 3.7.5 3.8.0 pypy3.6-7.2.0
+    pyenv local 3.7.5 3.8.0 pypy3.8
 
     # Run the whole test suite
     tox

docs/installation.rst

@@ -9,7 +9,7 @@ with pip::
 Compatibility
 -------------
 
-VCR.py supports Python 3.5+, and `pypy <http://pypy.org>`__.
+VCR.py supports Python 3.7+, and `pypy <http://pypy.org>`__.
 
 The following HTTP libraries are supported:
 
@@ -22,6 +22,7 @@ The following HTTP libraries are supported:
 -  ``tornado.httpclient``
 -  ``urllib2``
 -  ``urllib3``
+-  ``httpx``
 
 Speed
 -----

docs/usage.rst

@@ -4,10 +4,10 @@ Usage
 .. code:: python
 
     import vcr
-    import urllib2
+    import urllib
 
     with vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml'):
-        response = urllib2.urlopen('http://www.iana.org/domains/reserved').read()
+        response = urllib.request.urlopen('http://www.iana.org/domains/reserved').read()
         assert 'Example domains' in response
 
 Run this test once, and VCR.py will record the HTTP request to
@@ -25,7 +25,7 @@ look like this:
 
     @vcr.use_cassette('fixtures/vcr_cassettes/synopsis.yaml')
     def test_iana():
-        response = urllib2.urlopen('http://www.iana.org/domains/reserved').read()
+        response = urllib.request.urlopen('http://www.iana.org/domains/reserved').read()
         assert 'Example domains' in response
 
 When using the decorator version of ``use_cassette``, it is possible to
@@ -35,7 +35,7 @@ omit the path to the cassette file.
 
     @vcr.use_cassette()
     def test_iana():
-        response = urllib2.urlopen('http://www.iana.org/domains/reserved').read()
+        response = urllib.request.urlopen('http://www.iana.org/domains/reserved').read()
         assert 'Example domains' in response
 
 In this case, the cassette file will be given the same name as the test

pyproject.toml

@@ -1,2 +1,9 @@
 [tool.black]
 line-length=110
+
+[tool.isort]
+line_length = 110
+known_first_party = "vcrpy"
+multi_line_output = 3
+use_parentheses = true
+include_trailing_comma = true

runtests.sh

@@ -4,4 +4,4 @@
 # 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 $*
+REQUESTS_CA_BUNDLE=`python -m pytest_httpbin.certs` pytest $*

setup.py

@@ -5,7 +5,7 @@ import os
 import re
 import sys
 
-from setuptools import setup, find_packages
+from setuptools import find_packages, setup
 from setuptools.command.test import test as TestCommand
 
 long_description = open("README.rst", "r").read()
@@ -46,8 +46,7 @@ install_requires = [
     "PyYAML",
     "wrapt",
     "six>=1.5",
-    'yarl; python_version>="3.6"',
+    "yarl",
-    'yarl<1.4; python_version=="3.5"',
 ]
 
 setup(
@@ -60,7 +59,7 @@ setup(
     author_email="me@kevinmccarthy.org",
     url="https://github.com/kevin1024/vcrpy",
     packages=find_packages(exclude=["tests*"]),
-    python_requires=">=3.5",
+    python_requires=">=3.7",
     install_requires=install_requires,
     license="MIT",
     tests_require=["pytest", "mock", "pytest-httpbin"],
@@ -70,10 +69,11 @@ setup(
         "Intended Audience :: Developers",
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: Implementation :: PyPy",

tests/integration/aiohttp_utils.py

@@ -2,7 +2,6 @@
 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):

tests/integration/cassettes/test_httpx_test_test_behind_proxy.yml

@@ -0,0 +1,41 @@
+interactions:
+- request:
+    body: ''
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate, br
+      connection:
+      - keep-alive
+      host:
+      - httpbin.org
+      user-agent:
+      - python-httpx/0.12.1
+    method: GET
+    uri: https://mockbin.org/headers
+  response:
+    content: "{\n  \"headers\": {\n    \"Accept\": \"*/*\", \n    \"Accept-Encoding\"\
+      : \"gzip, deflate, br\", \n    \"Host\": \"httpbin.org\", \n    \"User-Agent\"\
+      : \"python-httpx/0.12.1\", \n    \"X-Amzn-Trace-Id\": \"Root=1-5ea778c9-ea76170da792abdbf7614067\"\
+      \n  }\n}\n"
+    headers:
+      access-control-allow-credentials:
+      - 'true'
+      access-control-allow-origin:
+      - '*'
+      connection:
+      - keep-alive
+      content-length:
+      - '226'
+      content-type:
+      - application/json
+      date:
+      - Tue, 28 Apr 2020 00:28:57 GMT
+      server:
+      - gunicorn/19.9.0
+      via:
+      - my_own_proxy
+    http_version: HTTP/1.1
+    status_code: 200
+version: 1

tests/integration/conftest.py

@@ -0,0 +1,17 @@
+import pytest
+
+
+@pytest.fixture(params=["https", "http"])
+def scheme(request):
+    """Fixture that returns both http and https."""
+    return request.param
+
+
+@pytest.fixture
+def mockbin(scheme):
+    return scheme + "://mockbin.org"
+
+
+@pytest.fixture
+def mockbin_request_url(mockbin):
+    return mockbin + "/request"

tests/integration/test_aiohttp.py

@@ -1,5 +1,6 @@
 import contextlib
 import logging
+import urllib.parse
 
 import pytest
 
@@ -7,6 +8,7 @@ asyncio = pytest.importorskip("asyncio")
 aiohttp = pytest.importorskip("aiohttp")
 
 import vcr  # noqa: E402
+
 from .aiohttp_utils import aiohttp_app, aiohttp_request  # noqa: E402
 
 
@@ -32,14 +34,9 @@ def post(url, output="text", **kwargs):
     return request("POST", url, output="text", **kwargs)
 
 
-@pytest.fixture(params=["https", "http"])
+def test_status(tmpdir, mockbin_request_url):
-def scheme(request):
+    url = mockbin_request_url
-    """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)
 
@@ -50,8 +47,8 @@ def test_status(tmpdir, scheme):
 
 
 @pytest.mark.parametrize("auth", [None, aiohttp.BasicAuth("vcrpy", "test")])
-def test_headers(tmpdir, scheme, auth):
+def test_headers(tmpdir, auth, mockbin_request_url):
-    url = scheme + "://httpbin.org"
+    url = mockbin_request_url
     with vcr.use_cassette(str(tmpdir.join("headers.yaml"))):
         response, _ = get(url, auth=auth)
 
@@ -66,8 +63,9 @@ def test_headers(tmpdir, scheme, auth):
         assert "yarl.URL" not in cassette.data[0]
 
 
-def test_case_insensitive_headers(tmpdir, scheme):
+def test_case_insensitive_headers(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org"
+    url = mockbin_request_url
+
     with vcr.use_cassette(str(tmpdir.join("whatever.yaml"))):
         _, _ = get(url)
 
@@ -78,8 +76,9 @@ def test_case_insensitive_headers(tmpdir, scheme):
         assert cassette.play_count == 1
 
 
-def test_text(tmpdir, scheme):
+def test_text(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org"
+    url = mockbin_request_url
+
     with vcr.use_cassette(str(tmpdir.join("text.yaml"))):
         _, response_text = get(url)
 
@@ -89,8 +88,8 @@ def test_text(tmpdir, scheme):
         assert cassette.play_count == 1
 
 
-def test_json(tmpdir, scheme):
+def test_json(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org/get"
+    url = mockbin_request_url
     headers = {"Content-Type": "application/json"}
 
     with vcr.use_cassette(str(tmpdir.join("json.yaml"))):
@@ -102,8 +101,8 @@ def test_json(tmpdir, scheme):
         assert cassette.play_count == 1
 
 
-def test_binary(tmpdir, scheme):
+def test_binary(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org/image/png"
+    url = mockbin_request_url + "/image/png"
     with vcr.use_cassette(str(tmpdir.join("binary.yaml"))):
         _, response_binary = get(url, output="raw")
 
@@ -113,23 +112,23 @@ def test_binary(tmpdir, scheme):
         assert cassette.play_count == 1
 
 
-def test_stream(tmpdir, scheme):
+def test_stream(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org/get"
+    url = mockbin_request_url
 
     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
+        _, 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")
+        _, 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):
+def test_post(tmpdir, body, caplog, mockbin_request_url):
     caplog.set_level(logging.INFO)
     data = {"key1": "value1", "key2": "value2"}
-    url = scheme + "://httpbin.org/post"
+    url = mockbin_request_url
     with vcr.use_cassette(str(tmpdir.join("post.yaml"))):
         _, response_json = post(url, **{body: data})
 
@@ -150,13 +149,14 @@ def test_post(tmpdir, scheme, body, caplog):
     ), "Log message not found."
 
 
-def test_params(tmpdir, scheme):
+def test_params(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org/get"
+    url = mockbin_request_url + "?d=d"
     headers = {"Content-Type": "application/json"}
-    params = {"a": 1, "b": False, "c": "c"}
+    params = {"a": 1, "b": 2, "c": "c"}
 
     with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
         _, response_json = get(url, output="json", params=params, headers=headers)
+        assert response_json["queryString"] == {"a": "1", "b": "2", "c": "c", "d": "d"}
 
     with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
         _, cassette_response_json = get(url, output="json", params=params, headers=headers)
@@ -164,10 +164,10 @@ def test_params(tmpdir, scheme):
         assert cassette.play_count == 1
 
 
-def test_params_same_url_distinct_params(tmpdir, scheme):
+def test_params_same_url_distinct_params(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org/get"
+    url = mockbin_request_url
     headers = {"Content-Type": "application/json"}
-    params = {"a": 1, "b": False, "c": "c"}
+    params = {"a": 1, "b": 2, "c": "c"}
 
     with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
         _, response_json = get(url, output="json", params=params, headers=headers)
@@ -179,13 +179,12 @@ def test_params_same_url_distinct_params(tmpdir, scheme):
 
     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)
+        with pytest.raises(vcr.errors.CannotOverwriteExistingCassetteException):
-        assert "No match for the request" in cassette_response_text
+            get(url, output="text", params=other_params)
-        assert response.status == 599
 
 
-def test_params_on_url(tmpdir, scheme):
+def test_params_on_url(tmpdir, mockbin_request_url):
-    url = scheme + "://httpbin.org/get?a=1&b=foo"
+    url = mockbin_request_url + "?a=1&b=foo"
     headers = {"Content-Type": "application/json"}
 
     with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
@@ -249,8 +248,8 @@ def test_aiohttp_test_client_json(aiohttp_client, tmpdir):
     assert cassette.play_count == 1
 
 
-def test_redirect(aiohttp_client, tmpdir):
+def test_redirect(tmpdir, mockbin):
-    url = "https://httpbin.org/redirect/2"
+    url = mockbin + "/redirect/302/2"
 
     with vcr.use_cassette(str(tmpdir.join("redirect.yaml"))):
         response, _ = get(url)
@@ -273,13 +272,30 @@ def test_redirect(aiohttp_client, tmpdir):
     assert cassette_response.request_info.real_url == response.request_info.real_url
 
 
-def test_double_requests(tmpdir):
+def test_not_modified(tmpdir, mockbin):
-    """We should capture, record, and replay all requests and response chains,
+    """It doesn't try to redirect on 304"""
-        even if there are duplicate ones.
+    url = mockbin + "/status/304"
 
-        We should replay in the order we saw them.
+    with vcr.use_cassette(str(tmpdir.join("not_modified.yaml"))):
+        response, _ = get(url)
+
+    with vcr.use_cassette(str(tmpdir.join("not_modified.yaml"))) as cassette:
+        cassette_response, _ = get(url)
+
+        assert cassette_response.status == 304
+        assert response.status == 304
+        assert len(cassette_response.history) == len(response.history)
+        assert len(cassette) == 1
+        assert cassette.play_count == 1
+
+
+def test_double_requests(tmpdir, mockbin_request_url):
+    """We should capture, record, and replay all requests and response chains,
+    even if there are duplicate ones.
+
+    We should replay in the order we saw them.
     """
-    url = "https://httpbin.org/get"
+    url = mockbin_request_url
 
     with vcr.use_cassette(str(tmpdir.join("text.yaml"))):
         _, response_text1 = get(url, output="text")
@@ -302,3 +318,99 @@ def test_double_requests(tmpdir):
 
         # Now that we made both requests, we should have played both.
         assert cassette.play_count == 2
+
+
+def test_cookies(scheme, tmpdir):
+    async def run(loop):
+        cookies_url = scheme + (
+            "://httpbin.org/response-headers?"
+            "set-cookie=" + urllib.parse.quote("cookie_1=val_1; Path=/") + "&"
+            "Set-Cookie=" + urllib.parse.quote("Cookie_2=Val_2; Path=/")
+        )
+        home_url = scheme + "://httpbin.org/"
+        tmp = str(tmpdir.join("cookies.yaml"))
+        req_cookies = {"Cookie_3": "Val_3"}
+        req_headers = {"Cookie": "Cookie_4=Val_4"}
+
+        # ------------------------- Record -------------------------- #
+        with vcr.use_cassette(tmp) as cassette:
+            async with aiohttp.ClientSession(loop=loop) as session:
+                cookies_resp = await session.get(cookies_url)
+                home_resp = await session.get(home_url, cookies=req_cookies, headers=req_headers)
+                assert cassette.play_count == 0
+        assert_responses(cookies_resp, home_resp)
+
+        # -------------------------- Play --------------------------- #
+        with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
+            async with aiohttp.ClientSession(loop=loop) as session:
+                cookies_resp = await session.get(cookies_url)
+                home_resp = await session.get(home_url, cookies=req_cookies, headers=req_headers)
+                assert cassette.play_count == 2
+        assert_responses(cookies_resp, home_resp)
+
+    def assert_responses(cookies_resp, home_resp):
+        assert cookies_resp.cookies.get("cookie_1").value == "val_1"
+        assert cookies_resp.cookies.get("Cookie_2").value == "Val_2"
+        request_cookies = home_resp.request_info.headers["cookie"]
+        assert "cookie_1=val_1" in request_cookies
+        assert "Cookie_2=Val_2" in request_cookies
+        assert "Cookie_3=Val_3" in request_cookies
+        assert "Cookie_4=Val_4" in request_cookies
+
+    run_in_loop(run)
+
+
+def test_cookies_redirect(scheme, tmpdir):
+    async def run(loop):
+        # Sets cookie as provided by the query string and redirects
+        cookies_url = scheme + "://httpbin.org/cookies/set?Cookie_1=Val_1"
+        tmp = str(tmpdir.join("cookies.yaml"))
+
+        # ------------------------- Record -------------------------- #
+        with vcr.use_cassette(tmp) as cassette:
+            async with aiohttp.ClientSession(loop=loop) as session:
+                cookies_resp = await session.get(cookies_url)
+                assert not cookies_resp.cookies
+                cookies = session.cookie_jar.filter_cookies(cookies_url)
+                assert cookies["Cookie_1"].value == "Val_1"
+                assert cassette.play_count == 0
+            cassette.requests[1].headers["Cookie"] == "Cookie_1=Val_1"
+
+        # -------------------------- Play --------------------------- #
+        with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
+            async with aiohttp.ClientSession(loop=loop) as session:
+                cookies_resp = await session.get(cookies_url)
+                assert not cookies_resp.cookies
+                cookies = session.cookie_jar.filter_cookies(cookies_url)
+                assert cookies["Cookie_1"].value == "Val_1"
+                assert cassette.play_count == 2
+            cassette.requests[1].headers["Cookie"] == "Cookie_1=Val_1"
+
+        # Assert that it's ignoring expiration date
+        with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
+            cassette.responses[0]["headers"]["set-cookie"] = [
+                "Cookie_1=Val_1; Expires=Wed, 21 Oct 2015 07:28:00 GMT"
+            ]
+            async with aiohttp.ClientSession(loop=loop) as session:
+                cookies_resp = await session.get(cookies_url)
+                assert not cookies_resp.cookies
+                cookies = session.cookie_jar.filter_cookies(cookies_url)
+                assert cookies["Cookie_1"].value == "Val_1"
+
+    run_in_loop(run)
+
+
+def test_not_allow_redirects(tmpdir, mockbin):
+    url = mockbin + "/redirect/308/5"
+    path = str(tmpdir.join("redirects.yaml"))
+
+    with vcr.use_cassette(path):
+        response, _ = get(url, allow_redirects=False)
+        assert response.url.path == "/redirect/308/5"
+        assert response.status == 308
+
+    with vcr.use_cassette(path) as cassette:
+        response, _ = get(url, allow_redirects=False)
+        assert response.url.path == "/redirect/308/5"
+        assert response.status == 308
+        assert cassette.play_count == 1

tests/integration/test_basic.py

@@ -11,7 +11,7 @@ import vcr
 
 def test_nonexistent_directory(tmpdir, httpbin):
     """If we load a cassette in a nonexistent directory, it can save ok"""
-    # Check to make sure directory doesnt exist
+    # Check to make sure directory doesn't exist
     assert not os.path.exists(str(tmpdir.join("nonexistent")))
 
     # Run VCR to create dir and cassette file

tests/integration/test_boto.py

@@ -2,11 +2,13 @@ import pytest
 
 boto = pytest.importorskip("boto")
 
+from configparser import DuplicateSectionError  # NOQA
+
 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
 
 
@@ -15,6 +17,7 @@ def test_boto_stubs(tmpdir):
         # Perform the imports within the patched context so that
         # CertValidatingHTTPSConnection refers to the patched version.
         from boto.https_connection import CertValidatingHTTPSConnection
+
         from vcr.stubs.boto_stubs import VCRCertValidatingHTTPSConnection
 
         # Prove that the class was patched by the stub and that we can instantiate it.

tests/integration/test_boto3.py

@@ -1,10 +1,12 @@
-import pytest
 import os
 
+import pytest
+
 boto3 = pytest.importorskip("boto3")
 
 import boto3  # NOQA
 import botocore  # NOQA
+
 import vcr  # NOQA
 
 try:
@@ -55,24 +57,6 @@ def get_user(iam_client):
     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"
@@ -80,7 +64,6 @@ def test_boto_vendored_stubs(tmpdir):
     "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

tests/integration/test_config.py

@@ -1,50 +1,54 @@
-import os
 import json
-import pytest
+import os
-import vcr
 from urllib.request import urlopen
 
+import pytest
 
-def test_set_serializer_default_config(tmpdir, httpbin):
+import vcr
+
+
+def test_set_serializer_default_config(tmpdir, mockbin_request_url):
     my_vcr = vcr.VCR(serializer="json")
 
     with my_vcr.use_cassette(str(tmpdir.join("test.json"))):
         assert my_vcr.serializer == "json"
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url)
 
     with open(str(tmpdir.join("test.json"))) as f:
-        assert json.loads(f.read())
+        file_content = f.read()
+        assert file_content.endswith("\n")
+        assert json.loads(file_content)
 
 
-def test_default_set_cassette_library_dir(tmpdir, httpbin):
+def test_default_set_cassette_library_dir(tmpdir, mockbin_request_url):
     my_vcr = vcr.VCR(cassette_library_dir=str(tmpdir.join("subdir")))
 
     with my_vcr.use_cassette("test.json"):
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url)
 
     assert os.path.exists(str(tmpdir.join("subdir").join("test.json")))
 
 
-def test_override_set_cassette_library_dir(tmpdir, httpbin):
+def test_override_set_cassette_library_dir(tmpdir, mockbin_request_url):
     my_vcr = vcr.VCR(cassette_library_dir=str(tmpdir.join("subdir")))
 
     cld = str(tmpdir.join("subdir2"))
 
     with my_vcr.use_cassette("test.json", cassette_library_dir=cld):
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url)
 
     assert os.path.exists(str(tmpdir.join("subdir2").join("test.json")))
     assert not os.path.exists(str(tmpdir.join("subdir").join("test.json")))
 
 
-def test_override_match_on(tmpdir, httpbin):
+def test_override_match_on(tmpdir, mockbin_request_url):
     my_vcr = vcr.VCR(match_on=["method"])
 
     with my_vcr.use_cassette(str(tmpdir.join("test.json"))):
-        urlopen(httpbin.url)
+        urlopen(mockbin_request_url)
 
     with my_vcr.use_cassette(str(tmpdir.join("test.json"))) as cass:
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url)
 
     assert len(cass) == 1
     assert cass.play_count == 1
@@ -56,3 +60,23 @@ def test_missing_matcher():
     with pytest.raises(KeyError):
         with my_vcr.use_cassette("test.yaml", match_on=["notawesome"]):
             pass
+
+
+def test_dont_record_on_exception(tmpdir, mockbin_request_url):
+    my_vcr = vcr.VCR(record_on_exception=False)
+
+    @my_vcr.use_cassette(str(tmpdir.join("dontsave.yml")))
+    def some_test():
+        assert b"Not in content" in urlopen(mockbin_request_url)
+
+    with pytest.raises(AssertionError):
+        some_test()
+
+    assert not os.path.exists(str(tmpdir.join("dontsave.yml")))
+
+    # Make sure context decorator has the same behavior
+    with pytest.raises(AssertionError):
+        with my_vcr.use_cassette(str(tmpdir.join("dontsave2.yml"))):
+            assert b"Not in content" in urlopen(mockbin_request_url).read()
+
+    assert not os.path.exists(str(tmpdir.join("dontsave2.yml")))

tests/integration/test_disksaver.py

@@ -10,19 +10,19 @@ from urllib.request import urlopen
 import vcr
 
 
-def test_disk_saver_nowrite(tmpdir, httpbin):
+def test_disk_saver_nowrite(tmpdir, mockbin_request_url):
     """
     Ensure that when you close a cassette without changing it it doesn't
     rewrite the file
     """
     fname = str(tmpdir.join("synopsis.yaml"))
     with vcr.use_cassette(fname) as cass:
-        urlopen(httpbin.url).read()
+        urlopen(mockbin_request_url).read()
         assert cass.play_count == 0
     last_mod = os.path.getmtime(fname)
 
     with vcr.use_cassette(fname) as cass:
-        urlopen(httpbin.url).read()
+        urlopen(mockbin_request_url).read()
         assert cass.play_count == 1
         assert cass.dirty is False
     last_mod2 = os.path.getmtime(fname)
@@ -30,14 +30,14 @@ def test_disk_saver_nowrite(tmpdir, httpbin):
     assert last_mod == last_mod2
 
 
-def test_disk_saver_write(tmpdir, httpbin):
+def test_disk_saver_write(tmpdir, mockbin_request_url):
     """
     Ensure that when you close a cassette after changing it it does
     rewrite the file
     """
     fname = str(tmpdir.join("synopsis.yaml"))
     with vcr.use_cassette(fname) as cass:
-        urlopen(httpbin.url).read()
+        urlopen(mockbin_request_url).read()
         assert cass.play_count == 0
     last_mod = os.path.getmtime(fname)
 
@@ -45,9 +45,9 @@ def test_disk_saver_write(tmpdir, httpbin):
     # the mtime doesn't change
     time.sleep(1)
 
-    with vcr.use_cassette(fname, record_mode="any") as cass:
+    with vcr.use_cassette(fname, record_mode=vcr.mode.ANY) as cass:
-        urlopen(httpbin.url).read()
+        urlopen(mockbin_request_url).read()
-        urlopen(httpbin.url + "/get").read()
+        urlopen(mockbin_request_url + "/get").read()
         assert cass.play_count == 1
         assert cass.dirty
     last_mod2 = os.path.getmtime(fname)

tests/integration/test_filter.py

@@ -1,12 +1,14 @@
 import base64
-import pytest
-from urllib.request import urlopen, Request
-from urllib.parse import urlencode
-from urllib.error import HTTPError
-import vcr
 import json
+from urllib.error import HTTPError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+import pytest
 from assertions import assert_cassette_has_one_response, assert_is_json
 
+import vcr
+
 
 def _request_with_auth(url, username, password):
     request = Request(url)
@@ -106,6 +108,18 @@ def test_decompress_gzip(tmpdir, httpbin):
     assert_is_json(decoded_response)
 
 
+def test_decomptess_empty_body(tmpdir, httpbin):
+    url = httpbin.url + "/gzip"
+    request = Request(url, headers={"Accept-Encoding": ["gzip, deflate"]}, method="HEAD")
+    cass_file = str(tmpdir.join("gzip_empty_response.yaml"))
+    with vcr.use_cassette(cass_file, decode_compressed_response=True):
+        response = urlopen(request).read()
+    with vcr.use_cassette(cass_file) as cass:
+        decoded_response = urlopen(request).read()
+        assert_cassette_has_one_response(cass)
+    assert decoded_response == response
+
+
 def test_decompress_deflate(tmpdir, httpbin):
     url = httpbin.url + "/deflate"
     request = Request(url, headers={"Accept-Encoding": ["gzip, deflate"]})

tests/integration/test_httplib2.py

@@ -1,16 +1,13 @@
 # -*- coding: utf-8 -*-
 """Integration tests with httplib2"""
-
-import sys
-
 from urllib.parse import urlencode
+
 import pytest
 import pytest_httpbin.certs
+from assertions import assert_cassette_has_one_response
 
 import vcr
 
-from assertions import assert_cassette_has_one_response
-
 httplib2 = pytest.importorskip("httplib2")
 
 
@@ -20,8 +17,6 @@ def http():
     with the certificate replaced by the httpbin one.
     """
     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)
 
 
@@ -61,13 +56,14 @@ def test_response_headers(tmpdir, httpbin_both):
         assert set(headers) == set(resp.items())
 
 
-def test_effective_url(tmpdir, httpbin_both):
+def test_effective_url(tmpdir):
     """Ensure that the effective_url is captured"""
-    url = httpbin_both.url + "/redirect-to?url=/html"
+    url = "http://mockbin.org/redirect/301"
+
     with vcr.use_cassette(str(tmpdir.join("headers.yaml"))):
         resp, _ = http().request(url)
         effective_url = resp["content-location"]
-        assert effective_url == httpbin_both + "/html"
+        assert effective_url == "http://mockbin.org/redirect/301/0"
 
     with vcr.use_cassette(str(tmpdir.join("headers.yaml"))):
         resp, _ = http().request(url)

tests/integration/test_httpx.py

@@ -0,0 +1,306 @@
+import os
+
+import pytest
+
+asyncio = pytest.importorskip("asyncio")
+httpx = pytest.importorskip("httpx")
+
+import vcr  # noqa: E402
+from vcr.stubs.httpx_stubs import HTTPX_REDIRECT_PARAM  # noqa: E402
+
+
+class BaseDoRequest:
+    _client_class = None
+
+    def __init__(self, *args, **kwargs):
+        self._client_args = args
+        self._client_kwargs = kwargs
+
+    def _make_client(self):
+        return self._client_class(*self._client_args, **self._client_kwargs)
+
+
+class DoSyncRequest(BaseDoRequest):
+    _client_class = httpx.Client
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+    @property
+    def client(self):
+        try:
+            return self._client
+        except AttributeError:
+            self._client = self._make_client()
+            return self._client
+
+    def __call__(self, *args, **kwargs):
+        return self.client.request(*args, timeout=60, **kwargs)
+
+
+class DoAsyncRequest(BaseDoRequest):
+    _client_class = httpx.AsyncClient
+
+    def __enter__(self):
+        # Need to manage both loop and client, because client's implementation
+        # will fail if the loop is closed before the client's end of life.
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        self._client = self._make_client()
+        self._loop.run_until_complete(self._client.__aenter__())
+        return self
+
+    def __exit__(self, *args):
+        try:
+            self._loop.run_until_complete(self._client.__aexit__(*args))
+        finally:
+            del self._client
+            self._loop.close()
+            del self._loop
+
+    @property
+    def client(self):
+        try:
+            return self._client
+        except AttributeError:
+            raise ValueError('To access async client, use "with do_request() as client"')
+
+    def __call__(self, *args, **kwargs):
+        if hasattr(self, "_loop"):
+            return self._loop.run_until_complete(self.client.request(*args, **kwargs))
+
+        # Use one-time context and dispose of the loop/client afterwards
+        with self:
+            return self(*args, **kwargs)
+
+
+def pytest_generate_tests(metafunc):
+    if "do_request" in metafunc.fixturenames:
+        metafunc.parametrize("do_request", [DoAsyncRequest, DoSyncRequest])
+
+
+@pytest.fixture
+def yml(tmpdir, request):
+    return str(tmpdir.join(request.function.__name__ + ".yaml"))
+
+
+def test_status(tmpdir, mockbin, do_request):
+    url = mockbin
+
+    with vcr.use_cassette(str(tmpdir.join("status.yaml"))):
+        response = do_request()("GET", url)
+
+    with vcr.use_cassette(str(tmpdir.join("status.yaml"))) as cassette:
+        cassette_response = do_request()("GET", url)
+        assert cassette_response.status_code == response.status_code
+        assert cassette.play_count == 1
+
+
+def test_case_insensitive_headers(tmpdir, mockbin, do_request):
+    url = mockbin
+
+    with vcr.use_cassette(str(tmpdir.join("whatever.yaml"))):
+        do_request()("GET", url)
+
+    with vcr.use_cassette(str(tmpdir.join("whatever.yaml"))) as cassette:
+        cassette_response = do_request()("GET", url)
+        assert "Content-Type" in cassette_response.headers
+        assert "content-type" in cassette_response.headers
+        assert cassette.play_count == 1
+
+
+def test_content(tmpdir, mockbin, do_request):
+    url = mockbin
+
+    with vcr.use_cassette(str(tmpdir.join("cointent.yaml"))):
+        response = do_request()("GET", url)
+
+    with vcr.use_cassette(str(tmpdir.join("cointent.yaml"))) as cassette:
+        cassette_response = do_request()("GET", url)
+        assert cassette_response.content == response.content
+        assert cassette.play_count == 1
+
+
+def test_json(tmpdir, mockbin, do_request):
+    url = mockbin + "/request"
+
+    headers = {"content-type": "application/json"}
+
+    with vcr.use_cassette(str(tmpdir.join("json.yaml"))):
+        response = do_request(headers=headers)("GET", url)
+
+    with vcr.use_cassette(str(tmpdir.join("json.yaml"))) as cassette:
+        cassette_response = do_request(headers=headers)("GET", url)
+        assert cassette_response.json() == response.json()
+        assert cassette.play_count == 1
+
+
+def test_params_same_url_distinct_params(tmpdir, mockbin, do_request):
+    url = mockbin + "/request"
+    headers = {"Content-Type": "application/json"}
+    params = {"a": 1, "b": False, "c": "c"}
+
+    with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
+        response = do_request()("GET", url, params=params, headers=headers)
+
+    with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
+        cassette_response = do_request()("GET", url, params=params, headers=headers)
+        assert cassette_response.request.url == response.request.url
+        assert cassette_response.json() == response.json()
+        assert cassette.play_count == 1
+
+    params = {"other": "params"}
+    with vcr.use_cassette(str(tmpdir.join("get.yaml"))) as cassette:
+        with pytest.raises(vcr.errors.CannotOverwriteExistingCassetteException):
+            do_request()("GET", url, params=params, headers=headers)
+
+
+def test_redirect(mockbin, yml, do_request):
+    url = mockbin + "/redirect/303/2"
+
+    redirect_kwargs = {HTTPX_REDIRECT_PARAM.name: True}
+
+    response = do_request()("GET", url, **redirect_kwargs)
+    with vcr.use_cassette(yml):
+        response = do_request()("GET", url, **redirect_kwargs)
+
+    with vcr.use_cassette(yml) as cassette:
+        cassette_response = do_request()("GET", url, **redirect_kwargs)
+
+        assert cassette_response.status_code == response.status_code
+        assert len(cassette_response.history) == len(response.history)
+        assert len(cassette) == 3
+        assert cassette.play_count == 3
+
+    # Assert that the real response and the cassette response have a similar
+    # looking request_info.
+    assert cassette_response.request.url == response.request.url
+    assert cassette_response.request.method == response.request.method
+    assert {k: v for k, v in cassette_response.request.headers.items()} == {
+        k: v for k, v in response.request.headers.items()
+    }
+
+
+def test_work_with_gzipped_data(mockbin, do_request, yml):
+    url = mockbin + "/gzip?foo=bar"
+    headers = {"accept-encoding": "deflate, gzip"}
+
+    with vcr.use_cassette(yml):
+        do_request(headers=headers)("GET", url)
+
+    with vcr.use_cassette(yml) as cassette:
+        cassette_response = do_request(headers=headers)("GET", url)
+
+        assert cassette_response.headers["content-encoding"] == "gzip"
+        assert cassette_response.read()
+        assert cassette.play_count == 1
+
+
+@pytest.mark.parametrize("url", ["https://github.com/kevin1024/vcrpy/issues/" + str(i) for i in range(3, 6)])
+def test_simple_fetching(do_request, yml, url):
+    with vcr.use_cassette(yml):
+        do_request()("GET", url)
+
+    with vcr.use_cassette(yml) as cassette:
+        cassette_response = do_request()("GET", url)
+        assert str(cassette_response.request.url) == url
+        assert cassette.play_count == 1
+
+
+def test_behind_proxy(do_request):
+    # This is recorded because otherwise we should have a live proxy somewhere.
+    yml = (
+        os.path.dirname(os.path.realpath(__file__)) + "/cassettes/" + "test_httpx_test_test_behind_proxy.yml"
+    )
+    url = "https://mockbin.org/headers"
+    proxy = "http://localhost:8080"
+    proxies = {"http://": proxy, "https://": proxy}
+
+    with vcr.use_cassette(yml):
+        response = do_request(proxies=proxies, verify=False)("GET", url)
+
+    with vcr.use_cassette(yml) as cassette:
+        cassette_response = do_request(proxies=proxies, verify=False)("GET", url)
+        assert str(cassette_response.request.url) == url
+        assert cassette.play_count == 1
+
+        assert cassette_response.headers["Via"] == "my_own_proxy", str(cassette_response.headers)
+        assert cassette_response.request.url == response.request.url
+
+
+def test_cookies(tmpdir, mockbin, do_request):
+    def client_cookies(client):
+        return [c for c in client.client.cookies]
+
+    def response_cookies(response):
+        return [c for c in response.cookies]
+
+    url = mockbin + "/bin/26148652-fe25-4f21-aaf5-689b5b4bf65f"
+    headers = {"cookie": "k1=v1;k2=v2"}
+
+    with do_request(headers=headers) as client:
+        assert client_cookies(client) == []
+
+        redirect_kwargs = {HTTPX_REDIRECT_PARAM.name: True}
+
+        testfile = str(tmpdir.join("cookies.yml"))
+        with vcr.use_cassette(testfile):
+            r1 = client("GET", url, **redirect_kwargs)
+
+            assert response_cookies(r1) == ["k1", "k2"]
+
+            r2 = client("GET", url, **redirect_kwargs)
+
+            assert response_cookies(r2) == ["k1", "k2"]
+            assert client_cookies(client) == ["k1", "k2"]
+
+    with do_request(headers=headers) as new_client:
+        assert client_cookies(new_client) == []
+
+        with vcr.use_cassette(testfile) as cassette:
+            cassette_response = new_client("GET", url)
+
+            assert cassette.play_count == 1
+            assert response_cookies(cassette_response) == ["k1", "k2"]
+            assert client_cookies(new_client) == ["k1", "k2"]
+
+
+def test_relative_redirects(tmpdir, scheme, do_request, mockbin):
+    redirect_kwargs = {HTTPX_REDIRECT_PARAM.name: True}
+
+    url = mockbin + "/redirect/301?to=/redirect/301?to=/request"
+    testfile = str(tmpdir.join("relative_redirects.yml"))
+    with vcr.use_cassette(testfile):
+        response = do_request()("GET", url, **redirect_kwargs)
+        assert len(response.history) == 2, response
+        assert response.json()["url"].endswith("request")
+
+    with vcr.use_cassette(testfile) as cassette:
+        response = do_request()("GET", url, **redirect_kwargs)
+        assert len(response.history) == 2
+        assert response.json()["url"].endswith("request")
+
+        assert cassette.play_count == 3
+
+
+def test_redirect_wo_allow_redirects(do_request, mockbin, yml):
+    url = mockbin + "/redirect/308/5"
+
+    redirect_kwargs = {HTTPX_REDIRECT_PARAM.name: False}
+
+    with vcr.use_cassette(yml):
+        response = do_request()("GET", url, **redirect_kwargs)
+
+        assert str(response.url).endswith("308/5")
+        assert response.status_code == 308
+
+    with vcr.use_cassette(yml) as cassette:
+        response = do_request()("GET", url, **redirect_kwargs)
+
+        assert str(response.url).endswith("308/5")
+        assert response.status_code == 308
+
+        assert cassette.play_count == 1

tests/integration/test_ignore.py

@@ -1,6 +1,7 @@
-from urllib.request import urlopen
 import socket
 from contextlib import contextmanager
+from urllib.request import urlopen
+
 import vcr
 
 

tests/integration/test_matchers.py

@@ -1,7 +1,8 @@
-import vcr
-import pytest
 from urllib.request import urlopen
 
+import pytest
+
+import vcr
 
 DEFAULT_URI = "http://httpbin.org/get?p1=q1&p2=q2"  # base uri for testing
 
@@ -13,13 +14,13 @@ def _replace_httpbin(uri, httpbin, httpbin_secure):
 @pytest.fixture
 def cassette(tmpdir, httpbin, httpbin_secure):
     """
-    Helper fixture used to prepare the cassete
+    Helper fixture used to prepare the cassette
     returns path to the recorded cassette
     """
     default_uri = _replace_httpbin(DEFAULT_URI, httpbin, httpbin_secure)
 
     cassette_path = str(tmpdir.join("test.yml"))
-    with vcr.use_cassette(cassette_path, record_mode="all"):
+    with vcr.use_cassette(cassette_path, record_mode=vcr.mode.ALL):
         urlopen(default_uri)
     return cassette_path
 
@@ -35,7 +36,6 @@ def cassette(tmpdir, httpbin, httpbin_secure):
     ],
 )
 def test_matchers(httpbin, httpbin_secure, cassette, matcher, matching_uri, not_matching_uri):
-
     matching_uri = _replace_httpbin(matching_uri, httpbin, httpbin_secure)
     not_matching_uri = _replace_httpbin(not_matching_uri, httpbin, httpbin_secure)
     default_uri = _replace_httpbin(DEFAULT_URI, httpbin, httpbin_secure)
@@ -75,7 +75,6 @@ def test_method_matcher(cassette, httpbin, httpbin_secure):
     "uri", [DEFAULT_URI, "http://httpbin.org/get?p2=q2&p1=q1", "http://httpbin.org/get?p2=q2&p1=q1"]
 )
 def test_default_matcher_matches(cassette, uri, httpbin, httpbin_secure):
-
     uri = _replace_httpbin(uri, httpbin, httpbin_secure)
 
     with vcr.use_cassette(cassette) as cass:

tests/integration/test_multiple.py

@@ -1,7 +1,9 @@
-import pytest
-import vcr
 from urllib.request import urlopen
 
+import pytest
+
+import vcr
+
 
 def test_making_extra_request_raises_exception(tmpdir, httpbin):
     # make two requests in the first request that are considered

tests/integration/test_proxy.py

@@ -1,15 +1,13 @@
 # -*- coding: utf-8 -*-
 """Test using a proxy."""
 
-# External imports
-import multiprocessing
-import pytest
-
 import http.server
+import multiprocessing
 import socketserver
 from urllib.request import urlopen
 
-# Internal imports
+import pytest
+
 import vcr
 
 # Conditional imports
@@ -39,7 +37,7 @@ class Proxy(http.server.SimpleHTTPRequestHandler):
         self.copyfile(upstream_response, self.wfile)
 
 
-@pytest.yield_fixture(scope="session")
+@pytest.fixture(scope="session")
 def proxy_server():
     httpd = socketserver.ThreadingTCPServer(("", 0), Proxy)
     proxy_process = multiprocessing.Process(target=httpd.serve_forever)

tests/integration/test_record_mode.py

@@ -1,15 +1,17 @@
-import pytest
-import vcr
 from urllib.request import urlopen
 
+import pytest
+
+import vcr
+
 
 def test_once_record_mode(tmpdir, httpbin):
     testfile = str(tmpdir.join("recordmode.yml"))
-    with vcr.use_cassette(testfile, record_mode="once"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ONCE):
         # cassette file doesn't exist, so create.
         urlopen(httpbin.url).read()
 
-    with vcr.use_cassette(testfile, record_mode="once"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ONCE):
         # make the same request again
         urlopen(httpbin.url).read()
 
@@ -22,12 +24,12 @@ def test_once_record_mode(tmpdir, httpbin):
 
 def test_once_record_mode_two_times(tmpdir, httpbin):
     testfile = str(tmpdir.join("recordmode.yml"))
-    with vcr.use_cassette(testfile, record_mode="once"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ONCE):
         # get two of the same file
         urlopen(httpbin.url).read()
         urlopen(httpbin.url).read()
 
-    with vcr.use_cassette(testfile, record_mode="once"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ONCE):
         # do it again
         urlopen(httpbin.url).read()
         urlopen(httpbin.url).read()
@@ -35,7 +37,7 @@ def test_once_record_mode_two_times(tmpdir, httpbin):
 
 def test_once_mode_three_times(tmpdir, httpbin):
     testfile = str(tmpdir.join("recordmode.yml"))
-    with vcr.use_cassette(testfile, record_mode="once"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ONCE):
         # get three of the same file
         urlopen(httpbin.url).read()
         urlopen(httpbin.url).read()
@@ -45,11 +47,11 @@ def test_once_mode_three_times(tmpdir, httpbin):
 def test_new_episodes_record_mode(tmpdir, httpbin):
     testfile = str(tmpdir.join("recordmode.yml"))
 
-    with vcr.use_cassette(testfile, record_mode="new_episodes"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NEW_EPISODES):
         # cassette file doesn't exist, so create.
         urlopen(httpbin.url).read()
 
-    with vcr.use_cassette(testfile, record_mode="new_episodes") as cass:
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NEW_EPISODES) as cass:
         # make the same request again
         urlopen(httpbin.url).read()
 
@@ -57,7 +59,7 @@ def test_new_episodes_record_mode(tmpdir, httpbin):
         assert cass.all_played
 
         # in the "new_episodes" record mode, we can add more requests to
-        # a cassette without repurcussions.
+        # a cassette without repercussions.
         urlopen(httpbin.url + "/get").read()
 
         # one of the responses has been played
@@ -66,7 +68,7 @@ def test_new_episodes_record_mode(tmpdir, httpbin):
         # not all responses have been played
         assert not cass.all_played
 
-    with vcr.use_cassette(testfile, record_mode="new_episodes") as cass:
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NEW_EPISODES) as cass:
         # the cassette should now have 2 responses
         assert len(cass.responses) == 2
 
@@ -74,11 +76,11 @@ def test_new_episodes_record_mode(tmpdir, httpbin):
 def test_new_episodes_record_mode_two_times(tmpdir, httpbin):
     testfile = str(tmpdir.join("recordmode.yml"))
     url = httpbin.url + "/bytes/1024"
-    with vcr.use_cassette(testfile, record_mode="new_episodes"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NEW_EPISODES):
         # cassette file doesn't exist, so create.
         original_first_response = urlopen(url).read()
 
-    with vcr.use_cassette(testfile, record_mode="new_episodes"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NEW_EPISODES):
         # make the same request again
         assert urlopen(url).read() == original_first_response
 
@@ -86,7 +88,7 @@ def test_new_episodes_record_mode_two_times(tmpdir, httpbin):
         # to the cassette without repercussions
         original_second_response = urlopen(url).read()
 
-    with vcr.use_cassette(testfile, record_mode="once"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ONCE):
         # make the same request again
         assert urlopen(url).read() == original_first_response
         assert urlopen(url).read() == original_second_response
@@ -99,16 +101,16 @@ def test_new_episodes_record_mode_two_times(tmpdir, httpbin):
 def test_all_record_mode(tmpdir, httpbin):
     testfile = str(tmpdir.join("recordmode.yml"))
 
-    with vcr.use_cassette(testfile, record_mode="all"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ALL):
         # cassette file doesn't exist, so create.
         urlopen(httpbin.url).read()
 
-    with vcr.use_cassette(testfile, record_mode="all") as cass:
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ALL) as cass:
         # make the same request again
         urlopen(httpbin.url).read()
 
         # in the "all" record mode, we can add more requests to
-        # a cassette without repurcussions.
+        # a cassette without repercussions.
         urlopen(httpbin.url + "/get").read()
 
         # The cassette was never actually played, even though it existed.
@@ -121,7 +123,7 @@ def test_none_record_mode(tmpdir, httpbin):
     # Cassette file doesn't exist, yet we are trying to make a request.
     # raise hell.
     testfile = str(tmpdir.join("recordmode.yml"))
-    with vcr.use_cassette(testfile, record_mode="none"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NONE):
         with pytest.raises(Exception):
             urlopen(httpbin.url).read()
 
@@ -130,11 +132,11 @@ def test_none_record_mode_with_existing_cassette(tmpdir, httpbin):
     # create a cassette file
     testfile = str(tmpdir.join("recordmode.yml"))
 
-    with vcr.use_cassette(testfile, record_mode="all"):
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.ALL):
         urlopen(httpbin.url).read()
 
     # play from cassette file
-    with vcr.use_cassette(testfile, record_mode="none") as cass:
+    with vcr.use_cassette(testfile, record_mode=vcr.mode.NONE) as cass:
         urlopen(httpbin.url).read()
         assert cass.play_count == 1
         # but if I try to hit the net, raise an exception.

tests/integration/test_register_matcher.py

@@ -1,6 +1,7 @@
-import vcr
 from urllib.request import urlopen
 
+import vcr
+
 
 def true_matcher(r1, r2):
     return True
@@ -10,27 +11,27 @@ def false_matcher(r1, r2):
     return False
 
 
-def test_registered_true_matcher(tmpdir, httpbin):
+def test_registered_true_matcher(tmpdir, mockbin_request_url):
     my_vcr = vcr.VCR()
     my_vcr.register_matcher("true", true_matcher)
     testfile = str(tmpdir.join("test.yml"))
     with my_vcr.use_cassette(testfile, match_on=["true"]):
         # These 2 different urls are stored as the same request
-        urlopen(httpbin.url)
+        urlopen(mockbin_request_url)
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url + "/get")
 
     with my_vcr.use_cassette(testfile, match_on=["true"]):
         # I can get the response twice even though I only asked for it once
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url)
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url)
 
 
-def test_registered_false_matcher(tmpdir, httpbin):
+def test_registered_false_matcher(tmpdir, mockbin_request_url):
     my_vcr = vcr.VCR()
     my_vcr.register_matcher("false", false_matcher)
     testfile = str(tmpdir.join("test.yml"))
     with my_vcr.use_cassette(testfile, match_on=["false"]) as cass:
         # These 2 different urls are stored as different requests
-        urlopen(httpbin.url)
+        urlopen(mockbin_request_url)
-        urlopen(httpbin.url + "/get")
+        urlopen(mockbin_request_url + "/get")
         assert len(cass) == 2

tests/integration/test_register_persister.py

@@ -12,7 +12,7 @@ from vcr.persisters.filesystem import FilesystemPersister
 
 class CustomFilesystemPersister(object):
     """Behaves just like default FilesystemPersister but adds .test extension
-       to the cassette file"""
+    to the cassette file"""
 
     @staticmethod
     def load_cassette(cassette_path, serializer):
@@ -30,7 +30,7 @@ def test_save_cassette_with_custom_persister(tmpdir, httpbin):
     my_vcr = vcr.VCR()
     my_vcr.register_persister(CustomFilesystemPersister)
 
-    # Check to make sure directory doesnt exist
+    # Check to make sure directory doesn't exist
     assert not os.path.exists(str(tmpdir.join("nonexistent")))
 
     # Run VCR to create dir and cassette file using new save_cassette callback

tests/integration/test_request.py

@@ -1,6 +1,7 @@
-import vcr
 from urllib.request import urlopen
 
+import vcr
+
 
 def test_recorded_request_uri_with_redirected_request(tmpdir, httpbin):
     with vcr.use_cassette(str(tmpdir.join("test.yml"))) as cass:

tests/integration/test_requests.py

@@ -1,11 +1,9 @@
-# -*- 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
 
+import vcr
+
 requests = pytest.importorskip("requests")
 from requests.exceptions import ConnectionError  # noqa E402
 
@@ -117,10 +115,6 @@ def test_post_chunked_binary(tmpdir, httpbin):
 
 
 @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"])

tests/integration/test_stubs.py

@@ -1,10 +1,11 @@
-import vcr
-import zlib
-import json
 import http.client as httplib
+import json
+import zlib
 
 from assertions import assert_is_json
 
+import vcr
+
 
 def _headers_are_case_insensitive(host, port):
     conn = httplib.HTTPConnection(host, port)
@@ -64,7 +65,7 @@ def test_original_decoded_response_is_not_modified(tmpdir, httpbin):
         inside = conn.getresponse()
 
         # Assert that we do not modify the original response while appending
-        # to the casssette.
+        # to the cassette.
         assert "gzip" == inside.headers["content-encoding"]
 
         # They should effectively be the same response.

tests/integration/test_tornado.py

@@ -4,11 +4,11 @@
 import json
 
 import pytest
+from assertions import assert_cassette_empty, assert_is_json
+
 import vcr
 from vcr.errors import CannotOverwriteExistingCassetteException
 
-from assertions import assert_cassette_empty, assert_is_json
-
 tornado = pytest.importorskip("tornado")
 http = pytest.importorskip("tornado.httpclient")
 
@@ -44,12 +44,6 @@ def post(client, url, data=None, **kwargs):
     return client.fetch(http.HTTPRequest(url, method="POST", **kwargs))
 
 
-@pytest.fixture(params=["https", "http"])
-def scheme(request):
-    """Fixture that returns both http and https."""
-    return request.param
-
-
 @pytest.mark.gen_test
 def test_status_code(get_client, scheme, tmpdir):
     """Ensure that we can read the status code"""
@@ -90,10 +84,10 @@ def test_body(get_client, tmpdir, scheme):
 @pytest.mark.gen_test
 def test_effective_url(get_client, scheme, tmpdir):
     """Ensure that the effective_url is captured"""
-    url = scheme + "://httpbin.org/redirect-to?url=/html"
+    url = scheme + "://mockbin.org/redirect/301?url=/html"
     with vcr.use_cassette(str(tmpdir.join("url.yaml"))):
         effective_url = (yield get(get_client(), url)).effective_url
-        assert effective_url == scheme + "://httpbin.org/html"
+        assert effective_url == scheme + "://mockbin.org/redirect/301/0"
 
     with vcr.use_cassette(str(tmpdir.join("url.yaml"))) as cass:
         assert effective_url == (yield get(get_client(), url)).effective_url
@@ -156,7 +150,7 @@ def test_post(get_client, tmpdir, scheme):
 @pytest.mark.gen_test
 def test_redirects(get_client, tmpdir, scheme):
     """Ensure that we can handle redirects"""
-    url = scheme + "://httpbin.org/redirect-to?url=bytes/1024"
+    url = scheme + "://mockbin.org/redirect/301?url=bytes/1024"
     with vcr.use_cassette(str(tmpdir.join("requests.yaml"))):
         content = (yield get(get_client(), url)).body
 

tests/integration/test_urllib2.py

@@ -2,15 +2,15 @@
 """Integration tests with urllib2"""
 
 import ssl
-from urllib.request import urlopen
 from urllib.parse import urlencode
+from urllib.request import urlopen
+
 import pytest_httpbin.certs
+from assertions import assert_cassette_has_one_response
 
 # Internal imports
 import vcr
 
-from assertions import assert_cassette_has_one_response
-
 
 def urlopen_with_cafile(*args, **kwargs):
     context = ssl.create_default_context(cafile=pytest_httpbin.certs.where())
@@ -56,12 +56,13 @@ def test_response_headers(httpbin_both, tmpdir):
         assert sorted(open1) == sorted(open2)
 
 
-def test_effective_url(httpbin_both, tmpdir):
+def test_effective_url(tmpdir):
     """Ensure that the effective_url is captured"""
-    url = httpbin_both.url + "/redirect-to?url=/html"
+    url = "http://mockbin.org/redirect/301"
+
     with vcr.use_cassette(str(tmpdir.join("headers.yaml"))):
         effective_url = urlopen_with_cafile(url).geturl()
-        assert effective_url == httpbin_both.url + "/html"
+        assert effective_url == "http://mockbin.org/redirect/301/0"
 
     with vcr.use_cassette(str(tmpdir.join("headers.yaml"))):
         assert effective_url == urlopen_with_cafile(url).geturl()

tests/integration/test_urllib3.py

@@ -4,9 +4,10 @@
 
 import pytest
 import pytest_httpbin
+from assertions import assert_cassette_empty, assert_is_json
+
 import vcr
 from vcr.patch import force_reset
-from assertions import assert_cassette_empty, assert_is_json
 
 urllib3 = pytest.importorskip("urllib3")
 
@@ -94,9 +95,10 @@ def test_post(tmpdir, httpbin_both, verify_pool_mgr):
     assert req1 == req2
 
 
-def test_redirects(tmpdir, httpbin_both, verify_pool_mgr):
+def test_redirects(tmpdir, verify_pool_mgr):
     """Ensure that we can handle redirects"""
-    url = httpbin_both.url + "/redirect-to?url=bytes/1024"
+    url = "http://mockbin.org/redirect/301"
+
     with vcr.use_cassette(str(tmpdir.join("verify_pool_mgr.yaml"))):
         content = verify_pool_mgr.request("GET", url).data
 
@@ -104,8 +106,9 @@ def test_redirects(tmpdir, httpbin_both, verify_pool_mgr):
         assert content == verify_pool_mgr.request("GET", url).data
         # Ensure that we've now cached *two* responses. One for the redirect
         # and one for the final fetch
-        assert len(cass) == 2
+
-        assert cass.play_count == 2
+    assert len(cass) == 2
+    assert cass.play_count == 2
 
 
 def test_cross_scheme(tmpdir, httpbin, httpbin_secure, verify_pool_mgr):

tests/integration/test_wild.py

@@ -1,9 +1,10 @@
 import http.client as httplib
 import multiprocessing
-import pytest
 from xmlrpc.client import ServerProxy
 from xmlrpc.server import SimpleXMLRPCServer
 
+import pytest
+
 requests = pytest.importorskip("requests")
 
 import vcr  # NOQA
@@ -83,7 +84,7 @@ def start_rpc_server(q):
     httpd.serve_forever()
 
 
-@pytest.yield_fixture(scope="session")
+@pytest.fixture(scope="session")
 def rpc_server():
     q = multiprocessing.Queue()
     proxy_process = multiprocessing.Process(target=start_rpc_server, args=(q,))

tests/unit/test_cassettes.py

@@ -1,10 +1,10 @@
 import contextlib
 import copy
-import inspect
-import mock
-import os
-
 import http.client as httplib
+import inspect
+import os
+from unittest import mock
+
 import pytest
 import yaml
 
@@ -138,6 +138,31 @@ def test_cassette_all_played():
     assert a.all_played
 
 
+@mock.patch("vcr.cassette.requests_match", _mock_requests_match)
+def test_cassette_allow_playback_repeats():
+    a = Cassette("test", allow_playback_repeats=True)
+    a.append("foo", "bar")
+    a.append("other", "resp")
+    for x in range(10):
+        assert a.play_response("foo") == "bar"
+    assert a.play_count == 10
+    assert a.all_played is False
+    assert a.play_response("other") == "resp"
+    assert a.play_count == 11
+    assert a.all_played
+
+    a.allow_playback_repeats = False
+    with pytest.raises(UnhandledHTTPRequestError) as e:
+        a.play_response("foo")
+    assert str(e.value) == "\"The cassette ('test') doesn't contain the request ('foo') asked for\""
+    a.rewind()
+    assert a.all_played is False
+    assert a.play_response("foo") == "bar"
+    assert a.all_played is False
+    assert a.play_response("other") == "resp"
+    assert a.all_played
+
+
 @mock.patch("vcr.cassette.requests_match", _mock_requests_match)
 def test_cassette_rewound():
     a = Cassette("test")
@@ -184,7 +209,7 @@ def test_nesting_cassette_context_managers(*args):
         )
         assert_get_response_body_is("first_response")
 
-        # Make sure a second cassette can supercede the first
+        # Make sure a second cassette can supersede the first
         with Cassette.use(path="test") as second_cassette:
             with mock.patch.object(second_cassette, "play_response", return_value=second_response):
                 assert_get_response_body_is("second_response")
@@ -286,16 +311,16 @@ def test_func_path_generator():
 
 
 def test_use_as_decorator_on_coroutine():
-    original_http_connetion = httplib.HTTPConnection
+    original_http_connection = httplib.HTTPConnection
 
     @Cassette.use(inject=True)
     def test_function(cassette):
         assert httplib.HTTPConnection.cassette is cassette
-        assert httplib.HTTPConnection is not original_http_connetion
+        assert httplib.HTTPConnection is not original_http_connection
         value = yield 1
         assert value == 1
         assert httplib.HTTPConnection.cassette is cassette
-        assert httplib.HTTPConnection is not original_http_connetion
+        assert httplib.HTTPConnection is not original_http_connection
         value = yield 2
         assert value == 2
 
@@ -309,15 +334,15 @@ def test_use_as_decorator_on_coroutine():
 
 
 def test_use_as_decorator_on_generator():
-    original_http_connetion = httplib.HTTPConnection
+    original_http_connection = httplib.HTTPConnection
 
     @Cassette.use(inject=True)
     def test_function(cassette):
         assert httplib.HTTPConnection.cassette is cassette
-        assert httplib.HTTPConnection is not original_http_connetion
+        assert httplib.HTTPConnection is not original_http_connection
         yield 1
         assert httplib.HTTPConnection.cassette is cassette
-        assert httplib.HTTPConnection is not original_http_connetion
+        assert httplib.HTTPConnection is not original_http_connection
         yield 2
 
     assert list(test_function()) == [1, 2]

tests/unit/test_errors.py

@@ -1,4 +1,4 @@
-import mock
+from unittest import mock
 
 import pytest
 

tests/unit/test_filters.py

@@ -1,18 +1,19 @@
-from io import BytesIO
-from vcr.filters import (
-    remove_headers,
-    replace_headers,
-    remove_query_parameters,
-    replace_query_parameters,
-    remove_post_data_parameters,
-    replace_post_data_parameters,
-    decode_response,
-)
-from vcr.request import Request
 import gzip
 import json
-import mock
 import zlib
+from io import BytesIO
+from unittest import mock
+
+from vcr.filters import (
+    decode_response,
+    remove_headers,
+    remove_post_data_parameters,
+    remove_query_parameters,
+    replace_headers,
+    replace_post_data_parameters,
+    replace_query_parameters,
+)
+from vcr.request import Request
 
 
 def test_replace_headers():
@@ -220,6 +221,49 @@ def test_remove_all_json_post_data_parameters():
     assert request.body == b"{}"
 
 
+def test_replace_dict_post_data_parameters():
+    # This tests all of:
+    #   1. keeping a parameter
+    #   2. removing a parameter
+    #   3. replacing a parameter
+    #   4. replacing a parameter using a callable
+    #   5. removing a parameter using a callable
+    #   6. replacing a parameter that doesn't exist
+    body = {"one": "keep", "two": "lose", "three": "change", "four": "shout", "five": "whisper"}
+    request = Request("POST", "http://google.com", body, {})
+    request.headers["Content-Type"] = "application/x-www-form-urlencoded"
+    replace_post_data_parameters(
+        request,
+        [
+            ("two", None),
+            ("three", "tada"),
+            ("four", lambda key, value, request: value.upper()),
+            ("five", lambda key, value, request: None),
+            ("six", "doesntexist"),
+        ],
+    )
+    expected_data = {"one": "keep", "three": "tada", "four": "SHOUT"}
+    assert request.body == expected_data
+
+
+def test_remove_dict_post_data_parameters():
+    # Test the backward-compatible API wrapper.
+    body = {"id": "secret", "foo": "bar", "baz": "qux"}
+    request = Request("POST", "http://google.com", body, {})
+    request.headers["Content-Type"] = "application/x-www-form-urlencoded"
+    remove_post_data_parameters(request, ["id"])
+    expected_data = {"foo": "bar", "baz": "qux"}
+    assert request.body == expected_data
+
+
+def test_remove_all_dict_post_data_parameters():
+    body = {"id": "secret", "foo": "bar"}
+    request = Request("POST", "http://google.com", body, {})
+    request.headers["Content-Type"] = "application/x-www-form-urlencoded"
+    replace_post_data_parameters(request, [("id", None), ("foo", None)])
+    assert request.body == {}
+
+
 def test_decode_response_uncompressed():
     recorded_response = {
         "status": {"message": "OK", "code": 200},

tests/unit/test_json_serializer.py

@@ -1,6 +1,7 @@
 import pytest
-from vcr.serializers.jsonserializer import serialize
+
 from vcr.request import Request
+from vcr.serializers.jsonserializer import serialize
 
 
 def test_serialize_binary():

tests/unit/test_matchers.py

@@ -1,10 +1,9 @@
 import itertools
-import mock
+from unittest import mock
 
 import pytest
 
-from vcr import matchers
+from vcr import matchers, request
-from vcr import request
 
 # the dict contains requests with corresponding to its key difference
 # with 'base' request.

tests/unit/test_migration.py

@@ -1,6 +1,7 @@
 import filecmp
 import json
 import shutil
+
 import yaml
 
 import vcr.migration
@@ -44,4 +45,4 @@ def test_try_migrate_with_invalid_or_new_cassettes(tmpdir):
     for file_path in files:
         shutil.copy(file_path, cassette)
         assert not vcr.migration.try_migrate(cassette)
-        assert filecmp.cmp(cassette, file_path)  # shold not change file
+        assert filecmp.cmp(cassette, file_path)  # should not change file

tests/unit/test_request.py

@@ -1,6 +1,6 @@
 import pytest
 
-from vcr.request import Request, HeadersDict
+from vcr.request import HeadersDict, Request
 
 
 @pytest.mark.parametrize(
@@ -60,7 +60,6 @@ def test_uri(method, uri):
 
 
 def test_HeadersDict():
-
     # Simple test of CaseInsensitiveDict
     h = HeadersDict()
     assert h == {}

tests/unit/test_serialize.py

@@ -1,11 +1,11 @@
 # -*- encoding: utf-8 -*-
-import mock
+from unittest import mock
 
 import pytest
 
 from vcr.request import Request
 from vcr.serialize import deserialize, serialize
-from vcr.serializers import yamlserializer, jsonserializer, compat
+from vcr.serializers import compat, jsonserializer, yamlserializer
 
 
 def test_deserialize_old_yaml_cassette():

tests/unit/test_stubs.py

@@ -1,11 +1,12 @@
-import mock
+from unittest import mock
 
-from vcr.stubs import VCRHTTPSConnection
+from vcr import mode
 from vcr.cassette import Cassette
+from vcr.stubs import VCRHTTPSConnection
 
 
 class TestVCRConnection:
-    def test_setting_of_attributes_get_propogated_to_real_connection(self):
+    def test_setting_of_attributes_get_propagated_to_real_connection(self):
         vcr_connection = VCRHTTPSConnection("www.examplehost.com")
         vcr_connection.ssl_version = "example_ssl_version"
         assert vcr_connection.real_connection.ssl_version == "example_ssl_version"
@@ -13,6 +14,6 @@ class TestVCRConnection:
     @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.cassette = Cassette("test", record_mode=mode.ALL)
         vcr_connection.real_connection.connect()
         assert vcr_connection.real_connection.sock is not None

tests/unit/test_vcr.py

@@ -1,13 +1,14 @@
-import mock
+import http.client as httplib
 import os
+from pathlib import Path
+from unittest import mock
 
 import pytest
-import http.client as httplib
 
-from vcr import VCR, use_cassette
+from vcr import VCR, mode, use_cassette
+from vcr.patch import _HTTPConnection, force_reset
 from vcr.request import Request
 from vcr.stubs import VCRHTTPSConnection
-from vcr.patch import _HTTPConnection, force_reset
 
 
 def test_vcr_use_cassette():
@@ -31,7 +32,7 @@ def test_vcr_use_cassette():
         function()
         assert mock_cassette_load.call_args[1]["record_mode"] == test_vcr.record_mode
 
-        # Ensure that explicitly provided arguments still supercede
+        # Ensure that explicitly provided arguments still supersede
         # those on the vcr.
         new_record_mode = mock.Mock()
 
@@ -95,7 +96,6 @@ def test_vcr_before_record_response_iterable():
 
     # Prevent actually saving the cassette
     with mock.patch("vcr.cassette.FilesystemPersister.save_cassette"):
-
         # Baseline: non-iterable before_record_response should work
         mock_filter = mock.Mock()
         vcr = VCR(before_record_response=mock_filter)
@@ -119,7 +119,6 @@ def test_before_record_response_as_filter():
 
     # Prevent actually saving the cassette
     with mock.patch("vcr.cassette.FilesystemPersister.save_cassette"):
-
         filter_all = mock.Mock(return_value=None)
         vcr = VCR(before_record_response=filter_all)
         with vcr.use_cassette("test") as cassette:
@@ -133,7 +132,6 @@ def test_vcr_path_transformer():
 
     # Prevent actually saving the cassette
     with mock.patch("vcr.cassette.FilesystemPersister.save_cassette"):
-
         # Baseline: path should be unchanged
         vcr = VCR()
         with vcr.use_cassette("test") as cassette:
@@ -188,11 +186,11 @@ def test_custom_patchers():
 def test_inject_cassette():
     vcr = VCR(inject_cassette=True)
 
-    @vcr.use_cassette("test", record_mode="once")
+    @vcr.use_cassette("test", record_mode=mode.ONCE)
     def with_cassette_injected(cassette):
-        assert cassette.record_mode == "once"
+        assert cassette.record_mode == mode.ONCE
 
-    @vcr.use_cassette("test", record_mode="once", inject_cassette=False)
+    @vcr.use_cassette("test", record_mode=mode.ONCE, inject_cassette=False)
     def without_cassette_injected():
         pass
 
@@ -201,7 +199,7 @@ def test_inject_cassette():
 
 
 def test_with_current_defaults():
-    vcr = VCR(inject_cassette=True, record_mode="once")
+    vcr = VCR(inject_cassette=True, record_mode=mode.ONCE)
 
     @vcr.use_cassette("test", with_current_defaults=False)
     def changing_defaults(cassette, checks):
@@ -212,10 +210,10 @@ def test_with_current_defaults():
         checks(cassette)
 
     def assert_record_mode_once(cassette):
-        assert cassette.record_mode == "once"
+        assert cassette.record_mode == mode.ONCE
 
     def assert_record_mode_all(cassette):
-        assert cassette.record_mode == "all"
+        assert cassette.record_mode == mode.ALL
 
     changing_defaults(assert_record_mode_once)
     current_defaults(assert_record_mode_once)
@@ -226,7 +224,7 @@ def test_with_current_defaults():
 
 
 def test_cassette_library_dir_with_decoration_and_no_explicit_path():
-    library_dir = "/libary_dir"
+    library_dir = "/library_dir"
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir)
 
     @vcr.use_cassette()
@@ -237,7 +235,7 @@ def test_cassette_library_dir_with_decoration_and_no_explicit_path():
 
 
 def test_cassette_library_dir_with_decoration_and_explicit_path():
-    library_dir = "/libary_dir"
+    library_dir = "/library_dir"
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir)
 
     @vcr.use_cassette(path="custom_name")
@@ -248,7 +246,7 @@ def test_cassette_library_dir_with_decoration_and_explicit_path():
 
 
 def test_cassette_library_dir_with_decoration_and_super_explicit_path():
-    library_dir = "/libary_dir"
+    library_dir = "/library_dir"
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir)
 
     @vcr.use_cassette(path=os.path.join(library_dir, "custom_name"))
@@ -259,7 +257,7 @@ def test_cassette_library_dir_with_decoration_and_super_explicit_path():
 
 
 def test_cassette_library_dir_with_path_transformer():
-    library_dir = "/libary_dir"
+    library_dir = "/library_dir"
     vcr = VCR(
         inject_cassette=True, cassette_library_dir=library_dir, path_transformer=lambda path: path + ".json"
     )
@@ -360,3 +358,11 @@ def test_dynamically_added(self):
 
 TestVCRClass.test_dynamically_added = test_dynamically_added
 del test_dynamically_added
+
+
+def test_path_class_as_cassette():
+    path = Path(__file__).parent.parent.joinpath(
+        "integration/cassettes/test_httpx_test_test_behind_proxy.yml"
+    )
+    with use_cassette(path):
+        pass

tests/unit/test_vcr_import.py

@@ -2,7 +2,6 @@ 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"]

tox.ini

@@ -1,13 +1,23 @@
 [tox]
 skip_missing_interpreters=true
-envlist = 
+envlist =
   cov-clean,
   lint,
-  {py35,py36,py37,py38}-{requests,httplib2,urllib3,tornado4,boto3,aiohttp},
+  {py37,py38,py39,py310,py311}-{requests,httplib2,urllib3,tornado4,boto3,aiohttp,httpx},
   {pypy3}-{requests,httplib2,urllib3,tornado4,boto3},
+  {py310}-httpx019,
   cov-report
 
 
+[gh-actions]
+python =
+    3.7: py37
+    3.8: py38
+    3.9: py39
+    3.10: py310, lint
+    3.11: py311
+    pypy-3: pypy3
+
 # Coverage environment tasks: cov-clean and cov-report
 # https://pytest-cov.readthedocs.io/en/latest/tox.html
 [testenv:cov-clean]
@@ -18,7 +28,7 @@ commands = coverage erase
 [testenv:cov-report]
 deps = coverage
 skip_install=true
-commands = 
+commands =
   coverage html
   coverage report --fail-under=90
 
@@ -27,12 +37,16 @@ skipsdist = True
 commands =
     black --version
     black --check --diff .
+    isort --version
+    isort . --check --diff
     flake8 --version
-    flake8 --exclude=./docs/conf.py,./.tox/
+    flake8 --exclude=./docs/conf.py,./.tox/,./venv/
     pyflakes ./docs/conf.py
-deps = 
+deps =
-  flake8 
+  flake8
   black
+  isort
+basepython = python3.10
 
 [testenv:docs]
 # Running sphinx from inside the "docs" directory
@@ -61,28 +75,34 @@ basepython = python3.7
 usedevelop=true
 commands =
     ./runtests.sh --cov=./vcr --cov-branch --cov-report=xml --cov-append {posargs}
+allowlist_externals =
+    ./runtests.sh
 deps =
-    Flask
+    Werkzeug==2.0.3
-    mock
     pytest
-    pytest-httpbin
+    pytest-httpbin>=1.0.1
     pytest-cov
     PyYAML
     ipaddress
     requests: requests>=2.22.0
+    requests: urllib3<2
     httplib2: httplib2
-    urllib3: urllib3
+    urllib3: urllib3<2
-    {py35,py36}-tornado4: tornado>=4,<5
-    {py35,py36}-tornado4: pytest-tornado
-    {py35,py36}-tornado4: pycurl
     boto3: boto3
     boto3: urllib3
     aiohttp: aiohttp
     aiohttp: pytest-asyncio
     aiohttp: pytest-aiohttp
-depends = 
+    httpx: httpx
-  lint,{py35,py36,py37,py38,pypy3}-{requests,httplib2,urllib3,tornado4,boto3},{py35,py36,py37,py38}-{aiohttp}: cov-clean
+    {py37,py38,py39,py310}-{httpx}: httpx
-  cov-report: lint,{py35,py36,py37,py38,pypy3}-{requests,httplib2,urllib3,tornado4,boto3},{py35,py36,py37,py38}-{aiohttp}
+    {py37,py38,py39,py310}-{httpx}: pytest-asyncio
+    httpx: httpx>0.19
+    # httpx==0.19 is the latest version that supports allow_redirects, newer versions use follow_redirects
+    httpx019: httpx==0.19
+    {py37,py38,py39,py310}-{httpx}: pytest-asyncio
+depends =
+  lint,{py37,py38,py39,py310,py311,pypy3}-{requests,httplib2,urllib3,tornado4,boto3},{py37,py38,py39,py310,py311}-{aiohttp},{py37,py38,py39,py310,py311}-{httpx}: cov-clean
+  cov-report: lint,{py37,py38,py39,py310,py311,pypy3}-{requests,httplib2,urllib3,tornado4,boto3},{py37,py38,py39,py310,py311}-{aiohttp}
 passenv =
     AWS_ACCESS_KEY_ID
     AWS_DEFAULT_REGION

vcr/__init__.py

@@ -1,8 +1,10 @@
 import logging
-from .config import VCR
 from logging import NullHandler
 
-__version__ = "4.0.1"
+from .config import VCR
+from .record_mode import RecordMode as mode  # noqa import is not used in this file
+
+__version__ = "4.3.0"
 
 logging.getLogger(__name__).addHandler(NullHandler())
 

vcr/cassette.py

@@ -1,19 +1,20 @@
 import collections
 import contextlib
 import copy
-import sys
 import inspect
 import logging
+import sys
 
 import wrapt
 
-from .errors import UnhandledHTTPRequestError
-from .matchers import requests_match, uri, method, get_matchers_results
-from .patch import CassettePatcherBuilder
-from .serializers import yamlserializer
-from .persisters.filesystem import FilesystemPersister
-from .util import partition_dict
 from ._handle_coroutine import handle_coroutine
+from .errors import UnhandledHTTPRequestError
+from .matchers import get_matchers_results, method, requests_match, uri
+from .patch import CassettePatcherBuilder
+from .persisters.filesystem import FilesystemPersister
+from .record_mode import RecordMode
+from .serializers import yamlserializer
+from .util import partition_dict
 
 try:
     from asyncio import iscoroutinefunction
@@ -44,7 +45,11 @@ class CassetteContextDecorator:
     this class as a context manager in ``__exit__``.
     """
 
-    _non_cassette_arguments = ("path_transformer", "func_path_generator")
+    _non_cassette_arguments = (
+        "path_transformer",
+        "func_path_generator",
+        "record_on_exception",
+    )
 
     @classmethod
     def from_args(cls, cassette_class, **kwargs):
@@ -54,6 +59,7 @@ class CassetteContextDecorator:
         self.cls = cls
         self._args_getter = args_getter
         self.__finish = None
+        self.__cassette = None
 
     def _patch_generator(self, cassette):
         with contextlib.ExitStack() as exit_stack:
@@ -63,9 +69,6 @@ class CassetteContextDecorator:
             log.debug(log_format.format(action="Entering", path=cassette._path))
             yield cassette
             log.debug(log_format.format(action="Exiting", path=cassette._path))
-            # TODO(@IvanMalison): Hmmm. it kind of feels like this should be
-            # somewhere else.
-            cassette._save()
 
     def __enter__(self):
         # This assertion is here to prevent the dangerous behavior
@@ -83,10 +86,22 @@ class CassetteContextDecorator:
         if other_kwargs.get("path_transformer"):
             transformer = other_kwargs["path_transformer"]
             cassette_kwargs["path"] = transformer(cassette_kwargs["path"])
-        self.__finish = self._patch_generator(self.cls.load(**cassette_kwargs))
+        self.__cassette = self.cls.load(**cassette_kwargs)
+        self.__finish = self._patch_generator(self.__cassette)
         return next(self.__finish)
 
-    def __exit__(self, *args):
+    def __exit__(self, *exc_info):
+        exception_was_raised = any(exc_info)
+        record_on_exception = self._args_getter().get("record_on_exception", True)
+        if record_on_exception or not exception_was_raised:
+            self.__cassette._save()
+            self.__cassette = None
+        # Fellow programmer, don't remove this `next`, if `self.__finish` is
+        # not consumed the unpatcher functions accumulated in the `exit_stack`
+        # object created in `_patch_generator` will not be called until
+        # `exit_stack` is not garbage collected.
+        # This works in CPython but not in Pypy, where the unpatchers will not
+        # be called until much later.
         next(self.__finish, None)
         self.__finish = None
 
@@ -175,12 +190,13 @@ class Cassette:
         path,
         serializer=None,
         persister=None,
-        record_mode="once",
+        record_mode=RecordMode.ONCE,
         match_on=(uri, method),
         before_record_request=None,
         before_record_response=None,
         custom_patches=(),
         inject=False,
+        allow_playback_repeats=False,
     ):
         self._persister = persister or FilesystemPersister
         self._path = path
@@ -192,6 +208,7 @@ class Cassette:
         self.inject = inject
         self.record_mode = record_mode
         self.custom_patches = custom_patches
+        self.allow_playback_repeats = allow_playback_repeats
 
         # self.data is the list of (req, resp) tuples
         self.data = []
@@ -206,7 +223,7 @@ class Cassette:
     @property
     def all_played(self):
         """Returns True if all responses have been played, False otherwise."""
-        return self.play_count == len(self)
+        return len(self.play_counts.values()) == len(self)
 
     @property
     def requests(self):
@@ -218,7 +235,7 @@ class Cassette:
 
     @property
     def write_protected(self):
-        return self.rewound and self.record_mode == "once" or self.record_mode == "none"
+        return self.rewound and self.record_mode == RecordMode.ONCE or self.record_mode == RecordMode.NONE
 
     def append(self, request, response):
         """Add a request, response pair to this cassette"""
@@ -250,7 +267,7 @@ class Cassette:
 
     def can_play_response_for(self, request):
         request = self._before_record_request(request)
-        return request and request in self and self.record_mode != "all" and self.rewound
+        return request and request in self and self.record_mode != RecordMode.ALL and self.rewound
 
     def play_response(self, request):
         """
@@ -258,7 +275,7 @@ class Cassette:
         hasn't been played back before, and mark it as played
         """
         for index, response in self._responses(request):
-            if self.play_counts[index] == 0:
+            if self.play_counts[index] == 0 or self.allow_playback_repeats:
                 self.play_counts[index] += 1
                 return response
         # The cassette doesn't contain the request asked for.
@@ -348,6 +365,6 @@ class Cassette:
     def __contains__(self, request):
         """Return whether or not a request has been stored"""
         for index, response in self._responses(request):
-            if self.play_counts[index] == 0:
+            if self.play_counts[index] == 0 or self.allow_playback_repeats:
                 return True
         return False

vcr/config.py

@@ -1,19 +1,19 @@
 import copy
-
-from collections import abc as collections_abc
 import functools
 import inspect
 import os
 import types
+from collections import abc as collections_abc
+from pathlib import Path
 
 import six
 
+from . import filters, matchers
 from .cassette import Cassette
-from .serializers import yamlserializer, jsonserializer
 from .persisters.filesystem import FilesystemPersister
-from .util import compose, auto_decorate
+from .record_mode import RecordMode
-from . import matchers
+from .serializers import jsonserializer, yamlserializer
-from . import filters
+from .util import auto_decorate, compose
 
 
 class VCR:
@@ -37,7 +37,7 @@ class VCR:
         custom_patches=(),
         filter_query_parameters=(),
         ignore_hosts=(),
-        record_mode="once",
+        record_mode=RecordMode.ONCE,
         ignore_localhost=False,
         filter_headers=(),
         before_record_response=None,
@@ -49,6 +49,7 @@ class VCR:
         cassette_library_dir=None,
         func_path_generator=None,
         decode_compressed_response=False,
+        record_on_exception=True,
     ):
         self.serializer = serializer
         self.match_on = match_on
@@ -80,6 +81,7 @@ class VCR:
         self.path_transformer = path_transformer
         self.func_path_generator = func_path_generator
         self.decode_compressed_response = decode_compressed_response
+        self.record_on_exception = record_on_exception
         self._custom_patches = tuple(custom_patches)
 
     def _get_serializer(self, serializer_name):
@@ -99,7 +101,7 @@ class VCR:
         return matchers
 
     def use_cassette(self, path=None, **kwargs):
-        if path is not None and not isinstance(path, str):
+        if path is not None and not isinstance(path, (str, Path)):
             function = path
             # Assume this is an attempt to decorate a function
             return self._use_cassette(**kwargs)(function)
@@ -123,6 +125,7 @@ class VCR:
         func_path_generator = kwargs.get("func_path_generator", self.func_path_generator)
         cassette_library_dir = kwargs.get("cassette_library_dir", self.cassette_library_dir)
         additional_matchers = kwargs.get("additional_matchers", ())
+        record_on_exception = kwargs.get("record_on_exception", self.record_on_exception)
 
         if cassette_library_dir:
 
@@ -148,6 +151,8 @@ class VCR:
             "inject": kwargs.get("inject_cassette", self.inject_cassette),
             "path_transformer": path_transformer,
             "func_path_generator": func_path_generator,
+            "allow_playback_repeats": kwargs.get("allow_playback_repeats", False),
+            "record_on_exception": record_on_exception,
         }
         path = kwargs.get("path")
         if path:

vcr/filters.py

@@ -1,8 +1,8 @@
-from io import BytesIO
-from urllib.parse import urlparse, urlencode, urlunparse
 import copy
 import json
 import zlib
+from io import BytesIO
+from urllib.parse import urlencode, urlparse, urlunparse
 
 from .util import CaseInsensitiveDict
 
@@ -84,7 +84,17 @@ def replace_post_data_parameters(request, replacements):
 
     replacements = dict(replacements)
     if request.method == "POST" and not isinstance(request.body, BytesIO):
-        if request.headers.get("Content-Type") == "application/json":
+        if isinstance(request.body, dict):
+            new_body = request.body.copy()
+            for k, rv in replacements.items():
+                if k in new_body:
+                    ov = new_body.pop(k)
+                    if callable(rv):
+                        rv = rv(key=k, value=ov, request=request)
+                    if rv is not None:
+                        new_body[k] = rv
+            request.body = new_body
+        elif request.headers.get("Content-Type") == "application/json":
             json_data = json.loads(request.body.decode("utf-8"))
             for k, rv in replacements.items():
                 if k in json_data:
@@ -140,6 +150,8 @@ def decode_response(response):
         """Returns decompressed body according to encoding using zlib.
         to (de-)compress gzip format, use wbits = zlib.MAX_WBITS | 16
         """
+        if not body:
+            return ""
         if encoding == "gzip":
             return zlib.decompress(body, zlib.MAX_WBITS | 16)
         else:  # encoding == 'deflate'

vcr/matchers.py

@@ -1,9 +1,9 @@
 import json
+import logging
 import urllib
 import xmlrpc.client
-from .util import read_body
-import logging
 
+from .util import read_body
 
 log = logging.getLogger(__name__)
 

vcr/migration.py

@@ -17,11 +17,12 @@ import os
 import shutil
 import sys
 import tempfile
+
 import yaml
 
-from .serializers import yamlserializer, jsonserializer
-from .serialize import serialize
 from . import request
+from .serialize import serialize
+from .serializers import jsonserializer, yamlserializer
 from .stubs.compat import get_httpmessage
 
 # Use the libYAML versions if possible

vcr/patch.py

@@ -1,13 +1,12 @@
 """Utilities for patching in cassettes"""
 import contextlib
 import functools
+import http.client as httplib
 import itertools
-import mock
+import logging
+from unittest import mock
 
 from .stubs import VCRHTTPConnection, VCRHTTPSConnection
-import http.client as httplib
-
-import logging
 
 log = logging.getLogger(__name__)
 # Save some of the original types for the purposes of unpatching
@@ -16,16 +15,17 @@ _HTTPSConnection = httplib.HTTPSConnection
 
 # Try to save the original types for boto3
 try:
-    from botocore.awsrequest import AWSHTTPSConnection, AWSHTTPConnection
+    from botocore.awsrequest import AWSHTTPConnection, AWSHTTPSConnection
-except ImportError:
+except ImportError as e:
     try:
-        import botocore.vendored.requests.packages.urllib3.connectionpool as cpool
+        import botocore.vendored.requests  # noqa: F401
     except ImportError:  # pragma: no cover
         pass
     else:
-        _Boto3VerifiedHTTPSConnection = cpool.VerifiedHTTPSConnection
+        raise RuntimeError(
-        _cpoolBoto3HTTPConnection = cpool.HTTPConnection
+            "vcrpy >=4.2.2 and botocore <1.11.0 are not compatible"
-        _cpoolBoto3HTTPSConnection = cpool.HTTPSConnection
+            "; please upgrade botocore (or downgrade vcrpy)"
+        ) from e
 else:
     _Boto3VerifiedHTTPSConnection = AWSHTTPSConnection
     _cpoolBoto3HTTPConnection = AWSHTTPConnection
@@ -44,14 +44,16 @@ else:
 
 # Try to save the original types for requests
 try:
-    if not cpool:
+    import requests
-        import requests.packages.urllib3.connectionpool as cpool
 except ImportError:  # pragma: no cover
     pass
 else:
-    _VerifiedHTTPSConnection = cpool.VerifiedHTTPSConnection
+    if requests.__build__ < 0x021602:
-    _cpoolHTTPConnection = cpool.HTTPConnection
+        raise RuntimeError(
-    _cpoolHTTPSConnection = cpool.HTTPSConnection
+            "vcrpy >=4.2.2 and requests <2.16.2 are not compatible"
+            "; please upgrade requests (or downgrade vcrpy)"
+        )
+
 
 # Try to save the original types for httplib2
 try:
@@ -94,6 +96,15 @@ else:
     _AiohttpClientSessionRequest = aiohttp.client.ClientSession._request
 
 
+try:
+    import httpx
+except ImportError:  # pragma: no cover
+    pass
+else:
+    _HttpxSyncClient_send = httpx.Client.send
+    _HttpxAsyncClient_send = httpx.AsyncClient.send
+
+
 class CassettePatcherBuilder:
     def _build_patchers_from_mock_triples_decorator(function):
         @functools.wraps(function)
@@ -116,6 +127,7 @@ class CassettePatcherBuilder:
             self._boto(),
             self._tornado(),
             self._aiohttp(),
+            self._httpx(),
             self._build_patchers_from_mock_triples(self._cassette.custom_patches),
         )
 
@@ -190,20 +202,11 @@ class CassettePatcherBuilder:
 
     @_build_patchers_from_mock_triples_decorator
     def _boto3(self):
-
         try:
             # botocore using awsrequest
             import botocore.awsrequest as cpool
         except ImportError:  # pragma: no cover
-            try:
+            pass
-                # 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
 
@@ -259,8 +262,7 @@ class CassettePatcherBuilder:
         except ImportError:  # pragma: no cover
             pass
         else:
-            from .stubs.httplib2_stubs import VCRHTTPConnectionWithTimeout
+            from .stubs.httplib2_stubs import VCRHTTPConnectionWithTimeout, VCRHTTPSConnectionWithTimeout
-            from .stubs.httplib2_stubs import VCRHTTPSConnectionWithTimeout
 
             yield cpool, "HTTPConnectionWithTimeout", VCRHTTPConnectionWithTimeout
             yield cpool, "HTTPSConnectionWithTimeout", VCRHTTPSConnectionWithTimeout
@@ -313,6 +315,21 @@ class CassettePatcherBuilder:
             new_request = vcr_request(self._cassette, _AiohttpClientSessionRequest)
             yield client.ClientSession, "_request", new_request
 
+    @_build_patchers_from_mock_triples_decorator
+    def _httpx(self):
+        try:
+            import httpx
+        except ImportError:  # pragma: no cover
+            return
+        else:
+            from .stubs.httpx_stubs import async_vcr_send, sync_vcr_send
+
+            new_async_client_send = async_vcr_send(self._cassette, _HttpxAsyncClient_send)
+            yield httpx.AsyncClient, "send", new_async_client_send
+
+            new_sync_client_send = sync_vcr_send(self._cassette, _HttpxSyncClient_send)
+            yield httpx.Client, "send", new_sync_client_send
+
     def _urllib3_patchers(self, cpool, stubs):
         http_connection_remover = ConnectionRemover(
             self._get_cassette_subclass(stubs.VCRRequestsHTTPConnection)
@@ -392,36 +409,6 @@ def reset_patchers():
     yield mock.patch.object(httplib, "HTTPConnection", _HTTPConnection)
     yield mock.patch.object(httplib, "HTTPSConnection", _HTTPSConnection)
 
-    try:
-        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:
-        # unpatch requests v1.x
-        yield mock.patch.object(cpool, "VerifiedHTTPSConnection", _VerifiedHTTPSConnection)
-        yield mock.patch.object(cpool, "HTTPConnection", _cpoolHTTPConnection)
-        # unpatch requests v2.x
-        if hasattr(cpool.HTTPConnectionPool, "ConnectionCls"):
-            yield mock.patch.object(cpool.HTTPConnectionPool, "ConnectionCls", _cpoolHTTPConnection)
-            yield mock.patch.object(cpool.HTTPSConnectionPool, "ConnectionCls", _cpoolHTTPSConnection)
-
-        if hasattr(cpool, "HTTPSConnection"):
-            yield mock.patch.object(cpool, "HTTPSConnection", _cpoolHTTPSConnection)
-
     try:
         import urllib3.connectionpool as cpool
     except ImportError:  # pragma: no cover
@@ -438,24 +425,7 @@ def reset_patchers():
         # unpatch botocore with awsrequest
         import botocore.awsrequest as cpool
     except ImportError:  # pragma: no cover
-        try:
+        pass
-            # 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)

vcr/persisters/filesystem.py

@@ -1,25 +1,32 @@
 # .. _persister_example:
 
-import os
+from pathlib import Path
-from ..serialize import serialize, deserialize
+
+from ..serialize import deserialize, serialize
 
 
 class FilesystemPersister:
     @classmethod
     def load_cassette(cls, cassette_path, serializer):
-        try:
+        cassette_path = Path(cassette_path)  # if cassette path is already Path this is no operation
-            with open(cassette_path) as f:
+        if not cassette_path.is_file():
-                cassette_content = f.read()
-        except OSError:
             raise ValueError("Cassette not found.")
-        cassette = deserialize(cassette_content, serializer)
+        try:
-        return cassette
+            with cassette_path.open() as f:
+                data = f.read()
+        except UnicodeEncodeError as err:
+            raise ValueError("Can't read Cassette, Encoding is broken") from err
+
+        return deserialize(data, serializer)
 
     @staticmethod
     def save_cassette(cassette_path, cassette_dict, serializer):
         data = serialize(cassette_dict, serializer)
-        dirname, filename = os.path.split(cassette_path)
+        cassette_path = Path(cassette_path)  # if cassette path is already Path this is no operation
-        if dirname and not os.path.exists(dirname):
+
-            os.makedirs(dirname)
+        cassette_folder = cassette_path.parent
-        with open(cassette_path, "w") as f:
+        if not cassette_folder.exists():
+            cassette_folder.mkdir(parents=True)
+
+        with cassette_path.open("w") as f:
             f.write(data)

vcr/record_mode.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class RecordMode(str, Enum):
+    """
+    Configures when VCR will record to the cassette.
+
+    Can be declared by either using the enumerated value (`vcr.mode.ONCE`)
+    or by simply using the defined string (`once`).
+
+    `ALL`: Every request is recorded.
+    `ANY`: ?
+    `NEW_EPISODES`: Any request not found in the cassette is recorded.
+    `NONE`: No requests are recorded.
+    `ONCE`:  First set of requests is recorded, all others are replayed.
+    Attempting to add a new episode fails.
+    """
+
+    ALL = "all"
+    ANY = "any"
+    NEW_EPISODES = "new_episodes"
+    NONE = "none"
+    ONCE = "once"

vcr/request.py

@@ -1,8 +1,9 @@
+import logging
 import warnings
 from io import BytesIO
-from urllib.parse import urlparse, parse_qsl
+from urllib.parse import parse_qsl, urlparse
+
 from .util import CaseInsensitiveDict
-import logging
 
 log = logging.getLogger(__name__)
 

vcr/serialize.py

@@ -1,7 +1,8 @@
-from vcr.serializers import compat
-from vcr.request import Request
 import yaml
 
+from vcr.request import Request
+from vcr.serializers import compat
+
 # version 1 cassettes started with VCR 1.0.x.
 # Before 1.0.x, there was no versioning.
 CASSETTE_FORMAT_VERSION = 1

vcr/serializers/jsonserializer.py

@@ -16,7 +16,7 @@ def serialize(cassette_dict):
     )
 
     try:
-        return json.dumps(cassette_dict, indent=4)
+        return json.dumps(cassette_dict, indent=4) + "\n"
     except UnicodeDecodeError as original:  # py2
         raise UnicodeDecodeError(
             original.encoding,

vcr/serializers/yamlserializer.py

@@ -2,9 +2,10 @@ import yaml
 
 # Use the libYAML versions if possible
 try:
-    from yaml import CLoader as Loader, CDumper as Dumper
+    from yaml import CDumper as Dumper
+    from yaml import CLoader as Loader
 except ImportError:
-    from yaml import Loader, Dumper
+    from yaml import Dumper, Loader
 
 
 def deserialize(cassette_string):

vcr/stubs/__init__.py

@@ -1,14 +1,12 @@
 """Stubs for patching HTTP and HTTPS requests"""
 
 import logging
-from http.client import (
+from http.client import HTTPConnection, HTTPResponse, HTTPSConnection
-    HTTPConnection,
-    HTTPSConnection,
-    HTTPResponse,
-)
 from io import BytesIO
-from vcr.request import Request
+
 from vcr.errors import CannotOverwriteExistingCassetteException
+from vcr.request import Request
+
 from . import compat
 
 log = logging.getLogger(__name__)
@@ -87,7 +85,7 @@ class VCRHTTPResponse(HTTPResponse):
     def closed(self):
         # in python3, I can't change the value of self.closed.  So I'
         # twiddling self._closed and using this property to shadow the real
-        # self.closed from the superclas
+        # self.closed from the superclass
         return self._closed
 
     def read(self, *args, **kwargs):
@@ -314,7 +312,7 @@ class VCRConnection:
     def __setattr__(self, name, value):
         """
         We need to define this because any attributes that are set on the
-        VCRConnection need to be propogated to the real connection.
+        VCRConnection need to be propagated to the real connection.
 
         For example, urllib3 will set certain attributes on the connection,
         such as 'ssl_version'. These attributes need to get set on the real

vcr/stubs/aiohttp_stubs.py

@@ -1,13 +1,17 @@
 """Stubs for aiohttp HTTP clients"""
 import asyncio
 import functools
-import logging
 import json
+import logging
+from http.cookies import CookieError, Morsel, SimpleCookie
+from typing import Mapping, Union
 
-from aiohttp import ClientConnectionError, ClientResponse, RequestInfo, streams
+from aiohttp import ClientConnectionError, ClientResponse, CookieJar, RequestInfo, hdrs, streams
-from multidict import CIMultiDict, CIMultiDictProxy
+from aiohttp.helpers import strip_auth_from_url
+from multidict import CIMultiDict, CIMultiDictProxy, MultiDict
 from yarl import URL
 
+from vcr.errors import CannotOverwriteExistingCassetteException
 from vcr.request import Request
 
 log = logging.getLogger(__name__)
@@ -59,15 +63,27 @@ def build_response(vcr_request, vcr_response, history):
     request_info = RequestInfo(
         url=URL(vcr_request.url),
         method=vcr_request.method,
-        headers=CIMultiDictProxy(CIMultiDict(vcr_request.headers)),
+        headers=_deserialize_headers(vcr_request.headers),
         real_url=URL(vcr_request.url),
     )
     response = MockClientResponse(vcr_request.method, URL(vcr_response.get("url")), request_info=request_info)
     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._headers = _deserialize_headers(vcr_response["headers"])
     response._history = tuple(history)
+    # cookies
+    for hdr in response.headers.getall(hdrs.SET_COOKIE, ()):
+        try:
+            cookies = SimpleCookie(hdr)
+            for cookie_name, cookie in cookies.items():
+                expires = cookie.get("expires", "").strip()
+                if expires:
+                    log.debug('Ignoring expiration date: %s="%s"', cookie_name, expires)
+                cookie["expires"] = ""
+                response.cookies.load(cookie.output(header="").strip())
+        except CookieError as exc:
+            log.warning("Can not load response cookies: %s", exc)
 
     response.close()
     return response
@@ -75,31 +91,54 @@ def build_response(vcr_request, vcr_response, history):
 
 def _serialize_headers(headers):
     """Serialize CIMultiDictProxy to a pickle-able dict because proxy
-        objects forbid pickling:
+    objects forbid pickling:
 
-        https://github.com/aio-libs/multidict/issues/340
+    https://github.com/aio-libs/multidict/issues/340
     """
     # Mark strings as keys so 'istr' types don't show up in
     # the cassettes as comments.
-    return {str(k): v for k, v in headers.items()}
+    serialized_headers = {}
+    for k, v in headers.items():
+        serialized_headers.setdefault(str(k), []).append(v)
+
+    return serialized_headers
 
 
-def play_responses(cassette, vcr_request):
+def _deserialize_headers(headers):
+    deserialized_headers = CIMultiDict()
+    for k, vs in headers.items():
+        if isinstance(vs, list):
+            for v in vs:
+                deserialized_headers.add(k, v)
+        else:
+            deserialized_headers.add(k, vs)
+
+    return CIMultiDictProxy(deserialized_headers)
+
+
+def play_responses(cassette, vcr_request, kwargs):
     history = []
+    allow_redirects = kwargs.get("allow_redirects", True)
     vcr_response = cassette.play_response(vcr_request)
     response = build_response(vcr_request, vcr_response, history)
 
     # If we're following redirects, continue playing until we reach
     # our final destination.
-    while 300 <= response.status <= 399:
+    while allow_redirects and 300 <= response.status <= 399:
-        next_url = URL(response.url).with_path(response.headers["location"])
+        if "location" not in response.headers:
+            break
+
+        next_url = URL(response.url).join(URL(response.headers["location"]))
 
         # Make a stub VCR request that we can then use to look up the recorded
         # VCR request saved to the cassette. This feels a little hacky and
         # may have edge cases based on the headers we're providing (e.g. if
         # there's a matcher that is used to filter by headers).
         vcr_request = Request("GET", str(next_url), None, _serialize_headers(response.request_info.headers))
-        vcr_request = cassette.find_requests_with_most_matches(vcr_request)[0][0]
+        vcr_requests = cassette.find_requests_with_most_matches(vcr_request)
+        for vcr_request, *_ in vcr_requests:
+            if cassette.can_play_response_for(vcr_request):
+                break
 
         # Tack on the response we saw from the redirect into the history
         # list that is added on to the final response.
@@ -132,19 +171,19 @@ async def record_response(cassette, vcr_request, response):
 
 async def record_responses(cassette, vcr_request, response):
     """Because aiohttp follows redirects by default, we must support
-        them by default. This method is used to write individual
+    them by default. This method is used to write individual
-        request-response chains that were implicitly followed to get
+    request-response chains that were implicitly followed to get
-        to the final destination.
+    to the final destination.
     """
 
-    for past_response in response.history:
+    for i, past_response in enumerate(response.history):
         aiohttp_request = past_response.request_info
 
-        # No data because it's following a redirect.
         past_request = Request(
             aiohttp_request.method,
             str(aiohttp_request.url),
-            None,
+            # Record body of first request, rest are following a redirect.
+            None if i else vcr_request.body,
             _serialize_headers(aiohttp_request.headers),
         )
         await record_response(cassette, past_request, past_response)
@@ -163,6 +202,43 @@ async def record_responses(cassette, vcr_request, response):
     await record_response(cassette, vcr_request, response)
 
 
+def _build_cookie_header(session, cookies, cookie_header, url):
+    url, _ = strip_auth_from_url(url)
+    all_cookies = session._cookie_jar.filter_cookies(url)
+    if cookies is not None:
+        tmp_cookie_jar = CookieJar()
+        tmp_cookie_jar.update_cookies(cookies)
+        req_cookies = tmp_cookie_jar.filter_cookies(url)
+        if req_cookies:
+            all_cookies.load(req_cookies)
+
+    if not all_cookies and not cookie_header:
+        return None
+
+    c = SimpleCookie()
+    if cookie_header:
+        c.load(cookie_header)
+    for name, value in all_cookies.items():
+        if isinstance(value, Morsel):
+            mrsl_val = value.get(value.key, Morsel())
+            mrsl_val.set(value.key, value.value, value.coded_value)
+            c[name] = mrsl_val
+        else:
+            c[name] = value
+
+    return c.output(header="", sep=";").strip()
+
+
+def _build_url_with_params(url_str: str, params: Mapping[str, Union[str, int, float]]) -> URL:
+    # This code is basically a copy&paste of aiohttp.
+    # https://github.com/aio-libs/aiohttp/blob/master/aiohttp/client_reqrep.py#L225
+    url = URL(url_str)
+    q = MultiDict(url.query)
+    url2 = url.with_query(params)
+    q.extend(url2.query)
+    return url.with_query(q)
+
+
 def vcr_request(cassette, real_request):
     @functools.wraps(real_request)
     async def new_request(self, method, url, **kwargs):
@@ -171,32 +247,29 @@ def vcr_request(cassette, real_request):
         headers = self._prepare_headers(headers)
         data = kwargs.get("data", kwargs.get("json"))
         params = kwargs.get("params")
+        cookies = kwargs.get("cookies")
 
         if auth is not None:
             headers["AUTHORIZATION"] = auth.encode()
 
-        request_url = URL(url)
+        request_url = URL(url) if not params else _build_url_with_params(url, params)
-        if params:
+        c_header = headers.pop(hdrs.COOKIE, None)
-            for k, v in params.items():
+        cookie_header = _build_cookie_header(self, cookies, c_header, request_url)
-                params[k] = str(v)
+        if cookie_header:
-            request_url = URL(url).with_query(params)
+            headers[hdrs.COOKIE] = cookie_header
 
-        vcr_request = Request(method, str(request_url), data, headers)
+        vcr_request = Request(method, str(request_url), data, _serialize_headers(headers))
 
         if cassette.can_play_response_for(vcr_request):
-            return play_responses(cassette, vcr_request)
+            log.info("Playing response for {} from cassette".format(vcr_request))
+            response = play_responses(cassette, vcr_request, kwargs)
+            for redirect in response.history:
+                self._cookie_jar.update_cookies(redirect.cookies, redirect.url)
+            self._cookie_jar.update_cookies(response.cookies, response.url)
+            return response
 
         if cassette.write_protected and cassette.filter_request(vcr_request):
-            response = MockClientResponse(method, URL(url))
+            raise CannotOverwriteExistingCassetteException(cassette=cassette, failed_request=vcr_request)
-            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)
 

vcr/stubs/boto3_stubs.py

@@ -1,17 +1,6 @@
 """Stubs for boto3"""
-try:
+from botocore.awsrequest import AWSHTTPConnection as HTTPConnection
-    # boto using awsrequest
+from botocore.awsrequest import AWSHTTPSConnection as VerifiedHTTPSConnection
-    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
 

vcr/stubs/boto_stubs.py

@@ -1,6 +1,7 @@
 """Stubs for boto"""
 
 from boto.https_connection import CertValidatingHTTPSConnection
+
 from ..stubs import VCRHTTPSConnection
 
 

vcr/stubs/compat.py

@@ -1,6 +1,5 @@
-from io import BytesIO
 import http.client
-
+from io import BytesIO
 
 """
 The python3 http.client api moved some stuff around, so this is an abstraction
@@ -13,7 +12,7 @@ def get_header(message, name):
 
 
 def get_header_items(message):
-    for (key, values) in get_headers(message):
+    for key, values in get_headers(message):
         for value in values:
             yield key, value
 

vcr/stubs/httplib2_stubs.py

@@ -1,6 +1,7 @@
 """Stubs for httplib2"""
 
 from httplib2 import HTTPConnectionWithTimeout, HTTPSConnectionWithTimeout
+
 from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
 
 
@@ -27,7 +28,6 @@ class VCRHTTPSConnectionWithTimeout(VCRHTTPSConnection, HTTPSConnectionWithTimeo
     _baseclass = HTTPSConnectionWithTimeout
 
     def __init__(self, *args, **kwargs):
-
         # Delete the keyword arguments that HTTPSConnection would not recognize
         safe_keys = {
             "host",

vcr/stubs/httpx_stubs.py

@@ -0,0 +1,171 @@
+import functools
+import inspect
+import logging
+from unittest.mock import MagicMock, patch
+
+import httpx
+
+from vcr.errors import CannotOverwriteExistingCassetteException
+from vcr.request import Request as VcrRequest
+
+_httpx_signature = inspect.signature(httpx.Client.request)
+
+try:
+    HTTPX_REDIRECT_PARAM = _httpx_signature.parameters["follow_redirects"]
+except KeyError:
+    HTTPX_REDIRECT_PARAM = _httpx_signature.parameters["allow_redirects"]
+
+
+_logger = logging.getLogger(__name__)
+
+
+def _transform_headers(httpx_response):
+    """
+    Some headers can appear multiple times, like "Set-Cookie".
+    Therefore transform to every header key to list of values.
+    """
+
+    out = {}
+    for key, var in httpx_response.headers.raw:
+        decoded_key = key.decode("utf-8")
+        out.setdefault(decoded_key, [])
+        out[decoded_key].append(var.decode("utf-8"))
+    return out
+
+
+def _to_serialized_response(httpx_response):
+    return {
+        "status_code": httpx_response.status_code,
+        "http_version": httpx_response.http_version,
+        "headers": _transform_headers(httpx_response),
+        "content": httpx_response.content.decode("utf-8", "ignore"),
+    }
+
+
+def _from_serialized_headers(headers):
+    """
+    httpx accepts headers as list of tuples of header key and value.
+    """
+
+    header_list = []
+    for key, values in headers.items():
+        for v in values:
+            header_list.append((key, v))
+    return header_list
+
+
+@patch("httpx.Response.close", MagicMock())
+@patch("httpx.Response.read", MagicMock())
+def _from_serialized_response(request, serialized_response, history=None):
+    content = serialized_response.get("content").encode()
+    response = httpx.Response(
+        status_code=serialized_response.get("status_code"),
+        request=request,
+        headers=_from_serialized_headers(serialized_response.get("headers")),
+        content=content,
+        history=history or [],
+    )
+    response._content = content
+    return response
+
+
+def _make_vcr_request(httpx_request, **kwargs):
+    body = httpx_request.read().decode("utf-8")
+    uri = str(httpx_request.url)
+    headers = dict(httpx_request.headers)
+    return VcrRequest(httpx_request.method, uri, body, headers)
+
+
+def _shared_vcr_send(cassette, real_send, *args, **kwargs):
+    real_request = args[1]
+
+    vcr_request = _make_vcr_request(real_request, **kwargs)
+
+    if cassette.can_play_response_for(vcr_request):
+        return vcr_request, _play_responses(cassette, real_request, vcr_request, args[0], kwargs)
+
+    if cassette.write_protected and cassette.filter_request(vcr_request):
+        raise CannotOverwriteExistingCassetteException(cassette=cassette, failed_request=vcr_request)
+
+    _logger.info("%s not in cassette, sending to real server", vcr_request)
+    return vcr_request, None
+
+
+def _record_responses(cassette, vcr_request, real_response):
+    for past_real_response in real_response.history:
+        past_vcr_request = _make_vcr_request(past_real_response.request)
+        cassette.append(past_vcr_request, _to_serialized_response(past_real_response))
+
+    if real_response.history:
+        # If there was a redirection keep we want the request which will hold the
+        # final redirect value
+        vcr_request = _make_vcr_request(real_response.request)
+
+    cassette.append(vcr_request, _to_serialized_response(real_response))
+    return real_response
+
+
+def _play_responses(cassette, request, vcr_request, client, kwargs):
+    history = []
+
+    allow_redirects = kwargs.get(
+        HTTPX_REDIRECT_PARAM.name,
+        HTTPX_REDIRECT_PARAM.default,
+    )
+    vcr_response = cassette.play_response(vcr_request)
+    response = _from_serialized_response(request, vcr_response)
+
+    while allow_redirects and 300 <= response.status_code <= 399:
+        next_url = response.headers.get("location")
+        if not next_url:
+            break
+
+        vcr_request = VcrRequest("GET", next_url, None, dict(response.headers))
+        vcr_request = cassette.find_requests_with_most_matches(vcr_request)[0][0]
+
+        history.append(response)
+        # add cookies from response to session cookie store
+        client.cookies.extract_cookies(response)
+
+        vcr_response = cassette.play_response(vcr_request)
+        response = _from_serialized_response(vcr_request, vcr_response, history)
+
+    return response
+
+
+async def _async_vcr_send(cassette, real_send, *args, **kwargs):
+    vcr_request, response = _shared_vcr_send(cassette, real_send, *args, **kwargs)
+    if response:
+        # add cookies from response to session cookie store
+        args[0].cookies.extract_cookies(response)
+        return response
+
+    real_response = await real_send(*args, **kwargs)
+    return _record_responses(cassette, vcr_request, real_response)
+
+
+def async_vcr_send(cassette, real_send):
+    @functools.wraps(real_send)
+    def _inner_send(*args, **kwargs):
+        return _async_vcr_send(cassette, real_send, *args, **kwargs)
+
+    return _inner_send
+
+
+def _sync_vcr_send(cassette, real_send, *args, **kwargs):
+    vcr_request, response = _shared_vcr_send(cassette, real_send, *args, **kwargs)
+    if response:
+        # add cookies from response to session cookie store
+        args[0].cookies.extract_cookies(response)
+        return response
+
+    real_response = real_send(*args, **kwargs)
+    return _record_responses(cassette, vcr_request, real_response)
+
+
+def sync_vcr_send(cassette, real_send):
+    @functools.wraps(real_send)
+    def _inner_send(*args, **kwargs):
+        return _sync_vcr_send(cassette, real_send, *args, **kwargs)
+
+    return _inner_send

vcr/stubs/requests_stubs.py

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

vcr/stubs/urllib3_stubs.py

@@ -1,6 +1,7 @@
 """Stubs for urllib3"""
 
 from urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
+
 from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
 
 # urllib3 defines its own HTTPConnection classes. It includes some polyfills