Revision 9a05a743
Nettoyage des tests unitaires.
Utilisation des fonctions outils définies vigilo.models.demo.functions
lorsque c'est possible, afin de réduire la taille des tests et de
privilégier la réutilisation du code existant.
Ce changement précède un autre gros changement dans le modèle (pour le
ticket #918) et vise à diminuer la quantité de changements (pour
faciliter la relecture).
Change-Id: I84f1fb3b4b2306f2ef3a4b0070c4fe5330fa4906
Reviewed-on: https://vigilo-dev.si.c-s.fr/review/482
Tested-by: Build system <qa@vigilo-dev.si.c-s.fr>
Reviewed-by: Aurelien BOMPARD <aurelien.bompard@c-s.fr>
| vigiboard/tests/functional/plugins/test_details_plugin.py | ||
|---|---|---|
| 12 | 12 |
|
| 13 | 13 |
from vigiboard.tests import TestController |
| 14 | 14 |
from vigilo.models.session import DBSession |
| 15 |
from vigilo.models.demo import functions |
|
| 15 | 16 |
from vigilo.models.tables import SupItemGroup, User, UserGroup, \ |
| 16 | 17 |
Permission, DataPermission, StateName, \ |
| 17 | 18 |
LowLevelService, Event, CorrEvent, Host |
| ... | ... | |
| 30 | 31 |
""" |
| 31 | 32 |
timestamp = datetime.now() |
| 32 | 33 |
|
| 33 |
hostgroup = SupItemGroup(name=u'foo', parent=None) |
|
| 34 |
DBSession.add(hostgroup) |
|
| 35 |
|
|
| 36 |
host = Host( |
|
| 37 |
name=u'bar', |
|
| 38 |
description=u'', |
|
| 39 |
hosttpl=u'', |
|
| 40 |
address=u'127.0.0.1', |
|
| 41 |
snmpport=42, |
|
| 42 |
snmpcommunity=u'public', |
|
| 43 |
snmpversion=u'3', |
|
| 44 |
weight=42, |
|
| 45 |
) |
|
| 46 |
DBSession.add(host) |
|
| 47 |
DBSession.flush() |
|
| 48 |
|
|
| 34 |
hostgroup = functions.add_supitemgroup(u'foo') |
|
| 35 |
host = functions.add_host(u'bar') |
|
| 49 | 36 |
hostgroup.supitems.append(host) |
| 50 | 37 |
DBSession.flush() |
| 51 | 38 |
|
| 52 |
servicegroup = SupItemGroup(name=u'bar', parent=None) |
|
| 53 |
DBSession.add(servicegroup) |
|
| 54 |
|
|
| 55 |
service = LowLevelService( |
|
| 56 |
host=host, |
|
| 57 |
command=u'', |
|
| 58 |
weight=42, |
|
| 59 |
servicename=u'baz', |
|
| 60 |
) |
|
| 61 |
DBSession.add(service) |
|
| 62 |
DBSession.flush() |
|
| 63 |
|
|
| 39 |
servicegroup = functions.add_supitemgroup(u'bar') |
|
| 40 |
service = functions.add_lowlevelservice(host, u'baz') |
|
| 64 | 41 |
servicegroup.supitems.append(service) |
| 65 | 42 |
DBSession.flush() |
| 66 | 43 |
|
| 67 |
event = Event( |
|
| 68 |
timestamp=timestamp, |
|
| 69 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 70 |
message=u'Hello world', |
|
| 71 |
) |
|
| 72 | 44 |
if return_service: |
| 73 |
event.supitem = service
|
|
| 45 |
event = functions.add_event(service, u'WARNING', u'', timestamp)
|
|
| 74 | 46 |
else: |
| 75 |
event.supitem = host |
|
| 76 |
DBSession.add(event) |
|
| 77 |
DBSession.flush() |
|
| 47 |
event = functions.add_event(host, u'WARNING', u'', timestamp) |
|
| 78 | 48 |
|
| 79 |
correvent = CorrEvent( |
|
| 80 |
priority=42, |
|
| 81 |
trouble_ticket=None, |
|
| 82 |
ack=CorrEvent.ACK_NONE, |
|
| 83 |
occurrence=42, |
|
| 84 |
timestamp_active=timestamp, |
|
| 85 |
cause=event, |
|
| 86 |
) |
|
| 87 |
correvent.events.append(event) |
|
| 88 |
DBSession.add(correvent) |
|
| 89 |
DBSession.flush() |
|
| 49 |
correvent = functions.add_correvent([event], timestamp=timestamp) |
|
| 90 | 50 |
|
| 91 | 51 |
usergroup = UserGroup.by_group_name(u'users_with_access') |
| 92 | 52 |
DBSession.add(DataPermission( |
| ... | ... | |
| 95 | 55 |
access=u'r', |
| 96 | 56 |
)) |
| 97 | 57 |
DBSession.flush() |
| 98 |
|
|
| 99 | 58 |
transaction.commit() |
| 59 |
|
|
| 100 | 60 |
correvent = DBSession.query(CorrEvent).first() |
| 101 | 61 |
event = DBSession.query(Event).first() |
| 102 |
|
|
| 103 | 62 |
return (hostgroup, correvent.idcorrevent, event.idevent) |
| 104 | 63 |
|
| 105 | 64 |
class TestDetailsPlugin(TestController): |
| vigiboard/tests/functional/plugins/test_plugin_hls.py | ||
|---|---|---|
| 9 | 9 |
from nose.tools import assert_equal |
| 10 | 10 |
|
| 11 | 11 |
from vigilo.models.session import DBSession |
| 12 |
from vigilo.models.demo import functions |
|
| 12 | 13 |
from vigilo.models.tables import Permission, DataPermission, StateName, \ |
| 13 | 14 |
SupItemGroup, Host, HighLevelService, \ |
| 14 | 15 |
Event, CorrEvent, ImpactedPath, ImpactedHLS, \ |
| ... | ... | |
| 33 | 34 |
DBSession.flush() |
| 34 | 35 |
|
| 35 | 36 |
# On crée un hôte de test. |
| 36 |
host = Host( |
|
| 37 |
name = u'host', |
|
| 38 |
snmpcommunity = u'public', |
|
| 39 |
hosttpl = u'/dev/null', |
|
| 40 |
address = u'192.168.1.1', |
|
| 41 |
snmpport = 42, |
|
| 42 |
weight = 42, |
|
| 43 |
) |
|
| 44 |
DBSession.add(host) |
|
| 37 |
host = functions.add_host(u'host') |
|
| 45 | 38 |
|
| 46 | 39 |
# On affecte cet hôte au groupe précédemment créé. |
| 47 | 40 |
hostmanagers.supitems.append(host) |
| 48 | 41 |
DBSession.flush() |
| 49 | 42 |
|
| 50 |
# On ajoute un évènement causé par cet hôte. |
|
| 51 |
event1 = Event( |
|
| 52 |
supitem = host, |
|
| 53 |
message = u'foo', |
|
| 54 |
current_state = StateName.statename_to_value(u'WARNING'), |
|
| 55 |
timestamp = datetime.now(), |
|
| 56 |
) |
|
| 57 |
DBSession.add(event1) |
|
| 58 |
DBSession.flush() |
|
| 59 |
|
|
| 60 |
# On ajoute un évènement corrélé causé par cet évènement 'brut'. |
|
| 61 |
aggregate = CorrEvent( |
|
| 62 |
idcause = event1.idevent, |
|
| 63 |
timestamp_active = datetime.now(), |
|
| 64 |
priority = 1, |
|
| 65 |
ack = CorrEvent.ACK_NONE) |
|
| 66 |
aggregate.events.append(event1) |
|
| 67 |
DBSession.add(aggregate) |
|
| 68 |
DBSession.flush() |
|
| 43 |
# On ajoute un évènement brut et un événement corrélé causé par cet hôte. |
|
| 44 |
event1 = functions.add_event(host, u'WARNING', u'foo') |
|
| 45 |
aggregate = functions.add_correvent([event1]) |
|
| 69 | 46 |
|
| 70 | 47 |
transaction.commit() |
| 71 | 48 |
return aggregate |
| ... | ... | |
| 80 | 57 |
haut niveau sont créés dans l'opération. |
| 81 | 58 |
""" |
| 82 | 59 |
|
| 83 |
# Création de services de haut niveau dans la BDD. |
|
| 84 |
hls_template = {
|
|
| 85 |
'message': u'Bar', |
|
| 86 |
'warning_threshold': 60, |
|
| 87 |
'critical_threshold': 80, |
|
| 88 |
'weight': None, |
|
| 89 |
} |
|
| 90 |
|
|
| 91 | 60 |
# Création des chemins de services de haut niveau impactés. |
| 92 | 61 |
for j in range(path_number): |
| 93 | 62 |
|
| ... | ... | |
| 98 | 67 |
|
| 99 | 68 |
# Pour chaque étage du chemin, |
| 100 | 69 |
for i in range(path_length): |
| 101 |
# on ajoute un service de haut niveau dans la BDD, |
|
| 102 |
hls = HighLevelService( |
|
| 103 |
servicename = u'HLS' + str(j + 1) + str(i + 1), |
|
| 104 |
**hls_template) |
|
| 105 |
DBSession.add(hls) |
|
| 106 |
# et on ajoute un étage au chemin contenant ce service. |
|
| 70 |
# on ajoute un service de haut niveau dans la BDD... |
|
| 71 |
hls = functions.add_highlevelservice( |
|
| 72 |
u'HLS' + str(j + 1) + str(i + 1), None) |
|
| 73 |
|
|
| 74 |
# ...et on ajoute un étage au chemin contenant ce service. |
|
| 107 | 75 |
DBSession.add( |
| 108 | 76 |
ImpactedHLS( |
| 109 | 77 |
path = path, |
| 110 | 78 |
hls = hls, |
| 111 | 79 |
distance = i + 1, |
| 112 |
))
|
|
| 80 |
)) |
|
| 113 | 81 |
|
| 114 | 82 |
DBSession.flush() |
| 115 | 83 |
transaction.commit() |
| ... | ... | |
| 212 | 180 |
|
| 213 | 181 |
# On peuple la base de données avant le test. |
| 214 | 182 |
DBSession.add(self.aggregate) |
| 215 |
hls = HighLevelService( |
|
| 216 |
servicename = u'HLS', |
|
| 217 |
message = u'Bar', |
|
| 218 |
warning_threshold = 60, |
|
| 219 |
critical_threshold = 80, |
|
| 220 |
weight = None, |
|
| 221 |
) |
|
| 222 |
DBSession.add(hls) |
|
| 223 |
DBSession.flush() |
|
| 183 |
hls = functions.add_highlevelservice(u'HLS', None, u'Bar') |
|
| 224 | 184 |
path1 = ImpactedPath(idsupitem = self.aggregate.events[0].idsupitem) |
| 225 | 185 |
DBSession.add(path1) |
| 226 | 186 |
path2 = ImpactedPath(idsupitem = self.aggregate.events[0].idsupitem) |
| vigiboard/tests/functional/test_history_table.py | ||
|---|---|---|
| 13 | 13 |
import transaction |
| 14 | 14 |
|
| 15 | 15 |
from vigilo.models.session import DBSession |
| 16 |
from vigilo.models.demo import functions |
|
| 16 | 17 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, \ |
| 17 | 18 |
Permission, StateName, Host, \ |
| 18 | 19 |
SupItemGroup, LowLevelService, \ |
| ... | ... | |
| 36 | 37 |
DBSession.flush() |
| 37 | 38 |
|
| 38 | 39 |
# On crée un hôte de test, et on l'ajoute au groupe d'hôtes. |
| 39 |
managerhost = Host( |
|
| 40 |
name = u'managerhost', |
|
| 41 |
snmpcommunity = u'public', |
|
| 42 |
hosttpl = u'/dev/null', |
|
| 43 |
address = u'192.168.1.1', |
|
| 44 |
snmpport = 42, |
|
| 45 |
weight = 42, |
|
| 46 |
) |
|
| 47 |
DBSession.add(managerhost) |
|
| 40 |
managerhost = functions.add_host(u'managerhost') |
|
| 48 | 41 |
supitemmanagers.supitems.append(managerhost) |
| 49 | 42 |
DBSession.flush() |
| 50 | 43 |
|
| 51 | 44 |
# On crée un services de bas niveau, et on l'ajoute au groupe de services. |
| 52 |
managerservice = LowLevelService( |
|
| 53 |
host = managerhost, |
|
| 54 |
servicename = u'managerservice', |
|
| 55 |
command = u'halt', |
|
| 56 |
weight = 42, |
|
| 57 |
) |
|
| 58 |
DBSession.add(managerservice) |
|
| 45 |
managerservice = functions.add_lowlevelservice( |
|
| 46 |
managerhost, u'managerservice') |
|
| 59 | 47 |
supitemmanagers.supitems.append(managerservice) |
| 60 | 48 |
DBSession.flush() |
| 61 | 49 |
|
| ... | ... | |
| 68 | 56 |
Génère un historique pour les tests. |
| 69 | 57 |
""" |
| 70 | 58 |
|
| 71 |
# Ajout d'un événement |
|
| 72 |
event = Event( |
|
| 73 |
supitem = supitem, |
|
| 74 |
message = u'foo', |
|
| 75 |
current_state = StateName.statename_to_value(u"WARNING"), |
|
| 76 |
timestamp = datetime.now(), |
|
| 77 |
) |
|
| 78 |
DBSession.add(event) |
|
| 79 |
DBSession.flush() |
|
| 80 |
|
|
| 81 |
# Ajout des historiques |
|
| 59 |
# Ajout d'un événement et de ses entrées dans l'historique. |
|
| 60 |
event = functions.add_event(supitem, u'WARNING', u'foo') |
|
| 82 | 61 |
DBSession.add(EventHistory( |
| 83 | 62 |
type_action=u'Nagios update state', |
| 84 | 63 |
idevent=event.idevent, |
| ... | ... | |
| 89 | 68 |
timestamp=datetime.now())) |
| 90 | 69 |
DBSession.flush() |
| 91 | 70 |
|
| 92 |
# Ajout d'un événement corrélé |
|
| 93 |
aggregate = CorrEvent( |
|
| 94 |
idcause = event.idevent, |
|
| 95 |
timestamp_active = datetime.now(), |
|
| 96 |
priority = 1, |
|
| 97 |
ack = CorrEvent.ACK_NONE) |
|
| 98 |
aggregate.events.append(event) |
|
| 99 |
DBSession.add(aggregate) |
|
| 100 |
DBSession.flush() |
|
| 101 |
|
|
| 71 |
aggregate = functions.add_correvent([event]) |
|
| 102 | 72 |
return event.idevent |
| 103 | 73 |
|
| 104 | 74 |
|
| vigiboard/tests/functional/test_raw_events_table.py | ||
|---|---|---|
| 12 | 12 |
import transaction |
| 13 | 13 |
|
| 14 | 14 |
from vigilo.models.session import DBSession |
| 15 |
from vigilo.models.demo import functions |
|
| 15 | 16 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, User, \ |
| 16 | 17 |
Permission, StateName, Host, UserGroup, \ |
| 17 | 18 |
LowLevelService, SupItemGroup, DataPermission |
| ... | ... | |
| 60 | 61 |
)) |
| 61 | 62 |
DBSession.flush() |
| 62 | 63 |
|
| 63 |
# On crée un hôte de test, et on l'ajoute au groupe d'hôtes. |
|
| 64 |
managerhost = Host( |
|
| 65 |
name = u'managerhost', |
|
| 66 |
snmpcommunity = u'public', |
|
| 67 |
hosttpl = u'/dev/null', |
|
| 68 |
address = u'192.168.1.1', |
|
| 69 |
snmpport = 42, |
|
| 70 |
weight = 42, |
|
| 71 |
) |
|
| 72 |
DBSession.add(managerhost) |
|
| 64 |
# On crée un hôte de test et on l'ajoute au groupe d'hôtes. |
|
| 65 |
managerhost = functions.add_host(u'managerhost') |
|
| 73 | 66 |
supitemmanagers.supitems.append(managerhost) |
| 74 | 67 |
DBSession.flush() |
| 75 | 68 |
|
| 76 |
# On crée un services de bas niveau, et on l'ajoute au groupe de services. |
|
| 77 |
managerservice = LowLevelService( |
|
| 78 |
host = managerhost, |
|
| 79 |
servicename = u'managerservice', |
|
| 80 |
command = u'halt', |
|
| 81 |
weight = 42, |
|
| 82 |
) |
|
| 83 |
DBSession.add(managerservice) |
|
| 69 |
# On crée un services de bas niveau et on l'ajoute au groupe de services. |
|
| 70 |
managerservice = functions.add_lowlevelservice( |
|
| 71 |
managerhost, u'managerservice') |
|
| 84 | 72 |
supitemmanagers.supitems.append(managerservice) |
| 85 | 73 |
DBSession.flush() |
| 86 | 74 |
|
| 87 | 75 |
if caused_by_service: |
| 88 |
supitem = managerservice
|
|
| 76 |
event = functions.add_event(managerservice, u'WARNING', u'foo')
|
|
| 89 | 77 |
else: |
| 90 |
supitem = managerhost |
|
| 91 |
|
|
| 92 |
# Ajout d'un événement |
|
| 93 |
event = Event( |
|
| 94 |
supitem = supitem, |
|
| 95 |
message = u'foo', |
|
| 96 |
current_state = StateName.statename_to_value(u"WARNING"), |
|
| 97 |
timestamp = datetime.now(), |
|
| 98 |
) |
|
| 99 |
DBSession.add(event) |
|
| 100 |
DBSession.flush() |
|
| 78 |
event = functions.add_event(managerhost, u'WARNING', u'foo') |
|
| 101 | 79 |
|
| 102 | 80 |
# Ajout des historiques |
| 103 | 81 |
DBSession.add(EventHistory( |
| ... | ... | |
| 111 | 89 |
DBSession.flush() |
| 112 | 90 |
|
| 113 | 91 |
# Ajout d'un événement corrélé |
| 114 |
aggregate = CorrEvent( |
|
| 115 |
idcause = event.idevent, |
|
| 116 |
timestamp_active = datetime.now(), |
|
| 117 |
priority = 1, |
|
| 118 |
ack = CorrEvent.ACK_NONE) |
|
| 119 |
aggregate.events.append(event) |
|
| 120 |
DBSession.add(aggregate) |
|
| 121 |
DBSession.flush() |
|
| 92 |
aggregate = functions.add_correvent([event]) |
|
| 122 | 93 |
return aggregate.idcorrevent |
| 123 | 94 |
|
| 124 | 95 |
def add_masked_event(idcorrevent): |
| ... | ... | |
| 127 | 98 |
hostmanagers = SupItemGroup.by_group_name(u'managersgroup') |
| 128 | 99 |
nb_hosts = DBSession.query(Host).count() |
| 129 | 100 |
|
| 130 |
masked_host = Host( |
|
| 131 |
name = u'masked host #%d' % nb_hosts, |
|
| 132 |
snmpcommunity = u'public', |
|
| 133 |
hosttpl = u'/dev/null', |
|
| 134 |
address = u'192.168.1.%d' % nb_hosts, |
|
| 135 |
snmpport = 42, |
|
| 136 |
weight = 42, |
|
| 137 |
) |
|
| 138 |
DBSession.add(masked_host) |
|
| 101 |
masked_host = functions.add_host(u'masked host #%d' % nb_hosts) |
|
| 139 | 102 |
hostmanagers.supitems.append(masked_host) |
| 140 | 103 |
DBSession.flush() |
| 141 | 104 |
|
| 142 |
event = Event( |
|
| 143 |
supitem = masked_host, |
|
| 144 |
message = u'masked event #%d' % nb_hosts, |
|
| 145 |
current_state = StateName.statename_to_value(u"CRITICAL"), |
|
| 146 |
timestamp = datetime.now(), |
|
| 147 |
) |
|
| 148 |
DBSession.add(event) |
|
| 149 |
DBSession.flush() |
|
| 105 |
event = functions.add_event(masked_host, u'CRITICAL', |
|
| 106 |
u'masked event #%d' % nb_hosts) |
|
| 150 | 107 |
|
| 151 | 108 |
aggregate = DBSession.query(CorrEvent).filter( |
| 152 | 109 |
CorrEvent.idcorrevent == idcorrevent).one() |
| vigiboard/tests/functional/test_root.py | ||
|---|---|---|
| 20 | 20 |
import transaction |
| 21 | 21 |
|
| 22 | 22 |
from vigilo.models.session import DBSession |
| 23 |
from vigilo.models.demo import functions |
|
| 23 | 24 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, User, \ |
| 24 | 25 |
Permission, StateName, Host, UserGroup, \ |
| 25 | 26 |
SupItemGroup, LowLevelService, DataPermission |
| ... | ... | |
| 29 | 30 |
def populate_DB(): |
| 30 | 31 |
""" Peuple la base de données. """ |
| 31 | 32 |
# On ajoute un groupe d'hôtes et un groupe de services. |
| 32 |
supitemmanagers = SupItemGroup(name = u'managersgroup', parent=None) |
|
| 33 |
DBSession.add(supitemmanagers) |
|
| 34 |
DBSession.flush() |
|
| 33 |
supitemmanagers = functions.add_supitemgroup(u'managersgroup') |
|
| 35 | 34 |
|
| 36 | 35 |
usergroup = UserGroup.by_group_name(u'users_with_access') |
| 37 | 36 |
DBSession.add(DataPermission( |
| ... | ... | |
| 42 | 41 |
DBSession.flush() |
| 43 | 42 |
|
| 44 | 43 |
# On crée un 2 hôtes, et on les ajoute au groupe d'hôtes. |
| 45 |
host1 = Host( |
|
| 46 |
name = u'host1', |
|
| 47 |
snmpcommunity = u'public', |
|
| 48 |
hosttpl = u'/dev/null', |
|
| 49 |
address = u'192.168.1.1', |
|
| 50 |
snmpport = 42, |
|
| 51 |
weight = 42, |
|
| 52 |
) |
|
| 53 |
DBSession.add(host1) |
|
| 44 |
host1 = functions.add_host(u'host1') |
|
| 45 |
host2 = functions.add_host(u'host2') |
|
| 54 | 46 |
supitemmanagers.supitems.append(host1) |
| 55 |
host2 = Host( |
|
| 56 |
name = u'host2', |
|
| 57 |
snmpcommunity = u'public', |
|
| 58 |
hosttpl = u'/dev/null', |
|
| 59 |
address = u'192.168.1.1', |
|
| 60 |
snmpport = 42, |
|
| 61 |
weight = 42, |
|
| 62 |
) |
|
| 63 |
DBSession.add(host2) |
|
| 64 | 47 |
supitemmanagers.supitems.append(host2) |
| 65 | 48 |
DBSession.flush() |
| 66 | 49 |
|
| 67 | 50 |
# On crée 2 services de bas niveau, et on les ajoute au groupe de services. |
| 68 |
service1 = LowLevelService( |
|
| 69 |
host = host1, |
|
| 70 |
servicename = u'service1', |
|
| 71 |
command = u'halt', |
|
| 72 |
weight = 42, |
|
| 73 |
) |
|
| 74 |
DBSession.add(service1) |
|
| 51 |
service1 = functions.add_lowlevelservice(host1, u'service1') |
|
| 52 |
service2 = functions.add_lowlevelservice(host2, u'service2') |
|
| 75 | 53 |
supitemmanagers.supitems.append(service1) |
| 76 |
service2 = LowLevelService( |
|
| 77 |
host = host2, |
|
| 78 |
servicename = u'service2', |
|
| 79 |
command = u'halt', |
|
| 80 |
weight = 42, |
|
| 81 |
) |
|
| 82 |
DBSession.add(service2) |
|
| 83 | 54 |
supitemmanagers.supitems.append(service2) |
| 84 | 55 |
DBSession.flush() |
| 85 | 56 |
|
| ... | ... | |
| 93 | 64 |
Génère un historique pour les tests. |
| 94 | 65 |
""" |
| 95 | 66 |
|
| 96 |
# Ajout d'un événement |
|
| 97 |
event = Event( |
|
| 98 |
supitem = supitem, |
|
| 99 |
message = u'foo', |
|
| 100 |
current_state = StateName.statename_to_value(event_status), |
|
| 101 |
timestamp = datetime.now(), |
|
| 102 |
) |
|
| 103 |
DBSession.add(event) |
|
| 104 |
DBSession.flush() |
|
| 105 |
|
|
| 106 |
# Ajout d'un événement corrélé |
|
| 107 |
aggregate = CorrEvent( |
|
| 108 |
idcause = event.idevent, |
|
| 109 |
timestamp_active = timestamp, |
|
| 110 |
priority = 1, |
|
| 111 |
ack = correvent_status) |
|
| 112 |
aggregate.events.append(event) |
|
| 113 |
DBSession.add(aggregate) |
|
| 114 |
DBSession.flush() |
|
| 115 |
|
|
| 67 |
# Ajout d'un événement brut et d'un événement corrélé. |
|
| 68 |
event = functions.add_event(supitem, event_status, u'foo') |
|
| 69 |
aggregate = functions.add_correvent([event], status=correvent_status) |
|
| 116 | 70 |
return aggregate.idcorrevent |
| 117 | 71 |
|
| 118 | 72 |
|
| vigiboard/tests/functional/test_search_form_service.py | ||
|---|---|---|
| 11 | 11 |
|
| 12 | 12 |
from vigiboard.tests import TestController |
| 13 | 13 |
from vigilo.models.session import DBSession |
| 14 |
from vigilo.models.demo import functions |
|
| 14 | 15 |
from vigilo.models.tables import SupItemGroup, Host, Permission, \ |
| 15 | 16 |
StateName, LowLevelService, \ |
| 16 | 17 |
Event, CorrEvent, User, UserGroup, \ |
| ... | ... | |
| 20 | 21 |
"""Insère les dépendances nécessaires aux tests.""" |
| 21 | 22 |
timestamp = datetime.now() |
| 22 | 23 |
|
| 23 |
hostgroup = SupItemGroup(name=u'foo', parent=None) |
|
| 24 |
DBSession.add(hostgroup) |
|
| 25 |
|
|
| 26 |
host = Host( |
|
| 27 |
name=u'bar', |
|
| 28 |
description=u'', |
|
| 29 |
hosttpl=u'', |
|
| 30 |
address=u'127.0.0.1', |
|
| 31 |
snmpport=42, |
|
| 32 |
snmpcommunity=u'public', |
|
| 33 |
snmpversion=u'3', |
|
| 34 |
weight=42, |
|
| 35 |
) |
|
| 36 |
DBSession.add(host) |
|
| 37 |
DBSession.flush() |
|
| 38 |
|
|
| 24 |
hostgroup = functions.add_supitemgroup(u'foo') |
|
| 25 |
host = functions.add_host(u'bar') |
|
| 39 | 26 |
hostgroup.supitems.append(host) |
| 40 | 27 |
DBSession.flush() |
| 41 | 28 |
|
| 42 |
servicegroup = SupItemGroup(name=u'bar', parent=None) |
|
| 43 |
DBSession.add(servicegroup) |
|
| 44 |
DBSession.flush() |
|
| 45 |
|
|
| 46 |
service = LowLevelService( |
|
| 47 |
host=host, |
|
| 48 |
command=u'', |
|
| 49 |
weight=42, |
|
| 50 |
servicename=u'baz', |
|
| 51 |
) |
|
| 52 |
DBSession.add(service) |
|
| 53 |
DBSession.flush() |
|
| 54 |
|
|
| 29 |
servicegroup = functions.add_supitemgroup(u'bar') |
|
| 30 |
service = functions.add_lowlevelservice(host, u'baz') |
|
| 55 | 31 |
servicegroup.supitems.append(service) |
| 56 | 32 |
DBSession.flush() |
| 57 | 33 |
|
| 58 |
event = Event( |
|
| 59 |
supitem=service, |
|
| 60 |
timestamp=timestamp, |
|
| 61 |
current_state=StateName.statename_to_value(u'WARNING'), |
|
| 62 |
message=u'Hello world', |
|
| 63 |
) |
|
| 64 |
DBSession.add(event) |
|
| 65 |
DBSession.flush() |
|
| 66 |
|
|
| 67 |
correvent = CorrEvent( |
|
| 68 |
priority=42, |
|
| 69 |
trouble_ticket=None, |
|
| 70 |
ack=CorrEvent.ACK_NONE, |
|
| 71 |
occurrence=42, |
|
| 72 |
timestamp_active=timestamp, |
|
| 73 |
cause=event, |
|
| 74 |
) |
|
| 75 |
correvent.events.append(event) |
|
| 76 |
DBSession.add(correvent) |
|
| 77 |
DBSession.flush() |
|
| 34 |
event = functions.add_event(service, u'WARNING', u'Hello world', timestamp) |
|
| 35 |
correvent = functions.add_correvent([event], timestamp=timestamp) |
|
| 78 | 36 |
return (hostgroup, servicegroup) |
| 79 | 37 |
|
| 80 | 38 |
class TestSearchFormService(TestController): |
| vigiboard/tests/functional/utils.py | ||
|---|---|---|
| 12 | 12 |
import transaction |
| 13 | 13 |
|
| 14 | 14 |
from vigilo.models.session import DBSession |
| 15 |
from vigilo.models.demo import functions |
|
| 15 | 16 |
from vigilo.models.tables import Event, CorrEvent, DataPermission, \ |
| 16 | 17 |
Permission, StateName, Host, SupItemGroup, \ |
| 17 | 18 |
LowLevelService, User, UserGroup, Permission |
| ... | ... | |
| 22 | 23 |
|
| 23 | 24 |
# Création des 4 groupes de supitems : |
| 24 | 25 |
# - 1 groupe racine 'root' ; |
| 25 |
root = SupItemGroup(name=u'root', parent=None) |
|
| 26 |
DBSession.add(root) |
|
| 26 |
root = functions.add_supitemgroup(u'root') |
|
| 27 | 27 |
# - 1 groupe principal 'maingroup' ; |
| 28 |
maingroup = SupItemGroup(name=u'maingroup', parent=root) |
|
| 29 |
DBSession.add(maingroup) |
|
| 28 |
maingroup = functions.add_supitemgroup(u'maingroup', root) |
|
| 30 | 29 |
# - 2 sous-groupes 'group1' et 'group2', faisant tous |
| 31 | 30 |
# les deux parties du groupe principal 'maingroup'. |
| 32 |
group1 = SupItemGroup(name=u'group1', parent=maingroup) |
|
| 33 |
DBSession.add(group1) |
|
| 34 |
group2 = SupItemGroup(name=u'group2', parent=maingroup) |
|
| 35 |
DBSession.add(group2) |
|
| 36 |
DBSession.flush() |
|
| 31 |
group1 = functions.add_supitemgroup(u'group1', maingroup) |
|
| 32 |
group2 = functions.add_supitemgroup(u'group2', maingroup) |
|
| 37 | 33 |
|
| 38 | 34 |
# Création de 2 groupes d'utilisateurs (contenant chacun un utilisateur) : |
| 39 | 35 |
vigiboard_perm = Permission.by_permission_name(u'vigiboard-access') |
| ... | ... | |
| 73 | 69 |
DBSession.flush() |
| 74 | 70 |
|
| 75 | 71 |
# Création de 3 hôtes (1 par groupe de supitems). |
| 76 |
host_template = {
|
|
| 77 |
'snmpcommunity': u'public', |
|
| 78 |
'hosttpl': u'/dev/null', |
|
| 79 |
'address': u'192.168.1.1', |
|
| 80 |
'snmpport': 42, |
|
| 81 |
'weight': 42, |
|
| 82 |
} |
|
| 83 |
|
|
| 84 |
maingroup_host = Host(name=u'maingroup_host', **host_template) |
|
| 85 |
DBSession.add(maingroup_host) |
|
| 86 |
group1_host = Host(name=u'group1_host', **host_template) |
|
| 87 |
DBSession.add(group1_host) |
|
| 88 |
group2_host = Host(name=u'group2_host', **host_template) |
|
| 89 |
DBSession.add(group2_host) |
|
| 72 |
maingroup_host = functions.add_host(u'maingroup_host') |
|
| 73 |
group1_host = functions.add_host(u'group1_host') |
|
| 74 |
group2_host = functions.add_host(u'group2_host') |
|
| 90 | 75 |
|
| 91 | 76 |
# Affectation des hôtes aux groupes. |
| 92 | 77 |
maingroup.supitems.append(maingroup_host) |
| ... | ... | |
| 100 | 85 |
'weight': 42, |
| 101 | 86 |
} |
| 102 | 87 |
|
| 103 |
group1_service = LowLevelService( |
|
| 104 |
host = group1_host, |
|
| 105 |
servicename = u'group1_service', |
|
| 106 |
**service_template |
|
| 107 |
) |
|
| 108 |
DBSession.add(group1_service) |
|
| 109 |
|
|
| 110 |
group2_service = LowLevelService( |
|
| 111 |
host = group2_host, |
|
| 112 |
servicename = u'group2_service', |
|
| 113 |
**service_template |
|
| 114 |
) |
|
| 115 |
DBSession.add(group2_service) |
|
| 116 |
|
|
| 117 |
maingroup_service = LowLevelService( |
|
| 118 |
host = maingroup_host, |
|
| 119 |
servicename = u'maingroup_service', |
|
| 120 |
**service_template |
|
| 121 |
) |
|
| 122 |
DBSession.add(maingroup_service) |
|
| 123 |
DBSession.flush() |
|
| 88 |
group1_service = functions.add_lowlevelservice( |
|
| 89 |
group1_host, u'group1_service') |
|
| 90 |
group2_service = functions.add_lowlevelservice( |
|
| 91 |
group2_host, u'group2_service') |
|
| 92 |
maingroup_service = functions.add_lowlevelservice( |
|
| 93 |
maingroup_host, u'maingroup_service') |
|
| 124 | 94 |
|
| 125 | 95 |
# Ajout de 6 événements (1 par supitem) |
| 126 |
event_template = {
|
|
| 127 |
'message': u'foo', |
|
| 128 |
'current_state': StateName.statename_to_value(u'WARNING'), |
|
| 129 |
'timestamp': datetime.now(), |
|
| 130 |
} |
|
| 131 |
|
|
| 132 |
event1 = Event(supitem=maingroup_host, **event_template) |
|
| 133 |
DBSession.add(event1) |
|
| 134 |
event2 = Event(supitem=maingroup_service, **event_template) |
|
| 135 |
DBSession.add(event2) |
|
| 136 |
event3 = Event(supitem=group1_host, **event_template) |
|
| 137 |
DBSession.add(event3) |
|
| 138 |
event4 = Event(supitem=group1_service, **event_template) |
|
| 139 |
DBSession.add(event4) |
|
| 140 |
event5 = Event(supitem=group2_host, **event_template) |
|
| 141 |
DBSession.add(event5) |
|
| 142 |
event6 = Event(supitem=group2_service, **event_template) |
|
| 143 |
DBSession.add(event6) |
|
| 144 |
DBSession.flush() |
|
| 96 |
event1 = functions.add_event(maingroup_host, u'WARNING', u'foo') |
|
| 97 |
event2 = functions.add_event(maingroup_service, u'WARNING', u'foo') |
|
| 98 |
event3 = functions.add_event(group1_host, u'WARNING', u'foo') |
|
| 99 |
event4 = functions.add_event(group1_service, u'WARNING', u'foo') |
|
| 100 |
event5 = functions.add_event(group2_host, u'WARNING', u'foo') |
|
| 101 |
event6 = functions.add_event(group2_service, u'WARNING', u'foo') |
|
| 145 | 102 |
|
| 146 | 103 |
# Ajout de 5 événements corrélés (1 pour chaque évènement, |
| 147 | 104 |
# sauf celui touchant le 'maingroup_service' qui sera rattaché |
| 148 | 105 |
# à l'évènement corrélé causé par le 'maingroup_host'). |
| 149 |
aggregate_template = {
|
|
| 150 |
'timestamp_active': datetime.now(), |
|
| 151 |
'priority': 1, |
|
| 152 |
'ack': CorrEvent.ACK_NONE, |
|
| 153 |
} |
|
| 154 |
|
|
| 155 |
aggregate1 = CorrEvent( |
|
| 156 |
idcause=event1.idevent, **aggregate_template) |
|
| 157 |
aggregate3 = CorrEvent( |
|
| 158 |
idcause=event3.idevent, **aggregate_template) |
|
| 159 |
aggregate4 = CorrEvent( |
|
| 160 |
idcause=event4.idevent, **aggregate_template) |
|
| 161 |
aggregate5 = CorrEvent( |
|
| 162 |
idcause=event5.idevent, **aggregate_template) |
|
| 163 |
aggregate6 = CorrEvent( |
|
| 164 |
idcause=event6.idevent, **aggregate_template) |
|
| 165 |
|
|
| 166 |
aggregate1.events.append(event1) |
|
| 167 |
aggregate1.events.append(event2) |
|
| 168 |
aggregate3.events.append(event3) |
|
| 169 |
aggregate4.events.append(event4) |
|
| 170 |
aggregate5.events.append(event5) |
|
| 171 |
aggregate6.events.append(event6) |
|
| 172 |
DBSession.add(aggregate1) |
|
| 173 |
DBSession.add(aggregate3) |
|
| 174 |
DBSession.add(aggregate4) |
|
| 175 |
DBSession.add(aggregate5) |
|
| 176 |
DBSession.add(aggregate6) |
|
| 177 |
DBSession.flush() |
|
| 178 |
|
|
| 106 |
aggregate1 = functions.add_correvent([event1, event2]) |
|
| 107 |
aggregate3 = functions.add_correvent([event3]) |
|
| 108 |
aggregate4 = functions.add_correvent([event4]) |
|
| 109 |
aggregate5 = functions.add_correvent([event5]) |
|
| 110 |
aggregate6 = functions.add_correvent([event6]) |
|
| 179 | 111 |
transaction.commit() |
Also available in: Unified diff