Debian Codegraph @

tests/pools_test.py

raw
1 from unittest import TestCase, main
2
3 import eventlet
4 from eventlet import Queue
5 from eventlet import hubs
6 from eventlet import pools
7
8
9 class IntPool(pools.Pool):
10 def create(self):
11 self.current_integer = getattr(self, 'current_integer', 0) + 1
12 return self.current_integer
13
14
15 class TestIntPool(TestCase):
16 def setUp(self):
17 self.pool = IntPool(min_size=0, max_size=4)
18
19 def test_integers(self):
20 # Do not actually use this pattern in your code. The pool will be
21 # exhausted, and unrestoreable.
22 # If you do a get, you should ALWAYS do a put, probably like this:
23 # try:
24 # thing = self.pool.get()
25 # do stuff
26 # finally:
27 # self.pool.put(thing)
28
29 # with self.pool.some_api_name() as thing:
30 # do stuff
31 self.assertEqual(self.pool.get(), 1)
32 self.assertEqual(self.pool.get(), 2)
33 self.assertEqual(self.pool.get(), 3)
34 self.assertEqual(self.pool.get(), 4)
35
36 def test_free(self):
37 self.assertEqual(self.pool.free(), 4)
38 gotten = self.pool.get()
39 self.assertEqual(self.pool.free(), 3)
40 self.pool.put(gotten)
41 self.assertEqual(self.pool.free(), 4)
42
43 def test_exhaustion(self):
44 waiter = Queue(0)
45
46 def consumer():
47 gotten = None
48 try:
49 gotten = self.pool.get()
50 finally:
51 waiter.put(gotten)
52
53 eventlet.spawn(consumer)
54
55 one, two, three, four = (
56 self.pool.get(), self.pool.get(), self.pool.get(), self.pool.get())
57 self.assertEqual(self.pool.free(), 0)
58
59 # Let consumer run; nothing will be in the pool, so he will wait
60 eventlet.sleep(0)
61
62 # Wake consumer
63 self.pool.put(one)
64
65 # wait for the consumer
66 self.assertEqual(waiter.get(), one)
67
68 def test_blocks_on_pool(self):
69 waiter = Queue(0)
70
71 def greedy():
72 self.pool.get()
73 self.pool.get()
74 self.pool.get()
75 self.pool.get()
76 # No one should be waiting yet.
77 self.assertEqual(self.pool.waiting(), 0)
78 # The call to the next get will unschedule this routine.
79 self.pool.get()
80 # So this put should never be called.
81 waiter.put('Failed!')
82
83 killable = eventlet.spawn(greedy)
84
85 # no one should be waiting yet.
86 self.assertEqual(self.pool.waiting(), 0)
87
88 # Wait for greedy
89 eventlet.sleep(0)
90
91 # Greedy should be blocking on the last get
92 self.assertEqual(self.pool.waiting(), 1)
93
94 # Send will never be called, so balance should be 0.
95 self.assertFalse(not waiter.full())
96
97 eventlet.kill(killable)
98
99 def test_ordering(self):
100 # normal case is that items come back out in the
101 # same order they are put
102 one, two = self.pool.get(), self.pool.get()
103 self.pool.put(one)
104 self.pool.put(two)
105 self.assertEqual(self.pool.get(), one)
106 self.assertEqual(self.pool.get(), two)
107
108 def test_putting_to_queue(self):
109 timer = eventlet.Timeout(0.1)
110 try:
111 size = 2
112 self.pool = IntPool(min_size=0, max_size=size)
113 queue = Queue()
114 results = []
115
116 def just_put(pool_item, index):
117 self.pool.put(pool_item)
118 queue.put(index)
119 for index in range(size + 1):
120 pool_item = self.pool.get()
121 eventlet.spawn(just_put, pool_item, index)
122
123 for _ in range(size + 1):
124 x = queue.get()
125 results.append(x)
126 self.assertEqual(sorted(results), list(range(size + 1)))
127 finally:
128 timer.cancel()
129
130 def test_resize(self):
131 pool = IntPool(max_size=2)
132 a = pool.get()
133 b = pool.get()
134 self.assertEqual(pool.free(), 0)
135
136 # verify that the pool discards excess items put into it
137 pool.resize(1)
138 pool.put(a)
139 pool.put(b)
140 self.assertEqual(pool.free(), 1)
141
142 # resize larger and assert that there are more free items
143 pool.resize(2)
144 self.assertEqual(pool.free(), 2)
145
146 def test_create_contention(self):
147 creates = [0]
148
149 def sleep_create():
150 creates[0] += 1
151 eventlet.sleep()
152 return "slept"
153
154 p = pools.Pool(max_size=4, create=sleep_create)
155
156 def do_get():
157 x = p.get()
158 self.assertEqual(x, "slept")
159 p.put(x)
160
161 gp = eventlet.GreenPool()
162 for i in range(100):
163 gp.spawn_n(do_get)
164 gp.waitall()
165 self.assertEqual(creates[0], 4)
166
167 def test_put_with_timed_out_getters(self):
168 p = IntPool(max_size=2)
169 hub = hubs.get_hub()
170 # check out all the items
171 p.get()
172 p.get()
173
174 # all getting greenthreads are blocked and have Timeouts that are
175 # ready to fire, but have not fired yet
176 getters = [eventlet.spawn(p.get) for _ in range(5)]
177 eventlet.sleep()
178 for getter in getters:
179 hub.schedule_call_global(0, getter.throw, eventlet.Timeout(None))
180
181 # put one item back; this should not block since the pool is empty
182 with eventlet.Timeout(10): # don't hang if unblocking fails
183 p.put(0)
184 self.assertEqual(len(p.free_items), 1)
185
186
187 class TestAbstract(TestCase):
188 mode = 'static'
189
190 def test_abstract(self):
191 # Going for 100% coverage here
192 # A Pool cannot be used without overriding create()
193 pool = pools.Pool()
194 self.assertRaises(NotImplementedError, pool.get)
195
196
197 class TestIntPool2(TestCase):
198 mode = 'static'
199
200 def setUp(self):
201 self.pool = IntPool(min_size=3, max_size=3)
202
203 def test_something(self):
204 self.assertEqual(len(self.pool.free_items), 3)
205 # Cover the clause in get where we get from the free list instead of creating
206 # an item on get
207 gotten = self.pool.get()
208 self.assertEqual(gotten, 1)
209
210
211 class TestOrderAsStack(TestCase):
212 mode = 'static'
213
214 def setUp(self):
215 self.pool = IntPool(max_size=3, order_as_stack=True)
216
217 def test_ordering(self):
218 # items come out in the reverse order they are put
219 one, two = self.pool.get(), self.pool.get()
220 self.pool.put(one)
221 self.pool.put(two)
222 self.assertEqual(self.pool.get(), two)
223 self.assertEqual(self.pool.get(), one)
224
225
226 class RaisePool(pools.Pool):
227 def create(self):
228 raise RuntimeError()
229
230
231 class TestCreateRaises(TestCase):
232 mode = 'static'
233
234 def setUp(self):
235 self.pool = RaisePool(max_size=3)
236
237 def test_it(self):
238 self.assertEqual(self.pool.free(), 3)
239 self.assertRaises(RuntimeError, self.pool.get)
240 self.assertEqual(self.pool.free(), 3)
241
242
243 ALWAYS = RuntimeError('I always fail')
244 SOMETIMES = RuntimeError('I fail half the time')
245
246
247 class TookTooLongToRunTest(Exception):
248 pass
249
250
251 if __name__ == '__main__':
252 main()