Revision 7e6517fe
Retrait des modifications liées à la fusion de la branche nested_sets du trunk (révisions r6116, r6121 et r6129).
Le nouveau mécanisme nécessite encore des ajustements pour être utilisable.
git-svn-id: https://vigilo-dev.si.c-s.fr/svn@6135 b22e2e97-25c9-44ff-b637-2e5ceca36478
| vigigraph/controllers/rpc.py | ||
|---|---|---|
| 30 | 30 |
from vigilo.models.tables import SupItemGroup |
| 31 | 31 |
from vigilo.models.tables import PerfDataSource |
| 32 | 32 |
from vigilo.models.tables import Graph, GraphGroup |
| 33 |
from vigilo.models.tables.grouphierarchy import GroupHierarchy |
|
| 33 | 34 |
from vigilo.models.tables import Change |
| 34 | 35 |
|
| 35 | 36 |
from vigilo.models.tables.secondary_tables import SUPITEM_GROUP_TABLE |
| ... | ... | |
| 96 | 97 |
Un critere peut correspondre a un intitule complet hote ou graphe |
| 97 | 98 |
ou a un extrait. |
| 98 | 99 |
|
| 100 |
@param kwargs : arguments nommes |
|
| 101 |
@type kwargs : dict |
|
| 102 |
( arguments nommes -> host et graphe ) |
|
| 103 |
|
|
| 99 | 104 |
@return: couples hote-graphe |
| 100 |
@rtype: dict
|
|
| 105 |
@rtype: document json (sous forme de dict)
|
|
| 101 | 106 |
""" |
| 102 | 107 |
user = get_current_user() |
| 103 | 108 |
items = [] |
| ... | ... | |
| 105 | 110 |
if user is None: |
| 106 | 111 |
return dict(items=[]) |
| 107 | 112 |
|
| 108 |
# On a un nom de graphe, mais pas de nom d'hôte,
|
|
| 109 |
# on considère que l'utilisateur veut tous les graphes
|
|
| 113 |
# On a un nom d'indicateur, mais pas de nom d'hôte,
|
|
| 114 |
# on considère que l'utilisateur veut tous les indicateurs
|
|
| 110 | 115 |
# correspondant au motif, quel que soit l'hôte. |
| 111 | 116 |
if search_form_graph: |
| 112 | 117 |
if not search_form_host: |
| ... | ... | |
| 161 | 166 |
if not is_manager: |
| 162 | 167 |
supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]] |
| 163 | 168 |
# pylint: disable-msg=E1103 |
| 164 |
items = items.filter( |
|
| 165 |
SUPITEM_GROUP_TABLE.c.idgroup.in_(supitemgroups)) |
|
| 169 |
items = items.join( |
|
| 170 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 171 |
SUPITEM_GROUP_TABLE.c.idgroup) |
|
| 172 |
).filter(GroupHierarchy.idparent.in_(supitemgroups)) |
|
| 166 | 173 |
|
| 167 | 174 |
items = items.limit(100).all() # pylint: disable-msg=E1103 |
| 168 | 175 |
if not search_form_graph: |
| ... | ... | |
| 348 | 355 |
is_manager = in_group('managers').is_met(request.environ)
|
| 349 | 356 |
if not is_manager: |
| 350 | 357 |
supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]] |
| 351 |
graphs = graphs.filter( |
|
| 352 |
SUPITEM_GROUP_TABLE.c.idgroup.in_(supitemgroups)) |
|
| 358 |
graphs = graphs.join( |
|
| 359 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 360 |
SUPITEM_GROUP_TABLE.c.idgroup) |
|
| 361 |
).filter(GroupHierarchy.idparent.in_(supitemgroups)) |
|
| 353 | 362 |
|
| 354 | 363 |
graphs = graphs.all() |
| 355 | 364 |
return dict(host=host, start=start, duration=duration, |
| ... | ... | |
| 385 | 394 |
).join( |
| 386 | 395 |
(SUPITEM_GROUP_TABLE, SUPITEM_GROUP_TABLE.c.idsupitem == \ |
| 387 | 396 |
Host.idhost), |
| 388 |
).filter(Host.name.like(query + u'%')
|
|
| 397 |
).filter(Host.name.like(query + '%') |
|
| 389 | 398 |
).order_by( |
| 390 | 399 |
Host.name.asc(), |
| 391 | 400 |
) |
| ... | ... | |
| 395 | 404 |
is_manager = in_group('managers').is_met(request.environ)
|
| 396 | 405 |
if not is_manager: |
| 397 | 406 |
supitemgroups = [sig[0] for sig in user.supitemgroups() if sig[1]] |
| 398 |
hosts = hosts.filter( |
|
| 399 |
SUPITEM_GROUP_TABLE.c.idgroup.in_(supitemgroups)) |
|
| 407 |
hosts = hosts.join( |
|
| 408 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 409 |
SUPITEM_GROUP_TABLE.c.idgroup) |
|
| 410 |
).filter(GroupHierarchy.idparent.in_(supitemgroups)) |
|
| 400 | 411 |
|
| 401 | 412 |
return dict(hosts=hosts) |
| 402 | 413 |
|
| ... | ... | |
| 423 | 434 |
|
| 424 | 435 |
# Si l'identifiant du groupe parent n'est pas |
| 425 | 436 |
# spécifié, on retourne la liste des groupes racines, |
| 426 |
# fournie par la méthode get_root_host_groups. |
|
| 437 |
# fournie par la méthode get_root_hosts_groups.
|
|
| 427 | 438 |
if parent_id is None: |
| 428 | 439 |
return self.get_root_host_groups() |
| 429 | 440 |
|
| 430 | 441 |
# TODO: Utiliser un schéma de validation |
| 431 | 442 |
parent_id = int(parent_id) |
| 432 |
parent = DBSession.query(SupItemGroup).get(parent_id) |
|
| 433 |
if not parent: |
|
| 434 |
return dict(groups = [], leaves = []) |
|
| 435 |
|
|
| 436 |
# On récupère la liste des groupes qui ont pour parent |
|
| 437 |
# le groupe dont l'identifiant est passé en paramètre |
|
| 438 |
# et auquel l'utilisateur a accès. |
|
| 439 |
db_groups = list(parent.children) # copie |
|
| 440 |
user = get_current_user() |
|
| 443 |
|
|
| 444 |
# On vérifie si le groupe parent fait partie des |
|
| 445 |
# groupes auxquel l'utilisateur a accès, et on |
|
| 446 |
# retourne une liste vide dans le cas contraire |
|
| 441 | 447 |
is_manager = in_group('managers').is_met(request.environ)
|
| 442 |
user_groups = {}
|
|
| 443 | 448 |
if not is_manager: |
| 449 |
direct_access = False |
|
| 450 |
user = get_current_user() |
|
| 444 | 451 |
user_groups = dict(user.supitemgroups()) |
| 445 |
copy = list(db_groups) |
|
| 446 |
for db_group in copy: |
|
| 447 |
if not user_groups.get(db_group.idgroup, False): |
|
| 448 |
db_groups.remove(db_group) |
|
| 449 |
|
|
| 452 |
# On regarde d'abord si le groupe fait partie de ceux |
|
| 453 |
# auquels l'utilisateur a explicitement accès, ou s'il |
|
| 454 |
# est un parent des groupes auxquels l'utilisateur a accès |
|
| 455 |
if parent_id in user_groups.keys(): |
|
| 456 |
direct_access = user_groups[parent_id] |
|
| 457 |
# Dans le cas contraire, on vérifie si le groupe est un |
|
| 458 |
# sous-groupe des groupes auxquels l'utilisateur a accès |
|
| 459 |
else: |
|
| 460 |
id_list = [ug for ug in user_groups.keys() if user_groups[ug]] |
|
| 461 |
child_groups = DBSession.query(SupItemGroup.idgroup |
|
| 462 |
).distinct( |
|
| 463 |
).join( |
|
| 464 |
(GroupHierarchy, |
|
| 465 |
GroupHierarchy.idchild == SupItemGroup.idgroup), |
|
| 466 |
).filter(GroupHierarchy.idparent.in_(id_list) |
|
| 467 |
).filter(GroupHierarchy.hops > 0 |
|
| 468 |
).all() |
|
| 469 |
for ucg in child_groups: |
|
| 470 |
if ucg.idgroup == parent_id: |
|
| 471 |
direct_access = True |
|
| 472 |
break |
|
| 473 |
# Sinon, l'utilisateur n'a pas accès à ce groupe |
|
| 474 |
else: |
|
| 475 |
return dict(groups = [], leaves = []) |
|
| 476 |
|
|
| 477 |
# On récupère la liste des groupes dont |
|
| 478 |
# l'identifiant du parent est passé en paramètre |
|
| 479 |
db_groups = DBSession.query( |
|
| 480 |
SupItemGroup |
|
| 481 |
).join( |
|
| 482 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 483 |
SupItemGroup.idgroup), |
|
| 484 |
).filter(GroupHierarchy.hops == 1 |
|
| 485 |
).filter(GroupHierarchy.idparent == parent_id |
|
| 486 |
).order_by(SupItemGroup.name.asc()) |
|
| 487 |
if not is_manager and not direct_access: |
|
| 488 |
id_list = [ug for ug in user_groups.keys()] |
|
| 489 |
|
|
| 490 |
db_groups = db_groups.filter( |
|
| 491 |
SupItemGroup.idgroup.in_(id_list)) |
|
| 450 | 492 |
groups = [] |
| 451 |
for group in db_groups: |
|
| 493 |
for group in db_groups.all():
|
|
| 452 | 494 |
groups.append({
|
| 453 | 495 |
'id' : group.idgroup, |
| 454 | 496 |
'name' : group.name, |
| ... | ... | |
| 457 | 499 |
# On récupère la liste des hôtes appartenant au |
| 458 | 500 |
# groupe dont l'identifiant est passé en paramètre |
| 459 | 501 |
hosts = [] |
| 460 |
if is_manager or user_groups.get(parent_id, False):
|
|
| 502 |
if is_manager or direct_access:
|
|
| 461 | 503 |
db_hosts = DBSession.query( |
| 462 | 504 |
Host.idhost, |
| 463 | 505 |
Host.name, |
| 464 | 506 |
).join( |
| 465 |
SUPITEM_GROUP_TABLE, |
|
| 507 |
(SUPITEM_GROUP_TABLE, |
|
| 508 |
SUPITEM_GROUP_TABLE.c.idsupitem == Host.idhost |
|
| 509 |
), |
|
| 466 | 510 |
).filter(SUPITEM_GROUP_TABLE.c.idgroup == parent_id |
| 467 | 511 |
).order_by(Host.name.asc()) |
| 468 | 512 |
hosts = [] |
| ... | ... | |
| 487 | 531 |
# Si l'identifiant de l'hôte n'est pas spécifié, on |
| 488 | 532 |
# retourne un dictionnaire contenant deux listes vides |
| 489 | 533 |
if host_id is None: |
| 490 |
return dict(groups = [], leaves=[])
|
|
| 534 |
return dict(groups = [], graphs=[])
|
|
| 491 | 535 |
|
| 492 | 536 |
# On vérifie les permissions sur l'hôte |
| 493 | 537 |
# TODO: Utiliser un schéma de validation |
| 494 | 538 |
host_id = int(host_id) |
| 495 |
host = DBSession.query(Host).get(host_id) |
|
| 539 |
host = DBSession.query(Host |
|
| 540 |
).filter(Host.idhost == host_id |
|
| 541 |
).first() |
|
| 496 | 542 |
if host is None: |
| 497 |
return dict(groups = [], leaves=[])
|
|
| 543 |
return dict(groups = [], graphs=[])
|
|
| 498 | 544 |
user = get_current_user() |
| 499 | 545 |
if not host.is_allowed_for(user): |
| 500 |
return dict(groups = [], leaves=[])
|
|
| 546 |
return dict(groups = [], graphs=[])
|
|
| 501 | 547 |
|
| 502 | 548 |
# On récupère la liste des groupes de graphes associés à l'hôte |
| 503 | 549 |
host_graph_groups = DBSession.query( |
| ... | ... | |
| 511 | 557 |
GRAPH_PERFDATASOURCE_TABLE.c.idgraph == Graph.idgraph), |
| 512 | 558 |
(PerfDataSource, PerfDataSource.idperfdatasource == \ |
| 513 | 559 |
GRAPH_PERFDATASOURCE_TABLE.c.idperfdatasource), |
| 560 |
(SUPITEM_GROUP_TABLE, \ |
|
| 561 |
SUPITEM_GROUP_TABLE.c.idsupitem == PerfDataSource.idhost), |
|
| 514 | 562 |
).filter(PerfDataSource.idhost == host_id |
| 515 |
).order_by(GraphGroup.name.asc())
|
|
| 516 |
host_graph_groups = host_graph_groups.all()
|
|
| 563 |
).order_by(GraphGroup.name.asc() |
|
| 564 |
).all()
|
|
| 517 | 565 |
|
| 518 | 566 |
# Si l'identifiant du groupe parent n'est pas spécifié, |
| 519 | 567 |
# on récupère la liste des groupes de graphes racines. |
| 520 | 568 |
if parent_id is None: |
| 521 |
graph_groups = GraphGroup.get_top_groups()[0].children
|
|
| 569 |
graph_groups = GraphGroup.get_top_groups() |
|
| 522 | 570 |
|
| 523 | 571 |
# Sinon on récupère la liste des graphes dont le |
| 524 |
# groupe passé en paramètre est le parent direct.
|
|
| 572 |
# groupe passé en paramètre est le parent direct |
|
| 525 | 573 |
else: |
| 526 | 574 |
# TODO: Utiliser un schéma de validation |
| 527 | 575 |
parent_id = int(parent_id) |
| 528 |
parent = DBSession.query(GraphGroup).get(parent_id) |
|
| 529 |
graph_groups = parent.children |
|
| 576 |
graph_groups = DBSession.query( |
|
| 577 |
GraphGroup |
|
| 578 |
).join( |
|
| 579 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 580 |
GraphGroup.idgroup), |
|
| 581 |
).filter(GroupHierarchy.hops == 1 |
|
| 582 |
).filter(GroupHierarchy.idparent == parent_id |
|
| 583 |
).order_by(GraphGroup.name.asc() |
|
| 584 |
).all() |
|
| 530 | 585 |
|
| 531 | 586 |
# On réalise l'intersection des deux listes |
| 532 | 587 |
groups = [] |
| ... | ... | |
| 573 | 628 |
@rtype : C{dict} of C{list} of C{dict} of C{mixed}
|
| 574 | 629 |
""" |
| 575 | 630 |
|
| 576 |
root_groups = list(SupItemGroup.get_top_groups()[0].children) |
|
| 631 |
# On récupère tous les groupes qui ont un parent. |
|
| 632 |
children = DBSession.query( |
|
| 633 |
SupItemGroup, |
|
| 634 |
).distinct( |
|
| 635 |
).join( |
|
| 636 |
(GroupHierarchy, GroupHierarchy.idchild == SupItemGroup.idgroup) |
|
| 637 |
).filter(GroupHierarchy.hops > 0) |
|
| 638 |
|
|
| 639 |
# Ensuite on les exclut de la liste des groupes, |
|
| 640 |
# pour ne garder que ceux qui sont au sommet de |
|
| 641 |
# l'arbre et qui constituent nos "root groups". |
|
| 642 |
root_groups = DBSession.query( |
|
| 643 |
SupItemGroup, |
|
| 644 |
).except_(children |
|
| 645 |
).order_by(SupItemGroup.name) |
|
| 577 | 646 |
|
| 578 | 647 |
# On filtre ces groupes racines afin de ne |
| 579 | 648 |
# retourner que ceux auquels l'utilisateur a accès |
| 580 | 649 |
user = get_current_user() |
| 581 | 650 |
is_manager = in_group('managers').is_met(request.environ)
|
| 582 | 651 |
if not is_manager: |
| 583 |
user_groups = [sig[0] for sig in user.supitemgroups()] |
|
| 584 |
copy = list(root_groups) |
|
| 585 |
for root_group in copy: |
|
| 586 |
if root_group.idgroup not in user_groups: |
|
| 587 |
root_groups.remove(root_group) |
|
| 652 |
user_groups = [ug[0] for ug in user.supitemgroups()] |
|
| 653 |
root_groups = root_groups.filter( |
|
| 654 |
SupItemGroup.idgroup.in_(user_groups)) |
|
| 588 | 655 |
|
| 589 | 656 |
groups = [] |
| 590 |
for group in root_groups: |
|
| 657 |
for group in root_groups.all():
|
|
| 591 | 658 |
groups.append({
|
| 592 | 659 |
'id' : group.idgroup, |
| 593 | 660 |
'name' : group.name, |
| vigigraph/tests/functional/test_graph_selection_form.py | ||
|---|---|---|
| 7 | 7 |
from vigigraph.tests import TestController |
| 8 | 8 |
from vigilo.models.session import DBSession |
| 9 | 9 |
from vigilo.models.tables import Host, Graph, GraphGroup |
| 10 |
from vigilo.models.demo.functions import * |
|
| 10 |
from vigilo.models.demo.functions import \ |
|
| 11 |
add_graph, add_graphgroup, add_graph2group, \ |
|
| 12 |
add_perfdatasource, add_perfdatasource2graph, \ |
|
| 13 |
add_vigiloserver, add_application |
|
| 11 | 14 |
|
| 12 | 15 |
from vigigraph.tests.functional.test_host_selection_form import populateDB |
| 13 | 16 |
|
| ... | ... | |
| 235 | 238 |
# de graphes retournée est vide |
| 236 | 239 |
self.assertEqual( |
| 237 | 240 |
json, {
|
| 238 |
'leaves': [],
|
|
| 241 |
'graphs': [],
|
|
| 239 | 242 |
'groups': [] |
| 240 | 243 |
} |
| 241 | 244 |
) |
| ... | ... | |
| 251 | 254 |
# de graphes retournée est vide |
| 252 | 255 |
self.assertEqual( |
| 253 | 256 |
json, {
|
| 254 |
'leaves': [],
|
|
| 257 |
'graphs': [],
|
|
| 255 | 258 |
'groups': [] |
| 256 | 259 |
} |
| 257 | 260 |
) |
| ... | ... | |
| 267 | 270 |
# de graphes retournée est vide |
| 268 | 271 |
self.assertEqual( |
| 269 | 272 |
json, {
|
| 270 |
'leaves': [],
|
|
| 273 |
'graphs': [],
|
|
| 271 | 274 |
'groups': [] |
| 272 | 275 |
} |
| 273 | 276 |
) |
| ... | ... | |
| 304 | 307 |
# de graphes retournée est vide |
| 305 | 308 |
self.assertEqual( |
| 306 | 309 |
json, {
|
| 307 |
'leaves': [],
|
|
| 310 |
'graphs': [],
|
|
| 308 | 311 |
'groups': [] |
| 309 | 312 |
} |
| 310 | 313 |
) |
| ... | ... | |
| 495 | 498 |
# de graphes retournée est vide |
| 496 | 499 |
self.assertEqual( |
| 497 | 500 |
json, {
|
| 498 |
'leaves': [],
|
|
| 501 |
'graphs': [],
|
|
| 499 | 502 |
'groups': [] |
| 500 | 503 |
} |
| 501 | 504 |
) |
| ... | ... | |
| 512 | 515 |
# de graphes retournée est vide |
| 513 | 516 |
self.assertEqual( |
| 514 | 517 |
json, {
|
| 515 |
'leaves': [],
|
|
| 518 |
'graphs': [],
|
|
| 516 | 519 |
'groups': [] |
| 517 | 520 |
} |
| 518 | 521 |
) |
| ... | ... | |
| 529 | 532 |
# de graphes retournée est vide |
| 530 | 533 |
self.assertEqual( |
| 531 | 534 |
json, {
|
| 532 |
'leaves': [],
|
|
| 535 |
'graphs': [],
|
|
| 533 | 536 |
'groups': [] |
| 534 | 537 |
} |
| 535 | 538 |
) |
| ... | ... | |
| 572 | 575 |
# graphes retournée est vide |
| 573 | 576 |
self.assertEqual( |
| 574 | 577 |
json, {
|
| 575 |
'leaves': [],
|
|
| 578 |
'graphs': [],
|
|
| 576 | 579 |
'groups': [] |
| 577 | 580 |
} |
| 578 | 581 |
) |
| vigigraph/tests/functional/test_host_selection_form.py | ||
|---|---|---|
| 7 | 7 |
from vigigraph.tests import TestController |
| 8 | 8 |
from vigilo.models.session import DBSession |
| 9 | 9 |
from vigilo.models.tables import Host, SupItemGroup, Permission |
| 10 |
from vigilo.models.demo.functions import * |
|
| 10 |
from vigilo.models.demo.functions import add_supitemgroup, \ |
|
| 11 |
add_host, add_host2group, add_usergroup, add_user, \ |
|
| 12 |
add_supitemgrouppermission, add_usergroup_permission |
|
| 11 | 13 |
|
| 12 | 14 |
|
| 13 | 15 |
def populateDB(): |
| ... | ... | |
| 24 | 26 |
""" |
| 25 | 27 |
|
| 26 | 28 |
# Ajout d'un groupe d'hôtes principal |
| 27 |
mainhostgroup = add_supitemgroup(u'mhg') |
|
| 29 |
mainhostgroup = add_supitemgroup(u'mhg', None)
|
|
| 28 | 30 |
|
| 29 | 31 |
# Ajout d'un premier groupe d'hôtes de second niveau |
| 30 | 32 |
hostgroup1 = add_supitemgroup(u'hg1', mainhostgroup) |
| ... | ... | |
| 257 | 259 |
self.assertEqual( |
| 258 | 260 |
json, {
|
| 259 | 261 |
'leaves': [ |
| 260 |
{'id': host1.idhost, 'name': host1.name},
|
|
| 262 |
{'id': host1.idhost, 'name': host1.name}
|
|
| 261 | 263 |
], |
| 262 | 264 |
'groups': [ |
| 263 | 265 |
{'id': hostgroup1.idgroup, 'name': hostgroup1.name},
|
| ... | ... | |
| 269 | 271 |
# Récupération des groupes d'hôtes |
| 270 | 272 |
# accessibles à l'utilisateur 'poweruser' |
| 271 | 273 |
response = self.app.post( |
| 272 |
'/rpc/hosttree?parent_id=%d' % mainhostgroup.idgroup, {},
|
|
| 273 |
extra_environ={'REMOTE_USER': 'poweruser'})
|
|
| 274 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
|
| 275 |
}, extra_environ={'REMOTE_USER': 'poweruser'})
|
|
| 274 | 276 |
json = response.json |
| 275 | 277 |
|
| 276 | 278 |
# On s'assure que la liste de groupes d'hôtes retournée |
| ... | ... | |
| 278 | 280 |
self.assertEqual( |
| 279 | 281 |
json, {
|
| 280 | 282 |
'leaves': [ |
| 281 |
{'id': host1.idhost, 'name': host1.name},
|
|
| 283 |
{'id': host1.idhost, 'name': host1.name}
|
|
| 282 | 284 |
], |
| 283 | 285 |
'groups': [ |
| 284 | 286 |
{'id': hostgroup1.idgroup, 'name': hostgroup1.name},
|
| ... | ... | |
| 504 | 506 |
# Récupération des hôtes du groupe 'hg2' |
| 505 | 507 |
# accessibles à l'utilisateur 'user' |
| 506 | 508 |
response = self.app.post( |
| 507 |
'/rpc/hosttree?parent_id=%s' % hostgroup2.idgroup, {},
|
|
| 508 |
extra_environ={'REMOTE_USER': 'user'})
|
|
| 509 |
'/rpc/hosttree?parent_id=%s' % (hostgroup2.idgroup, ), {
|
|
| 510 |
}, extra_environ={'REMOTE_USER': 'user'})
|
|
| 509 | 511 |
json = response.json |
| 510 | 512 |
|
| 511 | 513 |
# On s'assure que la liste d'hôtes retournée est vide |
| ... | ... | |
| 516 | 518 |
# Récupération des hôtes du groupe 'mhg' |
| 517 | 519 |
# accessibles à l'utilisateur 'visitor' |
| 518 | 520 |
response = self.app.post( |
| 519 |
'/rpc/hosttree?parent_id=%s' % mainhostgroup.idgroup, {},
|
|
| 520 |
extra_environ={'REMOTE_USER': 'visitor'})
|
|
| 521 |
'/rpc/hosttree?parent_id=%s' % (mainhostgroup.idgroup, ), {
|
|
| 522 |
}, extra_environ={'REMOTE_USER': 'visitor'})
|
|
| 521 | 523 |
json = response.json |
| 522 | 524 |
|
| 523 | 525 |
# On s'assure que la liste d'hôtes retournée est vide |
| vigigraph/tests/functional/test_search_form.py | ||
|---|---|---|
| 38 | 38 |
""" |
| 39 | 39 |
Résultats de la recherche sur un hôte avec les bons droits |
| 40 | 40 |
""" |
| 41 |
|
|
| 41 | 42 |
# Récupération du groupe d'hôtes 'mhg' dans la base de données |
| 42 | 43 |
mainhostgroup = DBSession.query(SupItemGroup).filter( |
| 43 | 44 |
SupItemGroup.name == u'mhg').first() |
| ... | ... | |
| 95 | 96 |
|
| 96 | 97 |
# On s'assure que les deux listes retournées contiennent |
| 97 | 98 |
# respectivement le nom de l'hôte et son identifiant |
| 98 |
print repr(DBSession.query(SupItemGroup.name, SupItemGroup.left, SupItemGroup.right, SupItemGroup.depth).all()) |
|
| 99 | 99 |
self.assertEqual( |
| 100 | 100 |
json, {
|
| 101 | 101 |
'labels': [[host2.name, None]], |
Also available in: Unified diff