Revision 03059edd
Mise à jour suite à r6528.
Correction des tests unitaires.
Ajout d'un test (en SKIP pour le moment pour #464).
Petit nettoyage dans le plugin des détails
(suppression des imports inutilisés).
git-svn-id: https://vigilo-dev.si.c-s.fr/svn@6529 b22e2e97-25c9-44ff-b637-2e5ceca36478
| vigiboard/controllers/plugins/details.py | ||
|---|---|---|
| 25 | 25 |
""" |
| 26 | 26 |
|
| 27 | 27 |
import urllib |
| 28 |
|
|
| 29 |
from tg.exceptions import HTTPForbidden |
|
| 30 | 28 |
from tg import config, url |
| 31 |
|
|
| 32 | 29 |
from sqlalchemy.sql.expression import null as expr_null, union_all |
| 30 |
|
|
| 33 | 31 |
from vigilo.models.session import DBSession |
| 34 | 32 |
from vigilo.models.tables import Event, \ |
| 35 | 33 |
CorrEvent, Host, LowLevelService, StateName |
| 36 | 34 |
|
| 37 | 35 |
from vigiboard.controllers.plugins import VigiboardRequestPlugin |
| 38 |
from vigilo.turbogears.helpers import get_current_user |
|
| 39 | 36 |
|
| 40 | 37 |
class PluginDetails(VigiboardRequestPlugin): |
| 41 | 38 |
""" |
| vigiboard/tests/functional/plugins/test_details_plugin.py | ||
|---|---|---|
| 27 | 27 |
""" |
| 28 | 28 |
timestamp = datetime.now() |
| 29 | 29 |
|
| 30 |
hostgroup = SupItemGroup(name=u'foo') |
|
| 30 |
hostgroup = SupItemGroup(name=u'foo', parent=None)
|
|
| 31 | 31 |
DBSession.add(hostgroup) |
| 32 | 32 |
|
| 33 | 33 |
host = Host( |
| ... | ... | |
| 47 | 47 |
hostgroup.supitems.append(host) |
| 48 | 48 |
DBSession.flush() |
| 49 | 49 |
|
| 50 |
servicegroup = SupItemGroup(name=u'bar') |
|
| 50 |
servicegroup = SupItemGroup(name=u'bar', parent=None)
|
|
| 51 | 51 |
DBSession.add(servicegroup) |
| 52 | 52 |
|
| 53 | 53 |
service = LowLevelService( |
| ... | ... | |
| 112 | 112 |
fullname=u'', |
| 113 | 113 |
email=u'user.has@access', |
| 114 | 114 |
) |
| 115 |
usergroup = UserGroup( |
|
| 116 |
group_name=u'users_with_access', |
|
| 117 |
) |
|
| 115 |
usergroup = UserGroup(group_name=u'users_with_access') |
|
| 118 | 116 |
usergroup.permissions.append(perm) |
| 119 | 117 |
user.usergroups.append(usergroup) |
| 120 | 118 |
DBSession.add(user) |
| ... | ... | |
| 126 | 124 |
fullname=u'', |
| 127 | 125 |
email=u'user.has.no@access', |
| 128 | 126 |
) |
| 129 |
usergroup = UserGroup( |
|
| 130 |
group_name=u'users_without_access', |
|
| 131 |
) |
|
| 127 |
usergroup = UserGroup(group_name=u'users_without_access') |
|
| 132 | 128 |
usergroup.permissions.append(perm) |
| 133 | 129 |
user.usergroups.append(usergroup) |
| 134 | 130 |
DBSession.add(user) |
| vigiboard/tests/functional/plugins/test_plugin_hls.py | ||
|---|---|---|
| 16 | 16 |
""" Peuple la base de données. """ |
| 17 | 17 |
|
| 18 | 18 |
# On ajoute un groupe d'hôtes |
| 19 |
hostmanagers = SupItemGroup(name=u'managersgroup') |
|
| 19 |
hostmanagers = SupItemGroup(name=u'managersgroup', parent=None)
|
|
| 20 | 20 |
DBSession.add(hostmanagers) |
| 21 | 21 |
DBSession.flush() |
| 22 | 22 |
|
| ... | ... | |
| 128 | 128 |
fullname=u'', |
| 129 | 129 |
email=u'user.has@access', |
| 130 | 130 |
) |
| 131 |
usergroup = UserGroup( |
|
| 132 |
group_name=u'users_with_access', |
|
| 133 |
) |
|
| 131 |
usergroup = UserGroup(group_name=u'users_with_access') |
|
| 134 | 132 |
usergroup.permissions.append(perm) |
| 135 | 133 |
user.usergroups.append(usergroup) |
| 136 | 134 |
DBSession.add(user) |
| vigiboard/tests/functional/test_correvents_table.py | ||
|---|---|---|
| 17 | 17 |
def populate_DB(): |
| 18 | 18 |
""" Peuple la base de données. """ |
| 19 | 19 |
# On ajoute les groupes et leurs dépendances |
| 20 |
hostmanagers = SupItemGroup(name=u'managersgroup') |
|
| 20 |
hostmanagers = SupItemGroup(name=u'managersgroup', parent=None)
|
|
| 21 | 21 |
DBSession.add(hostmanagers) |
| 22 | 22 |
hosteditors = SupItemGroup(name=u'editorsgroup', parent=hostmanagers) |
| 23 | 23 |
DBSession.add(hosteditors) |
| ... | ... | |
| 164 | 164 |
fullname=u'', |
| 165 | 165 |
email=u'user.has@access', |
| 166 | 166 |
) |
| 167 |
usergroup = UserGroup( |
|
| 168 |
group_name=u'users_with_access', |
|
| 169 |
) |
|
| 167 |
usergroup = UserGroup(group_name=u'users_with_access') |
|
| 170 | 168 |
usergroup.permissions.append(perm) |
| 171 | 169 |
user.usergroups.append(usergroup) |
| 172 | 170 |
DBSession.add(user) |
| ... | ... | |
| 178 | 176 |
fullname=u'', |
| 179 | 177 |
email=u'user.has.no@access', |
| 180 | 178 |
) |
| 181 |
usergroup = UserGroup( |
|
| 182 |
group_name=u'users_with_limited_access', |
|
| 183 |
) |
|
| 179 |
usergroup = UserGroup(group_name=u'users_with_limited_access') |
|
| 184 | 180 |
usergroup.permissions.append(perm) |
| 185 | 181 |
user.usergroups.append(usergroup) |
| 186 | 182 |
DBSession.add(user) |
| ... | ... | |
| 282 | 278 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
| 283 | 279 |
print "There are %d rows in the result set" % len(rows) |
| 284 | 280 |
assert_equal(len(rows), 1) |
| 285 |
|
|
| vigiboard/tests/functional/test_history_table.py | ||
|---|---|---|
| 20 | 20 |
def populate_DB(): |
| 21 | 21 |
""" Peuple la base de données. """ |
| 22 | 22 |
# On ajoute un groupe d'hôtes et un groupe de services. |
| 23 |
supitemmanagers = SupItemGroup(name=u'managersgroup') |
|
| 23 |
supitemmanagers = SupItemGroup(name=u'managersgroup', parent=None)
|
|
| 24 | 24 |
DBSession.add(supitemmanagers) |
| 25 | 25 |
DBSession.flush() |
| 26 | 26 |
|
| ... | ... | |
| 34 | 34 |
|
| 35 | 35 |
# On crée un hôte de test, et on l'ajoute au groupe d'hôtes. |
| 36 | 36 |
managerhost = Host( |
| 37 |
name = u'managerhost',
|
|
| 37 |
name = u'managerhost', |
|
| 38 | 38 |
checkhostcmd = u'halt', |
| 39 | 39 |
snmpcommunity = u'public', |
| 40 | 40 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 56 | 56 |
DBSession.add(managerservice) |
| 57 | 57 |
supitemmanagers.supitems.append(managerservice) |
| 58 | 58 |
DBSession.flush() |
| 59 |
|
|
| 59 |
|
|
| 60 | 60 |
return (managerhost, managerservice) |
| 61 | 61 |
|
| 62 | 62 |
def add_correvent_caused_by(supitem): |
| 63 | 63 |
""" |
| 64 |
Ajoute dans la base de données un évènement corrélé causé
|
|
| 64 |
Ajoute dans la base de données un évènement corrélé causé |
|
| 65 | 65 |
par un incident survenu sur l'item passé en paramètre. |
| 66 | 66 |
Génère un historique pour les tests. |
| 67 | 67 |
""" |
| 68 | 68 |
|
| 69 | 69 |
# Ajout d'un événement |
| 70 | 70 |
event = Event( |
| 71 |
supitem = supitem,
|
|
| 71 |
supitem = supitem, |
|
| 72 | 72 |
message = u'foo', |
| 73 | 73 |
current_state = StateName.statename_to_value(u"WARNING"), |
| 74 | 74 |
timestamp = datetime.now(), |
| ... | ... | |
| 79 | 79 |
# Ajout des historiques |
| 80 | 80 |
DBSession.add(EventHistory( |
| 81 | 81 |
type_action=u'Nagios update state', |
| 82 |
idevent=event.idevent,
|
|
| 82 |
idevent=event.idevent, |
|
| 83 | 83 |
timestamp=datetime.now())) |
| 84 | 84 |
DBSession.add(EventHistory( |
| 85 | 85 |
type_action=u'Acknowlegement change state', |
| 86 |
idevent=event.idevent,
|
|
| 86 |
idevent=event.idevent, |
|
| 87 | 87 |
timestamp=datetime.now())) |
| 88 | 88 |
DBSession.flush() |
| 89 | 89 |
|
| 90 | 90 |
# Ajout d'un événement corrélé |
| 91 | 91 |
aggregate = CorrEvent( |
| 92 |
idcause = event.idevent,
|
|
| 92 |
idcause = event.idevent, |
|
| 93 | 93 |
timestamp_active = datetime.now(), |
| 94 | 94 |
priority = 1, |
| 95 | 95 |
status = u"None") |
| 96 | 96 |
aggregate.events.append(event) |
| 97 | 97 |
DBSession.add(aggregate) |
| 98 | 98 |
DBSession.flush() |
| 99 |
|
|
| 99 |
|
|
| 100 | 100 |
return event.idevent |
| 101 |
|
|
| 101 |
|
|
| 102 | 102 |
|
| 103 | 103 |
class TestHistoryTable(TestController): |
| 104 | 104 |
""" |
| ... | ... | |
| 114 | 114 |
fullname=u'', |
| 115 | 115 |
email=u'user.has@access', |
| 116 | 116 |
) |
| 117 |
usergroup = UserGroup( |
|
| 118 |
group_name=u'users_with_access', |
|
| 119 |
) |
|
| 117 |
usergroup = UserGroup(group_name=u'users_with_access') |
|
| 120 | 118 |
usergroup.permissions.append(perm) |
| 121 | 119 |
user.usergroups.append(usergroup) |
| 122 | 120 |
DBSession.add(user) |
| ... | ... | |
| 128 | 126 |
fullname=u'', |
| 129 | 127 |
email=u'user.has.no@access', |
| 130 | 128 |
) |
| 131 |
usergroup = UserGroup( |
|
| 132 |
group_name=u'users_with_limited_access', |
|
| 133 |
) |
|
| 129 |
usergroup = UserGroup(group_name=u'users_with_limited_access') |
|
| 134 | 130 |
usergroup.permissions.append(perm) |
| 135 | 131 |
user.usergroups.append(usergroup) |
| 136 | 132 |
DBSession.add(user) |
| ... | ... | |
| 144 | 140 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
| 145 | 141 |
# et un groupe d'hôtes et de services associés à ces items. |
| 146 | 142 |
(managerhost, managerservice) = populate_DB() |
| 147 |
|
|
| 143 |
|
|
| 148 | 144 |
# On ajoute un évènement corrélé causé par l'hôte |
| 149 | 145 |
idevent = add_correvent_caused_by(managerhost) |
| 150 | 146 |
transaction.commit() |
| ... | ... | |
| 158 | 154 |
|
| 159 | 155 |
# L'utilisateur N'A PAS les bonnes permissions. |
| 160 | 156 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 161 |
|
|
| 157 |
|
|
| 162 | 158 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 163 | 159 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 164 | 160 |
# n'a pas accès aux informations concernant cet évènement. |
| 165 | 161 |
response = self.app.get( |
| 166 | 162 |
'/event/%d' % idevent, |
| 167 |
status = 302,
|
|
| 163 |
status = 302, |
|
| 168 | 164 |
extra_environ = environ) |
| 169 | 165 |
|
| 170 | 166 |
# On suit la redirection. |
| ... | ... | |
| 174 | 170 |
|
| 175 | 171 |
# L'utilisateur a les bonnes permissions. |
| 176 | 172 |
environ = {'REMOTE_USER': 'access'}
|
| 177 |
|
|
| 173 |
|
|
| 178 | 174 |
# On s'attend à ce que le statut de la requête soit 200. |
| 179 | 175 |
response = self.app.get( |
| 180 | 176 |
'/event/%d' % idevent, |
| 181 |
status = 200,
|
|
| 177 |
status = 200, |
|
| 182 | 178 |
extra_environ = environ) |
| 183 | 179 |
|
| 184 | 180 |
# Il doit y avoir 2 lignes de résultats. |
| ... | ... | |
| 195 | 191 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
| 196 | 192 |
# et un groupe d'hôtes et de services associés à ces items. |
| 197 | 193 |
(managerhost, managerservice) = populate_DB() |
| 198 |
|
|
| 194 |
|
|
| 199 | 195 |
# On ajoute un évènement corrélé causé par le service |
| 200 | 196 |
idevent = add_correvent_caused_by(managerservice) |
| 201 |
|
|
| 197 |
|
|
| 202 | 198 |
transaction.commit() |
| 203 | 199 |
|
| 204 | 200 |
# L'utilisateur n'est pas authentifié. |
| ... | ... | |
| 210 | 206 |
|
| 211 | 207 |
# L'utilisateur N'A PAS les bonnes permissions. |
| 212 | 208 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 213 |
|
|
| 209 |
|
|
| 214 | 210 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 215 | 211 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 216 | 212 |
# n'a pas accès aux informations concernant cet évènement. |
| 217 | 213 |
response = self.app.get( |
| 218 | 214 |
'/event/%d' % idevent, |
| 219 |
status = 302,
|
|
| 215 |
status = 302, |
|
| 220 | 216 |
extra_environ = environ) |
| 221 | 217 |
|
| 222 | 218 |
# On suit la redirection. |
| ... | ... | |
| 226 | 222 |
|
| 227 | 223 |
# L'utilisateur a les bonnes permissions. |
| 228 | 224 |
environ = {'REMOTE_USER': 'access'}
|
| 229 |
|
|
| 225 |
|
|
| 230 | 226 |
# On s'attend à ce que le statut de la requête soit 200. |
| 231 | 227 |
response = self.app.get( |
| 232 | 228 |
'/event/%d' % idevent, |
| 233 |
status = 200,
|
|
| 229 |
status = 200, |
|
| 234 | 230 |
extra_environ = environ) |
| 235 | 231 |
|
| 236 | 232 |
# Il doit y avoir 2 lignes de résultats. |
| ... | ... | |
| 240 | 236 |
rows = response.lxml.xpath( |
| 241 | 237 |
'//table[contains(@class,"vigitable")]/tbody/tr') |
| 242 | 238 |
assert_equal(len(rows), 2) |
| 243 |
|
|
| vigiboard/tests/functional/test_raw_events_table.py | ||
|---|---|---|
| 22 | 22 |
fullname=u'', |
| 23 | 23 |
email=u'user.has@access', |
| 24 | 24 |
) |
| 25 |
usergroup = UserGroup( |
|
| 26 |
group_name=u'users_with_access', |
|
| 27 |
) |
|
| 25 |
usergroup = UserGroup(group_name=u'users_with_access') |
|
| 28 | 26 |
usergroup.permissions.append(perm) |
| 29 | 27 |
user.usergroups.append(usergroup) |
| 30 | 28 |
DBSession.add(user) |
| ... | ... | |
| 36 | 34 |
fullname=u'', |
| 37 | 35 |
email=u'user.has.no@access', |
| 38 | 36 |
) |
| 39 |
usergroup = UserGroup( |
|
| 40 |
group_name=u'users_with_limited_access', |
|
| 41 |
) |
|
| 37 |
usergroup = UserGroup(group_name=u'users_with_limited_access') |
|
| 42 | 38 |
usergroup.permissions.append(perm) |
| 43 | 39 |
user.usergroups.append(usergroup) |
| 44 | 40 |
DBSession.add(user) |
| ... | ... | |
| 49 | 45 |
def populate_DB(caused_by_service): |
| 50 | 46 |
""" Peuple la base de données. """ |
| 51 | 47 |
# On ajoute un groupe d'hôtes et un groupe de services. |
| 52 |
supitemmanagers = SupItemGroup(name = u'managersgroup') |
|
| 48 |
supitemmanagers = SupItemGroup(name = u'managersgroup', parent=None)
|
|
| 53 | 49 |
DBSession.add(supitemmanagers) |
| 54 | 50 |
DBSession.flush() |
| 55 | 51 |
|
| vigiboard/tests/functional/test_root.py | ||
|---|---|---|
| 11 | 11 |
|
| 12 | 12 |
""" |
| 13 | 13 |
from nose.tools import assert_true, assert_false, assert_equal |
| 14 |
from nose import SkipTest |
|
| 14 | 15 |
from datetime import datetime |
| 15 | 16 |
from time import mktime |
| 16 | 17 |
import transaction |
| ... | ... | |
| 20 | 21 |
Permission, StateName, Host, UserGroup, \ |
| 21 | 22 |
SupItemGroup, LowLevelService, DataPermission |
| 22 | 23 |
from vigiboard.tests import TestController |
| 24 |
from tg import config |
|
| 23 | 25 |
|
| 24 | 26 |
def populate_DB(): |
| 25 | 27 |
""" Peuple la base de données. """ |
| 26 | 28 |
# On ajoute un groupe d'hôtes et un groupe de services. |
| 27 |
supitemmanagers = SupItemGroup(name = u'managersgroup') |
|
| 29 |
supitemmanagers = SupItemGroup(name = u'managersgroup', parent=None)
|
|
| 28 | 30 |
DBSession.add(supitemmanagers) |
| 29 | 31 |
DBSession.flush() |
| 30 | 32 |
|
| ... | ... | |
| 38 | 40 |
|
| 39 | 41 |
# On crée un 2 hôtes, et on les ajoute au groupe d'hôtes. |
| 40 | 42 |
host1 = Host( |
| 41 |
name = u'host1',
|
|
| 43 |
name = u'host1', |
|
| 42 | 44 |
checkhostcmd = u'halt', |
| 43 | 45 |
snmpcommunity = u'public', |
| 44 | 46 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 49 | 51 |
DBSession.add(host1) |
| 50 | 52 |
supitemmanagers.supitems.append(host1) |
| 51 | 53 |
host2 = Host( |
| 52 |
name = u'host2',
|
|
| 54 |
name = u'host2', |
|
| 53 | 55 |
checkhostcmd = u'halt', |
| 54 | 56 |
snmpcommunity = u'public', |
| 55 | 57 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 79 | 81 |
DBSession.add(service2) |
| 80 | 82 |
supitemmanagers.supitems.append(service2) |
| 81 | 83 |
DBSession.flush() |
| 82 |
|
|
| 84 |
|
|
| 83 | 85 |
return ([host1, host2], [service1, service2]) |
| 84 | 86 |
|
| 85 | 87 |
def add_correvent_caused_by(supitem, timestamp, |
| 86 | 88 |
correvent_status=u"None", event_status=u"WARNING"): |
| 87 | 89 |
""" |
| 88 |
Ajoute dans la base de données un évènement corrélé causé
|
|
| 90 |
Ajoute dans la base de données un évènement corrélé causé |
|
| 89 | 91 |
par un incident survenu sur l'item passé en paramètre. |
| 90 | 92 |
Génère un historique pour les tests. |
| 91 | 93 |
""" |
| 92 | 94 |
|
| 93 | 95 |
# Ajout d'un événement |
| 94 | 96 |
event = Event( |
| 95 |
supitem = supitem,
|
|
| 97 |
supitem = supitem, |
|
| 96 | 98 |
message = u'foo', |
| 97 | 99 |
current_state = StateName.statename_to_value(event_status), |
| 98 | 100 |
timestamp = datetime.now(), |
| ... | ... | |
| 102 | 104 |
|
| 103 | 105 |
# Ajout d'un événement corrélé |
| 104 | 106 |
aggregate = CorrEvent( |
| 105 |
idcause = event.idevent,
|
|
| 107 |
idcause = event.idevent, |
|
| 106 | 108 |
timestamp_active = timestamp, |
| 107 | 109 |
priority = 1, |
| 108 | 110 |
status = correvent_status) |
| 109 | 111 |
aggregate.events.append(event) |
| 110 | 112 |
DBSession.add(aggregate) |
| 111 | 113 |
DBSession.flush() |
| 112 |
|
|
| 114 |
|
|
| 113 | 115 |
return aggregate.idcorrevent |
| 114 | 116 |
|
| 115 | 117 |
|
| ... | ... | |
| 125 | 127 |
fullname=u'', |
| 126 | 128 |
email=u'user.has@access', |
| 127 | 129 |
) |
| 128 |
usergroup = UserGroup( |
|
| 129 |
group_name=u'users_with_access', |
|
| 130 |
) |
|
| 130 |
usergroup = UserGroup(group_name=u'users_with_access') |
|
| 131 | 131 |
usergroup.permissions.append(perm) |
| 132 | 132 |
usergroup.permissions.append(perm2) |
| 133 | 133 |
user.usergroups.append(usergroup) |
| ... | ... | |
| 140 | 140 |
fullname=u'', |
| 141 | 141 |
email=u'user.has.no@access', |
| 142 | 142 |
) |
| 143 |
usergroup = UserGroup( |
|
| 144 |
group_name=u'users_with_limited_access', |
|
| 145 |
) |
|
| 143 |
usergroup = UserGroup(group_name=u'users_with_limited_access') |
|
| 146 | 144 |
usergroup.permissions.append(perm) |
| 147 | 145 |
usergroup.permissions.append(perm2) |
| 148 | 146 |
user.usergroups.append(usergroup) |
| ... | ... | |
| 163 | 161 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 164 | 162 |
# et un groupe d'hôtes et de services associés à ces items. |
| 165 | 163 |
(hosts, services) = populate_DB() |
| 166 |
|
|
| 164 |
|
|
| 167 | 165 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 168 | 166 |
timestamp = datetime.now() |
| 169 | 167 |
correvent1_id = add_correvent_caused_by(hosts[0], timestamp) |
| 170 | 168 |
correvent2_id = add_correvent_caused_by(hosts[1], timestamp) |
| 171 | 169 |
transaction.commit() |
| 172 |
|
|
| 170 |
|
|
| 173 | 171 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 174 | 172 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 175 | 173 |
response = self.app.post( |
| ... | ... | |
| 179 | 177 |
"trouble_ticket" : u"foo", |
| 180 | 178 |
"ack" : u'NoChange', |
| 181 | 179 |
}, status = 401) |
| 182 |
|
|
| 180 |
|
|
| 183 | 181 |
### 2ème cas : L'utilisateur utilisé pour |
| 184 | 182 |
# se connecter à Vigiboard est 'limited_access'. |
| 185 | 183 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 186 |
|
|
| 184 |
|
|
| 187 | 185 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 188 | 186 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 189 | 187 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 194 | 192 |
"trouble_ticket" : u"foo", |
| 195 | 193 |
"last_modification": mktime(timestamp.timetuple()), |
| 196 | 194 |
}, status = 302, extra_environ = environ) |
| 197 |
|
|
| 195 |
|
|
| 198 | 196 |
response = response.follow(status=200, extra_environ = environ) |
| 199 | 197 |
assert_true(response.lxml.xpath( |
| 200 | 198 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 202 | 200 |
### 3ème cas : L'utilisateur utilisé pour |
| 203 | 201 |
# se connecter à Vigiboard est 'access'. |
| 204 | 202 |
environ = {'REMOTE_USER': 'access'}
|
| 205 |
|
|
| 203 |
|
|
| 206 | 204 |
# On s'attend à ce que le statut de la requête soit 302, |
| 207 | 205 |
# et à ce qu'un message informe l'utilisateur que les |
| 208 | 206 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 213 | 211 |
"trouble_ticket" : u"foo", |
| 214 | 212 |
"ack" : u'NoChange', |
| 215 | 213 |
}, status = 302, extra_environ = environ) |
| 216 |
|
|
| 214 |
|
|
| 217 | 215 |
response = response.follow(status=200, extra_environ = environ) |
| 218 | 216 |
assert_false(response.lxml.xpath( |
| 219 | 217 |
'//div[@id="flash"]/div[@class="error"]')) |
| 220 | 218 |
assert_true(response.lxml.xpath( |
| 221 | 219 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 222 |
|
|
| 220 |
|
|
| 223 | 221 |
# On s'assure que le ticket de l'évènement corrélé |
| 224 | 222 |
# a bien été mis à jour dans la base de données. |
| 225 | 223 |
correvents = DBSession.query( |
| 226 | 224 |
CorrEvent.trouble_ticket |
| 227 | 225 |
).filter(CorrEvent.idcorrevent.in_([correvent1_id, correvent2_id]) |
| 228 | 226 |
).all() |
| 229 |
|
|
| 227 |
|
|
| 230 | 228 |
assert_equal(correvents[0].trouble_ticket, u"foo") |
| 231 | 229 |
assert_equal(correvents[1].trouble_ticket, u"foo") |
| 232 | 230 |
|
| ... | ... | |
| 236 | 234 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 237 | 235 |
# et un groupe d'hôtes et de services associés à ces items. |
| 238 | 236 |
(hosts, services) = populate_DB() |
| 239 |
|
|
| 237 |
|
|
| 240 | 238 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 241 | 239 |
timestamp = datetime.now() |
| 242 | 240 |
correvent1_id = add_correvent_caused_by(services[0], timestamp) |
| 243 | 241 |
correvent2_id = add_correvent_caused_by(services[1], timestamp) |
| 244 |
|
|
| 242 |
|
|
| 245 | 243 |
transaction.commit() |
| 246 |
|
|
| 244 |
|
|
| 247 | 245 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 248 | 246 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 249 | 247 |
response = self.app.post( |
| ... | ... | |
| 253 | 251 |
"trouble_ticket" : u"foo", |
| 254 | 252 |
"ack" : u'NoChange', |
| 255 | 253 |
}, status = 401) |
| 256 |
|
|
| 254 |
|
|
| 257 | 255 |
### 2ème cas : L'utilisateur utilisé pour |
| 258 | 256 |
# se connecter à Vigiboard est 'limited_access'. |
| 259 | 257 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 260 |
|
|
| 258 |
|
|
| 261 | 259 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 262 | 260 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 263 | 261 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 268 | 266 |
"trouble_ticket" : u"foo", |
| 269 | 267 |
"ack" : u'NoChange', |
| 270 | 268 |
}, status = 302, extra_environ = environ) |
| 271 |
|
|
| 269 |
|
|
| 272 | 270 |
response = response.follow(status=200, extra_environ = environ) |
| 273 | 271 |
assert_true(response.lxml.xpath( |
| 274 | 272 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 276 | 274 |
### 3ème cas : L'utilisateur utilisé pour |
| 277 | 275 |
# se connecter à Vigiboard est 'access'. |
| 278 | 276 |
environ = {'REMOTE_USER': 'access'}
|
| 279 |
|
|
| 277 |
|
|
| 280 | 278 |
# On s'attend à ce que le statut de la requête soit 302, |
| 281 | 279 |
# et à ce qu'un message informe l'utilisateur que les |
| 282 | 280 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 287 | 285 |
"trouble_ticket" : u"foo", |
| 288 | 286 |
"ack" : u'NoChange', |
| 289 | 287 |
}, status = 302, extra_environ = environ) |
| 290 |
|
|
| 288 |
|
|
| 291 | 289 |
response = response.follow(status=200, extra_environ = environ) |
| 292 | 290 |
assert_false(response.lxml.xpath( |
| 293 | 291 |
'//div[@id="flash"]/div[@class="error"]')) |
| 294 | 292 |
assert_true(response.lxml.xpath( |
| 295 | 293 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 296 |
|
|
| 294 |
|
|
| 297 | 295 |
# On s'assure que le ticket de l'évènement corrélé |
| 298 | 296 |
# a bien été mis à jour dans la base de données. |
| 299 | 297 |
correvents = DBSession.query( |
| ... | ... | |
| 309 | 307 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 310 | 308 |
# et un groupe d'hôtes et de services associés à ces items. |
| 311 | 309 |
(hosts, services) = populate_DB() |
| 312 |
|
|
| 310 |
|
|
| 313 | 311 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 314 | 312 |
timestamp = datetime.now() |
| 315 | 313 |
correvent1_id = add_correvent_caused_by(hosts[0], timestamp) |
| 316 | 314 |
correvent2_id = add_correvent_caused_by(hosts[1], timestamp) |
| 317 | 315 |
transaction.commit() |
| 318 |
|
|
| 316 |
|
|
| 319 | 317 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 320 | 318 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 321 | 319 |
response = self.app.post( |
| ... | ... | |
| 325 | 323 |
"trouble_ticket" : "", |
| 326 | 324 |
"ack" : u'Acknowledged', |
| 327 | 325 |
}, status = 401) |
| 328 |
|
|
| 326 |
|
|
| 329 | 327 |
### 2ème cas : L'utilisateur utilisé pour |
| 330 | 328 |
# se connecter à Vigiboard est 'limited_access'. |
| 331 | 329 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 332 |
|
|
| 330 |
|
|
| 333 | 331 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 334 | 332 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 335 | 333 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 340 | 338 |
"trouble_ticket" : "", |
| 341 | 339 |
"ack" : u'Acknowledged', |
| 342 | 340 |
}, status = 302, extra_environ = environ) |
| 343 |
|
|
| 341 |
|
|
| 344 | 342 |
response = response.follow(status=200, extra_environ = environ) |
| 345 | 343 |
assert_true(response.lxml.xpath( |
| 346 | 344 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 348 | 346 |
### 3ème cas : L'utilisateur utilisé pour |
| 349 | 347 |
# se connecter à Vigiboard est 'access'. |
| 350 | 348 |
environ = {'REMOTE_USER': 'access'}
|
| 351 |
|
|
| 349 |
|
|
| 352 | 350 |
# On s'attend à ce que le statut de la requête soit 302, |
| 353 | 351 |
# et à ce qu'un message informe l'utilisateur que les |
| 354 | 352 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 359 | 357 |
"trouble_ticket" : "", |
| 360 | 358 |
"ack" : u'Acknowledged', |
| 361 | 359 |
}, status = 302, extra_environ = environ) |
| 362 |
|
|
| 360 |
|
|
| 363 | 361 |
response = response.follow(status=200, extra_environ = environ) |
| 364 | 362 |
assert_false(response.lxml.xpath( |
| 365 | 363 |
'//div[@id="flash"]/div[@class="error"]')) |
| 366 | 364 |
assert_true(response.lxml.xpath( |
| 367 | 365 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 368 |
|
|
| 366 |
|
|
| 369 | 367 |
# On s'assure que le statut de l'évènement corrélé |
| 370 | 368 |
# a bien été mis à jour dans la base de données. |
| 371 | 369 |
correvents = DBSession.query( |
| ... | ... | |
| 382 | 380 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 383 | 381 |
# et un groupe d'hôtes et de services associés à ces items. |
| 384 | 382 |
(hosts, services) = populate_DB() |
| 385 |
|
|
| 383 |
|
|
| 386 | 384 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 387 | 385 |
timestamp = datetime.now() |
| 388 | 386 |
correvent1_id = add_correvent_caused_by(services[0], timestamp) |
| 389 | 387 |
correvent2_id = add_correvent_caused_by(services[1], timestamp) |
| 390 |
|
|
| 388 |
|
|
| 391 | 389 |
transaction.commit() |
| 392 |
|
|
| 390 |
|
|
| 393 | 391 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 394 | 392 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 395 | 393 |
response = self.app.post( |
| ... | ... | |
| 399 | 397 |
"trouble_ticket" : "", |
| 400 | 398 |
"ack" : u'Acknowledged', |
| 401 | 399 |
}, status = 401) |
| 402 |
|
|
| 400 |
|
|
| 403 | 401 |
### 2ème cas : L'utilisateur utilisé pour |
| 404 | 402 |
# se connecter à Vigiboard est 'limited_access'. |
| 405 | 403 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 406 |
|
|
| 404 |
|
|
| 407 | 405 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 408 | 406 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 409 | 407 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 414 | 412 |
"trouble_ticket" : "", |
| 415 | 413 |
"ack" : u'Acknowledged', |
| 416 | 414 |
}, status = 302, extra_environ = environ) |
| 417 |
|
|
| 415 |
|
|
| 418 | 416 |
response = response.follow(status=200, extra_environ = environ) |
| 419 | 417 |
assert_true(response.lxml.xpath( |
| 420 | 418 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 422 | 420 |
### 3ème cas : L'utilisateur utilisé pour |
| 423 | 421 |
# se connecter à Vigiboard est 'access'. |
| 424 | 422 |
environ = {'REMOTE_USER': 'access'}
|
| 425 |
|
|
| 423 |
|
|
| 426 | 424 |
# On s'attend à ce que le statut de la requête soit 302, |
| 427 | 425 |
# et à ce qu'un message informe l'utilisateur que les |
| 428 | 426 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 433 | 431 |
"trouble_ticket" : "", |
| 434 | 432 |
"ack" : u'Acknowledged', |
| 435 | 433 |
}, status = 302, extra_environ = environ) |
| 436 |
|
|
| 434 |
|
|
| 437 | 435 |
response = response.follow(status=200, extra_environ = environ) |
| 438 | 436 |
assert_false(response.lxml.xpath( |
| 439 | 437 |
'//div[@id="flash"]/div[@class="error"]')) |
| 440 | 438 |
assert_true(response.lxml.xpath( |
| 441 | 439 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 442 |
|
|
| 440 |
|
|
| 443 | 441 |
# On s'assure que le statut de l'évènement corrélé |
| 444 | 442 |
# a bien été mis à jour dans la base de données. |
| 445 | 443 |
correvents = DBSession.query( |
| ... | ... | |
| 455 | 453 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 456 | 454 |
# et un groupe d'hôtes et de services associés à ces items. |
| 457 | 455 |
(hosts, services) = populate_DB() |
| 458 |
|
|
| 456 |
|
|
| 459 | 457 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 460 | 458 |
timestamp = datetime.now() |
| 461 | 459 |
correvent1_id = add_correvent_caused_by(services[0], timestamp) |
| 462 | 460 |
correvent2_id = add_correvent_caused_by(services[1], timestamp) |
| 463 |
|
|
| 464 |
# Date de modification du premier évènement corrélé
|
|
| 461 |
|
|
| 462 |
# Date de modification du premier évènement corrélé |
|
| 465 | 463 |
later_date = datetime.now() |
| 466 | 464 |
# Date du chargement de la page |
| 467 | 465 |
date = mktime(later_date.timetuple()) - 42 |
| 468 |
|
|
| 466 |
|
|
| 469 | 467 |
# On ajoute une entrée dans l'historique de l'évènement brut |
| 470 | 468 |
# causant le premier évènement corrélé, portant pour timestamp |
| 471 | 469 |
# une date postérieure à celle du chargement de la page. |
| ... | ... | |
| 477 | 475 |
idevent = correvent1.idcause, |
| 478 | 476 |
timestamp = later_date)) |
| 479 | 477 |
DBSession.flush() |
| 480 |
|
|
| 478 |
|
|
| 481 | 479 |
transaction.commit() |
| 482 |
|
|
| 480 |
|
|
| 483 | 481 |
# L'utilisateur utilisé pour se connecter à Vigiboard est 'access'. |
| 484 | 482 |
environ = {'REMOTE_USER': 'access'}
|
| 485 |
|
|
| 483 |
|
|
| 486 | 484 |
# On s'attend à ce que le statut de la requête soit 302, et |
| 487 | 485 |
# à ce qu'un message d'erreur avise l'utilisateur que des |
| 488 | 486 |
# changements sont intervenus depuis le chargement de la page. |
| ... | ... | |
| 493 | 491 |
"trouble_ticket" : "", |
| 494 | 492 |
"ack" : u'Acknowledged', |
| 495 | 493 |
}, status = 302, extra_environ = environ) |
| 496 |
|
|
| 494 |
|
|
| 497 | 495 |
response = response.follow(status=200, extra_environ = environ) |
| 498 | 496 |
assert_true(response.lxml.xpath( |
| 499 | 497 |
'//div[@id="flash"]/div[@class="warning"]')) |
| 500 |
|
|
| 498 |
|
|
| 501 | 499 |
# On s'assure que le statut de l'évènement corrélé |
| 502 | 500 |
# n'a pas été modifié dans la base de données. |
| 503 | 501 |
status = DBSession.query( |
| ... | ... | |
| 506 | 504 |
).scalar() |
| 507 | 505 |
assert_equal(status, u'None') |
| 508 | 506 |
|
| 507 |
def test_close_last_page(self): |
|
| 508 |
""" |
|
| 509 |
Suppression de tous les événements de la dernière page. |
|
| 510 |
|
|
| 511 |
Lorsqu'on supprime tous les événements de la page, on doit |
|
| 512 |
implicitement afficher le contenu de la page d'avant. |
|
| 513 |
""" |
|
| 514 |
raise SkipTest("Not ready yet")
|
|
| 515 |
|
|
| 516 |
# On crée autant d'événements qu'on peut en afficher par page + 1, |
|
| 517 |
# afin d'avoir 2 pages dans le bac à événements. |
|
| 518 |
items_per_page = int(config['vigiboard_items_per_page']) |
|
| 519 |
for i in xrange(items_per_page + 1): |
|
| 520 |
host = Host( |
|
| 521 |
name = u'host%d' % i, |
|
| 522 |
checkhostcmd = u'halt', |
|
| 523 |
snmpcommunity = u'public', |
|
| 524 |
hosttpl = u'/dev/null', |
|
| 525 |
address = u'192.168.1.%d' % i, |
|
| 526 |
snmpport = 42, |
|
| 527 |
weight = 42, |
|
| 528 |
) |
|
| 529 |
DBSession.add(host) |
|
| 530 |
DBSession.flush() |
|
| 531 |
add_correvent_caused_by(host, datetime.now()) |
|
| 532 |
# transaction.commit() |
|
| 533 |
|
|
| 534 |
environ = {'REMOTE_USER': 'manager'}
|
|
| 535 |
|
|
| 536 |
# On vérifie qu'on a 2 pages et que sur la 2ème page, |
|
| 537 |
# il n'y a qu'un seul événement. |
|
| 538 |
response = self.app.get('/?page=2', extra_environ=environ)
|
|
| 539 |
|
|
| 540 |
print [(e.idcorrevent, e.idcause) for e in DBSession.query(CorrEvent).all()] |
|
| 541 |
raise ValueError, str(response.body).decode('ascii', 'ignore')
|
|
| 542 |
|
|
| 543 |
current_page = response.lxml.xpath( |
|
| 544 |
'//span[@class="pager_curpage"]/text()') |
|
| 545 |
assert_equal(2, int(current_page[0])) |
|
| 546 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 547 |
assert_equal(len(rows), 1) |
|
| 548 |
|
|
| 549 |
# On force l'état de l'événement sur la 2ème page à 'OK'. |
|
| 550 |
# - Tout d'abord, on récupère l'identifiant de l'événement en question. |
|
| 551 |
idcorrevent = response.lxml.xpath('string(//table[@class="vigitable"]/tbody/tr/td[@class="plugin_details"]/a/@href)')
|
|
| 552 |
idcorrevent = int(idcorrevent.lstrip('#'))
|
|
| 553 |
# - Puis, on met à jour son état (en le forçant à OK). |
|
| 554 |
# On s'attend à ce que le statut de la requête soit 302, |
|
| 555 |
# et à ce qu'un message informe l'utilisateur que les |
|
| 556 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
|
| 557 |
response = self.app.post( |
|
| 558 |
'/update', {
|
|
| 559 |
"id" : str(idcorrevent), |
|
| 560 |
"last_modification": mktime(datetime.now().timetuple()), |
|
| 561 |
"trouble_ticket" : "", |
|
| 562 |
"ack" : u'Forced', |
|
| 563 |
}, status=302, extra_environ=environ) |
|
| 564 |
# - On s'assure que la mise à jour a fonctionné. |
|
| 565 |
response = response.follow(status=200, extra_environ=environ) |
|
| 566 |
assert_false(response.lxml.xpath( |
|
| 567 |
'//div[@id="flash"]/div[@class="error"]')) |
|
| 568 |
assert_true(response.lxml.xpath( |
|
| 569 |
'//div[@id="flash"]/div[@class="ok"]')) |
|
| 570 |
|
|
| 571 |
# Une requête sur la 2ème page doit désormais afficher |
|
| 572 |
# le contenu de la 1ère page, et le nombre d'événements |
|
| 573 |
# doit être le même qu'au départ - 1. |
|
| 574 |
response = self.app.get('/?page=2', extra_environ=environ)
|
|
| 575 |
current_page = response.lxml.xpath( |
|
| 576 |
'//span[@class="pager_curpage"]/text()') |
|
| 577 |
assert_equal(1, int(current_page[0])) |
|
| 578 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 579 |
assert_equal(len(rows), items_per_page) |
|
| vigiboard/tests/functional/test_search_form_host.py | ||
|---|---|---|
| 16 | 16 |
"""Insère les dépendances nécessaires aux tests.""" |
| 17 | 17 |
timestamp = datetime.now() |
| 18 | 18 |
|
| 19 |
hostgroup = SupItemGroup( |
|
| 20 |
name=u'foo', |
|
| 21 |
) |
|
| 19 |
hostgroup = SupItemGroup(name=u'foo', parent=None) |
|
| 22 | 20 |
DBSession.add(hostgroup) |
| 23 | 21 |
DBSession.flush() |
| 24 | 22 |
|
| ... | ... | |
| 72 | 70 |
fullname=u'', |
| 73 | 71 |
email=u'some.random@us.er', |
| 74 | 72 |
) |
| 75 |
usergroup = UserGroup( |
|
| 76 |
group_name=u'users', |
|
| 77 |
) |
|
| 73 |
usergroup = UserGroup(group_name=u'users') |
|
| 78 | 74 |
user.usergroups.append(usergroup) |
| 79 | 75 |
usergroup.permissions.append(perm) |
| 80 | 76 |
DBSession.add(user) |
| ... | ... | |
| 153 | 149 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 154 | 150 |
print "There are %d columns in the result set" % len(cols) |
| 155 | 151 |
assert_equal(len(cols), 1) |
| 156 |
|
|
| vigiboard/tests/functional/test_search_form_misc.py | ||
|---|---|---|
| 31 | 31 |
DBSession.add(host) |
| 32 | 32 |
DBSession.flush() |
| 33 | 33 |
|
| 34 |
hostgroup = SupItemGroup(name=u'foo') |
|
| 34 |
hostgroup = SupItemGroup(name=u'foo', parent=None)
|
|
| 35 | 35 |
hostgroup.supitems.append(host) |
| 36 | 36 |
DBSession.add(hostgroup) |
| 37 | 37 |
DBSession.flush() |
| ... | ... | |
| 79 | 79 |
fullname=u'', |
| 80 | 80 |
email=u'some.random@us.er', |
| 81 | 81 |
) |
| 82 |
usergroup = UserGroup( |
|
| 83 |
group_name=u'users', |
|
| 84 |
) |
|
| 82 |
usergroup = UserGroup(group_name=u'users') |
|
| 85 | 83 |
user.usergroups.append(usergroup) |
| 86 | 84 |
usergroup.permissions.append(perm) |
| 87 | 85 |
DBSession.add(user) |
| ... | ... | |
| 161 | 159 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 162 | 160 |
print "There are %d columns in the result set" % len(cols) |
| 163 | 161 |
assert_true(len(cols) > 1) |
| 164 |
|
|
| vigiboard/tests/functional/test_search_form_service.py | ||
|---|---|---|
| 17 | 17 |
"""Insère les dépendances nécessaires aux tests.""" |
| 18 | 18 |
timestamp = datetime.now() |
| 19 | 19 |
|
| 20 |
hostgroup = SupItemGroup(name=u'foo') |
|
| 20 |
hostgroup = SupItemGroup(name=u'foo', parent=None)
|
|
| 21 | 21 |
DBSession.add(hostgroup) |
| 22 | 22 |
|
| 23 | 23 |
host = Host( |
| ... | ... | |
| 37 | 37 |
hostgroup.supitems.append(host) |
| 38 | 38 |
DBSession.flush() |
| 39 | 39 |
|
| 40 |
servicegroup = SupItemGroup(name=u'bar') |
|
| 40 |
servicegroup = SupItemGroup(name=u'bar', parent=None)
|
|
| 41 | 41 |
DBSession.add(servicegroup) |
| 42 | 42 |
DBSession.flush() |
| 43 | 43 |
|
| ... | ... | |
| 86 | 86 |
fullname=u'', |
| 87 | 87 |
email=u'some.random@us.er', |
| 88 | 88 |
) |
| 89 |
usergroup = UserGroup( |
|
| 90 |
group_name=u'users', |
|
| 91 |
) |
|
| 89 |
usergroup = UserGroup(group_name=u'users') |
|
| 92 | 90 |
user.usergroups.append(usergroup) |
| 93 | 91 |
usergroup.permissions.append(perm) |
| 94 | 92 |
DBSession.add(user) |
| ... | ... | |
| 204 | 202 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 205 | 203 |
print "There are %d columns in the result set" % len(cols) |
| 206 | 204 |
assert_equal(len(cols), 1) |
| 207 |
|
|
| vigiboard/tests/functional/test_search_form_supitemgroup.py | ||
|---|---|---|
| 16 | 16 |
"""Insère les dépendances nécessaires aux tests.""" |
| 17 | 17 |
timestamp = datetime.now() |
| 18 | 18 |
|
| 19 |
supitemgroup = SupItemGroup( |
|
| 20 |
name=u'foo', |
|
| 21 |
) |
|
| 19 |
supitemgroup = SupItemGroup(name=u'foo', parent=None) |
|
| 22 | 20 |
DBSession.add(supitemgroup) |
| 23 | 21 |
DBSession.flush() |
| 24 | 22 |
|
| ... | ... | |
| 72 | 70 |
fullname=u'', |
| 73 | 71 |
email=u'some.random@us.er', |
| 74 | 72 |
) |
| 75 |
usergroup = UserGroup( |
|
| 76 |
group_name=u'users', |
|
| 77 |
) |
|
| 73 |
usergroup = UserGroup(group_name=u'users') |
|
| 78 | 74 |
user.usergroups.append(usergroup) |
| 79 | 75 |
usergroup.permissions.append(perm) |
| 80 | 76 |
DBSession.add(user) |
| ... | ... | |
| 160 | 156 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 161 | 157 |
print "There are %d columns in the result set" % len(cols) |
| 162 | 158 |
assert_equal(len(cols), 1) |
| 163 |
|
|
Also available in: Unified diff