Coverage for tests/endpoints/publisher/tests_register.py: 100%

1import responses 

2from tests.publisher.endpoint_testing import BaseTestCases 

3 

4 

5class GetRegisterNamePageNotAuth(BaseTestCases.EndpointLoggedOut): 

6 def setUp(self): 

7 endpoint_url = "/register-snap" 

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

9 

10 

11class GetRegisterNamePage(BaseTestCases.BaseAppTesting): 

12 def setUp(self): 

13 endpoint_url = "/register-snap" 

14 super().setUp(snap_name=None, api_url=None, endpoint_url=endpoint_url) 

15 self.user_url = "https://dashboard.snapcraft.io/dev/api/account" 

16 

17 @responses.activate 

18 def test_register_name_logged_in(self): 

19 self._log_in(self.client) 

20 

21 responses.add(responses.GET, self.user_url, status=200) 

22 

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

24 

25 assert response.status_code == 200 

26 self.assert_template_used("store/publisher.html") 

27 

28 

29class PostRegisterNamePageNotAuth(BaseTestCases.EndpointLoggedOut): 

30 def setUp(self): 

31 endpoint_url = "/api/register-snap" 

32 

33 super().setUp( 

34 snap_name=None, endpoint_url=endpoint_url, method_endpoint="POST" 

35 ) 

36 

37 

38class PostRegisterNamePage(BaseTestCases.EndpointLoggedIn): 

39 def setUp(self): 

40 endpoint_url = "/api/register-snap" 

41 api_url = "https://dashboard.snapcraft.io/dev/api/register-name/" 

42 

43 data = {"snap_name": "test-snap"} 

44 

45 super().setUp( 

46 snap_name=None, 

47 api_url=api_url, 

48 endpoint_url=endpoint_url, 

49 method_api="POST", 

50 method_endpoint="POST", 

51 data=data, 

52 ) 

53 self.user_url = "https://dashboard.snapcraft.io/dev/api/account" 

54 

55 @responses.activate 

56 def test_post_snap_name(self): 

57 responses.add(responses.POST, self.api_url, json={}, status=200) 

58 

59 response = self.client.post(self.endpoint_url, data=self.data) 

60 

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

62 called = responses.calls[0] 

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

64 self.assertEqual( 

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

66 ) 

67 self.assertEqual(b'{"snap_name": "test-snap"}', called.request.body) 

68 

69 assert response.status_code == 200 

70 

71 @responses.activate 

72 def test_post_store(self): 

73 responses.add(responses.POST, self.api_url, json={}, status=200) 

74 

75 self.data["store"] = "store" 

76 response = self.client.post(self.endpoint_url, data=self.data) 

77 

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

79 called = responses.calls[0] 

80 self.assertEqual( 

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

82 ) 

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

84 self.assertIn(b'"snap_name": "test-snap"', called.request.body) 

85 self.assertIn(b'"store": "store"', called.request.body) 

86 

87 assert response.status_code == 200 

88 

89 @responses.activate 

90 def test_post_private(self): 

91 responses.add(responses.POST, self.api_url, json={}, status=200) 

92 

93 self.data["is_private"] = "private" 

94 response = self.client.post(self.endpoint_url, data=self.data) 

95 

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

97 called = responses.calls[0] 

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

99 self.assertEqual( 

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

101 ) 

102 self.assertIn(b'"snap_name": "test-snap"', called.request.body) 

103 self.assertIn(b'"is_private": true', called.request.body) 

104 

105 assert response.status_code == 200 

106 

107 @responses.activate 

108 def test_name_already_registered(self): 

109 payload = {"error_list": [{"code": "already_registered"}]} 

110 responses.add(responses.POST, self.api_url, json=payload, status=409) 

111 

112 user_payload = {"error_list": [], "stores": []} 

113 responses.add( 

114 responses.GET, self.user_url, json=user_payload, status=200 

115 ) 

116 

117 response = self.client.post(self.endpoint_url, data=self.data) 

118 

119 assert response.status_code == 200 

120 assert ( 

121 response.get_json()["data"]["error_code"] == "already_registered" 

122 ) 

123 

124 @responses.activate 

125 def test_name_reserved(self): 

126 payload = {"error_list": [{"code": "reserved_name"}]} 

127 responses.add(responses.POST, self.api_url, json=payload, status=409) 

128 

129 user_payload = {"error_list": [], "stores": []} 

130 responses.add( 

131 responses.GET, self.user_url, json=user_payload, status=200 

132 ) 

133 

134 response = self.client.post(self.endpoint_url, data=self.data) 

135 

136 assert response.status_code == 200 

137 assert response.get_json()["data"]["error_code"] == "reserved_name" 

138 

139 @responses.activate 

140 def test_claim_dispute(self): 

141 payload = { 

142 "success": False, 

143 "data": { 

144 "snap_name": "test-snap", 

145 "is_private": "private", 

146 "store": "store", 

147 "error_code": "already_claimed", 

148 }, 

149 } 

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

151 

152 response = self.client.post(self.endpoint_url, data=self.data) 

153 

154 assert response.status_code == 200 

155 assert response.get_json()["success"] is True 

156 

157 

158class PostRegisterNameDisputeNotAuth(BaseTestCases.EndpointLoggedOut): 

159 def setUp(self): 

160 endpoint_url = "/api/register-name-dispute" 

161 super().setUp( 

162 snap_name=None, endpoint_url=endpoint_url, method_endpoint="POST" 

163 ) 

164 

165 

166class PostRegisterNameDispute(BaseTestCases.EndpointLoggedIn): 

167 def setUp(self): 

168 endpoint_url = "/api/register-name-dispute" 

169 api_url = ( 

170 "https://dashboard.snapcraft.io/dev/api/register-name-dispute/" 

171 ) 

172 

173 json_data = { 

174 "snap-name": "test-snap", 

175 "claim-comment": "I own this trademark", 

176 } 

177 

178 super().setUp( 

179 snap_name=None, 

180 api_url=api_url, 

181 endpoint_url=endpoint_url, 

182 method_api="POST", 

183 method_endpoint="POST", 

184 json=json_data, 

185 ) 

186 

187 @responses.activate 

188 def test_post_register_name_dispute_success(self): 

189 responses.add(responses.POST, self.api_url, json={}, status=200) 

190 

191 response = self.client.post( 

192 self.endpoint_url, 

193 json=self.json, 

194 content_type="application/json", 

195 ) 

196 

197 # Check that the API was called (JSON was parsed correctly) 

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

199 called = responses.calls[0] 

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

201 self.assertEqual( 

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

203 ) 

204 

205 assert response.status_code == 200 

206 assert response.get_json()["success"] is True 

207 

208 @responses.activate 

209 def test_post_register_name_dispute_400_error(self): 

210 payload = { 

211 "error_list": [ 

212 { 

213 "code": "invalid-request", 

214 "message": "Invalid request parameters", 

215 } 

216 ] 

217 } 

218 responses.add(responses.POST, self.api_url, json=payload, status=400) 

219 

220 response = self.client.post( 

221 self.endpoint_url, 

222 json=self.json, 

223 content_type="application/json", 

224 ) 

225 

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

227 called = responses.calls[0] 

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

229 self.assertEqual( 

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

231 ) 

232 

233 assert response.status_code == 200 

234 response_data = response.get_json() 

235 assert response_data["success"] is False 

236 assert response_data["data"] == payload["error_list"] 

237 assert response_data["message"] == "Invalid request parameters" 

238 

239 @responses.activate 

240 def test_post_register_name_dispute_409_error(self): 

241 payload = { 

242 "error_list": [ 

243 { 

244 "code": "dispute-already-exists", 

245 "message": "A dispute for this name already exists", 

246 } 

247 ] 

248 } 

249 responses.add(responses.POST, self.api_url, json=payload, status=409) 

250 

251 response = self.client.post( 

252 self.endpoint_url, 

253 json=self.json, 

254 content_type="application/json", 

255 ) 

256 

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

258 called = responses.calls[0] 

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

260 self.assertEqual( 

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

262 ) 

263 

264 assert response.status_code == 200 

265 response_data = response.get_json() 

266 assert response_data["success"] is False 

267 assert response_data["data"] == payload["error_list"] 

268 expected_message = "A dispute for this name already exists" 

269 assert response_data["message"] == expected_message