1import random 

2from datetime import datetime 

3 

4import responses 

5from tests.publisher.endpoint_testing import BaseTestCases 

6 

7 

8class MetricsPageNotAuth(BaseTestCases.EndpointLoggedOut): 

9 def setUp(self): 

10 snap_name = "test-snap" 

11 endpoint_url = "/{}/metrics".format(snap_name) 

12 

13 super().setUp(snap_name=snap_name, endpoint_url=endpoint_url) 

14 

15 

16class GetMetricsGetInfoPage(BaseTestCases.EndpointLoggedInErrorHandling): 

17 def setUp(self): 

18 snap_name = "test-snap" 

19 

20 api_url = "https://dashboard.snapcraft.io/dev/api/snaps/info/{}" 

21 api_url = api_url.format(snap_name) 

22 endpoint_url = "/{}/metrics".format(snap_name) 

23 

24 super().setUp( 

25 snap_name=snap_name, 

26 endpoint_url=endpoint_url, 

27 method_endpoint="GET", 

28 api_url=api_url, 

29 method_api="GET", 

30 ) 

31 

32 

33class GetMetricsPostMetrics(BaseTestCases.EndpointLoggedInErrorHandling): 

34 def setUp(self): 

35 snap_name = "test-snap" 

36 

37 self.snap_id = "complexId" 

38 info_url = "https://dashboard.snapcraft.io/dev/api/snaps/info/{}" 

39 self.info_url = info_url.format(snap_name) 

40 

41 payload = { 

42 "snap_id": "id", 

43 "title": "Test Snap", 

44 "private": False, 

45 "categories": { 

46 "items": [{"name": "test", "since": "2018-01-01T00:00:00"}] 

47 }, 

48 "publisher": {"display-name": "test"}, 

49 } 

50 

51 responses.add(responses.GET, self.info_url, json=payload, status=200) 

52 

53 api_url = "https://dashboard.snapcraft.io/dev/api/snaps/metrics" 

54 endpoint_url = "/{}/metrics".format(snap_name) 

55 

56 super().setUp( 

57 snap_name=snap_name, 

58 endpoint_url=endpoint_url, 

59 api_url=api_url, 

60 method_endpoint="GET", 

61 method_api="POST", 

62 ) 

63 

64 @responses.activate 

65 def test_no_data(self): 

66 payload = { 

67 "metrics": [ 

68 { 

69 "status": "NO DATA", 

70 "series": [], 

71 "buckets": [], 

72 "metric_name": "weekly_installed_base_by_version", 

73 }, 

74 { 

75 "status": "NO DATA", 

76 "series": [], 

77 "buckets": [], 

78 "metric_name": "weekly_installed_base_by_country", 

79 }, 

80 ] 

81 } 

82 

83 responses.add(responses.POST, self.api_url, json=payload, status=200) 

84 

85 response = self.client.get(self.endpoint_url) 

86 

87 self.assertEqual(3, len(responses.calls)) 

88 called = responses.calls[0] 

89 self.assertEqual(self.info_url, called.request.url) 

90 self.assertEqual( 

91 self.authorization, called.request.headers.get("Authorization") 

92 ) 

93 called = responses.calls[1] 

94 self.assertEqual(self.api_url, called.request.url) 

95 self.assertEqual( 

96 self.authorization, called.request.headers.get("Authorization") 

97 ) 

98 

99 self.assertEqual(response.status_code, 200) 

100 self.assert_template_used("publisher/metrics.html") 

101 self.assert_context("snap_name", self.snap_name) 

102 self.assert_context("snap_title", "Test Snap") 

103 self.assert_context("metric_period", "30d") 

104 self.assert_context("active_device_metric", "version") 

105 self.assert_context("nodata", True) 

106 

107 @responses.activate 

108 def test_data_version_1_year(self): 

109 random_values = random.sample(range(1, 30), 29) 

110 dates = [ 

111 datetime(2018, 3, day).strftime("%Y-%m-%d") for day in range(1, 30) 

112 ] 

113 countries = [ 

114 {"values": [2], "name": "FR"}, 

115 {"values": [3], "name": "GB"}, 

116 ] 

117 payload = { 

118 "metrics": [ 

119 { 

120 "status": "OK", 

121 "series": [{"values": random_values, "name": "0.1"}], 

122 "buckets": dates, 

123 "metric_name": "weekly_installed_base_by_version", 

124 }, 

125 { 

126 "status": "OK", 

127 "series": countries, 

128 "buckets": ["2018-03-18"], 

129 "metric_name": "weekly_installed_base_by_country", 

130 }, 

131 ] 

132 } 

133 responses.add(responses.POST, self.api_url, json=payload, status=200) 

134 

135 response = self.client.get(self.endpoint_url + "?period=1y") 

136 

137 self.assertEqual(3, len(responses.calls)) 

138 called = responses.calls[0] 

139 self.assertEqual(self.info_url, called.request.url) 

140 self.assertEqual( 

141 self.authorization, called.request.headers.get("Authorization") 

142 ) 

143 called = responses.calls[1] 

144 self.assertEqual(self.api_url, called.request.url) 

145 self.assertEqual( 

146 self.authorization, called.request.headers.get("Authorization") 

147 ) 

148 

149 self.assertEqual(response.status_code, 200) 

150 self.assert_template_used("publisher/metrics.html") 

151 self.assert_context("snap_name", self.snap_name) 

152 self.assert_context("snap_title", "Test Snap") 

153 self.assert_context("metric_period", "1y") 

154 self.assert_context("active_device_metric", "version") 

155 self.assert_context("nodata", False) 

156 

157 @responses.activate 

158 def test_data_version_1_month(self): 

159 random_values = random.sample(range(1, 30), 29) 

160 dates = [ 

161 datetime(2018, 3, day).strftime("%Y-%m-%d") for day in range(1, 30) 

162 ] 

163 countries = [ 

164 {"values": [2], "name": "FR"}, 

165 {"values": [3], "name": "GB"}, 

166 ] 

167 payload = { 

168 "metrics": [ 

169 { 

170 "status": "OK", 

171 "series": [{"values": random_values, "name": "0.1"}], 

172 "buckets": dates, 

173 "metric_name": "weekly_installed_base_by_version", 

174 }, 

175 { 

176 "status": "OK", 

177 "series": countries, 

178 "buckets": ["2018-03-18"], 

179 "metric_name": "weekly_installed_base_by_country", 

180 }, 

181 ] 

182 } 

183 responses.add(responses.POST, self.api_url, json=payload, status=200) 

184 

185 response = self.client.get(self.endpoint_url + "?period=30d") 

186 

187 self.assertEqual(3, len(responses.calls)) 

188 called = responses.calls[0] 

189 self.assertEqual(self.info_url, called.request.url) 

190 self.assertEqual( 

191 self.authorization, called.request.headers.get("Authorization") 

192 ) 

193 called = responses.calls[1] 

194 self.assertEqual(self.api_url, called.request.url) 

195 self.assertEqual( 

196 self.authorization, called.request.headers.get("Authorization") 

197 ) 

198 

199 self.assertEqual(response.status_code, 200) 

200 self.assert_template_used("publisher/metrics.html") 

201 self.assert_context("snap_name", self.snap_name) 

202 self.assert_context("snap_title", "Test Snap") 

203 self.assert_context("metric_period", "30d") 

204 self.assert_context("active_device_metric", "version") 

205 self.assert_context("nodata", False) 

206 

207 @responses.activate 

208 def test_data_version_weekly(self): 

209 random_values = random.sample(range(1, 30), 6) 

210 dates = [ 

211 datetime(2018, 3, day).strftime("%Y-%m-%d") for day in range(1, 7) 

212 ] 

213 countries = [ 

214 {"values": [2], "name": "FR"}, 

215 {"values": [3], "name": "GB"}, 

216 ] 

217 payload = { 

218 "metrics": [ 

219 { 

220 "status": "OK", 

221 "series": [{"values": random_values, "name": "0.1"}], 

222 "buckets": dates, 

223 "metric_name": "weekly_installed_base_by_version", 

224 }, 

225 { 

226 "status": "OK", 

227 "series": countries, 

228 "buckets": ["2018-03-18"], 

229 "metric_name": "weekly_installed_base_by_country", 

230 }, 

231 ] 

232 } 

233 responses.add(responses.POST, self.api_url, json=payload, status=200) 

234 

235 response = self.client.get(self.endpoint_url + "?period=7d") 

236 

237 self.assertEqual(3, len(responses.calls)) 

238 called = responses.calls[0] 

239 self.assertEqual(self.info_url, called.request.url) 

240 self.assertEqual( 

241 self.authorization, called.request.headers.get("Authorization") 

242 ) 

243 called = responses.calls[1] 

244 self.assertEqual(self.api_url, called.request.url) 

245 self.assertEqual( 

246 self.authorization, called.request.headers.get("Authorization") 

247 ) 

248 

249 self.assertEqual(response.status_code, 200) 

250 self.assert_template_used("publisher/metrics.html") 

251 self.assert_context("snap_name", self.snap_name) 

252 self.assert_context("snap_title", "Test Snap") 

253 self.assert_context("metric_period", "7d") 

254 self.assert_context("active_device_metric", "version") 

255 self.assert_context("nodata", False) 

256 

257 @responses.activate 

258 def test_data_version_3_month(self): 

259 random_values = random.sample(range(1, 100), 59) 

260 dates = [] 

261 for month in range(4, 7): 

262 dates = dates + [ 

263 datetime(2018, month, day).strftime("%Y-%m-%d") 

264 for day in range(1, 30) 

265 ] 

266 

267 countries = [ 

268 {"values": [2], "name": "FR"}, 

269 {"values": [3], "name": "GB"}, 

270 ] 

271 payload = { 

272 "metrics": [ 

273 { 

274 "status": "OK", 

275 "series": [{"values": random_values, "name": "0.1"}], 

276 "buckets": dates, 

277 "metric_name": "weekly_installed_base_by_version", 

278 }, 

279 { 

280 "status": "OK", 

281 "series": countries, 

282 "buckets": ["2018-03-18"], 

283 "metric_name": "weekly_installed_base_by_country", 

284 }, 

285 ] 

286 } 

287 responses.add(responses.POST, self.api_url, json=payload, status=200) 

288 

289 response = self.client.get(self.endpoint_url + "?period=3m") 

290 

291 self.assertEqual(3, len(responses.calls)) 

292 called = responses.calls[0] 

293 self.assertEqual(self.info_url, called.request.url) 

294 self.assertEqual( 

295 self.authorization, called.request.headers.get("Authorization") 

296 ) 

297 called = responses.calls[1] 

298 self.assertEqual(self.api_url, called.request.url) 

299 self.assertEqual( 

300 self.authorization, called.request.headers.get("Authorization") 

301 ) 

302 

303 self.assertEqual(response.status_code, 200) 

304 self.assert_template_used("publisher/metrics.html") 

305 self.assert_context("snap_name", self.snap_name) 

306 self.assert_context("snap_title", "Test Snap") 

307 self.assert_context("metric_period", "3m") 

308 self.assert_context("active_device_metric", "version") 

309 self.assert_context("nodata", False) 

310 

311 @responses.activate 

312 def test_data_os_7_days(self): 

313 random_values = random.sample(range(1, 100), 59) 

314 dates = [ 

315 datetime(2018, 3, day).strftime("%Y-%m-%d") for day in range(1, 7) 

316 ] 

317 countries = [ 

318 {"values": [2], "name": "FR"}, 

319 {"values": [3], "name": "GB"}, 

320 ] 

321 payload = { 

322 "metrics": [ 

323 { 

324 "status": "OK", 

325 "series": [ 

326 {"values": random_values, "name": "ubuntu/0.1"} 

327 ], 

328 "buckets": dates, 

329 "metric_name": "weekly_installed_base_by_operating_system", 

330 }, 

331 { 

332 "status": "OK", 

333 "series": countries, 

334 "buckets": ["2018-03-18"], 

335 "metric_name": "weekly_installed_base_by_country", 

336 }, 

337 ] 

338 } 

339 responses.add(responses.POST, self.api_url, json=payload, status=200) 

340 

341 response = self.client.get( 

342 self.endpoint_url + "?period=7d&active-devices=os" 

343 ) 

344 

345 self.assertEqual(3, len(responses.calls)) 

346 called = responses.calls[0] 

347 self.assertEqual(self.info_url, called.request.url) 

348 self.assertEqual( 

349 self.authorization, called.request.headers.get("Authorization") 

350 ) 

351 called = responses.calls[1] 

352 self.assertEqual(self.api_url, called.request.url) 

353 self.assertEqual( 

354 self.authorization, called.request.headers.get("Authorization") 

355 ) 

356 

357 self.assertEqual(response.status_code, 200) 

358 self.assert_template_used("publisher/metrics.html") 

359 self.assert_context("snap_name", self.snap_name) 

360 self.assert_context("snap_title", "Test Snap") 

361 self.assert_context("metric_period", "7d") 

362 self.assert_context("active_device_metric", "os") 

363 self.assert_context("nodata", False) 

364 

365 @responses.activate 

366 def test_data_os_1_year(self): 

367 random_values = random.sample(range(1, 100), 59) 

368 dates = [ 

369 datetime(2018, 3, day).strftime("%Y-%m-%d") for day in range(1, 30) 

370 ] 

371 countries = [ 

372 {"values": [2], "name": "FR"}, 

373 {"values": [3], "name": "GB"}, 

374 ] 

375 payload = { 

376 "metrics": [ 

377 { 

378 "status": "OK", 

379 "series": [ 

380 {"values": random_values, "name": "ubuntu/0.1"} 

381 ], 

382 "buckets": dates, 

383 "metric_name": "weekly_installed_base_by_operating_system", 

384 }, 

385 { 

386 "status": "OK", 

387 "series": countries, 

388 "buckets": ["2018-03-18"], 

389 "metric_name": "weekly_installed_base_by_country", 

390 }, 

391 ] 

392 } 

393 responses.add(responses.POST, self.api_url, json=payload, status=200) 

394 

395 response = self.client.get( 

396 self.endpoint_url + "?period=1y&active-devices=os" 

397 ) 

398 

399 self.assertEqual(3, len(responses.calls)) 

400 called = responses.calls[0] 

401 self.assertEqual(self.info_url, called.request.url) 

402 self.assertEqual( 

403 self.authorization, called.request.headers.get("Authorization") 

404 ) 

405 called = responses.calls[1] 

406 self.assertEqual(self.api_url, called.request.url) 

407 self.assertEqual( 

408 self.authorization, called.request.headers.get("Authorization") 

409 ) 

410 

411 self.assertEqual(response.status_code, 200) 

412 self.assert_template_used("publisher/metrics.html") 

413 self.assert_context("snap_name", self.snap_name) 

414 self.assert_context("snap_title", "Test Snap") 

415 self.assert_context("metric_period", "1y") 

416 self.assert_context("active_device_metric", "os") 

417 self.assert_context("nodata", False) 

418 

419 @responses.activate 

420 def test_data_os_1_month(self): 

421 random_values = random.sample(range(1, 100), 59) 

422 dates = [ 

423 datetime(2018, 3, day).strftime("%Y-%m-%d") for day in range(1, 30) 

424 ] 

425 countries = [ 

426 {"values": [2], "name": "FR"}, 

427 {"values": [3], "name": "GB"}, 

428 ] 

429 payload = { 

430 "metrics": [ 

431 { 

432 "status": "OK", 

433 "series": [ 

434 {"values": random_values, "name": "ubuntu/0.1"} 

435 ], 

436 "buckets": dates, 

437 "metric_name": "weekly_installed_base_by_operating_system", 

438 }, 

439 { 

440 "status": "OK", 

441 "series": countries, 

442 "buckets": ["2018-03-18"], 

443 "metric_name": "weekly_installed_base_by_country", 

444 }, 

445 ] 

446 } 

447 responses.add(responses.POST, self.api_url, json=payload, status=200) 

448 

449 response = self.client.get( 

450 self.endpoint_url + "?period=30d&active-devices=os" 

451 ) 

452 

453 self.assertEqual(3, len(responses.calls)) 

454 called = responses.calls[0] 

455 self.assertEqual(self.info_url, called.request.url) 

456 self.assertEqual( 

457 self.authorization, called.request.headers.get("Authorization") 

458 ) 

459 called = responses.calls[1] 

460 self.assertEqual(self.api_url, called.request.url) 

461 self.assertEqual( 

462 self.authorization, called.request.headers.get("Authorization") 

463 ) 

464 

465 self.assertEqual(response.status_code, 200) 

466 self.assert_template_used("publisher/metrics.html") 

467 self.assert_context("snap_name", self.snap_name) 

468 self.assert_context("snap_title", "Test Snap") 

469 self.assert_context("metric_period", "30d") 

470 self.assert_context("active_device_metric", "os") 

471 self.assert_context("nodata", False) 

472 

473 @responses.activate 

474 def test_data_os_3_month(self): 

475 random_values = random.sample(range(1, 100), 59) 

476 dates = [] 

477 for month in range(4, 7): 

478 dates = dates + [ 

479 datetime(2018, month, day).strftime("%Y-%m-%d") 

480 for day in range(1, 30) 

481 ] 

482 

483 countries = [ 

484 {"values": [2], "name": "FR"}, 

485 {"values": [3], "name": "GB"}, 

486 ] 

487 payload = { 

488 "metrics": [ 

489 { 

490 "status": "OK", 

491 "series": [ 

492 {"values": random_values, "name": "ubuntu/0.1"} 

493 ], 

494 "buckets": dates, 

495 "metric_name": "weekly_installed_base_by_operating_system", 

496 }, 

497 { 

498 "status": "OK", 

499 "series": countries, 

500 "buckets": ["2018-03-18"], 

501 "metric_name": "weekly_installed_base_by_country", 

502 }, 

503 ] 

504 } 

505 responses.add(responses.POST, self.api_url, json=payload, status=200) 

506 

507 response = self.client.get( 

508 self.endpoint_url + "?period=3m&active-devices=os" 

509 ) 

510 

511 self.assertEqual(3, len(responses.calls)) 

512 called = responses.calls[0] 

513 self.assertEqual(self.info_url, called.request.url) 

514 self.assertEqual( 

515 self.authorization, called.request.headers.get("Authorization") 

516 ) 

517 called = responses.calls[1] 

518 self.assertEqual(self.api_url, called.request.url) 

519 self.assertEqual( 

520 self.authorization, called.request.headers.get("Authorization") 

521 ) 

522 

523 self.assertEqual(response.status_code, 200) 

524 self.assert_template_used("publisher/metrics.html") 

525 self.assert_context("snap_name", self.snap_name) 

526 self.assert_context("snap_title", "Test Snap") 

527 self.assert_context("metric_period", "3m") 

528 self.assert_context("active_device_metric", "os") 

529 self.assert_context("nodata", False)