add helper class to analyze response.location

Author: bdauvergne

tests/test_response.py

@@ -416,6 +416,15 @@ def test_content_dezips(self):
         resp = app.get('/')
         self.assertEqual(resp.body, b'test')
 
+    def test_location(self):
+        app = webtest.TestApp(debug_app)
+        res = app.post('/')
+        res.location = 'http://pylons.org'
+        res.content_location = 'https://example.org/a/b/c'
+        self.assertTrue(res.location.match('http://'))
+        self.assertTrue(res.content_location.match('https://example.org/a/b/c'))
+        self.assertTrue(res.url.match('http://localhost/'))
+
 
 class TestFollow(unittest.TestCase):
 

tests/test_utils.py

@@ -117,3 +117,69 @@ def test_json_method_doc(self):
 
     def test_json_method_name(self):
         self.assertEqual(self.mock.foo_json.__name__, 'foo_json')
+
+class URLTest(unittest.TestCase):
+    def test_attributes(self):
+        url = utils.URL('https://example.com/a/b/c?foo=bar&foo=barbar&bar=foo')
+        self.assertEqual(str(url), 'https://example.com/a/b/c?foo=bar&foo=barbar&bar=foo')
+        self.assertEqual(repr(url), "<URL 'https://example.com/a/b/c?foo=bar&foo=barbar&bar=foo'>")
+        self.assertEqual(url.scheme, 'https')
+        self.assertEqual(url.domain, 'example.com')
+        # webob.Response is wrong in environ_from_url(), here it should be example.com
+        self.assertEqual(url.host, 'example.com:443')
+        # so netloc was implemented to replace it
+        self.assertEqual(url.netloc, 'example.com')
+        self.assertEqual(url.host_url, 'https://example.com')
+        self.assertEqual(url.path, '/a/b/c')
+        self.assertEqual(url.path_url, 'https://example.com/a/b/c')
+        self.assertEqual(url.path_qs, '/a/b/c?foo=bar&foo=barbar&bar=foo')
+        self.assertEqual(list(url.params.items()), [('foo', 'bar'), ('foo', 'barbar'), ('bar', 'foo')])
+        self.assertEqual(url.params['foo'], 'barbar')
+        self.assertEqual(url.query_string, 'foo=bar&foo=barbar&bar=foo')
+
+    def test_join(self):
+        url = utils.URL('https://example.com/a/b/c?foo=bar&foo=barbar&bar=foo')
+        new_url = url.join('x/y?foofo=bar')
+
+        self.assertEqual(new_url, 'https://example.com/a/b/x/y?foofo=bar')
+
+    def test_match(self):
+        url = utils.URL('https://example.com/a/b/c?foo=bar&foo=barbar&bar=foo')
+        self.assertTrue(url.match('https://'))
+        self.assertFalse(url.match('http://'))
+        self.assertEqual(repr(url.match('http://')), 'Error -- scheme differs https != http')
+        self.assertTrue(url.match('//example.com'))
+        self.assertFalse(url.match('//a.example.com'))
+        self.assertEqual(repr(url.match('//a.example.com')), 'Error -- netloc differs example.com != a.example.com')
+        self.assertTrue(url.match('https://example.com'))
+
+        self.assertTrue(url.match('/a/b/c'))
+        self.assertFalse(url.match('/a/b/c/'))
+        self.assertEqual(repr(url.match('/a/b/c/')), 'Error -- path differs /a/b/c != /a/b/c/')
+        self.assertFalse(url.match('/x'))
+
+        self.assertTrue(url.match('https://example.com/a/b/c'))
+        self.assertFalse(url.match('https://example.com/a/b/c/'))
+        self.assertFalse(url.match('https://example.com/x'))
+
+        self.assertTrue(url.match(url))
+        self.assertTrue(url.match('https://example.com/a/b/c?foo=bar&foo=barbar&bar=foo'))
+        self.assertTrue(url.match('https://example.com/a/b/c?foo=bar'))
+        self.assertTrue(url.match('https://example.com/a/b/c?foo=barbar'))
+        self.assertFalse(url.match('https://example.com/a/b/c?foo=bar', strict=True))
+        self.assertEqual(repr(url.match('https://example.com/a/b/c?foo=bar&bar=foo', strict=True)), 'Error -- ?foo=barbar was not expected.')
+
+        # multiple errors
+        self.assertEqual(repr(url.match('https://example.com/a/b/c?foo=bar', strict=True)), 'Error -- ?foo=barbar was not expected. ?bar=foo was not expected.')
+
+        self.assertTrue(url.match('?!foobar'))
+        self.assertTrue(url.match('?bar=?'))
+        self.assertTrue(url.match('?bar=?&foo=*', strict=True))
+        self.assertEqual(repr(url.match('?!foo')), 'Error -- foo should be absent, but ?foo=bar&foo=barbar found.')
+        self.assertEqual(repr(url.match('?foo=?')), 'Error -- foo should have only one value but ?foo=bar&foo=barbar found.')
+        self.assertEqual(repr(url.match('?foobar=?')), 'Error -- foobar should have only one value but is absent.')
+
+        self.assertEqual(repr(url.match('?foo=barfoo')), 'Error -- foo should have value \'barfoo\' but ?foo=bar&foo=barbar found.')
+        self.assertEqual(repr(url.match('?foobar=barfoo')), 'Error -- foobar should have value \'barfoo\' but is absent.')
+
+

webtest/response.py

@@ -545,3 +545,19 @@ def showbrowser(self):
         else:
             url = 'file://' + name
         webbrowser.open_new(url)
+
+    @webob.Response.location.getter
+    def location(self):
+        value = webob.Response.location.fget(self)
+        if value is not None:
+            return utils.URL(value)
+
+    @webob.Response.content_location.getter
+    def content_location(self):
+        value = webob.Response.content_location.fget(self)
+        if value is not None:
+            return utils.URL(value)
+
+    @property
+    def url(self):
+        return utils.URL(self.request.url)

webtest/utils.py

@@ -1,5 +1,9 @@
+import functools
 import re
 from json import dumps
+import urllib.parse
+
+import webob
 
 from webtest.compat import urlencode
 
@@ -167,3 +171,107 @@ def getheaders(self, header):
     def get_all(self, headers, default):  # NOQA
         # This is undocumented method that Python 3 cookielib uses
         return self._response.headers.getall(headers)
+
+
+class Error:
+    def __init__(self, message):
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+    def __bool__(self):
+        return False
+
+    def __repr__(self):
+        return f'Error -- {self.message}'
+
+
+class URL(str):
+    @functools.cached_property
+    def request(self):
+        parsed = urllib.parse.urlparse(self)
+        request = webob.Request.blank(self)
+        # XXX: webob force the http: scheme if parsed.scheme is absent
+        # XXX: webob does not understand //{host}/ it interprets it as if //{host}/ is a path
+        if not parsed.scheme:
+            request.environ['PATH_INFO'] = parsed.path
+            request.environ['HTTP_HOST'] = parsed.netloc
+            request.environ['wsgi.url_scheme'] = None
+        return request
+
+    def __getattr__(self, attr):
+        return getattr(self.request, attr)
+
+    def join(self, other):
+        return URL(urllib.parse.urljoin(str(self), str(other) if other else ''))
+
+    @property
+    def netloc(self):
+        return urllib.parse.urlparse(self).netloc
+
+    @property
+    def host_url(self):
+        return URL(self.request.host_url)
+
+    @property
+    def path(self):
+        return URL(self.request.path)
+
+    @property
+    def path_url(self):
+        return URL(self.request.path_url)
+
+    @property
+    def path_qs(self):
+        return URL(self.request.path_qs)
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__} {str(self)!r}>'
+
+    def match(self, other, strict=False):
+        if not isinstance(other, URL):
+            other = URL(other)
+        errors = []
+        if other.scheme and other.scheme != self.scheme:
+            errors.append(f'scheme differs {self.scheme} != {other.scheme}')
+        if other.netloc and self.netloc != other.netloc:
+            errors.append(f'netloc differs {self.netloc} != {other.netloc}')
+        if other.path and other.path != '/*/' and other.path != self.path:
+            errors.append(f'path differs {self.path} != {other.path}')
+        if other.params or strict:
+            expected = set()
+            for key, value in other.params.items():
+                # &!key forbids key in query string
+                if key.startswith('!'):
+                    if key[1:] in self.params:
+                        qs = urllib.parse.urlencode([(key[1:], v) for v in self.params.getall(key[1:])])
+                        errors.append(f'{key[1:]} should be absent, but ?{qs} found.')
+                elif value == '?':
+                    values = self.params.getall(key)
+                    if len(values) == 0 or (len(values) == 1 and not values[0]):
+                        errors.append(f'{key} should have only one value but is absent.')
+                    elif len(values) > 1:
+                        qs = urllib.parse.urlencode([(key, v) for v in self.params.getall(key)])
+                        errors.append(f'{key} should have only one value but ?{qs} found.')
+                    else:
+                        expected.add((key, self.params[key]))
+                elif value == '*':
+                    for v in self.params.getall(key):
+                        expected.add((key, v))
+                else:
+                    if key not in self.params:
+                        errors.append(f'{key} should have value {value!r} but is absent.')
+                    elif value not in self.params.getall(key):
+                        qs = urllib.parse.urlencode([(key, v) for v in self.params.getall(key)])
+                        errors.append(f'{key} should have value {value!r} but ?{qs} found.')
+                    else:
+                        expected.add((key, value))
+
+            if strict:
+                for key, value in self.params.items():
+                    if (key, value) not in expected:
+                        errors.append(f'?{key}={value} was not expected.')
+        if errors:
+            return Error(' '.join(errors))
+        return True