← Back to branch summary

~ubuntu-branches/debian/jessie/lava-server/jessie

« back to all changes in this revision

Viewing changes to dashboard_app/tests/models/test_bundle_stream.py

  • Committer: Package Import Robot
  • Author(s): Neil Williams
  • Date: 2014-06-29 19:29:34 UTC
  • Revision ID: package-import@ubuntu.com-20140629192934-ue8hrzzpye9isevt
Tags: upstream-2014.05.30.09
Import upstream version 2014.05.30.09

Show diffs side-by-side

added added

removed removed

Lines of Context:
dashboard_app/tests/models/test_bundle_stream.py
 
1
# Copyright (C) 2010 Linaro Limited
 
2
#
 
3
# Author: Zygmunt Krynicki <zygmunt.krynicki@linaro.org>
 
4
#
 
5
# This file is part of Launch Control.
 
6
#
 
7
# Launch Control is free software: you can redistribute it and/or modify
 
8
# it under the terms of the GNU Affero General Public License version 3
 
9
# as published by the Free Software Foundation
 
10
#
 
11
# Launch Control is distributed in the hope that it will be useful,
 
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
# GNU General Public License for more details.
 
15
#
 
16
# You should have received a copy of the GNU Affero General Public License
 
17
# along with Launch Control.  If not, see <http://www.gnu.org/licenses/>.
 
18
 
 
19
"""
 
20
Tests for the BundleStream model
 
21
"""
 
22
 
 
23
from django.contrib.auth.models import User, Group
 
24
from django.core.exceptions import PermissionDenied
 
25
from django.db import IntegrityError
 
26
from django_testscenarios.ubertest import TestCase, TestCaseWithScenarios
 
27
 
 
28
from dashboard_app.models import BundleStream
 
29
from dashboard_app.tests import fixtures
 
30
 
 
31
 
 
32
class BundleStreamTests(TestCaseWithScenarios):
 
33
 
 
34
    _NAME = "name"
 
35
    _SLUG = "slug"
 
36
    _GROUPNAME = "group"
 
37
    _USERNAME = "user"
 
38
 
 
39
    scenarios = [
 
40
        ('anonymous-no-slug', {
 
41
            'pathname': '/anonymous/',
 
42
            'is_public': "true",
 
43
            'is_anonymous': "true",
 
44
            'username': "user",
 
45
        }),
 
46
        ('anonymous-with-slug', {
 
47
            'name': _NAME,
 
48
            'slug': _SLUG,
 
49
            'is_public': "true",
 
50
            'is_anonymous': "true",
 
51
            'pathname': '/anonymous/slug/',
 
52
            'username': "user",
 
53
        }),
 
54
        ('personal-no-slug', {
 
55
            'username': _USERNAME,
 
56
            'pathname': '/private/personal/user/',
 
57
        }),
 
58
        ('personal-with-slug', {
 
59
            'username': _USERNAME,
 
60
            'name': _NAME,
 
61
            'slug': _SLUG,
 
62
            'pathname': '/private/personal/user/slug/',
 
63
        }),
 
64
        ('team-no-slug', {
 
65
            'groupname': _GROUPNAME,
 
66
            'pathname': '/private/team/group/',
 
67
        }),
 
68
        ('team-with-slug', {
 
69
            'groupname': _GROUPNAME,
 
70
            'name': _NAME,
 
71
            'slug': _SLUG,
 
72
            'pathname': '/private/team/group/slug/',
 
73
        }),
 
74
    ]
 
75
 
 
76
    groupname = None
 
77
    username = None
 
78
    group = None
 
79
    user = None
 
80
    name = ''
 
81
    slug = ''
 
82
    is_public = 0
 
83
    is_anonymous = 0
 
84
 
 
85
    def setUp(self):
 
86
        super(BundleStreamTests, self).setUp()
 
87
        if self.username is not None:
 
88
            self.user = User.objects.create(username='user')
 
89
        if self.groupname is not None:
 
90
            self.group = Group.objects.create(name='group')
 
91
 
 
92
    def test_creation(self):
 
93
        bundle_stream = BundleStream.objects.create(
 
94
            user=self.user,
 
95
            group=self.group,
 
96
            name=self.name,
 
97
            is_anonymous=False,
 
98
            is_public=False,
 
99
            slug=self.slug)
 
100
        bundle_stream.save()
 
101
        self.assertEqual(bundle_stream.user, self.user)
 
102
        self.assertEqual(bundle_stream.group, self.group)
 
103
        self.assertEqual(bundle_stream.name, self.name)
 
104
        self.assertEqual(bundle_stream.slug, self.slug)
 
105
 
 
106
    def test_team_named_stream(self):
 
107
        bundle_stream = BundleStream.objects.create(
 
108
            user=self.user, group=self.group, name=self.name, slug=self.slug,
 
109
            is_anonymous=self.is_anonymous, is_public=self.is_public)
 
110
        bundle_stream.save()
 
111
        self.assertEqual(bundle_stream.pathname, self.pathname)
 
112
 
 
113
    def test_pathname_uniqueness(self):
 
114
        bundle_stream = BundleStream.objects.create(
 
115
            user=self.user,
 
116
            group=self.group,
 
117
            name=self.name,
 
118
            is_anonymous=False,
 
119
            is_public=False,
 
120
            slug=self.slug)
 
121
        bundle_stream.save()
 
122
        self.assertRaises(
 
123
            IntegrityError,
 
124
            BundleStream.objects.create,
 
125
            user=self.user, group=self.group, slug=self.slug,
 
126
            name=self.name
 
127
        )
 
128
 
 
129
    def test_pathname_update(self):
 
130
        bundle_stream = BundleStream.objects.create(
 
131
            user=self.user,
 
132
            group=self.group,
 
133
            name=self.name,
 
134
            is_anonymous=False,
 
135
            is_public=False,
 
136
            slug=self.slug)
 
137
        bundle_stream.save()
 
138
        old_pathname = bundle_stream.pathname
 
139
        bundle_stream.slug += "-changed"
 
140
        bundle_stream.save()
 
141
        self.assertNotEqual(bundle_stream.pathname, old_pathname)
 
142
        self.assertEqual(
 
143
            bundle_stream.pathname,
 
144
            bundle_stream._calc_pathname()
 
145
        )
 
146
 
 
147
    def test_unicode(self):
 
148
        obj = BundleStream(pathname=self.pathname)
 
149
        self.assertEqual(unicode(obj), self.pathname)
 
150
 
 
151
 
 
152
class BundleStreamPermissionTests(TestCase):
 
153
 
 
154
    def test_can_upload_to_anonymous(self):
 
155
        user = User.objects.create(username='user')
 
156
        bundle_stream = fixtures.create_bundle_stream("/anonymous/")
 
157
        self.assertTrue(bundle_stream.can_upload(user))
 
158
 
 
159
    def test_can_upload_to_owned_stream(self):
 
160
        bundle_stream = fixtures.create_bundle_stream("/public/personal/owner/")
 
161
        user = User.objects.get(username='owner')
 
162
        self.assertTrue(bundle_stream.can_upload(user))
 
163
 
 
164
    def test_can_upload_to_other_stream(self):
 
165
        bundle_stream = fixtures.create_bundle_stream("/public/personal/owner/")
 
166
        user = User.objects.create(username='non-owner')
 
167
        self.assertFalse(bundle_stream.can_upload(user))
 
168
 
 
169
    def test_group_can_upload_to_owned(self):
 
170
        group = Group.objects.create(name='group')
 
171
        member = User.objects.create(username="member")
 
172
        group.user_set.add(member)
 
173
        other = User.objects.create(username="other")
 
174
        bundle_stream = fixtures.create_bundle_stream("/public/team/group/basic/")
 
175
        self.assertTrue(bundle_stream.can_upload(member))
 
176
        self.assertFalse(bundle_stream.can_upload(other))
 
177
 
 
178
    def test_create_from_pathname_permission_denied_user(self):
 
179
        user = User.objects.get_or_create(username="non-owner")[0]
 
180
        self.assertRaises(
 
181
            PermissionDenied,
 
182
            BundleStream.create_from_pathname,
 
183
            "/private/personal/owner/name/", user)
 
184
 
 
185
    def test_create_from_pathname_permission_denied_group(self):
 
186
        user = User.objects.get_or_create(username="non-owner")[0]
 
187
        self.assertRaises(
 
188
            PermissionDenied,
 
189
            BundleStream.create_from_pathname,
 
190
            "/public/team/group/name/", user)
 
191
 
 
192
    def test_create_from_pathname_permission_denied_anonymous(self):
 
193
        self.assertRaises(
 
194
            PermissionDenied,
 
195
            BundleStream.create_from_pathname,
 
196
            "/public/team/group/name/", user=None)
 
197
 
 
198
    def test_create_from_pathname(self):
 
199
        user = User.objects.get_or_create(username="owner")[0]
 
200
        bundle_stream = BundleStream.create_from_pathname(
 
201
            "/private/personal/owner/name/", user)
 
202
        self.assertEqual(bundle_stream.pathname,
 
203
                         "/private/personal/owner/name/")
 
204
        group = Group.objects.create(name='group')
 
205
        group.user_set.add(user)
 
206
        bundle_stream = BundleStream.create_from_pathname(
 
207
            "/private/team/group/name/", user)
 
208
        self.assertEqual(bundle_stream.pathname, "/private/team/group/name/")
 
209
        bundle_stream = BundleStream.create_from_pathname(
 
210
            "/anonymous/name/", user=None)
 
211
        self.assertEqual(bundle_stream.pathname, "/anonymous/name/")
 
212
 
 
213
    def test_create_from_pathname_permission_denied_integrity(self):
 
214
        BundleStream.create_from_pathname("/anonymous/name/", user=None)
 
215
        self.assertRaises(
 
216
            IntegrityError,
 
217
            BundleStream.create_from_pathname,
 
218
            "/anonymous/name/", user=None)