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")