def test_update_cache_new_item(self, mock_requests):
        """
        Tests the simple case of updating the cache with a new URL's response.
        """
        headers = {
            'Connection': 'Keep-Alive',
            'Content-Type': 'text/plain',
        }
        self.set_mock_response(mock_requests, headers=headers)
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        # The URL cannot be found in the cache at this point
        self.assertFalse(url in cache)

        response, updated = cache.update(url)

        # The returned response is correct
        self.assertEqual(self.response_content, response.content)
        self.assertEqual(200, response.status_code)
        # The return value indicates the cache has been updated
        self.assertTrue(updated)
        # The URL is now found in the cache
        self.assertTrue(url in cache)
        # The content is accessible through the cache
        self.assertEqual(self.response_content, cache.get_content(url))
        # The returned headers are accessible through the cache
        cached_headers = cache.get_headers(url)
        for key, value in headers.items():
            self.assertIn(key, cached_headers)
            self.assertEqual(value, cached_headers[key])
Beispiel #2
0
def get_pseudo_package_list():
    """
    Existing pseudo packages for Debian are obtained from
    `BTS <http://bugs.debian.org/pseudo-packages.maintainers>`_
    """
    PSEUDO_PACKAGE_LIST_URL = (
        'http://bugs.debian.org/pseudo-packages.maintainers'
    )
    cache = HttpCache(settings.PTS_CACHE_DIRECTORY)
    if not cache.is_expired(PSEUDO_PACKAGE_LIST_URL):
        return
    response, updated = cache.update(PSEUDO_PACKAGE_LIST_URL)

    try:
        response.raise_for_status()
    except requests.exceptions.HTTPError as e:
        raise PluginProcessingError()

    if not updated:
        return

    return [
        line.split(None, 1)[0]
        for line in response.text.splitlines()
    ]
    def test_cache_remove_url(self, mock_requests):
        """
        Tests removing a cached response.
        """
        self.set_mock_response(mock_requests)
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)
        # Sanity check - the url is cached
        self.assertTrue(url in cache)

        cache.remove(url)

        self.assertFalse(url in cache)
    def test_cache_expires_header_expired(self, mock_requests):
        """
        Tests that the cache knows that a cached response is expired based
        on its Expires header.
        """
        expires = http_date(time.time() - 3600)
        self.set_mock_response(mock_requests, headers={
            'Expires': expires
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)

        self.assertTrue(cache.is_expired(url))
    def test_cache_expired(self, mock_requests):
        """
        Tests that the cache knows when an entry with a stale Cache-Control
        header is expired.
        """
        self.set_mock_response(mock_requests, headers={
            'Cache-Control': 'must-revalidate, max-age=0',
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'

        cache.update(url)

        self.assertTrue(url in cache)
        self.assertTrue(cache.is_expired(url))
    def test_cache_not_expired(self, mock_requests):
        """
        Tests that the cache knows a response is not expired based on its
        Cache-Control header.
        """
        self.set_mock_response(mock_requests, headers={
            'Cache-Control': 'must-revalidate, max-age=3600',
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'

        cache.update(url)

        self.assertTrue(url in cache)
        self.assertFalse(cache.is_expired(url))
    def test_conditional_force_unconditional_get(self, mock_requests):
        """
        Tests that the users can force the cache to perform an unconditional
        GET when updating a cached resource.
        """
        last_modified = http_date(time.time())
        self.set_mock_response(mock_requests, headers={
            'Last-Modified': last_modified
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)

        # Run the update again
        response, updated = cache.update(url, force=True)

        # Make sure that we ask for a non-cached version
        mock_requests.get.assert_called_with(url, verify=False, headers={
            'Cache-Control': 'no-cache'
        })
        self.assertTrue(updated)
    def test_conditional_get_etag_expired(self, mock_requests):
        """
        Tests that the cache performs a conditional GET request when asked to
        update the response for a URL with an ETag header, which has since
        expired.
        """
        etag = '"466010a-11bf9-4e17efa8afb81"'
        self.set_mock_response(mock_requests, headers={
            'ETag': etag,
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)
        # Set a new ETag and content value
        new_etag = '"57ngfhty11bf9-9t831116kn1qw1'
        self.response_content = b'Response'
        self.set_mock_response(mock_requests, headers={
            'ETag': new_etag
        })

        # Run the update again
        response, updated = cache.update(url)

        self.assertTrue(updated)
        self.assertEqual(200, response.status_code)
        # The new content is found in the cache
        self.assertEqual(self.response_content, cache.get_content(url))
        # The new Last-Modified is found in the headers cache
        self.assertEqual(
            new_etag,
            cache.get_headers(url)['ETag']
        )
    def test_cache_conditional_get_last_modified_expired(self, mock_requests):
        """
        Tests that the cache performs a conditional GET request when asked to
        update the response for a URL with a Last-Modified header, which has
        since expired.
        """
        last_modified = http_date(time.time() - 3600)
        self.set_mock_response(mock_requests, headers={
            'Last-Modified': last_modified
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)
        # Set a new Last-Modified and content value
        new_last_modified = http_date(time.time())
        self.response_content = b'Response'
        self.set_mock_response(mock_requests, headers={
            'Last-Modified': new_last_modified
        })

        # Run the update again
        response, updated = cache.update(url)

        self.assertTrue(updated)
        self.assertEqual(200, response.status_code)
        # The new content is found in the cache
        self.assertEqual(self.response_content, cache.get_content(url))
        # The new Last-Modified is found in the headers cache
        self.assertEqual(
            new_last_modified,
            cache.get_headers(url)['Last-Modified']
        )
    def test_conditional_get_etag(self, mock_requests):
        """
        Tests that the cache performs a conditional GET request when asked to
        update the response for a URL with an ETag header
        """
        etag = '"466010a-11bf9-4e17efa8afb81"'
        self.set_mock_response(mock_requests, headers={
            'ETag': etag,
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)

        self.response_content = b''
        self.set_mock_response(mock_requests, status_code=304)
        # Run the update again
        response, updated = cache.update(url)

        self.assertFalse(updated)
        mock_requests.get.assert_called_with(url, verify=False, headers={
            'If-None-Match': etag,
        })
        # The actual server's response is returned
        self.assertEqual(response.status_code, 304)
    def test_cache_conditional_get_last_modified(self, mock_requests):
        """
        Tests that the cache performs a conditional GET request when asked to
        update the response for a URL with a Last-Modified header.
        """
        last_modified = http_date(time.time())
        self.set_mock_response(mock_requests, headers={
            'Last-Modified': last_modified
        })
        cache = HttpCache(self.cache_directory)
        url = 'http://example.com'
        cache.update(url)

        self.response_content = b''
        self.set_mock_response(mock_requests, status_code=304)
        # Run the update again
        response, updated = cache.update(url)

        self.assertFalse(updated)
        mock_requests.get.assert_called_with(url, verify=False, headers={
            'If-Modified-Since': last_modified,
        })
        # The actual server's response is returned
        self.assertEqual(response.status_code, 304)