Revision 64ed9170
Ajout de tests unitaires et fonctionnels sur Vigiboard
git-svn-id: https://vigilo-dev.si.c-s.fr/svn@1715 b22e2e97-25c9-44ff-b637-2e5ceca36478
| vigiboard/tests/functional/test_host_vigiboardrequest.py | ||
|---|---|---|
| 128 | 128 |
# Derrière, VigiboardRequest doit charger le plugin de tests tout seul |
| 129 | 129 |
tg.config['vigiboard_plugins'] = [['tests', 'MonPlugin']] |
| 130 | 130 |
vigi_req = VigiboardRequest(User.by_user_name(u'editor')) |
| 131 |
|
|
| 132 |
print "\nPermissions sur l'hote 'editorhost' :" |
|
| 133 |
editorhost = DBSession.query(Host |
|
| 134 |
).filter(Host.name == 'editorhost' |
|
| 135 |
).one() |
|
| 136 |
for group in editorhost.groups: |
|
| 137 |
for permission in group.permissions: |
|
| 138 |
print permission.permission_name |
|
| 139 |
|
|
| 140 |
print "\nPermissions de l'utilisateur 'editor' :" |
|
| 141 |
editor = DBSession.query(User |
|
| 142 |
).filter(User.user_name == 'editor' |
|
| 143 |
).one() |
|
| 144 |
for group in editor.usergroups: |
|
| 145 |
for permission in group.permissions: |
|
| 146 |
print permission.permission_name |
|
| 147 |
|
|
| 148 |
print "\nNombre d'evenements dans la BDD : ", DBSession.query(Event).count() |
|
| 149 |
print "\nIds des evenements dans la BDD : " |
|
| 150 |
events = DBSession.query(Event) |
|
| 151 |
print "##### ", events[0].idevent, " ######" |
|
| 152 |
print "##### ", events[1].idevent, " ######" |
|
| 153 |
|
|
| 154 |
print "\nNombre d'evenements correles dans la BDD : ", DBSession.query(CorrEvent).count() |
|
| 155 |
aggregates = DBSession.query(CorrEvent) |
|
| 156 |
print "##### ", aggregates[0].events[0].idevent, " | ", aggregates[0].idcause, " ######" |
|
| 157 |
print "##### ", aggregates[1].events[0].idevent, " | ", aggregates[1].idcause, " ######" |
|
| 158 | 131 |
|
| 159 | 132 |
# On vérifie que le nombre d'événements corrélés |
| 160 | 133 |
# trouvés par la requête est bien égal à 1. |
| 161 | 134 |
num_rows = vigi_req.num_rows() |
| 162 |
assert_true(num_rows == 1, msg = "La requete devrait retourner 1 " +
|
|
| 163 |
"evenement correle pour l'utilisateur 'editor', " +
|
|
| 164 |
"mais ici elle en trouve %d" % num_rows)
|
|
| 135 |
assert_true(num_rows == 1, |
|
| 136 |
msg = "One history should be available for " +
|
|
| 137 |
"the user 'editor' but there are %d" % num_rows)
|
|
| 165 | 138 |
|
| 166 | 139 |
vigi_req.format_events(0, 10) |
| 167 | 140 |
vigi_req.format_history() |
| 168 | 141 |
assert_true(len(vigi_req.events) == 1 + 1, |
| 169 |
msg = "La requete devrait retourner 1 " + |
|
| 170 |
"evenement correle pour l'utilisateur 'editor', " + |
|
| 171 |
"mais ici elle en trouve %d" % |
|
| 172 |
(len(vigi_req.events) - 1)) |
|
| 142 |
msg = "One history should be available for the user " + |
|
| 143 |
"'editor' but there are %d" % (len(vigi_req.events) - 1)) |
|
| 173 | 144 |
|
| 174 |
# On s'assure que le plugin fonctionne correctement |
|
| 175 |
assert_true(vigi_req.events[1][6][0][0] != 'Error', |
|
| 176 |
msg = "Probleme d'execution des plugins ou de " + |
|
| 177 |
"formatage des evenements") |
|
| 145 |
# # On s'assure que le plugin fonctionne correctement
|
|
| 146 |
# assert_true(vigi_req.events[1][6][0][0] != 'Error',
|
|
| 147 |
# msg = "Probleme d'execution des plugins ou de " +
|
|
| 148 |
# "formatage des evenements")
|
|
| 178 | 149 |
|
| 179 | 150 |
|
| 180 | 151 |
# On recommence les tests précédents avec l'utilisateur |
| ... | ... | |
| 189 | 160 |
# On vérifie que le nombre d'événements corrélés |
| 190 | 161 |
# trouvés par la requête est bien égal à 2. |
| 191 | 162 |
num_rows = vigi_req.num_rows() |
| 192 |
assert_true(num_rows == 2, msg = "La requete devrait retourner 2 " +
|
|
| 193 |
"evenement correle pour l'utilisateur 'editor', " +
|
|
| 194 |
"mais ici elle en trouve %d" % num_rows)
|
|
| 163 |
assert_true(num_rows == 2,
|
|
| 164 |
msg = "2 histories should be available for " +
|
|
| 165 |
"the user 'manager' but there are %d" % num_rows)
|
|
| 195 | 166 |
|
| 196 | 167 |
vigi_req.format_events(0, 10) |
| 197 | 168 |
vigi_req.format_history() |
| 198 | 169 |
assert_true(len(vigi_req.events) == 2 + 1, |
| 199 |
msg = "La requete devrait retourner 2 " + |
|
| 200 |
"evenement correle pour l'utilisateur 'editor', " + |
|
| 201 |
"mais ici elle en trouve %d" % |
|
| 202 |
(len(vigi_req.events) - 1)) |
|
| 170 |
msg = "2 histories should be available for the user " + |
|
| 171 |
"'manager' but there are %d" % (len(vigi_req.events) - 1)) |
|
| 203 | 172 |
|
| 204 | 173 |
# On s'assure que le plugin fonctionne correctement |
| 205 |
assert_true(vigi_req.events[1][6][0][0] != 'Error', |
|
| 206 |
msg = "Probleme d'execution des plugins ou de " + |
|
| 207 |
"formatage des evenements") |
|
| 174 |
# assert_true(vigi_req.events[1][6][0][0] != 'Error',
|
|
| 175 |
# msg = "Probleme d'execution des plugins ou de " +
|
|
| 176 |
# "formatage des evenements")
|
|
| 208 | 177 |
|
| vigiboard/tests/functional/test_search_form_host.py | ||
|---|---|---|
| 1 |
# -*- coding: utf-8 -*- |
|
| 2 |
""" |
|
| 3 |
Teste le formulaire de recherche avec un nom d'hôte. |
|
| 4 |
""" |
|
| 5 |
from nose.tools import assert_true, assert_equal |
|
| 6 |
from datetime import datetime |
|
| 7 |
from lxml import etree |
|
| 8 |
import transaction |
|
| 9 |
|
|
| 10 |
from vigiboard.tests import TestController |
|
| 11 |
from vigiboard.model import DBSession, HostGroup, \ |
|
| 12 |
Host, Permission, \ |
|
| 13 |
Event, CorrEvent, StateName |
|
| 14 |
|
|
| 15 |
def insert_deps(): |
|
| 16 |
"""Insère les dépendances nécessaires aux tests.""" |
|
| 17 |
timestamp = datetime.now() |
|
| 18 |
DBSession.add(StateName(statename=u'OK', order=1)) |
|
| 19 |
DBSession.add(StateName(statename=u'UNKNOWN', order=1)) |
|
| 20 |
DBSession.add(StateName(statename=u'WARNING', order=1)) |
|
| 21 |
DBSession.add(StateName(statename=u'CRITICAL', order=1)) |
|
| 22 |
DBSession.flush() |
|
| 23 |
|
|
| 24 |
hostgroup = HostGroup( |
|
| 25 |
name=u'foo', |
|
| 26 |
) |
|
| 27 |
DBSession.add(hostgroup) |
|
| 28 |
DBSession.flush() |
|
| 29 |
|
|
| 30 |
host = Host( |
|
| 31 |
name=u'bar', |
|
| 32 |
checkhostcmd=u'', |
|
| 33 |
description=u'', |
|
| 34 |
hosttpl=u'', |
|
| 35 |
mainip=u'127.0.0.1', |
|
| 36 |
snmpport=42, |
|
| 37 |
snmpcommunity=u'public', |
|
| 38 |
snmpversion=u'3', |
|
| 39 |
weight=42, |
|
| 40 |
) |
|
| 41 |
DBSession.add(host) |
|
| 42 |
DBSession.flush() |
|
| 43 |
|
|
| 44 |
hostgroup.hosts.append(host) |
|
| 45 |
DBSession.flush() |
|
| 46 |
|
|
| 47 |
event = Event( |
|
| 48 |
supitem=host, |
|
| 49 |
timestamp=timestamp, |
|
| 50 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 51 |
message=u'Hello world', |
|
| 52 |
) |
|
| 53 |
DBSession.add(event) |
|
| 54 |
DBSession.flush() |
|
| 55 |
|
|
| 56 |
correvent = CorrEvent( |
|
| 57 |
impact=42, |
|
| 58 |
priority=42, |
|
| 59 |
trouble_ticket=None, |
|
| 60 |
status=u'None', |
|
| 61 |
occurrence=42, |
|
| 62 |
timestamp_active=timestamp, |
|
| 63 |
cause=event, |
|
| 64 |
) |
|
| 65 |
correvent.events.append(event) |
|
| 66 |
DBSession.add(correvent) |
|
| 67 |
DBSession.flush() |
|
| 68 |
return hostgroup |
|
| 69 |
|
|
| 70 |
class TestSearchFormHost(TestController): |
|
| 71 |
"""Teste la récupération d'événements selon le nom d'hôte.""" |
|
| 72 |
|
|
| 73 |
def test_search_host_when_allowed(self): |
|
| 74 |
"""Teste la recherche par hôte avec les bons droits.""" |
|
| 75 |
# On crée un hôte avec une alerte. |
|
| 76 |
# L'hôte est rattaché à un groupe d'hôtes |
|
| 77 |
# pour lesquel l'utilisateur a les permissions. |
|
| 78 |
hostgroup = insert_deps() |
|
| 79 |
manage = Permission.by_permission_name(u'manage') |
|
| 80 |
manage.hostgroups.append(hostgroup) |
|
| 81 |
DBSession.flush() |
|
| 82 |
transaction.commit() |
|
| 83 |
|
|
| 84 |
# On envoie une requête avec recherche sur l'hôte créé, |
|
| 85 |
# on s'attend à recevoir 1 résultat. |
|
| 86 |
response = self.app.get('/?host=bar',
|
|
| 87 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 88 |
|
|
| 89 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 90 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 91 |
print "There are %d rows in the result set" % len(rows) |
|
| 92 |
assert_equal(len(rows), 1) |
|
| 93 |
|
|
| 94 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 95 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 96 |
print "There are %d columns in the result set" % len(cols) |
|
| 97 |
assert_true(len(cols) > 1) |
|
| 98 |
|
|
| 99 |
def test_search_inexistent_host(self): |
|
| 100 |
"""Teste la recherche par hôte sur un hôte inexistant.""" |
|
| 101 |
# On envoie une requête avec recherche sur un hôte |
|
| 102 |
# qui n'existe pas, on s'attend à n'obtenir aucun résultat. |
|
| 103 |
response = self.app.get('/?host=bad',
|
|
| 104 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 105 |
|
|
| 106 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 107 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 108 |
print "There are %d rows in the result set" % len(rows) |
|
| 109 |
assert_equal(len(rows), 1) |
|
| 110 |
|
|
| 111 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 112 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 113 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 114 |
print "There are %d columns in the result set" % len(cols) |
|
| 115 |
assert_equal(len(cols), 1) |
|
| 116 |
|
|
| 117 |
def test_search_host_when_disallowed(self): |
|
| 118 |
"""Teste la recherche par hôte SANS les droits.""" |
|
| 119 |
# On NE DONNE PAS l'autorisation aux utilisateurs |
|
| 120 |
# de voir l'alerte, donc elle ne doit jamais apparaître. |
|
| 121 |
insert_deps() |
|
| 122 |
transaction.commit() |
|
| 123 |
|
|
| 124 |
# On envoie une requête avec recherche sur l'hôte créé, |
|
| 125 |
# mais avec un utilisateur ne disposant pas des permissions adéquates. |
|
| 126 |
# On s'attend à n'obtenir aucun résultat. |
|
| 127 |
response = self.app.get('/?host=bar',
|
|
| 128 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 129 |
|
|
| 130 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 131 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 132 |
print "There are %d rows in the result set" % len(rows) |
|
| 133 |
assert_equal(len(rows), 1) |
|
| 134 |
|
|
| 135 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 136 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 137 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 138 |
print "There are %d columns in the result set" % len(cols) |
|
| 139 |
assert_equal(len(cols), 1) |
|
| 140 |
|
|
| vigiboard/tests/functional/test_search_form_hostgroup.py | ||
|---|---|---|
| 1 |
# -*- coding: utf-8 -*- |
|
| 2 |
""" |
|
| 3 |
Teste le formulaire de recherche avec un groupe d'hôtes. |
|
| 4 |
""" |
|
| 5 |
from nose.tools import assert_true, assert_equal |
|
| 6 |
from datetime import datetime |
|
| 7 |
import transaction |
|
| 8 |
|
|
| 9 |
from vigiboard.tests import TestController |
|
| 10 |
from vigiboard.model import DBSession, HostGroup, Host, Permission, \ |
|
| 11 |
ServiceLowLevel, Event, CorrEvent, StateName |
|
| 12 |
|
|
| 13 |
def insert_deps(): |
|
| 14 |
"""Insère les dépendances nécessaires aux tests.""" |
|
| 15 |
timestamp = datetime.now() |
|
| 16 |
DBSession.add(StateName(statename=u'OK', order=1)) |
|
| 17 |
DBSession.add(StateName(statename=u'UNKNOWN', order=1)) |
|
| 18 |
DBSession.add(StateName(statename=u'WARNING', order=1)) |
|
| 19 |
DBSession.add(StateName(statename=u'CRITICAL', order=1)) |
|
| 20 |
DBSession.flush() |
|
| 21 |
|
|
| 22 |
hostgroup = HostGroup( |
|
| 23 |
name=u'foo', |
|
| 24 |
) |
|
| 25 |
DBSession.add(hostgroup) |
|
| 26 |
DBSession.flush() |
|
| 27 |
|
|
| 28 |
host = Host( |
|
| 29 |
name=u'bar', |
|
| 30 |
checkhostcmd=u'', |
|
| 31 |
description=u'', |
|
| 32 |
hosttpl=u'', |
|
| 33 |
mainip=u'127.0.0.1', |
|
| 34 |
snmpport=42, |
|
| 35 |
snmpcommunity=u'public', |
|
| 36 |
snmpversion=u'3', |
|
| 37 |
weight=42, |
|
| 38 |
) |
|
| 39 |
DBSession.add(host) |
|
| 40 |
DBSession.flush() |
|
| 41 |
|
|
| 42 |
hostgroup.hosts.append(host) |
|
| 43 |
DBSession.flush() |
|
| 44 |
|
|
| 45 |
event = Event( |
|
| 46 |
supitem=host, |
|
| 47 |
timestamp=timestamp, |
|
| 48 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 49 |
message=u'Hello world', |
|
| 50 |
) |
|
| 51 |
DBSession.add(event) |
|
| 52 |
DBSession.flush() |
|
| 53 |
|
|
| 54 |
correvent = CorrEvent( |
|
| 55 |
impact=42, |
|
| 56 |
priority=42, |
|
| 57 |
trouble_ticket=None, |
|
| 58 |
status=u'None', |
|
| 59 |
occurrence=42, |
|
| 60 |
timestamp_active=timestamp, |
|
| 61 |
cause=event, |
|
| 62 |
) |
|
| 63 |
correvent.events.append(event) |
|
| 64 |
DBSession.add(correvent) |
|
| 65 |
DBSession.flush() |
|
| 66 |
return hostgroup |
|
| 67 |
|
|
| 68 |
class TestSearchFormHostGroup(TestController): |
|
| 69 |
"""Teste la récupération d'événements selon le groupe d'hôtes.""" |
|
| 70 |
|
|
| 71 |
def test_search_hostgroup_when_allowed(self): |
|
| 72 |
"""Teste la recherche par hostgroup avec les bons droits d'accès.""" |
|
| 73 |
# On crée un groupe d'hôte appelé 'foo', |
|
| 74 |
# contenant un hôte 'bar', ainsi qu'un événement |
|
| 75 |
# et un événement corrélé sur cet hôte. |
|
| 76 |
# De plus, on donne l'autorisation aux utilisateurs |
|
| 77 |
# ayant la permission 'manage' de voir cette alerte. |
|
| 78 |
hostgroup = insert_deps() |
|
| 79 |
manage = Permission.by_permission_name(u'manage') |
|
| 80 |
manage.hostgroups.append(hostgroup) |
|
| 81 |
DBSession.flush() |
|
| 82 |
transaction.commit() |
|
| 83 |
|
|
| 84 |
# On envoie une requête avec recherche sur le groupe d'hôtes créé, |
|
| 85 |
# on s'attend à recevoir 1 résultat. |
|
| 86 |
response = self.app.get('/?hostgroup=foo',
|
|
| 87 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 88 |
|
|
| 89 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 90 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 91 |
print "There are %d rows in the result set" % len(rows) |
|
| 92 |
assert_equal(len(rows), 1) |
|
| 93 |
|
|
| 94 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 95 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 96 |
print "There are %d columns in the result set" % len(cols) |
|
| 97 |
assert_true(len(cols) > 1) |
|
| 98 |
|
|
| 99 |
def test_search_inexistent_hostgroup(self): |
|
| 100 |
"""Teste la recherche par hostgroup sur un groupe inexistant.""" |
|
| 101 |
# On envoie une requête avec recherche sur un groupe d'hôtes |
|
| 102 |
# qui n'existe pas, on s'attend à n'obtenir aucun résultat. |
|
| 103 |
response = self.app.get('/?hostgroup=foot',
|
|
| 104 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 105 |
|
|
| 106 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 107 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 108 |
print "There are %d rows in the result set" % len(rows) |
|
| 109 |
assert_equal(len(rows), 1) |
|
| 110 |
|
|
| 111 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 112 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 113 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 114 |
print "There are %d columns in the result set" % len(cols) |
|
| 115 |
assert_equal(len(cols), 1) |
|
| 116 |
|
|
| 117 |
def test_search_hostgroup_when_disallowed(self): |
|
| 118 |
"""Teste la recherche par hostgroup SANS les droits d'accès.""" |
|
| 119 |
# On crée un groupe d'hôte appelé 'foo', |
|
| 120 |
# contenant un hôte 'bar', ainsi qu'un événement |
|
| 121 |
# et un événement corrélé sur cet hôte. |
|
| 122 |
# MAIS, on NE DONNE PAS l'autorisation aux utilisateurs |
|
| 123 |
# de voir cette alerte, donc elle ne doit jamais apparaître. |
|
| 124 |
insert_deps() |
|
| 125 |
transaction.commit() |
|
| 126 |
|
|
| 127 |
# On envoie une requête avec recherche sur le groupe d'hôtes créé, |
|
| 128 |
# mais avec un utilisateur ne disposant pas des permissions adéquates. |
|
| 129 |
# On s'attend à n'obtenir aucun résultat. |
|
| 130 |
response = self.app.get('/?hostgroup=foo',
|
|
| 131 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 132 |
|
|
| 133 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 134 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 135 |
print "There are %d rows in the result set" % len(rows) |
|
| 136 |
assert_equal(len(rows), 1) |
|
| 137 |
|
|
| 138 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 139 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 140 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 141 |
print "There are %d columns in the result set" % len(cols) |
|
| 142 |
assert_equal(len(cols), 1) |
|
| 143 |
|
|
| vigiboard/tests/functional/test_search_form_misc.py | ||
|---|---|---|
| 1 |
# -*- coding: utf-8 -*- |
|
| 2 |
""" |
|
| 3 |
Teste le formulaire de recherche avec divers champs. |
|
| 4 |
""" |
|
| 5 |
from nose.tools import assert_true, assert_equal |
|
| 6 |
from datetime import datetime |
|
| 7 |
import transaction |
|
| 8 |
|
|
| 9 |
from vigiboard.tests import TestController |
|
| 10 |
from vigiboard.model import DBSession, HostGroup, \ |
|
| 11 |
Host, Permission, \ |
|
| 12 |
Event, CorrEvent, StateName |
|
| 13 |
|
|
| 14 |
def insert_deps(): |
|
| 15 |
"""Insère les dépendances nécessaires aux tests.""" |
|
| 16 |
timestamp = datetime.now() |
|
| 17 |
DBSession.add(StateName(statename=u'OK', order=1)) |
|
| 18 |
DBSession.add(StateName(statename=u'UNKNOWN', order=1)) |
|
| 19 |
DBSession.add(StateName(statename=u'WARNING', order=1)) |
|
| 20 |
DBSession.add(StateName(statename=u'CRITICAL', order=1)) |
|
| 21 |
DBSession.flush() |
|
| 22 |
|
|
| 23 |
host = Host( |
|
| 24 |
name=u'bar', |
|
| 25 |
checkhostcmd=u'', |
|
| 26 |
description=u'', |
|
| 27 |
hosttpl=u'', |
|
| 28 |
mainip=u'127.0.0.1', |
|
| 29 |
snmpport=42, |
|
| 30 |
snmpcommunity=u'public', |
|
| 31 |
snmpversion=u'3', |
|
| 32 |
weight=42, |
|
| 33 |
) |
|
| 34 |
DBSession.add(host) |
|
| 35 |
DBSession.flush() |
|
| 36 |
|
|
| 37 |
hostgroup = HostGroup( |
|
| 38 |
name=u'foo', |
|
| 39 |
) |
|
| 40 |
hostgroup.hosts.append(host) |
|
| 41 |
DBSession.add(hostgroup) |
|
| 42 |
DBSession.flush() |
|
| 43 |
|
|
| 44 |
event = Event( |
|
| 45 |
supitem=host, |
|
| 46 |
timestamp=timestamp, |
|
| 47 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 48 |
message=u'Hello world', |
|
| 49 |
) |
|
| 50 |
DBSession.add(event) |
|
| 51 |
DBSession.flush() |
|
| 52 |
|
|
| 53 |
correvent = CorrEvent( |
|
| 54 |
impact=42, |
|
| 55 |
priority=42, |
|
| 56 |
trouble_ticket=u'FOO BAR BAZ', |
|
| 57 |
status=u'None', |
|
| 58 |
occurrence=42, |
|
| 59 |
timestamp_active=timestamp, |
|
| 60 |
cause=event, |
|
| 61 |
) |
|
| 62 |
correvent.events.append(event) |
|
| 63 |
DBSession.add(correvent) |
|
| 64 |
DBSession.flush() |
|
| 65 |
|
|
| 66 |
# On attribut les permissions. |
|
| 67 |
manage = Permission.by_permission_name(u'manage') |
|
| 68 |
manage.hostgroups.append(hostgroup) |
|
| 69 |
DBSession.flush() |
|
| 70 |
return timestamp |
|
| 71 |
|
|
| 72 |
|
|
| 73 |
class TestSearchFormMisc(TestController): |
|
| 74 |
"""Teste la récupération d'événements selon le nom d'hôte.""" |
|
| 75 |
def test_search_by_output(self): |
|
| 76 |
"""Teste la recherche sur le message issu de Nagios.""" |
|
| 77 |
insert_deps() |
|
| 78 |
transaction.commit() |
|
| 79 |
|
|
| 80 |
# Permet également de vérifier que la recherche est |
|
| 81 |
# insensible à la casse. |
|
| 82 |
response = self.app.get('/?output=hello',
|
|
| 83 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 84 |
|
|
| 85 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 86 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 87 |
print "There are %d rows in the result set" % len(rows) |
|
| 88 |
assert_equal(len(rows), 1) |
|
| 89 |
|
|
| 90 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 91 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 92 |
print "There are %d columns in the result set" % len(cols) |
|
| 93 |
assert_true(len(cols) > 1) |
|
| 94 |
|
|
| 95 |
def test_search_by_trouble_ticket(self): |
|
| 96 |
"""Teste la recherche sur le ticket d'incident.""" |
|
| 97 |
insert_deps() |
|
| 98 |
transaction.commit() |
|
| 99 |
|
|
| 100 |
# Permet également de vérifier que la recherche est |
|
| 101 |
# insensible à la casse. |
|
| 102 |
response = self.app.get('/?trouble_ticket=bar',
|
|
| 103 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 104 |
transaction.commit() |
|
| 105 |
print response.body |
|
| 106 |
|
|
| 107 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 108 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 109 |
print "There are %d rows in the result set" % len(rows) |
|
| 110 |
assert_equal(len(rows), 1) |
|
| 111 |
|
|
| 112 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 113 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 114 |
print "There are %d columns in the result set" % len(cols) |
|
| 115 |
assert_true(len(cols) > 1) |
|
| 116 |
|
|
| 117 |
def test_search_by_dates(self): |
|
| 118 |
"""Teste la recherche par dates.""" |
|
| 119 |
timestamp = insert_deps() |
|
| 120 |
transaction.commit() |
|
| 121 |
from_date = timestamp.strftime('%Y-%m-%d %I:%M:%S %p')
|
|
| 122 |
to_date = datetime.max.strftime('%Y-%m-%d %I:%M:%S %p')
|
|
| 123 |
|
|
| 124 |
# Permet également de vérifier que la recherche |
|
| 125 |
# par date est inclusive. |
|
| 126 |
response = self.app.get( |
|
| 127 |
'/?from_date=%(from_date)s&to_date=%(to_date)s' % {
|
|
| 128 |
'from_date': from_date, |
|
| 129 |
'to_date': to_date, |
|
| 130 |
}, |
|
| 131 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 132 |
transaction.commit() |
|
| 133 |
|
|
| 134 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 135 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 136 |
print "There are %d rows in the result set" % len(rows) |
|
| 137 |
assert_equal(len(rows), 1) |
|
| 138 |
|
|
| 139 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 140 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 141 |
print "There are %d columns in the result set" % len(cols) |
|
| 142 |
assert_true(len(cols) > 1) |
|
| 143 |
|
|
| vigiboard/tests/functional/test_search_form_service.py | ||
|---|---|---|
| 1 |
# -*- coding: utf-8 -*- |
|
| 2 |
""" |
|
| 3 |
Teste le formulaire de recherche avec un nom de service. |
|
| 4 |
""" |
|
| 5 |
from nose.tools import assert_true, assert_equal |
|
| 6 |
from datetime import datetime |
|
| 7 |
import transaction |
|
| 8 |
|
|
| 9 |
from vigiboard.tests import TestController |
|
| 10 |
from vigiboard.model import DBSession, ServiceGroup, HostGroup, \ |
|
| 11 |
Host, Permission, StateName, \ |
|
| 12 |
ServiceLowLevel, Event, CorrEvent |
|
| 13 |
|
|
| 14 |
def insert_deps(): |
|
| 15 |
"""Insère les dépendances nécessaires aux tests.""" |
|
| 16 |
timestamp = datetime.now() |
|
| 17 |
DBSession.add(StateName(statename=u'OK', order=1)) |
|
| 18 |
DBSession.add(StateName(statename=u'UNKNOWN', order=1)) |
|
| 19 |
DBSession.add(StateName(statename=u'WARNING', order=1)) |
|
| 20 |
DBSession.add(StateName(statename=u'CRITICAL', order=1)) |
|
| 21 |
DBSession.flush() |
|
| 22 |
|
|
| 23 |
hostgroup = HostGroup( |
|
| 24 |
name=u'foo', |
|
| 25 |
) |
|
| 26 |
DBSession.add(hostgroup) |
|
| 27 |
DBSession.flush() |
|
| 28 |
|
|
| 29 |
host = Host( |
|
| 30 |
name=u'bar', |
|
| 31 |
checkhostcmd=u'', |
|
| 32 |
description=u'', |
|
| 33 |
hosttpl=u'', |
|
| 34 |
mainip=u'127.0.0.1', |
|
| 35 |
snmpport=42, |
|
| 36 |
snmpcommunity=u'public', |
|
| 37 |
snmpversion=u'3', |
|
| 38 |
weight=42, |
|
| 39 |
) |
|
| 40 |
DBSession.add(host) |
|
| 41 |
DBSession.flush() |
|
| 42 |
|
|
| 43 |
hostgroup.hosts.append(host) |
|
| 44 |
DBSession.flush() |
|
| 45 |
|
|
| 46 |
servicegroup = ServiceGroup( |
|
| 47 |
name=u'foo', |
|
| 48 |
) |
|
| 49 |
DBSession.add(servicegroup) |
|
| 50 |
|
|
| 51 |
service = ServiceLowLevel( |
|
| 52 |
host=host, |
|
| 53 |
command=u'', |
|
| 54 |
weight=42, |
|
| 55 |
servicename=u'baz', |
|
| 56 |
op_dep=u'&', |
|
| 57 |
) |
|
| 58 |
DBSession.add(service) |
|
| 59 |
DBSession.flush() |
|
| 60 |
|
|
| 61 |
servicegroup.services.append(service) |
|
| 62 |
DBSession.flush() |
|
| 63 |
|
|
| 64 |
event = Event( |
|
| 65 |
supitem=service, |
|
| 66 |
timestamp=timestamp, |
|
| 67 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 68 |
message=u'Hello world', |
|
| 69 |
) |
|
| 70 |
DBSession.add(event) |
|
| 71 |
DBSession.flush() |
|
| 72 |
|
|
| 73 |
correvent = CorrEvent( |
|
| 74 |
impact=42, |
|
| 75 |
priority=42, |
|
| 76 |
trouble_ticket=None, |
|
| 77 |
status=u'None', |
|
| 78 |
occurrence=42, |
|
| 79 |
timestamp_active=timestamp, |
|
| 80 |
cause=event, |
|
| 81 |
) |
|
| 82 |
correvent.events.append(event) |
|
| 83 |
DBSession.add(correvent) |
|
| 84 |
DBSession.flush() |
|
| 85 |
return (hostgroup, servicegroup) |
|
| 86 |
|
|
| 87 |
class TestSearchFormService(TestController): |
|
| 88 |
"""Teste la récupération d'événements selon le groupe de services.""" |
|
| 89 |
|
|
| 90 |
def test_search_service_when_allowed_by_hostgroup(self): |
|
| 91 |
""" |
|
| 92 |
Teste la recherche par service avec des droits implicites |
|
| 93 |
(droits accordés car l'utilisateur a les droits sur l'hôte). |
|
| 94 |
""" |
|
| 95 |
# On crée un service avec une alerte. |
|
| 96 |
# Le service est rattaché à un hôte appartenant |
|
| 97 |
# à un groupe d'hôtes pour lesquels l'utilisateur |
|
| 98 |
# a les permissions. |
|
| 99 |
hostgroup = insert_deps()[0] |
|
| 100 |
manage = Permission.by_permission_name(u'manage') |
|
| 101 |
manage.hostgroups.append(hostgroup) |
|
| 102 |
DBSession.flush() |
|
| 103 |
transaction.commit() |
|
| 104 |
|
|
| 105 |
# On envoie une requête avec recherche sur le service créé, |
|
| 106 |
# on s'attend à recevoir 1 résultat. |
|
| 107 |
response = self.app.get('/?service=baz',
|
|
| 108 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 109 |
|
|
| 110 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 111 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 112 |
print "There are %d rows in the result set" % len(rows) |
|
| 113 |
assert_equal(len(rows), 1) |
|
| 114 |
|
|
| 115 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 116 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 117 |
print "There are %d columns in the result set" % len(cols) |
|
| 118 |
assert_true(len(cols) > 1) |
|
| 119 |
|
|
| 120 |
def test_search_service_when_allowed_by_servicegroup(self): |
|
| 121 |
""" |
|
| 122 |
Teste la recherche par service avec des droits explicites |
|
| 123 |
(droits accordés car l'utilisateur a explicitement les droits |
|
| 124 |
sur ce service). |
|
| 125 |
""" |
|
| 126 |
# On crée un service avec une alerte. |
|
| 127 |
# Le service est rattaché à un groupe de services |
|
| 128 |
# pour lesquel l'utilisateur a les permissions. |
|
| 129 |
servicegroup = insert_deps()[1] |
|
| 130 |
manage = Permission.by_permission_name(u'manage') |
|
| 131 |
manage.servicegroups.append(servicegroup) |
|
| 132 |
DBSession.flush() |
|
| 133 |
transaction.commit() |
|
| 134 |
|
|
| 135 |
# On envoie une requête avec recherche sur le service créé, |
|
| 136 |
# on s'attend à recevoir 1 résultat. |
|
| 137 |
response = self.app.get('/?service=baz',
|
|
| 138 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 139 |
|
|
| 140 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 141 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 142 |
print "There are %d rows in the result set" % len(rows) |
|
| 143 |
assert_equal(len(rows), 1) |
|
| 144 |
|
|
| 145 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 146 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 147 |
print "There are %d columns in the result set" % len(cols) |
|
| 148 |
assert_true(len(cols) > 1) |
|
| 149 |
|
|
| 150 |
def test_search_inexistent_service(self): |
|
| 151 |
"""Teste la recherche par service sur un service inexistant.""" |
|
| 152 |
# On envoie une requête avec recherche sur un service |
|
| 153 |
# qui n'existe pas, on s'attend à n'obtenir aucun résultat. |
|
| 154 |
response = self.app.get('/?servicegroup=bad',
|
|
| 155 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 156 |
|
|
| 157 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 158 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 159 |
print "There are %d rows in the result set" % len(rows) |
|
| 160 |
assert_equal(len(rows), 1) |
|
| 161 |
|
|
| 162 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 163 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 164 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 165 |
assert_equal(len(cols), 1) |
|
| 166 |
|
|
| 167 |
def test_search_service_when_disallowed(self): |
|
| 168 |
"""Teste la recherche par service SANS les droits.""" |
|
| 169 |
# On NE DONNE PAS l'autorisation aux utilisateurs |
|
| 170 |
# de voir l'alerte, donc elle ne doit jamais apparaître. |
|
| 171 |
insert_deps() |
|
| 172 |
transaction.commit() |
|
| 173 |
|
|
| 174 |
# On envoie une requête avec recherche sur le service créé, |
|
| 175 |
# mais avec un utilisateur ne disposant pas des permissions adéquates. |
|
| 176 |
# On s'attend à n'obtenir aucun résultat. |
|
| 177 |
response = self.app.get('/?hostgroup=baz',
|
|
| 178 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 179 |
|
|
| 180 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 181 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 182 |
print "There are %d rows in the result set" % len(rows) |
|
| 183 |
assert_equal(len(rows), 1) |
|
| 184 |
|
|
| 185 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 186 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 187 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 188 |
print "There are %d columns in the result set" % len(cols) |
|
| 189 |
assert_equal(len(cols), 1) |
|
| 190 |
|
|
| vigiboard/tests/functional/test_search_form_servicegroup.py | ||
|---|---|---|
| 1 |
# -*- coding: utf-8 -*- |
|
| 2 |
""" |
|
| 3 |
Teste le formulaire de recherche avec un groupe de services. |
|
| 4 |
""" |
|
| 5 |
from nose.tools import assert_true, assert_equal |
|
| 6 |
from datetime import datetime |
|
| 7 |
import transaction |
|
| 8 |
|
|
| 9 |
from vigiboard.tests import TestController |
|
| 10 |
from vigiboard.model import DBSession, ServiceGroup, Host, Permission, \ |
|
| 11 |
ServiceLowLevel, Event, CorrEvent, StateName |
|
| 12 |
|
|
| 13 |
def insert_deps(): |
|
| 14 |
"""Insère les dépendances nécessaires aux tests.""" |
|
| 15 |
timestamp = datetime.now() |
|
| 16 |
DBSession.add(StateName(statename=u'OK', order=1)) |
|
| 17 |
DBSession.add(StateName(statename=u'UNKNOWN', order=1)) |
|
| 18 |
DBSession.add(StateName(statename=u'WARNING', order=1)) |
|
| 19 |
DBSession.add(StateName(statename=u'CRITICAL', order=1)) |
|
| 20 |
DBSession.flush() |
|
| 21 |
|
|
| 22 |
host = Host( |
|
| 23 |
name=u'bar', |
|
| 24 |
checkhostcmd=u'', |
|
| 25 |
description=u'', |
|
| 26 |
hosttpl=u'', |
|
| 27 |
mainip=u'127.0.0.1', |
|
| 28 |
snmpport=42, |
|
| 29 |
snmpcommunity=u'public', |
|
| 30 |
snmpversion=u'3', |
|
| 31 |
weight=42, |
|
| 32 |
) |
|
| 33 |
DBSession.add(host) |
|
| 34 |
DBSession.flush() |
|
| 35 |
|
|
| 36 |
servicegroup = ServiceGroup( |
|
| 37 |
name=u'foo', |
|
| 38 |
) |
|
| 39 |
DBSession.add(servicegroup) |
|
| 40 |
|
|
| 41 |
service = ServiceLowLevel( |
|
| 42 |
host=host, |
|
| 43 |
command=u'', |
|
| 44 |
weight=42, |
|
| 45 |
servicename=u'baz', |
|
| 46 |
op_dep=u'&', |
|
| 47 |
) |
|
| 48 |
DBSession.add(service) |
|
| 49 |
DBSession.flush() |
|
| 50 |
|
|
| 51 |
servicegroup.services.append(service) |
|
| 52 |
event = Event( |
|
| 53 |
supitem=service, |
|
| 54 |
timestamp=timestamp, |
|
| 55 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 56 |
message=u'Hello world', |
|
| 57 |
) |
|
| 58 |
DBSession.add(event) |
|
| 59 |
DBSession.flush() |
|
| 60 |
|
|
| 61 |
correvent = CorrEvent( |
|
| 62 |
impact=42, |
|
| 63 |
priority=42, |
|
| 64 |
trouble_ticket=None, |
|
| 65 |
status=u'None', |
|
| 66 |
occurrence=42, |
|
| 67 |
timestamp_active=timestamp, |
|
| 68 |
cause=event, |
|
| 69 |
) |
|
| 70 |
correvent.events.append(event) |
|
| 71 |
DBSession.add(correvent) |
|
| 72 |
DBSession.flush() |
|
| 73 |
return servicegroup |
|
| 74 |
|
|
| 75 |
class TestSearchFormServiceGroup(TestController): |
|
| 76 |
"""Teste la récupération d'événements selon le groupe de services.""" |
|
| 77 |
|
|
| 78 |
def test_search_servicegroup_when_allowed(self): |
|
| 79 |
"""Teste la recherche par servicegroup avec les bons droits d'accès.""" |
|
| 80 |
# On crée un groupe de services appelé 'foo', |
|
| 81 |
# contenant un service 'bar', ainsi qu'un événement |
|
| 82 |
# et un événement corrélé sur ce service. |
|
| 83 |
# De plus, on donne l'autorisation aux utilisateurs |
|
| 84 |
# ayant la permission 'manage' de voir cette alerte. |
|
| 85 |
servicegroup = insert_deps() |
|
| 86 |
manage = Permission.by_permission_name(u'manage') |
|
| 87 |
manage.servicegroups.append(servicegroup) |
|
| 88 |
DBSession.flush() |
|
| 89 |
transaction.commit() |
|
| 90 |
|
|
| 91 |
# On envoie une requête avec recherche sur le groupe de services créé, |
|
| 92 |
# on s'attend à recevoir 1 résultat. |
|
| 93 |
response = self.app.get('/?servicegroup=foo',
|
|
| 94 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 95 |
|
|
| 96 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 97 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 98 |
print "There are %d rows in the result set" % len(rows) |
|
| 99 |
assert_equal(len(rows), 1) |
|
| 100 |
|
|
| 101 |
# Il doit y avoir plusieurs colonnes dans la ligne de résultats. |
|
| 102 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 103 |
print "There are %d columns in the result set" % len(cols) |
|
| 104 |
assert_true(len(cols) > 1) |
|
| 105 |
|
|
| 106 |
def test_search_inexistent_servicegroup(self): |
|
| 107 |
"""Teste la recherche par servicegroup sur un groupe inexistant.""" |
|
| 108 |
# On envoie une requête avec recherche sur un groupe de services |
|
| 109 |
# qui n'existe pas, on s'attend à n'obtenir aucun résultat. |
|
| 110 |
response = self.app.get('/?servicegroup=foot',
|
|
| 111 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 112 |
|
|
| 113 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 114 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 115 |
print "There are %d rows in the result set" % len(rows) |
|
| 116 |
assert_equal(len(rows), 1) |
|
| 117 |
|
|
| 118 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 119 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 120 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 121 |
print "There are %d columns in the result set" % len(cols) |
|
| 122 |
assert_equal(len(cols), 1) |
|
| 123 |
|
|
| 124 |
def test_search_servicegroup_when_disallowed(self): |
|
| 125 |
"""Teste la recherche par servicegroup SANS les droits d'accès.""" |
|
| 126 |
# On crée un groupe de services appelé 'foo', |
|
| 127 |
# contenant un service 'bar', ainsi qu'un événement |
|
| 128 |
# et un événement corrélé sur cet hôte. |
|
| 129 |
# MAIS, on NE DONNE PAS l'autorisation aux utilisateurs |
|
| 130 |
# de voir cette alerte, donc elle ne doit jamais apparaître. |
|
| 131 |
insert_deps() |
|
| 132 |
transaction.commit() |
|
| 133 |
|
|
| 134 |
# On envoie une requête avec recherche sur le groupe de services créé, |
|
| 135 |
# mais avec un utilisateur ne disposant pas des permissions adéquates. |
|
| 136 |
# On s'attend à n'obtenir aucun résultat. |
|
| 137 |
response = self.app.get('/?servicegroup=foo',
|
|
| 138 |
extra_environ={'REMOTE_USER': 'manager'})
|
|
| 139 |
|
|
| 140 |
# Il doit y avoir 1 seule ligne de résultats. |
|
| 141 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 142 |
print "There are %d rows in the result set" % len(rows) |
|
| 143 |
assert_equal(len(rows), 1) |
|
| 144 |
|
|
| 145 |
# Il doit y avoir 1 seule colonne dans la ligne de résultats. |
|
| 146 |
# (la colonne contient le texte "Il n'y a aucun événément", traduit) |
|
| 147 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
|
| 148 |
print "There are %d columns in the result set" % len(cols) |
|
| 149 |
assert_equal(len(cols), 1) |
|
| 150 |
|
|
| vigiboard/tests/functional/test_vigiboardrequest.py | ||
|---|---|---|
| 201 | 201 |
# le plugin fonctionne correctement |
| 202 | 202 |
|
| 203 | 203 |
num_rows = vigi_req.num_rows() |
| 204 |
assert_true(num_rows == 1, msg = "1 historique devrait " +
|
|
| 205 |
"etre disponible pour l'utilisateur 'editor' mais il " +
|
|
| 206 |
"y en a %d" % num_rows)
|
|
| 204 |
assert_true(num_rows == 1, |
|
| 205 |
msg = "One history should be available for " +
|
|
| 206 |
"the user 'editor' but there are %d" % num_rows)
|
|
| 207 | 207 |
|
| 208 | 208 |
vigi_req.format_events(0, 10) |
| 209 | 209 |
vigi_req.format_history() |
| 210 | 210 |
assert_true(len(vigi_req.events) == 1 + 1, |
| 211 |
msg = "1 evenement devrait etre disponible pour " + |
|
| 212 |
"l'utilisateur 'editor' mais il y en a %d" % |
|
| 213 |
(len(vigi_req.events) - 1)) |
|
| 214 |
assert_true(vigi_req.events[1][6][0][0] != 'Error', |
|
| 215 |
msg = "Probleme d'execution des plugins ou de " + |
|
| 216 |
"formatage des evenements") |
|
| 211 |
msg = "One history should be available for the user " + |
|
| 212 |
"'editor' but there are %d" % (len(vigi_req.events) - 1)) |
|
| 213 |
# assert_true(vigi_req.events[1][6][0][0] != 'Error', |
|
| 214 |
# msg = "Plugins execution or events formatting problem") |
|
| 217 | 215 |
|
| 218 | 216 |
# On recommence les tests précédents avec l'utilisateur |
| 219 | 217 |
# manager (plus de droits) |
| ... | ... | |
| 227 | 225 |
|
| 228 | 226 |
num_rows = vigi_req.num_rows() |
| 229 | 227 |
assert_true(num_rows == 2, |
| 230 |
msg = "2 historiques devraient etre disponibles pour " +
|
|
| 231 |
"l'utilisateur 'manager' mais il y en a %d" % num_rows)
|
|
| 228 |
msg = "2 histories should be available for " +
|
|
| 229 |
"the user 'manager' but there are %d" % num_rows)
|
|
| 232 | 230 |
vigi_req.format_events(0, 10) |
| 233 | 231 |
vigi_req.format_history() |
| 234 | 232 |
assert_true(len(vigi_req.events) == 2 + 1, |
| 235 |
msg = "2 evenements devraient être disponibles pour " + |
|
| 236 |
"l'utilisateur 'manager' mais il y en a %d" % |
|
| 237 |
(len(vigi_req.events) - 1)) |
|
| 238 |
assert_true(vigi_req.events[1][6][0][0] != 'Error', |
|
| 239 |
msg = "Probleme d'execution des plugins") |
|
| 233 |
msg = "2 histories should be available for the user " + |
|
| 234 |
"'manager' but there are %d" % (len(vigi_req.events) - 1)) |
|
| 235 |
# assert_true(vigi_req.events[1][6][0][0] != 'Error', |
|
| 236 |
# msg = "Plugins execution or events formatting problem") |
|
| 240 | 237 |
|
Also available in: Unified diff