Coverage for manila/tests/share/test_drivers_private_data.py: 100%

1# Copyright 2015 Mirantis inc. 

2# All Rights Reserved. 

3# 

4# Licensed under the Apache License, Version 2.0 (the "License"); you may 

5# not use this file except in compliance with the License. You may obtain 

6# a copy of the License at 

7# 

8# http://www.apache.org/licenses/LICENSE-2.0 

9# 

10# Unless required by applicable law or agreed to in writing, software 

11# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

12# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

13# License for the specific language governing permissions and limitations 

14# under the License. 

15 

16from unittest import mock 

17 

18import ddt 

19from oslo_utils import uuidutils 

20 

21from manila.share import drivers_private_data as pd 

22from manila import test 

23 

24 

25@ddt.ddt 

26class DriverPrivateDataTestCase(test.TestCase): 

27 """Tests DriverPrivateData.""" 

28 

29 def setUp(self): 

30 super(DriverPrivateDataTestCase, self).setUp() 

31 

32 self.fake_storage = mock.Mock() 

33 self.entity_id = uuidutils.generate_uuid() 

34 

35 def test_default_storage_driver(self): 

36 private_data = pd.DriverPrivateData( 

37 storage=None, context="fake", backend_host="fake") 

38 

39 self.assertIsInstance(private_data._storage, pd.SqlStorageDriver) 

40 

41 def test_custom_storage_driver(self): 

42 private_data = pd.DriverPrivateData(storage=self.fake_storage) 

43 

44 self.assertEqual(self.fake_storage, private_data._storage) 

45 

46 def test_invalid_parameters(self): 

47 self.assertRaises(ValueError, pd.DriverPrivateData) 

48 

49 @ddt.data({'context': 'fake'}, {'backend_host': 'fake'}) 

50 def test_invalid_single_parameter(self, test_args): 

51 self.assertRaises(ValueError, pd.DriverPrivateData, **test_args) 

52 

53 @ddt.data("111", ["fake"], None) 

54 def test_validate_entity_id_invalid(self, entity_id): 

55 data = pd.DriverPrivateData(storage="fake") 

56 

57 self.assertRaises(ValueError, data._validate_entity_id, entity_id) 

58 

59 def test_validate_entity_id_valid(self): 

60 actual_result = ( 

61 pd.DriverPrivateData._validate_entity_id(self.entity_id) 

62 ) 

63 

64 self.assertIsNone(actual_result) 

65 

66 def test_update(self): 

67 data = pd.DriverPrivateData(storage=self.fake_storage) 

68 details = {"foo": "bar"} 

69 self.mock_object(self.fake_storage, 'update', 

70 mock.Mock(return_value=True)) 

71 

72 actual_result = data.update( 

73 self.entity_id, 

74 details, 

75 delete_existing=True 

76 ) 

77 

78 self.assertTrue(actual_result) 

79 self.fake_storage.update.assert_called_once_with( 

80 self.entity_id, details, True 

81 ) 

82 

83 def test_update_invalid(self): 

84 data = pd.DriverPrivateData(storage=self.fake_storage) 

85 details = ["invalid"] 

86 self.mock_object(self.fake_storage, 'update', 

87 mock.Mock(return_value=True)) 

88 

89 self.assertRaises( 

90 ValueError, data.update, self.entity_id, details) 

91 

92 self.assertFalse(self.fake_storage.update.called) 

93 

94 def test_get(self): 

95 data = pd.DriverPrivateData(storage=self.fake_storage) 

96 key = "fake_key" 

97 value = "fake_value" 

98 default_value = "def" 

99 self.mock_object(self.fake_storage, 'get', 

100 mock.Mock(return_value=value)) 

101 

102 actual_result = data.get(self.entity_id, key, default_value) 

103 

104 self.assertEqual(value, actual_result) 

105 self.fake_storage.get.assert_called_once_with( 

106 self.entity_id, key, default_value 

107 ) 

108 

109 def test_delete(self): 

110 data = pd.DriverPrivateData(storage=self.fake_storage) 

111 key = "fake_key" 

112 self.mock_object(self.fake_storage, 'get', 

113 mock.Mock(return_value=True)) 

114 

115 actual_result = data.delete(self.entity_id, key) 

116 

117 self.assertTrue(actual_result) 

118 self.fake_storage.delete.assert_called_once_with( 

119 self.entity_id, key 

120 ) 

121 

122 

123fake_storage_data = { 

124 "entity_id": "fake_id", 

125 "details": {"foo": "bar"}, 

126 "context": "fake_context", 

127 "backend_host": "fake_host", 

128 "default": "def", 

129 "delete_existing": True, 

130 "key": "fake_key", 

131} 

132 

133 

134def create_arg_list(key_names): 

135 return [fake_storage_data[key] for key in key_names] 

136 

137 

138def create_arg_dict(key_names): 

139 return {key: fake_storage_data[key] for key in key_names} 

140 

141 

142@ddt.ddt 

143class SqlStorageDriverTestCase(test.TestCase): 

144 

145 @ddt.data( 

146 { 

147 "method_name": 'update', 

148 "method_kwargs": create_arg_dict( 

149 ["entity_id", "details", "delete_existing"]), 

150 "valid_args": create_arg_list( 

151 ["context", "entity_id", "details", 

152 "delete_existing"] 

153 ) 

154 }, 

155 { 

156 "method_name": 'get', 

157 "method_kwargs": create_arg_dict(["entity_id", "key", "default"]), 

158 "valid_args": create_arg_list( 

159 ["context", "entity_id", "key", "default"]), 

160 }, 

161 { 

162 "method_name": 'delete', 

163 "method_kwargs": create_arg_dict(["entity_id", "key"]), 

164 "valid_args": create_arg_list( 

165 ["context", "entity_id", "key"]), 

166 }) 

167 @ddt.unpack 

168 def test_methods(self, method_kwargs, method_name, valid_args): 

169 method = method_name 

170 db_method = 'driver_private_data_' + method_name 

171 

172 with mock.patch('manila.db.api.' + db_method) as db_method: 

173 storage_driver = pd.SqlStorageDriver( 

174 context=fake_storage_data['context'], 

175 backend_host=fake_storage_data['backend_host']) 

176 method = getattr(storage_driver, method) 

177 

178 method(**method_kwargs) 

179 

180 db_method.assert_called_once_with(*valid_args)