Revision 0bd9c069
Retrait des modifications liées à la fusion de la branche nested_sets du trunk (révisions r6116, r6121 et r6129).
Le nouveau mécanisme nécessite encore des ajustements pour être utilisable.
git-svn-id: https://vigilo-dev.si.c-s.fr/svn@6135 b22e2e97-25c9-44ff-b637-2e5ceca36478
| vigiboard/controllers/root.py | ||
|---|---|---|
| 31 | 31 |
from pylons.i18n import ugettext as _, lazy_ugettext as l_ |
| 32 | 32 |
from sqlalchemy import asc |
| 33 | 33 |
from sqlalchemy.sql import func |
| 34 |
from sqlalchemy.orm import aliased |
|
| 35 | 34 |
from repoze.what.predicates import Any, All, in_group, \ |
| 36 | 35 |
has_permission, not_anonymous, \ |
| 37 | 36 |
NotAuthorizedError |
| ... | ... | |
| 42 | 41 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, Host, \ |
| 43 | 42 |
SupItem, SupItemGroup, LowLevelService, \ |
| 44 | 43 |
StateName, State |
| 44 |
from vigilo.models.tables.grouphierarchy import GroupHierarchy |
|
| 45 | 45 |
from vigilo.models.functions import sql_escape_like |
| 46 | 46 |
from vigilo.models.tables.secondary_tables import EVENTSAGGREGATE_TABLE |
| 47 | 47 |
|
| ... | ... | |
| 147 | 147 |
|
| 148 | 148 |
# Application des filtres si nécessaire |
| 149 | 149 |
if supitemgroup: |
| 150 |
base = DBSession.query(SupItemGroup).get(supitemgroup) |
|
| 151 |
if base: |
|
| 152 |
search['supitemgroup'] = supitemgroup |
|
| 153 |
sig = aliased(SupItemGroup) |
|
| 154 |
aggregates.add_join( |
|
| 155 |
(sig, aggregates.items.c.idsupitemgroup == sig.idgroup), |
|
| 156 |
) |
|
| 157 |
aggregates.add_filter(sig.left >= base.left) |
|
| 158 |
aggregates.add_filter(sig.right <= base.right) |
|
| 150 |
search['supitemgroup'] = supitemgroup |
|
| 151 |
aggregates.add_join((GroupHierarchy, GroupHierarchy.idchild == |
|
| 152 |
aggregates.items.c.idsupitemgroup)) |
|
| 153 |
aggregates.add_filter(GroupHierarchy.idparent == supitemgroup) |
|
| 159 | 154 |
|
| 160 | 155 |
if host: |
| 161 | 156 |
search['host_'] = host |
| 162 | 157 |
host = sql_escape_like(host) |
| 163 |
aggregates.add_filter(aggregates.items.c.hostname.ilike(host)) |
|
| 158 |
aggregates.add_filter(aggregates.items.c.hostname.ilike( |
|
| 159 |
'%s' % host)) |
|
| 164 | 160 |
|
| 165 | 161 |
if service: |
| 166 | 162 |
search['service'] = service |
| 167 | 163 |
service = sql_escape_like(service) |
| 168 |
aggregates.add_filter(aggregates.items.c.servicename.ilike(service)) |
|
| 164 |
aggregates.add_filter(aggregates.items.c.servicename.ilike( |
|
| 165 |
'%s' % service)) |
|
| 169 | 166 |
|
| 170 | 167 |
if output: |
| 171 | 168 |
search['output'] = output |
| 172 | 169 |
output = sql_escape_like(output) |
| 173 |
aggregates.add_filter(Event.message.ilike(output)) |
|
| 170 |
aggregates.add_filter(Event.message.ilike('%s' % output))
|
|
| 174 | 171 |
|
| 175 | 172 |
if trouble_ticket: |
| 176 | 173 |
search['tt'] = trouble_ticket |
| 177 | 174 |
trouble_ticket = sql_escape_like(trouble_ticket) |
| 178 |
aggregates.add_filter(CorrEvent.trouble_ticket.ilike(trouble_ticket)) |
|
| 175 |
aggregates.add_filter(CorrEvent.trouble_ticket.ilike( |
|
| 176 |
'%s' % trouble_ticket)) |
|
| 179 | 177 |
|
| 180 | 178 |
if from_date: |
| 181 | 179 |
search['from_date'] = from_date.lower() |
| ... | ... | |
| 207 | 205 |
else: |
| 208 | 206 |
aggregates.add_filter(CorrEvent.timestamp_active <= to_date) |
| 209 | 207 |
|
| 210 |
|
|
| 211 | 208 |
# Calcul des éléments à afficher et du nombre de pages possibles |
| 212 | 209 |
total_rows = aggregates.num_rows() |
| 213 | 210 |
items_per_page = int(config['vigiboard_items_per_page']) |
| ... | ... | |
| 752 | 749 |
if parent_id is None: |
| 753 | 750 |
return self.get_root_host_groups() |
| 754 | 751 |
|
| 755 |
parent = DBSession.query(SupItemGroup).get(parent_id) |
|
| 752 |
# TODO: Utiliser un schéma de validation |
|
| 753 |
parent_id = int(parent_id) |
|
| 756 | 754 |
|
| 757 | 755 |
# On vérifie si le groupe parent fait partie des |
| 758 | 756 |
# groupes auxquel l'utilisateur a accès, et on |
| 759 | 757 |
# retourne une liste vide dans le cas contraire |
| 760 | 758 |
is_manager = in_group('managers').is_met(request.environ)
|
| 759 |
if not is_manager: |
|
| 760 |
direct_access = False |
|
| 761 |
user = get_current_user() |
|
| 762 |
user_groups = dict(user.supitemgroups()) |
|
| 763 |
# On regarde d'abord si le groupe fait partie de ceux |
|
| 764 |
# auquels l'utilisateur a explicitement accès, ou s'il |
|
| 765 |
# est un parent des groupes auxquels l'utilisateur a accès |
|
| 766 |
if parent_id in user_groups.keys(): |
|
| 767 |
direct_access = user_groups[parent_id] |
|
| 768 |
# Dans le cas contraire, on vérifie si le groupe est un |
|
| 769 |
# sous-groupe des groupes auxquels l'utilisateur a accès |
|
| 770 |
else: |
|
| 771 |
id_list = [ug for ug in user_groups.keys() if user_groups[ug]] |
|
| 772 |
child_groups = DBSession.query(SupItemGroup.idgroup |
|
| 773 |
).distinct( |
|
| 774 |
).join( |
|
| 775 |
(GroupHierarchy, |
|
| 776 |
GroupHierarchy.idchild == SupItemGroup.idgroup), |
|
| 777 |
).filter(GroupHierarchy.idparent.in_(id_list) |
|
| 778 |
).filter(GroupHierarchy.hops > 0 |
|
| 779 |
).all() |
|
| 780 |
for ucg in child_groups: |
|
| 781 |
if ucg.idgroup == parent_id: |
|
| 782 |
direct_access = True |
|
| 783 |
break |
|
| 784 |
# Sinon, l'utilisateur n'a pas accès à ce groupe |
|
| 785 |
else: |
|
| 786 |
return dict(groups = [], leaves = []) |
|
| 761 | 787 |
|
| 762 | 788 |
# On récupère la liste des groupes dont |
| 763 | 789 |
# l'identifiant du parent est passé en paramètre |
| 764 | 790 |
db_groups = DBSession.query( |
| 765 | 791 |
SupItemGroup |
| 766 |
).filter(SupItemGroup.depth == parent.depth + 1 |
|
| 767 |
).filter(SupItemGroup.left > parent.left |
|
| 768 |
).filter(SupItemGroup.right < parent.right |
|
| 792 |
).join( |
|
| 793 |
(GroupHierarchy, GroupHierarchy.idchild == \ |
|
| 794 |
SupItemGroup.idgroup), |
|
| 795 |
).filter(GroupHierarchy.hops == 1 |
|
| 796 |
).filter(GroupHierarchy.idparent == parent_id |
|
| 769 | 797 |
).order_by(SupItemGroup.name.asc()) |
| 770 |
|
|
| 771 |
if not is_manager: |
|
| 772 |
user = get_current_user() |
|
| 773 |
user_groups = [g[0] for g in user.supitemgroups() if g[1]] |
|
| 774 |
db_groups = db_groups.filter(SupItemGroup.idgroup.in_(user_groups)) |
|
| 775 |
|
|
| 798 |
if not is_manager and not direct_access: |
|
| 799 |
id_list = [ug for ug in user_groups.keys()] |
|
| 800 |
db_groups = db_groups.filter( |
|
| 801 |
SupItemGroup.idgroup.in_(id_list)) |
|
| 776 | 802 |
groups = [] |
| 777 | 803 |
for group in db_groups.all(): |
| 778 | 804 |
groups.append({
|
| ... | ... | |
| 791 | 817 |
@rtype : C{dict} of C{list} of C{dict} of C{mixed}
|
| 792 | 818 |
""" |
| 793 | 819 |
|
| 794 |
root_groups = SupItemGroup.get_top_groups() |
|
| 820 |
# On récupère tous les groupes qui ont un parent. |
|
| 821 |
children = DBSession.query( |
|
| 822 |
SupItemGroup, |
|
| 823 |
).distinct( |
|
| 824 |
).join( |
|
| 825 |
(GroupHierarchy, GroupHierarchy.idchild == SupItemGroup.idgroup) |
|
| 826 |
).filter(GroupHierarchy.hops > 0) |
|
| 827 |
|
|
| 828 |
# Ensuite on les exclut de la liste des groupes, |
|
| 829 |
# pour ne garder que ceux qui sont au sommet de |
|
| 830 |
# l'arbre et qui constituent nos "root groups". |
|
| 831 |
root_groups = DBSession.query( |
|
| 832 |
SupItemGroup, |
|
| 833 |
).except_(children |
|
| 834 |
).order_by(SupItemGroup.name) |
|
| 795 | 835 |
|
| 796 | 836 |
# On filtre ces groupes racines afin de ne |
| 797 | 837 |
# retourner que ceux auquels l'utilisateur a accès |
| 798 | 838 |
user = get_current_user() |
| 799 | 839 |
is_manager = in_group('managers').is_met(request.environ)
|
| 800 | 840 |
if not is_manager: |
| 801 |
user_groups = [sig[0] for sig in user.supitemgroups()] |
|
| 802 |
for root_group in root_groups: |
|
| 803 |
if root_group.idgroup not in user_groups: |
|
| 804 |
root_groups.remove(root_group) |
|
| 841 |
user_groups = [ug[0] for ug in user.supitemgroups()] |
|
| 842 |
root_groups = root_groups.filter( |
|
| 843 |
SupItemGroup.idgroup.in_(user_groups)) |
|
| 805 | 844 |
|
| 806 | 845 |
groups = [] |
| 807 |
for group in root_groups: |
|
| 846 |
for group in root_groups.all():
|
|
| 808 | 847 |
groups.append({
|
| 809 | 848 |
'id' : group.idgroup, |
| 810 | 849 |
'name' : group.name, |
| vigiboard/controllers/vigiboardrequest.py | ||
|---|---|---|
| 244 | 244 |
Retourne le nombre de lignes de la requête. |
| 245 | 245 |
Si celle-ci n'est pas encore générée, on le fait. |
| 246 | 246 |
|
| 247 |
@return: Nombre de lignes
|
|
| 247 |
@return: Nombre de ligne |
|
| 248 | 248 |
""" |
| 249 | 249 |
|
| 250 | 250 |
self.generate_request() |
| vigiboard/tests/functional/plugins/test_details_plugin.py | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
from vigiboard.tests import TestController |
| 11 | 11 |
from vigilo.models.session import DBSession |
| 12 |
from vigilo.models.tables import User, UserGroup, \ |
|
| 12 |
from vigilo.models.tables import SupItemGroup, User, UserGroup, \
|
|
| 13 | 13 |
Permission, DataPermission, StateName, \ |
| 14 | 14 |
LowLevelService, Event, CorrEvent, Host |
| 15 |
from vigilo.models.demo.functions import * |
|
| 16 | 15 |
|
| 17 | 16 |
def insert_deps(return_service): |
| 18 | 17 |
""" |
| ... | ... | |
| 28 | 27 |
""" |
| 29 | 28 |
timestamp = datetime.now() |
| 30 | 29 |
|
| 31 |
hostgroup = add_supitemgroup(name=u'foo') |
|
| 30 |
hostgroup = SupItemGroup(name=u'foo') |
|
| 31 |
DBSession.add(hostgroup) |
|
| 32 | 32 |
|
| 33 | 33 |
host = Host( |
| 34 | 34 |
name=u'bar', |
| ... | ... | |
| 47 | 47 |
hostgroup.supitems.append(host) |
| 48 | 48 |
DBSession.flush() |
| 49 | 49 |
|
| 50 |
servicegroup = add_supitemgroup(name=u'bar') |
|
| 50 |
servicegroup = SupItemGroup(name=u'bar') |
|
| 51 |
DBSession.add(servicegroup) |
|
| 51 | 52 |
|
| 52 | 53 |
service = LowLevelService( |
| 53 | 54 |
host=host, |
| ... | ... | |
| 234 | 235 |
'idcorrevent': idcorrevent, |
| 235 | 236 |
'plugin_name': 'details', |
| 236 | 237 |
}, status=401) |
| 238 |
|
|
| vigiboard/tests/functional/plugins/test_plugin_hls.py | ||
|---|---|---|
| 7 | 7 |
|
| 8 | 8 |
from vigilo.models.session import DBSession |
| 9 | 9 |
from vigilo.models.tables import Permission, DataPermission, StateName, \ |
| 10 |
Host, HighLevelService, \ |
|
| 10 |
SupItemGroup, Host, HighLevelService, \
|
|
| 11 | 11 |
Event, CorrEvent, ImpactedPath, ImpactedHLS, \ |
| 12 | 12 |
User, UserGroup |
| 13 |
from vigilo.models.demo.functions import * |
|
| 14 | 13 |
from vigiboard.tests import TestController |
| 15 | 14 |
|
| 16 | 15 |
def populate_DB(): |
| 17 | 16 |
""" Peuple la base de données. """ |
| 18 | 17 |
|
| 19 | 18 |
# On ajoute un groupe d'hôtes |
| 20 |
hostmanagers = add_supitemgroup(name=u'managersgroup') |
|
| 19 |
hostmanagers = SupItemGroup(name=u'managersgroup') |
|
| 20 |
DBSession.add(hostmanagers) |
|
| 21 |
DBSession.flush() |
|
| 21 | 22 |
|
| 22 | 23 |
# On lui octroie les permissions |
| 23 | 24 |
usergroup = UserGroup.by_group_name(u'users_with_access') |
| ... | ... | |
| 30 | 31 |
|
| 31 | 32 |
# On crée un hôte de test. |
| 32 | 33 |
host = Host( |
| 33 |
name = u'host', |
|
| 34 |
name = u'host',
|
|
| 34 | 35 |
checkhostcmd = u'halt', |
| 35 | 36 |
snmpcommunity = u'public', |
| 36 | 37 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 56 | 57 |
|
| 57 | 58 |
# On ajoute un évènement corrélé causé par cet évènement 'brut'. |
| 58 | 59 |
aggregate = CorrEvent( |
| 59 |
idcause = event1.idevent, |
|
| 60 |
idcause = event1.idevent,
|
|
| 60 | 61 |
timestamp_active = datetime.now(), |
| 61 | 62 |
priority = 1, |
| 62 | 63 |
status = u'None') |
| 63 | 64 |
aggregate.events.append(event1) |
| 64 | 65 |
DBSession.add(aggregate) |
| 65 | 66 |
DBSession.flush() |
| 66 |
|
|
| 67 |
|
|
| 67 | 68 |
transaction.commit() |
| 68 | 69 |
return aggregate |
| 69 | 70 |
|
| 70 | 71 |
def add_paths(path_number, path_length, idsupitem): |
| 71 |
""" |
|
| 72 |
"""
|
|
| 72 | 73 |
Ajoute path_number chemins de services de haut niveau impactés |
| 73 | 74 |
dans la base de donnée. Leur longeur sera égale à path_length. |
| 74 | 75 |
La 3ème valeur passée en paramètre est l'id du supitem impactant. |
| 75 |
|
|
| 76 |
path_number * path_length services de |
|
| 76 |
|
|
| 77 |
path_number * path_length services de
|
|
| 77 | 78 |
haut niveau sont créés dans l'opération. |
| 78 | 79 |
""" |
| 79 | 80 |
|
| ... | ... | |
| 88 | 89 |
|
| 89 | 90 |
# Création des chemins de services de haut niveau impactés. |
| 90 | 91 |
for j in range(path_number): |
| 91 |
|
|
| 92 |
|
|
| 92 | 93 |
# On crée le chemin en lui-même |
| 93 | 94 |
path = ImpactedPath(idsupitem = idsupitem) |
| 94 | 95 |
DBSession.add(path) |
| 95 | 96 |
DBSession.flush() |
| 96 |
|
|
| 97 |
|
|
| 97 | 98 |
# Pour chaque étage du chemin, |
| 98 | 99 |
for i in range(path_length): |
| 99 | 100 |
# on ajoute un service de haut niveau dans la BDD, |
| 100 | 101 |
hls = HighLevelService( |
| 101 |
servicename = u'HLS' + str(j + 1) + str(i + 1), |
|
| 102 |
servicename = u'HLS' + str(j + 1) + str(i + 1),
|
|
| 102 | 103 |
**hls_template) |
| 103 | 104 |
DBSession.add(hls) |
| 104 |
# et on ajoute un étage au chemin contenant ce service. |
|
| 105 |
# et on ajoute un étage au chemin contenant ce service.
|
|
| 105 | 106 |
DBSession.add( |
| 106 | 107 |
ImpactedHLS( |
| 107 | 108 |
path = path, |
| 108 | 109 |
hls = hls, |
| 109 | 110 |
distance = i + 1, |
| 110 | 111 |
)) |
| 111 |
|
|
| 112 |
|
|
| 112 | 113 |
DBSession.flush() |
| 113 | 114 |
transaction.commit() |
| 114 | 115 |
|
| 115 | 116 |
|
| 116 | 117 |
class TestHLSPlugin(TestController): |
| 117 | 118 |
""" |
| 118 |
Classe de test du contrôleur listant les services |
|
| 119 |
Classe de test du contrôleur listant les services
|
|
| 119 | 120 |
de haut niveau impactés par un évènement corrélé. |
| 120 | 121 |
""" |
| 121 | 122 |
def setUp(self): |
| ... | ... | |
| 158 | 159 |
Teste la valeur de retour du plugin lorsque |
| 159 | 160 |
aucun service de haut niveau n'est impacté. |
| 160 | 161 |
""" |
| 161 |
|
|
| 162 |
|
|
| 162 | 163 |
# On peuple la base de données avant le test. |
| 163 | 164 |
DBSession.add(self.aggregate) |
| 164 | 165 |
add_paths(0, 0, self.aggregate.events[0].idsupitem) |
| 165 | 166 |
DBSession.add(self.aggregate) |
| 166 |
|
|
| 167 |
|
|
| 167 | 168 |
### 1er cas : l'utilisateur n'est pas connecté. |
| 168 | 169 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 169 | 170 |
resp = self.app.post( |
| 170 |
'/get_plugin_value', |
|
| 171 |
'/get_plugin_value',
|
|
| 171 | 172 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 172 | 173 |
"plugin_name" : "hls"}, |
| 173 | 174 |
status = 401,) |
| 174 |
|
|
| 175 |
|
|
| 175 | 176 |
### 2ème cas : l'utilisateur n'a pas les |
| 176 | 177 |
### droits sur l'hôte ayant causé le correvent. |
| 177 | 178 |
# On vérifie que le plugin retourne bien une erreur 404. |
| 178 | 179 |
resp = self.app.post( |
| 179 |
'/get_plugin_value', |
|
| 180 |
'/get_plugin_value',
|
|
| 180 | 181 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 181 | 182 |
"plugin_name" : "hls"}, |
| 182 | 183 |
status = 404, |
| 183 | 184 |
extra_environ={'REMOTE_USER': 'no_access'})
|
| 184 |
|
|
| 185 |
|
|
| 185 | 186 |
### 3ème cas : l'utilisateur a cette fois les droits. |
| 186 | 187 |
resp = self.app.post( |
| 187 |
'/get_plugin_value', |
|
| 188 |
'/get_plugin_value',
|
|
| 188 | 189 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 189 | 190 |
"plugin_name" : "hls"}, |
| 190 | 191 |
extra_environ={'REMOTE_USER': 'access'})
|
| 191 | 192 |
# On vérifie que le plugin ne retourne toujours rien. |
| 192 | 193 |
assert_equal(resp.json, {"services": []})
|
| 193 |
|
|
| 194 |
|
|
| 194 | 195 |
def test_1_impacted_hls_path(self): |
| 195 | 196 |
""" |
| 196 | 197 |
Retour du plugin HLS pour 1 chemin impacté |
| 197 | 198 |
Teste la valeur de retour du plugin lorsqu'un |
| 198 | 199 |
chemin de services de haut niveau est impacté. |
| 199 | 200 |
""" |
| 200 |
|
|
| 201 |
|
|
| 201 | 202 |
# On peuple la base de données avant le test. |
| 202 | 203 |
DBSession.add(self.aggregate) |
| 203 | 204 |
add_paths(1, 2, self.aggregate.events[0].idsupitem) |
| 204 | 205 |
DBSession.add(self.aggregate) |
| 205 |
|
|
| 206 |
|
|
| 206 | 207 |
### 1er cas : l'utilisateur n'est pas connecté. |
| 207 | 208 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 208 | 209 |
resp = self.app.post( |
| 209 |
'/get_plugin_value', |
|
| 210 |
'/get_plugin_value',
|
|
| 210 | 211 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 211 | 212 |
"plugin_name" : "hls"}, |
| 212 | 213 |
status = 401,) |
| 213 |
|
|
| 214 |
|
|
| 214 | 215 |
### 2ème cas : l'utilisateur n'a pas les droits |
| 215 | 216 |
### sur l'hôte ayant causé le correvent, on doit |
| 216 | 217 |
### obtenir une erreur 404 (pas d'événement trouvé |
| 217 | 218 |
### avec les informations liées à cet utilisateur). |
| 218 | 219 |
resp = self.app.post( |
| 219 |
'/get_plugin_value', |
|
| 220 |
'/get_plugin_value',
|
|
| 220 | 221 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 221 | 222 |
"plugin_name" : "hls"}, |
| 222 | 223 |
status = 404, |
| 223 | 224 |
extra_environ={'REMOTE_USER': 'no_access'})
|
| 224 |
|
|
| 225 |
|
|
| 225 | 226 |
### 3ème cas : l'utilisateur a cette fois les droits. |
| 226 | 227 |
resp = self.app.post( |
| 227 |
'/get_plugin_value', |
|
| 228 |
'/get_plugin_value',
|
|
| 228 | 229 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 229 | 230 |
"plugin_name" : "hls"}, |
| 230 | 231 |
extra_environ={'REMOTE_USER': 'access'})
|
| 231 | 232 |
# On vérifie que le plugin retourne bien les 2 HLS impactés. |
| 232 | 233 |
assert_equal(resp.json, {"services": ['HLS12']})
|
| 233 |
|
|
| 234 |
|
|
| 234 | 235 |
def test_2_impacted_hls_path(self): |
| 235 | 236 |
""" |
| 236 | 237 |
Retour du plugin HLS pour 2 chemins impactés |
| 237 | 238 |
Teste la valeur de retour du plugin lorsque deux |
| 238 | 239 |
chemins de services de haut niveau sont impactés. |
| 239 | 240 |
""" |
| 240 |
|
|
| 241 |
|
|
| 241 | 242 |
# On peuple la base de données avant le test. |
| 242 | 243 |
DBSession.add(self.aggregate) |
| 243 | 244 |
add_paths(2, 2, self.aggregate.events[0].idsupitem) |
| 244 | 245 |
DBSession.add(self.aggregate) |
| 245 |
|
|
| 246 |
|
|
| 246 | 247 |
### 1er cas : l'utilisateur n'est pas connecté. |
| 247 | 248 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 248 | 249 |
resp = self.app.post( |
| 249 |
'/get_plugin_value', |
|
| 250 |
'/get_plugin_value',
|
|
| 250 | 251 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 251 | 252 |
"plugin_name" : "hls"}, |
| 252 | 253 |
status = 401,) |
| 253 |
|
|
| 254 |
|
|
| 254 | 255 |
### 2ème cas : l'utilisateur n'a pas les |
| 255 | 256 |
### droits sur l'hôte ayant causé le correvent. |
| 256 | 257 |
resp = self.app.post( |
| 257 |
'/get_plugin_value', |
|
| 258 |
'/get_plugin_value',
|
|
| 258 | 259 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 259 | 260 |
"plugin_name" : "hls"}, |
| 260 | 261 |
status = 404, |
| 261 | 262 |
extra_environ={'REMOTE_USER': 'no_access'})
|
| 262 |
|
|
| 263 |
|
|
| 263 | 264 |
### 3ème cas : l'utilisateur a cette fois les droits. |
| 264 | 265 |
resp = self.app.post( |
| 265 |
'/get_plugin_value', |
|
| 266 |
'/get_plugin_value',
|
|
| 266 | 267 |
{"idcorrevent" : str(self.aggregate.idcorrevent),
|
| 267 | 268 |
"plugin_name" : "hls"}, |
| 268 | 269 |
extra_environ={'REMOTE_USER': 'access'})
|
| 269 | 270 |
# On vérifie que le plugin retourne bien les 4 HLS impactés. |
| 270 | 271 |
assert_equal(resp.json, {"services": ['HLS12', 'HLS22']})
|
| 272 |
|
|
| vigiboard/tests/functional/test_correvents_table.py | ||
|---|---|---|
| 10 | 10 |
|
| 11 | 11 |
from vigilo.models.session import DBSession |
| 12 | 12 |
from vigilo.models.tables import Event, CorrEvent, DataPermission, \ |
| 13 |
Permission, StateName, Host, \ |
|
| 13 |
Permission, StateName, Host, SupItemGroup, \
|
|
| 14 | 14 |
LowLevelService, User, UserGroup, Permission |
| 15 |
from vigilo.models.demo.functions import * |
|
| 16 | 15 |
from vigiboard.tests import TestController |
| 17 | 16 |
|
| 18 | 17 |
def populate_DB(): |
| 19 | 18 |
""" Peuple la base de données. """ |
| 20 | 19 |
# On ajoute les groupes et leurs dépendances |
| 21 |
hostmanagers = add_supitemgroup(name=u'managersgroup') |
|
| 22 |
hosteditors = add_supitemgroup(name=u'editorsgroup') |
|
| 20 |
hostmanagers = SupItemGroup(name=u'managersgroup') |
|
| 21 |
DBSession.add(hostmanagers) |
|
| 22 |
hosteditors = SupItemGroup(name=u'editorsgroup', parent=hostmanagers) |
|
| 23 |
DBSession.add(hosteditors) |
|
| 24 |
DBSession.flush() |
|
| 23 | 25 |
|
| 24 | 26 |
usergroup = UserGroup.by_group_name(u'users_with_access') |
| 25 | 27 |
DBSession.add(DataPermission( |
| ... | ... | |
| 280 | 282 |
rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')
|
| 281 | 283 |
print "There are %d rows in the result set" % len(rows) |
| 282 | 284 |
assert_equal(len(rows), 1) |
| 285 |
|
|
| vigiboard/tests/functional/test_history_table.py | ||
|---|---|---|
| 12 | 12 |
from vigilo.models.session import DBSession |
| 13 | 13 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, \ |
| 14 | 14 |
Permission, StateName, Host, \ |
| 15 |
SupItemGroup, LowLevelService, \ |
|
| 15 | 16 |
Permission, DataPermission, User, \ |
| 16 |
LowLevelService, UserGroup |
|
| 17 |
from vigilo.models.demo.functions import * |
|
| 17 |
UserGroup |
|
| 18 | 18 |
from vigiboard.tests import TestController |
| 19 | 19 |
|
| 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 = add_supitemgroup('managersgroup')
|
|
| 23 |
supitemmanagers = SupItemGroup(name=u'managersgroup') |
|
| 24 |
DBSession.add(supitemmanagers) |
|
| 25 |
DBSession.flush() |
|
| 24 | 26 |
|
| 25 | 27 |
usergroup = UserGroup.by_group_name(u'users_with_access') |
| 26 | 28 |
DBSession.add(DataPermission( |
| ... | ... | |
| 32 | 34 |
|
| 33 | 35 |
# On crée un hôte de test, et on l'ajoute au groupe d'hôtes. |
| 34 | 36 |
managerhost = Host( |
| 35 |
name = u'managerhost', |
|
| 37 |
name = u'managerhost',
|
|
| 36 | 38 |
checkhostcmd = u'halt', |
| 37 | 39 |
snmpcommunity = u'public', |
| 38 | 40 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 54 | 56 |
DBSession.add(managerservice) |
| 55 | 57 |
supitemmanagers.supitems.append(managerservice) |
| 56 | 58 |
DBSession.flush() |
| 57 |
|
|
| 59 |
|
|
| 58 | 60 |
return (managerhost, managerservice) |
| 59 | 61 |
|
| 60 | 62 |
def add_correvent_caused_by(supitem): |
| 61 | 63 |
""" |
| 62 |
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é
|
|
| 63 | 65 |
par un incident survenu sur l'item passé en paramètre. |
| 64 | 66 |
Génère un historique pour les tests. |
| 65 | 67 |
""" |
| 66 | 68 |
|
| 67 | 69 |
# Ajout d'un événement |
| 68 | 70 |
event = Event( |
| 69 |
supitem = supitem, |
|
| 71 |
supitem = supitem,
|
|
| 70 | 72 |
message = u'foo', |
| 71 | 73 |
current_state = StateName.statename_to_value(u"WARNING"), |
| 72 | 74 |
timestamp = datetime.now(), |
| ... | ... | |
| 77 | 79 |
# Ajout des historiques |
| 78 | 80 |
DBSession.add(EventHistory( |
| 79 | 81 |
type_action=u'Nagios update state', |
| 80 |
idevent=event.idevent, |
|
| 82 |
idevent=event.idevent,
|
|
| 81 | 83 |
timestamp=datetime.now())) |
| 82 | 84 |
DBSession.add(EventHistory( |
| 83 | 85 |
type_action=u'Acknowlegement change state', |
| 84 |
idevent=event.idevent, |
|
| 86 |
idevent=event.idevent,
|
|
| 85 | 87 |
timestamp=datetime.now())) |
| 86 | 88 |
DBSession.flush() |
| 87 | 89 |
|
| 88 | 90 |
# Ajout d'un événement corrélé |
| 89 | 91 |
aggregate = CorrEvent( |
| 90 |
idcause = event.idevent, |
|
| 92 |
idcause = event.idevent,
|
|
| 91 | 93 |
timestamp_active = datetime.now(), |
| 92 | 94 |
priority = 1, |
| 93 | 95 |
status = u"None") |
| 94 | 96 |
aggregate.events.append(event) |
| 95 | 97 |
DBSession.add(aggregate) |
| 96 | 98 |
DBSession.flush() |
| 97 |
|
|
| 99 |
|
|
| 98 | 100 |
return event.idevent |
| 99 |
|
|
| 101 |
|
|
| 100 | 102 |
|
| 101 | 103 |
class TestHistoryTable(TestController): |
| 102 | 104 |
""" |
| ... | ... | |
| 142 | 144 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
| 143 | 145 |
# et un groupe d'hôtes et de services associés à ces items. |
| 144 | 146 |
(managerhost, managerservice) = populate_DB() |
| 145 |
|
|
| 147 |
|
|
| 146 | 148 |
# On ajoute un évènement corrélé causé par l'hôte |
| 147 | 149 |
idevent = add_correvent_caused_by(managerhost) |
| 148 | 150 |
transaction.commit() |
| ... | ... | |
| 156 | 158 |
|
| 157 | 159 |
# L'utilisateur N'A PAS les bonnes permissions. |
| 158 | 160 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 159 |
|
|
| 161 |
|
|
| 160 | 162 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 161 | 163 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 162 | 164 |
# n'a pas accès aux informations concernant cet évènement. |
| 163 | 165 |
response = self.app.get( |
| 164 | 166 |
'/event/%d' % idevent, |
| 165 |
status = 302, |
|
| 167 |
status = 302,
|
|
| 166 | 168 |
extra_environ = environ) |
| 167 | 169 |
|
| 168 | 170 |
# On suit la redirection. |
| ... | ... | |
| 172 | 174 |
|
| 173 | 175 |
# L'utilisateur a les bonnes permissions. |
| 174 | 176 |
environ = {'REMOTE_USER': 'access'}
|
| 175 |
|
|
| 177 |
|
|
| 176 | 178 |
# On s'attend à ce que le statut de la requête soit 200. |
| 177 | 179 |
response = self.app.get( |
| 178 | 180 |
'/event/%d' % idevent, |
| 179 |
status = 200, |
|
| 181 |
status = 200,
|
|
| 180 | 182 |
extra_environ = environ) |
| 181 | 183 |
|
| 182 | 184 |
# Il doit y avoir 2 lignes de résultats. |
| ... | ... | |
| 193 | 195 |
# On peuple la BDD avec un hôte, un service de bas niveau, |
| 194 | 196 |
# et un groupe d'hôtes et de services associés à ces items. |
| 195 | 197 |
(managerhost, managerservice) = populate_DB() |
| 196 |
|
|
| 198 |
|
|
| 197 | 199 |
# On ajoute un évènement corrélé causé par le service |
| 198 | 200 |
idevent = add_correvent_caused_by(managerservice) |
| 199 |
|
|
| 201 |
|
|
| 200 | 202 |
transaction.commit() |
| 201 | 203 |
|
| 202 | 204 |
# L'utilisateur n'est pas authentifié. |
| ... | ... | |
| 208 | 210 |
|
| 209 | 211 |
# L'utilisateur N'A PAS les bonnes permissions. |
| 210 | 212 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 211 |
|
|
| 213 |
|
|
| 212 | 214 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 213 | 215 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 214 | 216 |
# n'a pas accès aux informations concernant cet évènement. |
| 215 | 217 |
response = self.app.get( |
| 216 | 218 |
'/event/%d' % idevent, |
| 217 |
status = 302, |
|
| 219 |
status = 302,
|
|
| 218 | 220 |
extra_environ = environ) |
| 219 | 221 |
|
| 220 | 222 |
# On suit la redirection. |
| ... | ... | |
| 224 | 226 |
|
| 225 | 227 |
# L'utilisateur a les bonnes permissions. |
| 226 | 228 |
environ = {'REMOTE_USER': 'access'}
|
| 227 |
|
|
| 229 |
|
|
| 228 | 230 |
# On s'attend à ce que le statut de la requête soit 200. |
| 229 | 231 |
response = self.app.get( |
| 230 | 232 |
'/event/%d' % idevent, |
| 231 |
status = 200, |
|
| 233 |
status = 200,
|
|
| 232 | 234 |
extra_environ = environ) |
| 233 | 235 |
|
| 234 | 236 |
# Il doit y avoir 2 lignes de résultats. |
| ... | ... | |
| 238 | 240 |
rows = response.lxml.xpath( |
| 239 | 241 |
'//table[contains(@class,"vigitable")]/tbody/tr') |
| 240 | 242 |
assert_equal(len(rows), 2) |
| 243 |
|
|
| vigiboard/tests/functional/test_raw_events_table.py | ||
|---|---|---|
| 12 | 12 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, User, \ |
| 13 | 13 |
Permission, StateName, Host, UserGroup, \ |
| 14 | 14 |
LowLevelService, SupItemGroup, DataPermission |
| 15 |
from vigilo.models.demo.functions import * |
|
| 16 | 15 |
from vigiboard.tests import TestController |
| 17 | 16 |
|
| 18 | 17 |
def populate_accounts(): |
| ... | ... | |
| 50 | 49 |
def populate_DB(caused_by_service): |
| 51 | 50 |
""" Peuple la base de données. """ |
| 52 | 51 |
# On ajoute un groupe d'hôtes et un groupe de services. |
| 53 |
supitemmanagers = add_supitemgroup('managersgroup')
|
|
| 52 |
supitemmanagers = SupItemGroup(name = u'managersgroup') |
|
| 53 |
DBSession.add(supitemmanagers) |
|
| 54 |
DBSession.flush() |
|
| 54 | 55 |
|
| 55 | 56 |
usergroup = UserGroup.by_group_name(u'users_with_access') |
| 56 | 57 |
DBSession.add(DataPermission( |
| vigiboard/tests/functional/test_root.py | ||
|---|---|---|
| 18 | 18 |
from vigilo.models.session import DBSession |
| 19 | 19 |
from vigilo.models.tables import Event, EventHistory, CorrEvent, User, \ |
| 20 | 20 |
Permission, StateName, Host, UserGroup, \ |
| 21 |
LowLevelService, DataPermission |
|
| 22 |
from vigilo.models.demo.functions import * |
|
| 21 |
SupItemGroup, LowLevelService, DataPermission |
|
| 23 | 22 |
from vigiboard.tests import TestController |
| 24 | 23 |
|
| 25 | 24 |
def populate_DB(): |
| 26 | 25 |
""" Peuple la base de données. """ |
| 27 | 26 |
# On ajoute un groupe d'hôtes et un groupe de services. |
| 28 |
supitemmanagers = add_supitemgroup('managersgroup')
|
|
| 27 |
supitemmanagers = SupItemGroup(name = u'managersgroup')
|
|
| 29 | 28 |
DBSession.add(supitemmanagers) |
| 30 | 29 |
DBSession.flush() |
| 31 | 30 |
|
| ... | ... | |
| 39 | 38 |
|
| 40 | 39 |
# On crée un 2 hôtes, et on les ajoute au groupe d'hôtes. |
| 41 | 40 |
host1 = Host( |
| 42 |
name = u'host1', |
|
| 41 |
name = u'host1',
|
|
| 43 | 42 |
checkhostcmd = u'halt', |
| 44 | 43 |
snmpcommunity = u'public', |
| 45 | 44 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 50 | 49 |
DBSession.add(host1) |
| 51 | 50 |
supitemmanagers.supitems.append(host1) |
| 52 | 51 |
host2 = Host( |
| 53 |
name = u'host2', |
|
| 52 |
name = u'host2',
|
|
| 54 | 53 |
checkhostcmd = u'halt', |
| 55 | 54 |
snmpcommunity = u'public', |
| 56 | 55 |
hosttpl = u'/dev/null', |
| ... | ... | |
| 80 | 79 |
DBSession.add(service2) |
| 81 | 80 |
supitemmanagers.supitems.append(service2) |
| 82 | 81 |
DBSession.flush() |
| 83 |
|
|
| 82 |
|
|
| 84 | 83 |
return ([host1, host2], [service1, service2]) |
| 85 | 84 |
|
| 86 | 85 |
def add_correvent_caused_by(supitem, timestamp, |
| 87 | 86 |
correvent_status=u"None", event_status=u"WARNING"): |
| 88 | 87 |
""" |
| 89 |
Ajoute dans la base de données un évènement corrélé causé |
|
| 88 |
Ajoute dans la base de données un évènement corrélé causé
|
|
| 90 | 89 |
par un incident survenu sur l'item passé en paramètre. |
| 91 | 90 |
Génère un historique pour les tests. |
| 92 | 91 |
""" |
| 93 | 92 |
|
| 94 | 93 |
# Ajout d'un événement |
| 95 | 94 |
event = Event( |
| 96 |
supitem = supitem, |
|
| 95 |
supitem = supitem,
|
|
| 97 | 96 |
message = u'foo', |
| 98 | 97 |
current_state = StateName.statename_to_value(event_status), |
| 99 | 98 |
timestamp = datetime.now(), |
| ... | ... | |
| 103 | 102 |
|
| 104 | 103 |
# Ajout d'un événement corrélé |
| 105 | 104 |
aggregate = CorrEvent( |
| 106 |
idcause = event.idevent, |
|
| 105 |
idcause = event.idevent,
|
|
| 107 | 106 |
timestamp_active = timestamp, |
| 108 | 107 |
priority = 1, |
| 109 | 108 |
status = correvent_status) |
| 110 | 109 |
aggregate.events.append(event) |
| 111 | 110 |
DBSession.add(aggregate) |
| 112 | 111 |
DBSession.flush() |
| 113 |
|
|
| 112 |
|
|
| 114 | 113 |
return aggregate.idcorrevent |
| 115 | 114 |
|
| 116 | 115 |
|
| ... | ... | |
| 164 | 163 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 165 | 164 |
# et un groupe d'hôtes et de services associés à ces items. |
| 166 | 165 |
(hosts, services) = populate_DB() |
| 167 |
|
|
| 166 |
|
|
| 168 | 167 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 169 | 168 |
timestamp = datetime.now() |
| 170 | 169 |
correvent1_id = add_correvent_caused_by(hosts[0], timestamp) |
| 171 | 170 |
correvent2_id = add_correvent_caused_by(hosts[1], timestamp) |
| 172 | 171 |
transaction.commit() |
| 173 |
|
|
| 172 |
|
|
| 174 | 173 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 175 | 174 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 176 | 175 |
response = self.app.post( |
| ... | ... | |
| 180 | 179 |
"trouble_ticket" : u"foo", |
| 181 | 180 |
"ack" : u'NoChange', |
| 182 | 181 |
}, status = 401) |
| 183 |
|
|
| 182 |
|
|
| 184 | 183 |
### 2ème cas : L'utilisateur utilisé pour |
| 185 | 184 |
# se connecter à Vigiboard est 'limited_access'. |
| 186 | 185 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 187 |
|
|
| 186 |
|
|
| 188 | 187 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 189 | 188 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 190 | 189 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 195 | 194 |
"trouble_ticket" : u"foo", |
| 196 | 195 |
"last_modification": mktime(timestamp.timetuple()), |
| 197 | 196 |
}, status = 302, extra_environ = environ) |
| 198 |
|
|
| 197 |
|
|
| 199 | 198 |
response = response.follow(status=200, extra_environ = environ) |
| 200 | 199 |
assert_true(response.lxml.xpath( |
| 201 | 200 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 203 | 202 |
### 3ème cas : L'utilisateur utilisé pour |
| 204 | 203 |
# se connecter à Vigiboard est 'access'. |
| 205 | 204 |
environ = {'REMOTE_USER': 'access'}
|
| 206 |
|
|
| 205 |
|
|
| 207 | 206 |
# On s'attend à ce que le statut de la requête soit 302, |
| 208 | 207 |
# et à ce qu'un message informe l'utilisateur que les |
| 209 | 208 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 214 | 213 |
"trouble_ticket" : u"foo", |
| 215 | 214 |
"ack" : u'NoChange', |
| 216 | 215 |
}, status = 302, extra_environ = environ) |
| 217 |
|
|
| 216 |
|
|
| 218 | 217 |
response = response.follow(status=200, extra_environ = environ) |
| 219 | 218 |
assert_false(response.lxml.xpath( |
| 220 | 219 |
'//div[@id="flash"]/div[@class="error"]')) |
| 221 | 220 |
assert_true(response.lxml.xpath( |
| 222 | 221 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 223 |
|
|
| 222 |
|
|
| 224 | 223 |
# On s'assure que le ticket de l'évènement corrélé |
| 225 | 224 |
# a bien été mis à jour dans la base de données. |
| 226 | 225 |
correvents = DBSession.query( |
| 227 | 226 |
CorrEvent.trouble_ticket |
| 228 | 227 |
).filter(CorrEvent.idcorrevent.in_([correvent1_id, correvent2_id]) |
| 229 | 228 |
).all() |
| 230 |
|
|
| 229 |
|
|
| 231 | 230 |
assert_equal(correvents[0].trouble_ticket, u"foo") |
| 232 | 231 |
assert_equal(correvents[1].trouble_ticket, u"foo") |
| 233 | 232 |
|
| ... | ... | |
| 237 | 236 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 238 | 237 |
# et un groupe d'hôtes et de services associés à ces items. |
| 239 | 238 |
(hosts, services) = populate_DB() |
| 240 |
|
|
| 239 |
|
|
| 241 | 240 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 242 | 241 |
timestamp = datetime.now() |
| 243 | 242 |
correvent1_id = add_correvent_caused_by(services[0], timestamp) |
| 244 | 243 |
correvent2_id = add_correvent_caused_by(services[1], timestamp) |
| 245 |
|
|
| 244 |
|
|
| 246 | 245 |
transaction.commit() |
| 247 |
|
|
| 246 |
|
|
| 248 | 247 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 249 | 248 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 250 | 249 |
response = self.app.post( |
| ... | ... | |
| 254 | 253 |
"trouble_ticket" : u"foo", |
| 255 | 254 |
"ack" : u'NoChange', |
| 256 | 255 |
}, status = 401) |
| 257 |
|
|
| 256 |
|
|
| 258 | 257 |
### 2ème cas : L'utilisateur utilisé pour |
| 259 | 258 |
# se connecter à Vigiboard est 'limited_access'. |
| 260 | 259 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 261 |
|
|
| 260 |
|
|
| 262 | 261 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 263 | 262 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 264 | 263 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 269 | 268 |
"trouble_ticket" : u"foo", |
| 270 | 269 |
"ack" : u'NoChange', |
| 271 | 270 |
}, status = 302, extra_environ = environ) |
| 272 |
|
|
| 271 |
|
|
| 273 | 272 |
response = response.follow(status=200, extra_environ = environ) |
| 274 | 273 |
assert_true(response.lxml.xpath( |
| 275 | 274 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 277 | 276 |
### 3ème cas : L'utilisateur utilisé pour |
| 278 | 277 |
# se connecter à Vigiboard est 'access'. |
| 279 | 278 |
environ = {'REMOTE_USER': 'access'}
|
| 280 |
|
|
| 279 |
|
|
| 281 | 280 |
# On s'attend à ce que le statut de la requête soit 302, |
| 282 | 281 |
# et à ce qu'un message informe l'utilisateur que les |
| 283 | 282 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 288 | 287 |
"trouble_ticket" : u"foo", |
| 289 | 288 |
"ack" : u'NoChange', |
| 290 | 289 |
}, status = 302, extra_environ = environ) |
| 291 |
|
|
| 290 |
|
|
| 292 | 291 |
response = response.follow(status=200, extra_environ = environ) |
| 293 | 292 |
assert_false(response.lxml.xpath( |
| 294 | 293 |
'//div[@id="flash"]/div[@class="error"]')) |
| 295 | 294 |
assert_true(response.lxml.xpath( |
| 296 | 295 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 297 |
|
|
| 296 |
|
|
| 298 | 297 |
# On s'assure que le ticket de l'évènement corrélé |
| 299 | 298 |
# a bien été mis à jour dans la base de données. |
| 300 | 299 |
correvents = DBSession.query( |
| ... | ... | |
| 310 | 309 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 311 | 310 |
# et un groupe d'hôtes et de services associés à ces items. |
| 312 | 311 |
(hosts, services) = populate_DB() |
| 313 |
|
|
| 312 |
|
|
| 314 | 313 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 315 | 314 |
timestamp = datetime.now() |
| 316 | 315 |
correvent1_id = add_correvent_caused_by(hosts[0], timestamp) |
| 317 | 316 |
correvent2_id = add_correvent_caused_by(hosts[1], timestamp) |
| 318 | 317 |
transaction.commit() |
| 319 |
|
|
| 318 |
|
|
| 320 | 319 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 321 | 320 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 322 | 321 |
response = self.app.post( |
| ... | ... | |
| 326 | 325 |
"trouble_ticket" : "", |
| 327 | 326 |
"ack" : u'Acknowledged', |
| 328 | 327 |
}, status = 401) |
| 329 |
|
|
| 328 |
|
|
| 330 | 329 |
### 2ème cas : L'utilisateur utilisé pour |
| 331 | 330 |
# se connecter à Vigiboard est 'limited_access'. |
| 332 | 331 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 333 |
|
|
| 332 |
|
|
| 334 | 333 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 335 | 334 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 336 | 335 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 341 | 340 |
"trouble_ticket" : "", |
| 342 | 341 |
"ack" : u'Acknowledged', |
| 343 | 342 |
}, status = 302, extra_environ = environ) |
| 344 |
|
|
| 343 |
|
|
| 345 | 344 |
response = response.follow(status=200, extra_environ = environ) |
| 346 | 345 |
assert_true(response.lxml.xpath( |
| 347 | 346 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 349 | 348 |
### 3ème cas : L'utilisateur utilisé pour |
| 350 | 349 |
# se connecter à Vigiboard est 'access'. |
| 351 | 350 |
environ = {'REMOTE_USER': 'access'}
|
| 352 |
|
|
| 351 |
|
|
| 353 | 352 |
# On s'attend à ce que le statut de la requête soit 302, |
| 354 | 353 |
# et à ce qu'un message informe l'utilisateur que les |
| 355 | 354 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 360 | 359 |
"trouble_ticket" : "", |
| 361 | 360 |
"ack" : u'Acknowledged', |
| 362 | 361 |
}, status = 302, extra_environ = environ) |
| 363 |
|
|
| 362 |
|
|
| 364 | 363 |
response = response.follow(status=200, extra_environ = environ) |
| 365 | 364 |
assert_false(response.lxml.xpath( |
| 366 | 365 |
'//div[@id="flash"]/div[@class="error"]')) |
| 367 | 366 |
assert_true(response.lxml.xpath( |
| 368 | 367 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 369 |
|
|
| 368 |
|
|
| 370 | 369 |
# On s'assure que le statut de l'évènement corrélé |
| 371 | 370 |
# a bien été mis à jour dans la base de données. |
| 372 | 371 |
correvents = DBSession.query( |
| ... | ... | |
| 383 | 382 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 384 | 383 |
# et un groupe d'hôtes et de services associés à ces items. |
| 385 | 384 |
(hosts, services) = populate_DB() |
| 386 |
|
|
| 385 |
|
|
| 387 | 386 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 388 | 387 |
timestamp = datetime.now() |
| 389 | 388 |
correvent1_id = add_correvent_caused_by(services[0], timestamp) |
| 390 | 389 |
correvent2_id = add_correvent_caused_by(services[1], timestamp) |
| 391 |
|
|
| 390 |
|
|
| 392 | 391 |
transaction.commit() |
| 393 |
|
|
| 392 |
|
|
| 394 | 393 |
### 1er cas : L'utilisateur n'est pas connecté. |
| 395 | 394 |
# On vérifie que le plugin retourne bien une erreur 401. |
| 396 | 395 |
response = self.app.post( |
| ... | ... | |
| 400 | 399 |
"trouble_ticket" : "", |
| 401 | 400 |
"ack" : u'Acknowledged', |
| 402 | 401 |
}, status = 401) |
| 403 |
|
|
| 402 |
|
|
| 404 | 403 |
### 2ème cas : L'utilisateur utilisé pour |
| 405 | 404 |
# se connecter à Vigiboard est 'limited_access'. |
| 406 | 405 |
environ = {'REMOTE_USER': 'limited_access'}
|
| 407 |
|
|
| 406 |
|
|
| 408 | 407 |
# On s'attend à ce qu'une erreur 302 soit renvoyée, et à |
| 409 | 408 |
# ce qu'un message d'erreur précise à l'utilisateur qu'il |
| 410 | 409 |
# n'a pas la permission de modifier ces évènements. |
| ... | ... | |
| 415 | 414 |
"trouble_ticket" : "", |
| 416 | 415 |
"ack" : u'Acknowledged', |
| 417 | 416 |
}, status = 302, extra_environ = environ) |
| 418 |
|
|
| 417 |
|
|
| 419 | 418 |
response = response.follow(status=200, extra_environ = environ) |
| 420 | 419 |
assert_true(response.lxml.xpath( |
| 421 | 420 |
'//div[@id="flash"]/div[@class="error"]')) |
| ... | ... | |
| 423 | 422 |
### 3ème cas : L'utilisateur utilisé pour |
| 424 | 423 |
# se connecter à Vigiboard est 'access'. |
| 425 | 424 |
environ = {'REMOTE_USER': 'access'}
|
| 426 |
|
|
| 425 |
|
|
| 427 | 426 |
# On s'attend à ce que le statut de la requête soit 302, |
| 428 | 427 |
# et à ce qu'un message informe l'utilisateur que les |
| 429 | 428 |
# évènements corrélés sélectionnées ont bien été mis à jour. |
| ... | ... | |
| 434 | 433 |
"trouble_ticket" : "", |
| 435 | 434 |
"ack" : u'Acknowledged', |
| 436 | 435 |
}, status = 302, extra_environ = environ) |
| 437 |
|
|
| 436 |
|
|
| 438 | 437 |
response = response.follow(status=200, extra_environ = environ) |
| 439 | 438 |
assert_false(response.lxml.xpath( |
| 440 | 439 |
'//div[@id="flash"]/div[@class="error"]')) |
| 441 | 440 |
assert_true(response.lxml.xpath( |
| 442 | 441 |
'//div[@id="flash"]/div[@class="ok"]')) |
| 443 |
|
|
| 442 |
|
|
| 444 | 443 |
# On s'assure que le statut de l'évènement corrélé |
| 445 | 444 |
# a bien été mis à jour dans la base de données. |
| 446 | 445 |
correvents = DBSession.query( |
| ... | ... | |
| 456 | 455 |
# On peuple la BDD avec 2 hôtes, 2 services de bas niveau, |
| 457 | 456 |
# et un groupe d'hôtes et de services associés à ces items. |
| 458 | 457 |
(hosts, services) = populate_DB() |
| 459 |
|
|
| 458 |
|
|
| 460 | 459 |
# On ajoute 2 évènements corrélés causés par ces hôtes |
| 461 | 460 |
timestamp = datetime.now() |
| 462 | 461 |
correvent1_id = add_correvent_caused_by(services[0], timestamp) |
| 463 | 462 |
correvent2_id = add_correvent_caused_by(services[1], timestamp) |
| 464 |
|
|
| 465 |
# Date de modification du premier évènement corrélé |
|
| 463 |
|
|
| 464 |
# Date de modification du premier évènement corrélé
|
|
| 466 | 465 |
later_date = datetime.now() |
| 467 | 466 |
# Date du chargement de la page |
| 468 | 467 |
date = mktime(later_date.timetuple()) - 42 |
| 469 |
|
|
| 468 |
|
|
| 470 | 469 |
# On ajoute une entrée dans l'historique de l'évènement brut |
| 471 | 470 |
# causant le premier évènement corrélé, portant pour timestamp |
| 472 | 471 |
# une date postérieure à celle du chargement de la page. |
| ... | ... | |
| 478 | 477 |
idevent = correvent1.idcause, |
| 479 | 478 |
timestamp = later_date)) |
| 480 | 479 |
DBSession.flush() |
| 481 |
|
|
| 480 |
|
|
| 482 | 481 |
transaction.commit() |
| 483 |
|
|
| 482 |
|
|
| 484 | 483 |
# L'utilisateur utilisé pour se connecter à Vigiboard est 'access'. |
| 485 | 484 |
environ = {'REMOTE_USER': 'access'}
|
| 486 |
|
|
| 485 |
|
|
| 487 | 486 |
# On s'attend à ce que le statut de la requête soit 302, et |
| 488 | 487 |
# à ce qu'un message d'erreur avise l'utilisateur que des |
| 489 | 488 |
# changements sont intervenus depuis le chargement de la page. |
| ... | ... | |
| 494 | 493 |
"trouble_ticket" : "", |
| 495 | 494 |
"ack" : u'Acknowledged', |
| 496 | 495 |
}, status = 302, extra_environ = environ) |
| 497 |
|
|
| 496 |
|
|
| 498 | 497 |
response = response.follow(status=200, extra_environ = environ) |
| 499 | 498 |
assert_true(response.lxml.xpath( |
| 500 | 499 |
'//div[@id="flash"]/div[@class="warning"]')) |
| 501 |
|
|
| 500 |
|
|
| 502 | 501 |
# On s'assure que le statut de l'évènement corrélé |
| 503 | 502 |
# n'a pas été modifié dans la base de données. |
| 504 | 503 |
status = DBSession.query( |
| ... | ... | |
| 506 | 505 |
).filter(CorrEvent.idcorrevent == correvent1_id |
| 507 | 506 |
).scalar() |
| 508 | 507 |
assert_equal(status, u'None') |
| 508 |
|
|
| vigiboard/tests/functional/test_search_form_host.py | ||
|---|---|---|
| 8 | 8 |
|
| 9 | 9 |
from vigiboard.tests import TestController |
| 10 | 10 |
from vigilo.models.session import DBSession |
| 11 |
from vigilo.models.tables import Host, Permission, \ |
|
| 11 |
from vigilo.models.tables import SupItemGroup, Host, Permission, \
|
|
| 12 | 12 |
Event, CorrEvent, StateName, \ |
| 13 | 13 |
User, UserGroup, DataPermission |
| 14 |
from vigilo.models.demo.functions import * |
|
| 15 | 14 |
|
| 16 | 15 |
def insert_deps(): |
| 17 | 16 |
"""Insère les dépendances nécessaires aux tests.""" |
| 18 | 17 |
timestamp = datetime.now() |
| 19 | 18 |
|
| 20 |
hostgroup = add_supitemgroup(name=u'foo') |
|
| 19 |
hostgroup = SupItemGroup( |
|
| 20 |
name=u'foo', |
|
| 21 |
) |
|
| 22 |
DBSession.add(hostgroup) |
|
| 23 |
DBSession.flush() |
|
| 21 | 24 |
|
| 22 | 25 |
host = Host( |
| 23 | 26 |
name=u'bar', |
| ... | ... | |
| 150 | 153 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 151 | 154 |
print "There are %d columns in the result set" % len(cols) |
| 152 | 155 |
assert_equal(len(cols), 1) |
| 156 |
|
|
| vigiboard/tests/functional/test_search_form_misc.py | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
from vigiboard.tests import TestController |
| 11 | 11 |
from vigilo.models.session import DBSession |
| 12 |
from vigilo.models.tables import Host, Permission, \ |
|
| 12 |
from vigilo.models.tables import SupItemGroup, Host, Permission, \
|
|
| 13 | 13 |
Event, CorrEvent, StateName, \ |
| 14 | 14 |
User, UserGroup, DataPermission |
| 15 |
from vigilo.models.demo.functions import * |
|
| 16 | 15 |
|
| 17 | 16 |
def insert_deps(): |
| 18 | 17 |
"""Insère les dépendances nécessaires aux tests.""" |
| ... | ... | |
| 32 | 31 |
DBSession.add(host) |
| 33 | 32 |
DBSession.flush() |
| 34 | 33 |
|
| 35 |
hostgroup = add_supitemgroup(name=u'foo')
|
|
| 34 |
hostgroup = SupItemGroup(name=u'foo')
|
|
| 36 | 35 |
hostgroup.supitems.append(host) |
| 36 |
DBSession.add(hostgroup) |
|
| 37 |
DBSession.flush() |
|
| 37 | 38 |
|
| 38 | 39 |
event = Event( |
| 39 | 40 |
supitem=host, |
| ... | ... | |
| 160 | 161 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 161 | 162 |
print "There are %d columns in the result set" % len(cols) |
| 162 | 163 |
assert_true(len(cols) > 1) |
| 164 |
|
|
| vigiboard/tests/functional/test_search_form_service.py | ||
|---|---|---|
| 8 | 8 |
|
| 9 | 9 |
from vigiboard.tests import TestController |
| 10 | 10 |
from vigilo.models.session import DBSession |
| 11 |
from vigilo.models.tables import Host, Permission, \ |
|
| 11 |
from vigilo.models.tables import SupItemGroup, Host, Permission, \
|
|
| 12 | 12 |
StateName, LowLevelService, \ |
| 13 | 13 |
Event, CorrEvent, User, UserGroup, \ |
| 14 | 14 |
DataPermission |
| 15 |
from vigilo.models.demo.functions import * |
|
| 16 | 15 |
|
| 17 | 16 |
def insert_deps(): |
| 18 | 17 |
"""Insère les dépendances nécessaires aux tests.""" |
| 19 | 18 |
timestamp = datetime.now() |
| 20 | 19 |
|
| 21 |
hostgroup = add_supitemgroup(name=u'foo') |
|
| 20 |
hostgroup = SupItemGroup(name=u'foo') |
|
| 21 |
DBSession.add(hostgroup) |
|
| 22 | 22 |
|
| 23 | 23 |
host = Host( |
| 24 | 24 |
name=u'bar', |
| ... | ... | |
| 37 | 37 |
hostgroup.supitems.append(host) |
| 38 | 38 |
DBSession.flush() |
| 39 | 39 |
|
| 40 |
servicegroup = add_supitemgroup(name=u'bar')
|
|
| 40 |
servicegroup = SupItemGroup(name=u'bar')
|
|
| 41 | 41 |
DBSession.add(servicegroup) |
| 42 | 42 |
DBSession.flush() |
| 43 | 43 |
|
| ... | ... | |
| 204 | 204 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 205 | 205 |
print "There are %d columns in the result set" % len(cols) |
| 206 | 206 |
assert_equal(len(cols), 1) |
| 207 |
|
|
| vigiboard/tests/functional/test_search_form_supitemgroup.py | ||
|---|---|---|
| 8 | 8 |
|
| 9 | 9 |
from vigiboard.tests import TestController |
| 10 | 10 |
from vigilo.models.session import DBSession |
| 11 |
from vigilo.models.tables import Host, Permission, StateName, \ |
|
| 11 |
from vigilo.models.tables import SupItemGroup, Host, Permission, StateName, \
|
|
| 12 | 12 |
Event, CorrEvent, User, UserGroup, \ |
| 13 | 13 |
DataPermission |
| 14 |
from vigilo.models.demo.functions import * |
|
| 15 | 14 |
|
| 16 | 15 |
def insert_deps(): |
| 17 | 16 |
"""Insère les dépendances nécessaires aux tests.""" |
| 18 | 17 |
timestamp = datetime.now() |
| 19 | 18 |
|
| 20 |
supitemgroup = add_supitemgroup(name=u'foo') |
|
| 19 |
supitemgroup = SupItemGroup( |
|
| 20 |
name=u'foo', |
|
| 21 |
) |
|
| 22 |
DBSession.add(supitemgroup) |
|
| 23 |
DBSession.flush() |
|
| 21 | 24 |
|
| 22 | 25 |
host = Host( |
| 23 | 26 |
name=u'bar', |
| ... | ... | |
| 157 | 160 |
cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')
|
| 158 | 161 |
print "There are %d columns in the result set" % len(cols) |
| 159 | 162 |
assert_equal(len(cols), 1) |
| 163 |
|
|
| who.ini | ||
|---|---|---|
| 19 | 19 |
[plugin:sqlauth] |
| 20 | 20 |
use = vigilo.turbogears.repoze_plugins:auth_plugin |
| 21 | 21 |
|
| 22 |
;[plugin:kerberos] |
|
| 23 |
;use = repoze.who.plugins.vigilo.kerberos:VigiloKerberosAuthenticator |
|
| 24 |
;ldap_url = ldap://ldap.example.com |
|
| 25 |
;ldap_base = uid=%s,dc=example,dc=com |
|
| 26 |
;filterstr = sAMAccountName=%s |
|
| 27 |
;ldap_charset = cp1252 |
|
| 28 |
;http_charset = utf-8 |
|
| 29 |
;binddn = mybinduser |
|
| 30 |
;bindpw = mybindpassword |
|
| 31 |
|
|
| 32 | 22 |
[general] |
| 23 |
;request_classifier = repoze.who.classifiers:default_request_classifier |
|
| 33 | 24 |
request_classifier = vigilo.turbogears.repoze_plugins:vigilo_api_classifier |
| 34 | 25 |
challenge_decider = repoze.who.classifiers:default_challenge_decider |
| 35 |
;remote_user_key = '' |
|
| 36 | 26 |
|
| 37 | 27 |
[identifiers] |
| 38 | 28 |
plugins = |
Also available in: Unified diff