Automatically generate cassette names from function names. Add

`path_transformer` and `func_path_generator`. Closes #151.

vcr/cassette.py

@@ -1,4 +1,5 @@
 """The container for recorded requests and responses"""
+import functools
 import logging
 
 import contextlib2
@@ -9,11 +10,12 @@ except ImportError:
     from backport_collections import Counter
 
 # Internal imports
+from .errors import UnhandledHTTPRequestError
+from .matchers import requests_match, uri, method
 from .patch import CassettePatcherBuilder
 from .persist import load_cassette, save_cassette
 from .serializers import yamlserializer
-from .matchers import requests_match, uri, method
-from .errors import UnhandledHTTPRequestError
+from .util import partition_dict
 
 
 log = logging.getLogger(__name__)
@@ -29,9 +31,11 @@ class CassetteContextDecorator(object):
     from interfering with another.
     """
 
+    _non_cassette_arguments = ('path_transformer', 'func_path_generator')
+
     @classmethod
-    def from_args(cls, cassette_class, path, **kwargs):
-        return cls(cassette_class, lambda: (path, kwargs))
+    def from_args(cls, cassette_class, **kwargs):
+        return cls(cassette_class, lambda: dict(kwargs))
 
     def __init__(self, cls, args_getter):
         self.cls = cls
@@ -49,6 +53,14 @@ class CassetteContextDecorator(object):
             # somewhere else.
             cassette._save()
 
+    @classmethod
+    def key_predicate(cls, key, value):
+        return key in cls._non_cassette_arguments
+
+    @classmethod
+    def _split_keys(cls, kwargs):
+        return partition_dict(cls.key_predicate, kwargs)
+
     def __enter__(self):
         # This assertion is here to prevent the dangerous behavior
         # that would result from forgetting about a __finish before
@@ -59,8 +71,11 @@ class CassetteContextDecorator(object):
         #     with context_decorator:
         #         pass
         assert self.__finish is None, "Cassette already open."
-        path, kwargs = self._args_getter()
-        self.__finish = self._patch_generator(self.cls.load(path, **kwargs))
+        other_kwargs, cassette_kwargs = self._split_keys(self._args_getter())
+        if 'path_transformer' in other_kwargs:
+            transformer = other_kwargs['path_transformer']
+            cassette_kwargs['path'] = transformer(cassette_kwargs['path'])
+        self.__finish = self._patch_generator(self.cls.load(**cassette_kwargs))
         return next(self.__finish)
 
     def __exit__(self, *args):
@@ -70,23 +85,42 @@ class CassetteContextDecorator(object):
     @wrapt.decorator
     def __call__(self, function, instance, args, kwargs):
         # This awkward cloning thing is done to ensure that decorated
-        # functions are reentrant. Reentrancy is required for thread
+        # functions are reentrant. This is required for thread
         # safety and the correct operation of recursive functions.
-        clone = type(self)(self.cls, self._args_getter)
+        args_getter = self._build_args_getter_for_decorator(
+            function, self._args_getter
+        )
+        clone = type(self)(self.cls, args_getter)
         with clone as cassette:
             if cassette.inject:
                 return function(cassette, *args, **kwargs)
             else:
                 return function(*args, **kwargs)
 
+    @staticmethod
+    def get_function_name(function):
+        return function.__name__
+
+    @classmethod
+    def _build_args_getter_for_decorator(cls, function, args_getter):
+        def new_args_getter():
+            kwargs = args_getter()
+            if 'path' not in kwargs:
+                name_generator = (kwargs.get('func_path_generator') or
+                                  cls.get_function_name)
+                path = name_generator(function)
+                kwargs['path'] = path
+            return kwargs
+        return new_args_getter
+
 
 class Cassette(object):
     """A container for recorded requests and responses"""
 
     @classmethod
-    def load(cls, path, **kwargs):
+    def load(cls, **kwargs):
         """Instantiate and load the cassette stored at the specified path."""
-        new_cassette = cls(path, **kwargs)
+        new_cassette = cls(**kwargs)
         new_cassette._load()
         return new_cassette
 
@@ -95,8 +129,8 @@ class Cassette(object):
         return CassetteContextDecorator(cls, arg_getter)
 
     @classmethod
-    def use(cls, *args, **kwargs):
-        return CassetteContextDecorator.from_args(cls, *args, **kwargs)
+    def use(cls, **kwargs):
+        return CassetteContextDecorator.from_args(cls, **kwargs)
 
     def __init__(self, path, serializer=yamlserializer, record_mode='once',
                  match_on=(uri, method),  before_record_request=None,