Coverage for website/photos/tests/test_views.py: 100.00%

1import os 

2from datetime import date 

3 

4from django.conf import settings 

5from django.core.files.uploadedfile import SimpleUploadedFile 

6from django.test import Client, TestCase, override_settings 

7from django.urls import reverse 

8 

9from members.models import Member, Membership 

10from photos.models import Album, Photo 

11 

12 

13@override_settings(SUSPEND_SIGNALS=True) 

14class AlbumIndexTest(TestCase): 

15 fixtures = ["members.json"] 

16 

17 @classmethod 

18 def setUpTestData(cls): 

19 cls.member = Member.objects.filter(last_name="Wiggers").first() 

20 cls.client = Client() 

21 

22 def setUp(self): 

23 self.client.force_login(self.member) 

24 

25 def test_index(self): 

26 with self.subTest(album_objects__count=Album.objects.count()): 

27 response = self.client.get(reverse("photos:index")) 

28 self.assertEqual(response.status_code, 200) 

29 

30 for i in range(12): 

31 Album.objects.create( 

32 title=f"test_album_a{i}", 

33 date=date(year=2018, month=9, day=5), 

34 slug=f"test_album_a{i}", 

35 ) 

36 

37 with self.subTest(album_objects__count=Album.objects.count()): 

38 response = self.client.get(reverse("photos:index")) 

39 self.assertEqual(response.status_code, 200) 

40 self.assertEqual(len(response.context["albums"]), 12) 

41 self.assertEqual(response.context["page_range"], range(1, 2)) 

42 

43 for i in range(12): 

44 Album.objects.create( 

45 title=f"test_album_b{i}", 

46 date=date(year=2018, month=9, day=5), 

47 slug=f"test_album_b{i}", 

48 ) 

49 

50 with self.subTest(album_objects__count=Album.objects.count()): 

51 response = self.client.get(reverse("photos:index")) 

52 self.assertEqual(response.status_code, 200) 

53 self.assertEqual(len(response.context["albums"]), 16) 

54 self.assertEqual(response.context["page_range"], range(1, 3)) 

55 

56 for i in range(72): 

57 Album.objects.create( 

58 title=f"test_album_c{i}", 

59 date=date(year=2018, month=9, day=5), 

60 slug=f"test_album_c{i}", 

61 ) 

62 

63 with self.subTest(album_objects__count=Album.objects.count()): 

64 response = self.client.get(reverse("photos:index")) 

65 self.assertEqual(response.status_code, 200) 

66 self.assertEqual(len(response.context["albums"]), 16) 

67 self.assertEqual(response.context["page_range"], range(1, 6)) 

68 

69 def test_empty_page(self): 

70 Album.objects.create( 

71 title="test_album", 

72 date=date(year=2018, month=9, day=5), 

73 slug="test_album", 

74 ) 

75 

76 response = self.client.get(reverse("photos:index") + "?page=5") 

77 self.assertEqual(response.status_code, 404) 

78 

79 def test_keywords(self): 

80 Album.objects.create( 

81 title="test_album1", 

82 date=date(year=2018, month=9, day=5), 

83 slug="test_album1", 

84 ) 

85 

86 Album.objects.create( 

87 title="test_album12", 

88 date=date(year=2018, month=9, day=5), 

89 slug="test_album2", 

90 ) 

91 

92 Album.objects.create( 

93 title="test_album3", 

94 date=date(year=2018, month=9, day=5), 

95 slug="test_album3", 

96 ) 

97 

98 for count, keywords in [(3, ""), (2, "1"), (1, "12"), (1, "3")]: 

99 with self.subTest(keywords=keywords): 

100 response = self.client.get( 

101 reverse("photos:index") + f"?keywords={keywords}" 

102 ) 

103 self.assertEqual(response.status_code, 200) 

104 self.assertEqual(len(response.context["albums"]), count) 

105 self.assertEqual(response.context["page_range"], range(1, 2)) 

106 

107 def test_many_pages(self): 

108 for i in range(120): 

109 Album.objects.create( 

110 title=f"test_album_{i}", 

111 date=date(year=2018, month=9, day=5), 

112 slug=f"test_album_{i}", 

113 ) 

114 

115 with self.subTest(page=1): 

116 response = self.client.get(reverse("photos:index") + "?page=1") 

117 self.assertEqual(response.status_code, 200) 

118 self.assertEqual(len(response.context["albums"]), 16) 

119 self.assertEqual(response.context["page_range"], range(1, 6)) 

120 

121 with self.subTest(page=4): 

122 response = self.client.get(reverse("photos:index") + "?page=4") 

123 self.assertEqual(response.status_code, 200) 

124 self.assertEqual(len(response.context["albums"]), 16) 

125 self.assertEqual(response.context["page_range"], range(2, 7)) 

126 

127 with self.subTest(page=8): 

128 response = self.client.get(reverse("photos:index") + "?page=8") 

129 self.assertEqual(response.status_code, 200) 

130 self.assertEqual(len(response.context["albums"]), 8) 

131 self.assertEqual(response.context["page_range"], range(4, 9)) 

132 

133 

134@override_settings(SUSPEND_SIGNALS=True) 

135class AlbumTest(TestCase): 

136 fixtures = ["members.json"] 

137 

138 @classmethod 

139 def setUpTestData(cls): 

140 cls.member = Member.objects.filter(username="testuser").first() 

141 cls.client = Client() 

142 

143 def setUp(self): 

144 self.album = Album.objects.create( 

145 title="test_album", 

146 date=date(year=2017, month=9, day=5), 

147 slug="test_album", 

148 ) 

149 

150 self.client.force_login(self.member) 

151 

152 def test_get(self): 

153 Membership.objects.create( 

154 type=Membership.MEMBER, 

155 user=self.member, 

156 since=date(year=2015, month=1, day=1), 

157 until=None, 

158 ) 

159 

160 for i in range(1, 4): 

161 with open( 

162 os.path.join(settings.BASE_DIR, f"photos/fixtures/poker_{i}.jpg"), 

163 "rb", 

164 ) as f: 

165 fi = SimpleUploadedFile( 

166 name=f"photo{i}.jpg", 

167 content=f.read(), 

168 content_type="image/jpeg", 

169 ) 

170 photo = Photo(album=self.album, file=fi) 

171 photo.save() 

172 

173 response = self.client.get(reverse("photos:album", args=(self.album.slug,))) 

174 self.assertEqual(response.status_code, 200) 

175 self.assertEqual(response.context["album"], self.album) 

176 self.assertEqual(len(response.context["photos"]), 3) 

177 

178 def test_unaccessible(self): 

179 Membership.objects.create( 

180 type=Membership.MEMBER, 

181 user=self.member, 

182 since=date(year=2016, month=1, day=1), 

183 until=date(year=2018, month=1, day=1), 

184 ) 

185 

186 with self.subTest(): 

187 self.album.date = date(year=2017, month=1, day=1) 

188 self.album.save() 

189 

190 response = self.client.get(reverse("photos:album", args=(self.album.slug,))) 

191 self.assertEqual(response.status_code, 200) 

192 

193 with self.subTest(): 

194 self.album.date = date(year=2018, month=9, day=5) 

195 self.album.save() 

196 

197 response = self.client.get(reverse("photos:album", args=(self.album.slug,))) 

198 self.assertEqual(response.status_code, 404) 

199 

200 

201@override_settings(SUSPEND_SIGNALS=True) 

202class SharedAlbumTest(TestCase): 

203 fixtures = ["members.json"] 

204 

205 @classmethod 

206 def setUpTestData(cls): 

207 cls.member = Member.objects.filter(username="testuser").first() 

208 cls.client = Client() 

209 

210 def setUp(self): 

211 self.album = Album.objects.create( 

212 title="test_album", 

213 date=date(year=2017, month=9, day=5), 

214 shareable=True, 

215 slug="test_album", 

216 ) 

217 

218 def test_get(self): 

219 for i in range(1, 4): 

220 with open( 

221 os.path.join(settings.BASE_DIR, f"photos/fixtures/poker_{i}.jpg"), 

222 "rb", 

223 ) as f: 

224 file = SimpleUploadedFile( 

225 name=f"photo{i}.jpg", 

226 content=f.read(), 

227 content_type="image/jpeg", 

228 ) 

229 Photo.objects.create(album=self.album, file=file) 

230 

231 response = self.client.get( 

232 reverse( 

233 "photos:shared-album", 

234 args=( 

235 self.album.slug, 

236 self.album.access_token, 

237 ), 

238 ) 

239 ) 

240 self.assertEqual(response.status_code, 200) 

241 self.assertEqual(response.context["album"], self.album) 

242 self.assertEqual(len(response.context["photos"]), 3) 

243 

244 

245@override_settings(SUSPEND_SIGNALS=True) 

246class DownloadTest(TestCase): 

247 fixtures = ["members.json"] 

248 

249 @classmethod 

250 def setUpTestData(cls): 

251 cls.member = Member.objects.filter(last_name="Wiggers").first() 

252 

253 def setUp(self): 

254 self.client = Client() 

255 

256 self.album = Album.objects.create( 

257 title="test_album", 

258 date=date(year=2017, month=9, day=5), 

259 slug="test_album", 

260 ) 

261 

262 with open( 

263 os.path.join(settings.BASE_DIR, "photos/fixtures/thom_assessor.png"), "rb" 

264 ) as f: 

265 file = SimpleUploadedFile( 

266 name="photo.png", content=f.read(), content_type="image/png" 

267 ) 

268 

269 self.photo = Photo.objects.create(album=self.album, file=file) 

270 

271 def test_download(self): 

272 self.client.force_login(self.member) 

273 

274 response = self.client.get( 

275 reverse( 

276 "photos:download", 

277 args=( 

278 self.album.slug, 

279 self.photo, 

280 ), 

281 ) 

282 ) 

283 self.assertEqual(response.status_code, 302) 

284 self.assertIn( 

285 f"{settings.MEDIA_URL}{self.photo.file.name}", response.headers["Location"] 

286 ) 

287 

288 def test_logged_out(self): 

289 response = self.client.get( 

290 reverse( 

291 "photos:download", 

292 args=( 

293 self.album.slug, 

294 self.photo, 

295 ), 

296 ) 

297 ) 

298 self.assertEqual(response.status_code, 302) 

299 self.assertIn("/user/account/login", response.headers["Location"]) 

300 

301 

302class _DownloadBaseTestCase(TestCase): 

303 def setUp(self): 

304 self.client = Client() 

305 

306 self.album = Album.objects.create( 

307 title="test_album", 

308 date=date(year=2017, month=9, day=5), 

309 slug="test_album", 

310 ) 

311 

312 with open( 

313 os.path.join(settings.BASE_DIR, "photos/fixtures/thom_assessor.png"), "rb" 

314 ) as f: 

315 file = SimpleUploadedFile( 

316 name="photo.png", content=f.read(), content_type="image/png" 

317 ) 

318 

319 self.photo = Photo.objects.create(album=self.album, file=file) 

320 

321 

322@override_settings(SUSPEND_SIGNALS=True) 

323class SharedDownloadTest(_DownloadBaseTestCase): 

324 fixtures = ["members.json"] 

325 

326 @classmethod 

327 def setUpTestData(cls): 

328 cls.member = Member.objects.filter(last_name="Wiggers").first() 

329 cls.client = Client() 

330 

331 def test_download(self): 

332 with self.subTest(): 

333 response = self.client.get( 

334 reverse( 

335 "photos:shared-download", 

336 args=( 

337 self.album.slug, 

338 self.album.access_token, 

339 self.photo, 

340 ), 

341 ) 

342 ) 

343 self.assertEqual(response.status_code, 302) 

344 self.assertIn( 

345 f"{settings.MEDIA_URL}{self.photo.file.name}", 

346 response.headers["Location"], 

347 ) 

348 

349 self.client.force_login(self.member) 

350 

351 with self.subTest(): 

352 response = self.client.get( 

353 reverse( 

354 "photos:shared-download", 

355 args=( 

356 self.album.slug, 

357 self.album.access_token, 

358 self.photo, 

359 ), 

360 ) 

361 ) 

362 self.assertEqual(response.status_code, 302) 

363 self.assertIn( 

364 f"{settings.MEDIA_URL}{self.photo.file.name}", 

365 response.headers["Location"], 

366 )