appengine/findit/common/test/cache_decorator_test.py - Issue 2344443005: [Findit] Factoring the gitiles (etc) stuff out into its own directory

Side by Side Diff: appengine/findit/common/test/cache_decorator_test.py

Issue 2344443005: [Findit] Factoring the gitiles (etc) stuff out into its own directory (Closed)

Patch Set: rebase-update Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 # Copyright 2015 The Chromium Authors. All rights reserved.

2 # Use of this source code is governed by a BSD-style license that can be

3 # found in the LICENSE file.

4

5 import pickle

6 import zlib

7

8 from google.appengine.api import memcache

9

10 from testing_utils import testing

11

12 from common import cache_decorator

13

14

15 class _DummyCacher(cache_decorator.Cacher):

16 def __init__(self, cached_data):

17 self.cached_data = cached_data

18

19 def Get(self, key):

20 return self.cached_data.get(key)

21

22 def Set(self, key, data, expire_time=0):

23 self.cached_data[key] = data

24

25

26 def _DummyKeyGenerator(func, *_):

27 return func.__name__

28

29

30 class CacheDecoratorTest(testing.AppengineTestCase):

31 def testPickledMemCacher(self):

32 cacher = cache_decorator.PickledMemCacher()

33 cacher.Set('a', 'd')

34 self.assertEquals('d', cacher.Get('a'))

35

36 def _MockPickleAndZlib(self):

37 def Func(string, _, *__):

38 return string

39 self.mock(pickle, 'dumps', Func)

40 self.mock(pickle, 'loads', Func)

41 self.mock(zlib, 'compress', Func)

42 self.mock(zlib, 'decompress', Func)

43

44 def testCachingSmallDataInCompressedMemCacher(self):

45 self._MockPickleAndZlib()

46 cacher = cache_decorator.CompressedMemCacher()

47 data = 'A' * 1024 # A string of size 1KB.

48 cacher.Set('a', data)

49 self.assertEquals(data, cacher.Get('a'))

50

51 def testCachingLargeDataInCompressedMemCacher(self):

52 self._MockPickleAndZlib()

53 cacher = cache_decorator.CompressedMemCacher()

54 data = 'A' * (1024 * 1024 * 2) # A string of size 2MB.

55 cacher.Set('a', data)

56 self.assertEquals(data, cacher.Get('a'))

57

58 def testMissingSubPieceOfLargeDataInCompressedMemCacher(self):

59 self._MockPickleAndZlib()

60 cacher = cache_decorator.CompressedMemCacher()

61 data = 'A' * (1024 * 1024 * 2) # A string of size 2MB.

62 cacher.Set('a', data)

63 memcache.delete('a-0')

64 self.assertEquals(None, cacher.Get('a'))

65

66 def testDefaultKeyGenerator(self):

67 expected_params = {

68 'id1': 'fi',

69 'id2': 'pi',

70 'url': 'http://url',

71 }

72 # Hexadecimal digits of MD5 digest of "pickled_params".

73 expected_key = 'f5f173c811f7c537a80d44511903a3e0'

74

75 def MockPickleDumps(params):

76 self.assertEqual(expected_params, params)

77 return 'pickled_params'

78

79 def Func(id1, id2, url=None): # Unused parameters-pylint: disable=W0613

80 return 1 # pragma: no cover.

81

82 class CallableIdentifier(object):

83 def identifier(self):

84 return 'fi'

85

86 class PropertyIdentifier(object):

87 @property

88 def identifier(self):

89 return 'pi'

90

91 self.mock(pickle, 'dumps', MockPickleDumps)

92

93 args = (CallableIdentifier(), PropertyIdentifier())

94 kwargs = {'url': 'http://url'}

95 key = cache_decorator._DefaultKeyGenerator(Func, args, kwargs)

96 self.assertEqual(expected_key, key)

97

98 def testCachedDecoratorWhenResultIsAlreadyCached(self):

99 cacher = _DummyCacher({'n-Func': 1})

100

101 @cache_decorator.Cached(

102 namespace='n', key_generator=_DummyKeyGenerator, cacher=cacher)

103 def Func():

104 return 2 # pragma: no cover.

105

106 self.assertEqual(1, Func())

107 self.assertEqual({'n-Func': 1}, cacher.cached_data)

108

109 def testCachedDecoratorWhenResultIsNotCachedYet(self):

110 cacher = _DummyCacher({})

111

112 @cache_decorator.Cached(

113 namespace='n', key_generator=_DummyKeyGenerator, cacher=cacher)

114 def Func():

115 return 2

116

117 self.assertEqual(2, Func())

118 self.assertEqual({'n-Func': 2}, cacher.cached_data)

119

120 def testCachedDecoratorWhenResultShouldNotBeCached(self):

121 cacher = _DummyCacher({})

122

123 results = [None, 0, [], {}, '']

124

125 @cache_decorator.Cached(

126 namespace='n', key_generator=_DummyKeyGenerator, cacher=cacher)

127 def Func():

128 return results.pop()

129

130 self.assertEqual('', Func())

131 self.assertEqual({}, cacher.cached_data)

132 self.assertEqual({}, Func())

133 self.assertEqual({}, cacher.cached_data)

134 self.assertEqual([], Func())

135 self.assertEqual({}, cacher.cached_data)

136 self.assertEqual(0, Func())

137 self.assertEqual({}, cacher.cached_data)

138 self.assertIsNone(Func())

139 self.assertEqual({}, cacher.cached_data)

140

141 def testCachedDecoratorWithMethodInAClass(self):

142 class A(object):

143 def __init__(self, url, retries):

144 self.url = url

145 self.retries = retries

146 self.runs = 0

147

148 @property

149 def identifier(self):

150 return self.url

151

152 @cache_decorator.Cached()

153 def Func(self, path):

154 self.runs += 1

155 return self.url + '/' + path

156

157 a1 = A('http://test', 3)

158 self.assertEqual('http://test/p1', a1.Func('p1'))

159 self.assertEqual('http://test/p1', a1.Func('p1'))

160 self.assertEqual(1, a1.runs)

161

162 a2 = A('http://test', 5)

163 self.assertEqual('http://test/p1', a2.Func('p1'))

164 self.assertEqual(0, a2.runs)

OLD	NEW