v1.7.3

Trivial cleanups and one bugfix

README.rst

@@ -14,17 +14,18 @@ library <https://github.com/vcr/vcr>`__.
 What it does
 ------------
 
-VCR.py simplifies and speeds up tests that make HTTP requests. The first
+VCR.py simplifies and speeds up tests that make HTTP requests. The
-time you run code that is inside a VCR.py context manager or decorated
+first time you run code that is inside a VCR.py context manager or
-function, VCR.py records all HTTP interactions that take place through
+decorated function, VCR.py records all HTTP interactions that take
-the libraries it supports and serializes and writes them to a flat file
+place through the libraries it supports and serializes and writes them
-(in yaml format by default). This flat file is called a cassette. When
+to a flat file (in yaml format by default). This flat file is called a
-the relevant peice of code is executed again, VCR.py will read the
+cassette. When the relevant peice of code is executed again, VCR.py
-serialized requests and responses from the aforementioned cassette file,
+will read the serialized requests and responses from the
-and intercept any HTTP requests that it recognizes from the original
+aforementioned cassette file, and intercept any HTTP requests that it
-test run and return responses that corresponded to those requests. This
+recognizes from the original test run and return the responses that
-means that the requests will not actually result in HTTP traffic, which
+corresponded to those requests. This means that the requests will not
-confers several benefits including:
+actually result in HTTP traffic, which confers several benefits
+including:
 
 -  The ability to work offline
 -  Completely deterministic tests
@@ -608,6 +609,9 @@ new API in version 1.0.x
 
 Changelog
 ---------
+-  1.7.3 [#188] ``additional_matchers`` kwarg on ``use_casstte``.
+   [#191] Actually support passing multiple before_record_request
+   functions (thanks @agriffis).
 -  1.7.2 [#186] Get effective_url in tornado (thanks @mvschaik), [#187]
    Set request_time on Response object in tornado (thanks @abhinav).
 -  1.7.1 [#183] Patch ``fetch_impl`` instead of the entire HTTPClient

setup.py

@@ -51,7 +51,7 @@ except Exception:
 
 setup(
     name='vcrpy',
-    version='1.7.2',
+    version='1.7.3',
     description=(
         "Automatically mock your HTTP interactions to simplify and "
         "speed up testing"

tests/unit/test_vcr.py

@@ -15,9 +15,11 @@ def test_vcr_use_cassette():
         'vcr.cassette.Cassette.load',
         return_value=mock.MagicMock(inject=False)
     ) 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]['record_mode'] is record_mode
@@ -38,9 +40,11 @@ def test_vcr_use_cassette():
 
 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',))
@@ -53,8 +57,12 @@ def test_vcr_before_record_request_params():
         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', '',
+        assert cassette.filter_request(
-                                               {'cookie': 'test', 'other': 'fun'})).headers == {'other': 'fun'}
+            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
@@ -64,6 +72,32 @@ def test_vcr_before_record_request_params():
         assert cassette.filter_request(Request('GET', base_path + 'get', '', {})) is not None
 
 
+def test_vcr_before_record_response_iterable():
+    # Regression test for #191
+
+    request = Request('GET', '/', '', {})
+    response = object()  # just can't be None
+
+    # Prevent actually saving the cassette
+    with mock.patch('vcr.cassette.save_cassette'):
+
+        # Baseline: non-iterable before_record_response should work
+        mock_filter = mock.Mock()
+        vcr = VCR(before_record_response=mock_filter)
+        with vcr.use_cassette('test') as cassette:
+            assert mock_filter.call_count == 0
+            cassette.append(request, response)
+            assert mock_filter.call_count == 1
+
+        # Regression test: iterable before_record_response should work too
+        mock_filter = mock.Mock()
+        vcr = VCR(before_record_response=(mock_filter,))
+        with vcr.use_cassette('test') as cassette:
+            assert mock_filter.call_count == 0
+            cassette.append(request, response)
+            assert mock_filter.call_count == 1
+
+
 @pytest.fixture
 def random_fixture():
     return 1
@@ -103,6 +137,7 @@ def test_custom_patchers():
 
 def test_inject_cassette():
     vcr = VCR(inject_cassette=True)
+
     @vcr.use_cassette('test', record_mode='once')
     def with_cassette_injected(cassette):
         assert cassette.record_mode == 'once'
@@ -117,9 +152,11 @@ def test_inject_cassette():
 
 def test_with_current_defaults():
     vcr = VCR(inject_cassette=True, record_mode='once')
+
     @vcr.use_cassette('test', with_current_defaults=False)
     def changing_defaults(cassette, checks):
         checks(cassette)
+
     @vcr.use_cassette('test', with_current_defaults=True)
     def current_defaults(cassette, checks):
         checks(cassette)
@@ -141,27 +178,33 @@ def test_with_current_defaults():
 def test_cassette_library_dir_with_decoration_and_no_explicit_path():
     library_dir = '/libary_dir'
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir)
+
     @vcr.use_cassette()
     def function_name(cassette):
         assert cassette._path == os.path.join(library_dir, 'function_name')
+
     function_name()
 
 
 def test_cassette_library_dir_with_decoration_and_explicit_path():
     library_dir = '/libary_dir'
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir)
+
     @vcr.use_cassette(path='custom_name')
     def function_name(cassette):
         assert cassette._path == os.path.join(library_dir, 'custom_name')
+
     function_name()
 
 
 def test_cassette_library_dir_with_decoration_and_super_explicit_path():
     library_dir = '/libary_dir'
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir)
+
     @vcr.use_cassette(path=os.path.join(library_dir, 'custom_name'))
     def function_name(cassette):
         assert cassette._path == os.path.join(library_dir, 'custom_name')
+
     function_name()
 
 
@@ -169,26 +212,32 @@ def test_cassette_library_dir_with_path_transformer():
     library_dir = '/libary_dir'
     vcr = VCR(inject_cassette=True, cassette_library_dir=library_dir,
               path_transformer=lambda path: path + '.json')
+
     @vcr.use_cassette()
     def function_name(cassette):
         assert cassette._path == os.path.join(library_dir, 'function_name.json')
+
     function_name()
 
 
 def test_use_cassette_with_no_extra_invocation():
     vcr = VCR(inject_cassette=True, cassette_library_dir='/')
+
     @vcr.use_cassette
     def function_name(cassette):
         assert cassette._path == os.path.join('/', 'function_name')
+
     function_name()
 
 
 def test_path_transformer():
     vcr = VCR(inject_cassette=True, cassette_library_dir='/',
               path_transformer=lambda x: x + '_test')
+
     @vcr.use_cassette
     def function_name(cassette):
         assert cassette._path == os.path.join('/', 'function_name_test')
+
     function_name()
 
 
@@ -203,8 +252,25 @@ def test_cassette_name_generator_defaults_to_using_module_function_defined_in():
 
 def test_ensure_suffix():
     vcr = VCR(inject_cassette=True, path_transformer=VCR.ensure_suffix('.yaml'))
+
     @vcr.use_cassette
     def function_name(cassette):
         assert cassette._path == os.path.join(os.path.dirname(__file__),
                                               'function_name.yaml')
+
     function_name()
+
+
+def test_additional_matchers():
+    vcr = VCR(match_on=('uri',), inject_cassette=True)
+
+    @vcr.use_cassette
+    def function_defaults(cassette):
+        assert set(cassette._match_on) == set([vcr.matchers['uri']])
+
+    @vcr.use_cassette(additional_matchers=('body',))
+    def function_additional(cassette):
+        assert set(cassette._match_on) == set([vcr.matchers['uri'], vcr.matchers['body']])
+
+    function_defaults()
+    function_additional()

vcr/cassette.py

@@ -210,7 +210,6 @@ class Cassette(object):
         request = self._before_record_request(request)
         if not request:
             return
-        if self._before_record_response:
         response = self._before_record_response(response)
         self.data.append((request, response))
         self.dirty = True

vcr/config.py

@@ -67,10 +67,11 @@ class VCR(object):
         try:
             serializer = self.serializers[serializer_name]
         except KeyError:
-            print("Serializer {0} doesn't exist or isn't registered".format(
+            raise KeyError(
+                "Serializer {0} doesn't exist or isn't registered".format(
                     serializer_name
-            ))
+                )
-            raise KeyError
+            )
         return serializer
 
     def _get_matchers(self, matcher_names):
@@ -117,12 +118,16 @@ class VCR(object):
             'cassette_library_dir',
             self.cassette_library_dir
         )
+        additional_matchers = kwargs.get('additional_matchers', ())
+
         if cassette_library_dir:
             def add_cassette_library_dir(path):
                 if not path.startswith(cassette_library_dir):
                     return os.path.join(cassette_library_dir, path)
                 return path
-            path_transformer = compose(add_cassette_library_dir, path_transformer)
+            path_transformer = compose(
+                add_cassette_library_dir, path_transformer
+            )
         elif not func_path_generator:
             # If we don't have a library dir, use the functions
             # location to build a full path for cassettes.
@@ -130,12 +135,12 @@ class VCR(object):
 
         merged_config = {
             'serializer': self._get_serializer(serializer_name),
-            'match_on': self._get_matchers(matcher_names),
+            'match_on': self._get_matchers(
+                tuple(matcher_names) + tuple(additional_matchers)
+            ),
             '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(
+            'before_record_response': self._build_before_record_response(kwargs),
-                kwargs
-            ),
             'custom_patches': self._custom_patches + kwargs.get(
                 'custom_patches', ()
             ),
@@ -153,11 +158,11 @@ class VCR(object):
             'before_record_response', self.before_record_response
         )
         filter_functions = []
-        if before_record_response and not isinstance(before_record_response,
+        if before_record_response:
-                                                     collections.Iterable):
+            if not isinstance(before_record_response, collections.Iterable):
                 before_record_response = (before_record_response,)
-            for function in before_record_response:
+            filter_functions.extend(before_record_response)
-                filter_functions.append(function)
+
         def before_record_response(response):
             for function in filter_functions:
                 if response is None:
@@ -178,7 +183,8 @@ class VCR(object):
             'filter_post_data_parameters', self.filter_post_data_parameters
         )
         before_record_request = options.get(
-            "before_record_request", options.get("before_record", self.before_record_request)
+            "before_record_request",
+            options.get("before_record", self.before_record_request)
         )
         ignore_hosts = options.get(
             'ignore_hosts', self.ignore_hosts
@@ -187,28 +193,36 @@ class VCR(object):
             'ignore_localhost', self.ignore_localhost
         )
         if filter_headers:
-            filter_functions.append(functools.partial(filters.remove_headers,
+            filter_functions.append(
-                                                      headers_to_remove=filter_headers))
+                functools.partial(
+                    filters.remove_headers,
+                    headers_to_remove=filter_headers
+                )
+            )
         if filter_query_parameters:
-            filter_functions.append(functools.partial(filters.remove_query_parameters,
+            filter_functions.append(functools.partial(
-                                                      query_parameters_to_remove=filter_query_parameters))
+                filters.remove_query_parameters,
+                query_parameters_to_remove=filter_query_parameters
+            ))
         if filter_post_data_parameters:
-            filter_functions.append(functools.partial(filters.remove_post_data_parameters,
+            filter_functions.append(
-                                                      post_data_parameters_to_remove=filter_post_data_parameters))
+                functools.partial(
+                    filters.remove_post_data_parameters,
+                    post_data_parameters_to_remove=filter_post_data_parameters
+                )
+            )
 
-        hosts_to_ignore = list(ignore_hosts)
+        hosts_to_ignore = set(ignore_hosts)
         if ignore_localhost:
-            hosts_to_ignore.extend(('localhost', '0.0.0.0', '127.0.0.1'))
+            hosts_to_ignore.update(('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.extend(before_record_request)
-                filter_functions.append(function)
+
         def before_record_request(request):
             request = copy.copy(request)
             for function in filter_functions:
@@ -216,7 +230,6 @@ class VCR(object):
                     break
                 request = function(request)
             return request
-
         return before_record_request
 
     @staticmethod

vcr/errors.py

@@ -3,8 +3,5 @@ class CannotOverwriteExistingCassetteException(Exception):
 
 
 class UnhandledHTTPRequestError(KeyError):
-    '''
+    """Raised when a cassette does not contain the request we want."""
-    Raised when a cassette does not c
-    ontain the request we want
-    '''
     pass

vcr/matchers.py

@@ -2,6 +2,8 @@ import json
 from six.moves import urllib, xmlrpc_client
 from .util import CaseInsensitiveDict, read_body
 import logging
+
+
 log = logging.getLogger(__name__)