Merge branch 'master' of github.com:mindflayer/python-mocket

Author: Giorgio Salluzzo

mocket/compat.py

@@ -4,27 +4,37 @@
 
 import six
 
+encoding = os.getenv("MOCKET_ENCODING", 'utf-8')
+
+text_type = six.text_type
+byte_type = six.binary_type
+basestring = six.string_types
+
 PY2 = sys.version_info[0] == 2
 if PY2:
     from BaseHTTPServer import BaseHTTPRequestHandler
-    from urlparse import urlsplit, parse_qs
+    from urlparse import urlsplit, parse_qs, unquote
+
+    def unquote_utf8(qs):
+        if isinstance(qs, text_type):
+            qs = qs.encode(encoding)
+        s = unquote(qs)
+        if isinstance(s, byte_type):
+            return s.decode(encoding)
+        else:
+            return s
+
     FileNotFoundError = IOError
 else:
     from http.server import BaseHTTPRequestHandler
-    from urllib.parse import urlsplit, parse_qs
+    from urllib.parse import urlsplit, parse_qs, unquote as unquote_utf8
     FileNotFoundError = FileNotFoundError
 
 try:
     from json.decoder import JSONDecodeError
 except ImportError:
     JSONDecodeError = ValueError
 
-text_type = six.text_type
-byte_type = six.binary_type
-basestring = six.string_types
-
-encoding = os.getenv("MOCKET_ENCODING", 'utf-8')
-
 
 def encode_to_bytes(s, charset=encoding):
     if isinstance(s, text_type):

mocket/mockhttp.py

@@ -6,7 +6,14 @@
 
 import magic
 
-from .compat import BaseHTTPRequestHandler, urlsplit, parse_qs, encode_to_bytes, decode_from_bytes
+from .compat import (
+    BaseHTTPRequestHandler,
+    urlsplit,
+    parse_qs,
+    encode_to_bytes,
+    decode_from_bytes,
+    unquote_utf8,
+)
 from .mocket import Mocket, MocketEntry
 
 
@@ -22,41 +29,57 @@ def __init__(self, data):
         self.error_code = self.error_message = None
         self.parse_request()
         self.method = self.command
+        self.querystring = parse_qs(unquote_utf8(urlsplit(self.path).query), keep_blank_values=True)
+
+    def __str__(self):
+        return "{} - {} - {}".format(self.method, self.path, self.headers)
 
     def __str__(self):
         return "{} - {} - {}".format(self.method, self.path, self.headers)
 
 
 class Response(object):
+    headers = None
+    is_file_object = False
+
     def __init__(self, body='', status=200, headers=None):
         headers = headers or {}
-        is_file_object = False
         try:
             #  File Objects
             self.body = body.read()
-            is_file_object = True
+            self.is_file_object = True
         except AttributeError:
             self.body = encode_to_bytes(body)
         self.status = status
+
+        self.set_base_headers()
+
+        if headers is not None:
+            self.set_extra_headers(headers)
+
+        self.data = self.get_protocol_data() + self.body
+
+    def get_protocol_data(self):
+        status_line = 'HTTP/1.1 {status_code} {status}'.format(status_code=self.status, status=STATUS[self.status])
+        header_lines = CRLF.join(['{0}: {1}'.format(k.capitalize(), v) for k, v in self.headers.items()])
+        return '{0}\r\n{1}\r\n\r\n'.format(status_line, header_lines).encode('utf-8')
+
+    def set_base_headers(self):
         self.headers = {
             'Status': str(self.status),
             'Date': time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime()),
             'Server': 'Python/Mocket',
             'Connection': 'close',
             'Content-Length': str(len(self.body)),
         }
-        if not is_file_object:
+        if not self.is_file_object:
             self.headers['Content-Type'] = 'text/plain; charset=utf-8'
         else:
             self.headers['Content-Type'] = decode_from_bytes(magic.from_buffer(self.body, mime=True))
+
+    def set_extra_headers(self, headers):
         for k, v in headers.items():
             self.headers['-'.join([token.capitalize() for token in k.split('-')])] = v
-        self.data = self.get_protocol_data() + self.body
-
-    def get_protocol_data(self):
-        status_line = 'HTTP/1.1 {status_code} {status}'.format(status_code=self.status, status=STATUS[self.status])
-        header_lines = CRLF.join(['{0}: {1}'.format(k.capitalize(), v) for k, v in self.headers.items()])
-        return '{0}\r\n{1}\r\n\r\n'.format(status_line, header_lines).encode('utf-8')
 
 
 class Entry(MocketEntry):
@@ -75,7 +98,7 @@ class Entry(MocketEntry):
     request_cls = Request
     response_cls = Response
 
-    def __init__(self, uri, method, responses):
+    def __init__(self, uri, method, responses, match_querystring=True):
         uri = urlsplit(uri)
 
         if not uri.port:
@@ -90,6 +113,7 @@ def __init__(self, uri, method, responses):
         self.query = uri.query
         self.method = method.upper()
         self._sent_data = b''
+        self._match_querystring = match_querystring
 
     def collect(self, data):
         self._sent_data += data
@@ -116,11 +140,13 @@ def can_handle(self, data):
             except AttributeError:
                 return False
         uri = urlsplit(path)
-        kw = dict(keep_blank_values=True)
-        ch = uri.path == self.path and parse_qs(uri.query, **kw) == parse_qs(self.query, **kw) and method == self.method
-        if ch:
+        can_handle = uri.path == self.path and method == self.method
+        if self._match_querystring:
+            kw = dict(keep_blank_values=True)
+            can_handle = can_handle and parse_qs(uri.query, **kw) == parse_qs(self.query, **kw)
+        if can_handle:
             Mocket._last_entry = self
-        return ch
+        return can_handle
 
     @staticmethod
     def _parse_requestline(line):
@@ -144,9 +170,21 @@ def _parse_requestline(line):
             raise ValueError('Not a Request-Line')
 
     @classmethod
-    def register(cls, method, uri, *responses):
-        Mocket.register(cls(uri, method, responses))
+    def register(cls, method, uri, *responses, **config):
+
+        default_config = dict(match_querystring=True, add_trailing_slash=True)
+        default_config.update(config)
+        config = default_config
+
+        if config['add_trailing_slash'] and not urlsplit(uri).path:
+            uri += '/'
+
+        Mocket.register(cls(uri, method, responses, match_querystring=config['match_querystring']))
 
     @classmethod
-    def single_register(cls, method, uri, body='', status=200, headers=None):
-        cls.register(method, uri, Response(body=body, status=status, headers=headers))
+    def single_register(cls, method, uri, body='', status=200, headers=None, match_querystring=True):
+        cls.register(
+            method, uri, cls.response_cls(
+                body=body, status=status, headers=headers
+            ), match_querystring=match_querystring
+        )

mocket/plugins/httpretty/__init__.py

@@ -0,0 +1,104 @@
+from mocket import mocketize, Mocket
+from mocket.mockhttp import Entry as MocketHttpEntry, Response as MocketHttpResponse, STATUS, CRLF
+from mocket.compat import text_type, byte_type, encode_to_bytes
+
+
+def httprettifier_headers(headers):
+    return {k.lower().replace('_', '-'): v for k, v in headers.items()}
+
+
+class Response(MocketHttpResponse):
+    def get_protocol_data(self):
+        status_line = 'HTTP/1.1 {status_code} {status}'.format(status_code=self.status, status=STATUS[self.status])
+        if 'server' in self.headers and self.headers['server'] == 'Python/Mocket':
+            self.headers['server'] = 'Python/HTTPretty'
+        header_lines = CRLF.join(['{0}: {1}'.format(k.lower(), v) for k, v in self.headers.items()])
+        return '{0}\r\n{1}\r\n\r\n'.format(status_line, header_lines).encode('utf-8')
+
+    def set_base_headers(self):
+        super(Response, self).set_base_headers()
+        self.headers = httprettifier_headers(self.headers)
+    original_set_base_headers = set_base_headers
+
+    def set_extra_headers(self, headers):
+        self.headers.update(headers)
+
+
+class Entry(MocketHttpEntry):
+    response_cls = Response
+
+
+activate = mocketize
+httprettified = mocketize
+enable = Mocket.enable
+disable = Mocket.disable
+reset = Mocket.reset
+
+GET = Entry.GET
+PUT = Entry.PUT
+POST = Entry.POST
+DELETE = Entry.DELETE
+HEAD = Entry.HEAD
+PATCH = Entry.PATCH
+OPTIONS = Entry.OPTIONS
+
+
+def register_uri(
+    method,
+    uri,
+    body='HTTPretty :)',
+    adding_headers=None,
+    forcing_headers=None,
+    status=200,
+    responses=None,
+    match_querystring=False,
+    priority=0,
+    **headers
+):
+
+    headers = httprettifier_headers(headers)
+
+    if adding_headers is not None:
+        headers.update(httprettifier_headers(adding_headers))
+
+    if forcing_headers is not None:
+        def force_headers(self):
+            self.headers = httprettifier_headers(forcing_headers)
+        Response.set_base_headers = force_headers
+    else:
+        Response.set_base_headers = Response.original_set_base_headers
+
+    if responses:
+        Entry.register(method, uri, *responses)
+    else:
+        Entry.single_register(
+            method, uri, body=body, status=status, headers=headers, match_querystring=match_querystring
+        )
+
+
+class MocketHTTPretty:
+
+    Response = Response
+
+    def __init__(self):
+        pass
+
+    def __getattr__(self, name):
+        if name == 'last_request':
+            last_request = getattr(Mocket, 'last_request')()
+            last_request.body = encode_to_bytes(last_request.body)
+            return last_request
+        elif name == 'latest_requests':
+            return getattr(Mocket, '_requests')
+        else:
+            return getattr(Entry, name)
+
+
+HTTPretty = MocketHTTPretty()
+HTTPretty.register_uri = register_uri
+
+
+__all__ = (
+    HTTPretty, activate, httprettified, enable, disable, reset, Response, GET, PUT, POST, DELETE, HEAD, PATCH,
+    register_uri, text_type, byte_type
+)

mocket/plugins/httpretty/core.py

@@ -0,0 +1,3 @@
+from mocket.compat import text_type, byte_type, decode_from_bytes
+
+decode_utf8 = decode_from_bytes

test_requirements.txt

@@ -5,3 +5,4 @@ mock
 requests
 redis
 gevent
+sure