Coverage for tests/admin/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.admin.admin_endpoint_testing import TestAdminEndpoints 

10 

11 

12candid = CandidClient(api_publisher_session) 

13 

14 

15class TestModelServiceEndpoints(TestAdminEndpoints): 

16 def setUp(self): 

17 self.api_key = "qwertyuioplkjhgfdsazxcvbnmkiopuytrewqasdfghjklmnbv" 

18 self.mock_get_store = patch( 

19 "webapp.admin.views.dashboard.get_store" 

20 ).start() 

21 super().setUp() 

22 

23 

24class TestGetModels(TestModelServiceEndpoints): 

25 @patch( 

26 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

27 ) 

28 def test_get_models(self, mock_get_store_models): 

29 mock_get_store_models.return_value = { 

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

31 } 

32 

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

34 data = response.json 

35 

36 self.assertEqual(response.status_code, 200) 

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

38 

39 @patch( 

40 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

41 ) 

42 def test_store_has_no_models(self, mock_get_store_models): 

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

44 

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

46 data = response.json["data"] 

47 

48 success = response.json["success"] 

49 self.assertEqual(response.status_code, 200) 

50 self.assertTrue(success) 

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

52 

53 @patch( 

54 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

55 ) 

56 def test_invalid_store_id(self, mock_get_store_models): 

57 mock_get_store_models.side_effect = StoreApiResponseErrorList( 

58 "Store not found", 

59 404, 

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

61 ) 

62 

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

64 data = response.json 

65 

66 self.assertEqual(response.status_code, 500) 

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

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

69 

70 @patch( 

71 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

72 ) 

73 def test_unauthorized_user(self, mock_get_store_models): 

74 mock_get_store_models.side_effect = StoreApiResponseErrorList( 

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

76 ) 

77 

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

79 data = response.json 

80 

81 self.assertEqual(response.status_code, 500) 

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

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

84 

85 

86class TestCreateModel(TestModelServiceEndpoints): 

87 @patch( 

88 "canonicalwebteam.store_api.publishergw.PublisherGW.create_store_model" 

89 ) 

90 def test_create_model(self, mock_create_store_model): 

91 mock_create_store_model.return_value = None 

92 

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

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

95 data = response.json 

96 

97 self.assertEqual(response.status_code, 201) 

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

99 

100 def test_create_model_with_invalid_api_key(self): 

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

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

103 data = response.json 

104 

105 self.assertEqual(response.status_code, 500) 

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

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

108 

109 def test_name_too_long(self): 

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

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

112 data = response.json 

113 

114 self.assertEqual(response.status_code, 500) 

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

116 self.assertEqual( 

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

118 ) 

119 

120 def test_missing_name(self): 

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

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

123 data = response.json 

124 

125 self.assertEqual(response.status_code, 500) 

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

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

128 

129 

130class TestUpdateModel(TestModelServiceEndpoints): 

131 @patch( 

132 "canonicalwebteam.store_api.publishergw.PublisherGW.update_store_model" 

133 ) 

134 def test_update_model(self, mock_update_store_model): 

135 mock_update_store_model.return_value = None 

136 

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

138 response = self.client.patch( 

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

140 ) 

141 data = response.json 

142 

143 self.assertEqual(response.status_code, 200) 

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

145 

146 def test_update_model_with_invalid_api_key(self): 

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

148 response = self.client.patch( 

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

150 ) 

151 data = response.json 

152 

153 self.assertEqual(response.status_code, 500) 

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

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

156 

157 @patch( 

158 "canonicalwebteam.store_api.publishergw.PublisherGW.update_store_model" 

159 ) 

160 def test_model_not_found(self, mock_update_store_model): 

161 mock_update_store_model.side_effect = StoreApiResourceNotFound( 

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

163 ) 

164 

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

166 response = self.client.patch( 

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

168 ) 

169 data = response.json 

170 

171 self.assertEqual(response.status_code, 500) 

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

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