Commit | Line | Data |
---|---|---|
32d2d479 MJ |
1 | # |
2 | # Copyright (C) 2019 EfficiOS Inc. | |
3 | # | |
4 | # This program is free software; you can redistribute it and/or | |
5 | # modify it under the terms of the GNU General Public License | |
6 | # as published by the Free Software Foundation; only version 2 | |
7 | # of the License. | |
8 | # | |
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. | |
13 | # | |
14 | # You should have received a copy of the GNU General Public License | |
15 | # along with this program; if not, write to the Free Software | |
16 | # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
17 | # | |
18 | ||
ae0bfae8 | 19 | from bt2 import value |
f6a5e476 | 20 | import unittest |
f6a5e476 PP |
21 | import bt2 |
22 | ||
23 | ||
24 | class UserComponentClassTestCase(unittest.TestCase): | |
25 | def _test_no_init(self, cls): | |
26 | with self.assertRaises(bt2.Error): | |
27 | cls() | |
28 | ||
29 | def test_no_init_source(self): | |
fa4c33e3 | 30 | class MyIter(bt2._UserMessageIterator): |
f6a5e476 PP |
31 | def __next__(self): |
32 | raise bt2.Stop | |
33 | ||
34 | class MySource(bt2._UserSourceComponent, | |
fa4c33e3 | 35 | message_iterator_class=MyIter): |
f6a5e476 PP |
36 | pass |
37 | ||
38 | self._test_no_init(MySource) | |
39 | ||
40 | def test_no_init_filter(self): | |
fa4c33e3 | 41 | class MyIter(bt2._UserMessageIterator): |
f6a5e476 PP |
42 | def __next__(self): |
43 | raise bt2.Stop | |
44 | ||
45 | class MyFilter(bt2._UserFilterComponent, | |
fa4c33e3 | 46 | message_iterator_class=MyIter): |
f6a5e476 PP |
47 | pass |
48 | ||
49 | self._test_no_init(MyFilter) | |
50 | ||
51 | def test_no_init_sink(self): | |
52 | class MySink(bt2._UserSinkComponent): | |
53 | def _consume(self): | |
54 | pass | |
55 | ||
8a08af82 SM |
56 | def _graph_is_configured(self): |
57 | pass | |
58 | ||
f6a5e476 PP |
59 | self._test_no_init(MySink) |
60 | ||
fa4c33e3 SM |
61 | def test_incomplete_source_no_msg_iter_cls(self): |
62 | class MyIter(bt2._UserMessageIterator): | |
f6a5e476 PP |
63 | pass |
64 | ||
65 | with self.assertRaises(bt2.IncompleteUserClass): | |
66 | class MySource(bt2._UserSourceComponent): | |
67 | pass | |
68 | ||
fa4c33e3 SM |
69 | def test_incomplete_source_wrong_msg_iter_cls_type(self): |
70 | class MyIter(bt2._UserMessageIterator): | |
f6a5e476 PP |
71 | pass |
72 | ||
73 | with self.assertRaises(bt2.IncompleteUserClass): | |
74 | class MySource(bt2._UserSourceComponent, | |
fa4c33e3 | 75 | message_iterator_class=int): |
f6a5e476 PP |
76 | pass |
77 | ||
fa4c33e3 SM |
78 | def test_incomplete_filter_no_msg_iter_cls(self): |
79 | class MyIter(bt2._UserMessageIterator): | |
f6a5e476 PP |
80 | pass |
81 | ||
82 | with self.assertRaises(bt2.IncompleteUserClass): | |
83 | class MyFilter(bt2._UserFilterComponent): | |
84 | pass | |
85 | ||
86 | def test_incomplete_sink_no_consume_method(self): | |
fa4c33e3 | 87 | class MyIter(bt2._UserMessageIterator): |
f6a5e476 PP |
88 | pass |
89 | ||
90 | with self.assertRaises(bt2.IncompleteUserClass): | |
91 | class MySink(bt2._UserSinkComponent): | |
92 | pass | |
93 | ||
94 | def test_minimal_source(self): | |
fa4c33e3 | 95 | class MyIter(bt2._UserMessageIterator): |
f6a5e476 PP |
96 | pass |
97 | ||
98 | class MySource(bt2._UserSourceComponent, | |
fa4c33e3 | 99 | message_iterator_class=MyIter): |
f6a5e476 PP |
100 | pass |
101 | ||
102 | def test_minimal_filter(self): | |
fa4c33e3 | 103 | class MyIter(bt2._UserMessageIterator): |
f6a5e476 PP |
104 | pass |
105 | ||
106 | class MyFilter(bt2._UserFilterComponent, | |
fa4c33e3 | 107 | message_iterator_class=MyIter): |
f6a5e476 PP |
108 | pass |
109 | ||
110 | def test_minimal_sink(self): | |
111 | class MySink(bt2._UserSinkComponent): | |
112 | def _consume(self): | |
113 | pass | |
114 | ||
8a08af82 SM |
115 | def _graph_is_configured(self): |
116 | pass | |
117 | ||
f6a5e476 PP |
118 | def test_default_name(self): |
119 | class MySink(bt2._UserSinkComponent): | |
120 | def _consume(self): | |
121 | pass | |
122 | ||
8a08af82 SM |
123 | def _graph_is_configured(self): |
124 | pass | |
125 | ||
f6a5e476 PP |
126 | self.assertEqual(MySink.name, 'MySink') |
127 | ||
128 | def test_custom_name(self): | |
129 | class MySink(bt2._UserSinkComponent, name='salut'): | |
130 | def _consume(self): | |
131 | pass | |
132 | ||
8a08af82 SM |
133 | def _graph_is_configured(self): |
134 | pass | |
135 | ||
f6a5e476 PP |
136 | self.assertEqual(MySink.name, 'salut') |
137 | ||
138 | def test_invalid_custom_name(self): | |
139 | with self.assertRaises(TypeError): | |
140 | class MySink(bt2._UserSinkComponent, name=23): | |
141 | def _consume(self): | |
142 | pass | |
143 | ||
8a08af82 SM |
144 | def _graph_is_configured(self): |
145 | pass | |
146 | ||
f6a5e476 PP |
147 | def test_description(self): |
148 | class MySink(bt2._UserSinkComponent): | |
149 | """ | |
150 | The description. | |
151 | ||
152 | Bacon ipsum dolor amet ribeye t-bone corned beef, beef jerky | |
153 | porchetta burgdoggen prosciutto chicken frankfurter boudin | |
154 | hamburger doner bacon turducken. Sirloin shank sausage, | |
155 | boudin meatloaf alcatra meatball t-bone tongue pastrami | |
156 | cupim flank tenderloin. | |
157 | """ | |
158 | ||
159 | def _consume(self): | |
160 | pass | |
161 | ||
8a08af82 SM |
162 | def _graph_is_configured(self): |
163 | pass | |
164 | ||
f6a5e476 PP |
165 | self.assertEqual(MySink.description, 'The description.') |
166 | ||
167 | def test_empty_description(self): | |
168 | class MySink(bt2._UserSinkComponent): | |
169 | """ | |
170 | """ | |
171 | ||
172 | def _consume(self): | |
173 | pass | |
174 | ||
8a08af82 SM |
175 | def _graph_is_configured(self): |
176 | pass | |
177 | ||
f6a5e476 PP |
178 | self.assertIsNone(MySink.description) |
179 | ||
180 | def test_help(self): | |
181 | class MySink(bt2._UserSinkComponent): | |
182 | """ | |
183 | The description. | |
184 | ||
185 | The help | |
186 | text is | |
187 | here. | |
188 | """ | |
189 | ||
190 | def _consume(self): | |
191 | pass | |
192 | ||
8a08af82 SM |
193 | def _graph_is_configured(self): |
194 | pass | |
195 | ||
f6a5e476 PP |
196 | self.assertEqual(MySink.help, 'The help\ntext is\nhere.') |
197 | ||
198 | def test_addr(self): | |
199 | class MySink(bt2._UserSinkComponent): | |
200 | def _consume(self): | |
201 | pass | |
202 | ||
8a08af82 SM |
203 | def _graph_is_configured(self): |
204 | pass | |
205 | ||
f6a5e476 PP |
206 | self.assertIsInstance(MySink.addr, int) |
207 | self.assertNotEqual(MySink.addr, 0) | |
208 | ||
209 | def test_query_not_implemented(self): | |
210 | class MySink(bt2._UserSinkComponent): | |
211 | def _consume(self): | |
212 | pass | |
213 | ||
8a08af82 SM |
214 | def _graph_is_configured(self): |
215 | pass | |
216 | ||
f6a5e476 | 217 | with self.assertRaises(bt2.Error): |
1286dcbb | 218 | bt2.QueryExecutor().query(MySink, 'obj', 23) |
f6a5e476 PP |
219 | |
220 | def test_query_raises(self): | |
221 | class MySink(bt2._UserSinkComponent): | |
222 | def _consume(self): | |
223 | pass | |
224 | ||
8a08af82 SM |
225 | def _graph_is_configured(self): |
226 | pass | |
227 | ||
f6a5e476 | 228 | @classmethod |
83da519a | 229 | def _query(cls, query_exec, obj, params, log_level): |
f6a5e476 PP |
230 | raise ValueError |
231 | ||
232 | with self.assertRaises(bt2.Error): | |
1286dcbb | 233 | bt2.QueryExecutor().query(MySink, 'obj', 23) |
f6a5e476 PP |
234 | |
235 | def test_query_wrong_return_type(self): | |
236 | class MySink(bt2._UserSinkComponent): | |
237 | def _consume(self): | |
238 | pass | |
239 | ||
8a08af82 SM |
240 | def _graph_is_configured(self): |
241 | pass | |
242 | ||
f6a5e476 | 243 | @classmethod |
83da519a | 244 | def _query(cls, query_exec, obj, params, log_level): |
f6a5e476 PP |
245 | return ... |
246 | ||
247 | with self.assertRaises(bt2.Error): | |
1286dcbb | 248 | bt2.QueryExecutor().query(MySink, 'obj', 23) |
f6a5e476 PP |
249 | |
250 | def test_query_params_none(self): | |
251 | class MySink(bt2._UserSinkComponent): | |
252 | def _consume(self): | |
253 | pass | |
254 | ||
8a08af82 SM |
255 | def _graph_is_configured(self): |
256 | pass | |
257 | ||
f6a5e476 | 258 | @classmethod |
83da519a | 259 | def _query(cls, query_exec, obj, params, log_level): |
f6a5e476 PP |
260 | nonlocal query_params |
261 | query_params = params | |
262 | return None | |
263 | ||
264 | query_params = None | |
265 | params = None | |
1286dcbb | 266 | res = bt2.QueryExecutor().query(MySink, 'obj', params) |
f6a5e476 PP |
267 | self.assertEqual(query_params, params) |
268 | self.assertIsNone(res) | |
269 | del query_params | |
270 | ||
999e7442 PP |
271 | def test_query_logging_level(self): |
272 | class MySink(bt2._UserSinkComponent): | |
273 | def _consume(self): | |
274 | pass | |
275 | ||
8a08af82 SM |
276 | def _graph_is_configured(self): |
277 | pass | |
278 | ||
999e7442 PP |
279 | @classmethod |
280 | def _query(cls, query_exec, obj, params, log_level): | |
281 | nonlocal query_log_level | |
282 | query_log_level = log_level | |
283 | ||
284 | query_log_level = None | |
285 | res = bt2.QueryExecutor().query(MySink, 'obj', None, | |
e9d0e821 PP |
286 | bt2.LoggingLevel.WARNING) |
287 | self.assertEqual(query_log_level, bt2.LoggingLevel.WARNING) | |
999e7442 PP |
288 | del query_log_level |
289 | ||
70ad0c69 SM |
290 | def test_query_returns_none(self): |
291 | class MySink(bt2._UserSinkComponent): | |
292 | def _consume(self): | |
293 | pass | |
294 | ||
8a08af82 SM |
295 | def _graph_is_configured(self): |
296 | pass | |
297 | ||
70ad0c69 SM |
298 | @staticmethod |
299 | def _query(query_exec, obj, params, log_level): | |
300 | return | |
301 | ||
302 | res = bt2.QueryExecutor().query(MySink, 'obj', None) | |
303 | self.assertIsNone(res) | |
304 | ||
f6a5e476 PP |
305 | def test_query_simple(self): |
306 | class MySink(bt2._UserSinkComponent): | |
307 | def _consume(self): | |
308 | pass | |
309 | ||
8a08af82 SM |
310 | def _graph_is_configured(self): |
311 | pass | |
312 | ||
f6a5e476 | 313 | @classmethod |
83da519a | 314 | def _query(cls, query_exec, obj, params, log_level): |
f6a5e476 PP |
315 | nonlocal query_params |
316 | query_params = params | |
317 | return 17.5 | |
318 | ||
319 | query_params = None | |
320 | params = ['coucou', 23, None] | |
1286dcbb | 321 | res = bt2.QueryExecutor().query(MySink, 'obj', params) |
f6a5e476 PP |
322 | self.assertEqual(query_params, params) |
323 | self.assertEqual(res, 17.5) | |
324 | del query_params | |
325 | ||
326 | def test_query_complex(self): | |
327 | class MySink(bt2._UserSinkComponent): | |
328 | def _consume(self): | |
329 | pass | |
330 | ||
8a08af82 SM |
331 | def _graph_is_configured(self): |
332 | pass | |
333 | ||
f6a5e476 | 334 | @classmethod |
83da519a | 335 | def _query(cls, query_exec, obj, params, log_level): |
f6a5e476 PP |
336 | nonlocal query_params |
337 | query_params = params | |
338 | return { | |
339 | 'null': None, | |
340 | 'bt2': 'BT2', | |
341 | } | |
342 | ||
343 | query_params = None | |
344 | params = { | |
345 | 'array': ['coucou', 23, None], | |
346 | 'other_map': { | |
347 | 'yes': 'yeah', | |
348 | '19': 19, | |
349 | 'minus 1.5': -1.5, | |
350 | }, | |
351 | 'null': None, | |
352 | } | |
353 | ||
1286dcbb | 354 | res = bt2.QueryExecutor().query(MySink, 'obj', params) |
f6a5e476 PP |
355 | self.assertEqual(query_params, params) |
356 | self.assertEqual(res, { | |
357 | 'null': None, | |
358 | 'bt2': 'BT2', | |
359 | }) | |
360 | del query_params | |
361 | ||
362 | def test_eq(self): | |
363 | class MySink(bt2._UserSinkComponent): | |
364 | def _consume(self): | |
365 | pass | |
366 | ||
8a08af82 SM |
367 | def _graph_is_configured(self): |
368 | pass | |
369 | ||
f6a5e476 PP |
370 | self.assertEqual(MySink, MySink) |
371 | ||
372 | ||
373 | class GenericComponentClassTestCase(unittest.TestCase): | |
374 | def setUp(self): | |
375 | class MySink(bt2._UserSinkComponent): | |
376 | ''' | |
377 | The description. | |
378 | ||
379 | The help. | |
380 | ''' | |
381 | def _consume(self): | |
382 | pass | |
383 | ||
8a08af82 SM |
384 | def _graph_is_configured(self): |
385 | pass | |
386 | ||
f6a5e476 | 387 | @classmethod |
83da519a | 388 | def _query(cls, query_exec, obj, params, log_level): |
f6a5e476 PP |
389 | return [obj, params, 23] |
390 | ||
391 | self._py_comp_cls = MySink | |
392 | graph = bt2.Graph() | |
bc5c9924 | 393 | comp = graph.add_component(MySink, 'salut') |
c88be1c8 | 394 | self._comp_cls = comp.cls |
f6a5e476 PP |
395 | self.assertTrue(issubclass(type(self._comp_cls), |
396 | bt2.component._GenericComponentClass)) | |
397 | ||
398 | def tearDown(self): | |
399 | del self._py_comp_cls | |
400 | del self._comp_cls | |
401 | ||
402 | def test_description(self): | |
403 | self.assertEqual(self._comp_cls.description, 'The description.') | |
404 | ||
405 | def test_help(self): | |
406 | self.assertEqual(self._comp_cls.help, 'The help.') | |
407 | ||
408 | def test_name(self): | |
409 | self.assertEqual(self._comp_cls.name, 'MySink') | |
410 | ||
411 | def test_addr(self): | |
412 | self.assertIsInstance(self._comp_cls.addr, int) | |
413 | self.assertNotEqual(self._comp_cls.addr, 0) | |
414 | ||
415 | def test_eq_invalid(self): | |
416 | self.assertFalse(self._comp_cls == 23) | |
417 | ||
418 | def test_eq(self): | |
419 | self.assertEqual(self._comp_cls, self._comp_cls) | |
420 | self.assertEqual(self._py_comp_cls, self._comp_cls) | |
421 | ||
422 | def test_query(self): | |
1286dcbb PP |
423 | res = bt2.QueryExecutor().query(self._comp_cls, 'an object', |
424 | {'yes': 'no', 'book': -17}) | |
f6a5e476 PP |
425 | expected = ['an object', {'yes': 'no', 'book': -17}, 23] |
426 | self.assertEqual(res, expected) |