Coverage for tests / endpoints / tests_models.py: 100%

1from unittest.mock import patch 

2 

3from canonicalwebteam.candid import CandidClient 

4from canonicalwebteam.exceptions import ( 

5 StoreApiResponseErrorList, 

6 StoreApiResourceNotFound, 

7) 

8from webapp.helpers import api_publisher_session 

9from tests.endpoints.endpoint_testing import TestModelServiceEndpoints 

10 

11 

12candid = CandidClient(api_publisher_session) 

13 

14 

15class TestCreateModel(TestModelServiceEndpoints): 

16 @patch( 

17 "canonicalwebteam.store_api.publishergw.PublisherGW.create_store_model" 

18 ) 

19 def test_create_model(self, mock_create_store_model): 

20 mock_create_store_model.return_value = None 

21 

22 payload = {"name": "Test Model", "api_key": self.api_key} 

23 response = self.client.post("/api/store/1/models", data=payload) 

24 data = response.json 

25 

26 self.assertEqual(response.status_code, 201) 

27 self.assertTrue(data["success"]) 

28 

29 def test_create_model_with_invalid_api_key(self): 

30 payload = {"name": "Test Model", "api_key": "invalid_api_key"} 

31 response = self.client.post("/api/store/1/models", data=payload) 

32 data = response.json 

33 

34 self.assertEqual(response.status_code, 500) 

35 self.assertFalse(data["success"]) 

36 self.assertIn("Invalid API key", data["message"]) 

37 

38 def test_name_too_long(self): 

39 payload = {"name": "some_random_long_name" * 7} 

40 response = self.client.post("/api/store/1/models", data=payload) 

41 data = response.json 

42 

43 self.assertEqual(response.status_code, 500) 

44 self.assertFalse(data["success"]) 

45 self.assertEqual( 

46 data["message"], "Name is too long. Limit 128 characters" 

47 ) 

48 

49 def test_missing_name(self): 

50 payload = {"api_key": self.api_key} 

51 response = self.client.post("/api/store/1/models", data=payload) 

52 data = response.json 

53 

54 self.assertEqual(response.status_code, 500) 

55 self.assertFalse(data["success"]) 

56 self.assertEqual(data["message"], "An error occurred") 

57 

58 

59class TestGetModels(TestModelServiceEndpoints): 

60 @patch( 

61 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

62 ) 

63 def test_get_models(self, mock_get_store_models): 

64 mock_get_store_models.return_value = { 

65 "models": [{"name": "test_model"}] 

66 } 

67 

68 response = self.client.get("/api/store/1/models") 

69 data = response.json 

70 

71 self.assertEqual(response.status_code, 200) 

72 self.assertIsNotNone(data["data"]) 

73 

74 @patch( 

75 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

76 ) 

77 def test_store_has_no_models(self, mock_get_store_models): 

78 mock_get_store_models.return_value = {"models": []} 

79 

80 response = self.client.get("/api/store/2/models") 

81 data = response.json["data"] 

82 

83 success = response.json["success"] 

84 self.assertEqual(response.status_code, 200) 

85 self.assertTrue(success) 

86 self.assertEqual(data["models"], []) 

87 

88 @patch( 

89 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

90 ) 

91 def test_invalid_store_id(self, mock_get_store_models): 

92 mock_get_store_models.side_effect = StoreApiResponseErrorList( 

93 "Store not found", 

94 404, 

95 [{"message": "Store not found"}], 

96 ) 

97 

98 response = self.client.get("/api/store/3/models") 

99 data = response.json 

100 

101 self.assertEqual(response.status_code, 500) 

102 self.assertFalse(data["success"]) 

103 self.assertIn("Store not found", data["message"]) 

104 

105 @patch( 

106 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

107 ) 

108 def test_unauthorized_user(self, mock_get_store_models): 

109 mock_get_store_models.side_effect = StoreApiResponseErrorList( 

110 "unauthorized", 401, [{"message": "unauthorized"}] 

111 ) 

112 

113 response = self.client.get("/api/store/1/models") 

114 data = response.json 

115 

116 self.assertEqual(response.status_code, 500) 

117 self.assertFalse(data["success"]) 

118 self.assertIn("Store not found", data["message"]) 

119 

120 

121class TestUpdateModel(TestModelServiceEndpoints): 

122 @patch( 

123 "canonicalwebteam.store_api.publishergw.PublisherGW.update_store_model" 

124 ) 

125 def test_update_model(self, mock_update_store_model): 

126 mock_update_store_model.return_value = None 

127 

128 payload = {"api_key": self.api_key} 

129 response = self.client.patch( 

130 "/api/store/1/models/Model1", data=payload 

131 ) 

132 data = response.json 

133 

134 self.assertEqual(response.status_code, 200) 

135 self.assertTrue(data["success"]) 

136 

137 def test_update_model_with_invalid_api_key(self): 

138 payload = {"api_key": "invalid_api_key"} 

139 response = self.client.patch( 

140 "/api/store/1/models/Model1", data=payload 

141 ) 

142 data = response.json 

143 

144 self.assertEqual(response.status_code, 500) 

145 self.assertFalse(data["success"]) 

146 self.assertEqual(data["message"], "Invalid API key") 

147 

148 @patch( 

149 "canonicalwebteam.store_api.publishergw.PublisherGW.update_store_model" 

150 ) 

151 def test_model_not_found(self, mock_update_store_model): 

152 mock_update_store_model.side_effect = StoreApiResourceNotFound( 

153 "Model not found", 404, [{"message": "Model not found"}] 

154 ) 

155 

156 payload = {"api_key": self.api_key} 

157 response = self.client.patch( 

158 "/api/store/1/models/Model1", data=payload 

159 ) 

160 data = response.json 

161 

162 self.assertEqual(response.status_code, 500) 

163 self.assertFalse(data["success"]) 

164 self.assertEqual(data["message"], "Model not found") 

165 

166 

167class TestGetRemodelAllowlist(TestModelServiceEndpoints): 

168 @patch( 

169 "canonicalwebteam.store_api.publishergw.PublisherGW" 

170 + ".get_remodel_allowlist" 

171 ) 

172 def test_get_remodel_allowlist_success(self, mock_get_remodel_allowlist): 

173 mock_allowlist = { 

174 "allowlist": [ 

175 { 

176 "created-at": "2026-02-03T11:31:06Z", 

177 "created-by": "test-user-id", 

178 "description": "Test description", 

179 "from-model": "test-from-model", 

180 "from-serial": "test-from-serial", 

181 "modified-at": None, 

182 "modified-by": None, 

183 "to-model": "test-to-model", 

184 } 

185 ] 

186 } 

187 mock_get_remodel_allowlist.return_value = mock_allowlist 

188 

189 response = self.client.get("/api/store/1/models/remodel-allowlist") 

190 data = response.json 

191 

192 self.assertEqual(response.status_code, 200) 

193 self.assertTrue(data["success"]) 

194 self.assertEqual(data["data"], mock_allowlist) 

195 

196 @patch( 

197 "canonicalwebteam.store_api.publishergw.PublisherGW" 

198 + ".get_remodel_allowlist" 

199 ) 

200 def test_get_remodel_allowlist_empty(self, mock_get_remodel_allowlist): 

201 mock_get_remodel_allowlist.return_value = {"allowlist": []} 

202 

203 response = self.client.get("/api/store/1/models/remodel-allowlist") 

204 data = response.json 

205 

206 self.assertEqual(response.status_code, 200) 

207 self.assertTrue(data["success"]) 

208 self.assertEqual(data["data"]["allowlist"], []) 

209 

210 @patch( 

211 "canonicalwebteam.store_api.publishergw.PublisherGW" 

212 + ".get_remodel_allowlist" 

213 ) 

214 def test_get_remodel_allowlist_unauthorized( 

215 self, mock_get_remodel_allowlist 

216 ): 

217 mock_get_remodel_allowlist.side_effect = StoreApiResponseErrorList( 

218 "unauthorized", 401, [{"message": "unauthorized"}] 

219 ) 

220 

221 response = self.client.get("/api/store/1/models/remodel-allowlist") 

222 data = response.json 

223 

224 self.assertEqual(response.status_code, 500) 

225 self.assertFalse(data["success"]) 

226 self.assertEqual(data["message"], "Store not found") 

227 

228 @patch( 

229 "canonicalwebteam.store_api.publishergw.PublisherGW" 

230 + ".get_remodel_allowlist" 

231 ) 

232 def test_get_remodel_allowlist_store_not_found( 

233 self, mock_get_remodel_allowlist 

234 ): 

235 mock_get_remodel_allowlist.side_effect = StoreApiResponseErrorList( 

236 "Store not found", 404, [{"message": "Store not found"}] 

237 ) 

238 

239 response = self.client.get("/api/store/999/models/remodel-allowlist") 

240 data = response.json 

241 

242 self.assertEqual(response.status_code, 500) 

243 self.assertFalse(data["success"]) 

244 self.assertEqual(data["message"], "Store not found") 

245 

246 @patch( 

247 "canonicalwebteam.store_api.publishergw.PublisherGW" 

248 + ".get_remodel_allowlist" 

249 ) 

250 def test_get_remodel_allowlist_general_error( 

251 self, mock_get_remodel_allowlist 

252 ): 

253 mock_get_remodel_allowlist.side_effect = StoreApiResponseErrorList( 

254 "Internal server error", 

255 500, 

256 [{"message": "Internal server error"}], 

257 ) 

258 

259 response = self.client.get("/api/store/1/models/remodel-allowlist") 

260 data = response.json 

261 

262 self.assertEqual(response.status_code, 500) 

263 self.assertFalse(data["success"]) 

264 self.assertEqual(data["message"], "Internal server error")