Version 1.3.0.

update urllib3 patch/stub to be same as used for requests and add tests

.travis.yml

@@ -8,9 +8,13 @@ env:
     - WITH_LIB="requests2.2"
     - WITH_LIB="requests2.3"
     - WITH_LIB="requests2.4"
+    - WITH_LIB="requests2.5"
     - WITH_LIB="requests1.x"
     - WITH_LIB="httplib2"
     - WITH_LIB="boto"
+    - WITH_LIB="urllib31.7"
+    - WITH_LIB="urllib31.9"
+    - WITH_LIB="urllib31.10"
 matrix:
   allow_failures:
     - env: WITH_LIB="boto"
@@ -33,6 +37,10 @@ install:
 - if [ $WITH_LIB = "requests2.2" ] ; then pip install requests==2.2.1; fi
 - if [ $WITH_LIB = "requests2.3" ] ; then pip install requests==2.3.0; fi
 - if [ $WITH_LIB = "requests2.4" ] ; then pip install requests==2.4.0; fi
+- if [ $WITH_LIB = "requests2.5" ] ; then pip install requests==2.5.0; fi
 - if [ $WITH_LIB = "httplib2" ] ; then pip install httplib2; fi
 - if [ $WITH_LIB = "boto" ] ; then pip install boto; fi
+- if [ $WITH_LIB = "urllib31.7" ] ; then pip install certifi urllib3==1.7.1; fi
+- if [ $WITH_LIB = "urllib31.9" ] ; then pip install certifi urllib3==1.9.1; fi
+- if [ $WITH_LIB = "urllib31.10" ] ; then pip install certifi urllib3==1.10.2; fi
 script: python setup.py test

README.md

@@ -336,7 +336,7 @@ argument. It's usage is similar to that of `before_record`:
 ```python
 def scrub_string(string, replacement=''):
     def before_record_reponse(response):
-        return response['body']['string] = response['body']['string].replace(string, replacement)
+        return response['body']['string'] = response['body']['string'].replace(string, replacement)
     return scrub_string
 
 my_vcr = vcr.VCR(
@@ -362,6 +362,23 @@ back from a cassette.  VCR will completely ignore those requests as if it
 didn't notice them at all, and they will continue to hit the server as if VCR
 were not there.
 
+## Custom Patches
+
+If you use a custom `HTTPConnection` class, or otherwise make http
+requests in a way that requires additional patching, you can use the
+`custom_patches` keyword argument of the `VCR` and `Cassette` objects
+to patch those objects whenever a cassette's context is entered. To
+patch a custom version of `HTTPConnection` you can do something like
+this:
+
+```
+import where_the_custom_https_connection_lives
+from vcr.stubs import VCRHTTPSConnection
+my_vcr = config.VCR(custom_patches=((where_the_custom_https_connection_lives, 'CustomHTTPSConnection', VCRHTTPSConnection),))
+
+@my_vcr.use_cassette(...)
+```
+
 ## Installation
 
 VCR.py is a package on PyPI, so you can `pip install vcrpy` (first you may need
@@ -457,6 +474,21 @@ API in version 1.0.x
 
 
 ## Changelog
+  * 1.3.0 Fix/add support for urllib3 (thanks @aisch), fix default
+    port for https (thanks @abhinav).
+  * 1.2.0 Add custom_patches argument to VCR/Cassette objects to allow
+    users to stub custom classes when cassettes become active.
+  * 1.1.4 Add force reset around calls to actual connection from stubs, to ensure
+    compatibility with the version of httplib/urlib2 in python 2.7.9.
+  * 1.1.3 Fix python3 headers field (thanks @rtaboada), fix boto test (thanks
+    @telaviv), fix new_episodes record mode (thanks @jashugan), fix Windows
+    connectionpool stub bug (thanks @gazpachoking), add support for requests 2.5
+  * 1.1.2 Add urllib==1.7.1 support. Make json serialize error handling correct
+    Improve logging of match failures.
+  * 1.1.1 Use function signature preserving `wrapt.decorator` to write the
+    decorator version of use_cassette in order to ensure compatibility with
+    py.test fixtures and python 2. Move all request filtering into the
+    `before_record_callable`.
   * 1.1.0 Add `before_record_response`. Fix several bugs related to the context
     management of cassettes.
   * 1.0.3: Fix an issue with requests 2.4 and make sure case sensitivity is

setup.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+##!/usr/bin/env python
 
 import sys
 from setuptools import setup
@@ -20,7 +20,7 @@ class PyTest(TestCommand):
 
 setup(
     name='vcrpy',
-    version='1.1.0',
+    version='1.3.0',
     description=(
         "Automatically mock your HTTP interactions to simplify and "
         "speed up testing"
@@ -41,7 +41,7 @@ setup(
         'vcr.compat': 'vcr/compat',
         'vcr.persisters': 'vcr/persisters',
         },
-    install_requires=['PyYAML', 'mock', 'six', 'contextlib2'],
+    install_requires=['PyYAML', 'mock', 'six', 'contextlib2', 'wrapt'],
     license='MIT',
     tests_require=['pytest', 'mock', 'pytest-localserver'],
     cmdclass={'test': PyTest},

tests/integration/test_basic.py

@@ -1,5 +1,5 @@
-'''Basic tests about cassettes'''
-# coding=utf-8
+# -*- coding: utf-8 -*-
+'''Basic tests for cassettes'''
 
 # External imports
 import os

tests/integration/test_boto.py

@@ -14,7 +14,7 @@ def test_boto_stubs(tmpdir):
         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.
-        assert CertValidatingHTTPSConnection is VCRCertValidatingHTTPSConnection
+        assert issubclass(CertValidatingHTTPSConnection, VCRCertValidatingHTTPSConnection)
         CertValidatingHTTPSConnection('hostname.does.not.matter')
 
 def test_boto_without_vcr():

tests/integration/test_disksaver.py

@@ -1,5 +1,5 @@
+# -*- coding: utf-8 -*-
 '''Basic tests about save behavior'''
-# coding=utf-8
 
 # External imports
 import os

tests/integration/test_filter.py

@@ -54,15 +54,20 @@ def test_filter_querystring(tmpdir):
         urlopen(url)
         assert 'foo' not in cass.requests[0].url
 
+
 def test_filter_callback(tmpdir):
     url = 'http://httpbin.org/get'
     cass_file = str(tmpdir.join('basic_auth_filter.yaml'))
     def before_record_cb(request):
         if request.path != '/get':
             return request
-    my_vcr = vcr.VCR(
-        before_record = before_record_cb,
-    )
+    # Test the legacy keyword.
+    my_vcr = vcr.VCR(before_record=before_record_cb)
+    with my_vcr.use_cassette(cass_file, filter_headers=['authorization']) as cass:
+        urlopen(url)
+        assert len(cass) == 0
+
+    my_vcr = vcr.VCR(before_record_request=before_record_cb)
     with my_vcr.use_cassette(cass_file, filter_headers=['authorization']) as cass:
         urlopen(url)
         assert len(cass) == 0

tests/integration/test_httplib2.py

@@ -1,5 +1,5 @@
+# -*- coding: utf-8 -*-
 '''Integration tests with httplib2'''
-# coding=utf-8
 
 # External imports
 from six.moves.urllib_parse import urlencode
@@ -54,7 +54,7 @@ def test_response_headers(scheme, tmpdir):
 
     with vcr.use_cassette(str(tmpdir.join('headers.yaml'))) as cass:
         resp, _ = httplib2.Http().request(url)
-        assert headers == resp.items()
+        assert set(headers) == set(resp.items())
 
 
 def test_multiple_requests(scheme, tmpdir):

tests/integration/test_record_mode.py

@@ -72,6 +72,31 @@ def test_new_episodes_record_mode(tmpdir):
         assert len(cass.responses) == 2
 
 
+def test_new_episodes_record_mode_two_times(tmpdir):
+    testfile = str(tmpdir.join('recordmode.yml'))
+    url = 'http://httpbin.org/bytes/1024'
+    with vcr.use_cassette(testfile, record_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"):
+        # make the same request again
+        assert urlopen(url).read() == original_first_response
+
+        # in the "new_episodes" record mode, we can add the same request
+        # to the cassette without repercussions
+        original_second_response = urlopen(url).read()
+
+    with vcr.use_cassette(testfile, record_mode="once"):
+        # make the same request again
+        assert urlopen(url).read() == original_first_response
+        assert urlopen(url).read() == original_second_response
+        # now that we are back in once mode, this should raise
+        # an error.
+        with pytest.raises(Exception):
+            urlopen(url).read()
+
+
 def test_all_record_mode(tmpdir):
     testfile = str(tmpdir.join('recordmode.yml'))
 

tests/integration/test_requests.py

@@ -1,23 +1,17 @@
+# -*- coding: utf-8 -*-
 '''Test requests' interaction with vcr'''
 
-# coding=utf-8
-
-import os
 import pytest
 import vcr
-from assertions import (
-    assert_cassette_empty,
-    assert_cassette_has_one_response,
-    assert_is_json
-)
+from assertions import assert_cassette_empty, assert_is_json
+
+
 requests = pytest.importorskip("requests")
 
 
 @pytest.fixture(params=["https", "http"])
 def scheme(request):
-    """
-    Fixture that returns both http and https
-    """
+    '''Fixture that returns both http and https.'''
     return request.param
 
 

tests/integration/test_urllib2.py

@@ -1,8 +1,5 @@
+# -*- coding: utf-8 -*-
 '''Integration tests with urllib2'''
-# coding=utf-8
-
-# External imports
-import os
 
 import pytest
 from six.moves.urllib.request import urlopen
@@ -11,7 +8,7 @@ from six.moves.urllib_parse import urlencode
 # Internal imports
 import vcr
 
-from assertions import assert_cassette_empty, assert_cassette_has_one_response
+from assertions import assert_cassette_has_one_response
 
 
 @pytest.fixture(params=["https", "http"])

tests/integration/test_urllib3.py

@@ -0,0 +1,148 @@
+'''Integration tests with urllib3'''
+
+# coding=utf-8
+
+import pytest
+import vcr
+from assertions import assert_cassette_empty, assert_is_json
+certifi = pytest.importorskip("certifi")
+urllib3 = pytest.importorskip("urllib3")
+
+
+@pytest.fixture(params=["https", "http"])
+def scheme(request):
+    """
+    Fixture that returns both http and https
+    """
+    return request.param
+
+
+@pytest.fixture(scope='module')
+def verify_pool_mgr():
+    return urllib3.PoolManager(
+        cert_reqs='CERT_REQUIRED', # Force certificate check.
+        ca_certs=certifi.where()
+    )
+
+
+@pytest.fixture(scope='module')
+def pool_mgr():
+    return urllib3.PoolManager()
+
+
+def test_status_code(scheme, tmpdir, verify_pool_mgr):
+    '''Ensure that we can read the status code'''
+    url = scheme + '://httpbin.org/'
+    with vcr.use_cassette(str(tmpdir.join('atts.yaml'))):
+        status_code = verify_pool_mgr.request('GET', url).status
+
+    with vcr.use_cassette(str(tmpdir.join('atts.yaml'))):
+        assert status_code == verify_pool_mgr.request('GET', url).status
+
+
+def test_headers(scheme, tmpdir, verify_pool_mgr):
+    '''Ensure that we can read the headers back'''
+    url = scheme + '://httpbin.org/'
+    with vcr.use_cassette(str(tmpdir.join('headers.yaml'))):
+        headers = verify_pool_mgr.request('GET', url).headers
+
+    with vcr.use_cassette(str(tmpdir.join('headers.yaml'))):
+        assert headers == verify_pool_mgr.request('GET', url).headers
+
+
+def test_body(tmpdir, scheme, verify_pool_mgr):
+    '''Ensure the responses are all identical enough'''
+    url = scheme + '://httpbin.org/bytes/1024'
+    with vcr.use_cassette(str(tmpdir.join('body.yaml'))):
+        content = verify_pool_mgr.request('GET', url).data
+
+    with vcr.use_cassette(str(tmpdir.join('body.yaml'))):
+        assert content == verify_pool_mgr.request('GET', url).data
+
+
+def test_auth(tmpdir, scheme, verify_pool_mgr):
+    '''Ensure that we can handle basic auth'''
+    auth = ('user', 'passwd')
+    headers = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(*auth))
+    url = scheme + '://httpbin.org/basic-auth/user/passwd'
+    with vcr.use_cassette(str(tmpdir.join('auth.yaml'))):
+        one = verify_pool_mgr.request('GET', url, headers=headers)
+
+    with vcr.use_cassette(str(tmpdir.join('auth.yaml'))):
+        two = verify_pool_mgr.request('GET', url, headers=headers)
+        assert one.data == two.data
+        assert one.status == two.status
+
+
+def test_auth_failed(tmpdir, scheme, verify_pool_mgr):
+    '''Ensure that we can save failed auth statuses'''
+    auth = ('user', 'wrongwrongwrong')
+    headers = urllib3.util.make_headers(basic_auth='{0}:{1}'.format(*auth))
+    url = scheme + '://httpbin.org/basic-auth/user/passwd'
+    with vcr.use_cassette(str(tmpdir.join('auth-failed.yaml'))) as cass:
+        # Ensure that this is empty to begin with
+        assert_cassette_empty(cass)
+        one = verify_pool_mgr.request('GET', url, headers=headers)
+        two = verify_pool_mgr.request('GET', url, headers=headers)
+        assert one.data == two.data
+        assert one.status == two.status == 401
+
+
+def test_post(tmpdir, scheme, verify_pool_mgr):
+    '''Ensure that we can post and cache the results'''
+    data = {'key1': 'value1', 'key2': 'value2'}
+    url = scheme + '://httpbin.org/post'
+    with vcr.use_cassette(str(tmpdir.join('verify_pool_mgr.yaml'))):
+        req1 = verify_pool_mgr.request('POST', url, data).data
+
+    with vcr.use_cassette(str(tmpdir.join('verify_pool_mgr.yaml'))):
+        req2 = verify_pool_mgr.request('POST', url, data).data
+
+    assert req1 == req2
+
+
+def test_redirects(tmpdir, scheme, verify_pool_mgr):
+    '''Ensure that we can handle redirects'''
+    url = scheme + '://httpbin.org/redirect-to?url=bytes/1024'
+    with vcr.use_cassette(str(tmpdir.join('verify_pool_mgr.yaml'))):
+        content = verify_pool_mgr.request('GET', url).data
+
+    with vcr.use_cassette(str(tmpdir.join('verify_pool_mgr.yaml'))) as cass:
+        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
+
+
+def test_cross_scheme(tmpdir, scheme, verify_pool_mgr):
+    '''Ensure that requests between schemes are treated separately'''
+    # First fetch a url under http, and then again under https and then
+    # ensure that we haven't served anything out of cache, and we have two
+    # requests / response pairs in the cassette
+    with vcr.use_cassette(str(tmpdir.join('cross_scheme.yaml'))) as cass:
+        verify_pool_mgr.request('GET', 'https://httpbin.org/')
+        verify_pool_mgr.request('GET', 'http://httpbin.org/')
+        assert cass.play_count == 0
+        assert len(cass) == 2
+
+
+def test_gzip(tmpdir, scheme, verify_pool_mgr):
+    '''
+    Ensure that requests (actually urllib3) is able to automatically decompress
+    the response body
+    '''
+    url = scheme + '://httpbin.org/gzip'
+    response = verify_pool_mgr.request('GET', url)
+
+    with vcr.use_cassette(str(tmpdir.join('gzip.yaml'))):
+        response = verify_pool_mgr.request('GET', url)
+        assert_is_json(response.data)
+
+    with vcr.use_cassette(str(tmpdir.join('gzip.yaml'))):
+        assert_is_json(response.data)
+
+
+def test_https_with_cert_validation_disabled(tmpdir, pool_mgr):
+    with vcr.use_cassette(str(tmpdir.join('cert_validation_disabled.yaml'))):
+        pool_mgr.request('GET', 'https://httpbin.org')

tests/unit/test_cassettes.py

@@ -7,8 +7,10 @@ import pytest
 import yaml
 
 from vcr.cassette import Cassette
-from vcr.patch import force_reset
 from vcr.errors import UnhandledHTTPRequestError
+from vcr.patch import force_reset
+from vcr.stubs import VCRHTTPSConnection
+
 
 
 def test_cassette_load(tmpdir):
@@ -181,3 +183,21 @@ def test_nesting_context_managers_by_checking_references_of_http_connection():
                     assert httplib.HTTPConnection is original
             assert httplib.HTTPConnection is second_cassette_HTTPConnection
         assert httplib.HTTPConnection is first_cassette_HTTPConnection
+
+
+def test_custom_patchers():
+    class Test(object):
+        attribute = None
+    with Cassette.use('custom_patches', custom_patches=((Test, 'attribute', VCRHTTPSConnection),)):
+        assert issubclass(Test.attribute, VCRHTTPSConnection)
+        assert VCRHTTPSConnection is not Test.attribute
+        old_attribute = Test.attribute
+
+        with Cassette.use('custom_patches', custom_patches=((Test, 'attribute', VCRHTTPSConnection),)):
+            assert issubclass(Test.attribute, VCRHTTPSConnection)
+            assert VCRHTTPSConnection is not Test.attribute
+            assert  Test.attribute is not old_attribute
+
+        assert issubclass(Test.attribute, VCRHTTPSConnection)
+        assert VCRHTTPSConnection is not Test.attribute
+        assert  Test.attribute is old_attribute

tests/unit/test_filters.py

@@ -1,37 +1,37 @@
-from vcr.filters import _remove_headers, _remove_query_parameters
+from vcr.filters import remove_headers, remove_query_parameters
 from vcr.request import Request
 
 
 def test_remove_headers():
     headers = {'hello': ['goodbye'], 'secret': ['header']}
     request = Request('GET', 'http://google.com', '', headers)
-    _remove_headers(request, ['secret'])
+    remove_headers(request, ['secret'])
     assert request.headers == {'hello': 'goodbye'}
 
 
 def test_remove_headers_empty():
     headers = {'hello': 'goodbye', 'secret': 'header'}
     request = Request('GET', 'http://google.com', '', headers)
-    _remove_headers(request, [])
+    remove_headers(request, [])
     assert request.headers == headers
 
 
 def test_remove_query_parameters():
     uri = 'http://g.com/?q=cowboys&w=1'
     request = Request('GET', uri, '', {})
-    _remove_query_parameters(request, ['w'])
+    remove_query_parameters(request, ['w'])
     assert request.uri == 'http://g.com/?q=cowboys'
 
 
 def test_remove_all_query_parameters():
     uri = 'http://g.com/?q=cowboys&w=1'
     request = Request('GET', uri, '', {})
-    _remove_query_parameters(request, ['w', 'q'])
+    remove_query_parameters(request, ['w', 'q'])
     assert request.uri == 'http://g.com/'
 
 
 def test_remove_nonexistent_query_parameters():
     uri = 'http://g.com/'
     request = Request('GET', uri, '', {})
-    _remove_query_parameters(request, ['w', 'q'])
+    remove_query_parameters(request, ['w', 'q'])
     assert request.uri == 'http://g.com/'

tests/unit/test_request.py

@@ -21,8 +21,8 @@ def test_headers():
     ('http://go.com/', 80),
     ('http://go.com:80/', 80),
     ('http://go.com:3000/', 3000),
-    ('https://go.com/', 433),
-    ('https://go.com:433/', 433),
+    ('https://go.com/', 443),
+    ('https://go.com:443/', 443),
     ('https://go.com:3000/', 3000),
     ])
 def test_port(uri, expected_port):

tests/unit/test_response.py

@@ -0,0 +1,68 @@
+# coding: UTF-8
+from vcr.stubs import VCRHTTPResponse
+
+
+def test_response_should_have_headers_field():
+    recorded_response = {
+        "status": {
+            "message": "OK",
+            "code": 200
+        },
+        "headers": {
+            "content-length": ["0"],
+            "server": ["gunicorn/18.0"],
+            "connection": ["Close"],
+            "access-control-allow-credentials": ["true"],
+            "date": ["Fri, 24 Oct 2014 18:35:37 GMT"],
+            "access-control-allow-origin": ["*"],
+            "content-type": ["text/html; charset=utf-8"],
+        },
+        "body": {
+            "string": b""
+        }
+    }
+    response = VCRHTTPResponse(recorded_response)
+
+    assert response.headers is not None
+
+
+def test_response_headers_should_be_equal_to_msg():
+    recorded_response = {
+        "status": {
+            "message": b"OK",
+            "code": 200
+        },
+        "headers": {
+            "content-length": ["0"],
+            "server": ["gunicorn/18.0"],
+            "connection": ["Close"],
+            "content-type": ["text/html; charset=utf-8"],
+        },
+        "body": {
+            "string": b""
+        }
+    }
+    response = VCRHTTPResponse(recorded_response)
+
+    assert response.headers == response.msg
+
+
+def test_response_headers_should_have_correct_values():
+    recorded_response = {
+        "status": {
+            "message": "OK",
+            "code": 200
+        },
+        "headers": {
+            "content-length": ["10806"],
+            "date": ["Fri, 24 Oct 2014 18:35:37 GMT"],
+            "content-type": ["text/html; charset=utf-8"],
+        },
+        "body": {
+            "string": b""
+        }
+    }
+    response = VCRHTTPResponse(recorded_response)
+
+    assert response.headers.get('content-length') == "10806"
+    assert response.headers.get('date') == "Fri, 24 Oct 2014 18:35:37 GMT"

tests/unit/test_serialize.py

@@ -1,21 +1,35 @@
+import mock
 import pytest
+
 from vcr.serialize import deserialize
 from vcr.serializers import yamlserializer, jsonserializer
 
+
 def test_deserialize_old_yaml_cassette():
     with open('tests/fixtures/migration/old_cassette.yaml', 'r') as f:
         with pytest.raises(ValueError):
             deserialize(f.read(), yamlserializer)
 
+
 def test_deserialize_old_json_cassette():
     with open('tests/fixtures/migration/old_cassette.json', 'r') as f:
         with pytest.raises(ValueError):
             deserialize(f.read(), jsonserializer)
 
+
 def test_deserialize_new_yaml_cassette():
     with open('tests/fixtures/migration/new_cassette.yaml', 'r') as f:
         deserialize(f.read(), yamlserializer)
 
+
 def test_deserialize_new_json_cassette():
     with open('tests/fixtures/migration/new_cassette.json', 'r') as f:
         deserialize(f.read(), jsonserializer)
+
+
+@mock.patch.object(jsonserializer.json, 'dumps',
+                   side_effect=UnicodeDecodeError('utf-8', b'unicode error in serialization',
+                                                  0, 10, 'blew up'))
+def test_serialize_constructs_UnicodeDecodeError(mock_dumps):
+    with pytest.raises(UnicodeDecodeError):
+        jsonserializer.serialize({})

tests/unit/test_vcr.py

@@ -1,28 +1,92 @@
 import mock
+import pytest
 
-from vcr import VCR
+from vcr import VCR, use_cassette
+from vcr.request import Request
+from vcr.stubs import VCRHTTPSConnection
 
 
 def test_vcr_use_cassette():
-    filter_headers = mock.Mock()
-    test_vcr = VCR(filter_headers=filter_headers)
+    record_mode = mock.Mock()
+    test_vcr = VCR(record_mode=record_mode)
     with mock.patch('vcr.cassette.Cassette.load') as mock_cassette_load:
         @test_vcr.use_cassette('test')
         def function():
             pass
         assert mock_cassette_load.call_count == 0
         function()
-        assert mock_cassette_load.call_args[1]['filter_headers'] is filter_headers
+        assert mock_cassette_load.call_args[1]['record_mode'] is record_mode
 
         # Make sure that calls to function now use cassettes with the
         # new filter_header_settings
-        test_vcr.filter_headers = ('a',)
+        test_vcr.record_mode = mock.Mock()
         function()
-        assert mock_cassette_load.call_args[1]['filter_headers'] == test_vcr.filter_headers
+        assert mock_cassette_load.call_args[1]['record_mode'] == test_vcr.record_mode
 
         # Ensure that explicitly provided arguments still supercede
         # those on the vcr.
-        new_filter_headers = mock.Mock()
+        new_record_mode = mock.Mock()
 
-    with test_vcr.use_cassette('test', filter_headers=new_filter_headers) as cassette:
-        assert cassette._filter_headers == new_filter_headers
+    with test_vcr.use_cassette('test', record_mode=new_record_mode) as cassette:
+        assert cassette.record_mode == new_record_mode
+
+
+def test_vcr_before_record_request_params():
+    base_path = 'http://httpbin.org/'
+    def before_record_cb(request):
+        if request.path != '/get':
+            return request
+    test_vcr = VCR(filter_headers=('cookie',), before_record_request=before_record_cb,
+                   ignore_hosts=('www.test.com',), ignore_localhost=True,
+                   filter_query_parameters=('foo',))
+
+    with test_vcr.use_cassette('test') as cassette:
+        assert cassette.filter_request(Request('GET', base_path + 'get', '', {})) is None
+        assert cassette.filter_request(Request('GET', base_path + 'get2', '', {})) is not None
+
+        assert cassette.filter_request(Request('GET', base_path + '?foo=bar', '', {})).query == []
+        assert cassette.filter_request(
+            Request('GET', base_path + '?foo=bar', '',
+                    {'cookie': 'test', 'other': 'fun'})).headers == {'other': 'fun'}
+        assert cassette.filter_request(Request('GET', base_path + '?foo=bar', '',
+                                               {'cookie': 'test', 'other': 'fun'})).headers == {'other': 'fun'}
+
+        assert cassette.filter_request(Request('GET', 'http://www.test.com' + '?foo=bar', '',
+                                               {'cookie': 'test', 'other': 'fun'})) is None
+
+    with test_vcr.use_cassette('test', before_record_request=None) as cassette:
+        # Test that before_record can be overwritten with
+        assert cassette.filter_request(Request('GET', base_path + 'get', '', {})) is not None
+
+
+@pytest.fixture
+def random_fixture():
+    return 1
+
+
+@use_cassette('test')
+def test_fixtures_with_use_cassette(random_fixture):
+    # Applying a decorator to a test function that requests features can cause
+    # problems if the decorator does not preserve the signature of the original
+    # test function.
+
+    # This test ensures that use_cassette preserves the signature of the original
+    # test function, and thus that use_cassette is compatible with py.test
+    # fixtures. It is admittedly a bit strange because the test would never even
+    # run if the relevant feature were broken.
+    pass
+
+
+def test_custom_patchers():
+    class Test(object):
+        attribute = None
+        attribute2 = None
+    test_vcr = VCR(custom_patches=((Test, 'attribute', VCRHTTPSConnection),))
+    with test_vcr.use_cassette('custom_patches'):
+        assert issubclass(Test.attribute, VCRHTTPSConnection)
+        assert VCRHTTPSConnection is not Test.attribute
+
+    with test_vcr.use_cassette('custom_patches', custom_patches=((Test, 'attribute2', VCRHTTPSConnection),)):
+        assert issubclass(Test.attribute, VCRHTTPSConnection)
+        assert VCRHTTPSConnection is not Test.attribute
+        assert Test.attribute is Test.attribute2

tox.ini

@@ -1,189 +1,27 @@
-# Tox (http://tox.testrun.org/) is a tool for running tests
-# in multiple virtualenvs. This configuration file will run the
-# test suite on all supported python versions. To use it, "pip install tox"
-# and then run "tox" from this directory.
-
 [tox]
-envlist = 
-    py26,
-    py27,
-    py33,
-    py34,
-    pypy,
-    py26requests24,
-    py27requests24,
-    py34requests24,
-    pypyrequests24,
-    py26requests23,
-    py27requests23,
-    py34requests23,
-    pypyrequests23,
-    py26requests22,
-    py27requests22,
-    py34requests22,
-    pypyrequests22,
-    py26requests1,
-    py27requests1,
-    py33requests1,
-    pypyrequests1,
-    py26httplib2,
-    py27httplib2,
-    py33httplib2,
-    py34httplib2,
-    pypyhttplib2,
+envlist = {py26,py27,py33,py34,pypy}-{requests25,requests24,requests23,requests22,requests1,httplib2,urllib3,boto}
 
 [testenv]
 commands =
     py.test {posargs}
+basepython =
+    py26: python2.6
+    py27: python2.7
+    py33: python3.3
+    py34: python3.4
+    pypy: pypy
 deps =
     mock
     pytest
     pytest-localserver
     PyYAML
-    ipdb
-
-[testenv:py26requests1]
-basepython = python2.6
-deps =
-    {[testenv]deps}
-    requests==1.2.3
-
-[testenv:py27requests1]
-basepython = python2.7
-deps =
-    {[testenv]deps}
-    requests==1.2.3
-
-[testenv:py33requests1]
-basepython = python3.3
-deps =
-    {[testenv]deps}
-    requests==1.2.3
-
-[testenv:pypyrequests1]
-basepython = pypy
-deps =
-    {[testenv]deps}
-    requests==1.2.3
-
-[testenv:py26requests24]
-basepython = python2.6
-deps =
-    {[testenv]deps}
-    requests==2.4.0
-
-[testenv:py27requests24]
-basepython = python2.7
-deps =
-    {[testenv]deps}
-    requests==2.4.0
-
-[testenv:py33requests24]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    requests==2.4.0
-
-[testenv:py34requests24]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    requests==2.4.0
-
-[testenv:pypyrequests24]
-basepython = pypy
-deps =
-    {[testenv]deps}
-    requests==2.4.0
-
-
-[testenv:py26requests23]
-basepython = python2.6
-deps =
-    {[testenv]deps}
-    requests==2.3.0
-
-[testenv:py27requests23]
-basepython = python2.7
-deps =
-    {[testenv]deps}
-    requests==2.3.0
-
-[testenv:py33requests23]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    requests==2.3.0
-
-[testenv:py34requests23]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    requests==2.3.0
-
-[testenv:pypyrequests23]
-basepython = pypy
-deps =
-    {[testenv]deps}
-    requests==2.3.0
-
-[testenv:py26requests22]
-basepython = python2.6
-deps =
-    {[testenv]deps}
-    requests==2.2.1
-
-[testenv:py27requests22]
-basepython = python2.7
-deps =
-    {[testenv]deps}
-    requests==2.2.1
-
-[testenv:py33requests22]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    requests==2.2.1
-
-[testenv:py34requests22]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    requests==2.2.1
-    
-
-[testenv:pypyrequests22]
-basepython = pypy
-deps =
-    {[testenv]deps}
-    requests==2.2.1
-
-[testenv:py26httplib2]
-basepython = python2.6
-deps =
-    {[testenv]deps}
-    httplib2
-
-[testenv:py27httplib2]
-basepython = python2.7
-deps =
-    {[testenv]deps}
-    httplib2
-
-[testenv:py33httplib2]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    httplib2
-
-[testenv:py34httplib2]
-basepython = python3.4
-deps =
-    {[testenv]deps}
-    httplib2
-
-[testenv:pypyhttplib2]
-basepython = pypy
-deps =
-    {[testenv]deps}
-    httplib2
+    requests1: requests==1.2.3
+    requests25: requests==2.5.0
+    requests24: requests==2.4.0
+    requests23: requests==2.3.0
+    requests22: requests==2.2.1
+    httplib2: httplib2
+    urllib317: urllib3==1.7.1
+    urllib319: urllib3==1.9.1
+    urllib3110: urllib3==1.10.2
+    boto: boto

vcr/cassette.py

@@ -1,7 +1,8 @@
-'''The container for recorded requests and responses'''
+"""The container for recorded requests and responses"""
 import logging
 
 import contextlib2
+import wrapt
 try:
     from collections import Counter
 except ImportError:
@@ -10,7 +11,6 @@ except ImportError:
 # Internal imports
 from .patch import CassettePatcherBuilder
 from .persist import load_cassette, save_cassette
-from .filters import filter_request
 from .serializers import yamlserializer
 from .matchers import requests_match, uri, method
 from .errors import UnhandledHTTPRequestError
@@ -19,7 +19,7 @@ from .errors import UnhandledHTTPRequestError
 log = logging.getLogger(__name__)
 
 
-class CassetteContextDecorator(contextlib2.ContextDecorator):
+class CassetteContextDecorator(object):
     """Context manager/decorator that handles installing the cassette and
     removing cassettes.
 
@@ -45,11 +45,12 @@ class CassetteContextDecorator(contextlib2.ContextDecorator):
             log.debug('Entered context for cassette at {0}.'.format(cassette._path))
             yield cassette
             log.debug('Exiting context for cassette at {0}.'.format(cassette._path))
-             # TODO(@IvanMalison): Hmmm. it kind of feels like this should be somewhere else.
+            # TODO(@IvanMalison): Hmmm. it kind of feels like this should be
+            # somewhere else.
             cassette._save()
 
     def __enter__(self):
-        assert self.__finish is None
+        assert self.__finish is None, "Cassette already open."
         path, kwargs = self._args_getter()
         self.__finish = self._patch_generator(self.cls.load(path, **kwargs))
         return next(self.__finish)
@@ -58,13 +59,18 @@ class CassetteContextDecorator(contextlib2.ContextDecorator):
         next(self.__finish, None)
         self.__finish = None
 
+    @wrapt.decorator
+    def __call__(self, function, instance, args, kwargs):
+        with self:
+            return function(*args, **kwargs)
+
 
 class Cassette(object):
-    '''A container for recorded requests and responses'''
+    """A container for recorded requests and responses"""
 
     @classmethod
     def load(cls, path, **kwargs):
-        '''Load in the cassette stored at the provided path'''
+        """Instantiate and load the cassette stored at the specified path."""
         new_cassette = cls(path, **kwargs)
         new_cassette._load()
         return new_cassette
@@ -79,20 +85,14 @@ class Cassette(object):
 
     def __init__(self, path, serializer=yamlserializer, record_mode='once',
                  match_on=(uri, method), filter_headers=(),
-                 filter_query_parameters=(), before_record=None, before_record_response=None,
-                 ignore_hosts=(), ignore_localhost=()):
+                 filter_query_parameters=(), before_record_request=None,
+                 before_record_response=None, ignore_hosts=(),
+                 ignore_localhost=(), custom_patches=()):
         self._path = path
         self._serializer = serializer
         self._match_on = match_on
-        self._filter_headers = filter_headers
-        self._filter_query_parameters = filter_query_parameters
-        self._before_record = before_record
-        self._before_record_response = before_record_response
-        self._ignore_hosts = ignore_hosts
-        if ignore_localhost:
-            self._ignore_hosts = list(set(
-                list(self._ignore_hosts) + ['localhost', '0.0.0.0', '127.0.0.1']
-            ))
+        self._before_record_request = before_record_request or (lambda x: x)
+        self._before_record_response = before_record_response or (lambda x: x)
 
         # self.data is the list of (req, resp) tuples
         self.data = []
@@ -100,6 +100,7 @@ class Cassette(object):
         self.dirty = False
         self.rewound = False
         self.record_mode = record_mode
+        self.custom_patches = custom_patches
 
     @property
     def play_count(self):
@@ -107,9 +108,7 @@ class Cassette(object):
 
     @property
     def all_played(self):
-        """
-        Returns True if all responses have been played, False otherwise.
-        """
+        """Returns True if all responses have been played, False otherwise."""
         return self.play_count == len(self)
 
     @property
@@ -125,18 +124,9 @@ class Cassette(object):
         return self.rewound and self.record_mode == 'once' or \
             self.record_mode == 'none'
 
-    def _filter_request(self, request):
-        return filter_request(
-            request=request,
-            filter_headers=self._filter_headers,
-            filter_query_parameters=self._filter_query_parameters,
-            before_record=self._before_record,
-            ignore_hosts=self._ignore_hosts
-        )
-
     def append(self, request, response):
-        '''Add a request, response pair to this cassette'''
-        request = self._filter_request(request)
+        """Add a request, response pair to this cassette"""
+        request = self._before_record_request(request)
         if not request:
             return
         if self._before_record_response:
@@ -144,29 +134,30 @@ class Cassette(object):
         self.data.append((request, response))
         self.dirty = True
 
+    def filter_request(self, request):
+        return self._before_record_request(request)
+
     def _responses(self, request):
         """
         internal API, returns an iterator with all responses matching
         the request.
         """
-        request = self._filter_request(request)
-        if not request:
-            return
+        request = self._before_record_request(request)
         for index, (stored_request, response) in enumerate(self.data):
             if requests_match(request, stored_request, self._match_on):
                 yield index, response
 
     def can_play_response_for(self, request):
-        request = self._filter_request(request)
+        request = self._before_record_request(request)
         return request and request in self and \
             self.record_mode != 'all' and \
             self.rewound
 
     def play_response(self, request):
-        '''
+        """
         Get the response corresponding to a request, but only if it
         hasn't been played back before, and mark it as played
-        '''
+        """
         for index, response in self._responses(request):
             if self.play_counts[index] == 0:
                 self.play_counts[index] += 1
@@ -178,11 +169,11 @@ class Cassette(object):
         )
 
     def responses_of(self, request):
-        '''
+        """
         Find the responses corresponding to a request.
         This function isn't actually used by VCR internally, but is
         provided as an external API.
-        '''
+        """
         responses = [response for index, response in self._responses(request)]
 
         if responses:
@@ -224,11 +215,12 @@ class Cassette(object):
         )
 
     def __len__(self):
-        '''Return the number of request,response pairs stored in here'''
+        """Return the number of request,response pairs stored in here"""
         return len(self.data)
 
     def __contains__(self, request):
-        '''Return whether or not a request has been stored'''
-        for response in self._responses(request):
-            return True
+        """Return whether or not a request has been stored"""
+        for index, response in self._responses(request):
+            if self.play_counts[index] == 0:
+                return True
         return False

vcr/config.py

@@ -1,30 +1,22 @@
+import collections
+import copy
 import functools
 import os
+
 from .cassette import Cassette
 from .serializers import yamlserializer, jsonserializer
 from . import matchers
+from . import filters
 
 
 class VCR(object):
-    def __init__(self,
-                 serializer='yaml',
-                 cassette_library_dir=None,
-                 record_mode="once",
-                 filter_headers=(),
-                 filter_query_parameters=(),
-                 before_record=None,
-                 before_record_response=None,
-                 match_on=(
-                     'method',
-                     'scheme',
-                     'host',
-                     'port',
-                     'path',
-                     'query',
-                 ),
-                 ignore_hosts=(),
-                 ignore_localhost=False,
-                 ):
+
+    def __init__(self, serializer='yaml', cassette_library_dir=None,
+                 record_mode="once", filter_headers=(), custom_patches=(),
+                 filter_query_parameters=(), before_record_request=None,
+                 before_record_response=None, ignore_hosts=(),
+                 match_on=('method', 'scheme', 'host', 'port', 'path', 'query',),
+                 ignore_localhost=False, before_record=None):
         self.serializer = serializer
         self.match_on = match_on
         self.cassette_library_dir = cassette_library_dir
@@ -47,10 +39,11 @@ class VCR(object):
         self.record_mode = record_mode
         self.filter_headers = filter_headers
         self.filter_query_parameters = filter_query_parameters
-        self.before_record = before_record
+        self.before_record_request = before_record_request or before_record
         self.before_record_response = before_record_response
         self.ignore_hosts = ignore_hosts
         self.ignore_localhost = ignore_localhost
+        self._custom_patches = tuple(custom_patches)
 
     def _get_serializer(self, serializer_name):
         try:
@@ -69,12 +62,16 @@ class VCR(object):
                 matchers.append(self.matchers[m])
         except KeyError:
             raise KeyError(
-                "Matcher {0} doesn't exist or isn't registered".format(
-                    m)
+                "Matcher {0} doesn't exist or isn't registered".format(m)
             )
         return matchers
 
-    def use_cassette(self, path, **kwargs):
+    def use_cassette(self, path, with_current_defaults=False, **kwargs):
+        if with_current_defaults:
+            return Cassette.use(path, self.get_path_and_merged_config(path, **kwargs))
+        # This is made a function that evaluates every time a cassette is made so that
+        # changes that are made to this VCR instance that occur AFTER the use_cassette
+        # decorator is applied still affect subsequent calls to the decorated function.
         args_getter = functools.partial(self.get_path_and_merged_config, path, **kwargs)
         return Cassette.use_arg_getter(args_getter)
 
@@ -89,30 +86,88 @@ class VCR(object):
             path = os.path.join(cassette_library_dir, path)
 
         merged_config = {
-            "serializer": self._get_serializer(serializer_name),
-            "match_on": self._get_matchers(matcher_names),
-            "record_mode": kwargs.get('record_mode', self.record_mode),
-            "filter_headers": kwargs.get(
-                'filter_headers', self.filter_headers
-            ),
-            "filter_query_parameters": kwargs.get(
-                'filter_query_parameters', self.filter_query_parameters
-            ),
-            "before_record": kwargs.get(
-                "before_record", self.before_record
-            ),
-            "before_record_response": kwargs.get(
-                "before_record_response", self.before_record_response
-            ),
-            "ignore_hosts": kwargs.get(
-                'ignore_hosts', self.ignore_hosts
-            ),
-            "ignore_localhost": kwargs.get(
-                'ignore_localhost', self.ignore_localhost
-            ),
+            'serializer': self._get_serializer(serializer_name),
+            'match_on': self._get_matchers(matcher_names),
+            'record_mode': kwargs.get('record_mode', self.record_mode),
+            'before_record_request': self._build_before_record_request(kwargs),
+            'before_record_response': self._build_before_record_response(kwargs),
+            'custom_patches': self._custom_patches + kwargs.get('custom_patches', ())
         }
         return path, merged_config
 
+    def _build_before_record_response(self, options):
+        before_record_response = options.get(
+            'before_record_response', self.before_record_response
+        )
+        filter_functions = []
+        if before_record_response and not isinstance(before_record_response,
+                                                     collections.Iterable):
+            before_record_response = (before_record_response,)
+            for function in before_record_response:
+                filter_functions.append(function)
+        def before_record_response(response):
+            for function in filter_functions:
+                if response is None:
+                    break
+                response = function(response)
+            return response
+        return before_record_response
+
+    def _build_before_record_request(self, options):
+        filter_functions = []
+        filter_headers = options.get(
+            'filter_headers', self.filter_headers
+        )
+        filter_query_parameters = options.get(
+            'filter_query_parameters', self.filter_query_parameters
+        )
+        before_record_request = options.get(
+            "before_record_request", options.get("before_record", self.before_record_request)
+        )
+        ignore_hosts = options.get(
+            'ignore_hosts', self.ignore_hosts
+        )
+        ignore_localhost = options.get(
+            'ignore_localhost', self.ignore_localhost
+        )
+        if filter_headers:
+            filter_functions.append(functools.partial(filters.remove_headers,
+                                                      headers_to_remove=filter_headers))
+        if filter_query_parameters:
+            filter_functions.append(functools.partial(filters.remove_query_parameters,
+                                                      query_parameters_to_remove=filter_query_parameters))
+
+        hosts_to_ignore = list(ignore_hosts)
+        if ignore_localhost:
+            hosts_to_ignore.extend(('localhost', '0.0.0.0', '127.0.0.1'))
+
+        if hosts_to_ignore:
+            hosts_to_ignore = set(hosts_to_ignore)
+            filter_functions.append(self._build_ignore_hosts(hosts_to_ignore))
+
+        if before_record_request:
+            if not isinstance(before_record_request, collections.Iterable):
+                before_record_request = (before_record_request,)
+            for function in before_record_request:
+                filter_functions.append(function)
+        def before_record_request(request):
+            request = copy.copy(request)
+            for function in filter_functions:
+                if request is None:
+                    break
+                request = function(request)
+            return request
+
+        return before_record_request
+
+    @staticmethod
+    def _build_ignore_hosts(hosts_to_ignore):
+        def filter_ignored_hosts(request):
+            if hasattr(request, 'host') and request.host in hosts_to_ignore:
+                return
+            return request
+        return filter_ignored_hosts
+
     def register_serializer(self, name, serializer):
         self.serializers[name] = serializer
 

vcr/filters.py

@@ -2,7 +2,7 @@ from six.moves.urllib.parse import urlparse, urlencode, urlunparse
 import copy
 
 
-def _remove_headers(request, headers_to_remove):
+def remove_headers(request, headers_to_remove):
     headers = copy.copy(request.headers)
     headers_to_remove = [h.lower() for h in headers_to_remove]
     keys = [k for k in headers if k.lower() in headers_to_remove]
@@ -13,7 +13,7 @@ def _remove_headers(request, headers_to_remove):
     return request
 
 
-def _remove_query_parameters(request, query_parameters_to_remove):
+def remove_query_parameters(request, query_parameters_to_remove):
     query = request.query
     new_query = [(k, v) for (k, v) in query
                  if k not in query_parameters_to_remove]
@@ -22,22 +22,3 @@ def _remove_query_parameters(request, query_parameters_to_remove):
         uri_parts[4] = urlencode(new_query)
         request.uri = urlunparse(uri_parts)
     return request
-
-
-def filter_request(
-        request,
-        filter_headers,
-        filter_query_parameters,
-        before_record,
-        ignore_hosts
-        ):
-    request = copy.copy(request)  # don't mutate request object
-    if hasattr(request, 'headers') and filter_headers:
-        request = _remove_headers(request, filter_headers)
-    if hasattr(request, 'host') and request.host in ignore_hosts:
-        return None
-    if filter_query_parameters:
-        request = _remove_query_parameters(request, filter_query_parameters)
-    if before_record:
-        request = before_record(request)
-    return request

vcr/matchers.py

@@ -38,16 +38,16 @@ def headers(r1, r2):
     return r1.headers == r2.headers
 
 
-def _log_matches(matches):
+def _log_matches(r1, r2, matches):
     differences = [m for m in matches if not m[0]]
     if differences:
         log.debug(
-            'Requests differ according to the following matchers: ' +
-            str(differences)
+            "Requests {0} and {1} differ according to "
+            "the following matchers: {2}".format(r1, r2, differences)
         )
 
 
 def requests_match(r1, r2, matchers):
     matches = [(m(r1, r2), m) for m in matchers]
-    _log_matches(matches)
+    _log_matches(r1, r2, matches)
     return all([m[0] for m in matches])

vcr/migration.py

@@ -58,7 +58,7 @@ PARTS = [
 def build_uri(**parts):
     port = parts['port']
     scheme = parts['protocol']
-    default_port = {'https': 433, 'http': 80}[scheme]
+    default_port = {'https': 443, 'http': 80}[scheme]
     parts['port'] = ':{0}'.format(port) if port != default_port else ''
     return "{protocol}://{host}{port}{path}".format(**parts)
 

vcr/patch.py

@@ -59,7 +59,9 @@ class CassettePatcherBuilder(object):
     def _build_patchers_from_mock_triples_decorator(function):
         @functools.wraps(function)
         def wrapped(self, *args, **kwargs):
-            return self._build_patchers_from_mock_triples(function(self, *args, **kwargs))
+            return self._build_patchers_from_mock_triples(
+                function(self, *args, **kwargs)
+            )
         return wrapped
 
     def __init__(self, cassette):
@@ -67,9 +69,12 @@ class CassettePatcherBuilder(object):
         self._class_to_cassette_subclass = {}
 
     def build(self):
-        return itertools.chain(self._httplib(), self._requests(),
-                               self._urllib3(), self._httplib2(),
-                               self._boto())
+        return itertools.chain(
+            self._httplib(), self._requests(), self._urllib3(), self._httplib2(),
+            self._boto(), self._build_patchers_from_mock_triples(
+                self._cassette.custom_patches
+            )
+        )
 
     def _build_patchers_from_mock_triples(self, mock_triples):
         for args in mock_triples:
@@ -86,6 +91,23 @@ class CassettePatcherBuilder(object):
                                      replacement_class))
 
     def _recursively_apply_get_cassette_subclass(self, replacement_dict_or_obj):
+        """One of the subtleties of this class is that it does not directly
+        replace HTTPSConnection with `VCRRequestsHTTPSConnection`, but a
+        subclass of the aforementioned class that has the `cassette`
+        class attribute assigned to `self._cassette`. This behavior is
+        necessary to properly support nested cassette contexts.
+
+        This function exists to ensure that we use the same class
+        object (reference) to patch everything that replaces
+        VCRRequestHTTP[S]Connection, but that we can talk about
+        patching them with the raw references instead, and without
+        worrying about exactly where the subclass with the relevant
+        value for `cassette` is first created.
+
+        The function is recursive because it looks in to dictionaries
+        and replaces class values at any depth with the subclass
+        described in the previous paragraph.
+        """
         if isinstance(replacement_dict_or_obj, dict):
             for key, replacement_obj  in replacement_dict_or_obj.items():
                 replacement_obj = self._recursively_apply_get_cassette_subclass(
@@ -122,38 +144,8 @@ class CassettePatcherBuilder(object):
             import requests.packages.urllib3.connectionpool as cpool
         except ImportError:  # pragma: no cover
             return ()
-        from .stubs.requests_stubs import VCRRequestsHTTPConnection, VCRRequestsHTTPSConnection
-        http_connection_remover = ConnectionRemover(
-            self._get_cassette_subclass(VCRRequestsHTTPConnection)
-        )
-        https_connection_remover = ConnectionRemover(
-            self._get_cassette_subclass(VCRRequestsHTTPSConnection)
-        )
-        mock_triples = (
-            (cpool, 'VerifiedHTTPSConnection', VCRRequestsHTTPSConnection),
-            (cpool, 'VerifiedHTTPSConnection', VCRRequestsHTTPSConnection),
-            (cpool, 'HTTPConnection', VCRRequestsHTTPConnection),
-            (cpool, 'HTTPSConnection', VCRRequestsHTTPSConnection),
-            (cpool.HTTPConnectionPool, 'ConnectionCls', VCRRequestsHTTPConnection),
-            (cpool.HTTPSConnectionPool, 'ConnectionCls', VCRRequestsHTTPSConnection),
-        )
-        # These handle making sure that sessions only use the
-        # connections of the appropriate type.
-        mock_triples += ((cpool.HTTPConnectionPool, '_get_conn',
-                          self._patched_get_conn(cpool.HTTPConnectionPool,
-                                                 lambda : cpool.HTTPConnection)),
-                         (cpool.HTTPSConnectionPool, '_get_conn',
-                          self._patched_get_conn(cpool.HTTPSConnectionPool,
-                                                 lambda : cpool.HTTPSConnection)),
-                         (cpool.HTTPConnectionPool, '_new_conn',
-                          self._patched_new_conn(cpool.HTTPConnectionPool,
-                                                 http_connection_remover)),
-                         (cpool.HTTPSConnectionPool, '_new_conn',
-                          self._patched_new_conn(cpool.HTTPSConnectionPool,
-                                                 https_connection_remover)))
-
-        return itertools.chain(self._build_patchers_from_mock_triples(mock_triples),
-                               (http_connection_remover, https_connection_remover))
+        from .stubs import requests_stubs
+        return self._urllib3_patchers(cpool, requests_stubs)
 
     def _patched_get_conn(self, connection_pool_class, connection_class_getter):
         get_conn = connection_pool_class._get_conn
@@ -162,6 +154,12 @@ class CassettePatcherBuilder(object):
             connection = get_conn(pool, timeout)
             connection_class = pool.ConnectionCls if hasattr(pool, 'ConnectionCls') \
                                else connection_class_getter()
+            # We need to make sure that we are actually providing a
+            # patched version of the connection class. This might not
+            # always be the case because the pool keeps previously
+            # used connections (which might actually be of a different
+            # class) around. This while loop will terminate because
+            # eventually the pool will run out of connections.
             while not isinstance(connection, connection_class):
                 connection = get_conn(pool, timeout)
             return connection
@@ -176,17 +174,13 @@ class CassettePatcherBuilder(object):
             return new_connection
         return patched_new_conn
 
-    @_build_patchers_from_mock_triples_decorator
     def _urllib3(self):
         try:
             import urllib3.connectionpool as cpool
         except ImportError:  # pragma: no cover
-            pass
-        else:
-            from .stubs.urllib3_stubs import VCRVerifiedHTTPSConnection
-
-            yield cpool, 'VerifiedHTTPSConnection', VCRVerifiedHTTPSConnection
-            yield cpool, 'HTTPConnection', VCRHTTPConnection
+            return ()
+        from .stubs import urllib3_stubs
+        return self._urllib3_patchers(cpool, urllib3_stubs)
 
     @_build_patchers_from_mock_triples_decorator
     def _httplib2(self):
@@ -212,6 +206,40 @@ class CassettePatcherBuilder(object):
         else:
             from .stubs.boto_stubs import VCRCertValidatingHTTPSConnection
             yield cpool, 'CertValidatingHTTPSConnection', VCRCertValidatingHTTPSConnection
+            
+    def _urllib3_patchers(self, cpool, stubs):
+        http_connection_remover = ConnectionRemover(
+            self._get_cassette_subclass(stubs.VCRRequestsHTTPConnection)
+        )
+        https_connection_remover = ConnectionRemover(
+            self._get_cassette_subclass(stubs.VCRRequestsHTTPSConnection)
+        )
+        mock_triples = (
+            (cpool, 'VerifiedHTTPSConnection', stubs.VCRRequestsHTTPSConnection),
+            (cpool, 'VerifiedHTTPSConnection', stubs.VCRRequestsHTTPSConnection),
+            (cpool, 'HTTPConnection', stubs.VCRRequestsHTTPConnection),
+            (cpool, 'HTTPSConnection', stubs.VCRRequestsHTTPSConnection),
+            (cpool, 'is_connection_dropped', mock.Mock(return_value=False)),  # Needed on Windows only
+            (cpool.HTTPConnectionPool, 'ConnectionCls', stubs.VCRRequestsHTTPConnection),
+            (cpool.HTTPSConnectionPool, 'ConnectionCls', stubs.VCRRequestsHTTPSConnection),
+        )
+        # These handle making sure that sessions only use the
+        # connections of the appropriate type.
+        mock_triples += ((cpool.HTTPConnectionPool, '_get_conn',
+                          self._patched_get_conn(cpool.HTTPConnectionPool,
+                                                 lambda : cpool.HTTPConnection)),
+                         (cpool.HTTPSConnectionPool, '_get_conn',
+                          self._patched_get_conn(cpool.HTTPSConnectionPool,
+                                                 lambda : cpool.HTTPSConnection)),
+                         (cpool.HTTPConnectionPool, '_new_conn',
+                          self._patched_new_conn(cpool.HTTPConnectionPool,
+                                                 http_connection_remover)),
+                         (cpool.HTTPSConnectionPool, '_new_conn',
+                          self._patched_new_conn(cpool.HTTPSConnectionPool,
+                                                 https_connection_remover)))
+
+        return itertools.chain(self._build_patchers_from_mock_triples(mock_triples),
+                               (http_connection_remover, https_connection_remover))
 
 
 class ConnectionRemover(object):
@@ -234,7 +262,7 @@ class ConnectionRemover(object):
     def __exit__(self, *args):
         for pool, connections in self._connection_pool_to_connections.items():
             readd_connections = []
-            while not pool.pool.empty() and connections:
+            while pool.pool and not pool.pool.empty() and connections:
                 connection = pool.pool.get()
                 if isinstance(connection, self._connection_class):
                     connections.remove(connection)
@@ -273,8 +301,9 @@ def reset_patchers():
         yield mock.patch.object(cpool, 'VerifiedHTTPSConnection', _VerifiedHTTPSConnection)
         yield mock.patch.object(cpool, 'HTTPConnection', _HTTPConnection)
         yield mock.patch.object(cpool, 'HTTPSConnection', _HTTPSConnection)
-        yield mock.patch.object(cpool.HTTPConnectionPool, 'ConnectionCls', _HTTPConnection)
-        yield mock.patch.object(cpool.HTTPSConnectionPool, 'ConnectionCls', _HTTPSConnection)
+        if hasattr(cpool.HTTPConnectionPool, 'ConnectionCls'):
+            yield mock.patch.object(cpool.HTTPConnectionPool, 'ConnectionCls', _HTTPConnection)
+            yield mock.patch.object(cpool.HTTPSConnectionPool, 'ConnectionCls', _HTTPSConnection)
 
     try:
         import httplib2 as cpool

vcr/request.py

@@ -51,7 +51,7 @@ class Request(object):
         parse_uri = urlparse(self.uri)
         port = parse_uri.port
         if port is None:
-            port = {'https': 433, 'http': 80}[parse_uri.scheme]
+            port = {'https': 443, 'http': 80}[parse_uri.scheme]
         return port
 
     @property

vcr/serializers/jsonserializer.py

@@ -11,10 +11,14 @@ def deserialize(cassette_string):
 def serialize(cassette_dict):
     try:
         return json.dumps(cassette_dict, indent=4)
-    except UnicodeDecodeError:
+    except UnicodeDecodeError as original:
         raise UnicodeDecodeError(
-            "Error serializing cassette to JSON. ",
-            "Does this HTTP interaction contain binary data? ",
-            "If so, use a different serializer (like the yaml serializer) ",
-            "for this request"
+            original.encoding,
+            b"Error serializing cassette to JSON",
+            original.start,
+            original.end,
+            original.args[-1] +
+            ("Does this HTTP interaction contain binary data? "
+             "If so, use a different serializer (like the yaml serializer) "
+             "for this request?")
         )

vcr/stubs/__init__.py

@@ -76,7 +76,7 @@ class VCRHTTPResponse(HTTPResponse):
         self._closed = False
 
         headers = self.recorded_response['headers']
-        self.msg = parse_headers(headers)
+        self.headers = self.msg = parse_headers(headers)
 
         self.length = compat.get_header(self.msg, 'content-length') or None
 
@@ -128,7 +128,7 @@ class VCRConnection(object):
         Returns empty string for the default port and ':port' otherwise
         """
         port = self.real_connection.port
-        default_port = {'https': 433, 'http': 80}[self._protocol]
+        default_port = {'https': 443, 'http': 80}[self._protocol]
         return ':{0}'.format(port) if port != default_port else ''
 
     def _uri(self, url):
@@ -217,11 +217,15 @@ class VCRConnection(object):
             response = self.cassette.play_response(self._vcr_request)
             return VCRHTTPResponse(response)
         else:
-            if self.cassette.write_protected and self.cassette._filter_request(self._vcr_request):
+            if self.cassette.write_protected and self.cassette.filter_request(
+                self._vcr_request
+            ):
                 raise CannotOverwriteExistingCassetteException(
+                    "No match for the request (%r) was found. "
                     "Can't overwrite existing cassette (%r) in "
                     "your current record mode (%r)."
-                    % (self.cassette._path, self.cassette.record_mode)
+                    % (self._vcr_request, self.cassette._path,
+                       self.cassette.record_mode)
                 )
 
             # Otherwise, we should send the request, then get the response
@@ -232,12 +236,16 @@ class VCRConnection(object):
                     self._vcr_request
                 )
             )
-            self.real_connection.request(
-                method=self._vcr_request.method,
-                url=self._url(self._vcr_request.uri),
-                body=self._vcr_request.body,
-                headers=self._vcr_request.headers,
-            )
+            # This is imported here to avoid circular import.
+            # TODO(@IvanMalison): Refactor to allow normal import.
+            from vcr.patch import force_reset
+            with force_reset():
+                self.real_connection.request(
+                    method=self._vcr_request.method,
+                    url=self._url(self._vcr_request.uri),
+                    body=self._vcr_request.body,
+                    headers=self._vcr_request.headers,
+                )
 
             # get the response
             response = self.real_connection.getresponse()
@@ -310,3 +318,4 @@ class VCRHTTPSConnection(VCRConnection):
     '''A Mocked class for HTTPS requests'''
     _baseclass = HTTPSConnection
     _protocol = 'https'
+    is_verified = True

vcr/stubs/urllib3_stubs.py

@@ -1,8 +1,13 @@
 '''Stubs for urllib3'''
 
-from urllib3.connectionpool import VerifiedHTTPSConnection
-from ..stubs import VCRHTTPSConnection
+from urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
+from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
 
+# urllib3 defines its own HTTPConnection classes. It includes some polyfills
+# for newer features missing in older pythons.
 
-class VCRVerifiedHTTPSConnection(VCRHTTPSConnection, VerifiedHTTPSConnection):
+class VCRRequestsHTTPConnection(VCRHTTPConnection, HTTPConnection):
+    _baseclass = HTTPConnection
+
+class VCRRequestsHTTPSConnection(VCRHTTPSConnection, VerifiedHTTPSConnection):
     _baseclass = VerifiedHTTPSConnection