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

1from unittest.mock import Mock, patch 

2from canonicalwebteam.exceptions import StoreApiResponseErrorList 

3 

4from tests.admin.tests_models import TestModelServiceEndpoints 

5 

6 

7class TestGetPolicies(TestModelServiceEndpoints): 

8 @patch( 

9 "canonicalwebteam.store_api.publishergw." 

10 "PublisherGW.get_store_model_policies" 

11 ) 

12 def test_get_policies(self, mock_get_store_model_policies): 

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

14 

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

16 data = response.json 

17 

18 self.assertEqual(response.status_code, 200) 

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

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

21 

22 @patch( 

23 "canonicalwebteam.store_api.publishergw." 

24 "PublisherGW.get_store_model_policies" 

25 ) 

26 def test_failed_get_policies(self, mock_get_store_model_policies): 

27 mock_get_store_model_policies.side_effect = StoreApiResponseErrorList( 

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

29 ) 

30 

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

32 data = response.json 

33 

34 self.assertEqual(response.status_code, 500) 

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

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

37 

38 

39class TestCreatePolicies(TestModelServiceEndpoints): 

40 @patch( 

41 "canonicalwebteam.store_api.publishergw." 

42 "PublisherGW.get_store_signing_keys" 

43 ) 

44 @patch( 

45 "canonicalwebteam.store_api.publishergw." 

46 "PublisherGW.create_store_model_policy" 

47 ) 

48 def test_create_policy( 

49 self, mock_create_store_model_policy, mock_get_store_signing_keys 

50 ): 

51 mock_get_store_signing_keys.return_value = [ 

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

53 ] 

54 mock_create_store_model_policy.return_value = None 

55 

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

57 response = self.client.post( 

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

59 ) 

60 data = response.json 

61 

62 self.assertEqual(response.status_code, 200) 

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

64 

65 @patch( 

66 "canonicalwebteam.store_api.publishergw." 

67 "PublisherGW.get_store_signing_keys" 

68 ) 

69 def test_missing_signing_key(self, mock_get_store_signing_keys): 

70 mock_get_store_signing_keys.return_value = [ 

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

72 ] 

73 

74 payload = {} 

75 response = self.client.post( 

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

77 ) 

78 data = response.json 

79 

80 self.assertEqual(response.status_code, 500) 

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

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

83 

84 @patch( 

85 "canonicalwebteam.store_api.publishergw." 

86 "PublisherGW.get_store_signing_keys" 

87 ) 

88 def test_invalid_signing_key(self, mock_get_store_signing_keys): 

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

90 

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

92 response = self.client.post( 

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

94 ) 

95 data = response.json 

96 

97 self.assertEqual(response.status_code, 500) 

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

99 self.assertEqual(data["message"], "Invalid signing key") 

100 

101 @patch( 

102 "canonicalwebteam.store_api.publishergw." 

103 "PublisherGW.get_store_signing_keys" 

104 ) 

105 @patch( 

106 "canonicalwebteam.store_api.publishergw." 

107 "PublisherGW.create_store_model_policy" 

108 ) 

109 def test_exception_in_create_policy( 

110 self, 

111 mock_create_store_model_policy, 

112 mock_get_store_signing_keys, 

113 ): 

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

115 mock_create_store_model_policy.side_effect = StoreApiResponseErrorList( 

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

117 ) 

118 

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

120 response = self.client.post( 

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

122 ) 

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 TestDeletePolicies(TestModelServiceEndpoints): 

131 @patch( 

132 "canonicalwebteam.store_api.publishergw." 

133 "PublisherGW.delete_store_model_policy" 

134 ) 

135 def test_successful_delete_policy(self, mock_delete_store_model_policy): 

136 mock_delete_store_model_policy.return_value = Mock(status_code=204) 

137 

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

139 data = response.json 

140 

141 self.assertEqual(response.status_code, 200) 

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

143 

144 @patch( 

145 "canonicalwebteam.store_api.publishergw." 

146 "PublisherGW.delete_store_model_policy" 

147 ) 

148 def test_policy_not_found(self, mock_delete_store_model_policy): 

149 mock_delete_store_model_policy.return_value = Mock(status_code=404) 

150 

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

152 data = response.json 

153 

154 self.assertEqual(response.status_code, 500) 

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

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

157 

158 @patch( 

159 "canonicalwebteam.store_api.publishergw." 

160 "PublisherGW.delete_store_model_policy" 

161 ) 

162 def test_exception_in_delete_policy(self, mock_delete_store_model_policy): 

163 mock_delete_store_model_policy.side_effect = StoreApiResponseErrorList( 

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

165 ) 

166 

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

168 data = response.json 

169 

170 self.assertEqual(response.status_code, 500) 

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

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