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

1from unittest.mock import patch, Mock 

2from canonicalwebteam.exceptions import StoreApiResponseErrorList 

3 

4from tests.endpoints.endpoint_testing import TestModelServiceEndpoints 

5 

6 

7class TestGetPolicies(TestModelServiceEndpoints): 

8 @patch( 

9 "canonicalwebteam.store_api.dashboard.Dashboard.get_store", 

10 Mock(return_value={"brand-id": "BrandName"}), 

11 ) 

12 @patch( 

13 "canonicalwebteam.store_api.publishergw." 

14 "PublisherGW.get_store_model_policies" 

15 ) 

16 def test_get_policies(self, mock_get_store_model_policies): 

17 mock_get_store_model_policies.return_value = ["policy1", "policy2"] 

18 

19 response = self.client.get("/api/store/1/models/Model1/policies") 

20 data = response.json 

21 

22 self.assertEqual(response.status_code, 200) 

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

24 self.assertEqual(data["data"], ["policy1", "policy2"]) 

25 

26 @patch( 

27 "canonicalwebteam.store_api.dashboard.Dashboard.get_store", 

28 Mock(return_value={"brand-id": "BrandName"}), 

29 ) 

30 @patch( 

31 "canonicalwebteam.store_api.publishergw." 

32 "PublisherGW.get_store_model_policies" 

33 ) 

34 def test_failed_get_policies(self, mock_get_store_model_policies): 

35 mock_get_store_model_policies.side_effect = StoreApiResponseErrorList( 

36 "An error occurred", 500, [{"message": "An error occurred"}] 

37 ) 

38 

39 response = self.client.get("/api/store/1/models/Model1/policies") 

40 data = response.json 

41 

42 self.assertEqual(response.status_code, 500) 

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

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

45 

46 

47class TestDeletePolicies(TestModelServiceEndpoints): 

48 @patch( 

49 "canonicalwebteam.store_api.publishergw." 

50 "PublisherGW.delete_store_model_policy" 

51 ) 

52 def test_successful_delete_policy(self, mock_delete_store_model_policy): 

53 mock_delete_store_model_policy.return_value = Mock(status_code=204) 

54 

55 response = self.client.delete("/api/store/1/models/Model1/policies/1") 

56 data = response.json 

57 

58 self.assertEqual(response.status_code, 200) 

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

60 

61 @patch( 

62 "canonicalwebteam.store_api.publishergw." 

63 "PublisherGW.delete_store_model_policy" 

64 ) 

65 def test_policy_not_found(self, mock_delete_store_model_policy): 

66 mock_delete_store_model_policy.return_value = Mock(status_code=404) 

67 

68 response = self.client.delete("/api/store/1/models/Model1/policies/1") 

69 data = response.json 

70 

71 self.assertEqual(response.status_code, 404) 

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

73 self.assertEqual(data["message"], "Policy not found") 

74 

75 @patch( 

76 "canonicalwebteam.store_api.publishergw." 

77 "PublisherGW.delete_store_model_policy" 

78 ) 

79 def test_exception_in_delete_policy(self, mock_delete_store_model_policy): 

80 mock_delete_store_model_policy.side_effect = StoreApiResponseErrorList( 

81 "An error occured", 500, [{"message": "An error occurred"}] 

82 ) 

83 

84 response = self.client.delete("/api/store/1/models/Model1/policies/1") 

85 data = response.json 

86 

87 self.assertEqual(response.status_code, 500) 

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

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

90 

91 

92class TestCreatePolicies(TestModelServiceEndpoints): 

93 @patch( 

94 "canonicalwebteam.store_api.publishergw." 

95 "PublisherGW.get_store_signing_keys" 

96 ) 

97 @patch( 

98 "canonicalwebteam.store_api.publishergw." 

99 "PublisherGW.create_store_model_policy" 

100 ) 

101 def test_create_policy( 

102 self, mock_create_store_model_policy, mock_get_store_signing_keys 

103 ): 

104 mock_get_store_signing_keys.return_value = [ 

105 {"sha3-384": "valid_signing_key"} 

106 ] 

107 mock_create_store_model_policy.return_value = None 

108 

109 payload = {"signing_key": "valid_signing_key"} 

110 response = self.client.post( 

111 "/api/store/1/models/Model1/policies", data=payload 

112 ) 

113 data = response.json 

114 

115 self.assertEqual(response.status_code, 200) 

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

117 

118 @patch( 

119 "canonicalwebteam.store_api.publishergw." 

120 "PublisherGW.get_store_signing_keys" 

121 ) 

122 def test_missing_signing_key(self, mock_get_store_signing_keys): 

123 mock_get_store_signing_keys.return_value = [ 

124 {"sha3-384": "valid_signing_key"} 

125 ] 

126 

127 payload = {} 

128 response = self.client.post( 

129 "/api/store/1/models/Model1/policies", data=payload 

130 ) 

131 data = response.json 

132 

133 self.assertEqual(response.status_code, 500) 

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

135 self.assertEqual(data["message"], "Signing key required") 

136 

137 @patch( 

138 "canonicalwebteam.store_api.publishergw." 

139 "PublisherGW.get_store_signing_keys" 

140 ) 

141 def test_invalid_signing_key(self, mock_get_store_signing_keys): 

142 mock_get_store_signing_keys.return_value = [{"sha3-384": "valid_key"}] 

143 

144 payload = {"signing_key": "invalid_key"} 

145 response = self.client.post( 

146 "/api/store/1/models/Model1/policies", 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 signing key") 

153 

154 @patch( 

155 "canonicalwebteam.store_api.publishergw." 

156 "PublisherGW.get_store_signing_keys" 

157 ) 

158 @patch( 

159 "canonicalwebteam.store_api.publishergw." 

160 "PublisherGW.create_store_model_policy" 

161 ) 

162 def test_exception_in_create_policy( 

163 self, 

164 mock_create_store_model_policy, 

165 mock_get_store_signing_keys, 

166 ): 

167 mock_get_store_signing_keys.return_value = [{"sha3-384": "valid_key"}] 

168 mock_create_store_model_policy.side_effect = StoreApiResponseErrorList( 

169 "Simulated failure", 500, [{"message": "An error occurred"}] 

170 ) 

171 

172 payload = {"signing_key": "valid_key"} 

173 response = self.client.post( 

174 "/api/store/1/models/Model1/policies", data=payload 

175 ) 

176 data = response.json 

177 

178 self.assertEqual(response.status_code, 500) 

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

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