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 super().setUp() 

19 

20 

21class TestGetModels(TestModelServiceEndpoints): 

22 @patch( 

23 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

24 ) 

25 def test_get_models(self, mock_get_store_models): 

26 mock_get_store_models.return_value = { 

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

28 } 

29 

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

31 data = response.json 

32 

33 self.assertEqual(response.status_code, 200) 

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

35 

36 @patch( 

37 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

38 ) 

39 def test_store_has_no_models(self, mock_get_store_models): 

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

41 

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

43 data = response.json["data"] 

44 

45 success = response.json["success"] 

46 self.assertEqual(response.status_code, 200) 

47 self.assertTrue(success) 

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

49 

50 @patch( 

51 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

52 ) 

53 def test_invalid_store_id(self, mock_get_store_models): 

54 mock_get_store_models.side_effect = StoreApiResponseErrorList( 

55 "Store not found", 

56 404, 

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

58 ) 

59 

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

61 data = response.json 

62 

63 self.assertEqual(response.status_code, 500) 

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

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

66 

67 @patch( 

68 "canonicalwebteam.store_api.publishergw.PublisherGW.get_store_models" 

69 ) 

70 def test_unauthorized_user(self, mock_get_store_models): 

71 mock_get_store_models.side_effect = StoreApiResponseErrorList( 

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

73 ) 

74 

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

76 data = response.json 

77 

78 self.assertEqual(response.status_code, 500) 

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

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

81 

82 

83class TestCreateModel(TestModelServiceEndpoints): 

84 @patch( 

85 "canonicalwebteam.store_api.publishergw.PublisherGW.create_store_model" 

86 ) 

87 def test_create_model(self, mock_create_store_model): 

88 mock_create_store_model.return_value = None 

89 

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

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

92 data = response.json 

93 

94 self.assertEqual(response.status_code, 201) 

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

96 

97 def test_create_model_with_invalid_api_key(self): 

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

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

100 data = response.json 

101 

102 self.assertEqual(response.status_code, 500) 

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

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

105 

106 def test_name_too_long(self): 

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

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

109 data = response.json 

110 

111 self.assertEqual(response.status_code, 500) 

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

113 self.assertEqual( 

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

115 ) 

116 

117 def test_missing_name(self): 

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

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

120 data = response.json 

121 

122 self.assertEqual(response.status_code, 500) 

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

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

125 

126 

127class TestUpdateModel(TestModelServiceEndpoints): 

128 @patch( 

129 "canonicalwebteam.store_api.publishergw.PublisherGW.update_store_model" 

130 ) 

131 def test_update_model(self, mock_update_store_model): 

132 mock_update_store_model.return_value = None 

133 

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

135 response = self.client.patch( 

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

137 ) 

138 data = response.json 

139 

140 self.assertEqual(response.status_code, 200) 

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

142 

143 def test_update_model_with_invalid_api_key(self): 

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

145 response = self.client.patch( 

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

147 ) 

148 data = response.json 

149 

150 self.assertEqual(response.status_code, 500) 

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

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

153 

154 @patch( 

155 "canonicalwebteam.store_api.publishergw.PublisherGW.update_store_model" 

156 ) 

157 def test_model_not_found(self, mock_update_store_model): 

158 mock_update_store_model.side_effect = StoreApiResourceNotFound( 

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

160 ) 

161 

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

163 response = self.client.patch( 

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

165 ) 

166 data = response.json 

167 

168 self.assertEqual(response.status_code, 500) 

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

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