Coverage for tests / store / tests_public_logic.py: 100%

1import unittest 

2 

3import datetime 

4from freezegun import freeze_time 

5import webapp.store.logic as logic 

6 

7 

8class StoreLogicTest(unittest.TestCase): 

9 # convert_channel_maps 

10 # === 

11 def test_empty_channel_map(self): 

12 channel_maps_list = [] 

13 result = logic.convert_channel_maps(channel_maps_list) 

14 

15 self.assertEqual(result, {}) 

16 

17 def test_one_track_channel_map(self): 

18 channel_maps_list = [ 

19 { 

20 "channel": { 

21 "name": "channel", 

22 "architecture": "arch", 

23 "track": "track", 

24 "risk": "risk", 

25 "released-at": "2019-01-12T16:48:41.821037+00:00", 

26 }, 

27 "created-at": "2019-01-12T16:48:41.821037+00:00", 

28 "confinement": "confinement", 

29 "download": {"size": "size"}, 

30 "version": "version", 

31 "revision": "revision", 

32 } 

33 ] 

34 

35 result = logic.convert_channel_maps(channel_maps_list) 

36 expected_result = { 

37 "arch": { 

38 "track": [ 

39 { 

40 "channel": "channel", 

41 "released-at": "12 January 2019", 

42 "confinement": "confinement", 

43 "size": "size", 

44 "risk": "risk", 

45 "version": "version", 

46 "revision": "revision", 

47 } 

48 ] 

49 } 

50 } 

51 

52 self.assertEqual(result, expected_result) 

53 

54 def test_multiple_track_same_arch_channel_map(self): 

55 channel_maps_list = [ 

56 { 

57 "channel": { 

58 "name": "channel", 

59 "architecture": "arch", 

60 "track": "track", 

61 "risk": "risk", 

62 "released-at": "2019-01-12T16:48:41.821037+00:00", 

63 }, 

64 "created-at": "2019-01-12T16:48:41.821037+00:00", 

65 "confinement": "confinement", 

66 "download": {"size": "size"}, 

67 "version": "version", 

68 "revision": "revision", 

69 }, 

70 { 

71 "channel": { 

72 "name": "channel", 

73 "architecture": "arch", 

74 "track": "track1", 

75 "risk": "risk", 

76 "released-at": "2019-01-12T16:48:41.821037+00:00", 

77 }, 

78 "created-at": "2019-01-12T16:48:41.821037+00:00", 

79 "confinement": "confinement", 

80 "download": {"size": "size"}, 

81 "version": "version", 

82 "revision": "revision", 

83 }, 

84 ] 

85 result = logic.convert_channel_maps(channel_maps_list) 

86 expected_result = { 

87 "arch": { 

88 "track": [ 

89 { 

90 "channel": "channel", 

91 "released-at": "12 January 2019", 

92 "confinement": "confinement", 

93 "size": "size", 

94 "risk": "risk", 

95 "version": "version", 

96 "revision": "revision", 

97 } 

98 ], 

99 "track1": [ 

100 { 

101 "channel": "channel", 

102 "released-at": "12 January 2019", 

103 "confinement": "confinement", 

104 "size": "size", 

105 "risk": "risk", 

106 "version": "version", 

107 "revision": "revision", 

108 } 

109 ], 

110 } 

111 } 

112 

113 self.assertEqual(result, expected_result) 

114 

115 def test_multiple_track_different_arch_channel_map(self): 

116 channel_maps_list = [ 

117 { 

118 "channel": { 

119 "name": "channel", 

120 "architecture": "arch", 

121 "track": "track", 

122 "risk": "risk", 

123 "released-at": "2019-01-12T16:48:41.821037+00:00", 

124 }, 

125 "created-at": "2019-01-12T16:48:41.821037+00:00", 

126 "confinement": "confinement", 

127 "download": {"size": "size"}, 

128 "version": "version", 

129 "revision": "revision", 

130 }, 

131 { 

132 "channel": { 

133 "name": "channel", 

134 "architecture": "arch1", 

135 "track": "track", 

136 "risk": "risk", 

137 "released-at": "2019-01-12T16:48:41.821037+00:00", 

138 }, 

139 "created-at": "2019-01-12T16:48:41.821037+00:00", 

140 "confinement": "confinement", 

141 "download": {"size": "size"}, 

142 "version": "version", 

143 "revision": "revision", 

144 }, 

145 ] 

146 

147 result = logic.convert_channel_maps(channel_maps_list) 

148 expected_result = { 

149 "arch": { 

150 "track": [ 

151 { 

152 "channel": "channel", 

153 "released-at": "12 January 2019", 

154 "confinement": "confinement", 

155 "size": "size", 

156 "risk": "risk", 

157 "version": "version", 

158 "revision": "revision", 

159 } 

160 ] 

161 }, 

162 "arch1": { 

163 "track": [ 

164 { 

165 "channel": "channel", 

166 "released-at": "12 January 2019", 

167 "confinement": "confinement", 

168 "size": "size", 

169 "risk": "risk", 

170 "version": "version", 

171 "revision": "revision", 

172 } 

173 ] 

174 }, 

175 } 

176 

177 self.assertEqual(result, expected_result) 

178 

179 def test_get_lowest_available_risk(self): 

180 channel_map = {"arch": {"track": [{"risk": "edge"}]}} 

181 edge_result = logic.get_lowest_available_risk(channel_map, "track") 

182 self.assertEqual(edge_result, "edge") 

183 

184 channel_map["arch"]["track"].append({"risk": "beta"}) 

185 beta_result = logic.get_lowest_available_risk(channel_map, "track") 

186 self.assertEqual(beta_result, "beta") 

187 

188 channel_map["arch"]["track"].append({"risk": "candidate"}) 

189 cand_result = logic.get_lowest_available_risk(channel_map, "track") 

190 self.assertEqual(cand_result, "candidate") 

191 

192 channel_map["arch"]["track"].append({"risk": "stable"}) 

193 stable_result = logic.get_lowest_available_risk(channel_map, "track") 

194 self.assertEqual(stable_result, "stable") 

195 

196 # assert that channel_map has been updated successfully 

197 self.assertEqual( 

198 channel_map, 

199 { 

200 "arch": { 

201 "track": [ 

202 {"risk": "edge"}, 

203 {"risk": "beta"}, 

204 {"risk": "candidate"}, 

205 {"risk": "stable"}, 

206 ] 

207 } 

208 }, 

209 ) 

210 

211 def test_get_version(self): 

212 channel_map = { 

213 "arch": { 

214 "track": [ 

215 {"risk": "edge", "version": "12"}, 

216 {"risk": "stable", "version": "10"}, 

217 ] 

218 } 

219 } 

220 edge_version = logic.extract_info_channel_map( 

221 channel_map, "track", "edge" 

222 )["version"] 

223 self.assertEqual(edge_version, "12") 

224 

225 stable_version = logic.extract_info_channel_map( 

226 channel_map, "track", "stable" 

227 )["version"] 

228 self.assertEqual(stable_version, "10") 

229 

230 def test_get_no_version(self): 

231 channel_map = { 

232 "arch": {"track": [{"risk": "stable", "version": "10"}]} 

233 } 

234 no_version = logic.extract_info_channel_map( 

235 channel_map, "track", "edge" 

236 )["version"] 

237 self.assertEqual(no_version, None) 

238 

239 def test_get_confinement(self): 

240 channel_map = { 

241 "arch": { 

242 "track": [ 

243 {"risk": "edge", "confinement": "classic"}, 

244 {"risk": "stable", "confinement": "strict"}, 

245 ] 

246 } 

247 } 

248 classic_result = logic.extract_info_channel_map( 

249 channel_map, "track", "edge" 

250 )["confinement"] 

251 self.assertEqual(classic_result, "classic") 

252 

253 strict_result = logic.extract_info_channel_map( 

254 channel_map, "track", "stable" 

255 )["confinement"] 

256 self.assertEqual(strict_result, "strict") 

257 

258 def test_get_no_confinement(self): 

259 channel_map = { 

260 "arch": {"track": [{"risk": "stable", "confinement": "strict"}]} 

261 } 

262 no_version = logic.extract_info_channel_map( 

263 channel_map, "track", "edge" 

264 )["confinement"] 

265 self.assertEqual(no_version, None) 

266 

267 def test_get_categories(self): 

268 categories = { 

269 "categories": [ 

270 {"name": "featured"}, 

271 {"name": "test"}, 

272 {"name": "development"}, 

273 ] 

274 } 

275 category_list = logic.get_categories(categories) 

276 self.assertTrue( 

277 {"name": "Development", "slug": "development"} in category_list 

278 ) 

279 self.assertTrue({"name": "Games", "slug": "games"} in category_list) 

280 self.assertTrue({"name": "Test", "slug": "test"} in category_list) 

281 

282 def test_get_video_embed_code(self): 

283 youtube_url = "https://youtube.com/watch?v=123" 

284 embed = logic.get_video_embed_code(youtube_url) 

285 self.assertEqual( 

286 embed, 

287 { 

288 "type": "youtube", 

289 "url": "https://youtube.com/embed/123", 

290 "id": "123", 

291 }, 

292 ) 

293 

294 youtu_be_url = "https://youtu.be/123" 

295 embed = logic.get_video_embed_code(youtu_be_url) 

296 self.assertEqual( 

297 embed, 

298 { 

299 "type": "youtube", 

300 "url": "https://youtube.com/embed/123", 

301 "id": "123", 

302 }, 

303 ) 

304 

305 vimeo_url = "https://vimeo.com/123123" 

306 embed = logic.get_video_embed_code(vimeo_url) 

307 self.assertEqual( 

308 embed, 

309 { 

310 "type": "vimeo", 

311 "url": "https://player.vimeo.com/video/123123", 

312 "id": "123123", 

313 }, 

314 ) 

315 

316 asciicinema_url = "https://asciinema.org/a/123" 

317 embed = logic.get_video_embed_code(asciicinema_url) 

318 self.assertEqual( 

319 embed, 

320 { 

321 "type": "asciinema", 

322 "url": "https://asciinema.org/a/123.js", 

323 "id": "123", 

324 }, 

325 ) 

326 

327 def test_convert_date_more_than_yesterday(self): 

328 date_test = "2019-01-12T16:48:41.821037+00:00" 

329 result = logic.convert_date(date_test) 

330 

331 self.assertEqual(result, "12 January 2019") 

332 

333 def test_convert_date_more_today(self): 

334 date_test = datetime.datetime.now().strftime("%Y-%m-%d") 

335 result = logic.convert_date(date_test) 

336 

337 self.assertEqual(result, "Today") 

338 

339 @freeze_time("2021-05-12 10:38:34", tz_offset=-6) 

340 def test_convert_date_timezone_yesterday(self): 

341 date_test = "2021-05-11T10:48:41.821037-06:00" 

342 result = logic.convert_date(date_test) 

343 

344 self.assertEqual(result, "Yesterday") 

345 

346 def test_get_snap_banner(self): 

347 snap_with_banner = { 

348 "media": [ 

349 {"type": "icon", "url": "icon.png"}, 

350 {"type": "banner", "url": "banner.png"}, 

351 {"type": "screenshot", "url": "screenshot.png"}, 

352 ] 

353 } 

354 

355 result = logic.get_snap_banner_url(snap_with_banner) 

356 

357 self.assertEqual(result.get("banner_url"), "banner.png") 

358 

359 def test_get_snap_banner_no_banner(self): 

360 snap_with_banner = { 

361 "media": [ 

362 {"type": "icon", "url": "icon.png"}, 

363 {"type": "screenshot", "url": "screenshot.png"}, 

364 ] 

365 } 

366 

367 result = logic.get_snap_banner_url(snap_with_banner) 

368 

369 self.assertEqual(result.get("banner_url"), None) 

370 

371 def test_get_latest_versions(self): 

372 latest_stable = { 

373 "channel": { 

374 "architecture": "amd64", 

375 "risk": "stable", 

376 "track": "latest", 

377 "released-at": "2023-02-02", 

378 } 

379 } 

380 

381 latest_edge = { 

382 "channel": { 

383 "architecture": "amd64", 

384 "risk": "edge", 

385 "track": "latest", 

386 "released-at": "2023-03-01", 

387 } 

388 } 

389 

390 latest_stable_arm = { 

391 "channel": { 

392 "architecture": "arm64", 

393 "released-at": "2023-01-04", 

394 "risk": "candidate", 

395 "track": "latest", 

396 } 

397 } 

398 

399 channel_map_single_channel = [latest_stable] 

400 

401 channel_map_stable_first = [latest_stable, latest_edge] 

402 

403 channel_map_stable_second = [latest_edge, latest_stable] 

404 

405 channel_map_multiple_stable_architectures = [ 

406 latest_edge, 

407 latest_stable, 

408 latest_stable_arm, 

409 ] 

410 

411 single_result = logic.get_latest_versions( 

412 channel_map_single_channel, "latest", "stable" 

413 ) 

414 self.assertEqual( 

415 single_result[0]["released-at-display"], "2 February 2023" 

416 ) 

417 self.assertEqual(single_result[1], None) 

418 

419 stable_first_result = logic.get_latest_versions( 

420 channel_map_stable_first, "latest", "stable" 

421 ) 

422 self.assertEqual( 

423 stable_first_result[0]["released-at-display"], "2 February 2023" 

424 ) 

425 self.assertEqual( 

426 stable_first_result[1]["released-at-display"], "1 March 2023" 

427 ) 

428 

429 stable_second_result = logic.get_latest_versions( 

430 channel_map_stable_second, "latest", "stable" 

431 ) 

432 self.assertEqual( 

433 stable_second_result[0]["released-at-display"], "2 February 2023" 

434 ) 

435 self.assertEqual( 

436 stable_second_result[1]["released-at-display"], "1 March 2023" 

437 ) 

438 

439 edge_highest_risk_result = logic.get_latest_versions( 

440 channel_map_stable_first, "latest", "edge" 

441 ) 

442 self.assertEqual( 

443 edge_highest_risk_result[0]["released-at-display"], "1 March 2023" 

444 ) 

445 self.assertEqual( 

446 edge_highest_risk_result[1]["released-at-display"], 

447 "2 February 2023", 

448 ) 

449 

450 multiple_stable_channels_results = logic.get_latest_versions( 

451 channel_map_multiple_stable_architectures, "latest", "stable" 

452 ) 

453 

454 self.assertEqual( 

455 multiple_stable_channels_results[0]["released-at-display"], 

456 "2 February 2023", 

457 ) 

458 self.assertEqual( 

459 multiple_stable_channels_results[1]["released-at-display"], 

460 "1 March 2023", 

461 ) 

462 

463 def test_get_last_updated_versions(self): 

464 latest_stable = { 

465 "channel": { 

466 "risk": "stable", 

467 "track": "latest", 

468 "released-at": "2023-02-02", 

469 } 

470 } 

471 

472 latest_edge = { 

473 "channel": { 

474 "risk": "edge", 

475 "track": "latest", 

476 "released-at": "2023-03-01", 

477 } 

478 } 

479 

480 result = logic.get_last_updated_versions([latest_stable, latest_edge]) 

481 

482 self.assertEqual( 

483 result, [latest_edge["channel"], latest_stable["channel"]] 

484 )