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

1from unittest.mock import patch, Mock 

2from tests.endpoints.endpoint_testing import TestModelServiceEndpoints 

3from canonicalwebteam.exceptions import StoreApiResponseErrorList 

4 

5 

6class TestGetSigningKeys(TestModelServiceEndpoints): 

7 @patch( 

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

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

10 ) 

11 @patch( 

12 "canonicalwebteam.store_api.publishergw." 

13 "PublisherGW.get_store_signing_keys" 

14 ) 

15 def test_get_signing_keys(self, mock_get_store_signing_keys): 

16 mock_get_store_signing_keys.return_value = [ 

17 {"sha3-384": "key1"}, 

18 {"sha3-384": "key2"}, 

19 ] 

20 

21 response = self.client.get("/api/store/1/signing-keys") 

22 data = response.json 

23 

24 self.assertEqual(response.status_code, 200) 

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

26 self.assertEqual( 

27 data["data"], 

28 [{"sha3-384": "key1"}, {"sha3-384": "key2"}], 

29 ) 

30 

31 @patch( 

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

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

34 ) 

35 @patch( 

36 "canonicalwebteam.store_api.publishergw." 

37 "PublisherGW.get_store_signing_keys" 

38 ) 

39 def test_failed_get_signing_keys(self, mock_get_store_signing_keys): 

40 mock_get_store_signing_keys.side_effect = StoreApiResponseErrorList( 

41 "error", 502, [{"message": "An error occurred"}] 

42 ) 

43 

44 response = self.client.get("/api/store/1/signing-keys") 

45 data = response.json 

46 

47 self.assertEqual(response.status_code, 500) 

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

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

50 

51 

52class TestCreateSigningKeys(TestModelServiceEndpoints): 

53 @patch( 

54 "canonicalwebteam.store_api.publishergw." 

55 "PublisherGW.create_store_signing_key" 

56 ) 

57 def test_create_signing_key(self, mock_create_store_signing_key): 

58 mock_create_store_signing_key.return_value = None 

59 

60 payload = {"name": "test_signing_key"} 

61 response = self.client.post( 

62 "/api/store/1/signing-keys", 

63 data=payload, 

64 ) 

65 self.assertEqual(response.status_code, 200) 

66 data = response.json 

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

68 

69 def test_name_too_long_create_signing_key(self): 

70 payload = {"name": "random name" * 12} 

71 response = self.client.post("/api/store/1/signing-keys", data=payload) 

72 data = response.json 

73 

74 self.assertEqual(response.status_code, 500) 

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

76 self.assertEqual( 

77 data["message"], 

78 "Invalid signing key. Limit 128 characters", 

79 ) 

80 

81 @patch( 

82 "canonicalwebteam.store_api.publishergw." 

83 "PublisherGW.create_store_signing_key" 

84 ) 

85 def test_exception_in_create_signing_key( 

86 self, 

87 mock_create_store_signing_key, 

88 ): 

89 mock_create_store_signing_key.side_effect = StoreApiResponseErrorList( 

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

91 ) 

92 

93 payload = {"name": "test_signing_key"} 

94 response = self.client.post( 

95 "/api/store/1/signing-keys", 

96 data=payload, 

97 ) 

98 data = response.json 

99 

100 self.assertEqual(response.status_code, 500) 

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

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

103 

104 

105class TestDeleteSigningKeys(TestModelServiceEndpoints): 

106 @patch( 

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

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

109 ) 

110 @patch( 

111 "canonicalwebteam.store_api.publishergw." 

112 "PublisherGW.delete_store_signing_key" 

113 ) 

114 def test_successful_delete_signing_key( 

115 self, 

116 mock_delete_store_signing_key, 

117 ): 

118 mock_delete_store_signing_key.return_value = Mock(status_code=204) 

119 

120 response = self.client.delete( 

121 "/api/store/1/signing-keys/signing_key_sha3_384" 

122 ) 

123 data = response.json 

124 

125 self.assertEqual(response.status_code, 200) 

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

127 

128 @patch( 

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

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

131 ) 

132 @patch( 

133 "canonicalwebteam.store_api.publishergw." 

134 "PublisherGW.delete_store_signing_key" 

135 ) 

136 @patch( 

137 "canonicalwebteam.store_api.publishergw." 

138 "PublisherGW.get_store_models" 

139 ) 

140 @patch( 

141 "canonicalwebteam.store_api.publishergw." 

142 "PublisherGW.get_store_model_policies" 

143 ) 

144 def test_signing_key_in_use( 

145 self, mock_get_policies, mock_get_models, mock_delete_store_signing_key 

146 ): 

147 mock_delete_store_signing_key.side_effect = StoreApiResponseErrorList( 

148 "Signing key is in use", 

149 409, 

150 [{"message": "key used to sign at least one serial policy"}], 

151 ) 

152 mock_get_models.return_value = [{"name": "Model1"}] 

153 mock_get_policies.return_value = [ 

154 {"revision": "1", "signing-key-sha3-384": "valid_key"} 

155 ] 

156 

157 response = self.client.delete("/api/store/1/signing-keys/valid_key") 

158 data = response.json 

159 

160 self.assertEqual(response.status_code, 500) 

161 self.assertEqual( 

162 data["message"], 

163 "Signing key is used in at least one policy", 

164 ) 

165 self.assertEqual( 

166 data["data"]["models"], 

167 [{"name": "Model1", "policies": [{"revision": "1"}]}], 

168 ) 

169 

170 @patch( 

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

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

173 ) 

174 @patch( 

175 "canonicalwebteam.store_api.publishergw." 

176 "PublisherGW.delete_store_signing_key" 

177 ) 

178 def test_signing_key_not_found(self, mock_delete_store_signing_key): 

179 mock_delete_store_signing_key.return_value = Mock(status_code=404) 

180 

181 response = self.client.delete("/api/store/1/signing-keys/invalid_key") 

182 data = response.json 

183 

184 self.assertEqual(response.status_code, 404) 

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

186 self.assertEqual(data["message"], "Signing key not found")