← Back to branch summary

~widelands-dev/widelands-website/django_staticfiles

« back to all changes in this revision

Viewing changes to wlmaps/tests/test_views.py

  • Committer: franku
  • Author(s): GunChleoc
  • Date: 2016-12-13 18:30:38 UTC
  • mfrom: (438.1.6 pyformat_util)
  • Revision ID: somal@arcor.de-20161213183038-5cgmvfh2fkgmoc1s
adding a script to run pyformat over the code base

Show diffs side-by-side

added added

removed removed

Lines of Context:
wlmaps/tests/test_views.py
18
18
###########
19
19
# Helpers #
20
20
###########
 
21
 
 
22
 
21
23
class _LoginToSite(DjangoTest):
 
24
 
22
25
    def setUp(self):
23
 
        u = User.objects.create(username="root", email="root@root.com")
24
 
        u.set_password("root")
 
26
        u = User.objects.create(username='root', email='root@root.com')
 
27
        u.set_password('root')
25
28
        u.save()
26
29
 
27
 
        self.client.login( username="root", password="root")
 
30
        self.client.login(username='root', password='root')
28
31
 
29
32
        self.user = u
30
33
 
34
37
###########
35
38
# Uploads #
36
39
###########
 
40
 
 
41
 
37
42
class TestWLMaps_ValidUpload_ExceptCorrectResult(_LoginToSite):
 
43
 
38
44
    def runTest(self):
39
45
        url = reverse('wlmaps_upload')
40
 
        c = self.client.post(url, {'file': open(elven_forests,"rb"), 'test': True })
 
46
        c = self.client.post(
 
47
            url, {'file': open(elven_forests, 'rb'), 'test': True})
41
48
 
42
49
        o = Map.objects.get(pk=1)
43
 
        self.assertEqual(o.name, "Elven Forests")
44
 
        self.assertEqual(o.author, "Winterwind")
 
50
        self.assertEqual(o.name, 'Elven Forests')
 
51
        self.assertEqual(o.author, 'Winterwind')
 
52
 
 
53
 
45
54
class TestWLMaps_AnonUpload_ExceptRedirect(DjangoTest):
 
55
 
46
56
    def runTest(self):
47
57
        url = reverse('wlmaps_upload')
48
 
        k = self.client.post(url, {'file': open(elven_forests,"rb") })
49
 
        self.assertRedirects( k, reverse('django.contrib.auth.views.login') + '?next=%s' %url )
 
58
        k = self.client.post(url, {'file': open(elven_forests, 'rb')})
 
59
        self.assertRedirects(k, reverse(
 
60
            'django.contrib.auth.views.login') + '?next=%s' % url)
50
61
 
51
62
 
52
63
# Invalid Uploading
53
64
class TestWLMaps_UploadWithoutMap_ExceptError(_LoginToSite):
 
65
 
54
66
    def runTest(self):
55
67
        url = reverse('wlmaps_upload')
56
 
        k = self.client.post(url, {'test': True })
 
68
        k = self.client.post(url, {'test': True})
57
69
        self.assertEqual(len(Map.objects.all()), 0)
 
70
 
 
71
 
58
72
class TestWLMaps_UploadTwice_ExceptCorrectResult(_LoginToSite):
 
73
 
59
74
    def runTest(self):
60
75
        url = reverse('wlmaps_upload')
61
 
        self.client.post(url, {'file': open(elven_forests,"rb"), 'test': True })
62
 
        self.assertEqual(len(Map.objects.all()), 1)
63
 
 
64
 
        self.client.post(url, {'file': open(elven_forests,"rb"), 'test': True })
65
 
        self.assertEqual(len(Map.objects.all()), 1)
 
76
        self.client.post(
 
77
            url, {'file': open(elven_forests, 'rb'), 'test': True})
 
78
        self.assertEqual(len(Map.objects.all()), 1)
 
79
 
 
80
        self.client.post(
 
81
            url, {'file': open(elven_forests, 'rb'), 'test': True})
 
82
        self.assertEqual(len(Map.objects.all()), 1)
 
83
 
 
84
 
66
85
class TestWLMaps_UploadWithInvalidMap_ExceptError(_LoginToSite):
 
86
 
67
87
    def runTest(self):
68
88
        url = reverse('wlmaps_upload')
69
 
        self.client.post(url, {'file': open(__file__,"rb"), 'test': True })
 
89
        self.client.post(url, {'file': open(__file__, 'rb'), 'test': True})
70
90
        self.assertEqual(len(Map.objects.all()), 0)
71
91
 
72
92
# Viewing
 
93
 
 
94
 
73
95
class TestWLMapsViews_Viewing(DjangoTest):
 
96
 
74
97
    def setUp(self):
75
 
        self.user = User.objects.create(username="testuser")
 
98
        self.user = User.objects.create(username='testuser')
76
99
        self.user.save()
77
100
 
78
101
        # Add maps
79
102
        nm = Map.objects.create(
80
 
                        name = "Map",
81
 
                        author = "Author",
82
 
                        w = 128,
83
 
                        h = 64,
84
 
                        nr_players = 4,
85
 
                        descr = "a good map to play with",
86
 
                        minimap = "/wlmaps/minimaps/Map.png",
87
 
                        world_name = "blackland",
 
103
            name='Map',
 
104
            author='Author',
 
105
            w=128,
 
106
            h=64,
 
107
            nr_players=4,
 
108
            descr='a good map to play with',
 
109
            minimap='/wlmaps/minimaps/Map.png',
 
110
            world_name='blackland',
88
111
 
89
 
                        uploader = self.user,
90
 
                        uploader_comment = "Rockdamap"
 
112
            uploader=self.user,
 
113
            uploader_comment='Rockdamap'
91
114
        )
92
115
        nm.save()
93
116
        self.map = nm
94
117
        nm = Map.objects.create(
95
 
                        name = "Map with a long slug",
96
 
                        author = "Author Paul",
97
 
                        w = 128,
98
 
                        h = 64,
99
 
                        nr_players = 4,
100
 
                        descr = "a good map to play with",
101
 
                        minimap = "/wlmaps/minimaps/Map with long slug.png",
102
 
                        world_name = "blackland",
 
118
            name='Map with a long slug',
 
119
            author='Author Paul',
 
120
            w=128,
 
121
            h=64,
 
122
            nr_players=4,
 
123
            descr='a good map to play with',
 
124
            minimap='/wlmaps/minimaps/Map with long slug.png',
 
125
            world_name='blackland',
103
126
 
104
 
                        uploader = self.user,
105
 
                        uploader_comment = "Rockdamap"
 
127
            uploader=self.user,
 
128
            uploader_comment='Rockdamap'
106
129
        )
107
130
        nm.save()
108
131
        self.map1 = nm
109
132
 
110
133
    def test_ViewingValidMap_ExceptCorrectResult(self):
111
 
        c = self.client.get(reverse("wlmaps_view",args=("map-with-a-long-slug",)))
112
 
        self.assertEqual(c.status_code, 200 )
113
 
        self.assertEqual(c.context["object"], Map.objects.get(slug="map-with-a-long-slug"))
114
 
        self.assertTemplateUsed( c, 'wlmaps/map_detail.html' )
 
134
        c = self.client.get(
 
135
            reverse('wlmaps_view', args=('map-with-a-long-slug',)))
 
136
        self.assertEqual(c.status_code, 200)
 
137
        self.assertEqual(c.context['object'], Map.objects.get(
 
138
            slug='map-with-a-long-slug'))
 
139
        self.assertTemplateUsed(c, 'wlmaps/map_detail.html')
115
140
 
116
141
    def test_ViewingNonExistingMap_Except404(self):
117
 
        c = self.client.get(reverse("wlmaps_view",args=("a-map-that-doesnt-exist",)))
118
 
        self.assertEqual(c.status_code, 404 )
 
142
        c = self.client.get(
 
143
            reverse('wlmaps_view', args=('a-map-that-doesnt-exist',)))
 
144
        self.assertEqual(c.status_code, 404)
119
145
 
120
146
 
121
147
############
122
148
#  RATING  #
123
149
############
124
150
class TestWLMapsViews_Rating(_LoginToSite):
 
151
 
125
152
    def setUp(self):
126
153
        _LoginToSite.setUp(self)
127
154
 
128
155
        # Add maps
129
156
        nm = Map.objects.create(
130
 
                        name = "Map",
131
 
                        author = "Author",
132
 
                        w = 128,
133
 
                        h = 64,
134
 
                        nr_players = 4,
135
 
                        descr = "a good map to play with",
136
 
                        minimap = "/wlmaps/minimaps/Map.png",
137
 
                        world_name = "blackland",
 
157
            name='Map',
 
158
            author='Author',
 
159
            w=128,
 
160
            h=64,
 
161
            nr_players=4,
 
162
            descr='a good map to play with',
 
163
            minimap='/wlmaps/minimaps/Map.png',
 
164
            world_name='blackland',
138
165
 
139
 
                        uploader = self.user,
140
 
                        uploader_comment = "Rockdamap"
 
166
            uploader=self.user,
 
167
            uploader_comment='Rockdamap'
141
168
        )
142
169
        nm.save()
143
170
        self.map = nm
144
171
 
145
172
    def test_RatingNonExistingMap_Except404(self):
146
173
        c = self.client.post(
147
 
            reverse("wlmaps_rate",args=("a-map-that-doesnt-exist",)),
148
 
            { "vote": 10 } )
149
 
        self.assertEqual(c.status_code, 404 )
 
174
            reverse('wlmaps_rate', args=('a-map-that-doesnt-exist',)),
 
175
            {'vote': 10})
 
176
        self.assertEqual(c.status_code, 404)
150
177
 
151
178
    def test_RatingGet_Except405(self):
152
179
        c = self.client.get(
153
 
            reverse("wlmaps_rate",args=("map",)),
154
 
            { "vote": 10 } )
155
 
        self.assertEqual(c.status_code, 405 )
 
180
            reverse('wlmaps_rate', args=('map',)),
 
181
            {'vote': 10})
 
182
        self.assertEqual(c.status_code, 405)
156
183
 
157
184
    def test_RatingInvalidValue_Except400(self):
158
185
        c = self.client.post(
159
 
            reverse("wlmaps_rate",args=("map",)),
160
 
            { "vote": 11 } )
161
 
        self.assertEqual(c.status_code, 400 )
 
186
            reverse('wlmaps_rate', args=('map',)),
 
187
            {'vote': 11})
 
188
        self.assertEqual(c.status_code, 400)
162
189
 
163
190
    def test_RatingNonIntegerValue_Except400(self):
164
191
        c = self.client.post(
165
 
            reverse("wlmaps_rate",args=("map",)),
166
 
            { "vote": "shubidu" } )
167
 
        self.assertEqual(c.status_code, 400 )
 
192
            reverse('wlmaps_rate', args=('map',)),
 
193
            {'vote': 'shubidu'})
 
194
        self.assertEqual(c.status_code, 400)
168
195
 
169
196
    def test_RatingExistingMap_ExceptCorrectResult(self):
170
197
        c = self.client.post(
171
 
            reverse("wlmaps_rate",args=("map",)),
172
 
            { "vote": 7 } )
 
198
            reverse('wlmaps_rate', args=('map',)),
 
199
            {'vote': 7})
173
200
        # Except redirect
174
 
        self.assertEqual(c.status_code, 302 )
 
201
        self.assertEqual(c.status_code, 302)
175
202
 
176
203
        # We have to refetch this map, because
177
204
        # votes doesn't hit the database
178
 
        m = Map.objects.get(slug="map")
 
205
        m = Map.objects.get(slug='map')
179
206
 
180
207
        self.assertEqual(m.rating.votes, 1)
181
208
        self.assertEqual(m.rating.score, 7)
182
 
 
183
 
 
184
 
 
185