Some tests. Probably worth pruning.

Author: elnuno

tests/test_adapter.py

@@ -54,3 +54,10 @@ def test_close(self):
 
         sess.close()
         assert cache.close.called
+
+def test_cache_control_sets_sort_query():
+    for bool_ in (True, False):
+        sess = CacheControl(Session(), mock.Mock(spec=DictCache),
+                            sort_query=bool_)
+        assert sess.adapters['http://'].sort_query == bool_
+        assert sess.adapters['http://'].controller.sort_query == bool_

tests/test_cache_control.py

@@ -4,6 +4,8 @@
 import pytest
 from mock import ANY, Mock
 import time
+from random import shuffle
+import string
 
 from cachecontrol import CacheController
 from cachecontrol.cache import DictCache
@@ -225,3 +227,30 @@ def test_cached_request_with_bad_max_age_headers_not_returned(self):
         self.c.cache = DictCache({self.url: resp})
 
         assert not self.req({})
+
+def test_cache_url_sorting():
+    letter_n_numbers = list(enumerate(string.ascii_lowercase[3:], start=4))
+    suff = '&' + '&'.join('%s=%s' % (k, v) for v, k in letter_n_numbers)
+
+    def get_param(url):
+        """Mock losing order when processing params"""
+        shuffle(letter_n_numbers)
+        params = {k: v for v, k in letter_n_numbers}
+        url = url.replace(suff, '')
+        query = '&' + '&'.join('%s=%s' % item for item in params.items())
+        return url + query
+
+    no_query = 'http://example.com'
+    unsorted_query = 'http://example.com?b=2&c=3&a=1' + suff
+    sorted_query = 'http://example.com?a=1&b=2&c=3' + suff
+
+    cache_url = CacheController.cache_url
+    assert cache_url(no_query, sort_query=True) == cache_url(no_query)
+    assert cache_url(unsorted_query) != cache_url(sorted_query)
+    assert cache_url(unsorted_query, True) == cache_url(sorted_query)
+    randomized = get_param(unsorted_query)
+    assert randomized != unsorted_query
+    assert cache_url(randomized) != cache_url(sorted_query)
+    assert cache_url(randomized, True) == cache_url(sorted_query)
+    randomized_again = get_param(unsorted_query)
+    assert cache_url(randomized, True) == cache_url(randomized_again, True)

tests/test_storage_filecache.py

@@ -4,12 +4,13 @@
 import os
 import string
 
-from random import randint, sample
+from random import randint, sample, shuffle
 
 import pytest
 import requests
 from cachecontrol import CacheControl
 from cachecontrol.caches import FileCache
+from cachecontrol.caches.file_cache import url_to_file_path
 from lockfile import LockFile
 from lockfile.mkdirlockfile import MkdirLockFile
 
@@ -110,3 +111,59 @@ def test_lock_class(self, tmpdir):
         lock_class = object()
         cache = FileCache(str(tmpdir), lock_class=lock_class)
         assert cache.lock_class is lock_class
+
+    def test_url_to_file_path(self, tmpdir):
+        cache = FileCache(str(tmpdir))
+        # We'll add a long sorted suffix so that unsorted queries have a low
+        # collision probability (about 3.8e-23 for each sorted/unsorted
+        # comparison).
+        letter_n_numbers = list(enumerate(string.ascii_lowercase[3:], start=4))
+        suff = '&' + '&'.join('%s=%s' % (k, v) for v, k in letter_n_numbers)
+
+        def get_param(url):
+            """Mock losing order when processing params"""
+            shuffle(letter_n_numbers)
+            params = {k: v for v, k in letter_n_numbers}
+            url = url.replace(suff, '')
+            query = '&' + '&'.join('%s=%s' % item for item in params.items())
+            return url + query
+
+        urls = {
+            'no_query': 'http://example.com',
+            'unsorted_query': 'http://example.com?b=2&c=3&a=1' + suff,
+            'sorted_query': 'http://example.com?a=1&b=2&c=3' + suff,
+            'unsorted_empty_value': 'http://example.com?b=&c=&a=1' + suff,
+            'sorted_empty_value': 'http://example.com?a=1&b=&c=3' + suff,
+            'unsorted_repeated_key': 'http://example.com?b=2&c=3&b=0'
+                                     '&c=5&a=1' + suff,
+            'sorted_repeated_key': 'http://example.com?a=1&b=0&b=2&c=3&'
+                                   'c=5' + suff}
+
+        unoquery = url_to_file_path(urls['no_query'], cache, sort_query=False)
+        snoquery = url_to_file_path(urls['no_query'], cache, sort_query=True)
+        assert unoquery == snoquery
+        urls.pop('no_query')
+
+        sortedpaths = {urlname: url_to_file_path(urlvalue, cache, True) for
+                       urlname, urlvalue in urls.items()}
+
+        for key, value in urls.items():
+            if key.startswith('sorted'):
+                assert url_to_file_path(value, cache, True) == sortedpaths[key]
+
+        unsortedpaths = {urlname: url_to_file_path(urlvalue, cache, False) for
+                         urlname, urlvalue in urls.items()}
+
+        for key, url in urls.items():
+            if key.startswith('unsorted'):
+                assert sortedpaths[key] != unsortedpaths[key]
+            else:
+                assert sortedpaths[key] == unsortedpaths[key]
+
+            # Randomize and sort params
+            sort_param = url_to_file_path(get_param(url), cache, True)
+            assert sort_param == sortedpaths[key]
+
+            # Randomize but don't sort params
+            unsort_param = url_to_file_path(get_param(url), cache, False)
+            assert unsort_param != unsortedpaths[key]