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

1from unittest.mock import Mock, patch 

2from tests.admin.tests_models import TestModelServiceEndpoints 

3from canonicalwebteam.exceptions import StoreApiResponseErrorList 

4 

5 

6class TestGetSigningKeys(TestModelServiceEndpoints): 

7 @patch( 

8 "canonicalwebteam.store_api.publishergw." 

9 "PublisherGW.get_store_signing_keys" 

10 ) 

11 def test_get_signing_keys(self, mock_get_store_signing_keys): 

12 mock_get_store_signing_keys.return_value = [ 

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

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

15 ] 

16 

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

18 data = response.json 

19 

20 self.assertEqual(response.status_code, 200) 

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

22 self.assertEqual( 

23 data["data"], 

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

25 ) 

26 

27 @patch( 

28 "canonicalwebteam.store_api.publishergw." 

29 "PublisherGW.get_store_signing_keys" 

30 ) 

31 def test_failed_get_signing_keys(self, mock_get_store_signing_keys): 

32 mock_get_store_signing_keys.side_effect = StoreApiResponseErrorList( 

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

34 ) 

35 

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

37 data = response.json 

38 

39 self.assertEqual(response.status_code, 500) 

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

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

42 

43 

44class TestCreateSigningKeys(TestModelServiceEndpoints): 

45 @patch( 

46 "canonicalwebteam.store_api.publishergw." 

47 "PublisherGW.create_store_signing_key" 

48 ) 

49 def test_create_signing_key(self, mock_create_store_signing_key): 

50 mock_create_store_signing_key.return_value = None 

51 

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

53 response = self.client.post( 

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

55 data=payload, 

56 ) 

57 self.assertEqual(response.status_code, 200) 

58 data = response.json 

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

60 

61 def test_name_too_long_create_signing_key(self): 

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

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

64 data = response.json 

65 

66 self.assertEqual(response.status_code, 500) 

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

68 self.assertEqual( 

69 data["message"], 

70 "Invalid signing key. Limit 128 characters", 

71 ) 

72 

73 @patch( 

74 "canonicalwebteam.store_api.publishergw." 

75 "PublisherGW.create_store_signing_key" 

76 ) 

77 def test_exception_in_create_signing_key( 

78 self, 

79 mock_create_store_signing_key, 

80 ): 

81 mock_create_store_signing_key.side_effect = StoreApiResponseErrorList( 

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

83 ) 

84 

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

86 response = self.client.post( 

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

88 data=payload, 

89 ) 

90 data = response.json 

91 

92 self.assertEqual(response.status_code, 500) 

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

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

95 

96 

97class TestDeleteSigningKeys(TestModelServiceEndpoints): 

98 @patch( 

99 "canonicalwebteam.store_api.publishergw." 

100 "PublisherGW.delete_store_signing_key" 

101 ) 

102 def test_successful_delete_signing_key( 

103 self, 

104 mock_delete_store_signing_key, 

105 ): 

106 mock_delete_store_signing_key.return_value = Mock(status_code=204) 

107 

108 response = self.client.delete( 

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

110 ) 

111 data = response.json 

112 

113 self.assertEqual(response.status_code, 200) 

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

115 

116 @patch( 

117 "canonicalwebteam.store_api.publishergw." 

118 "PublisherGW.delete_store_signing_key" 

119 ) 

120 @patch( 

121 "canonicalwebteam.store_api.publishergw." 

122 "PublisherGW.get_store_models" 

123 ) 

124 @patch( 

125 "canonicalwebteam.store_api.publishergw." 

126 "PublisherGW.get_store_model_policies" 

127 ) 

128 def test_signing_key_in_use( 

129 self, mock_get_policies, mock_get_models, mock_delete_store_signing_key 

130 ): 

131 mock_delete_store_signing_key.side_effect = StoreApiResponseErrorList( 

132 "Signing key is in use", 

133 409, 

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

135 ) 

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

137 mock_get_policies.return_value = [ 

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

139 ] 

140 

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

142 data = response.json 

143 

144 self.assertEqual(response.status_code, 500) 

145 self.assertEqual( 

146 data["message"], 

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

148 ) 

149 self.assertEqual( 

150 data["data"]["models"], 

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

152 ) 

153 

154 @patch( 

155 "canonicalwebteam.store_api.publishergw." 

156 "PublisherGW.delete_store_signing_key" 

157 ) 

158 def test_signing_key_not_found(self, mock_delete_store_signing_key): 

159 mock_delete_store_signing_key.return_value = Mock(status_code=404) 

160 

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

162 data = response.json 

163 

164 self.assertEqual(response.status_code, 404) 

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

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