add requests class to sow the seeds of a custom matcher

vcr/cassette.py

@@ -6,6 +6,7 @@ import tempfile
 # Internal imports
 from .patch import install, reset
 from .files import load_cassette, save_cassette
+from .request import Request
 
 
 class Cassette(object):
@@ -20,8 +21,7 @@ class Cassette(object):
 
     def __init__(self, path, data=None):
         self._path = path
-        self._requests = []
-        self._responses = []
+        self.requests = {}
         self.play_count = 0
         if data:
             self.deserialize(data)
@@ -35,12 +35,12 @@ class Cassette(object):
         return ([{
             'request': req,
             'response': res,
-        } for req, res in zip(self._requests, self._responses)])
+        } for req, res in self.requests.iteritems()])
 
     def deserialize(self, source):
         '''Given a serialized version, load the requests'''
-        self._requests, self._responses = (
-            [r['request'] for r in source], [r['response'] for r in source])
+        for r in source:
+            self.requests[r['request']] = r['response']
 
     def mark_played(self, request=None):
         '''
@@ -50,27 +50,19 @@ class Cassette(object):
 
     def append(self, request, response):
         '''Add a pair of request, response to this cassette'''
-        self._requests.append(request)
-        self._responses.append(response)
+        self.requests[request] = response
 
     def __len__(self):
         '''Return the number of request / response pairs stored in here'''
-        return len(self._requests)
+        return len(self.requests)
 
     def __contains__(self, request):
         '''Return whether or not a request has been stored'''
-        try:
-            self._requests.index(request)
-            return True
-        except ValueError:
-            return False
+        return request in self.requests
 
     def response(self, request):
         '''Find the response corresponding to a request'''
-        try:
-            return self._responses[self._requests.index(request)]
-        except ValueError:
-            raise KeyError
+        return self.requests[request]
 
     def __enter__(self):
         '''Patch the fetching libraries we know about'''

vcr/request.py

@@ -0,0 +1,18 @@
+class Request(object):
+
+    def __init__(self, host, port, method, url, body, headers):
+        self.host = host
+        self.port = port
+        self.method = method
+        self.url = url
+        self.body = body
+        self.headers = frozenset(headers.items())
+
+    def __key(self):
+        return (self.host, self.port, self.method, self.url, self.body, self.headers)
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __eq__(self, other):
+        return hash(self) == hash(other)

vcr/stubs/__init__.py

@@ -3,6 +3,8 @@
 from httplib import HTTPConnection, HTTPSConnection, HTTPMessage
 from cStringIO import StringIO
 
+from vcr.request import Request
+
 
 class VCRHTTPResponse(object):
     """
@@ -44,14 +46,15 @@ class VCRConnectionMixin:
 
     def request(self, method, url, body=None, headers=None):
         '''Persist the request metadata in self._vcr'''
-        self._request = {
-            'host': self.host,
-            'port': self.port,
-            'method': method,
-            'url': url,
-            'body': body,
-            'headers': headers or {},
-        }
+        self._request = Request(
+            host = self.host,
+            port = self.port,
+            method = method,
+            url = url,
+            body = body,
+            headers = headers or {}
+        )
+
         # Check if we have a cassette set, and if we have a response saved.
         # If so, there's no need to keep processing and we can bail
         if self.cassette and self._request in self.cassette: