Relax Werkzeug==2.0.3 into Werkzeug<3

.github/workflows/docs.yml

@@ -11,7 +11,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v4
         with:
           python-version: "3.12"
       

.github/workflows/main.yml

@@ -2,11 +2,7 @@ name: Test
 
 on:
   push:
-    branches:
-      - master
   pull_request:
-  schedule:
-    - cron: '0 16 * * 5'  # Every Friday 4pm
   workflow_dispatch:
 
 jobs:
@@ -15,58 +11,31 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version:
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "pypy-3.8", "pypy-3.9", "pypy-3.10"]
-          - "3.8"
-          - "3.9"
-          - "3.10"
-          - "3.11"
-          - "3.12"
-          - "3.13"
-          - "pypy-3.8"
-          - "pypy-3.9"
-          - "pypy-3.10"
-        urllib3-requirement:
-          - "urllib3>=2"
-          - "urllib3<2"
-
-        exclude:
-          - python-version: "3.8"
-            urllib3-requirement: "urllib3>=2"
-          - python-version: "pypy-3.8"
-            urllib3-requirement: "urllib3>=2"
-          - python-version: "3.9"
-            urllib3-requirement: "urllib3>=2"
-          - python-version: "pypy-3.9"
-            urllib3-requirement: "urllib3>=2"
-          - python-version: "pypy-3.10"
-            urllib3-requirement: "urllib3>=2"
 
     steps:
       - uses: actions/checkout@v4
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
-          cache: pip
-          allow-prereleases: true
 
       - name: Install project dependencies
         run: |
-          pip install --upgrade pip setuptools
+          pip3 install --upgrade pip
-          pip install codecov '.[tests]' '${{ matrix.urllib3-requirement }}'
+          pip3 install codecov tox tox-gh-actions
-          pip check
 
-      - name: Run online tests
+      - name: Run online tests with tox
-        run: ./runtests.sh --cov=./vcr --cov-branch --cov-report=xml --cov-append -m online
+        run: tox -- -m online
 
-      - name: Run offline tests with no access to the Internet
+      - name: Run offline tests with tox with no access to the Internet
         run: |
           # We're using unshare to take Internet access
-          # away so that we'll notice whenever some new test
+          # away from tox so that we'll notice whenever some new test
           # is missing @pytest.mark.online decoration in the future
           unshare --map-root-user --net -- \
-              sh -c 'ip link set lo up; ./runtests.sh --cov=./vcr --cov-branch --cov-report=xml --cov-append -m "not online"'
+              sh -c 'ip link set lo up; tox -- -m "not online"'
 
       - name: Run coverage
         run: codecov

.github/workflows/pre-commit-detect-outdated.yml

@@ -1,62 +0,0 @@
-# Copyright (c) 2023 Sebastian Pipping <sebastian@pipping.org>
-# Licensed under the MIT license
-
-name: Detect outdated pre-commit hooks
-
-on:
-  schedule:
-    - cron: '0 16 * * 5'  # Every Friday 4pm
-
-# NOTE: This will drop all permissions from GITHUB_TOKEN except metadata read,
-#       and then (re)add the ones listed below:
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  pre_commit_detect_outdated:
-    name: Detect outdated pre-commit hooks
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python 3.12
-        uses: actions/setup-python@v5
-        with:
-          python-version: 3.12
-
-      - name: Install pre-commit
-        run: |-
-          pip install \
-            --disable-pip-version-check \
-            --no-warn-script-location \
-            --user \
-            pre-commit
-          echo "PATH=${HOME}/.local/bin:${PATH}" >> "${GITHUB_ENV}"
-
-      - name: Check for outdated hooks
-        run: |-
-          pre-commit autoupdate
-          git diff -- .pre-commit-config.yaml
-
-      - name: Create pull request from changes (if any)
-        id: create-pull-request
-        uses: peter-evans/create-pull-request@v7
-        with:
-          author: 'pre-commit <pre-commit@tools.invalid>'
-          base: master
-          body: |-
-            For your consideration.
-
-            :warning: Please **CLOSE AND RE-OPEN** this pull request so that [further workflow runs get triggered](https://github.com/peter-evans/create-pull-request/blob/main/docs/concepts-guidelines.md#triggering-further-workflow-runs) for this pull request.
-          branch: precommit-autoupdate
-          commit-message: "pre-commit: Autoupdate"
-          delete-branch: true
-          draft: true
-          labels: enhancement
-          title: "pre-commit: Autoupdate"
-
-      - name: Log pull request URL
-        if: "${{ steps.create-pull-request.outputs.pull-request-url }}"
-        run: |
-          echo "Pull request URL is: ${{ steps.create-pull-request.outputs.pull-request-url }}"

.github/workflows/pre-commit.yml

@@ -1,20 +0,0 @@
-# Copyright (c) 2023 Sebastian Pipping <sebastian@pipping.org>
-# Licensed under the MIT license
-
-name: Run pre-commit
-
-on:
-- pull_request
-- push
-- workflow_dispatch
-
-jobs:
-  pre-commit:
-    name: Run pre-commit
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      with:
-        python-version: 3.12
-    - uses: pre-commit/action@v3.0.1

.pre-commit-config.yaml

@@ -1,17 +0,0 @@
-# Copyright (c) 2023 Sebastian Pipping <sebastian@pipping.org>
-# Licensed under the MIT license
-
-repos:
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.6
-    hooks:
-      - id: ruff
-        args: ["--output-format=full"]
-      - id: ruff-format
-
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.6.0
-    hooks:
-      - id: check-merge-conflict
-      - id: end-of-file-fixer
-      - id: trailing-whitespace

MANIFEST.in

@@ -1,5 +1,6 @@
 include README.rst
 include LICENSE.txt
+include tox.ini
 recursive-include tests *
 recursive-exclude * __pycache__
 recursive-exclude * *.py[co]

README.rst

@@ -4,7 +4,7 @@ VCR.py 📼
 ###########
 
 
-|PyPI| |Python versions| |Build Status| |CodeCov| |Gitter|
+|PyPI| |Python versions| |Build Status| |CodeCov| |Gitter| |CodeStyleBlack|
 
 ----
 
@@ -70,3 +70,6 @@ more details
 .. |CodeCov| image:: https://codecov.io/gh/kevin1024/vcrpy/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/kevin1024/vcrpy
    :alt: Code Coverage Status
+.. |CodeStyleBlack| image:: https://img.shields.io/badge/code%20style-black-000000.svg 
+   :target: https://github.com/psf/black
+   :alt: Code Style: black

docs/changelog.rst

@@ -7,21 +7,6 @@ For a full list of triaged issues, bugs and PRs and what release they are target
 
 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.
 
--  6.0.2
-    - Ensure body is consumed only once (#846) - thanks @sathieu
-    - Permit urllib3 2.x for non-PyPy Python >=3.10
-    - Fix typos in test commands - thanks @chuckwondo
-    - Several test and workflow improvements - thanks @hartwork and @graingert
--  6.0.1
-    - Bugfix with to Tornado cassette generator (thanks @graingert)
--  6.0.0
-    - BREAKING: Fix issue with httpx support (thanks @parkerhancock) in #784. NOTE: You may have to recreate some of your cassettes produced in previous releases due to the binary format being saved incorrectly in previous releases
-    - BREAKING: Drop support for `boto` (vcrpy still supports boto3, but is dropping the deprecated `boto` support in this release. (thanks @jairhenrique)
-    - Fix compatibility issue with Python 3.12 (thanks @hartwork)
-    - Drop simplejson (fixes some compatibility issues) (thanks @jairhenrique)
-    - Run CI on Python 3.12 and PyPy 3.9-3.10 (thanks @mgorny)
-    - Various linting and docs improvements (thanks @jairhenrique)
-    - Tornado fixes (thanks @graingert)
 -  5.1.0
     - Use ruff for linting (instead of current flake8/isort/pyflakes) - thanks @jairhenrique
     - Enable rule B (flake8-bugbear) on ruff - thanks @jairhenrique
@@ -302,3 +287,4 @@ All help in providing PRs to close out bug issues is appreciated. Even if that i
     - Add support for requests / urllib3
 -  0.0.1
     - Initial Release
+

docs/contributing.rst

@@ -83,21 +83,39 @@ The PR reviewer is a second set of eyes to see if:
 Running VCR's test suite
 ------------------------
 
-The tests are all run automatically on `Github Actions CI <https://github.com/kevin1024/vcrpy/actions>`__,
+The tests are all run automatically on `Travis
-but you can also run them yourself using `pytest <http://pytest.org/>`__.
+CI <https://travis-ci.org/kevin1024/vcrpy>`__, but you can also run them
+yourself using `pytest <http://pytest.org/>`__ and
+`Tox <http://tox.testrun.org/>`__. 
 
-In order for the boto3 tests to run, you will need an AWS key.
+Tox will automatically run them in all environments VCR.py supports if they are available on your `PATH`. Alternatively you can use `tox-pyenv <https://pypi.org/project/tox-pyenv/>`_ with 
+`pyenv <https://github.com/pyenv/pyenv>`_. 
+We recommend you read the documentation for each and see the section further below.
+
+The test suite is pretty big and slow, but you can tell tox to only run specific tests like this::
+
+    tox -e {pyNN}-{HTTP_LIBRARY} -- <pytest flags passed through>
+
+    tox -e py38-requests -- -v -k "'test_status_code or test_gzip'"
+    tox -e py38-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.8 environment
+that has ``requests`` installed.
+
+Also, in order for the boto3 tests to run, you will need an AWS key.
 Refer to the `boto3
 documentation <https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html>`__
 for how to set this up. I have marked the boto3 tests as optional in
 Travis so you don't have to worry about them failing if you submit a
 pull request.
 
-Using Pyenv with VCR's test suite
+Using PyEnv with VCR's test suite
 ---------------------------------
 
-Pyenv is a tool for managing multiple installation of python on your system.
+PyEnv is a tool for managing multiple installation of python on your system.
 See the full documentation at their `github <https://github.com/pyenv/pyenv>`_ 
+but we are also going to use `tox-pyenv <https://pypi.org/project/tox-pyenv/>`_ 
 in this example::
 
     git clone https://github.com/pyenv/pyenv ~/.pyenv
@@ -108,21 +126,27 @@ in this example::
     # Setup shim paths
     eval "$(pyenv init -)"
 
+    # Setup your local system tox tooling
+    pip3 install tox tox-pyenv
+
     # Install supported versions (at time of writing), this does not activate them
-    pyenv install 3.12.0 pypy3.10
+    pyenv install 3.8.0 pypy3.8
 
     # This activates them
-    pyenv local 3.12.0 pypy3.10
+    pyenv local 3.8.0 pypy3.8
 
     # Run the whole test suite
-    pip install .[tests]
+    tox
-    ./runtests.sh
+
+    # Run the whole test suite or just part of it
+    tox -e lint
+    tox -e py38-requests
 
 
 Troubleshooting on MacOSX
 -------------------------
 
-If you have this kind of error when running tests :
+If you have this kind of error when running tox :
 
 .. code:: python
 

docs/requirements.txt

@@ -1,2 +1,2 @@
 sphinx<8
-sphinx_rtd_theme==2.0.0
+sphinx_rtd_theme==1.3.0

pyproject.toml

@@ -1,3 +1,6 @@
+[tool.black]
+line-length=110
+
 [tool.codespell]
 skip = '.git,*.pdf,*.svg,.tox'
 ignore-regex = "\\\\[fnrstv]"
@@ -5,14 +8,8 @@ ignore-regex = "\\\\[fnrstv]"
 # ignore-words-list = ''
 
 [tool.pytest.ini_options]
-addopts = [
+markers = [
-    "--strict-config",
+    "online",
-    "--strict-markers",
-]
-markers = ["online"]
-filterwarnings = [
-    "error",
-    '''ignore:datetime\.datetime\.utcfromtimestamp\(\) is deprecated and scheduled for removal in a future version.*:DeprecationWarning''',
 ]
 
 [tool.ruff]
@@ -33,4 +30,4 @@ line-length = 110
 target-version = "py38"
 
 [tool.ruff.isort]
-known-first-party = ["vcr"]
+known-first-party = [ "vcr" ]

runtests.sh

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

setup.py

@@ -3,8 +3,10 @@
 import codecs
 import os
 import re
+import sys
 
 from setuptools import find_packages, setup
+from setuptools.command.test import test as TestCommand
 
 long_description = open("README.rst").read()
 here = os.path.abspath(os.path.dirname(__file__))
@@ -26,6 +28,20 @@ def find_version(*file_paths):
     raise RuntimeError("Unable to find version string.")
 
 
+class PyTest(TestCommand):
+    def finalize_options(self):
+        TestCommand.finalize_options(self)
+        self.test_args = []
+        self.test_suite = True
+
+    def run_tests(self):
+        # import here, cause outside the eggs aren't loaded
+        import pytest
+
+        errno = pytest.main(self.test_args)
+        sys.exit(errno)
+
+
 install_requires = [
     "PyYAML",
     "wrapt",
@@ -39,34 +55,26 @@ install_requires = [
     "urllib3 <2; python_version <'3.10'",
     # https://github.com/kevin1024/vcrpy/pull/775#issuecomment-1847849962
     "urllib3 <2; platform_python_implementation =='PyPy'",
-    # Workaround for Poetry with CPython >= 3.10, problem description at:
-    # https://github.com/kevin1024/vcrpy/pull/826
-    "urllib3; platform_python_implementation !='PyPy' and python_version >='3.10'",
 ]
 
-extras_require = {
+tests_require = [
-    "tests": [
     "aiohttp",
     "boto3",
     "httplib2",
     "httpx",
-        "pytest-aiohttp",
-        "pytest-asyncio",
-        "pytest-cov",
-        "pytest-httpbin",
     "pytest",
-        "requests>=2.22.0",
+    "pytest-aiohttp",
+    "pytest-httpbin",
+    "requests>=2.16.2",
     "tornado",
-        "urllib3",
+    # Needed to un-break httpbin 0.10.1. For httpbin >=0.10.2,
-        # Needed to un-break httpbin 0.7.0. For httpbin >=0.7.1 and after,
+    # this cap and the dependency itself can be removed, provided
-        # this pin and the dependency itself can be removed, provided
+    # that the related bug in httpbin has has been fixed in a new release:
-        # that the related bug in httpbin has been fixed:
+    # https://github.com/psf/httpbin/issues/28
-        # https://github.com/kevin1024/vcrpy/issues/645#issuecomment-1562489489
+    # https://github.com/psf/httpbin/pull/29
-        # https://github.com/postmanlabs/httpbin/issues/673
+    # https://github.com/psf/httpbin/pull/37
-        # https://github.com/postmanlabs/httpbin/pull/674
+    "Werkzeug<3",
-        "Werkzeug==2.0.3",
+]
-    ],
-}
 
 setup(
     name="vcrpy",
@@ -81,8 +89,7 @@ setup(
     python_requires=">=3.8",
     install_requires=install_requires,
     license="MIT",
-    extras_require=extras_require,
+    tests_require=tests_require,
-    tests_require=extras_require["tests"],
     classifiers=[
         "Development Status :: 5 - Production/Stable",
         "Environment :: Console",

tests/integration/aiohttp_utils.py

@@ -5,7 +5,7 @@ import aiohttp
 
 
 async def aiohttp_request(loop, method, url, output="text", encoding="utf-8", content_type=None, **kwargs):
-    async with aiohttp.ClientSession(loop=loop) as session:
+    session = aiohttp.ClientSession(loop=loop)
     response_ctx = session.request(method, url, **kwargs)
 
     response = await response_ctx.__aenter__()

tests/integration/cassettes/gzip_httpx_old_format.yaml

@@ -1,41 +0,0 @@
-interactions:
-- request:
-    body: ''
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate, br
-      connection:
-      - keep-alive
-      host:
-      - httpbin.org
-      user-agent:
-      - python-httpx/0.23.0
-    method: GET
-    uri: https://httpbin.org/gzip
-  response:
-    content: "{\n  \"gzipped\": true, \n  \"headers\": {\n    \"Accept\": \"*/*\",
-      \n    \"Accept-Encoding\": \"gzip, deflate, br\", \n    \"Host\": \"httpbin.org\",
-      \n    \"User-Agent\": \"python-httpx/0.23.0\", \n    \"X-Amzn-Trace-Id\": \"Root=1-62a62a8d-5f39b5c50c744da821d6ea99\"\n
-      \ }, \n  \"method\": \"GET\", \n  \"origin\": \"146.200.25.115\"\n}\n"
-    headers:
-      Access-Control-Allow-Credentials:
-      - 'true'
-      Access-Control-Allow-Origin:
-      - '*'
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Length:
-      - '230'
-      Content-Type:
-      - application/json
-      Date:
-      - Sun, 12 Jun 2022 18:03:57 GMT
-      Server:
-      - gunicorn/19.9.0
-    http_version: HTTP/1.1
-    status_code: 200
-version: 1

tests/integration/cassettes/gzip_requests.yaml

@@ -1,42 +0,0 @@
-interactions:
-- request:
-    body: null
-    headers:
-      Accept:
-      - '*/*'
-      Accept-Encoding:
-      - gzip, deflate, br
-      Connection:
-      - keep-alive
-      User-Agent:
-      - python-requests/2.28.0
-    method: GET
-    uri: https://httpbin.org/gzip
-  response:
-    body:
-      string: !!binary |
-        H4sIAKwrpmIA/z2OSwrCMBCG956izLIkfQSxkl2RogfQA9R2bIM1iUkqaOndnYDIrGa+/zELDB9l
-        LfYgg5uRwYhtj86DXKDuOrQBJKR5Cuy38kZ3pld6oHu0sqTH29QGZMnVkepgtMYuKKNJcEe0vJ3U
-        C4mcjI9hpaiygqaUW7ETFYGLR8frAXXE9h1Go7nD54w++FxkYp8VsDJ4IBH6E47NmVzGqUHFkn8g
-        rJsvp2omYs8AAAA=
-    headers:
-      Access-Control-Allow-Credentials:
-      - 'true'
-      Access-Control-Allow-Origin:
-      - '*'
-      Connection:
-      - Close
-      Content-Encoding:
-      - gzip
-      Content-Length:
-      - '182'
-      Content-Type:
-      - application/json
-      Date:
-      - Sun, 12 Jun 2022 18:08:44 GMT
-      Server:
-      - Pytest-HTTPBIN/0.1.0
-    status:
-      code: 200
-      message: great
-version: 1

tests/integration/conftest.py

@@ -0,0 +1,16 @@
+import os
+import ssl
+
+import pytest
+
+
+@pytest.fixture
+def httpbin_ssl_context():
+    ssl_ca_location = os.environ["REQUESTS_CA_BUNDLE"]
+    ssl_cert_location = os.environ["REQUESTS_CA_BUNDLE"].replace("cacert.pem", "cert.pem")
+    ssl_key_location = os.environ["REQUESTS_CA_BUNDLE"].replace("cacert.pem", "key.pem")
+
+    ssl_context = ssl.create_default_context(cafile=ssl_ca_location)
+    ssl_context.load_cert_chain(ssl_cert_location, ssl_key_location)
+
+    return ssl_context

tests/integration/test_aiohttp.py

@@ -1,9 +1,8 @@
+import contextlib
 import logging
-import ssl
 import urllib.parse
 
 import pytest
-import pytest_httpbin.certs
 
 import vcr
 
@@ -13,14 +12,12 @@ aiohttp = pytest.importorskip("aiohttp")
 
 from .aiohttp_utils import aiohttp_app, aiohttp_request  # noqa: E402
 
-HTTPBIN_SSL_CONTEXT = ssl.create_default_context(cafile=pytest_httpbin.certs.where())
-
 
 def run_in_loop(fn):
-    async def wrapper():
+    with contextlib.closing(asyncio.new_event_loop()) as loop:
-        return await fn(asyncio.get_running_loop())
+        asyncio.set_event_loop(loop)
-
+        task = loop.create_task(fn(loop))
-    return asyncio.run(wrapper())
+        return loop.run_until_complete(task)
 
 
 def request(method, url, output="text", **kwargs):
@@ -263,12 +260,6 @@ def test_aiohttp_test_client_json(aiohttp_client, tmpdir):
     assert cassette.play_count == 1
 
 
-def test_cleanup_from_pytest_asyncio():
-    # work around https://github.com/pytest-dev/pytest-asyncio/issues/724
-    asyncio.get_event_loop().close()
-    asyncio.set_event_loop(None)
-
-
 @pytest.mark.online
 def test_redirect(tmpdir, httpbin):
     url = httpbin.url + "/redirect/2"
@@ -342,7 +333,7 @@ def test_double_requests(tmpdir, httpbin):
         assert cassette.play_count == 2
 
 
-def test_cookies(httpbin_both, tmpdir):
+def test_cookies(httpbin_both, httpbin_ssl_context, tmpdir):
     async def run(loop):
         cookies_url = httpbin_both.url + (
             "/response-headers?"
@@ -357,12 +348,12 @@ def test_cookies(httpbin_both, tmpdir):
         # ------------------------- Record -------------------------- #
         with vcr.use_cassette(tmp) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
+                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
                 home_resp = await session.get(
                     home_url,
                     cookies=req_cookies,
                     headers=req_headers,
-                    ssl=HTTPBIN_SSL_CONTEXT,
+                    ssl=httpbin_ssl_context,
                 )
                 assert cassette.play_count == 0
         assert_responses(cookies_resp, home_resp)
@@ -370,12 +361,12 @@ def test_cookies(httpbin_both, tmpdir):
         # -------------------------- Play --------------------------- #
         with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
+                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
                 home_resp = await session.get(
                     home_url,
                     cookies=req_cookies,
                     headers=req_headers,
-                    ssl=HTTPBIN_SSL_CONTEXT,
+                    ssl=httpbin_ssl_context,
                 )
                 assert cassette.play_count == 2
         assert_responses(cookies_resp, home_resp)
@@ -392,7 +383,7 @@ def test_cookies(httpbin_both, tmpdir):
     run_in_loop(run)
 
 
-def test_cookies_redirect(httpbin_both, tmpdir):
+def test_cookies_redirect(httpbin_both, httpbin_ssl_context, tmpdir):
     async def run(loop):
         # Sets cookie as provided by the query string and redirects
         cookies_url = httpbin_both.url + "/cookies/set?Cookie_1=Val_1"
@@ -401,7 +392,7 @@ def test_cookies_redirect(httpbin_both, tmpdir):
         # ------------------------- Record -------------------------- #
         with vcr.use_cassette(tmp) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
+                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
                 assert not cookies_resp.cookies
                 cookies = session.cookie_jar.filter_cookies(cookies_url)
                 assert cookies["Cookie_1"].value == "Val_1"
@@ -412,7 +403,7 @@ def test_cookies_redirect(httpbin_both, tmpdir):
         # -------------------------- Play --------------------------- #
         with vcr.use_cassette(tmp, record_mode=vcr.mode.NONE) as cassette:
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
+                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
                 assert not cookies_resp.cookies
                 cookies = session.cookie_jar.filter_cookies(cookies_url)
                 assert cookies["Cookie_1"].value == "Val_1"
@@ -426,7 +417,7 @@ def test_cookies_redirect(httpbin_both, tmpdir):
                 "Cookie_1=Val_1; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
             ]
             async with aiohttp.ClientSession(loop=loop, cookie_jar=aiohttp.CookieJar(unsafe=True)) as session:
-                cookies_resp = await session.get(cookies_url, ssl=HTTPBIN_SSL_CONTEXT)
+                cookies_resp = await session.get(cookies_url, ssl=httpbin_ssl_context)
                 assert not cookies_resp.cookies
                 cookies = session.cookie_jar.filter_cookies(cookies_url)
                 assert cookies["Cookie_1"].value == "Val_1"

tests/integration/test_basic.py

@@ -39,7 +39,7 @@ def test_basic_json_use(tmpdir, httpbin):
     test_fixture = str(tmpdir.join("synopsis.json"))
     with vcr.use_cassette(test_fixture, serializer="json"):
         response = urlopen(httpbin.url).read()
-        assert b"HTTP Request & Response Service" in response
+        assert b"A simple HTTP Request & Response Service." in response
 
 
 def test_patched_content(tmpdir, httpbin):

tests/integration/test_filter.py

@@ -5,11 +5,10 @@ from urllib.parse import urlencode
 from urllib.request import Request, urlopen
 
 import pytest
+from assertions import assert_cassette_has_one_response, assert_is_json_bytes
 
 import vcr
 
-from ..assertions import assert_cassette_has_one_response, assert_is_json_bytes
-
 
 def _request_with_auth(url, username, password):
     request = Request(url)

tests/integration/test_httplib2.py

@@ -1,14 +1,12 @@
 """Integration tests with httplib2"""
-
 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")
 
 

tests/integration/test_httpx.py

@@ -1,11 +1,7 @@
-import os
-
 import pytest
 
 import vcr
 
-from ..assertions import assert_is_json_bytes
-
 asyncio = pytest.importorskip("asyncio")
 httpx = pytest.importorskip("httpx")
 
@@ -32,35 +28,23 @@ class DoSyncRequest(BaseDoRequest):
     _client_class = httpx.Client
 
     def __enter__(self):
-        self._client = self._make_client()
         return self
 
     def __exit__(self, *args):
-        self._client.close()
+        pass
-        del self._client
 
     @property
     def client(self):
         try:
             return self._client
-        except AttributeError as e:
+        except AttributeError:
-            raise ValueError('To access sync client, use "with do_request() as client"') from e
+            self._client = self._make_client()
+            return self._client
 
     def __call__(self, *args, **kwargs):
-        if hasattr(self, "_client"):
-            return self.client.request(*args, timeout=60, **kwargs)
-
-        # Use one-time context and dispose of the client afterwards
-        with self:
         return self.client.request(*args, timeout=60, **kwargs)
 
     def stream(self, *args, **kwargs):
-        if hasattr(self, "_client"):
-            with self.client.stream(*args, **kwargs) as response:
-                return b"".join(response.iter_bytes())
-
-        # Use one-time context and dispose of the client afterwards
-        with self:
         with self.client.stream(*args, **kwargs) as response:
             return b"".join(response.iter_bytes())
 
@@ -223,6 +207,22 @@ def test_redirect(httpbin, yml, do_request):
     assert cassette_response.request.headers.items() == response.request.headers.items()
 
 
+@pytest.mark.online
+def test_work_with_gzipped_data(httpbin, do_request, yml):
+    url = httpbin.url + "/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.online
 @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):
@@ -285,77 +285,3 @@ def test_stream(tmpdir, httpbin, do_request):
         assert cassette_content == response_content
         assert len(cassette_content) == 512
         assert cassette.play_count == 1
-
-
-# Regular cassette formats support the status reason,
-# but the old HTTPX cassette format does not.
-@pytest.mark.parametrize(
-    "cassette_name,reason",
-    [
-        ("requests", "great"),
-        ("httpx_old_format", "OK"),
-    ],
-)
-def test_load_cassette_format(do_request, cassette_name, reason):
-    mydir = os.path.dirname(os.path.realpath(__file__))
-    yml = f"{mydir}/cassettes/gzip_{cassette_name}.yaml"
-    url = "https://httpbin.org/gzip"
-
-    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
-
-        # Should be able to load up the JSON inside,
-        # regardless whether the content is the gzipped
-        # in the cassette or not.
-        json = cassette_response.json()
-        assert json["method"] == "GET", json
-        assert cassette_response.status_code == 200
-        assert cassette_response.reason_phrase == reason
-
-
-def test_gzip__decode_compressed_response_false(tmpdir, httpbin, do_request):
-    """
-    Ensure that httpx is able to automatically decompress the response body.
-    """
-    for _ in range(2):  # one for recording, one for re-playing
-        with vcr.use_cassette(str(tmpdir.join("gzip.yaml"))) as cassette:
-            response = do_request()("GET", httpbin + "/gzip")
-            assert response.headers["content-encoding"] == "gzip"  # i.e. not removed
-            # The content stored in the cassette should be gzipped.
-            assert cassette.responses[0]["body"]["string"][:2] == b"\x1f\x8b"
-            assert_is_json_bytes(response.content)  # i.e. uncompressed bytes
-
-
-def test_gzip__decode_compressed_response_true(do_request, tmpdir, httpbin):
-    url = httpbin + "/gzip"
-
-    expected_response = do_request()("GET", url)
-    expected_content = expected_response.content
-    assert expected_response.headers["content-encoding"] == "gzip"  # self-test
-
-    with vcr.use_cassette(
-        str(tmpdir.join("decode_compressed.yaml")),
-        decode_compressed_response=True,
-    ) as cassette:
-        r = do_request()("GET", url)
-        assert r.headers["content-encoding"] == "gzip"  # i.e. not removed
-        content_length = r.headers["content-length"]
-        assert r.content == expected_content
-
-    # Has the cassette body been decompressed?
-    cassette_response_body = cassette.responses[0]["body"]["string"]
-    assert isinstance(cassette_response_body, str)
-
-    # Content should be JSON.
-    assert cassette_response_body[0:1] == "{"
-
-    with vcr.use_cassette(str(tmpdir.join("decode_compressed.yaml")), decode_compressed_response=True):
-        r = httpx.get(url)
-        assert "content-encoding" not in r.headers  # i.e. removed
-        assert r.content == expected_content
-
-        # As the content is uncompressed, it should have a bigger
-        # length than the compressed version.
-        assert r.headers["content-length"] > content_length

tests/integration/test_proxy.py

@@ -39,7 +39,7 @@ class Proxy(http.server.SimpleHTTPRequestHandler):
 
 @pytest.fixture(scope="session")
 def proxy_server():
-    with socketserver.ThreadingTCPServer(("", 0), Proxy) as httpd:
+    httpd = socketserver.ThreadingTCPServer(("", 0), Proxy)
     proxy_process = threading.Thread(target=httpd.serve_forever)
     proxy_process.start()
     yield "http://{}:{}".format(*httpd.server_address)

tests/integration/test_register_persister.py

@@ -66,7 +66,7 @@ def test_load_cassette_with_custom_persister(tmpdir, httpbin):
 
     with my_vcr.use_cassette(test_fixture, serializer="json"):
         response = urlopen(httpbin.url).read()
-        assert b"HTTP Request & Response Service" in response
+        assert b"A simple HTTP Request & Response Service." in response
 
 
 def test_load_cassette_persister_exception_handling(tmpdir, httpbin):

tests/integration/test_requests.py

@@ -1,11 +1,9 @@
 """Test requests' interaction with vcr"""
-
 import pytest
+from assertions import assert_cassette_empty, assert_is_json_bytes
 
 import vcr
 
-from ..assertions import assert_cassette_empty, assert_is_json_bytes
-
 requests = pytest.importorskip("requests")
 
 
@@ -266,7 +264,7 @@ def test_nested_cassettes_with_session_created_before_nesting(httpbin_both, tmpd
 def test_post_file(tmpdir, httpbin_both):
     """Ensure that we handle posting a file."""
     url = httpbin_both + "/post"
-    with vcr.use_cassette(str(tmpdir.join("post_file.yaml"))) as cass, open(".editorconfig", "rb") as f:
+    with vcr.use_cassette(str(tmpdir.join("post_file.yaml"))) as cass, open("tox.ini", "rb") as f:
         original_response = requests.post(url, f).content
 
     # This also tests that we do the right thing with matching the body when they are files.
@@ -274,10 +272,10 @@ def test_post_file(tmpdir, httpbin_both):
         str(tmpdir.join("post_file.yaml")),
         match_on=("method", "scheme", "host", "port", "path", "query", "body"),
     ) as cass:
-        with open(".editorconfig", "rb") as f:
+        with open("tox.ini", "rb") as f:
-            editorconfig = f.read()
+            tox_content = f.read()
-        assert cass.requests[0].body.read() == editorconfig
+        assert cass.requests[0].body.read() == tox_content
-        with open(".editorconfig", "rb") as f:
+        with open("tox.ini", "rb") as f:
             new_response = requests.post(url, f).content
         assert original_response == new_response
 

tests/integration/test_stubs.py

@@ -2,9 +2,9 @@ import http.client as httplib
 import json
 import zlib
 
-import vcr
+from assertions import assert_is_json_bytes
 
-from ..assertions import assert_is_json_bytes
+import vcr
 
 
 def _headers_are_case_insensitive(host, port):

tests/integration/test_tornado.py

@@ -1,45 +1,19 @@
 """Test requests' interaction with vcr"""
 
-import asyncio
-import functools
-import inspect
 import json
 
 import pytest
+from assertions import assert_cassette_empty, assert_is_json_bytes
 
 import vcr
 from vcr.errors import CannotOverwriteExistingCassetteException
 
-from ..assertions import assert_cassette_empty, assert_is_json_bytes
-
 tornado = pytest.importorskip("tornado")
-gen = pytest.importorskip("tornado.gen")
 http = pytest.importorskip("tornado.httpclient")
 
 # whether the current version of Tornado supports the raise_error argument for
 # fetch().
 supports_raise_error = tornado.version_info >= (4,)
-raise_error_for_response_code_only = tornado.version_info >= (6,)
-
-
-def gen_test(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        async def coro():
-            return await gen.coroutine(func)(*args, **kwargs)
-
-        return asyncio.run(coro())
-
-    # Patch the signature so pytest can inject fixtures
-    # we can't use wrapt.decorator because it returns a generator function
-    wrapper.__signature__ = inspect.signature(func)
-    return wrapper
-
-
-@pytest.fixture(params=["https", "http"])
-def scheme(request):
-    """Fixture that returns both http and https."""
-    return request.param
 
 
 @pytest.fixture(params=["simple", "curl", "default"])
@@ -69,8 +43,7 @@ def post(client, url, data=None, **kwargs):
     return client.fetch(http.HTTPRequest(url, method="POST", **kwargs))
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_status_code(get_client, scheme, tmpdir):
     """Ensure that we can read the status code"""
     url = scheme + "://httpbin.org/"
@@ -82,8 +55,7 @@ def test_status_code(get_client, scheme, tmpdir):
         assert 1 == cass.play_count
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_headers(get_client, scheme, tmpdir):
     """Ensure that we can read the headers back"""
     url = scheme + "://httpbin.org/"
@@ -95,8 +67,7 @@ def test_headers(get_client, scheme, tmpdir):
         assert 1 == cass.play_count
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_body(get_client, tmpdir, scheme):
     """Ensure the responses are all identical enough"""
 
@@ -109,7 +80,7 @@ def test_body(get_client, tmpdir, scheme):
         assert 1 == cass.play_count
 
 
-@gen_test
+@pytest.mark.gen_test
 def test_effective_url(get_client, tmpdir, httpbin):
     """Ensure that the effective_url is captured"""
     url = httpbin.url + "/redirect/1"
@@ -122,8 +93,7 @@ def test_effective_url(get_client, tmpdir, httpbin):
         assert 1 == cass.play_count
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_auth(get_client, tmpdir, scheme):
     """Ensure that we can handle basic auth"""
     auth = ("user", "passwd")
@@ -138,8 +108,7 @@ def test_auth(get_client, tmpdir, scheme):
         assert 1 == cass.play_count
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_auth_failed(get_client, tmpdir, scheme):
     """Ensure that we can save failed auth statuses"""
     auth = ("user", "wrongwrongwrong")
@@ -162,8 +131,7 @@ def test_auth_failed(get_client, tmpdir, scheme):
         assert 1 == cass.play_count
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_post(get_client, tmpdir, scheme):
     """Ensure that we can post and cache the results"""
     data = {"key1": "value1", "key2": "value2"}
@@ -178,10 +146,10 @@ def test_post(get_client, tmpdir, scheme):
     assert 1 == cass.play_count
 
 
-@gen_test
+@pytest.mark.gen_test
-def test_redirects(get_client, tmpdir, httpbin):
+def test_redirects(get_client, tmpdir, scheme):
     """Ensure that we can handle redirects"""
-    url = httpbin + "/redirect-to?url=bytes/1024&status_code=301"
+    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
 
@@ -190,8 +158,7 @@ def test_redirects(get_client, tmpdir, httpbin):
         assert cass.play_count == 1
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_cross_scheme(get_client, tmpdir, scheme):
     """Ensure that requests between schemes are treated separately"""
     # First fetch a url under http, and then again under https and then
@@ -210,8 +177,7 @@ def test_cross_scheme(get_client, tmpdir, scheme):
         assert cass.play_count == 2
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_gzip(get_client, tmpdir, scheme):
     """
     Ensure that httpclient is able to automatically decompress the response
@@ -236,8 +202,7 @@ def test_gzip(get_client, tmpdir, scheme):
         assert 1 == cass.play_count
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_https_with_cert_validation_disabled(get_client, tmpdir):
     cass_path = str(tmpdir.join("cert_validation_disabled.yaml"))
 
@@ -249,7 +214,7 @@ def test_https_with_cert_validation_disabled(get_client, tmpdir):
         assert 1 == cass.play_count
 
 
-@gen_test
+@pytest.mark.gen_test
 def test_unsupported_features_raises_in_future(get_client, tmpdir):
     """Ensure that the exception for an AsyncHTTPClient feature not being
     supported is raised inside the future."""
@@ -267,11 +232,7 @@ def test_unsupported_features_raises_in_future(get_client, tmpdir):
 
 
 @pytest.mark.skipif(not supports_raise_error, reason="raise_error unavailable in tornado <= 3")
-@pytest.mark.skipif(
+@pytest.mark.gen_test
-    raise_error_for_response_code_only,
-    reason="raise_error only ignores HTTPErrors due to response code",
-)
-@gen_test
 def test_unsupported_features_raise_error_disabled(get_client, tmpdir):
     """Ensure that the exception for an AsyncHTTPClient feature not being
     supported is not raised if raise_error=False."""
@@ -290,8 +251,7 @@ def test_unsupported_features_raise_error_disabled(get_client, tmpdir):
     assert "not yet supported by VCR" in str(response.error)
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_cannot_overwrite_cassette_raises_in_future(get_client, tmpdir):
     """Ensure that CannotOverwriteExistingCassetteException is raised inside
     the future."""
@@ -307,11 +267,7 @@ def test_cannot_overwrite_cassette_raises_in_future(get_client, tmpdir):
 
 
 @pytest.mark.skipif(not supports_raise_error, reason="raise_error unavailable in tornado <= 3")
-@pytest.mark.skipif(
+@pytest.mark.gen_test
-    raise_error_for_response_code_only,
-    reason="raise_error only ignores HTTPErrors due to response code",
-)
-@gen_test
 def test_cannot_overwrite_cassette_raise_error_disabled(get_client, tmpdir):
     """Ensure that CannotOverwriteExistingCassetteException is not raised if
     raise_error=False in the fetch() call."""
@@ -325,14 +281,14 @@ def test_cannot_overwrite_cassette_raise_error_disabled(get_client, tmpdir):
     assert isinstance(response.error, CannotOverwriteExistingCassetteException)
 
 
-@gen_test
+@pytest.mark.gen_test
 @vcr.use_cassette(path_transformer=vcr.default_vcr.ensure_suffix(".yaml"))
 def test_tornado_with_decorator_use_cassette(get_client):
     response = yield get_client().fetch(http.HTTPRequest("http://www.google.com/", method="GET"))
     assert response.body.decode("utf-8") == "not actually google"
 
 
-@gen_test
+@pytest.mark.gen_test
 @vcr.use_cassette(path_transformer=vcr.default_vcr.ensure_suffix(".yaml"))
 def test_tornado_exception_can_be_caught(get_client):
     try:
@@ -346,8 +302,7 @@ def test_tornado_exception_can_be_caught(get_client):
         assert e.code == 404
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_existing_references_get_patched(tmpdir):
     from tornado.httpclient import AsyncHTTPClient
 
@@ -360,8 +315,7 @@ def test_existing_references_get_patched(tmpdir):
         assert cass.play_count == 1
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_existing_instances_get_patched(get_client, tmpdir):
     """Ensure that existing instances of AsyncHTTPClient get patched upon
     entering VCR context."""
@@ -376,8 +330,7 @@ def test_existing_instances_get_patched(get_client, tmpdir):
         assert cass.play_count == 1
 
 
-@pytest.mark.online
+@pytest.mark.gen_test
-@gen_test
 def test_request_time_is_set(get_client, tmpdir):
     """Ensures that the request_time on HTTPResponses is set."""
 

tests/integration/test_urllib2.py

@@ -5,13 +5,12 @@ from urllib.parse import urlencode
 from urllib.request import urlopen
 
 import pytest_httpbin.certs
+from assertions import assert_cassette_has_one_response
 from pytest import mark
 
 # 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())

tests/integration/test_urllib3.py

@@ -4,13 +4,12 @@
 
 import pytest
 import pytest_httpbin
+from assertions import assert_cassette_empty, assert_is_json_bytes
 
 import vcr
 from vcr.patch import force_reset
 from vcr.stubs.compat import get_headers
 
-from ..assertions import assert_cassette_empty, assert_is_json_bytes
-
 urllib3 = pytest.importorskip("urllib3")
 
 

tests/integration/test_wild.py

@@ -63,7 +63,7 @@ def test_flickr_should_respond_with_200(tmpdir):
 def test_cookies(tmpdir, httpbin):
     testfile = str(tmpdir.join("cookies.yml"))
     with vcr.use_cassette(testfile):
-        with requests.Session() as s:
+        s = requests.Session()
         s.get(httpbin.url + "/cookies/set?k1=v1&k2=v2")
         assert s.cookies.keys() == ["k1", "k2"]
 

tests/unit/test_stubs.py

@@ -1,12 +1,8 @@
-import contextlib
-import http.client as httplib
-from io import BytesIO
-from tempfile import NamedTemporaryFile
 from unittest import mock
 
 from pytest import mark
 
-from vcr import mode, use_cassette
+from vcr import mode
 from vcr.cassette import Cassette
 from vcr.stubs import VCRHTTPSConnection
 
@@ -20,56 +16,7 @@ class TestVCRConnection:
     @mark.online
     @mock.patch("vcr.cassette.Cassette.can_play_response_for", return_value=False)
     def testing_connect(*args):
-        with contextlib.closing(VCRHTTPSConnection("www.google.com")) as vcr_connection:
+        vcr_connection = VCRHTTPSConnection("www.google.com")
         vcr_connection.cassette = Cassette("test", record_mode=mode.ALL)
         vcr_connection.real_connection.connect()
         assert vcr_connection.real_connection.sock is not None
-
-    def test_body_consumed_once_stream(self, tmpdir, httpbin):
-        self._test_body_consumed_once(
-            tmpdir,
-            httpbin,
-            BytesIO(b"1234567890"),
-            BytesIO(b"9876543210"),
-            BytesIO(b"9876543210"),
-        )
-
-    def test_body_consumed_once_iterator(self, tmpdir, httpbin):
-        self._test_body_consumed_once(
-            tmpdir,
-            httpbin,
-            iter([b"1234567890"]),
-            iter([b"9876543210"]),
-            iter([b"9876543210"]),
-        )
-
-    # data2 and data3 should serve the same data, potentially as iterators
-    def _test_body_consumed_once(
-        self,
-        tmpdir,
-        httpbin,
-        data1,
-        data2,
-        data3,
-    ):
-        with NamedTemporaryFile(dir=tmpdir, suffix=".yml") as f:
-            testpath = f.name
-            # NOTE: ``use_cassette`` is not okay with the file existing
-            #       already.  So we using ``.close()`` to not only
-            #       close but also delete the empty file, before we start.
-            f.close()
-            host, port = httpbin.host, httpbin.port
-            match_on = ["method", "uri", "body"]
-            with use_cassette(testpath, match_on=match_on):
-                conn1 = httplib.HTTPConnection(host, port)
-                conn1.request("POST", "/anything", body=data1)
-                conn1.getresponse()
-                conn2 = httplib.HTTPConnection(host, port)
-                conn2.request("POST", "/anything", body=data2)
-                conn2.getresponse()
-            with use_cassette(testpath, match_on=match_on) as cass:
-                conn3 = httplib.HTTPConnection(host, port)
-                conn3.request("POST", "/anything", body=data3)
-                conn3.getresponse()
-            assert cass.play_counts[0] == 0
-            assert cass.play_counts[1] == 1

tests/unit/test_util.py

@@ -1,33 +0,0 @@
-from io import BytesIO, StringIO
-
-import pytest
-
-from vcr import request
-from vcr.util import read_body
-
-
-@pytest.mark.parametrize(
-    "input_, expected_output",
-    [
-        (BytesIO(b"Stream"), b"Stream"),
-        (StringIO("Stream"), b"Stream"),
-        (iter(["StringIter"]), b"StringIter"),
-        (iter(["String", "Iter"]), b"StringIter"),
-        (iter([b"BytesIter"]), b"BytesIter"),
-        (iter([b"Bytes", b"Iter"]), b"BytesIter"),
-        (iter([70, 111, 111]), b"Foo"),
-        (iter([]), b""),
-        ("String", b"String"),
-        (b"Bytes", b"Bytes"),
-    ],
-)
-def test_read_body(input_, expected_output):
-    r = request.Request("POST", "http://host.com/", input_, {})
-    assert read_body(r) == expected_output
-
-
-def test_unsupported_read_body():
-    r = request.Request("POST", "http://host.com/", iter([[]]), {})
-    with pytest.raises(ValueError) as excinfo:
-        assert read_body(r)
-    assert excinfo.value.args == ("Body type <class 'list'> not supported",)

tests/unit/test_vcr.py

@@ -372,19 +372,3 @@ def test_path_class_as_cassette():
     )
     with use_cassette(path):
         pass
-
-
-def test_use_cassette_generator_return():
-    ret_val = object()
-
-    vcr = VCR()
-
-    @vcr.use_cassette("test")
-    def gen():
-        return ret_val
-        yield
-
-    with pytest.raises(StopIteration) as exc_info:
-        next(gen())
-
-    assert exc_info.value.value is ret_val

tox.ini

@@ -0,0 +1,87 @@
+[tox]
+skip_missing_interpreters=true
+envlist =
+  cov-clean,
+  lint,
+  {py38,py39,py310,py311,py312}-{requests-urllib3-1,httplib2,urllib3-1,tornado4,boto3,aiohttp,httpx},
+  {py310,py311,py312}-{requests-urllib3-2,urllib3-2},
+  {pypy3}-{requests-urllib3-1,httplib2,urllib3-1,tornado4,boto3},
+  #{py310}-httpx019,
+  cov-report
+
+
+[gh-actions]
+python =
+    3.8: py38
+    3.9: py39
+    3.10: py310, lint
+    3.11: py311
+    3.12: py312
+    pypy-3: pypy3
+
+# Coverage environment tasks: cov-clean and cov-report
+# https://pytest-cov.readthedocs.io/en/latest/tox.html
+[testenv:cov-clean]
+deps = coverage
+skip_install=true
+commands = coverage erase
+
+[testenv:cov-report]
+deps = coverage
+skip_install=true
+commands =
+  coverage html
+  coverage report --fail-under=90
+
+[testenv:lint]
+skipsdist = True
+commands =
+    black --version
+    black --check --diff .
+    ruff --version
+    ruff check .
+deps =
+  black
+  ruff
+basepython = python3.10
+
+[testenv]
+# Need to use develop install so that paths
+# for aggregate code coverage combine
+usedevelop=true
+commands =
+    ./runtests.sh --cov=./vcr --cov-branch --cov-report=xml --cov-append {posargs}
+allowlist_externals =
+    ./runtests.sh
+deps =
+    Werkzeug<3
+    pytest
+    pytest-httpbin>=1.0.1
+    pytest-cov
+    PyYAML
+    ipaddress
+    requests: requests>=2.22.0
+    httplib2: httplib2
+    urllib3-1: urllib3<2
+    urllib3-2: urllib3<3
+    boto3: boto3
+    aiohttp: aiohttp
+    aiohttp: pytest-asyncio
+    aiohttp: pytest-aiohttp
+    httpx: httpx
+    {py38,py39,py310}-{httpx}: httpx
+    {py38,py39,py310}-{httpx}: pytest-asyncio
+    httpx: httpx>0.19
+    httpx019: httpx==0.19
+    {py38,py39,py310}-{httpx}: pytest-asyncio
+depends =
+  lint,{py38,py39,py310,py311,py312,pypy3}-{requests-urllib3-1,httplib2,urllib3-1,tornado4,boto3},{py310,py311,py312}-{requests-urllib3-2,urllib3-2},{py38,py39,py310,py311,py312}-{aiohttp},{py38,py39,py310,py311,py312}-{httpx}: cov-clean
+  cov-report: lint,{py38,py39,py310,py311,py312,pypy3}-{requests-urllib3-1,httplib2,urllib3-1,tornado4,boto3},{py310,py311,py312}-{requests-urllib3-2,urllib3-2},{py38,py39,py310,py311,py312}-{aiohttp}
+passenv =
+    AWS_ACCESS_KEY_ID
+    AWS_DEFAULT_REGION
+    AWS_SECRET_ACCESS_KEY
+setenv =
+    # workaround for broken C extension in aiohttp
+    # see: https://github.com/aio-libs/aiohttp/issues/7229
+    py312: AIOHTTP_NO_EXTENSIONS=1

vcr/__init__.py

@@ -4,7 +4,7 @@ from logging import NullHandler
 from .config import VCR
 from .record_mode import RecordMode as mode  # noqa: F401
 
-__version__ = "6.0.2"
+__version__ = "5.1.0"
 
 logging.getLogger(__name__).addHandler(NullHandler())
 

vcr/cassette.py

@@ -3,6 +3,7 @@ import contextlib
 import copy
 import inspect
 import logging
+import sys
 from asyncio import iscoroutinefunction
 
 import wrapt
@@ -125,7 +126,20 @@ class CassetteContextDecorator:
         duration of the generator.
         """
         with self as cassette:
-            return (yield from fn(cassette))
+            coroutine = fn(cassette)
+            # We don't need to catch StopIteration. The caller (Tornado's
+            # gen.coroutine, for example) will handle that.
+            to_yield = next(coroutine)
+            while True:
+                try:
+                    to_send = yield to_yield
+                except Exception:
+                    to_yield = coroutine.throw(*sys.exc_info())
+                else:
+                    try:
+                        to_yield = coroutine.send(to_send)
+                    except StopIteration:
+                        break
 
     def _handle_function(self, fn):
         with self as cassette:

vcr/patch.py

@@ -1,5 +1,4 @@
 """Utilities for patching in cassettes"""
-
 import contextlib
 import functools
 import http.client as httplib
@@ -261,14 +260,10 @@ class CassettePatcherBuilder:
 
             yield cpool, "HTTPConnectionWithTimeout", VCRHTTPConnectionWithTimeout
             yield cpool, "HTTPSConnectionWithTimeout", VCRHTTPSConnectionWithTimeout
-            yield (
+            yield cpool, "SCHEME_TO_CONNECTION", {
-                cpool,
-                "SCHEME_TO_CONNECTION",
-                {
                 "http": VCRHTTPConnectionWithTimeout,
                 "https": VCRHTTPSConnectionWithTimeout,
-                },
+            }
-            )
 
     @_build_patchers_from_mock_triples_decorator
     def _tornado(self):
@@ -373,6 +368,10 @@ class ConnectionRemover:
         if isinstance(connection, self._connection_class):
             self._connection_pool_to_connections.setdefault(pool, set()).add(connection)
 
+    def remove_connection_to_pool_entry(self, pool, connection):
+        if isinstance(connection, self._connection_class):
+            self._connection_pool_to_connections[self._connection_class].remove(connection)
+
     def __enter__(self):
         return self
 
@@ -383,13 +382,10 @@ class ConnectionRemover:
                 connection = pool.pool.get()
                 if isinstance(connection, self._connection_class):
                     connections.remove(connection)
-                    connection.close()
                 else:
                     readd_connections.append(connection)
             for connection in readd_connections:
                 pool._put_conn(connection)
-            for connection in connections:
-                connection.close()
 
 
 def reset_patchers():

vcr/request.py

@@ -3,7 +3,7 @@ import warnings
 from io import BytesIO
 from urllib.parse import parse_qsl, urlparse
 
-from .util import CaseInsensitiveDict, _is_nonsequence_iterator
+from .util import CaseInsensitiveDict
 
 log = logging.getLogger(__name__)
 
@@ -17,11 +17,8 @@ class Request:
         self.method = method
         self.uri = uri
         self._was_file = hasattr(body, "read")
-        self._was_iter = _is_nonsequence_iterator(body)
         if self._was_file:
             self.body = body.read()
-        elif self._was_iter:
-            self.body = list(body)
         else:
             self.body = body
         self.headers = headers
@@ -39,11 +36,7 @@ class Request:
 
     @property
     def body(self):
-        if self._was_file:
+        return BytesIO(self._body) if self._was_file else self._body
-            return BytesIO(self._body)
-        if self._was_iter:
-            return iter(self._body)
-        return self._body
 
     @body.setter
     def body(self, value):

vcr/stubs/aiohttp_stubs.py

@@ -1,5 +1,4 @@
 """Stubs for aiohttp HTTP clients"""
-
 import asyncio
 import functools
 import json

vcr/stubs/boto3_stubs.py

@@ -1,5 +1,4 @@
 """Stubs for boto3"""
-
 from botocore.awsrequest import AWSHTTPConnection as HTTPConnection
 from botocore.awsrequest import AWSHTTPSConnection as VerifiedHTTPSConnection
 

vcr/stubs/httpx_stubs.py

@@ -1,4 +1,3 @@
-import asyncio
 import functools
 import inspect
 import logging
@@ -7,9 +6,7 @@ from unittest.mock import MagicMock, patch
 import httpx
 
 from vcr.errors import CannotOverwriteExistingCassetteException
-from vcr.filters import decode_response
 from vcr.request import Request as VcrRequest
-from vcr.serializers.compat import convert_body_to_bytes
 
 _httpx_signature = inspect.signature(httpx.Client.request)
 
@@ -36,29 +33,14 @@ def _transform_headers(httpx_response):
     return out
 
 
-async def _to_serialized_response(resp, aread):
+def _to_serialized_response(httpx_response):
-    # The content shouldn't already have been read in by HTTPX.
+    return {
-    assert not hasattr(resp, "_decoder")
+        "status_code": httpx_response.status_code,
-
+        "http_version": httpx_response.http_version,
-    # Retrieve the content, but without decoding it.
+        "headers": _transform_headers(httpx_response),
-    with patch.dict(resp.headers, {"Content-Encoding": ""}):
+        "content": httpx_response.content,
-        if aread:
-            await resp.aread()
-        else:
-            resp.read()
-
-    result = {
-        "status": {"code": resp.status_code, "message": resp.reason_phrase},
-        "headers": _transform_headers(resp),
-        "body": {"string": resp.content},
     }
 
-    # As the content wasn't decoded, we restore the response to a state which
-    # will be capable of decoding the content for the consumer.
-    del resp._decoder
-    resp._content = resp._get_content_decoder().decode(resp.content)
-    return result
-
 
 def _from_serialized_headers(headers):
     """
@@ -75,32 +57,15 @@ def _from_serialized_headers(headers):
 @patch("httpx.Response.close", MagicMock())
 @patch("httpx.Response.read", MagicMock())
 def _from_serialized_response(request, serialized_response, history=None):
-    # Cassette format generated for HTTPX requests by older versions of
+    content = serialized_response.get("content")
-    # vcrpy. We restructure the content to resemble what a regular
-    # cassette looks like.
-    if "status_code" in serialized_response:
-        serialized_response = decode_response(
-            convert_body_to_bytes(
-                {
-                    "headers": serialized_response["headers"],
-                    "body": {"string": serialized_response["content"]},
-                    "status": {"code": serialized_response["status_code"]},
-                },
-            ),
-        )
-        extensions = None
-    else:
-        extensions = {"reason_phrase": serialized_response["status"]["message"].encode()}
-
     response = httpx.Response(
-        status_code=serialized_response["status"]["code"],
+        status_code=serialized_response.get("status_code"),
         request=request,
-        headers=_from_serialized_headers(serialized_response["headers"]),
+        headers=_from_serialized_headers(serialized_response.get("headers")),
-        content=serialized_response["body"]["string"],
+        content=content,
         history=history or [],
-        extensions=extensions,
     )
-
+    response._content = content
     return response
 
 
@@ -126,17 +91,17 @@ def _shared_vcr_send(cassette, real_send, *args, **kwargs):
     return vcr_request, None
 
 
-async def _record_responses(cassette, vcr_request, real_response, aread):
+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, await _to_serialized_response(past_real_response, aread))
+        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, await _to_serialized_response(real_response, aread))
+    cassette.append(vcr_request, _to_serialized_response(real_response))
     return real_response
 
 
@@ -154,8 +119,8 @@ async def _async_vcr_send(cassette, real_send, *args, **kwargs):
         return response
 
     real_response = await real_send(*args, **kwargs)
-    await _record_responses(cassette, vcr_request, real_response, aread=True)
+    await real_response.aread()
-    return real_response
+    return _record_responses(cassette, vcr_request, real_response)
 
 
 def async_vcr_send(cassette, real_send):
@@ -174,8 +139,8 @@ def _sync_vcr_send(cassette, real_send, *args, **kwargs):
         return response
 
     real_response = real_send(*args, **kwargs)
-    asyncio.run(_record_responses(cassette, vcr_request, real_response, aread=False))
+    real_response.read()
-    return real_response
+    return _record_responses(cassette, vcr_request, real_response)
 
 
 def sync_vcr_send(cassette, real_send):

vcr/stubs/tornado_stubs.py

@@ -1,5 +1,4 @@
 """Stubs for tornado HTTP clients"""
-
 import functools
 from io import BytesIO
 

vcr/util.py

@@ -89,28 +89,9 @@ def compose(*functions):
     return composed
 
 
-def _is_nonsequence_iterator(obj):
-    return hasattr(obj, "__iter__") and not isinstance(
-        obj,
-        (bytearray, bytes, dict, list, str),
-    )
-
-
 def read_body(request):
     if hasattr(request.body, "read"):
         return request.body.read()
-    if _is_nonsequence_iterator(request.body):
-        body = list(request.body)
-        if body:
-            if isinstance(body[0], str):
-                return "".join(body).encode("utf-8")
-            elif isinstance(body[0], (bytes, bytearray)):
-                return b"".join(body)
-            elif isinstance(body[0], int):
-                return bytes(body)
-            else:
-                raise ValueError(f"Body type {type(body[0])} not supported")
-        return b""
     return request.body