← Back to branch summary

~salgado/offspring/builder-details

« back to all changes in this revision

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

  • Committer: Guilherme Salgado
  • Date: 2011-10-13 17:41:00 UTC
  • mfrom: (50.1.23 private-projects-views)
  • Revision ID: salgado@canonical.com-20111013174100-9a77vs789ebpcwws
Make project and build views return a 404 if the user is not allowed to see that private project/build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/offspring/web/queuemanager/tests/test_views.py
 
1
from django.core.urlresolvers import reverse
 
2
from django.contrib.auth.models import (
 
3
    AnonymousUser,
 
4
    Group,
 
5
    Permission,
 
6
    )
 
7
from django.http import Http404
 
8
from django.test import TestCase
 
9
 
 
10
from offspring.enums import ProjectBuildStates
 
11
from offspring.web.queuemanager.models import (
 
12
    Project,
 
13
    )
 
14
from offspring.web.queuemanager.views import get_possibly_private_object
 
15
from offspring.web.queuemanager.tests.factory import factory
 
16
 
 
17
 
 
18
class Test_get_possibly_private_object(TestCase):
 
19
 
 
20
    def test_public_object(self):
 
21
        obj = factory.makeProject(is_private=False)
 
22
        obj2 = get_possibly_private_object(
 
23
            AnonymousUser(), Project, pk=obj.pk)
 
24
        self.assertEqual(obj.pk, obj2.pk)
 
25
 
 
26
    def test_private_object_for_owner(self):
 
27
        obj = factory.makeProject(is_private=True)
 
28
        obj2 = get_possibly_private_object(obj.owner, Project, pk=obj.pk)
 
29
        self.assertEqual(obj.pk, obj2.pk)
 
30
 
 
31
    def test_private_object_for_user_with_no_access(self):
 
32
        obj = factory.makeProject(is_private=True)
 
33
        user = factory.makeUser()
 
34
        self.assertRaises(
 
35
            Http404, get_possibly_private_object, user, Project, pk=obj.pk)
 
36
 
 
37
 
 
38
class ProjectViewTestsMixin(object):
 
39
    view_path = None
 
40
 
 
41
    def get_expected_page_heading(self, project):
 
42
        raise NotImplementedError()
 
43
 
 
44
    def grant_necessary_permission_to(self, user):
 
45
        pass
 
46
 
 
47
    def test_private_project_visible(self):
 
48
        project = factory.makeProject(is_private=True)
 
49
        user = project.owner
 
50
        self.grant_necessary_permission_to(user)
 
51
        self.assertTrue(
 
52
            self.client.login(username=user.username, password=user.username))
 
53
        response = self.client.get(
 
54
            reverse(self.view_path, args=[project.name]))
 
55
        self.assertContains(
 
56
            response, self.get_expected_page_heading(project),
 
57
            status_code=200, msg_prefix=response.content)
 
58
 
 
59
    def test_private_project_invisible(self):
 
60
        project = factory.makeProject(is_private=True)
 
61
        user = factory.makeUser()
 
62
        self.grant_necessary_permission_to(user)
 
63
        self.assertTrue(
 
64
            self.client.login(username=user.username, password=user.username))
 
65
        response = self.client.get(
 
66
            reverse(self.view_path, args=[project.name]))
 
67
        self.assertEqual(404, response.status_code)
 
68
 
 
69
 
 
70
class ProjectDetailsViewTests(TestCase, ProjectViewTestsMixin):
 
71
    view_path = 'offspring.web.queuemanager.views.project_details'
 
72
 
 
73
    def get_expected_page_heading(self, project):
 
74
        return 'Project Details for %s' % project.title.capitalize()
 
75
 
 
76
    def test_public_project(self):
 
77
        project = factory.makeProject(is_private=False)
 
78
        response = self.client.get(
 
79
            reverse(self.view_path, args=[project.name]))
 
80
        self.assertContains(
 
81
            response, self.get_expected_page_heading(project),
 
82
            status_code=200, msg_prefix=response.content)
 
83
 
 
84
 
 
85
class ProjectEditViewTests(TestCase, ProjectViewTestsMixin):
 
86
    view_path = 'offspring.web.queuemanager.views.project_edit'
 
87
 
 
88
    def get_expected_page_heading(self, project):
 
89
        return 'Update details for %s' % project.title.capitalize()
 
90
 
 
91
    def grant_necessary_permission_to(self, user):
 
92
        grant_permission_to_user(user, 'change_project')
 
93
 
 
94
    def test_public_project(self):
 
95
        project = factory.makeProject(is_private=False)
 
96
        user = factory.makeUser()
 
97
        self.grant_necessary_permission_to(user)
 
98
        self.assertTrue(
 
99
            self.client.login(username=user.username, password=user.username))
 
100
        response = self.client.get(
 
101
            reverse(self.view_path, args=[project.name]))
 
102
        self.assertContains(
 
103
            response, self.get_expected_page_heading(project),
 
104
            status_code=200, msg_prefix=response.content)
 
105
 
 
106
 
 
107
class BuildViewTests(TestCase):
 
108
 
 
109
    def test_public_build(self):
 
110
        project = factory.makeProject(is_private=False)
 
111
        build = factory.makeBuildResult(project=project)
 
112
        response = self.client.get(
 
113
            reverse('offspring.web.queuemanager.views.build_details',
 
114
                    args=[project.name, build.name]))
 
115
        self.assertContains(
 
116
            response, 'Build Details', status_code=200,
 
117
            msg_prefix=response.content)
 
118
 
 
119
    def test_private_build_visible(self):
 
120
        project = factory.makeProject(is_private=True)
 
121
        build = factory.makeBuildResult(project=project)
 
122
        user = project.owner
 
123
        self.assertTrue(
 
124
            self.client.login(username=user.username, password=user.username))
 
125
        response = self.client.get(
 
126
            reverse('offspring.web.queuemanager.views.build_details',
 
127
                    args=[project.name, build.name]))
 
128
        self.assertContains(
 
129
            response, 'Build Details', status_code=200,
 
130
            msg_prefix=response.content)
 
131
 
 
132
    def test_private_build_invisible(self):
 
133
        project = factory.makeProject(is_private=True)
 
134
        build = factory.makeBuildResult(project=project)
 
135
        self.assertTrue(make_user_and_login(self.client))
 
136
        response = self.client.get(
 
137
            reverse('offspring.web.queuemanager.views.build_details',
 
138
                    args=[project.name, build.name]))
 
139
        self.assertEqual(404, response.status_code)
 
140
 
 
141
 
 
142
class BuildPublishViewTests(TestCase):
 
143
 
 
144
    def test_public_build(self):
 
145
        project = factory.makeProject(is_private=False)
 
146
        build = factory.makeBuildResult(
 
147
            project=project, result=ProjectBuildStates.SUCCESS)
 
148
        user = factory.makeUser()
 
149
        grant_permission_to_user(user, 'add_release')
 
150
        self.assertTrue(
 
151
            self.client.login(username=user.username, password=user.username))
 
152
        response = self.client.get(
 
153
            reverse('offspring.web.queuemanager.views.build_publish',
 
154
                    args=[project.name, build.name]))
 
155
        self.assertContains(
 
156
            response, 'Release %s build' % project.title.capitalize(),
 
157
            status_code=200, msg_prefix=response.content)
 
158
 
 
159
    def test_private_build_visible(self):
 
160
        project = factory.makeProject(is_private=True)
 
161
        build = factory.makeBuildResult(
 
162
            project=project, result=ProjectBuildStates.SUCCESS)
 
163
        user = build.project.owner
 
164
        grant_permission_to_user(user, 'add_release')
 
165
        self.assertTrue(
 
166
            self.client.login(username=user.username, password=user.username))
 
167
        response = self.client.get(
 
168
            reverse('offspring.web.queuemanager.views.build_publish',
 
169
                    args=[project.name, build.name]))
 
170
        self.assertContains(
 
171
            response, 'Release %s build' % project.title.capitalize(),
 
172
            status_code=200, msg_prefix=response.content)
 
173
 
 
174
    def test_private_build_invisible(self):
 
175
        project = factory.makeProject(is_private=True)
 
176
        build = factory.makeBuildResult(
 
177
            project=project, result=ProjectBuildStates.SUCCESS)
 
178
        user = factory.makeUser()
 
179
        grant_permission_to_user(user, 'add_release')
 
180
        self.assertTrue(
 
181
            self.client.login(username=user.username, password=user.username))
 
182
        response = self.client.get(
 
183
            reverse('offspring.web.queuemanager.views.build_publish',
 
184
                    args=[project.name, build.name]))
 
185
        self.assertEqual(404, response.status_code)
 
186
 
 
187
 
 
188
def make_user_and_login(client):
 
189
    user = factory.makeUser()
 
190
    return client.login(username=user.username, password=user.username)
 
191
 
 
192
 
 
193
def grant_permission_to_user(user, permission):
 
194
    group = Group(name=user.username)
 
195
    group.save()
 
196
    group.permissions.add(Permission.objects.get(codename=permission))
 
197
    group.save()
 
198
    user.groups.add(group)
 
199
    user.save()
 
200
    return user
 
201