vigigraph / vigigraph / tests / functional / test_host_selection_form.py @ 71709694
History | View | Annotate | Download (19.8 KB)
1 |
# -*- coding: utf-8 -*-
|
---|---|
2 |
# Copyright (C) 2006-2020 CS GROUP – France
|
3 |
# License: GNU GPL v2 <http://www.gnu.org/licenses/gpl-2.0.html>
|
4 |
|
5 |
"""
|
6 |
Suite de tests de l'arbre de sélection des hôtes et groupes d'hôtes.
|
7 |
"""
|
8 |
import transaction |
9 |
|
10 |
from vigigraph.tests import TestController |
11 |
from vigilo.models.session import DBSession |
12 |
from vigilo.models.tables import Host, SupItemGroup |
13 |
from vigigraph.tests.functional.helpers import populateDB |
14 |
|
15 |
class TestHostTree(TestController): |
16 |
"""
|
17 |
Teste l'arbre de sélection des hôtes
|
18 |
et groupes d'hôtes de Vigigraph.
|
19 |
"""
|
20 |
|
21 |
def setUp(self): |
22 |
"""Préparation de la base de données de tests."""
|
23 |
|
24 |
# Initialisation de la base
|
25 |
super(TestHostTree, self).setUp() |
26 |
|
27 |
# Ajout de données de tests dans la base
|
28 |
populateDB() |
29 |
|
30 |
# Validation des ajouts dans la base
|
31 |
DBSession.flush() |
32 |
transaction.commit() |
33 |
|
34 |
def test_get_root_host_groups_as_manager(self): |
35 |
"""
|
36 |
Récupération des groupes d'hôtes racines en tant que manager
|
37 |
|
38 |
L'utilisateur "manager" appartient au groupe "managers",
|
39 |
qui a accès à tout et doit donc pouvoir lister tous
|
40 |
les groupes racines.
|
41 |
"""
|
42 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
43 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
44 |
SupItemGroup.name == u'mhg').first()
|
45 |
|
46 |
# Récupération des groupes d'hôtes principaux
|
47 |
# accessibles à l'utilisateur 'manager'.
|
48 |
response = self.app.post(
|
49 |
'/rpc/hosttree', {
|
50 |
}, extra_environ={'REMOTE_USER': 'manager'}) |
51 |
json = response.json |
52 |
|
53 |
# On s'assure que la liste de groupes
|
54 |
# d'hôtes retournée contient bien 'mhg'
|
55 |
self.assertEqual(
|
56 |
json, { |
57 |
'items': [], 'groups': [{ |
58 |
'id': mainhostgroup.idgroup,
|
59 |
'name': mainhostgroup.name,
|
60 |
'type': 'group', |
61 |
}] |
62 |
} |
63 |
) |
64 |
|
65 |
def test_get_main_host_groups_when_directly_allowed(self): |
66 |
"""
|
67 |
Récupération des groupes d'hôtes racines avec permissions directes
|
68 |
|
69 |
L'utilisateur "poweruser" a les permissions sur le
|
70 |
groupe racine "mhg" et peut donc le lister.
|
71 |
"""
|
72 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
73 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
74 |
SupItemGroup.name == u'mhg').first()
|
75 |
|
76 |
# Récupération des groupes d'hôtes principaux
|
77 |
# accessibles à l'utilisateur 'poweruser'
|
78 |
response = self.app.post(
|
79 |
'/rpc/hosttree', {
|
80 |
}, extra_environ={'REMOTE_USER': 'poweruser'}) |
81 |
json = response.json |
82 |
|
83 |
# On s'assure que la liste de groupes
|
84 |
# d'hôtes retournée contient bien 'mhg'
|
85 |
self.assertEqual(
|
86 |
json, { |
87 |
'items': [], 'groups': [{ |
88 |
'id': mainhostgroup.idgroup,
|
89 |
'name': mainhostgroup.name,
|
90 |
'type': 'group', |
91 |
}] |
92 |
} |
93 |
) |
94 |
|
95 |
def test_get_root_host_groups_for_children(self): |
96 |
"""
|
97 |
Récupération des groupes d'hôtes racines pour un sous-groupe
|
98 |
|
99 |
L'utilisateur "user" n'a pas les permissions sur "mhg",
|
100 |
mais il a accès au sous-groupe "hg1". Il doit pouvoir
|
101 |
lister le groupe racine "mhg" pour pouvoir accéder à "hg1".
|
102 |
"""
|
103 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
104 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
105 |
SupItemGroup.name == u'mhg').first()
|
106 |
|
107 |
# Récupération des groupes d'hôtes principaux
|
108 |
# accessibles à l'utilisateur 'user'
|
109 |
response = self.app.post(
|
110 |
'/rpc/hosttree', {
|
111 |
}, extra_environ={'REMOTE_USER': 'user'}) |
112 |
json = response.json |
113 |
|
114 |
# On s'assure que la liste de groupes
|
115 |
# d'hôtes retournée contient bien 'mhg'
|
116 |
self.assertEqual(
|
117 |
json, { |
118 |
'items': [], 'groups': [{ |
119 |
'id': mainhostgroup.idgroup,
|
120 |
'name': mainhostgroup.name,
|
121 |
'type': 'group', |
122 |
}] |
123 |
} |
124 |
) |
125 |
|
126 |
def test_get_main_host_groups_when_not_allowed(self): |
127 |
"""
|
128 |
Récupération des groupes d'hôtes principaux sans les bons droits
|
129 |
|
130 |
L'utilisateur "visitor" n'a accès à rien et ne doit donc
|
131 |
pas pouvoir lister le groupe racine "mhg".
|
132 |
"""
|
133 |
|
134 |
# Récupération des groupes d'hôtes principaux
|
135 |
# accessibles à l'utilisateur 'visitor'
|
136 |
response = self.app.post(
|
137 |
'/rpc/hosttree', {
|
138 |
}, extra_environ={'REMOTE_USER': 'visitor'}) |
139 |
json = response.json |
140 |
|
141 |
# On s'assure que la liste de groupes d'hôtes retournée est bien vide
|
142 |
self.assertEqual(
|
143 |
json, {'items': [], 'groups': []} |
144 |
) |
145 |
|
146 |
def test_get_main_host_groups_as_anonymous(self): |
147 |
"""
|
148 |
Récupération des groupes d'hôtes principaux en tant qu'anonyme
|
149 |
|
150 |
Une tentative de récupération des groupes racines
|
151 |
sans être authentifié doit demander à l'utilisateur
|
152 |
de s'authentifier.
|
153 |
"""
|
154 |
|
155 |
# Récupération des groupes d'hôtes principaux
|
156 |
# par un utilisateur anonyme : le contrôleur doit
|
157 |
# retourner une erreur 401 (HTTPUnauthorized)
|
158 |
self.app.post(
|
159 |
'/rpc/hosttree', {
|
160 |
}, status=401)
|
161 |
|
162 |
def test_get_host_groups_when_allowed(self): |
163 |
"""
|
164 |
Récupération des groupes d'hôtes secondaires avec les bons droits
|
165 |
"""
|
166 |
|
167 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
168 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
169 |
SupItemGroup.name == u'mhg').first()
|
170 |
|
171 |
# Récupération du groupe d'hôtes 'hg1' dans la base de données
|
172 |
hostgroup1 = DBSession.query(SupItemGroup).filter( |
173 |
SupItemGroup.name == u'hg1').first()
|
174 |
|
175 |
# Récupération du groupe d'hôtes 'hg2' dans la base de données
|
176 |
hostgroup2 = DBSession.query(SupItemGroup).filter( |
177 |
SupItemGroup.name == u'hg2').first()
|
178 |
|
179 |
# Récupération de l'hôte 'host1' dans la base de données
|
180 |
host1 = DBSession.query(Host).filter( |
181 |
Host.name == u'host1 éà').first()
|
182 |
|
183 |
# Récupération des groupes d'hôtes
|
184 |
# accessibles à l'utilisateur 'manager'
|
185 |
response = self.app.post(
|
186 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
187 |
}, extra_environ={'REMOTE_USER': 'manager'}) |
188 |
json = response.json |
189 |
|
190 |
# On s'assure que la liste de groupes d'hôtes retournée
|
191 |
# contient bien 'No subgroup', 'hg1', et 'hg2'
|
192 |
self.assertEqual(
|
193 |
json, { |
194 |
'items': [
|
195 |
{'id': host1.idhost, 'name': host1.name, 'type': 'item'} |
196 |
], |
197 |
'groups': [
|
198 |
{ |
199 |
'id': hostgroup1.idgroup,
|
200 |
'name': hostgroup1.name,
|
201 |
'type': 'group', |
202 |
}, |
203 |
{ |
204 |
'id': hostgroup2.idgroup,
|
205 |
'name': hostgroup2.name,
|
206 |
'type': 'group', |
207 |
}, |
208 |
], |
209 |
} |
210 |
) |
211 |
|
212 |
# Récupération des groupes d'hôtes
|
213 |
# accessibles à l'utilisateur 'poweruser'
|
214 |
response = self.app.post(
|
215 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
216 |
}, extra_environ={'REMOTE_USER': 'poweruser'}) |
217 |
json = response.json |
218 |
|
219 |
# On s'assure que la liste de groupes d'hôtes retournée
|
220 |
# contient bien 'No subgroup', 'hg1', et 'hg2'
|
221 |
self.assertEqual(
|
222 |
json, { |
223 |
'items': [
|
224 |
{'id': host1.idhost, 'name': host1.name, 'type': 'item'} |
225 |
], |
226 |
'groups': [
|
227 |
{ |
228 |
'id': hostgroup1.idgroup,
|
229 |
'name': hostgroup1.name,
|
230 |
'type': 'group', |
231 |
}, |
232 |
{ |
233 |
'id': hostgroup2.idgroup,
|
234 |
'name': hostgroup2.name,
|
235 |
'type': 'group', |
236 |
}, |
237 |
], |
238 |
} |
239 |
) |
240 |
|
241 |
# Récupération des groupes d'hôtes
|
242 |
# accessibles à l'utilisateur 'user'
|
243 |
response = self.app.post(
|
244 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
245 |
}, extra_environ={'REMOTE_USER': 'user'}) |
246 |
json = response.json |
247 |
|
248 |
# On s'assure que la liste de groupes
|
249 |
# d'hôtes retournée contient bien 'hg1'
|
250 |
self.assertEqual(
|
251 |
json, { |
252 |
'items': [],
|
253 |
'groups': [
|
254 |
{ |
255 |
'id': hostgroup1.idgroup,
|
256 |
'name': hostgroup1.name,
|
257 |
'type': 'group', |
258 |
}, |
259 |
], |
260 |
} |
261 |
) |
262 |
|
263 |
def test_get_host_groups_when_not_allowed(self): |
264 |
"""
|
265 |
Récupération des groupes d'hôtes secondaires sans les bons droits
|
266 |
"""
|
267 |
|
268 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
269 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
270 |
SupItemGroup.name == u'mhg').first()
|
271 |
|
272 |
# Récupération des groupes d'hôtes
|
273 |
# accessibles à l'utilisateur 'visitor'
|
274 |
response = self.app.post(
|
275 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
276 |
}, extra_environ={'REMOTE_USER': 'visitor'}) |
277 |
json = response.json |
278 |
|
279 |
# On s'assure que la liste de groupes d'hôtes retournée est bien vide
|
280 |
self.assertEqual(
|
281 |
json, {'items': [], 'groups': []} |
282 |
) |
283 |
|
284 |
def test_get_host_groups_as_anonymous(self): |
285 |
"""
|
286 |
Récupération des groupes d'hôtes secondaires en tant qu'anonyme
|
287 |
"""
|
288 |
|
289 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
290 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
291 |
SupItemGroup.name == u'mhg').first()
|
292 |
|
293 |
# Récupération des groupes d'hôtes par un
|
294 |
# utilisateur anonyme : le contrôleur doit
|
295 |
# retourner une erreur 401 (HTTPUnauthorized)
|
296 |
self.app.post(
|
297 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
298 |
}, status=401)
|
299 |
|
300 |
def test_get_host_groups_from_inexisting_main_group(self): |
301 |
"""
|
302 |
Récupération des groupes d'hôtes d'un groupe principal inexistant
|
303 |
"""
|
304 |
|
305 |
# Récupération des groupes d'hôtes accessibles à l'utilisateur
|
306 |
# 'manager' et appartenant à un groupe principal inexistant
|
307 |
response = self.app.post(
|
308 |
'/rpc/hosttree?parent_id=6666666', {
|
309 |
}, extra_environ={'REMOTE_USER': 'manager'}) |
310 |
json = response.json |
311 |
|
312 |
# On s'assure que la liste de groupes d'hôtes retournée est bien vide
|
313 |
self.assertEqual(
|
314 |
json, {'items': [], 'groups': []} |
315 |
) |
316 |
|
317 |
def test_get_hosts_when_allowed(self): |
318 |
"""
|
319 |
Récupération des hôtes avec les bons droits
|
320 |
"""
|
321 |
|
322 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
323 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
324 |
SupItemGroup.name == u'mhg').first()
|
325 |
|
326 |
# Récupération du groupe d'hôtes 'hg1' dans la base de données
|
327 |
hostgroup1 = DBSession.query(SupItemGroup).filter( |
328 |
SupItemGroup.name == u'hg1').first()
|
329 |
|
330 |
# Récupération du groupe d'hôtes 'hg2' dans la base de données
|
331 |
hostgroup2 = DBSession.query(SupItemGroup).filter( |
332 |
SupItemGroup.name == u'hg2').first()
|
333 |
|
334 |
# Récupération de l'hôte 'host1' dans la base de données
|
335 |
host1 = DBSession.query(Host).filter( |
336 |
Host.name == u'host1 éà').first()
|
337 |
|
338 |
# Récupération de l'hôte 'host2' dans la base de données
|
339 |
host2 = DBSession.query(Host).filter( |
340 |
Host.name == u'host2 éà').first()
|
341 |
|
342 |
# Récupération des hôtes du groupe 'mhg'
|
343 |
# accessibles à l'utilisateur 'manager'
|
344 |
response = self.app.post(
|
345 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
346 |
}, extra_environ={'REMOTE_USER': 'manager'}) |
347 |
json = response.json |
348 |
|
349 |
# On s'assure que la liste d'hôtes retournée contient bien 'host1'
|
350 |
self.assertEqual(
|
351 |
json, { |
352 |
'items': [
|
353 |
{ |
354 |
'id': host1.idhost,
|
355 |
'name': host1.name,
|
356 |
'type': 'item', |
357 |
}, |
358 |
], |
359 |
'groups': [
|
360 |
{ |
361 |
'id': hostgroup1.idgroup,
|
362 |
'name': hostgroup1.name,
|
363 |
'type': 'group', |
364 |
}, |
365 |
{ |
366 |
'id': hostgroup2.idgroup,
|
367 |
'name': hostgroup2.name,
|
368 |
'type': 'group', |
369 |
}, |
370 |
], |
371 |
} |
372 |
) |
373 |
|
374 |
# Récupération des hôtes du groupe 'hg1'
|
375 |
# accessibles à l'utilisateur 'manager'
|
376 |
response = self.app.post(
|
377 |
'/rpc/hosttree?parent_id=%s' % (hostgroup1.idgroup, ), {
|
378 |
}, extra_environ={'REMOTE_USER': 'manager'}) |
379 |
json = response.json |
380 |
|
381 |
# On s'assure que la liste d'hotes retournée contient bien 'host2'
|
382 |
self.assertEqual(
|
383 |
json, { |
384 |
'items': [
|
385 |
{ |
386 |
'id': host2.idhost,
|
387 |
'name': host2.name,
|
388 |
'type': 'item', |
389 |
}, |
390 |
], |
391 |
'groups': [],
|
392 |
} |
393 |
) |
394 |
|
395 |
# Récupération des hôtes du groupe 'mhg'
|
396 |
# accessibles à l'utilisateur 'poweruser'
|
397 |
response = self.app.post(
|
398 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
399 |
}, extra_environ={'REMOTE_USER': 'poweruser'}) |
400 |
json = response.json |
401 |
|
402 |
# On s'assure que la liste d'hôtes retournée contient bien 'host1'
|
403 |
self.assertEqual(
|
404 |
json, { |
405 |
'items': [
|
406 |
{ |
407 |
'id': host1.idhost,
|
408 |
'name': host1.name,
|
409 |
'type': 'item', |
410 |
}, |
411 |
], |
412 |
'groups': [
|
413 |
{ |
414 |
'id': hostgroup1.idgroup,
|
415 |
'name': hostgroup1.name,
|
416 |
'type': 'group', |
417 |
}, |
418 |
{ |
419 |
'id': hostgroup2.idgroup,
|
420 |
'name': hostgroup2.name,
|
421 |
'type': 'group', |
422 |
}, |
423 |
], |
424 |
} |
425 |
) |
426 |
|
427 |
# Récupération des hôtes du groupe 'hg1'
|
428 |
# accessibles à l'utilisateur 'poweruser'
|
429 |
response = self.app.post(
|
430 |
'/rpc/hosttree?parent_id=%s' % (hostgroup1.idgroup, ), {
|
431 |
}, extra_environ={'REMOTE_USER': 'poweruser'}) |
432 |
json = response.json |
433 |
|
434 |
# On s'assure que la liste d'hotes retournée contient bien 'host2'
|
435 |
self.assertEqual(
|
436 |
json, { |
437 |
'items': [
|
438 |
{ |
439 |
'id': host2.idhost,
|
440 |
'name': host2.name,
|
441 |
'type': 'item', |
442 |
}, |
443 |
], |
444 |
'groups': [],
|
445 |
} |
446 |
) |
447 |
|
448 |
# Récupération des hôtes du groupe 'hg1'
|
449 |
# accessibles à l'utilisateur 'user'
|
450 |
response = self.app.post(
|
451 |
'/rpc/hosttree?parent_id=%s' % (hostgroup1.idgroup, ), {
|
452 |
}, extra_environ={'REMOTE_USER': 'user'}) |
453 |
json = response.json |
454 |
|
455 |
# On s'assure que la liste d'hôtes retournée contient bien 'host2'
|
456 |
self.assertEqual(
|
457 |
json, { |
458 |
'items': [
|
459 |
{ |
460 |
'id': host2.idhost,
|
461 |
'name': host2.name,
|
462 |
'type': 'item', |
463 |
}, |
464 |
], |
465 |
'groups': [],
|
466 |
} |
467 |
) |
468 |
|
469 |
def test_get_hosts_when_not_allowed(self): |
470 |
"""
|
471 |
Récupération des hôtes sans les bons droits
|
472 |
"""
|
473 |
|
474 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
475 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
476 |
SupItemGroup.name == u'mhg').first()
|
477 |
|
478 |
# Récupération du groupe d'hôtes
|
479 |
# secondaire 'hg1' dans la base de données
|
480 |
hostgroup1 = DBSession.query(SupItemGroup).filter( |
481 |
SupItemGroup.name == u'hg1').first()
|
482 |
|
483 |
# Récupération du groupe d'hôtes
|
484 |
# secondaire 'hg2' dans la base de données
|
485 |
hostgroup2 = DBSession.query(SupItemGroup).filter( |
486 |
SupItemGroup.name == u'hg2').first()
|
487 |
|
488 |
# Récupération des hôtes du groupe 'mhg'
|
489 |
# accessibles à l'utilisateur 'user'
|
490 |
response = self.app.post(
|
491 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
492 |
}, extra_environ={'REMOTE_USER': 'user'}) |
493 |
json = response.json |
494 |
|
495 |
# On s'assure que la liste d'hôtes retournée est vide
|
496 |
self.assertEqual(
|
497 |
json, { |
498 |
'items': [],
|
499 |
'groups': [
|
500 |
{ |
501 |
'name': hostgroup1.name,
|
502 |
'id': hostgroup1.idgroup,
|
503 |
'type': 'group', |
504 |
}, |
505 |
], |
506 |
} |
507 |
) |
508 |
|
509 |
# Récupération des hôtes du groupe 'hg2'
|
510 |
# accessibles à l'utilisateur 'user'
|
511 |
response = self.app.post(
|
512 |
'/rpc/hosttree?parent_id=%s' % (hostgroup2.idgroup, ), {
|
513 |
}, extra_environ={'REMOTE_USER': 'user'}) |
514 |
json = response.json |
515 |
|
516 |
# On s'assure que la liste d'hôtes retournée est vide
|
517 |
self.assertEqual(
|
518 |
json, {'items': [], 'groups': []} |
519 |
) |
520 |
|
521 |
# Récupération des hôtes du groupe 'mhg'
|
522 |
# accessibles à l'utilisateur 'visitor'
|
523 |
response = self.app.post(
|
524 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
525 |
}, extra_environ={'REMOTE_USER': 'visitor'}) |
526 |
json = response.json |
527 |
|
528 |
# On s'assure que la liste d'hôtes retournée est vide
|
529 |
self.assertEqual(
|
530 |
json, {'items': [], 'groups': []} |
531 |
) |
532 |
|
533 |
# Récupération des hôtes du groupe 'hg1'
|
534 |
# accessibles à l'utilisateur 'visitor'
|
535 |
response = self.app.post(
|
536 |
'/rpc/hosttree?parent_id=%s' % (hostgroup1.idgroup, ), {
|
537 |
}, extra_environ={'REMOTE_USER': 'visitor'}) |
538 |
json = response.json |
539 |
|
540 |
# On s'assure que la liste d'hôtes retournée est vide
|
541 |
self.assertEqual(
|
542 |
json, {'items': [], 'groups': []} |
543 |
) |
544 |
|
545 |
def test_get_hosts_as_anonymous(self): |
546 |
"""
|
547 |
Récupération des hôtes en tant qu'anonyme
|
548 |
"""
|
549 |
|
550 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données
|
551 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
552 |
SupItemGroup.name == u'mhg').first()
|
553 |
|
554 |
# Récupération des hôtes du groupe 'mhg' par
|
555 |
# un utilisateur anonyme : le contrôleur doit
|
556 |
# retourner une erreur 401 (HTTPUnauthorized)
|
557 |
self.app.post(
|
558 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
559 |
}, status=401)
|
560 |
|
561 |
def test_get_hosts_from_inexisting_secondary_group(self): |
562 |
"""
|
563 |
Récupération des hôtes d'un groupe secondaire inexistant
|
564 |
"""
|
565 |
|
566 |
# Récupération des hôtes accessibles à l'utilisateur
|
567 |
# 'manager' et appartenant à un groupe secondaire inexistant
|
568 |
response = self.app.post(
|
569 |
'/rpc/hosttree?parent_id=6666666', {
|
570 |
}, extra_environ={'REMOTE_USER': 'manager'}) |
571 |
json = response.json |
572 |
|
573 |
# On s'assure que la liste retournée est vide
|
574 |
self.assertEqual(
|
575 |
json, {'items': [], 'groups': []} |
576 |
) |