Project

General

Profile

Statistics
| Branch: | Tag: | Revision:

vigiboard / vigiboard / tests / functional / test_group_selection_tree.py @ ddbaec88

History | View | Annotate | Download (10.4 KB)

1
# -*- coding: utf-8 -*-
2
# Copyright (C) 2006-2011 CS-SI
3
# License: GNU GPL v2 <http://www.gnu.org/licenses/gpl-2.0.html>
4

    
5
"""
6
Teste l'arbre de sélection des groupes du formulaire de recherche
7
"""
8
from nose.tools import assert_true, assert_equal
9
from datetime import datetime
10
import transaction
11

    
12
from vigiboard.tests import TestController
13
from vigilo.models.session import DBSession
14
from vigilo.models.tables import SupItemGroup, Host, Permission, StateName, \
15
                                    Event, CorrEvent, User, UserGroup, \
16
                                    DataPermission
17

    
18
from utils import populate_DB
19

    
20
class TestGroupSelectionTree(TestController):
21
    """Teste l'arbre de sélection des groupes du formulaire de recherche."""
22

    
23
    def setUp(self):
24
        super(TestGroupSelectionTree, self).setUp()
25
        populate_DB()
26

    
27
    def test_get_inexistent_group(self):
28
        """Récupération de l'étage de l'arbre pour un groupe inexistant"""
29

    
30
        # L'utilisateur est authentifié avec des permissions étendues.
31
        # Il cherche à obtenir la liste des groupes fils d'un groupe
32
        # qui n'existe pas, il ne doit donc obtenir aucun résultat.
33
        response = self.app.get('/get_groups?parent_id=%d' % -42,
34
            extra_environ={'REMOTE_USER': 'access'})
35
        json = response.json
36

    
37
        # On s'assure que la liste de groupes retournée est bien vide
38
        self.assertEqual(
39
            json, {'items': [], 'groups': []}
40
        )
41

    
42
        # L'utilisateur est authentifié et fait partie du groupe 'managers'.
43
        # Il cherche à obtenir la liste des groupes fils d'un groupe
44
        # qui n'existe pas, il ne doit donc obtenir aucun résultat.
45
        response = self.app.get('/get_groups?parent_id=%d' % -42,
46
            extra_environ={'REMOTE_USER': 'manager'})
47
        json = response.json
48

    
49
        # On s'assure que la liste de groupes retournée est bien vide
50
        self.assertEqual(
51
            json, {'items': [], 'groups': []}
52
        )
53

    
54
    def test_get_group_anonymous(self):
55
        """Récupération de l'étage de l'arbre en anonyme"""
56
        # Récupération du groupe utilisé lors de ce test.
57
        group2 = SupItemGroup.by_group_name(u'group2')
58

    
59
        # L'utilisateur n'est pas authentifié.
60
        # Il cherche à obtenir la liste des groupes fils d'un groupe donné.
61
        response = self.app.get('/get_groups?parent_id=%d' % group2.idgroup,
62
            status=401)
63

    
64
    def test_get_group_when_not_allowed(self):
65
        """Récupération de l'étage de l'arbre sans les droits"""
66

    
67
        # Récupération du groupe utilisé lors de ce test.
68
        group2 = SupItemGroup.by_group_name(u'group2')
69

    
70
        # L'utilisateur est authentifié avec des permissions
71
        # restreintes. Il cherche à obtenir la liste des groupes fils
72
        # d'un groupe auquel il n'a pas accès, même indirectement.
73
        response = self.app.get('/get_groups?parent_id=%d' % group2.idgroup,
74
            extra_environ={'REMOTE_USER': 'limited_access'})
75
        json = response.json
76

    
77
        # On s'assure que la liste de groupes retournée est bien vide
78
        self.assertEqual(
79
            json, {'items': [], 'groups': []}
80
        )
81

    
82
    def test_get_group_when_allowed(self):
83
        """Récupération de l'étage de l'arbre avec les droits"""
84

    
85
        # Récupération des groupes utilisés lors de ce test.
86
        root = SupItemGroup.by_group_name(u'root')
87
        maingroup = SupItemGroup.by_group_name(u'maingroup')
88
        group1 = SupItemGroup.by_group_name(u'group1')
89
        group2 = SupItemGroup.by_group_name(u'group2')
90

    
91
        # L'utilisateur est authentifié et fait partie du groupe 'managers'.
92
        # Il cherche à obtenir la liste des groupes fils d'un groupe donné.
93
        response = self.app.get('/get_groups?parent_id=%d' % root.idgroup,
94
            extra_environ={'REMOTE_USER': 'manager'})
95
        json = response.json
96

    
97
        # On s'assure que la liste retournée contient
98
        # bien les groupes fils de ce groupe parent
99
        self.assertEqual(
100
            json, {
101
                'items': [],
102
                'groups': [
103
                    {'id': maingroup.idgroup, 'name': maingroup.name, 'type': 'group'}
104
                ]
105
            }
106
        )
107

    
108
        # L'utilisateur est authentifié avec des permissions
109
        # étendues. Il cherche à obtenir la liste des groupes
110
        # fils d'un groupe auquel il a directement accès.
111
        response = self.app.get('/get_groups?parent_id=%d' % root.idgroup,
112
            extra_environ={'REMOTE_USER': 'access'})
113
        json = response.json
114

    
115
        # On s'assure que la liste retournée contient
116
        # bien les groupes fils de ce groupe parent
117
        self.assertEqual(
118
            json, {
119
                'items': [],
120
                'groups': [
121
                    {'id': maingroup.idgroup, 'name': maingroup.name, 'type': 'group'}
122
                ]
123
            }
124
        )
125

    
126
        # Le même utilisateur cherche à obtenir la liste des
127
        # groupes fils d'un groupe auquel il a indirectement accès.
128
        response = self.app.get('/get_groups?parent_id=%d' % maingroup.idgroup,
129
            extra_environ={'REMOTE_USER': 'access'})
130
        json = response.json
131

    
132
        # On s'assure que la liste retournée contient
133
        # bien les groupes fils de ce groupe parent.
134
        self.assertEqual(json, {
135
                'items': [],
136
                'groups': [
137
                    {'id': group1.idgroup, 'name': group1.name, 'type': 'group'},
138
                    {'id': group2.idgroup, 'name': group2.name, 'type': 'group'}
139
                ]
140
            })
141

    
142
        # L'utilisateur est authentifié avec des permissions
143
        # restreintes. Il cherche à obtenir la liste des groupes
144
        # fils d'un groupe auquel il n'a pas accès, mais a toutefois
145
        # le droit d'accéder à un des groupes fils en question.
146
        response = self.app.get('/get_groups?parent_id=%d' % maingroup.idgroup,
147
            extra_environ={'REMOTE_USER': 'limited_access'})
148
        json = response.json
149

    
150
        # On s'assure que la liste retournée contient bien ce groupe fils.
151
        self.assertEqual(
152
            json, {
153
                'items': [],
154
                'groups': [
155
                    {'id': group1.idgroup, 'name': group1.name, 'type': 'group'}
156
                ]
157
            }
158
        )
159

    
160
        # Le même utilisateur cherche à obtenir la liste des groupes
161
        # fils d'un groupe de niveau encore supérieur.
162
        response = self.app.get('/get_groups?parent_id=%d' % root.idgroup,
163
            extra_environ={'REMOTE_USER': 'limited_access'})
164
        json = response.json
165

    
166
        # On s'assure que la liste retournée contient bien
167
        # le groupe parent du groupe auquel il a accès.
168
        self.assertEqual(
169
            json, {
170
                'items': [],
171
                'groups': [
172
                    {'id': maingroup.idgroup, 'name': maingroup.name, 'type': 'group'}
173
                ]
174
            }
175
        )
176

    
177
    def test_get_root_group_when_allowed(self):
178
        """Récupération des groupes racines de l'arbre avec les droits"""
179

    
180
        # Récupération du groupe utilisé lors de ce test.
181
        root = SupItemGroup.by_group_name(u'root')
182

    
183
        # L'utilisateur est authentifié et fait partie du groupe 'managers'.
184
        # Il cherche à obtenir la liste des groupes racines de l'arbre.
185
        response = self.app.get('/get_groups',
186
            extra_environ={'REMOTE_USER': 'manager'})
187
        json = response.json
188

    
189
        # On s'assure que la liste retournée contient bien le groupe racine.
190
        self.assertEqual(
191
            json, {
192
                'items': [],
193
                'groups': [
194
                    {'id': root.idgroup, 'name': root.name, 'type': 'group'}
195
                ]
196
            }
197
        )
198

    
199
        # L'utilisateur est authentifié avec des permissions étendues.
200
        # Il cherche à obtenir la liste des groupes racines de l'arbre.
201
        response = self.app.get('/get_groups',
202
            extra_environ={'REMOTE_USER': 'access'})
203
        json = response.json
204

    
205
        # On s'assure que la liste retournée contient bien le
206
        # groupe racine, auquel cet utilisateur a directement accès.
207
        self.assertEqual(
208
            json, {
209
                'items': [],
210
                'groups': [
211
                    {'id': root.idgroup, 'name': root.name, 'type': 'group'}
212
                ]
213
            }
214
        )
215

    
216
        # L'utilisateur est authentifié avec des permissions restreintes.
217
        # Il cherche à obtenir la liste des groupes racines de l'arbre.
218
        response = self.app.get('/get_groups',
219
            extra_environ={'REMOTE_USER': 'limited_access'})
220
        json = response.json
221

    
222
        # On s'assure que la liste retournée contient bien le
223
        # groupe racine, auquel cet utilisateur a indirectement accès.
224
        self.assertEqual(
225
            json, {
226
                'items': [],
227
                'groups': [
228
                    {'id': root.idgroup, 'name': root.name, 'type': 'group'}
229
                ]
230
            }
231
        )
232

    
233
    def test_get_root_group_anonymous(self):
234
        """Récupération des groupes racines de l'arbre en anonyme"""
235
        # L'utilisateur n'est pas authentifié, et cherche
236
        # à obtenir la liste des groupes racines de l'arbre.
237
        response = self.app.get('/get_groups', status=401)
238

    
239

    
240
    def test_get_root_group_when_not_allowed(self):
241
        """Récupération des groupes racines de l'arbre sans les droits"""
242
        # Récupération du groupe utilisé lors de ce test.
243
        root = SupItemGroup.by_group_name(u'root')
244

    
245
        # Création d'un nouvel utilisateur et d'un nouveau groupe
246
        usergroup = UserGroup(group_name=u'new_users')
247
        vigiboard_perm = Permission.by_permission_name(u'vigiboard-access')
248
        usergroup.permissions.append(vigiboard_perm)
249
        user = User(
250
            user_name=u'new_user',
251
            fullname=u'',
252
            email=u'user.has.no@access',
253
        )
254
        user.usergroups.append(usergroup)
255
        DBSession.add(user)
256
        DBSession.flush()
257
        transaction.commit()
258

    
259
        # L'utilisateur est authentifié mais n'a aucun accès. Il
260
        # cherche à obtenir la liste des groupes racines de l'arbre.
261
        response = self.app.get('/get_groups',
262
            extra_environ={'REMOTE_USER': 'new_user'})
263
        json = response.json
264

    
265
        # On s'assure que la liste retournée est bien vide.
266
        self.assertEqual(
267
            json, {
268
                'items': [],
269
                'groups': []
270
            }
271
        )