Revision 718be55e
Ajout d'un test de l'affichage de l'historique détaillé d'un évènement corrélé portant sur un hôte (/event/host.idhost).
Ajout d'un test de l'affichage de l'historique détaillé d'un évènement corrélé portant sur un service (/event/service.idservice).
Ajout d'un test de l'affichage de l'historique détaillé des évènements corrélés portant sur un hôte donné (/host_service/host.name/).
Ajout d'un test de l'affichage de l'historique détaillé des évènements corrélés portant sur un service donné (/host_service/service.servicename/).
git-svn-id: https://vigilo-dev.si.c-s.fr/svn@1733 b22e2e97-25c9-44ff-b637-2e5ceca36478
| vigiboard/tests/functional/test_history_tables.py | ||
|---|---|---|
| 67 | 67 |
|
| 68 | 68 |
return (managerhost, managerservice) |
| 69 | 69 |
|
| 70 |
def add_correvent_caused_by(supitem): |
|
| 70 |
def add_correvent_caused_by(supitem, |
|
| 71 |
correvent_status=u"None", event_status=u"WARNING"): |
|
| 71 | 72 |
""" |
| 72 | 73 |
Ajoute dans la base de données un évènement corrélé causé |
| 73 | 74 |
par un incident survenu sur l'item passé en paramètre. |
| ... | ... | |
| 78 | 79 |
event = Event( |
| 79 | 80 |
supitem = supitem, |
| 80 | 81 |
message = u'foo', |
| 81 |
current_state = StateName.statename_to_value(u'WARNING'),
|
|
| 82 |
current_state = StateName.statename_to_value(event_status),
|
|
| 82 | 83 |
) |
| 83 | 84 |
DBSession.add(event) |
| 84 | 85 |
DBSession.flush() |
| ... | ... | |
| 99 | 100 |
idcause = event.idevent, |
| 100 | 101 |
timestamp_active = datetime.now(), |
| 101 | 102 |
priority = 1, |
| 102 |
status = u'None')
|
|
| 103 |
status = correvent_status)
|
|
| 103 | 104 |
aggregate.events.append(event) |
| 104 | 105 |
DBSession.add(aggregate) |
| 105 | 106 |
DBSession.flush() |
| ... | ... | |
| 112 | 113 |
Test des historiques de Vigiboard. |
| 113 | 114 |
""" |
| 114 | 115 |
|
| 115 |
def test_event_caused_by_host_history_table(self):
|
|
| 116 |
def test_host_event_history(self):
|
|
| 116 | 117 |
""" |
| 117 | 118 |
Test de l'affichage du tableau d'historique |
| 118 | 119 |
d'un évènement corrélé causé par un hôte. |
| 119 | 120 |
""" |
| 120 | 121 |
|
| 122 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
|
| 123 |
# et un groupe d'hôtes et de services associés à ces items. |
|
| 121 | 124 |
(managerhost, managerservice) = populate_DB() |
| 125 |
|
|
| 126 |
# On ajoute un évènement corrélé causé par l'hôte |
|
| 122 | 127 |
aggregate_id = add_correvent_caused_by(managerhost) |
| 123 | 128 |
|
| 124 |
#
|
|
| 129 |
transaction.commit()
|
|
| 125 | 130 |
|
| 126 |
aggregates = DBSession.query(CorrEvent).count() |
|
| 127 |
print "Nombre d'evenements correles dans la BDD : ", aggregates |
|
| 131 |
### 1er cas : L'utilisateur utilisé pour |
|
| 132 |
# se connecter à Vigiboard est 'editor'. |
|
| 133 |
environ = {'REMOTE_USER': 'editor'}
|
|
| 128 | 134 |
|
| 129 |
histories = DBSession.query(EventHistory).count() |
|
| 130 |
print "Nombre de lignes d'historique dans la BDD : ", histories |
|
| 135 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
|
| 136 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
|
| 137 |
# n'a pas accès aux informations concernant cet évènement. |
|
| 138 |
response = self.app.get( |
|
| 139 |
'/event?idcorrevent=' + str(aggregate_id), |
|
| 140 |
status = 302, |
|
| 141 |
extra_environ = environ) |
|
| 131 | 142 |
|
| 132 |
aggregate = DBSession.query(CorrEvent |
|
| 133 |
).filter(CorrEvent.idcorrevent == aggregate_id).one() |
|
| 134 |
print "Permissions sur l'evenement correle : ", |
|
| 135 |
for group in aggregate.cause.supitem.groups: |
|
| 136 |
print "\n\tGroupe : ", group.name |
|
| 137 |
for permission in group.permissions: |
|
| 138 |
print "\t\t> ", permission.permission_name |
|
| 139 |
|
|
| 140 |
user = DBSession.query(User).filter(User.user_name == u"manager").one() |
|
| 141 |
print "Permissions de l'utilisateur : ", |
|
| 142 |
for group in user.usergroups: |
|
| 143 |
print "\n\tGroupe : ", group.group_name |
|
| 144 |
for permission in group.permissions: |
|
| 145 |
print "\t\t> ", permission.permission_name |
|
| 146 |
|
|
| 143 |
response = self.app.get( |
|
| 144 |
'/', |
|
| 145 |
status = 200, |
|
| 146 |
extra_environ = environ) |
|
| 147 |
assert_true(response.lxml.xpath( |
|
| 148 |
'//div[@id="flash"]/div[@class="error"]')) |
|
| 149 |
|
|
| 150 |
### 2nd cas : L'utilisateur utilisé pour |
|
| 151 |
# se connecter à Vigiboard est 'manager'. |
|
| 152 |
environ = {'REMOTE_USER': 'manager'}
|
|
| 147 | 153 |
|
| 148 |
# |
|
| 154 |
# On s'attend à ce que le statut de la requête soit 200. |
|
| 155 |
response = self.app.get( |
|
| 156 |
'/event?idcorrevent=' + str(aggregate_id), |
|
| 157 |
status = 200, |
|
| 158 |
extra_environ = environ) |
|
| 159 |
|
|
| 160 |
# Il doit y avoir 2 lignes de résultats. |
|
| 161 |
rows = response.lxml.xpath('//table[@class="history_table"]/tbody/tr')
|
|
| 162 |
assert_equal(len(rows), 2) |
|
| 163 |
|
|
| 164 |
def test_service_event_history(self): |
|
| 165 |
""" |
|
| 166 |
Test de l'affichage du tableau d'historique d'un |
|
| 167 |
évènement corrélé causé par un service de bas niveau. |
|
| 168 |
""" |
|
| 169 |
|
|
| 170 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
|
| 171 |
# et un groupe d'hôtes et de services associés à ces items. |
|
| 172 |
(managerhost, managerservice) = populate_DB() |
|
| 173 |
|
|
| 174 |
# On ajoute un évènement corrélé causé par le service |
|
| 175 |
aggregate_id = add_correvent_caused_by(managerservice) |
|
| 176 |
|
|
| 177 |
transaction.commit() |
|
| 178 |
|
|
| 179 |
### 1er cas : L'utilisateur utilisé pour |
|
| 180 |
# se connecter à Vigiboard est 'editor'. |
|
| 181 |
environ = {'REMOTE_USER': 'editor'}
|
|
| 182 |
|
|
| 183 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
|
| 184 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
|
| 185 |
# n'a pas accès aux informations concernant cet évènement. |
|
| 186 |
response = self.app.get( |
|
| 187 |
'/event?idcorrevent=' + str(aggregate_id), |
|
| 188 |
status = 302, |
|
| 189 |
extra_environ = environ) |
|
| 190 |
|
|
| 191 |
response = self.app.get( |
|
| 192 |
'/', |
|
| 193 |
status = 200, |
|
| 194 |
extra_environ = environ) |
|
| 195 |
assert_true(response.lxml.xpath( |
|
| 196 |
'//div[@id="flash"]/div[@class="error"]')) |
|
| 197 |
|
|
| 198 |
### 2nd cas : L'utilisateur utilisé pour |
|
| 199 |
# se connecter à Vigiboard est 'manager'. |
|
| 200 |
environ = {'REMOTE_USER': 'manager'}
|
|
| 201 |
|
|
| 202 |
# On s'attend à ce que le statut de la requête soit 200. |
|
| 203 |
response = self.app.get( |
|
| 204 |
'/event?idcorrevent=' + str(aggregate_id), |
|
| 205 |
status = 200, |
|
| 206 |
extra_environ = environ) |
|
| 207 |
|
|
| 208 |
# Il doit y avoir 2 lignes de résultats. |
|
| 209 |
rows = response.lxml.xpath('//table[@class="history_table"]/tbody/tr')
|
|
| 210 |
assert_equal(len(rows), 2) |
|
| 211 |
|
|
| 212 |
def test_host_history(self): |
|
| 213 |
""" |
|
| 214 |
Test de l'affichage du tableau d'historique |
|
| 215 |
des évènements corrélé d'un hôte donné. |
|
| 216 |
""" |
|
| 149 | 217 |
|
| 218 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
|
| 219 |
# et un groupe d'hôtes et de services associés à ces items. |
|
| 220 |
(managerhost, managerservice) = populate_DB() |
|
| 221 |
|
|
| 222 |
# On ajoute deux évènements corrélés causés par l'hôte : |
|
| 223 |
# le premier encore ouvert, le second clos par un utilisateur. |
|
| 224 |
aggregate_id1 = add_correvent_caused_by(managerhost) |
|
| 225 |
aggregate_id2 = add_correvent_caused_by(managerhost, u"AAClosed", |
|
| 226 |
u"OK") |
|
| 227 |
|
|
| 228 |
transaction.commit() |
|
| 229 |
DBSession.add(managerhost) |
|
| 230 |
|
|
| 150 | 231 |
### 1er cas : L'utilisateur utilisé pour |
| 151 | 232 |
# se connecter à Vigiboard est 'editor'. |
| 152 | 233 |
environ = {'REMOTE_USER': 'editor'}
|
| 153 | 234 |
|
| 154 |
# On s'attend à ce qu'une erreur 302 soit renvoyée. |
|
| 235 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
|
| 236 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
|
| 237 |
# n'a pas accès aux informations concernant cet évènement. |
|
| 155 | 238 |
response = self.app.get( |
| 156 |
'/event/' + str(aggregate_id),
|
|
| 239 |
'/host_service/' + managerhost.name,
|
|
| 157 | 240 |
status = 302, |
| 158 | 241 |
extra_environ = environ) |
| 242 |
|
|
| 243 |
response = self.app.get( |
|
| 244 |
'/', |
|
| 245 |
status = 200, |
|
| 246 |
extra_environ = environ) |
|
| 247 |
assert_true(response.lxml.xpath( |
|
| 248 |
'//div[@id="flash"]/div[@class="error"]')) |
|
| 159 | 249 |
|
| 160 | 250 |
### 2nd cas : L'utilisateur utilisé pour |
| 161 | 251 |
# se connecter à Vigiboard est 'manager'. |
| ... | ... | |
| 163 | 253 |
|
| 164 | 254 |
# On s'attend à ce que le statut de la requête soit 200. |
| 165 | 255 |
response = self.app.get( |
| 166 |
'/event/' + str(aggregate_id),
|
|
| 256 |
'/host_service/' + managerhost.name,
|
|
| 167 | 257 |
status = 200, |
| 168 | 258 |
extra_environ = environ) |
| 259 |
|
|
| 260 |
# Il doit y avoir 2 lignes d'évènements |
|
| 261 |
# + 2 lignes contenant les tableaux d'historiques. |
|
| 262 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 263 |
assert_equal(len(rows), 2 + 2) |
|
| 264 |
# Et 4 lignes d'historiques dans les tableaux d'historiques. |
|
| 265 |
rows = response.lxml.xpath('//table[@class="history_table"]/tbody/tr')
|
|
| 266 |
assert_equal(len(rows), 4) |
|
| 267 |
|
|
| 268 |
def test_service_history(self): |
|
| 269 |
""" |
|
| 270 |
Test de l'affichage du tableau d'historique |
|
| 271 |
des évènements corrélé d'un service donné. |
|
| 272 |
""" |
|
| 273 |
|
|
| 274 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
|
| 275 |
# et un groupe d'hôtes et de services associés à ces items. |
|
| 276 |
(managerhost, managerservice) = populate_DB() |
|
| 277 |
|
|
| 278 |
# On ajoute deux évènements corrélés causés par le service : |
|
| 279 |
# le premier encore ouvert, le second clos par un utilisateur. |
|
| 280 |
aggregate_id1 = add_correvent_caused_by(managerservice) |
|
| 281 |
aggregate_id2 = add_correvent_caused_by(managerservice, u"AAClosed", |
|
| 282 |
u"OK") |
|
| 169 | 283 |
|
| 170 |
# response = self.app.get( |
|
| 171 |
# '/event/' + str(aggregate_id), extra_environ = environ) |
|
| 172 |
# |
|
| 173 |
# # Il doit y avoir 2 lignes de résultats. |
|
| 174 |
# rows = response.lxml.xpath('//table[@class="history_table"]/tbody/tr')
|
|
| 175 |
# print "There are %d rows in the result set" % len(rows) |
|
| 176 |
# assert_equal(len(rows), 2) |
|
| 284 |
transaction.commit() |
|
| 285 |
DBSession.add(managerhost) |
|
| 286 |
DBSession.add(managerservice) |
|
| 287 |
|
|
| 288 |
### 1er cas : L'utilisateur utilisé pour |
|
| 289 |
# se connecter à Vigiboard est 'editor'. |
|
| 290 |
environ = {'REMOTE_USER': 'editor'}
|
|
| 291 |
|
|
| 292 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
|
| 293 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
|
| 294 |
# n'a pas accès aux informations concernant cet évènement. |
|
| 295 |
response = self.app.get( |
|
| 296 |
'/host_service/' + managerhost.name |
|
| 297 |
+ '/' + managerservice.servicename, |
|
| 298 |
status = 302, |
|
| 299 |
extra_environ = environ) |
|
| 300 |
|
|
| 301 |
response = self.app.get( |
|
| 302 |
'/', |
|
| 303 |
status = 200, |
|
| 304 |
extra_environ = environ) |
|
| 305 |
assert_true(response.lxml.xpath( |
|
| 306 |
'//div[@id="flash"]/div[@class="error"]')) |
|
| 307 |
|
|
| 308 |
### 2nd cas : L'utilisateur utilisé pour |
|
| 309 |
# se connecter à Vigiboard est 'manager'. |
|
| 310 |
environ = {'REMOTE_USER': 'manager'}
|
|
| 311 |
|
|
| 312 |
# On s'attend à ce que le statut de la requête soit 200. |
|
| 313 |
response = self.app.get( |
|
| 314 |
'/host_service/' + managerhost.name |
|
| 315 |
+ '/' + managerservice.servicename, |
|
| 316 |
status = 200, |
|
| 317 |
extra_environ = environ) |
|
| 318 |
|
|
| 319 |
# Il doit y avoir 2 lignes d'évènements |
|
| 320 |
# + 2 lignes contenant les tableaux d'historiques. |
|
| 321 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
|
| 322 |
assert_equal(len(rows), 2 + 2) |
|
| 323 |
# Et 4 lignes d'historiques dans les tableaux d'historiques. |
|
| 324 |
rows = response.lxml.xpath('//table[@class="history_table"]/tbody/tr')
|
|
| 325 |
assert_equal(len(rows), 4) |
|
| 177 | 326 |
|
| 178 | 327 |
|
| 179 | 328 |
|
Also available in: Unified diff