Ejemplo n.º 1
0
    def test_get_or_prime_primes(self):
        cache.delete('foo')

        # Check that we primed
        cached, primed = cache.get_or_prime('foo', primer='bar')
        self.assertTrue(primed)
        self.assertEqual(cached, 'bar')

        # Subsequent call should not prime
        cached, primed = cache.get_or_prime('foo', primer='baz')
        self.assertFalse(primed)
        self.assertEqual(cached, 'bar')
Ejemplo n.º 2
0
    def get_resource(self, url, **kwargs):
        """
        Obtain an OEmbed resource JSON

        :param string url: Requested rich content URL
        :param kwargs: Optional arguments along with this request.
                       Currently only ``maxwidth`` and ``maxheight`` supported.
        :returns: :class:`monocle.resources.Resource`

        .. note::
            Currently only JSON-compatible requests are honored. If a request is
            made for an XML resource, it will still return a JSON resource
        """
        params = kwargs
        params['url'] = url

        # Only support JSON format
        params['format'] = 'json'

        request_url = self.get_request_url(**params)
        logger.info('Obtaining OEmbed resource at %s' % request_url)

        cached, primed = cache.get_or_prime(request_url, primer=Resource(params['url']))

        if primed or cached.is_stale:
            # Prevent many tasks being issued
            if cached.is_stale:
                cache.set(request_url, cached.refresh())

            request_external_oembed.apply_async((request_url,))
            logger.info('Scheduled external request for OEmbed resource %s' % url)

        return cached
Ejemplo n.º 3
0
    def get_resource(self, url, **kwargs):
        self._params = kwargs
        self._params['url'] = url

        # Only support JSON format
        self._params['format'] = 'json'

        if settings.CACHE_INTERNAL_PROVIDERS:
            cache_key = self.get_request_url(**self._params)
            logger.debug('Checking InternalProvider cache for key %s' % cache_key)
            cached, primed = cache.get_or_prime(cache_key, primer=Resource(url))

            if primed or cached.is_stale:
                logger.debug('Rebuilding new or stale internal provider resource at %s' % url)
                # This is just a safeguard in case the rebuild takes a little time
                if cached.is_stale:
                    cache.set(cache_key, cached.refresh())

                cached = self._build_resource(**self._params)
                cache.set(cache_key, cached)

            return cached

        # No caching, build directly
        return self._build_resource(**self._params)
Ejemplo n.º 4
0
    def test_cache_hit_signal(self):
        cb = mock_receiver()
        cache_hit.connect(cb)

        cache.set('foo', 'bar')
        cached, primed = cache.get_or_prime('foo', 'bar')

        self.assertFalse(primed)
        self.assertTrue(cb.called)
Ejemplo n.º 5
0
    def test_cache_miss_signal(self):
        cb = mock_receiver()
        cache_miss.connect(cb)

        cache.delete('foo')
        cached, primed = cache.get_or_prime('foo', 'bar')

        self.assertTrue(primed)
        self.assertTrue(cb.called)
Ejemplo n.º 6
0
    def test_get_or_prime_does_not_prime(self):
        cache.set('foo', 'bar')

        cached, primed = cache.get_or_prime('foo', primer='baz')
        self.assertFalse(primed)
        self.assertEqual(cached, 'bar')