Coverage for manila/tests/share_group/test_api.py: 99%

1# Copyright 2016 Alex Meade 

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"""Unit tests for the Share API module.""" 

16 

17import copy 

18import datetime 

19from unittest import mock 

20 

21import ddt 

22from oslo_config import cfg 

23from oslo_utils import timeutils 

24from webob import exc as webob_exc 

25 

26from manila.common import constants 

27from manila import context 

28from manila import db as db_driver 

29from manila import exception 

30from manila.share import share_types 

31from manila.share_group import api as share_group_api 

32from manila import test 

33from manila.tests.api.contrib import stubs 

34from manila.tests import utils as test_utils 

35 

36CONF = cfg.CONF 

37 

38 

39def fake_share_group(id, **kwargs): 

40 share_group = { 

41 'id': id, 

42 'user_id': 'fakeuser', 

43 'project_id': 'fakeproject', 

44 'status': constants.STATUS_CREATING, 

45 'name': None, 

46 'description': None, 

47 'host': None, 

48 'availability_zone_id': None, 

49 'share_group_type_id': None, 

50 'source_share_group_snapshot_id': None, 

51 'share_network_id': None, 

52 'share_server_id': None, 

53 'share_types': mock.ANY, 

54 'created_at': datetime.datetime(1, 1, 1, 1, 1, 1), 

55 } 

56 

57 if 'source_share_group_snapshot_id' in kwargs: 57 ↛ 58line 57 didn't jump to line 58 because the condition on line 57 was never true

58 share_group['share_network_id'] = 'fake_share_network_id' 

59 share_group['share_server_id'] = 'fake_share_server_id' 

60 

61 share_group.update(kwargs) 

62 return share_group 

63 

64 

65def fake_share_group_snapshot(id, **kwargs): 

66 snap = { 

67 'id': id, 

68 'user_id': 'fakeuser', 

69 'project_id': 'fakeproject', 

70 'status': constants.STATUS_CREATING, 

71 'name': None, 

72 'description': None, 

73 'share_group_id': None, 

74 'created_at': datetime.datetime(1, 1, 1, 1, 1, 1), 

75 } 

76 snap.update(kwargs) 

77 return snap 

78 

79 

80@ddt.ddt 

81class ShareGroupsAPITestCase(test.TestCase): 

82 def setUp(self): 

83 super(ShareGroupsAPITestCase, self).setUp() 

84 self.user_id = 'fake_user_id' 

85 self.project_id = 'fake_project_id' 

86 self.context = context.RequestContext( 

87 user_id=self.user_id, project_id=self.project_id, is_admin=True) 

88 self.scheduler_rpcapi = mock.Mock() 

89 self.share_rpcapi = mock.Mock() 

90 self.share_api = mock.Mock() 

91 self.api = share_group_api.API() 

92 self.mock_object(self.api, 'share_rpcapi', self.share_rpcapi) 

93 self.mock_object(self.api, 'share_api', self.share_api) 

94 self.mock_object(self.api, 'scheduler_rpcapi', self.scheduler_rpcapi) 

95 

96 dt_utc = timeutils.utcnow() 

97 self.mock_object(timeutils, 'utcnow', mock.Mock(return_value=dt_utc)) 

98 self.fake_share_type = { 

99 'name': 'default', 

100 'extra_specs': {'driver_handles_share_servers': 'False'}, 

101 'is_public': True, 

102 'id': 'c01990c1-448f-435a-9de6-c7c894bb6df9' 

103 } 

104 self.fake_share_type_2 = { 

105 'name': 'default2', 

106 'extra_specs': {'driver_handles_share_servers': 'False'}, 

107 'is_public': True, 

108 'id': 'c01990c1-448f-435a-9de6-c7c894bb7dfd' 

109 } 

110 self.fake_share_group_type = { 

111 'share_types': [ 

112 {'share_type_id': self.fake_share_type['id']}, 

113 {'share_type_id': self.fake_share_type_2['id']}, 

114 ] 

115 } 

116 self.mock_object(share_types, 'get_share_type', 

117 mock.Mock(return_value=self.fake_share_type)) 

118 self.mock_object( 

119 db_driver, 'share_group_type_get', 

120 mock.Mock(return_value=self.fake_share_group_type)) 

121 self.mock_object(share_group_api.QUOTAS, 'reserve') 

122 self.mock_object(share_group_api.QUOTAS, 'commit') 

123 self.mock_object(share_group_api.QUOTAS, 'rollback') 

124 

125 def test_create_empty_request(self): 

126 share_group = fake_share_group( 

127 'fakeid', user_id=self.context.user_id, 

128 project_id=self.context.project_id, 

129 status=constants.STATUS_CREATING) 

130 expected_values = share_group.copy() 

131 for name in ('id', 'host', 'created_at'): 

132 expected_values.pop(name, None) 

133 self.mock_object(db_driver, 'share_group_create', 

134 mock.Mock(return_value=share_group)) 

135 

136 self.api.create(self.context) 

137 

138 db_driver.share_group_create.assert_called_once_with( 

139 self.context, expected_values) 

140 share_group_api.QUOTAS.reserve.assert_called_once_with( 

141 self.context, share_groups=1) 

142 share_group_api.QUOTAS.commit.assert_called_once_with( 

143 self.context, share_group_api.QUOTAS.reserve.return_value) 

144 share_group_api.QUOTAS.rollback.assert_not_called() 

145 

146 def test_create_request_spec(self): 

147 """Ensure the correct values are sent to the scheduler.""" 

148 share_group = fake_share_group( 

149 'fakeid', user_id=self.context.user_id, 

150 project_id=self.context.project_id, 

151 status=constants.STATUS_CREATING) 

152 expected_values = share_group.copy() 

153 for name in ('id', 'host', 'created_at'): 

154 expected_values.pop(name, None) 

155 expected_request_spec = {'share_group_id': share_group['id']} 

156 expected_request_spec.update(share_group) 

157 expected_request_spec['availability_zones'] = set([]) 

158 del expected_request_spec['id'] 

159 del expected_request_spec['created_at'] 

160 del expected_request_spec['host'] 

161 expected_request_spec['resource_type'] = self.fake_share_group_type 

162 self.mock_object(db_driver, 'share_group_create', 

163 mock.Mock(return_value=share_group)) 

164 

165 self.api.create(self.context) 

166 

167 self.scheduler_rpcapi.create_share_group.assert_called_once_with( 

168 self.context, share_group_id=share_group['id'], 

169 request_spec=expected_request_spec, filter_properties={}) 

170 share_group_api.QUOTAS.reserve.assert_called_once_with( 

171 self.context, share_groups=1) 

172 share_group_api.QUOTAS.commit.assert_called_once_with( 

173 self.context, share_group_api.QUOTAS.reserve.return_value) 

174 share_group_api.QUOTAS.rollback.assert_not_called() 

175 

176 def test_create_with_name(self): 

177 fake_name = 'fake_name' 

178 share_group = fake_share_group( 

179 'fakeid', user_id=self.context.user_id, 

180 project_id=self.context.project_id, 

181 status=constants.STATUS_CREATING) 

182 expected_values = share_group.copy() 

183 for name in ('id', 'host', 'created_at'): 

184 expected_values.pop(name, None) 

185 expected_values['name'] = fake_name 

186 self.mock_object(db_driver, 'share_group_create', 

187 mock.Mock(return_value=share_group)) 

188 self.mock_object(db_driver, 'share_network_get') 

189 

190 self.api.create(self.context, name=fake_name) 

191 

192 db_driver.share_group_create.assert_called_once_with( 

193 self.context, expected_values) 

194 self.scheduler_rpcapi.create_share_group.assert_called_once_with( 

195 self.context, share_group_id=share_group['id'], 

196 request_spec=mock.ANY, filter_properties={}) 

197 share_group_api.QUOTAS.reserve.assert_called_once_with( 

198 self.context, share_groups=1) 

199 share_group_api.QUOTAS.commit.assert_called_once_with( 

200 self.context, share_group_api.QUOTAS.reserve.return_value) 

201 share_group_api.QUOTAS.rollback.assert_not_called() 

202 

203 def test_create_with_description(self): 

204 fake_desc = 'fake_desc' 

205 share_group = fake_share_group( 

206 'fakeid', user_id=self.context.user_id, 

207 project_id=self.context.project_id, 

208 status=constants.STATUS_CREATING) 

209 expected_values = share_group.copy() 

210 for name in ('id', 'host', 'created_at'): 

211 expected_values.pop(name, None) 

212 expected_values['description'] = fake_desc 

213 self.mock_object(db_driver, 'share_group_create', 

214 mock.Mock(return_value=share_group)) 

215 

216 self.api.create(self.context, description=fake_desc) 

217 

218 db_driver.share_group_create.assert_called_once_with( 

219 self.context, expected_values) 

220 share_group_api.QUOTAS.reserve.assert_called_once_with( 

221 self.context, share_groups=1) 

222 share_group_api.QUOTAS.commit.assert_called_once_with( 

223 self.context, share_group_api.QUOTAS.reserve.return_value) 

224 share_group_api.QUOTAS.rollback.assert_not_called() 

225 

226 @ddt.data(True, False) 

227 def test_create_with_multiple_share_types_with_az(self, with_az): 

228 share_type_1 = copy.deepcopy(self.fake_share_type) 

229 share_type_2 = copy.deepcopy(self.fake_share_type_2) 

230 share_type_1['extra_specs']['availability_zones'] = 'nova,supernova' 

231 share_type_2['extra_specs']['availability_zones'] = 'nova' 

232 fake_share_types = [share_type_1, share_type_2] 

233 fake_share_type_ids = [x['id'] for x in fake_share_types] 

234 share_group_type = { 

235 'share_types': [ 

236 {'share_type_id': share_type_1['id']}, 

237 {'share_type_id': share_type_2['id']}, 

238 {'share_type_id': self.fake_share_type['id']}, 

239 ] 

240 } 

241 self.mock_object( 

242 db_driver, 'share_group_type_get', 

243 mock.Mock(return_value=share_group_type)) 

244 self.mock_object(share_types, 'get_share_type', mock.Mock( 

245 side_effect=[share_type_1, share_type_2, 

246 share_type_1, share_type_2, self.fake_share_type])) 

247 share_group = fake_share_group( 

248 'fakeid', user_id=self.context.user_id, 

249 project_id=self.context.project_id, 

250 status=constants.STATUS_CREATING, 

251 availability_zone_id=('e030620e-892c-4ff4-8764-9f3f2b560bd1' 

252 if with_az else None) 

253 ) 

254 expected_values = share_group.copy() 

255 for name in ('id', 'host', 'created_at'): 

256 expected_values.pop(name, None) 

257 expected_values['share_types'] = fake_share_type_ids 

258 self.mock_object( 

259 db_driver, 'share_group_create', 

260 mock.Mock(return_value=share_group)) 

261 self.mock_object(db_driver, 'share_network_get') 

262 az_kwargs = { 

263 'availability_zone': 'nova', 

264 'availability_zone_id': share_group['availability_zone_id'], 

265 } 

266 

267 kwargs = {} if not with_az else az_kwargs 

268 self.api.create(self.context, share_type_ids=fake_share_type_ids, 

269 **kwargs) 

270 

271 scheduler_request_spec = ( 

272 self.scheduler_rpcapi.create_share_group.call_args_list[ 

273 0][1]['request_spec'] 

274 ) 

275 az_id = az_kwargs['availability_zone_id'] if with_az else None 

276 self.assertEqual({'nova', 'supernova'}, 

277 scheduler_request_spec['availability_zones']) 

278 self.assertEqual(az_id, scheduler_request_spec['availability_zone_id']) 

279 db_driver.share_group_create.assert_called_once_with( 

280 self.context, expected_values) 

281 share_group_api.QUOTAS.reserve.assert_called_once_with( 

282 self.context, share_groups=1) 

283 share_group_api.QUOTAS.commit.assert_called_once_with( 

284 self.context, share_group_api.QUOTAS.reserve.return_value) 

285 share_group_api.QUOTAS.rollback.assert_not_called() 

286 

287 @ddt.data( 

288 test_utils.annotated('specified_stypes_one_unsupported_in_AZ', 

289 (True, True)), 

290 test_utils.annotated('specified_stypes_all_unsupported_in_AZ', 

291 (True, False)), 

292 test_utils.annotated('group_type_stypes_one_unsupported_in_AZ', 

293 (False, True)), 

294 test_utils.annotated('group_type_stypes_all_unsupported_in_AZ', 

295 (False, False))) 

296 @ddt.unpack 

297 def test_create_unsupported_az(self, specify_stypes, all_unsupported): 

298 share_type_1 = copy.deepcopy(self.fake_share_type) 

299 share_type_2 = copy.deepcopy(self.fake_share_type_2) 

300 share_type_1['extra_specs']['availability_zones'] = 'nova,supernova' 

301 share_type_2['extra_specs']['availability_zones'] = ( 

302 'nova' if all_unsupported else 'nova,hypernova' 

303 ) 

304 share_group_type = { 

305 'share_types': [ 

306 {'share_type_id': share_type_1['id'], }, 

307 {'share_type_id': share_type_2['id']}, 

308 ] 

309 } 

310 share_group = fake_share_group( 

311 'fakeid', user_id=self.context.user_id, 

312 project_id=self.context.project_id, 

313 status=constants.STATUS_CREATING, 

314 availability_zone_id='e030620e-892c-4ff4-8764-9f3f2b560bd1') 

315 self.mock_object( 

316 db_driver, 'share_group_create', 

317 mock.Mock(return_value=share_group)) 

318 self.mock_object(db_driver, 'share_network_get') 

319 self.mock_object( 

320 db_driver, 'share_group_type_get', 

321 mock.Mock(return_value=share_group_type)) 

322 self.mock_object(share_types, 'get_share_type', 

323 mock.Mock(side_effect=[share_type_1, 

324 share_type_1] * 2)) 

325 self.mock_object(db_driver, 'share_group_snapshot_get') 

326 kwargs = { 

327 'availability_zone': 'hypernova', 

328 'availability_zone_id': share_group['availability_zone_id'], 

329 } 

330 if specify_stypes: 

331 kwargs['share_type_ids'] = [share_type_1['id'], share_type_2['id']] 

332 

333 self.assertRaises( 

334 exception.InvalidInput, 

335 self.api.create, 

336 self.context, **kwargs) 

337 db_driver.share_group_snapshot_get.assert_not_called() 

338 db_driver.share_network_get.assert_not_called() 

339 

340 def test_create_with_share_type_not_found(self): 

341 self.mock_object(share_types, 'get_share_type', 

342 mock.Mock(side_effect=exception.ShareTypeNotFound( 

343 share_type_id=self.fake_share_type['id']))) 

344 share_group = fake_share_group( 

345 'fakeid', user_id=self.context.user_id, 

346 project_id=self.context.project_id, 

347 status=constants.STATUS_CREATING) 

348 expected_values = share_group.copy() 

349 for name in ('id', 'host', 'created_at'): 

350 expected_values.pop(name, None) 

351 expected_values['share_types'] = self.fake_share_type['id'] 

352 self.mock_object(db_driver, 'share_group_create', 

353 mock.Mock(return_value=share_group)) 

354 

355 self.assertRaises( 

356 exception.InvalidInput, 

357 self.api.create, 

358 self.context, share_type_ids=[self.fake_share_type['id']]) 

359 

360 share_group_api.QUOTAS.reserve.assert_not_called() 

361 share_group_api.QUOTAS.commit.assert_not_called() 

362 share_group_api.QUOTAS.rollback.assert_not_called() 

363 

364 def test_create_with_error_on_quota_reserve(self): 

365 overs = ["share_groups"] 

366 usages = {"share_groups": {"reserved": 1, "in_use": 3, "limit": 4}} 

367 quotas = {"share_groups": 5} 

368 share_group_api.QUOTAS.reserve.side_effect = exception.OverQuota( 

369 overs=overs, 

370 usages=usages, 

371 quotas=quotas, 

372 ) 

373 self.mock_object(share_group_api.LOG, "warning") 

374 

375 self.assertRaises( 

376 exception.ShareGroupsLimitExceeded, 

377 self.api.create, self.context) 

378 

379 share_group_api.QUOTAS.reserve.assert_called_once_with( 

380 self.context, share_groups=1) 

381 share_group_api.QUOTAS.commit.assert_not_called() 

382 share_group_api.QUOTAS.rollback.assert_not_called() 

383 share_group_api.LOG.warning.assert_called_once_with(mock.ANY, mock.ANY) 

384 

385 def test_create_driver_handles_share_servers_is_false_with_net_id(self): 

386 fake_share_types = [self.fake_share_type] 

387 self.mock_object(share_types, 'get_share_type') 

388 

389 self.assertRaises(exception.InvalidInput, self.api.create, 

390 self.context, share_type_ids=fake_share_types, 

391 share_network_id="fake_share_network") 

392 

393 def test_create_with_conflicting_share_types(self): 

394 fake_share_type = { 

395 'name': 'default', 

396 'extra_specs': {'driver_handles_share_servers': 'True'}, 

397 'is_public': True, 

398 'id': 'c01990c1-448f-435a-9de6-c7c894bb6df9', 

399 } 

400 fake_share_type_2 = { 

401 'name': 'default2', 

402 'extra_specs': {'driver_handles_share_servers': 'False'}, 

403 'is_public': True, 

404 'id': 'c01990c1-448f-435a-9de6-c7c894bb7df9', 

405 } 

406 fake_share_types = [fake_share_type, fake_share_type_2] 

407 fake_share_type_ids = [x['id'] for x in fake_share_types] 

408 self.mock_object(share_types, 'get_share_type', 

409 mock.Mock(side_effect=[fake_share_type, 

410 fake_share_type_2])) 

411 

412 self.assertRaises( 

413 exception.InvalidInput, 

414 self.api.create, 

415 self.context, share_type_ids=fake_share_type_ids) 

416 

417 share_group_api.QUOTAS.reserve.assert_not_called() 

418 share_group_api.QUOTAS.commit.assert_not_called() 

419 share_group_api.QUOTAS.rollback.assert_not_called() 

420 

421 def test_create_with_conflicting_share_type_and_share_network(self): 

422 fake_share_type = { 

423 'name': 'default', 

424 'extra_specs': {'driver_handles_share_servers': 'False'}, 

425 'is_public': True, 

426 'id': 'c01990c1-448f-435a-9de6-c7c894bb6df9', 

427 } 

428 fake_share_types = [fake_share_type] 

429 self.mock_object(share_types, 'get_share_type', 

430 mock.Mock(return_value=fake_share_type)) 

431 

432 self.assertRaises( 

433 exception.InvalidInput, 

434 self.api.create, 

435 self.context, share_type_ids=fake_share_types, 

436 share_network_id="fake_sn") 

437 

438 share_group_api.QUOTAS.reserve.assert_not_called() 

439 share_group_api.QUOTAS.commit.assert_not_called() 

440 share_group_api.QUOTAS.rollback.assert_not_called() 

441 

442 def test_create_with_source_share_group_snapshot_id(self): 

443 snap = fake_share_group_snapshot( 

444 "fake_source_share_group_snapshot_id", 

445 status=constants.STATUS_AVAILABLE) 

446 fake_share_type_mapping = {'share_type_id': self.fake_share_type['id']} 

447 orig_share_group = fake_share_group( 

448 'fakeorigid', user_id=self.context.user_id, 

449 project_id=self.context.project_id, 

450 share_types=[fake_share_type_mapping], 

451 status=constants.STATUS_AVAILABLE, 

452 host='fake_original_host', 

453 share_network_id='fake_network_id', 

454 share_server_id='fake_server_id') 

455 

456 share_group = fake_share_group( 

457 'fakeid', user_id=self.context.user_id, 

458 project_id=self.context.project_id, 

459 share_types=[fake_share_type_mapping], 

460 status=constants.STATUS_CREATING, 

461 host='fake_original_host', 

462 share_network_id='fake_network_id', 

463 share_server_id='fake_server_id') 

464 share_network = { 

465 'id': 'fakeid', 

466 'status': constants.STATUS_NETWORK_ACTIVE 

467 } 

468 expected_values = share_group.copy() 

469 for name in ('id', 'created_at', 'share_network_id', 

470 'share_server_id'): 

471 expected_values.pop(name, None) 

472 expected_values['source_share_group_snapshot_id'] = snap['id'] 

473 expected_values['share_types'] = [self.fake_share_type['id']] 

474 expected_values['share_network_id'] = 'fake_network_id' 

475 expected_values['share_server_id'] = 'fake_server_id' 

476 

477 self.mock_object( 

478 db_driver, 'share_group_snapshot_get', 

479 mock.Mock(return_value=snap)) 

480 self.mock_object( 

481 db_driver, 'share_group_get', 

482 mock.Mock(return_value=orig_share_group)) 

483 self.mock_object( 

484 db_driver, 'share_group_create', 

485 mock.Mock(return_value=share_group)) 

486 self.mock_object( 

487 db_driver, 'share_get', 

488 mock.Mock(return_value=stubs.stub_share('fake_share'))) 

489 self.mock_object( 

490 share_types, 'get_share_type', 

491 mock.Mock(return_value={"id": self.fake_share_type['id']})) 

492 self.mock_object(db_driver, 'share_network_get', 

493 mock.Mock(return_value=share_network)) 

494 self.mock_object( 

495 db_driver, 'share_group_snapshot_members_get_all', 

496 mock.Mock(return_value=[])) 

497 

498 self.api.create( 

499 self.context, source_share_group_snapshot_id=snap['id']) 

500 

501 db_driver.share_group_create.assert_called_once_with( 

502 self.context, expected_values) 

503 self.share_rpcapi.create_share_group.assert_called_once_with( 

504 self.context, share_group, orig_share_group['host']) 

505 share_group_api.QUOTAS.reserve.assert_called_once_with( 

506 self.context, share_groups=1) 

507 share_group_api.QUOTAS.commit.assert_called_once_with( 

508 self.context, share_group_api.QUOTAS.reserve.return_value) 

509 share_group_api.QUOTAS.rollback.assert_not_called() 

510 

511 def test_create_share_group_network_not_active(self): 

512 fake_share_type_mapping = {'share_type_id': self.fake_share_type['id']} 

513 share_group = fake_share_group( 

514 'fakeid', user_id=self.context.user_id, 

515 project_id=self.context.project_id, 

516 share_types=[fake_share_type_mapping], 

517 status=constants.STATUS_CREATING, 

518 host='fake_original_host', 

519 share_network_id='fake_network_id', 

520 share_server_id='fake_server_id') 

521 network_id = 'fake_sn' 

522 share_network = { 

523 'id': network_id, 

524 'status': constants.STATUS_SERVER_NETWORK_CHANGE 

525 } 

526 expected_values = share_group.copy() 

527 for name in ('id', 'created_at', 'share_network_id', 

528 'share_server_id'): 

529 expected_values.pop(name, None) 

530 expected_values['share_types'] = [self.fake_share_type['id']] 

531 expected_values['share_network_id'] = 'fake_network_id' 

532 expected_values['share_server_id'] = 'fake_server_id' 

533 

534 self.mock_object( 

535 share_types, 'get_share_type', 

536 mock.Mock(return_value={"id": self.fake_share_type['id']})) 

537 self.mock_object(db_driver, 'share_network_get', 

538 mock.Mock(return_value=share_network)) 

539 

540 self.assertRaises( 

541 webob_exc.HTTPBadRequest, 

542 self.api.create, 

543 self.context, share_type_ids=[fake_share_type_mapping], 

544 share_network_id="fake_sn") 

545 

546 db_driver.share_network_get.assert_called_once_with( 

547 self.context, network_id) 

548 

549 def test_create_with_source_share_group_snapshot_id_with_member(self): 

550 snap = fake_share_group_snapshot( 

551 "fake_source_share_group_snapshot_id", 

552 status=constants.STATUS_AVAILABLE) 

553 share = stubs.stub_share('fakeshareid') 

554 member = stubs.stub_share_group_snapshot_member('fake_member_id') 

555 fake_share_type_mapping = {'share_type_id': self.fake_share_type['id']} 

556 orig_share_group = fake_share_group( 

557 'fakeorigid', user_id=self.context.user_id, 

558 project_id=self.context.project_id, 

559 share_types=[fake_share_type_mapping], 

560 status=constants.STATUS_AVAILABLE, 

561 share_network_id='fake_network_id', 

562 share_server_id='fake_server_id') 

563 share_group = fake_share_group( 

564 'fakeid', user_id=self.context.user_id, 

565 project_id=self.context.project_id, 

566 share_types=[fake_share_type_mapping], 

567 status=constants.STATUS_CREATING, 

568 share_network_id='fake_network_id', 

569 share_server_id='fake_server_id') 

570 expected_values = share_group.copy() 

571 share_network = { 

572 'id': 'fakeid', 

573 'status': constants.STATUS_NETWORK_ACTIVE 

574 } 

575 for name in ('id', 'created_at', 'fake_network_id', 

576 'fake_share_server_id'): 

577 expected_values.pop(name, None) 

578 expected_values['source_share_group_snapshot_id'] = snap['id'] 

579 expected_values['share_types'] = [self.fake_share_type['id']] 

580 expected_values['share_network_id'] = 'fake_network_id' 

581 expected_values['share_server_id'] = 'fake_server_id' 

582 

583 self.mock_object( 

584 db_driver, 'share_group_snapshot_get', 

585 mock.Mock(return_value=snap)) 

586 self.mock_object( 

587 db_driver, 'share_group_get', 

588 mock.Mock(return_value=orig_share_group)) 

589 self.mock_object( 

590 db_driver, 'share_group_create', 

591 mock.Mock(return_value=share_group)) 

592 self.mock_object( 

593 db_driver, 'share_get', 

594 mock.Mock(return_value=stubs.stub_share('fakeshare'))) 

595 self.mock_object( 

596 share_types, 'get_share_type', 

597 mock.Mock(return_value={"id": self.fake_share_type['id']})) 

598 self.mock_object(db_driver, 'share_network_get', 

599 mock.Mock(return_value=share_network)) 

600 self.mock_object( 

601 db_driver, 'share_instance_get', mock.Mock(return_value=share)) 

602 self.mock_object( 

603 db_driver, 'share_group_snapshot_members_get_all', 

604 mock.Mock(return_value=[member])) 

605 self.mock_object(self.share_api, 'create') 

606 

607 self.api.create( 

608 self.context, source_share_group_snapshot_id=snap['id']) 

609 

610 db_driver.share_group_create.assert_called_once_with( 

611 self.context, expected_values) 

612 self.assertTrue(self.share_api.create.called) 

613 self.share_rpcapi.create_share_group.assert_called_once_with( 

614 self.context, share_group, orig_share_group['host']) 

615 share_group_api.QUOTAS.reserve.assert_called_once_with( 

616 self.context, share_groups=1) 

617 share_group_api.QUOTAS.commit.assert_called_once_with( 

618 self.context, share_group_api.QUOTAS.reserve.return_value) 

619 share_group_api.QUOTAS.rollback.assert_not_called() 

620 

621 def test_create_with_source_sg_snapshot_id_with_members_error(self): 

622 snap = fake_share_group_snapshot( 

623 "fake_source_share_group_snapshot_id", 

624 status=constants.STATUS_AVAILABLE) 

625 member = stubs.stub_share_group_snapshot_member('fake_member_id') 

626 member_2 = stubs.stub_share_group_snapshot_member('fake_member2_id') 

627 share = stubs.stub_share('fakeshareid') 

628 fake_share_type_mapping = {'share_type_id': self.fake_share_type['id']} 

629 orig_share_group = fake_share_group( 

630 'fakeorigid', 

631 user_id=self.context.user_id, 

632 project_id=self.context.project_id, 

633 share_types=[fake_share_type_mapping], 

634 status=constants.STATUS_AVAILABLE, 

635 share_network_id='fake_network_id', 

636 share_server_id='fake_server_id') 

637 share_group = fake_share_group( 

638 'fakeid', 

639 user_id=self.context.user_id, 

640 project_id=self.context.project_id, 

641 share_types=[fake_share_type_mapping], 

642 status=constants.STATUS_CREATING, 

643 share_network_id='fake_network_id', 

644 share_server_id='fake_server_id') 

645 share_network = { 

646 'id': 'fakeid', 

647 'status': constants.STATUS_NETWORK_ACTIVE 

648 } 

649 expected_values = share_group.copy() 

650 for name in ('id', 'created_at', 'share_network_id', 

651 'share_server_id'): 

652 expected_values.pop(name, None) 

653 expected_values['source_share_group_snapshot_id'] = snap['id'] 

654 expected_values['share_types'] = [self.fake_share_type['id']] 

655 expected_values['share_network_id'] = 'fake_network_id' 

656 expected_values['share_server_id'] = 'fake_server_id' 

657 

658 self.mock_object(db_driver, 'share_group_snapshot_get', 

659 mock.Mock(return_value=snap)) 

660 self.mock_object(db_driver, 'share_group_get', 

661 mock.Mock(return_value=orig_share_group)) 

662 self.mock_object(db_driver, 'share_network_get', 

663 mock.Mock(return_value=share_network)) 

664 self.mock_object(db_driver, 'share_instance_get', 

665 mock.Mock(return_value=share)) 

666 self.mock_object(db_driver, 'share_group_create', 

667 mock.Mock(return_value=share_group)) 

668 self.mock_object(db_driver, 'share_get', 

669 mock.Mock(return_value=stubs.stub_share('fakeshare'))) 

670 self.mock_object(share_types, 'get_share_type', 

671 mock.Mock(return_value={ 

672 "id": self.fake_share_type['id']})) 

673 self.mock_object(db_driver, 'share_group_snapshot_members_get_all', 

674 mock.Mock(return_value=[member, member_2])) 

675 self.mock_object(self.share_api, 'create', 

676 mock.Mock(side_effect=[None, exception.Error])) 

677 self.mock_object(db_driver, 'share_group_destroy') 

678 

679 self.assertRaises(exception.Error, self.api.create, self.context, 

680 source_share_group_snapshot_id=snap['id']) 

681 

682 db_driver.share_group_create.assert_called_once_with( 

683 self.context, expected_values) 

684 self.assertEqual(2, self.share_api.create.call_count) 

685 self.assertEqual(1, db_driver.share_group_destroy.call_count) 

686 

687 share_group_api.QUOTAS.reserve.assert_called_once_with( 

688 self.context, share_groups=1) 

689 share_group_api.QUOTAS.commit.assert_not_called() 

690 share_group_api.QUOTAS.rollback.assert_called_once_with( 

691 self.context, share_group_api.QUOTAS.reserve.return_value) 

692 

693 def test_create_with_source_sg_snapshot_id_error_snapshot_status(self): 

694 snap = fake_share_group_snapshot( 

695 "fake_source_share_group_snapshot_id", 

696 status=constants.STATUS_ERROR) 

697 self.mock_object( 

698 db_driver, 'share_group_snapshot_get', 

699 mock.Mock(return_value=snap)) 

700 

701 self.assertRaises( 

702 exception.InvalidShareGroupSnapshot, 

703 self.api.create, 

704 self.context, source_share_group_snapshot_id=snap['id']) 

705 

706 share_group_api.QUOTAS.reserve.assert_not_called() 

707 share_group_api.QUOTAS.commit.assert_not_called() 

708 share_group_api.QUOTAS.rollback.assert_not_called() 

709 

710 def test_create_with_source_sg_snapshot_id_snap_not_found(self): 

711 snap = fake_share_group_snapshot( 

712 "fake_source_share_group_snapshot_id", 

713 status=constants.STATUS_ERROR) 

714 self.mock_object( 

715 db_driver, 'share_group_snapshot_get', 

716 mock.Mock(side_effect=exception.ShareGroupSnapshotNotFound( 

717 share_group_snapshot_id='fake_source_sg_snapshot_id'))) 

718 

719 self.assertRaises( 

720 exception.ShareGroupSnapshotNotFound, 

721 self.api.create,