Coverage for manila/tests/share/drivers/dell_emc/test_driver.py: 99%

1# Copyright (c) 2014 EMC Corporation. 

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 

18from stevedore import extension 

19 

20from manila.share import configuration as conf 

21from manila.share.drivers.dell_emc import driver as emcdriver 

22from manila.share.drivers.dell_emc.plugins import base 

23from manila import test 

24 

25 

26class FakeConnection(base.StorageConnection): 

27 def __init__(self, *args, **kwargs): 

28 self.ipv6_implemented = True 

29 self.dhss_mandatory_security_service_association = {} 

30 pass 

31 

32 @property 

33 def driver_handles_share_servers(self): 

34 return True 

35 

36 def create_share(self, context, share, share_server): 

37 """Is called to create share.""" 

38 

39 def create_snapshot(self, context, snapshot, share_server): 

40 """Is called to create snapshot.""" 

41 

42 def delete_share(self, context, share, share_server): 

43 """Is called to remove share.""" 

44 

45 def extend_share(self, share, new_size, share_server): 

46 """Is called to extend share.""" 

47 

48 def shrink_share(self, share, new_size, share_server): 

49 """Is called to shrink share.""" 

50 

51 def delete_snapshot(self, context, snapshot, share_server): 

52 """Is called to remove snapshot.""" 

53 

54 def ensure_share(self, context, share, share_server): 

55 """Invoked to sure that share is exported.""" 

56 

57 def allow_access(self, context, share, access, share_server): 

58 """Allow access to the share.""" 

59 

60 def deny_access(self, context, share, access, share_server): 

61 """Deny access to the share.""" 

62 

63 def raise_connect_error(self): 

64 """Check for setup error.""" 

65 

66 def connect(self, emc_share_driver, context): 

67 """Any initialization the share driver does while starting.""" 

68 

69 def update_share_stats(self, stats_dict): 

70 """Add key/values to stats_dict.""" 

71 

72 def get_network_allocations_number(self): 

73 """Returns number of network allocations for creating VIFs.""" 

74 

75 def setup_server(self, network_info, metadata=None): 

76 """Set up and configures share server with given network parameters.""" 

77 

78 def teardown_server(self, server_details, security_services=None): 

79 """Teardown share server.""" 

80 

81 def get_backend_info(self, context): 

82 """Get driver and array configuration parameters.""" 

83 

84 def ensure_shares(self, context, shares): 

85 """Invoked to ensure that shares are exported.""" 

86 

87 def snapshot_update_access(self, context, snapshot, access_rules, 

88 add_rules, delete_rules, share_server=None): 

89 """Update snapshot access""" 

90 

91 

92class FakeConnection_powermax(FakeConnection): 

93 def __init__(self, *args, **kwargs): 

94 self.dhss_mandatory_security_service_association = {} 

95 self.revert_to_snap_support = False 

96 self.shrink_share_support = False 

97 self.manage_existing_support = False 

98 self.manage_existing_with_server_support = False 

99 self.manage_existing_snapshot_support = False 

100 self.manage_snapshot_with_server_support = False 

101 self.manage_server_support = False 

102 self.get_share_server_network_info_support = False 

103 pass 

104 

105 

106FAKE_BACKEND = 'fake_backend' 

107FAKE_BACKEND_POWERMAX = 'powermax' 

108 

109 

110class FakeEMCExtensionManager(object): 

111 def __init__(self): 

112 self.extensions = [] 

113 self.extensions.append( 

114 extension.Extension(name=FAKE_BACKEND, 

115 plugin=FakeConnection, 

116 entry_point=None, 

117 obj=None)) 

118 self.extensions.append( 

119 extension.Extension(name=FAKE_BACKEND_POWERMAX, 

120 plugin=FakeConnection_powermax, 

121 entry_point=None, 

122 obj=None)) 

123 

124 

125class EMCShareFrameworkTestCase(test.TestCase): 

126 

127 @mock.patch('stevedore.extension.ExtensionManager', 

128 mock.Mock(return_value=FakeEMCExtensionManager())) 

129 def setUp(self): 

130 super(EMCShareFrameworkTestCase, self).setUp() 

131 self.configuration = conf.Configuration(None) 

132 self.configuration.append_config_values = mock.Mock(return_value=0) 

133 self.configuration.share_backend_name = FAKE_BACKEND 

134 self.mock_object(self.configuration, 'safe_get', self._fake_safe_get) 

135 self.driver = emcdriver.EMCShareDriver( 

136 configuration=self.configuration) 

137 

138 self.configuration_powermax = conf.Configuration(None) 

139 self.configuration_powermax.append_config_values = \ 

140 mock.Mock(return_value=0) 

141 self.configuration_powermax.share_backend_name = FAKE_BACKEND_POWERMAX 

142 self.mock_object(self.configuration_powermax, 'safe_get', 

143 self._fake_safe_get_powermax) 

144 self.driver_powermax = emcdriver.EMCShareDriver( 

145 configuration=self.configuration_powermax) 

146 

147 def test_driver_setup(self): 

148 FakeConnection.connect = mock.Mock() 

149 self.driver.do_setup(None) 

150 self.assertIsInstance(self.driver.plugin, FakeConnection, 

151 "Not an instance of FakeConnection") 

152 FakeConnection.connect.assert_called_with(self.driver, None) 

153 

154 def test_update_share_stats(self): 

155 data = {} 

156 self.driver.plugin = mock.Mock() 

157 self.driver.plugin.get_default_filter_function.return_value = None 

158 self.driver._update_share_stats() 

159 data["share_backend_name"] = FAKE_BACKEND 

160 data["driver_handles_share_servers"] = True 

161 data["vendor_name"] = 'Dell EMC' 

162 data["driver_version"] = '1.0' 

163 data["storage_protocol"] = 'NFS_CIFS' 

164 data['total_capacity_gb'] = 'unknown' 

165 data['free_capacity_gb'] = 'unknown' 

166 data['reserved_percentage'] = 0 

167 data['reserved_snapshot_percentage'] = 0 

168 data['reserved_share_extend_percentage'] = 0 

169 data['qos'] = False 

170 data['pools'] = None 

171 data['snapshot_support'] = True 

172 data['create_share_from_snapshot_support'] = True 

173 data['revert_to_snapshot_support'] = False 

174 data['share_group_stats'] = {'consistent_snapshot_support': None} 

175 data['mount_snapshot_support'] = False 

176 data['replication_domain'] = None 

177 data['filter_function'] = None 

178 data['goodness_function'] = None 

179 data['mount_point_name_support'] = False 

180 data['snapshot_support'] = True 

181 data['create_share_from_snapshot_support'] = True 

182 data['ipv4_support'] = True 

183 data['ipv6_support'] = False 

184 data['max_shares_per_share_server'] = -1 

185 data['max_share_server_size'] = -1 

186 data['security_service_update_support'] = False 

187 data['share_server_multiple_subnet_support'] = False 

188 data['network_allocation_update_support'] = False 

189 data['share_replicas_migration_support'] = False 

190 data['encryption_support'] = None 

191 self.assertEqual(data, self.driver._stats) 

192 

193 def _fake_safe_get(self, value): 

194 if value in ['emc_share_backend', 'share_backend_name']: 

195 return FAKE_BACKEND 

196 elif value == 'driver_handles_share_servers': 

197 return True 

198 return None 

199 

200 def _fake_safe_get_powermax(self, value): 

201 if value in ['emc_share_backend', 'share_backend_name']: 

202 return FAKE_BACKEND_POWERMAX 

203 elif value == 'driver_handles_share_servers': 203 ↛ 205line 203 didn't jump to line 205 because the condition on line 203 was always true

204 return True 

205 return None 

206 

207 def test_support_manage(self): 

208 share = mock.Mock() 

209 driver_options = mock.Mock() 

210 share_server = mock.Mock() 

211 snapshot = mock.Mock() 

212 context = mock.Mock() 

213 identifier = mock.Mock() 

214 self.driver.plugin = mock.Mock() 

215 self.driver.manage_existing_support = True 

216 self.driver.manage_existing_with_server_support = True 

217 self.driver.manage_existing_snapshot_support = True 

218 self.driver.manage_snapshot_with_server_support = True 

219 self.driver.manage_server_support = True 

220 self.driver.manage_existing(share, driver_options) 

221 self.driver.manage_existing_with_server(share, driver_options, 

222 share_server) 

223 self.driver.manage_existing_snapshot(snapshot, driver_options) 

224 self.driver.manage_existing_snapshot_with_server(snapshot, 

225 driver_options, 

226 share_server) 

227 self.driver.manage_server(context, share_server, identifier, 

228 driver_options) 

229 self.driver.get_share_server_network_info_support = True 

230 self.driver.get_share_server_network_info(context, share_server, 

231 identifier, driver_options) 

232 self.driver.create_share(context, share, share_server) 

233 self.driver.create_share_from_snapshot(context, share, snapshot, 

234 share_server) 

235 self.driver.extend_share(share, 20, share_server) 

236 self.driver.shrink_share_support = True 

237 self.driver.shrink_share(share, 20, share_server) 

238 self.driver.create_snapshot(context, snapshot, share_server) 

239 self.driver.delete_share(context, share, share_server) 

240 self.driver.delete_snapshot(context, snapshot, share_server) 

241 self.driver.ensure_share(context, share, share_server) 

242 self.driver.get_backend_info(context) 

243 self.driver.ensure_shares(context, [share]) 

244 access = mock.Mock() 

245 self.driver.allow_access(context, share, access, share_server) 

246 self.driver.deny_access(context, share, access, share_server) 

247 self.driver.update_access(context, share, None, None, 

248 None, share_server) 

249 self.driver.check_for_setup_error() 

250 self.driver.get_network_allocations_number() 

251 self.driver._teardown_server(None) 

252 self.driver.revert_to_snap_support = True 

253 share_access_rules = mock.Mock() 

254 snapshot_access_rules = mock.Mock() 

255 self.driver.revert_to_snapshot(context, snapshot, share_access_rules, 

256 snapshot_access_rules, share_server) 

257 self.driver.ipv6_implemented = False 

258 self.driver.get_configured_ip_versions() 

259 self.driver.mount_snapshot_support = True 

260 snap_access_rules = mock.Mock() 

261 self.driver.snapshot_update_access(context, snapshot, 

262 snap_access_rules, 

263 None, None, None) 

264 

265 def test_not_support_manage(self): 

266 share = mock.Mock() 

267 driver_options = {} 

268 share_server = mock.Mock() 

269 snapshot = mock.Mock() 

270 identifier = mock.Mock() 

271 self.driver.plugin = mock.Mock() 

272 self.driver.manage_existing_support = False 

273 self.assertRaises( 

274 NotImplementedError, 

275 self.driver.manage_existing, 

276 share, 

277 driver_options, 

278 ) 

279 result = self.driver.manage_existing_with_server( 

280 share, driver_options, share_server 

281 ) 

282 self.assertIsInstance(result, NotImplementedError) 

283 result = self.driver.manage_existing_snapshot(snapshot, driver_options) 

284 self.assertIsInstance(result, NotImplementedError) 

285 result = self.driver.manage_existing_snapshot_with_server( 

286 snapshot, driver_options, share_server 

287 ) 

288 self.assertIsInstance(result, NotImplementedError) 

289 result = self.driver.manage_server( 

290 None, 

291 share_server, 

292 identifier, 

293 driver_options, 

294 ) 

295 self.assertIsInstance(result, NotImplementedError) 

296 result = self.driver.get_share_server_network_info( 

297 None, share_server, identifier, driver_options 

298 ) 

299 self.assertIsInstance(result, NotImplementedError) 

300 self.assertRaises( 

301 NotImplementedError, 

302 self.driver.shrink_share, 

303 share, 

304 20, 

305 share_server, 

306 ) 

307 share_access_rules = mock.Mock() 

308 snapshot_access_rules = mock.Mock() 

309 self.assertRaises( 

310 NotImplementedError, 

311 self.driver.revert_to_snapshot, 

312 None, 

313 snapshot, 

314 share_access_rules, 

315 snapshot_access_rules, 

316 share_server, 

317 ) 

318 

319 def test_unmanage_manage(self): 

320 share = {} 

321 server_details = {} 

322 share_server = mock.Mock() 

323 snapshot = mock.Mock() 

324 self.driver.plugin = mock.Mock(share) 

325 self.driver.unmanage(share) 

326 self.driver.unmanage_with_server(share, share_server) 

327 self.driver.unmanage_snapshot(snapshot) 

328 self.driver.unmanage_snapshot_with_server(snapshot, share_server) 

329 self.driver.unmanage_server(server_details) 

330 

331 def test_get_default_filter_function(self): 

332 expected = None 

333 actual = self.driver.get_default_filter_function() 

334 self.assertEqual(expected, actual) 

335 

336 def test_setup_server(self): 

337 network_info = [{}] 

338 expected = None 

339 result = self.driver._setup_server(network_info) 

340 self.assertEqual(expected, result)