Coverage for manila/tests/api/v2/test_share_replicas.py: 99%

1# Copyright 2015 Goutham Pacha Ravi 

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 copy 

19import ddt 

20from oslo_config import cfg 

21from oslo_serialization import jsonutils 

22from oslo_utils import strutils 

23from webob import exc 

24 

25from manila.api import common 

26from manila.api.openstack import api_version_request as api_version 

27from manila.api.v2 import share_replicas 

28from manila.common import constants 

29from manila import context 

30from manila import exception 

31from manila import policy 

32from manila import share 

33from manila import test 

34from manila.tests.api import fakes 

35from manila.tests import db_utils 

36from manila.tests import fake_share 

37 

38CONF = cfg.CONF 

39CAST_RULES_READONLY_VERSION = '2.30' 

40PRE_GRADUATION_VERSION = '2.55' 

41GRADUATION_VERSION = '2.56' 

42PROMOTE_QUIESCE_WAIT_VERSION = '2.75' 

43 

44 

45@ddt.ddt 

46class ShareReplicasApiTest(test.TestCase): 

47 """Share Replicas API Test Cases.""" 

48 

49 def setUp(self): 

50 super(ShareReplicasApiTest, self).setUp() 

51 self.controller = share_replicas.ShareReplicationController() 

52 self.resource_name = self.controller.resource_name 

53 self.api_version = share_replicas.MIN_SUPPORTED_API_VERSION 

54 self.replicas_req = fakes.HTTPRequest.blank( 

55 '/share-replicas', version=self.api_version, 

56 experimental=True) 

57 self.member_context = context.RequestContext('fake', 'fake') 

58 self.replicas_req.environ['manila.context'] = self.member_context 

59 self.replicas_req_admin = fakes.HTTPRequest.blank( 

60 '/share-replicas', version=self.api_version, 

61 experimental=True, use_admin_context=True) 

62 self.admin_context = self.replicas_req_admin.environ['manila.context'] 

63 self.mock_policy_check = self.mock_object(policy, 'check_policy') 

64 self.fake_share_network = { 

65 'id': 'fake network id', 

66 'project_id': 'fake project', 

67 'updated_at': None, 

68 'name': 'fake name', 

69 'description': 'fake description', 

70 'security_services': [], 

71 'share_network_subnets': [], 

72 'security_service_update_support': True, 

73 'status': 'active' 

74 } 

75 

76 def _get_context(self, role): 

77 return getattr(self, '%s_context' % role) 

78 

79 def _create_replica_get_req(self, **kwargs): 

80 if 'status' not in kwargs: 80 ↛ 82line 80 didn't jump to line 82 because the condition on line 80 was always true

81 kwargs['status'] = constants.STATUS_AVAILABLE 

82 if 'replica_state' not in kwargs: 

83 kwargs['replica_state'] = constants.REPLICA_STATE_IN_SYNC 

84 replica = db_utils.create_share_replica(**kwargs) 

85 path = '/v2/fake/share-replicas/%s/action' % replica['id'] 

86 microversion = kwargs.get('microversion', self.api_version) 

87 experimental = True 

88 if (api_version.APIVersionRequest(microversion) >= 

89 api_version.APIVersionRequest(GRADUATION_VERSION)): 

90 experimental = False 

91 req = fakes.HTTPRequest.blank(path, script_name=path, 

92 version=microversion, 

93 experimental=experimental) 

94 req.method = 'POST' 

95 req.headers['content-type'] = 'application/json' 

96 req.headers['X-Openstack-Manila-Api-Version'] = microversion 

97 req.headers['X-Openstack-Manila-Api-Experimental'] = True 

98 

99 return replica, req 

100 

101 def _get_fake_replica( 

102 self, summary=False, admin=False, 

103 microversion=share_replicas.MIN_SUPPORTED_API_VERSION, **values): 

104 replica = fake_share.fake_replica(**values) 

105 replica['updated_at'] = '2016-02-11T19:57:56.506805' 

106 expected_keys = {'id', 'share_id', 'status', 'replica_state'} 

107 expected_replica = {key: replica[key] for key in replica if key 

108 in expected_keys} 

109 

110 if not summary: 

111 expected_replica.update({ 

112 'availability_zone': None, 

113 'created_at': None, 

114 'share_network_id': replica['share_network_id'], 

115 'updated_at': replica['updated_at'], 

116 }) 

117 

118 if admin: 

119 expected_replica['share_server_id'] = replica['share_server_id'] 

120 expected_replica['host'] = replica['host'] 

121 

122 if (api_version.APIVersionRequest(microversion) >= 

123 api_version.APIVersionRequest(CAST_RULES_READONLY_VERSION) 

124 and admin): 

125 expected_replica['cast_rules_to_readonly'] = False 

126 

127 return replica, expected_replica 

128 

129 def _get_request(self, microversion, is_admin=False): 

130 experimental = (api_version.APIVersionRequest(microversion) <= 

131 api_version.APIVersionRequest(GRADUATION_VERSION)) 

132 req = fakes.HTTPRequest.blank( 

133 '/share-replicas', version=microversion, 

134 experimental=experimental, use_admin_context=is_admin) 

135 

136 return req 

137 

138 @ddt.data((False, PRE_GRADUATION_VERSION), (False, GRADUATION_VERSION)) 

139 @ddt.unpack 

140 def test_list_replicas_summary(self, is_admin, microversion): 

141 fake_replica, expected_replica = self._get_fake_replica( 

142 summary=True, admin=is_admin, microversion=microversion) 

143 self.mock_object(share_replicas.db, 'share_replicas_get_all', 

144 mock.Mock(return_value=[fake_replica])) 

145 

146 req = self._get_request(is_admin=is_admin, microversion=microversion) 

147 context = req.environ['manila.context'] 

148 res_dict = self.controller.index(req) 

149 

150 self.assertEqual([expected_replica], res_dict['share_replicas']) 

151 self.mock_policy_check.assert_called_once_with( 

152 context, self.resource_name, 'get_all') 

153 

154 def test_list_share_replicas_summary(self): 

155 fake_replica, expected_replica = self._get_fake_replica(summary=True) 

156 self.mock_object(share_replicas.db, 'share_replicas_get_all_by_share', 

157 mock.Mock(return_value=[fake_replica])) 

158 req = fakes.HTTPRequest.blank( 

159 '/share-replicas?share_id=FAKE_SHARE_ID', 

160 version=self.api_version, experimental=True) 

161 req_context = req.environ['manila.context'] 

162 

163 res_dict = self.controller.index(req) 

164 

165 self.assertEqual([expected_replica], res_dict['share_replicas']) 

166 self.mock_policy_check.assert_called_once_with( 

167 req_context, self.resource_name, 'get_all') 

168 

169 @ddt.data((True, PRE_GRADUATION_VERSION), (False, GRADUATION_VERSION)) 

170 @ddt.unpack 

171 def test_list_replicas_detail(self, is_admin, microversion): 

172 fake_replica, expected_replica = self._get_fake_replica( 

173 admin=is_admin, microversion=microversion) 

174 self.mock_object(share_replicas.db, 'share_replicas_get_all', 

175 mock.Mock(return_value=[fake_replica])) 

176 

177 req = self._get_request(is_admin=is_admin, microversion=microversion) 

178 req_context = req.environ['manila.context'] 

179 

180 res_dict = self.controller.detail(req) 

181 

182 self.assertEqual([expected_replica], res_dict['share_replicas']) 

183 self.mock_policy_check.assert_called_once_with( 

184 req_context, self.resource_name, 'get_all') 

185 

186 def test_list_replicas_detail_with_limit(self): 

187 fake_replica_1, expected_replica_1 = self._get_fake_replica() 

188 fake_replica_2, expected_replica_2 = self._get_fake_replica( 

189 id="fake_id2") 

190 self.mock_object( 

191 share_replicas.db, 'share_replicas_get_all', 

192 mock.Mock(return_value=[fake_replica_1, fake_replica_2])) 

193 req = fakes.HTTPRequest.blank('/share-replicas?limit=1', 

194 version=self.api_version, 

195 experimental=True) 

196 req_context = req.environ['manila.context'] 

197 

198 res_dict = self.controller.detail(req) 

199 

200 self.assertEqual(1, len(res_dict['share_replicas'])) 

201 self.assertEqual([expected_replica_1], res_dict['share_replicas']) 

202 self.mock_policy_check.assert_called_once_with( 

203 req_context, self.resource_name, 'get_all') 

204 

205 def test_list_replicas_detail_with_limit_and_offset(self): 

206 fake_replica_1, expected_replica_1 = self._get_fake_replica() 

207 fake_replica_2, expected_replica_2 = self._get_fake_replica( 

208 id="fake_id2") 

209 self.mock_object( 

210 share_replicas.db, 'share_replicas_get_all', 

211 mock.Mock(return_value=[fake_replica_1, fake_replica_2])) 

212 req = fakes.HTTPRequest.blank( 

213 '/share-replicas/detail?limit=1&offset=1', 

214 version=self.api_version, experimental=True) 

215 req_context = req.environ['manila.context'] 

216 

217 res_dict = self.controller.detail(req) 

218 

219 self.assertEqual(1, len(res_dict['share_replicas'])) 

220 self.assertEqual([expected_replica_2], res_dict['share_replicas']) 

221 self.mock_policy_check.assert_called_once_with( 

222 req_context, self.resource_name, 'get_all') 

223 

224 def test_list_share_replicas_detail_invalid_share(self): 

225 self.mock_object(share_replicas.db, 'share_replicas_get_all_by_share', 

226 mock.Mock(side_effect=exception.NotFound)) 

227 mock__view_builder_call = self.mock_object( 

228 share_replicas.replication_view.ReplicationViewBuilder, 

229 'detail_list') 

230 req = self.replicas_req 

231 req.GET['share_id'] = 'FAKE_SHARE_ID' 

232 

233 self.assertRaises(exc.HTTPNotFound, 

234 self.controller.detail, req) 

235 self.assertFalse(mock__view_builder_call.called) 

236 self.mock_policy_check.assert_called_once_with( 

237 self.member_context, self.resource_name, 'get_all') 

238 

239 @ddt.data(True, False) 

240 def test_list_share_replicas_detail(self, is_admin): 

241 fake_replica, expected_replica = self._get_fake_replica(admin=is_admin) 

242 self.mock_object(share_replicas.db, 'share_replicas_get_all_by_share', 

243 mock.Mock(return_value=[fake_replica])) 

244 req = fakes.HTTPRequest.blank( 

245 '/share-replicas?share_id=FAKE_SHARE_ID', 

246 version=self.api_version, experimental=True) 

247 req.environ['manila.context'] = ( 

248 self.member_context if not is_admin else self.admin_context) 

249 req_context = req.environ['manila.context'] 

250 

251 res_dict = self.controller.detail(req) 

252 

253 self.assertEqual([expected_replica], res_dict['share_replicas']) 

254 self.mock_policy_check.assert_called_once_with( 

255 req_context, self.resource_name, 'get_all') 

256 

257 def test_list_share_replicas_with_limit(self): 

258 fake_replica_1, expected_replica_1 = self._get_fake_replica() 

259 fake_replica_2, expected_replica_2 = self._get_fake_replica( 

260 id="fake_id2") 

261 self.mock_object( 

262 share_replicas.db, 'share_replicas_get_all_by_share', 

263 mock.Mock(return_value=[fake_replica_1, fake_replica_2])) 

264 req = fakes.HTTPRequest.blank( 

265 '/share-replicas?share_id=FAKE_SHARE_ID&limit=1', 

266 version=self.api_version, experimental=True) 

267 req_context = req.environ['manila.context'] 

268 

269 res_dict = self.controller.detail(req) 

270 

271 self.assertEqual(1, len(res_dict['share_replicas'])) 

272 self.assertEqual([expected_replica_1], res_dict['share_replicas']) 

273 self.mock_policy_check.assert_called_once_with( 

274 req_context, self.resource_name, 'get_all') 

275 

276 def test_list_share_replicas_with_limit_and_offset(self): 

277 fake_replica_1, expected_replica_1 = self._get_fake_replica() 

278 fake_replica_2, expected_replica_2 = self._get_fake_replica( 

279 id="fake_id2") 

280 self.mock_object( 

281 share_replicas.db, 'share_replicas_get_all_by_share', 

282 mock.Mock(return_value=[fake_replica_1, fake_replica_2])) 

283 req = fakes.HTTPRequest.blank( 

284 '/share-replicas?share_id=FAKE_SHARE_ID&limit=1&offset=1', 

285 version=self.api_version, experimental=True) 

286 req_context = req.environ['manila.context'] 

287 

288 res_dict = self.controller.detail(req) 

289 

290 self.assertEqual(1, len(res_dict['share_replicas'])) 

291 self.assertEqual([expected_replica_2], res_dict['share_replicas']) 

292 self.mock_policy_check.assert_called_once_with( 

293 req_context, self.resource_name, 'get_all') 

294 

295 @ddt.data((True, PRE_GRADUATION_VERSION), 

296 (False, GRADUATION_VERSION)) 

297 @ddt.unpack 

298 def test_show(self, is_admin, microversion): 

299 fake_replica, expected_replica = self._get_fake_replica( 

300 admin=is_admin, microversion=microversion) 

301 self.mock_object( 

302 share_replicas.db, 'share_replica_get', 

303 mock.Mock(return_value=fake_replica)) 

304 

305 req = self._get_request(microversion, is_admin) 

306 req_context = req.environ['manila.context'] 

307 

308 res_dict = self.controller.show(req, fake_replica.get('id')) 

309 

310 self.assertEqual(expected_replica, res_dict['share_replica']) 

311 self.mock_policy_check.assert_called_once_with( 

312 req_context, self.resource_name, 'show') 

313 

314 def test_show_no_replica(self): 

315 mock__view_builder_call = self.mock_object( 

316 share_replicas.replication_view.ReplicationViewBuilder, 'detail') 

317 fake_exception = exception.ShareReplicaNotFound( 

318 replica_id='FAKE_REPLICA_ID') 

319 self.mock_object(share_replicas.db, 'share_replica_get', mock.Mock( 

320 side_effect=fake_exception)) 

321 

322 self.assertRaises(exc.HTTPNotFound, 

323 self.controller.show, 

324 self.replicas_req, 

325 'FAKE_REPLICA_ID') 

326 self.assertFalse(mock__view_builder_call.called) 

327 self.mock_policy_check.assert_called_once_with( 

328 self.member_context, self.resource_name, 'show') 

329 

330 def test_create_invalid_body(self): 

331 body = {} 

332 mock__view_builder_call = self.mock_object( 

333 share_replicas.replication_view.ReplicationViewBuilder, 

334 'detail_list') 

335 

336 self.assertRaises(exc.HTTPUnprocessableEntity, 

337 self.controller.create, 

338 self.replicas_req, body) 

339 self.assertEqual(0, mock__view_builder_call.call_count) 

340 self.mock_policy_check.assert_called_once_with( 

341 self.member_context, self.resource_name, 'create') 

342 

343 def test_create_no_share_id(self): 

344 body = { 

345 'share_replica': { 

346 'share_id': None, 

347 'availability_zone': None, 

348 } 

349 } 

350 mock__view_builder_call = self.mock_object( 

351 share_replicas.replication_view.ReplicationViewBuilder, 

352 'detail_list') 

353 

354 self.assertRaises(exc.HTTPBadRequest, 

355 self.controller.create, 

356 self.replicas_req, body) 

357 self.assertFalse(mock__view_builder_call.called) 

358 self.mock_policy_check.assert_called_once_with( 

359 self.member_context, self.resource_name, 'create') 

360 

361 def test_create_invalid_share_id(self): 

362 body = { 

363 'share_replica': { 

364 'share_id': 'FAKE_SHAREID', 

365 'availability_zone': 'FAKE_AZ' 

366 } 

367 } 

368 mock__view_builder_call = self.mock_object( 

369 share_replicas.replication_view.ReplicationViewBuilder, 

370 'detail_list') 

371 self.mock_object(share_replicas.db, 'share_get', 

372 mock.Mock(side_effect=exception.NotFound)) 

373 

374 self.assertRaises(exc.HTTPNotFound, 

375 self.controller.create, 

376 self.replicas_req, body) 

377 self.assertFalse(mock__view_builder_call.called) 

378 self.mock_policy_check.assert_called_once_with( 

379 self.member_context, self.resource_name, 'create') 

380 

381 def test_create_has_been_soft_deleted(self): 

382 share_ref = fake_share.fake_share(is_soft_deleted=True) 

383 body = { 

384 'share_replica': { 

385 'share_id': 'FAKE_SHAREID', 

386 'availability_zone': 'FAKE_AZ' 

387 } 

388 } 

389 mock__view_builder_call = self.mock_object( 

390 share_replicas.replication_view.ReplicationViewBuilder, 

391 'detail_list') 

392 self.mock_object(share_replicas.db, 'share_get', 

393 mock.Mock(return_value=share_ref)) 

394 

395 self.assertRaises(exc.HTTPForbidden, 

396 self.controller.create, 

397 self.replicas_req, body) 

398 self.assertFalse(mock__view_builder_call.called) 

399 self.mock_policy_check.assert_called_once_with( 

400 self.member_context, self.resource_name, 'create') 

401 

402 def test_create_has_been_encrypted(self): 

403 share_ref = fake_share.fake_share(encryption_key_ref='fake') 

404 body = { 

405 'share_replica': { 

406 'share_id': 'FAKE_SHAREID', 

407 'availability_zone': 'FAKE_AZ' 

408 } 

409 } 

410 mock__view_builder_call = self.mock_object( 

411 share_replicas.replication_view.ReplicationViewBuilder, 

412 'detail_list') 

413 self.mock_object(share_replicas.db, 'share_get', 

414 mock.Mock(return_value=share_ref)) 

415 

416 self.assertRaises(exc.HTTPForbidden, 

417 self.controller.create, 

418 self.replicas_req, body) 

419 self.assertFalse(mock__view_builder_call.called) 

420 self.mock_policy_check.assert_called_once_with( 

421 self.member_context, self.resource_name, 'create') 

422 

423 def test_create_invalid_network_id(self): 

424 fake_replica, _ = self._get_fake_replica( 

425 replication_type='writable') 

426 req = self._get_request("2.72", False) 

427 req_context = req.environ['manila.context'] 

428 

429 body = { 

430 'share_replica': { 

431 'share_id': 'FAKE_SHAREID', 

432 'availability_zone': 'FAKE_AZ', 

433 'share_network_id': 'FAKE_NETID' 

434 } 

435 } 

436 mock__view_builder_call = self.mock_object( 

437 share_replicas.replication_view.ReplicationViewBuilder, 

438 'detail_list') 

439 self.mock_object(share_replicas.db, 'share_get', 

440 mock.Mock(return_value=fake_replica)) 

441 self.mock_object(share_replicas.db, 'share_network_get', 

442 mock.Mock(side_effect=exception.ShareNetworkNotFound( 

443 share_network_id='FAKE_NETID'))) 

444 

445 self.assertRaises(exc.HTTPBadRequest, 

446 self.controller.create, 

447 req, body) 

448 self.assertFalse(mock__view_builder_call.called) 

449 self.mock_policy_check.assert_called_once_with( 

450 req_context, self.resource_name, 'create') 

451 

452 @ddt.data(exception.AvailabilityZoneNotFound, 

453 exception.ReplicationException, exception.ShareBusyException) 

454 def test_create_exception_path(self, exception_type): 

455 fake_replica, _ = self._get_fake_replica( 

456 replication_type='writable') 

457 mock__view_builder_call = self.mock_object( 

458 share_replicas.replication_view.ReplicationViewBuilder, 

459 'detail_list') 

460 share_network = db_utils.create_share_network() 

461 body = { 

462 'share_replica': { 

463 'share_id': 'FAKE_SHAREID', 

464 'availability_zone': 'FAKE_AZ' 

465 } 

466 } 

467 exc_args = {'id': 'xyz', 'reason': 'abc'} 

468 self.mock_object(share_replicas.db, 'share_get', 

469 mock.Mock(return_value=fake_replica)) 

470 self.mock_object(share.API, 'create_share_replica', 

471 mock.Mock(side_effect=exception_type(**exc_args))) 

472 self.mock_object(share_replicas.db, 'share_network_get', 

473 mock.Mock(return_value=share_network)) 

474 self.mock_object(common, 'check_share_network_is_active', 

475 mock.Mock(return_value=True)) 

476 

477 self.assertRaises(exc.HTTPBadRequest, 

478 self.controller.create, 

479 self.replicas_req, body) 

480 self.assertFalse(mock__view_builder_call.called) 

481 self.mock_policy_check.assert_called_once_with( 

482 self.member_context, self.resource_name, 'create') 

483 share_replicas.db.share_network_get.assert_called_once_with( 

484 self.member_context, fake_replica['share_network_id']) 

485 common.check_share_network_is_active.assert_called_once_with( 

486 share_network) 

487 

488 @ddt.data((True, PRE_GRADUATION_VERSION), (False, GRADUATION_VERSION), 

489 (False, "2.72")) 

490 @ddt.unpack 

491 def test_create(self, is_admin, microversion): 

492 fake_replica, expected_replica = self._get_fake_replica( 

493 replication_type='writable', admin=is_admin, 

494 microversion=microversion) 

495 body = { 

496 'share_replica': { 

497 'share_id': 'FAKE_SHAREID', 

498 'availability_zone': 'FAKE_AZ' 

499 } 

500 } 

501 if self.is_microversion_ge(microversion, '2.72'): 

502 body["share_replica"].update({"share_network_id": 'FAKE_NETID'}) 

503 share_network = {'id': 'FAKE_NETID'} 

504 else: 

505 share_network = db_utils.create_share_network() 

506 

507 self.mock_object(share_replicas.db, 'share_get', 

508 mock.Mock(return_value=fake_replica)) 

509 self.mock_object(share.API, 'create_share_replica', 

510 mock.Mock(return_value=fake_replica)) 

511 self.mock_object(share_replicas.db, 

512 'share_replicas_get_available_active_replica', 

513 mock.Mock(return_value=[{'id': 'active1'}])) 

514 self.mock_object(share_replicas.db, 'share_network_get', 

515 mock.Mock(return_value=share_network)) 

516 self.mock_object(common, 'check_share_network_is_active', 

517 mock.Mock(return_value=True)) 

518 

519 req = self._get_request(microversion, is_admin) 

520 req_context = req.environ['manila.context'] 

521 

522 res_dict = self.controller.create(req, body) 

523 

524 self.assertEqual(expected_replica, res_dict['share_replica']) 

525 self.mock_policy_check.assert_called_once_with( 

526 req_context, self.resource_name, 'create') 

527 if self.is_microversion_ge(microversion, '2.72'): 

528 share_replicas.db.share_network_get.assert_called_once_with( 

529 req_context, 'FAKE_NETID') 

530 else: 

531 share_replicas.db.share_network_get.assert_called_once_with( 

532 req_context, fake_replica['share_network_id']) 

533 common.check_share_network_is_active.assert_called_once_with( 

534 share_network) 

535 

536 def test_delete_invalid_replica(self): 

537 fake_exception = exception.ShareReplicaNotFound( 

538 replica_id='FAKE_REPLICA_ID') 

539 self.mock_object(share_replicas.db, 'share_replica_get', 

540 mock.Mock(side_effect=fake_exception)) 

541 mock_delete_replica_call = self.mock_object( 

542 share.API, 'delete_share_replica') 

543 

544 self.assertRaises( 

545 exc.HTTPNotFound, self.controller.delete, 

546 self.replicas_req, 'FAKE_REPLICA_ID') 

547 self.assertFalse(mock_delete_replica_call.called) 

548 self.mock_policy_check.assert_called_once_with( 

549 self.member_context, self.resource_name, 'delete') 

550 

551 def test_delete_exception(self): 

552 fake_replica_1 = self._get_fake_replica( 

553 share_id='FAKE_SHARE_ID', 

554 replica_state=constants.REPLICA_STATE_ACTIVE)[0] 

555 fake_replica_2 = self._get_fake_replica( 

556 share_id='FAKE_SHARE_ID', 

557 replica_state=constants.REPLICA_STATE_ACTIVE)[0] 

558 exception_type = exception.ReplicationException(reason='xyz') 

559 self.mock_object(share_replicas.db, 'share_replica_get', 

560 mock.Mock(return_value=fake_replica_1)) 

561 self.mock_object( 

562 share_replicas.db, 'share_replicas_get_all_by_share', 

563 mock.Mock(return_value=[fake_replica_1, fake_replica_2])) 

564 self.mock_object(share.API, 'delete_share_replica', 

565 mock.Mock(side_effect=exception_type)) 

566 

567 self.assertRaises(exc.HTTPBadRequest, self.controller.delete, 

568 self.replicas_req, 'FAKE_REPLICA_ID') 

569 self.mock_policy_check.assert_called_once_with( 

570 self.member_context, self.resource_name, 'delete') 

571 

572 @ddt.data(PRE_GRADUATION_VERSION, GRADUATION_VERSION) 

573 def test_delete(self, microversion): 

574 fake_replica = self._get_fake_replica( 

575 share_id='FAKE_SHARE_ID', 

576 replica_state=constants.REPLICA_STATE_ACTIVE)[0] 

577 req = self._get_request(microversion=microversion) 

578 context = req.environ['manila.context'] 

579 self.mock_object(share_replicas.db, 'share_replica_get', 

580 mock.Mock(return_value=fake_replica)) 

581 self.mock_object(share.API, 'delete_share_replica') 

582 

583 resp = self.controller.delete( 

584 req, 'FAKE_REPLICA_ID') 

585 

586 self.assertEqual(202, resp.status_code) 

587 self.mock_policy_check.assert_called_once_with( 

588 context, self.resource_name, 'delete') 

589 

590 def test_promote_invalid_replica_id(self): 

591 body = {'promote': None} 

592 fake_exception = exception.ShareReplicaNotFound( 

593 replica_id='FAKE_REPLICA_ID') 

594 self.mock_object(share_replicas.db, 'share_replica_get', 

595 mock.Mock(side_effect=fake_exception)) 

596 

597 self.assertRaises(exc.HTTPNotFound, 

598 self.controller.promote, 

599 self.replicas_req, 

600 'FAKE_REPLICA_ID', body) 

601 self.mock_policy_check.assert_called_once_with( 

602 self.member_context, self.resource_name, 'promote') 

603 

604 def test_promote_already_active(self): 

605 body = {'promote': None} 

606 replica, expected_replica = self._get_fake_replica( 

607 replica_state=constants.REPLICA_STATE_ACTIVE) 

608 self.mock_object(share_replicas.db, 'share_replica_get', 

609 mock.Mock(return_value=replica)) 

610 self.mock_object(share_replicas.db, 'share_network_get', 

611 mock.Mock(return_value=self.fake_share_network)) 

612 mock_api_promote_replica_call = self.mock_object( 

613 share.API, 'promote_share_replica') 

614 

615 resp = self.controller.promote(self.replicas_req, replica['id'], body) 

616 

617 self.assertEqual(200, resp.status_code) 

618 self.assertFalse(mock_api_promote_replica_call.called) 

619 self.mock_policy_check.assert_called_once_with( 

620 self.member_context, self.resource_name, 'promote') 

621 

622 def test_promote_replication_exception(self): 

623 body = {'promote': None} 

624 replica, expected_replica = self._get_fake_replica( 

625 replica_state=constants.REPLICA_STATE_IN_SYNC) 

626 exception_type = exception.ReplicationException(reason='xyz') 

627 self.mock_object(share_replicas.db, 'share_replica_get', 

628 mock.Mock(return_value=replica)) 

629 self.mock_object(share_replicas.db, 'share_network_get', 

630 mock.Mock(return_value=self.fake_share_network)) 

631 mock_api_promote_replica_call = self.mock_object( 

632 share.API, 'promote_share_replica', 

633 mock.Mock(side_effect=exception_type)) 

634 

635 self.assertRaises(exc.HTTPBadRequest, 

636 self.controller.promote, 

637 self.replicas_req, 

638 replica['id'], 

639 body) 

640 self.assertTrue(mock_api_promote_replica_call.called) 

641 self.mock_policy_check.assert_called_once_with( 

642 self.member_context, self.resource_name, 'promote') 

643 

644 def test_promote_share_network_not_active(self): 

645 body = {'promote': None} 

646 replica, expected_replica = self._get_fake_replica( 

647 replica_state=constants.REPLICA_STATE_IN_SYNC) 

648 fake_share_network = copy.deepcopy(self.fake_share_network) 

649 fake_share_network['status'] = constants.STATUS_NETWORK_CHANGE 

650 self.mock_object(share_replicas.db, 'share_replica_get', 

651 mock.Mock(return_value=replica)) 

652 self.mock_object(share_replicas.db, 'share_network_get', 

653 mock.Mock(return_value=fake_share_network)) 

654 

655 self.assertRaises(exc.HTTPBadRequest, 

656 self.controller.promote, 

657 self.replicas_req, 

658 replica['id'], 

659 body) 

660 self.mock_policy_check.assert_called_once_with( 

661 self.member_context, self.resource_name, 'promote') 

662 

663 def test_promote_admin_required_exception(self): 

664 body = {'promote': None} 

665 replica, expected_replica = self._get_fake_replica( 

666 replica_state=constants.REPLICA_STATE_IN_SYNC) 

667 self.mock_object(share_replicas.db, 'share_replica_get', 

668 mock.Mock(return_value=replica)) 

669 self.mock_object(share_replicas.db, 'share_network_get', 

670 mock.Mock(return_value=self.fake_share_network)) 

671 mock_api_promote_replica_call = self.mock_object( 

672 share.API, 'promote_share_replica', 

673 mock.Mock(side_effect=exception.AdminRequired)) 

674 

675 self.assertRaises(exc.HTTPForbidden, 

676 self.controller.promote, 

677 self.replicas_req, 

678 replica['id'], 

679 body) 

680 self.assertTrue(mock_api_promote_replica_call.called) 

681 self.mock_policy_check.assert_called_once_with( 

682 self.member_context, self.resource_name, 'promote') 

683 

684 @ddt.data(PRE_GRADUATION_VERSION, GRADUATION_VERSION) 

685 def test_promote(self, microversion): 

686 body = {'promote': None} 

687 replica, expected_replica = self._get_fake_replica( 

688 replica_state=constants.REPLICA_STATE_IN_SYNC, 

689 microversion=microversion) 

690 self.mock_object(share_replicas.db, 'share_replica_get', 

691 mock.Mock(return_value=replica)) 

692 self.mock_object(share_replicas.db, 'share_network_get', 

693 mock.Mock(return_value=self.fake_share_network)) 

694 mock_api_promote_replica_call = self.mock_object( 

695 share.API, 'promote_share_replica', 

696 mock.Mock(return_value=replica)) 

697 req = self._get_request(microversion=microversion) 

698 context = req.environ['manila.context'] 

699 resp = self.controller.promote(req, replica['id'], body) 

700 

701 self.assertEqual(expected_replica, resp['share_replica']) 

702 self.assertTrue(mock_api_promote_replica_call.called) 

703 self.mock_policy_check.assert_called_once_with( 

704 context, self.resource_name, 'promote') 

705 

706 @ddt.data(('2.74', None), 

707 (PROMOTE_QUIESCE_WAIT_VERSION, None), 

708 (PROMOTE_QUIESCE_WAIT_VERSION, 10), 

709 (PROMOTE_QUIESCE_WAIT_VERSION, 'foobar'), 

710 ) 

711 @ddt.unpack 

712 def test_promote_quiesce_wait_time(self, microversion, time): 

713 body = {'promote': {'quiesce_wait_time': time}} 

714 replica, expected_replica = self._get_fake_replica( 

715 replica_state=constants.REPLICA_STATE_IN_SYNC, 

716 microversion=microversion) 

717 self.mock_object(share_replicas.db, 'share_replica_get', 

718 mock.Mock(return_value=replica))