[Culprit-Finder] Add generator cache decorator.

appengine/findit/libs/test/cache_decorator_test.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import mock
 import pickle
+import unittest
 import zlib
 
-from testing_utils import testing
-
 from libs import cache
 from libs import cache_decorator
 
 
 class _DummyCache(cache.Cache):
   def __init__(self, cached_data):
     self.cached_data = cached_data
 
   def Get(self, key):
     return self.cached_data.get(key)
 
   def Set(self, key, data, expire_time=0):
     self.cached_data[key] = data
 
 
-def _DummyKeyGenerator(func, *_):
-  return func.__name__
+def _DummyKeyGenerator(func, args, kwargs,  # pylint: disable=W0613
+                       namespace=None):
+  namespace = namespace or '%s.%s' % (func.__module__, func.__name__)
+  return namespace + '-' + func.__name__
 
 
-class CacheDecoratorTest(testing.AppengineTestCase):
+class CachedTest(unittest.TestCase):
+  """Tests ``Cached`` decorator."""
+
   def testDefaultKeyGenerator(self):
+    namespace = 'n'
     expected_params = {
         'id1': 'fi',
         'id2': 'pi',
         'url': 'http://url',
     }
     # Hexadecimal digits of MD5 digest of "pickled_params".
-    expected_key = 'f5f173c811f7c537a80d44511903a3e0'
+    expected_key = namespace + '-f5f173c811f7c537a80d44511903a3e0'
 
     def MockPickleDumps(params):
       self.assertEqual(expected_params, params)
       return 'pickled_params'
 
     def Func(id1, id2, url=None):  # Unused parameters-pylint: disable=W0613

[chanli, 2017/01/21 07:11:56]

nit: Func -> func?

[Sharu Jiang, 2017/01/23 19:15:35]

Done.

       return 1  # pragma: no cover.
 
     class CallableIdentifier(object):
       def identifier(self):
         return 'fi'
 
     class PropertyIdentifier(object):
       @property
       def identifier(self):
         return 'pi'
 
-    self.mock(pickle, 'dumps', MockPickleDumps)
-
-    args = (CallableIdentifier(), PropertyIdentifier())
-    kwargs = {'url': 'http://url'}
-    key = cache_decorator._DefaultKeyGenerator(Func, args, kwargs)
-    self.assertEqual(expected_key, key)
+    with mock.patch('pickle.dumps', MockPickleDumps):
+      args = (CallableIdentifier(), PropertyIdentifier())
+      kwargs = {'url': 'http://url'}
+      key = cache_decorator._DefaultKeyGenerator(Func, args, kwargs,
+                                                 namespace=namespace)

[chanli, 2017/01/21 07:11:56]

Nit: move all parameters in one line?

[Sharu Jiang, 2017/01/23 19:15:35]

Done.

+      self.assertEqual(expected_key, key)
 
   def testCachedDecoratorWhenResultIsAlreadyCached(self):
     dummy_cache = _DummyCache({'n-Func': 1})
 
     @cache_decorator.Cached(
         namespace='n', key_generator=_DummyKeyGenerator, cache=dummy_cache)
     def Func():
       return 2  # pragma: no cover.
 
     self.assertEqual(1, Func())
@@ skipping 48 matching lines @@
         return self.url + '/' + path
 
     a1 = A('http://test', 3)
     self.assertEqual('http://test/p1', a1.Func('p1'))
     self.assertEqual('http://test/p1', a1.Func('p1'))
     self.assertEqual(1, a1.runs)
 
     a2 = A('http://test', 5)
     self.assertEqual('http://test/p1', a2.Func('p1'))
     self.assertEqual(0, a2.runs)
+
+
+class GeneratorCachedTest(unittest.TestCase):
+  """Tests ``GeneratorCached`` decorator."""
+
+  def testWhenResultIsAlreadyCached(self):
+    value_list = [0, 1, 2]
+    key = 'n-Func'
+    # Zero value won't be cached.
+    cached_keys = ['%s-%d' % (key, i) for i in xrange(len(value_list))]
+    cached_data = {key: value for key, value in zip(cached_keys, value_list)}
+    cached_data[key] = cached_keys
+
+    dummy_cache = _DummyCache(cached_data)
+
+    @cache_decorator.GeneratorCached(
+        dummy_cache, namespace='n', key_generator=_DummyKeyGenerator)
+    def Func():  # pragma: no cover
+      for value in value_list:
+        yield value
+
+    for value, expected_value in zip(Func(), value_list):
+      self.assertEqual(value, expected_value)
+
+  def testWhenResultIsNotCachedYet(self):
+    value_list = [0, 1, 2, 3, 4]
+    dummy_cache = _DummyCache({})
+
+    @cache_decorator.GeneratorCached(
+        dummy_cache, namespace='n', key_generator=_DummyKeyGenerator)
+    def Func():  # pragma: no cover
+      for value in value_list:
+        yield value
+
+    key = _DummyKeyGenerator(Func, [], {}, namespace='n')
+    cached_keys = ['%s-%d' % (key, i) for i in xrange(len(value_list))]
+    cached_data = {key: value for key, value in zip(cached_keys, value_list)}
+    cached_data[key] = cached_keys
+    for value, expected_value in zip(Func(), value_list):
+      self.assertEqual(value, expected_value)
+
+    self.assertDictEqual(dummy_cache.cached_data, cached_data)
+
+  @mock.patch('libs.cache_decorator.GeneratorCached.SetCache',
+              lambda *_: False)
+  def testFailedToSetValue(self):
+    value_list = [0, 1, 2, 3, 4]
+    dummy_cache = _DummyCache({})
+
+    @cache_decorator.GeneratorCached(
+        dummy_cache, namespace='n', key_generator=_DummyKeyGenerator)
+    def Func():  # pragma: no cover
+      for value in value_list:
+        yield value
+
+    key = _DummyKeyGenerator(Func, [], {}, namespace='n')
+    cached_keys = ['%s-%d' % (key, i) for i in xrange(len(value_list))]
+    cached_data = {key: value for key, value in zip(cached_keys, value_list)}
+    cached_data[key] = cached_keys
+    for value, expected_value in zip(Func(), value_list):
+      self.assertEqual(value, expected_value)
+
+    self.assertDictEqual(dummy_cache.cached_data, {})