1import responses 

2from unittest.mock import patch 

3from tests.publisher.endpoint_testing import BaseTestCases 

4 

5# Make sure tests fail on stray responses. 

6responses.mock.assert_all_requests_are_fired = True 

7 

8 

9class AccountSnapsNotAuth(BaseTestCases.EndpointLoggedOut): 

10 def setUp(self): 

11 endpoint_url = "/snaps" 

12 

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

14 

15 

16class AccountSnapsPage(BaseTestCases.EndpointLoggedInErrorHandling): 

17 def setUp(self): 

18 api_url = "https://dashboard.snapcraft.io/dev/api/account" 

19 endpoint_url = "/snaps" 

20 

21 super().setUp( 

22 snap_name=None, 

23 endpoint_url=endpoint_url, 

24 method_endpoint="GET", 

25 api_url=api_url, 

26 method_api="GET", 

27 ) 

28 

29 @responses.activate 

30 def test_no_snaps(self): 

31 payload = {"snaps": {"16": {}}} 

32 responses.add(responses.GET, self.api_url, json=payload, status=200) 

33 

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

35 self.assertEqual(200, response.status_code) 

36 # Add pyQuery basic context checks 

37 

38 self.assertEqual(1, len(responses.calls)) 

39 called = responses.calls[0] 

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

41 self.assertEqual( 

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

43 ) 

44 

45 assert response.status_code == 200 

46 self.assert_template_used("publisher/account-snaps.html") 

47 self.assert_context("current_user", "Toto") 

48 self.assert_context("snaps", {}) 

49 self.assert_context("registered_snaps", {}) 

50 

51 @responses.activate 

52 def test_registered_snaps(self): 

53 payload = { 

54 "snaps": { 

55 "16": { 

56 "test": { 

57 "status": "Approved", 

58 "snap-id": "1", 

59 "snap-name": "test", 

60 "latest_revisions": [], 

61 } 

62 } 

63 } 

64 } 

65 responses.add(responses.GET, self.api_url, json=payload, status=200) 

66 

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

68 self.assertEqual(200, response.status_code) 

69 # Add pyQuery basic context checks 

70 

71 self.assertEqual(2, len(responses.calls)) 

72 called = responses.calls[0] 

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

74 self.assertEqual( 

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

76 ) 

77 

78 assert response.status_code == 200 

79 self.assert_template_used("publisher/account-snaps.html") 

80 self.assert_context("current_user", "Toto") 

81 self.assert_context("snaps", {}) 

82 self.assert_context("registered_snaps", payload["snaps"]["16"]) 

83 

84 @responses.activate 

85 def test_uploaded_snaps(self): 

86 payload = { 

87 "snaps": { 

88 "16": { 

89 "test": { 

90 "status": "Approved", 

91 "snap-id": "1", 

92 "snap-name": "test", 

93 "latest_revisions": [ 

94 { 

95 "test": "test", 

96 "since": "2018-01-01T00:00:00Z", 

97 "channels": [], 

98 } 

99 ], 

100 "publisher": {"username": "Toto"}, 

101 } 

102 } 

103 } 

104 } 

105 responses.add(responses.GET, self.api_url, json=payload, status=200) 

106 

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

108 self.assertEqual(200, response.status_code) 

109 # Add pyQuery basic context checks 

110 

111 self.assertEqual(1, len(responses.calls)) 

112 called = responses.calls[0] 

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

114 self.assertEqual( 

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

116 ) 

117 

118 assert response.status_code == 200 

119 self.assert_template_used("publisher/account-snaps.html") 

120 self.assert_context("current_user", "Toto") 

121 self.assert_context("snaps", payload["snaps"]["16"]) 

122 self.assert_context("registered_snaps", {}) 

123 

124 @responses.activate 

125 def test_uploaded_snaps_with_latest_release(self): 

126 payload = { 

127 "snaps": { 

128 "16": { 

129 "test": { 

130 "status": "Approved", 

131 "snap-id": "1", 

132 "snap-name": "test", 

133 "latest_revisions": [ 

134 { 

135 "test": "test", 

136 "since": "2018-01-01T00:00:00Z", 

137 "channels": ["edge"], 

138 } 

139 ], 

140 "publisher": {"username": "Toto"}, 

141 } 

142 } 

143 } 

144 } 

145 responses.add(responses.GET, self.api_url, json=payload, status=200) 

146 

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

148 self.assertEqual(200, response.status_code) 

149 # Add pyQuery basic context checks 

150 

151 self.assertEqual(1, len(responses.calls)) 

152 called = responses.calls[0] 

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

154 self.assertEqual( 

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

156 ) 

157 

158 result_snaps = payload["snaps"]["16"] 

159 result_snaps["test"]["latest_release"] = result_snaps["test"][ 

160 "latest_revisions" 

161 ][0] 

162 

163 assert response.status_code == 200 

164 self.assert_template_used("publisher/account-snaps.html") 

165 self.assert_context("current_user", "Toto") 

166 self.assert_context("snaps", result_snaps) 

167 self.assert_context("registered_snaps", {}) 

168 

169 @responses.activate 

170 def test_uploaded_snaps_registered_snaps(self): 

171 payload = { 

172 "snaps": { 

173 "16": { 

174 "test": { 

175 "status": "Approved", 

176 "snap-id": "1", 

177 "snap-name": "test", 

178 "latest_revisions": [ 

179 { 

180 "test": "test", 

181 "since": "2018-01-01T00:00:00Z", 

182 "channels": [], 

183 } 

184 ], 

185 "publisher": {"username": "Toto"}, 

186 }, 

187 "test2": { 

188 "status": "Approved", 

189 "snap-id": "2", 

190 "snap-name": "test2", 

191 "latest_revisions": [], 

192 }, 

193 } 

194 } 

195 } 

196 responses.add(responses.GET, self.api_url, json=payload, status=200) 

197 

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

199 self.assertEqual(200, response.status_code) 

200 # Add pyQuery basic context checks 

201 

202 self.assertEqual(2, len(responses.calls)) 

203 called = responses.calls[0] 

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

205 self.assertEqual( 

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

207 ) 

208 

209 registered_snaps = { 

210 "test2": { 

211 "status": "Approved", 

212 "snap-id": "2", 

213 "snap-name": "test2", 

214 "latest_revisions": [], 

215 } 

216 } 

217 

218 uploaded_snaps = { 

219 "test": { 

220 "status": "Approved", 

221 "snap-id": "1", 

222 "snap-name": "test", 

223 "latest_revisions": [ 

224 { 

225 "test": "test", 

226 "since": "2018-01-01T00:00:00Z", 

227 "channels": [], 

228 } 

229 ], 

230 "publisher": {"username": "Toto"}, 

231 } 

232 } 

233 

234 assert response.status_code == 200 

235 self.assert_template_used("publisher/account-snaps.html") 

236 self.assert_context("current_user", "Toto") 

237 self.assert_context("snaps", uploaded_snaps) 

238 self.assert_context("registered_snaps", registered_snaps) 

239 

240 @responses.activate 

241 def test_revoked_snaps(self): 

242 payload = { 

243 "snaps": { 

244 "16": { 

245 "test": { 

246 "status": "Approved", 

247 "snap-id": "1", 

248 "snap-name": "test", 

249 "latest_revisions": [ 

250 { 

251 "test": "test", 

252 "since": "2018-01-01T00:00:00Z", 

253 "channels": [], 

254 } 

255 ], 

256 "publisher": {"username": "Toto"}, 

257 }, 

258 "test2": { 

259 "status": "Approved", 

260 "snap-id": "2", 

261 "snap-name": "test2", 

262 "latest_revisions": [], 

263 }, 

264 "test3": { 

265 "status": "Revoked", 

266 "snap-id": "3", 

267 "snap-name": "test", 

268 "latest_revisions": [ 

269 { 

270 "test": "test", 

271 "since": "2018-01-01T00:00:00Z", 

272 "channels": [], 

273 } 

274 ], 

275 }, 

276 "test4": { 

277 "status": "Revoked", 

278 "snap-id": "4", 

279 "snap-name": "test2", 

280 "latest_revisions": [], 

281 }, 

282 } 

283 } 

284 } 

285 responses.add(responses.GET, self.api_url, json=payload, status=200) 

286 

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

288 self.assertEqual(200, response.status_code) 

289 # Add pyQuery basic context checks 

290 

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

292 called = responses.calls[0] 

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

294 self.assertEqual( 

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

296 ) 

297 

298 registered_snaps = { 

299 "test2": { 

300 "status": "Approved", 

301 "snap-id": "2", 

302 "snap-name": "test2", 

303 "latest_revisions": [], 

304 } 

305 } 

306 

307 uploaded_snaps = { 

308 "test": { 

309 "status": "Approved", 

310 "snap-id": "1", 

311 "snap-name": "test", 

312 "latest_revisions": [ 

313 { 

314 "test": "test", 

315 "since": "2018-01-01T00:00:00Z", 

316 "channels": [], 

317 } 

318 ], 

319 "publisher": {"username": "Toto"}, 

320 } 

321 } 

322 

323 assert response.status_code == 200 

324 self.assert_template_used("publisher/account-snaps.html") 

325 self.assert_context("current_user", "Toto") 

326 self.assert_context("snaps", uploaded_snaps) 

327 self.assert_context("registered_snaps", registered_snaps) 

328 

329 @responses.activate 

330 @patch("webapp.publisher.snaps.views.authentication.is_authenticated") 

331 @patch("canonicalwebteam.store_api.publisher.Publisher.get_snap_info") 

332 def test_get_is_user_snap(self, mock_get_snap_info, mock_is_authenticated): 

333 mock_is_authenticated.return_value = True 

334 mock_get_snap_info.return_value = { 

335 "publisher": {"username": "test_username"} 

336 } 

337 

338 payload = { 

339 "snaps": { 

340 "test_snap": {"publisher": {"username": "test_username"}} 

341 } 

342 } 

343 

344 responses.add( 

345 responses.GET, 

346 self.api_url, 

347 json=payload, 

348 status=200, 

349 ) 

350 

351 with self.client.session_transaction() as sess: 

352 sess["publisher"] = { 

353 "nickname": "test_username", 

354 "fullname": "Test User", 

355 } 

356 

357 response = self.client.get("/snap_info/user_snap/test_snap") 

358 

359 self.assertEqual(response.status_code, 200) 

360 self.assertEqual(response.json, {"is_users_snap": True})