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 } 

32 ] 

33 

34 result = logic.convert_channel_maps(channel_maps_list) 

35 expected_result = { 

36 "arch": { 

37 "track": [ 

38 { 

39 "channel": "channel", 

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

41 "confinement": "confinement", 

42 "size": "size", 

43 "risk": "risk", 

44 "version": "version", 

45 } 

46 ] 

47 } 

48 } 

49 

50 self.assertEqual(result, expected_result) 

51 

52 def test_multiple_track_same_arch_channel_map(self): 

53 channel_maps_list = [ 

54 { 

55 "channel": { 

56 "name": "channel", 

57 "architecture": "arch", 

58 "track": "track", 

59 "risk": "risk", 

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

61 }, 

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

63 "confinement": "confinement", 

64 "download": {"size": "size"}, 

65 "version": "version", 

66 }, 

67 { 

68 "channel": { 

69 "name": "channel", 

70 "architecture": "arch", 

71 "track": "track1", 

72 "risk": "risk", 

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

74 }, 

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

76 "confinement": "confinement", 

77 "download": {"size": "size"}, 

78 "version": "version", 

79 }, 

80 ] 

81 result = logic.convert_channel_maps(channel_maps_list) 

82 expected_result = { 

83 "arch": { 

84 "track": [ 

85 { 

86 "channel": "channel", 

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

88 "confinement": "confinement", 

89 "size": "size", 

90 "risk": "risk", 

91 "version": "version", 

92 } 

93 ], 

94 "track1": [ 

95 { 

96 "channel": "channel", 

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

98 "confinement": "confinement", 

99 "size": "size", 

100 "risk": "risk", 

101 "version": "version", 

102 } 

103 ], 

104 } 

105 } 

106 

107 self.assertEqual(result, expected_result) 

108 

109 def test_multiple_track_different_arch_channel_map(self): 

110 channel_maps_list = [ 

111 { 

112 "channel": { 

113 "name": "channel", 

114 "architecture": "arch", 

115 "track": "track", 

116 "risk": "risk", 

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

118 }, 

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

120 "confinement": "confinement", 

121 "download": {"size": "size"}, 

122 "version": "version", 

123 }, 

124 { 

125 "channel": { 

126 "name": "channel", 

127 "architecture": "arch1", 

128 "track": "track", 

129 "risk": "risk", 

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

131 }, 

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

133 "confinement": "confinement", 

134 "download": {"size": "size"}, 

135 "version": "version", 

136 }, 

137 ] 

138 

139 result = logic.convert_channel_maps(channel_maps_list) 

140 expected_result = { 

141 "arch": { 

142 "track": [ 

143 { 

144 "channel": "channel", 

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

146 "confinement": "confinement", 

147 "size": "size", 

148 "risk": "risk", 

149 "version": "version", 

150 } 

151 ] 

152 }, 

153 "arch1": { 

154 "track": [ 

155 { 

156 "channel": "channel", 

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

158 "confinement": "confinement", 

159 "size": "size", 

160 "risk": "risk", 

161 "version": "version", 

162 } 

163 ] 

164 }, 

165 } 

166 

167 self.assertEqual(result, expected_result) 

168 

169 def test_get_lowest_available_risk(self): 

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

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

172 self.assertEqual(edge_result, "edge") 

173 

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

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

176 self.assertEqual(beta_result, "beta") 

177 

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

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

180 self.assertEqual(cand_result, "candidate") 

181 

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

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

184 self.assertEqual(stable_result, "stable") 

185 

186 # assert that channel_map has been updated successfully 

187 self.assertEqual( 

188 channel_map, 

189 { 

190 "arch": { 

191 "track": [ 

192 {"risk": "edge"}, 

193 {"risk": "beta"}, 

194 {"risk": "candidate"}, 

195 {"risk": "stable"}, 

196 ] 

197 } 

198 }, 

199 ) 

200 

201 def test_get_version(self): 

202 channel_map = { 

203 "arch": { 

204 "track": [ 

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

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

207 ] 

208 } 

209 } 

210 edge_version = logic.extract_info_channel_map( 

211 channel_map, "track", "edge" 

212 )["version"] 

213 self.assertEqual(edge_version, "12") 

214 

215 stable_version = logic.extract_info_channel_map( 

216 channel_map, "track", "stable" 

217 )["version"] 

218 self.assertEqual(stable_version, "10") 

219 

220 def test_get_no_version(self): 

221 channel_map = { 

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

223 } 

224 no_version = logic.extract_info_channel_map( 

225 channel_map, "track", "edge" 

226 )["version"] 

227 self.assertEqual(no_version, None) 

228 

229 def test_get_confinement(self): 

230 channel_map = { 

231 "arch": { 

232 "track": [ 

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

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

235 ] 

236 } 

237 } 

238 classic_result = logic.extract_info_channel_map( 

239 channel_map, "track", "edge" 

240 )["confinement"] 

241 self.assertEqual(classic_result, "classic") 

242 

243 strict_result = logic.extract_info_channel_map( 

244 channel_map, "track", "stable" 

245 )["confinement"] 

246 self.assertEqual(strict_result, "strict") 

247 

248 def test_get_no_confinement(self): 

249 channel_map = { 

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

251 } 

252 no_version = logic.extract_info_channel_map( 

253 channel_map, "track", "edge" 

254 )["confinement"] 

255 self.assertEqual(no_version, None) 

256 

257 def test_get_categories(self): 

258 categories = { 

259 "categories": [ 

260 {"name": "featured"}, 

261 {"name": "test"}, 

262 {"name": "development"}, 

263 ] 

264 } 

265 category_list = logic.get_categories(categories) 

266 self.assertTrue( 

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

268 ) 

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

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

271 

272 def test_get_video_embed_code(self): 

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

274 embed = logic.get_video_embed_code(youtube_url) 

275 self.assertEqual( 

276 embed, 

277 { 

278 "type": "youtube", 

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

280 "id": "123", 

281 }, 

282 ) 

283 

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

285 embed = logic.get_video_embed_code(youtu_be_url) 

286 self.assertEqual( 

287 embed, 

288 { 

289 "type": "youtube", 

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

291 "id": "123", 

292 }, 

293 ) 

294 

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

296 embed = logic.get_video_embed_code(vimeo_url) 

297 self.assertEqual( 

298 embed, 

299 { 

300 "type": "vimeo", 

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

302 "id": "123123", 

303 }, 

304 ) 

305 

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

307 embed = logic.get_video_embed_code(asciicinema_url) 

308 self.assertEqual( 

309 embed, 

310 { 

311 "type": "asciinema", 

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

313 "id": "123", 

314 }, 

315 ) 

316 

317 def test_convert_date_more_than_yesterday(self): 

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

319 result = logic.convert_date(date_test) 

320 

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

322 

323 def test_convert_date_more_today(self): 

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

325 result = logic.convert_date(date_test) 

326 

327 self.assertEqual(result, "Today") 

328 

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

330 def test_convert_date_timezone_yesterday(self): 

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

332 result = logic.convert_date(date_test) 

333 

334 self.assertEqual(result, "Yesterday") 

335 

336 def test_get_snap_banner(self): 

337 snap_with_banner = { 

338 "media": [ 

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

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

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

342 ] 

343 } 

344 

345 result = logic.get_snap_banner_url(snap_with_banner) 

346 

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

348 

349 def test_get_snap_banner_no_banner(self): 

350 snap_with_banner = { 

351 "media": [ 

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

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

354 ] 

355 } 

356 

357 result = logic.get_snap_banner_url(snap_with_banner) 

358 

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

360 

361 def test_get_latest_versions(self): 

362 latest_stable = { 

363 "channel": { 

364 "architecture": "amd64", 

365 "risk": "stable", 

366 "track": "latest", 

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

368 } 

369 } 

370 

371 latest_edge = { 

372 "channel": { 

373 "architecture": "amd64", 

374 "risk": "edge", 

375 "track": "latest", 

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

377 } 

378 } 

379 

380 latest_stable_arm = { 

381 "channel": { 

382 "architecture": "arm64", 

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

384 "risk": "candidate", 

385 "track": "latest", 

386 } 

387 } 

388 

389 channel_map_single_channel = [latest_stable] 

390 

391 channel_map_stable_first = [latest_stable, latest_edge] 

392 

393 channel_map_stable_second = [latest_edge, latest_stable] 

394 

395 channel_map_multiple_stable_architectures = [ 

396 latest_edge, 

397 latest_stable, 

398 latest_stable_arm, 

399 ] 

400 

401 single_result = logic.get_latest_versions( 

402 channel_map_single_channel, "latest", "stable" 

403 ) 

404 self.assertEqual( 

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

406 ) 

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

408 

409 stable_first_result = logic.get_latest_versions( 

410 channel_map_stable_first, "latest", "stable" 

411 ) 

412 self.assertEqual( 

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

414 ) 

415 self.assertEqual( 

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

417 ) 

418 

419 stable_second_result = logic.get_latest_versions( 

420 channel_map_stable_second, "latest", "stable" 

421 ) 

422 self.assertEqual( 

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

424 ) 

425 self.assertEqual( 

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

427 ) 

428 

429 edge_highest_risk_result = logic.get_latest_versions( 

430 channel_map_stable_first, "latest", "edge" 

431 ) 

432 self.assertEqual( 

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

434 ) 

435 self.assertEqual( 

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

437 "2 February 2023", 

438 ) 

439 

440 multiple_stable_channels_results = logic.get_latest_versions( 

441 channel_map_multiple_stable_architectures, "latest", "stable" 

442 ) 

443 

444 self.assertEqual( 

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

446 "2 February 2023", 

447 ) 

448 self.assertEqual( 

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

450 "1 March 2023", 

451 ) 

452 

453 def test_get_last_updated_versions(self): 

454 latest_stable = { 

455 "channel": { 

456 "risk": "stable", 

457 "track": "latest", 

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

459 } 

460 } 

461 

462 latest_edge = { 

463 "channel": { 

464 "risk": "edge", 

465 "track": "latest", 

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

467 } 

468 } 

469 

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

471 

472 self.assertEqual( 

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

474 )