← Back to branch summary

~salgado/offspring/builder-details

« back to all changes in this revision

Viewing changes to lib/offspring/web/queuemanager/tests/test_models.py

  • Committer: Guilherme Salgado
  • Date: 2011-10-13 17:39:46 UTC
  • mfrom: (50.1.19 private-projects)
  • Revision ID: salgado@canonical.com-20111013173946-ehtanmjh0wdsp7k9
Add support for private projects on models of web.queuemanager

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/offspring/web/queuemanager/tests/test_models.py
 
1
from operator import attrgetter
 
2
 
 
3
from django.contrib.auth.models import AnonymousUser
 
4
from django.test import TestCase
 
5
 
 
6
from offspring.web.queuemanager.models import (
 
7
    BuildRequest,
 
8
    BuildResult,
 
9
    Lexbuilder,
 
10
    Project,
 
11
    Release)
 
12
from offspring.web.queuemanager.tests.factory import factory
 
13
 
 
14
 
 
15
class ProjectTests(TestCase):
 
16
 
 
17
    def test_default_manager(self):
 
18
        # Make sure .all_objects is the default manager or else the admin UI
 
19
        # will exclude all private objects and we would break model validation
 
20
        # of unique fields if the user reuses a value from an object they're
 
21
        # not allowed to see.
 
22
        self.assertEquals(Project.all_objects, Project._default_manager)
 
23
 
 
24
    def test_is_private_for_public_project(self):
 
25
        project = factory.makeProject(is_private=False)
 
26
        self.assertEqual(False, project.is_private)
 
27
 
 
28
    def test_is_private_for_private_project(self):
 
29
        private_project = factory.makeProject(is_private=True)
 
30
        self.assertEqual(True, private_project.is_private)
 
31
 
 
32
    def test_is_visible_to_anyone_if_public(self):
 
33
        project = factory.makeProject(is_private=False)
 
34
        self.assertTrue(project.is_visible_to(AnonymousUser()))
 
35
 
 
36
    def test_is_not_visible_to_anyone_if_private(self):
 
37
        project = factory.makeProject(is_private=True)
 
38
        self.assertFalse(project.is_visible_to(AnonymousUser()))
 
39
 
 
40
    def test_is_visible_to_owner_if_private(self):
 
41
        project = factory.makeProject(is_private=True)
 
42
        self.assertTrue(project.is_visible_to(project.owner))
 
43
 
 
44
    def test_is_visible_to_member_of_access_group_if_private(self):
 
45
        user = factory.makeUser()
 
46
        group = factory.makeAccessGroup([user])
 
47
        project = factory.makeProject(is_private=True, access_groups=[group])
 
48
        self.assertTrue(project.is_visible_to(user))
 
49
 
 
50
    def test_default_model_manager_only_returns_public_projects(self):
 
51
        project = factory.makeProject(is_private=False)
 
52
        project2 = factory.makeProject(is_private=True)
 
53
        self.assertEqual([project], list(Project.objects.all()))
 
54
 
 
55
    def test_all_objects_model_manager(self):
 
56
        # Project.all_objects() is a separate model manager which returns
 
57
        # private objects as well. Its .all() method will return public and
 
58
        # private objects regardless of whether or not the current user has
 
59
        # access to them. It is to be used with caution.
 
60
        project = factory.makeProject(is_private=False)
 
61
        project2 = factory.makeProject(is_private=True)
 
62
        self.assertEqual([project, project2], list(Project.all_objects.all()))
 
63
 
 
64
    def test_accessible_by_user_with_anonymous_user(self):
 
65
        project = factory.makeProject(is_private=True)
 
66
        project2 = factory.makeProject(is_private=False)
 
67
        self.assertEqual(True, project.is_private)
 
68
        self.assertEqual(False, project2.is_private)
 
69
        objects = Project.all_objects.accessible_by_user(AnonymousUser())
 
70
        self.assertEqual([project2], list(objects))
 
71
 
 
72
    def test_accessible_by_user_with_public_project(self):
 
73
        user = factory.makeUser()
 
74
        project = factory.makeProject(is_private=False)
 
75
        self.assertEqual(False, project.is_private)
 
76
        objects = Project.all_objects.accessible_by_user(user)
 
77
        self.assertEqual([project], list(objects))
 
78
 
 
79
    def test_accessible_by_user_with_private_project(self):
 
80
        user = factory.makeUser()
 
81
        group = factory.makeAccessGroup([user])
 
82
        project = factory.makeProject(is_private=True, access_groups=[group])
 
83
        # This second project is private but has no access groups set up, so
 
84
        # the user cannot see it.
 
85
        project2 = factory.makeProject(is_private=True)
 
86
        self.assertEqual(True, project.is_private)
 
87
        self.assertEqual(True, project2.is_private)
 
88
        objects = Project.all_objects.accessible_by_user(user)
 
89
        self.assertEqual([project], list(objects))
 
90
 
 
91
 
 
92
class ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin(object):
 
93
    """A mixin with tests that work for the following models:
 
94
 
 
95
        Release
 
96
        Lexbuilder
 
97
        BuildResult
 
98
        BuildRequest
 
99
 
 
100
    You just need to mix this with TestCase in your subclass and define
 
101
    factoryMethod and model.
 
102
    """
 
103
    model = None
 
104
 
 
105
    def factoryMethod(self, project):
 
106
        raise NotImplementedError()
 
107
 
 
108
    def test_default_manager(self):
 
109
        # Make sure .all_objects is the default manager or else the admin UI
 
110
        # will exclude all private objects and we would break model validation
 
111
        # of unique fields if the user reuses a value from an object they're
 
112
        # not allowed to see.
 
113
        self.assertEquals(self.model.all_objects, self.model._default_manager)
 
114
 
 
115
    def test_is_private_for_public_object(self):
 
116
        public_object = self.factoryMethod(
 
117
            factory.makeProject(is_private=False))
 
118
        self.assertFalse(public_object.is_private)
 
119
 
 
120
    def test_is_private_for_private_object(self):
 
121
        private_object = self.factoryMethod(
 
122
            factory.makeProject(is_private=True))
 
123
        self.assertTrue(private_object.is_private)
 
124
 
 
125
    def test_is_visible_to_anyone_if_public(self):
 
126
        public_object = self.factoryMethod(
 
127
            factory.makeProject(is_private=False))
 
128
        self.assertTrue(public_object.is_visible_to(AnonymousUser()))
 
129
 
 
130
    def test_is_not_visible_to_anyone_if_private(self):
 
131
        private_object = self.factoryMethod(
 
132
            factory.makeProject(is_private=True))
 
133
        self.assertFalse(private_object.is_visible_to(AnonymousUser()))
 
134
 
 
135
    def test_is_visible_to_owner_if_private(self):
 
136
        # The object we're dealing with inherits the access-control rules from
 
137
        # the project it's related to, so the owner that matters is the
 
138
        # project owner.
 
139
        owner = factory.makeUser()
 
140
        private_object = self.factoryMethod(
 
141
            factory.makeProject(is_private=True, owner=owner))
 
142
        self.assertTrue(private_object.is_visible_to(owner))
 
143
 
 
144
    def test_is_visible_to_member_of_access_group_if_private(self):
 
145
        user = factory.makeUser()
 
146
        group = factory.makeAccessGroup([user])
 
147
        private_object = self.factoryMethod(
 
148
            factory.makeProject(is_private=True, access_groups=[group]))
 
149
        self.assertTrue(private_object.is_visible_to(user))
 
150
 
 
151
    def test_default_model_manager_only_returns_public_objects(self):
 
152
        private_object = self.factoryMethod(
 
153
            factory.makeProject(is_private=True))
 
154
        public_object = self.factoryMethod(
 
155
            factory.makeProject(is_private=False))
 
156
        self.assertEqual([public_object], list(self.model.objects.all()))
 
157
 
 
158
    def test_all_objects_model_manager(self):
 
159
        # self.model.all_objects() is a separate model manager which returns
 
160
        # private objects as well. Its .all() method will return public and
 
161
        # private objects regardless of whether or not the current user has
 
162
        # access to them. It is to be used with caution.
 
163
        public_object = self.factoryMethod(
 
164
            project=factory.makeProject(is_private=False))
 
165
        private_object = self.factoryMethod(
 
166
            project=factory.makeProject(is_private=True))
 
167
        self.assertEqual([public_object, private_object],
 
168
                         list(self.model.all_objects.all()))
 
169
 
 
170
    def test_accessible_by_user(self):
 
171
        user = factory.makeUser()
 
172
        group = factory.makeAccessGroup([user])
 
173
        visible_object = self.factoryMethod(
 
174
            factory.makeProject(is_private=True, access_groups=[group]))
 
175
        # This object is linked to a private project which has no access
 
176
        # groups set up, so the user cannot see it.
 
177
        invisible_object = self.factoryMethod(
 
178
            project=factory.makeProject(is_private=True))
 
179
        self.assertEqual(
 
180
            [visible_object],
 
181
            list(self.model.all_objects.accessible_by_user(user)))
 
182
 
 
183
 
 
184
class ReleaseTests(
 
185
    TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
 
186
    model = Release
 
187
 
 
188
    def factoryMethod(self, project):
 
189
        return factory.makeRelease(
 
190
            build=factory.makeBuildResult(project=project))
 
191
 
 
192
 
 
193
class LexbuilderTests(
 
194
        TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
 
195
    model = Lexbuilder
 
196
 
 
197
    def factoryMethod(self, project):
 
198
        return factory.makeLexbuilder(
 
199
            current_job=factory.makeBuildResult(project=project))
 
200
 
 
201
 
 
202
class BuildResultTests(
 
203
        TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
 
204
    model = BuildResult
 
205
    factoryMethod = factory.makeBuildResult
 
206
 
 
207
 
 
208
class BuildRequestTests(
 
209
        TestCase, ReleaseOrLexbuilderOrBuildResultOrBuildRequestTestsMixin):
 
210
    model = BuildRequest
 
211
    factoryMethod = factory.makeBuildRequest
 
212
 
 
213
 
 
214
class ProjectGroupTests(TestCase):
 
215
 
 
216
    def test_get_projects_filters_private_objects(self):
 
217
        user = factory.makeUser()
 
218
        group = factory.makeProjectGroup()
 
219
        public_project = factory.makeProject(
 
220
            is_private=False, project_group=group)
 
221
        private_project_visible_to_user = factory.makeProject(
 
222
            is_private=True, project_group=group, owner=user)
 
223
        private_project = factory.makeProject(
 
224
            is_private=True, project_group=group)
 
225
        self.assertEqual(
 
226
            sorted([public_project, private_project_visible_to_user],
 
227
                   key=attrgetter('name')),
 
228
            sorted(group.get_projects(user), key=attrgetter('name')))